Change PlusMinus to the correct MinusPlus, add documentation

6 files changed, 56 insertions, 55 deletions

diff --git a/src/features/line_numbers.rs b/src/features/line_numbers.rs
index f1ad146f..ff0a58ef 100644
--- a/src/features/line_numbers.rs
+++ b/src/features/line_numbers.rs
@@ -9,7 +9,7 @@ use crate::features::hyperlinks;
 use crate::features::side_by_side::{Left, PanelSide, Right};
 use crate::features::OptionValueFunction;
 use crate::format;
-use crate::plusminus::*;
+use crate::minusplus::*;
 use crate::style::Style;
 
 pub fn make_feature() -> Vec<(String, OptionValueFunction)> {
@@ -141,24 +141,24 @@ lazy_static! {
 
 #[derive(Default, Debug)]
 pub struct LineNumbersData<'a> {
-    pub format_data: PlusMinus<format::FormatStringData<'a>>,
-    pub line_number: PlusMinus<usize>,
+    pub format_data: MinusPlus<format::FormatStringData<'a>>,
+    pub line_number: MinusPlus<usize>,
     pub hunk_max_line_number_width: usize,
     pub plus_file: String,
 }
 
-pub type SideBySideLineWidth = PlusMinus<usize>;
+pub type SideBySideLineWidth = MinusPlus<usize>;
 
 // Although it's probably unusual, a single format string can contain multiple placeholders. E.g.
 // line-numbers-right-format = "{nm} {np}|"
 impl<'a> LineNumbersData<'a> {
     pub fn from_format_strings(left_format: &'a str, right_format: &'a str) -> LineNumbersData<'a> {
         Self {
-            format_data: PlusMinus::new(
+            format_data: MinusPlus::new(
                 format::parse_line_number_format(left_format, &*LINE_NUMBERS_PLACEHOLDER_REGEX),
                 format::parse_line_number_format(right_format, &*LINE_NUMBERS_PLACEHOLDER_REGEX),
             ),
-            line_number: PlusMinus::new(0, 0),
+            line_number: MinusPlus::new(0, 0),
             hunk_max_line_number_width: 0,
             plus_file: "".to_string(),
         }
@@ -169,7 +169,7 @@ impl<'a> LineNumbersData<'a> {
         // Typically, line_numbers has length 2: an entry for the minus file, and one for the plus
         // file. In the case of merge commits, it may be longer.
         self.line_number =
-            PlusMinus::new(line_numbers[0].0, line_numbers[line_numbers.len() - 1].0);
+            MinusPlus::new(line_numbers[0].0, line_numbers[line_numbers.len() - 1].0);
         let hunk_max_line_number = line_numbers.iter().map(|(n, d)| n + d).max().unwrap();
         self.hunk_max_line_number_width =
             1 + (hunk_max_line_number as f64).log10().floor() as usize;
@@ -196,7 +196,7 @@ impl<'a> LineNumbersData<'a> {
                 })
                 .unwrap_or(0)
         };
-        PlusMinus::new(
+        MinusPlus::new(
             format_data_width(&self.format_data[Left]),
             format_data_width(&self.format_data[Right]),
         )
@@ -452,23 +452,23 @@ pub mod tests {
     fn test_line_numbers_data() {
         let mut data = LineNumbersData::from_format_strings("", "");
         data.initialize_hunk(&[(10, 11), (10000, 100001)], "a".into());
-        assert_eq!(data.formatted_width(), PlusMinus::new(0, 0));
+        assert_eq!(data.formatted_width(), MinusPlus::new(0, 0));
 
         let mut data = LineNumbersData::from_format_strings("│", "│+│");
         data.initialize_hunk(&[(10, 11), (10000, 100001)], "a".into());
-        assert_eq!(data.formatted_width(), PlusMinus::new(1, 3));
+        assert_eq!(data.formatted_width(), MinusPlus::new(1, 3));
 
         let mut data = LineNumbersData::from_format_strings("│{nm:^3}│", "│{np:^3}│");
         data.initialize_hunk(&[(10, 11), (10000, 100001)], "a".into());
-        assert_eq!(data.formatted_width(), PlusMinus::new(8, 8));
+        assert_eq!(data.formatted_width(), MinusPlus::new(8, 8));
 
         let mut data = LineNumbersData::from_format_strings("│{nm:^3}│ │{np:<12}│ │{nm}│", "");
         data.initialize_hunk(&[(10, 11), (10000, 100001)], "a".into());
-        assert_eq!(data.formatted_width(), PlusMinus::new(32, 0));
+        assert_eq!(data.formatted_width(), MinusPlus::new(32, 0));
 
         let mut data = LineNumbersData::from_format_strings("│{np:^3}│ │{nm:<12}│ │{np}│", "");
         data.initialize_hunk(&[(10, 11), (10000, 100001)], "a".into());
-        assert_eq!(data.formatted_width(), PlusMinus::new(32, 0));
+        assert_eq!(data.formatted_width(), MinusPlus::new(32, 0));
     }
 
     fn _get_capture<'a>(i: usize, j: usize, caps: &'a Vec<Captures>) -> &'a str {
diff --git a/src/features/side_by_side.rs b/src/features/side_by_side.rs
index 42924623..b87207d8 100644
--- a/src/features/side_by_side.rs
+++ b/src/features/side_by_side.rs
@@ -8,9 +8,9 @@ use crate::config::Config;
 use crate::delta::State;
 use crate::features::line_numbers;
 use crate::features::OptionValueFunction;
+use crate::minusplus::*;
 use crate::paint::Painter;
 use crate::paint::{BgFillMethod, BgShouldFill};
-use crate::plusminus::*;
 use crate::style::Style;
 use crate::wrapping::wrap_zero_block;
 
@@ -32,9 +32,9 @@ pub fn make_feature() -> Vec<(String, OptionValueFunction)> {
 
 // Aliases for Minus/Plus because Left/Right and PanelSide makes
 // more sense in a side-by-side context.
-pub use crate::plusminus::PlusMinusIndex as PanelSide;
-pub use PlusMinusIndex::Minus as Left;
-pub use PlusMinusIndex::Plus as Right;
+pub use crate::minusplus::MinusPlusIndex as PanelSide;
+pub use MinusPlusIndex::Minus as Left;
+pub use MinusPlusIndex::Plus as Right;
 
 #[derive(Debug)]
 pub struct Panel {
@@ -42,11 +42,12 @@ pub struct Panel {
     pub offset: usize,
 }
 
-type LeftRight<T> = PlusMinus<T>;
+type LeftRight<T> = MinusPlus<T>;
 
 pub type SideBySideData = LeftRight<Panel>;
 
 impl SideBySideData {
+    /// Create a [`LeftRight<Panel>`](LeftRight<Panel>) named [`SideBySideData`].
     pub fn new_sbs(decorations_width: &cli::Width, available_terminal_width: &usize) -> Self {
         let panel_width = match decorations_width {
             cli::Width::Fixed(w) => w / 2,
diff --git a/src/main.rs b/src/main.rs
index 21b6e749..22f0c7aa 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -17,10 +17,10 @@ mod features;
 mod format;
 mod git_config;
 mod handlers;
+mod minusplus;
 mod options;
 mod paint;
 mod parse_style;
-mod plusminus;
 mod style;
 mod wrapping;
 
diff --git a/src/plusminus.rs b/src/minusplus.rs
index 0cdeaea9..e37c801c 100644
--- a/src/plusminus.rs
+++ b/src/minusplus.rs
@@ -1,24 +1,24 @@
 use std::ops::{Index, IndexMut};
 
-// Struct to represent data related to removed/minus and added/plus lines
-// which can be indexed with PlusMinusIndex::{Minus, Plus}.
+/// Represent data related to removed/minus and added/plus lines which
+/// can be indexed with [`MinusPlusIndex::{Plus`](MinusPlusIndex::Plus)`,`[`Minus}`](MinusPlusIndex::Minus).
 #[derive(Debug, PartialEq, Eq)]
-pub struct PlusMinus<T> {
+pub struct MinusPlus<T> {
     pub minus: T,
     pub plus: T,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum PlusMinusIndex {
+pub enum MinusPlusIndex {
     Minus,
     Plus,
 }
 
-pub use PlusMinusIndex::*;
+pub use MinusPlusIndex::*;
 
-impl<T> Index<PlusMinusIndex> for PlusMinus<T> {
+impl<T> Index<MinusPlusIndex> for MinusPlus<T> {
     type Output = T;
-    fn index(&self, side: PlusMinusIndex) -> &Self::Output {
+    fn index(&self, side: MinusPlusIndex) -> &Self::Output {
         match side {
             Minus => &self.minus,
             Plus => &self.plus,
@@ -26,8 +26,8 @@ impl<T> Index<PlusMinusIndex> for PlusMinus<T> {
     }
 }
 
-impl<T> IndexMut<PlusMinusIndex> for PlusMinus<T> {
-    fn index_mut(&mut self, side: PlusMinusIndex) -> &mut Self::Output {
+impl<T> IndexMut<MinusPlusIndex> for MinusPlus<T> {
+    fn index_mut(&mut self, side: MinusPlusIndex) -> &mut Self::Output {
         match side {
             Minus => &mut self.minus,
             Plus => &mut self.plus,
@@ -35,13 +35,13 @@ impl<T> IndexMut<PlusMinusIndex> for PlusMinus<T> {
     }
 }
 
-impl<T> PlusMinus<T> {
+impl<T> MinusPlus<T> {
     pub fn new(minus: T, plus: T) -> Self {
-        PlusMinus { minus, plus }
+        MinusPlus { minus, plus }
     }
 }
 
-impl<T: Default> Default for PlusMinus<T> {
+impl<T: Default> Default for MinusPlus<T> {
     fn default() -> Self {
         Self {
             minus: T::default(),
diff --git a/src/paint.rs b/src/paint.rs
index 929b9643..9b7e7fbe 100644
--- a/src/paint.rs
+++ b/src/paint.rs
@@ -12,10 +12,10 @@ use crate::delta::State;
 use crate::edits;
 use crate::features::line_numbers;
 use crate::features::side_by_side::{self, available_line_width, LineSegments, PanelSide};
+use crate::minusplus::*;
 use crate::paint::superimpose_style_sections::superimpose_style_sections;
-use crate::plusminus::*;
 use crate::style::Style;
-use crate::wrapping::wrap_plusminus_block;
+use crate::wrapping::wrap_minusplus_block;
 
 pub struct Painter<'a> {
     pub minus_lines: Vec<(String, State)>,
@@ -163,16 +163,16 @@ impl<'a> Painter<'a> {
             Self::get_diff_style_sections(&self.minus_lines, &self.plus_lines, self.config);
 
         if self.config.side_by_side {
-            let syntax_left_right = PlusMinus::new(
+            let syntax_left_right = MinusPlus::new(
                 minus_line_syntax_style_sections,
                 plus_line_syntax_style_sections,
             );
-            let diff_left_right = PlusMinus::new(
+            let diff_left_right = MinusPlus::new(
                 minus_line_diff_style_sections,
                 plus_line_diff_style_sections,
             );
 
-            let states_left_right = PlusMinus::new(
+            let states_left_right = MinusPlus::new(
                 self.minus_lines
                     .iter()
                     .map(|(_, state)| state.clone())
@@ -183,7 +183,7 @@ impl<'a> Painter<'a> {
                     .collect(),
             );
 
-            let bg_fill_left_right = PlusMinus::new(
+            let bg_fill_left_right = MinusPlus::new(
                 // Using an ANSI sequence to fill the left panel would not work.
                 BgShouldFill::With(BgFillMethod::Spaces),
                 // Use what is configured for the right side.
@@ -196,11 +196,11 @@ impl<'a> Painter<'a> {
             // long for later re-use.
             let (should_wrap, line_width, long_lines) = {
                 if self.config.wrap_config.max_lines == 1 {
-                    (false, PlusMinus::default(), PlusMinus::default())
+                    (false, MinusPlus::default(), MinusPlus::default())
                 } else {
                     let line_width = available_line_width(self.config, &self.line_numbers_data);
 
-                    let lines = PlusMinus::new(&self.minus_lines, &self.plus_lines);
+                    let lines = MinusPlus::new(&self.minus_lines, &self.plus_lines);
 
                     let (should_wrap, long_lines) =
                         side_by_side::has_long_lines(&lines, &line_width);
@@ -211,7 +211,7 @@ impl<'a> Painter<'a> {
 
             let (line_alignment, line_states, syntax_left_right, diff_left_right) = if should_wrap {
                 // Calculated for syntect::highlighting::style::Style and delta::Style
-                wrap_plusminus_block(
+                wrap_minusplus_block(
                     self.config,
                     syntax_left_right,
                     diff_left_right,
diff --git a/src/wrapping.rs b/src/wrapping.rs
index 9c4489eb..8ff1f8d5 100644
--- a/src/wrapping.rs
+++ b/src/wrapping.rs
@@ -11,7 +11,7 @@ use crate::features::side_by_side::available_line_width;
 use crate::features::side_by_side::line_is_too_long;
 use crate::features::side_by_side::LineSegments;
 use crate::features::side_by_side::{Left, Right};
-use crate::plusminus::*;
+use crate::minusplus::*;
 use crate::style::Style;
 
 /// See [`wrap_line`] for documentation.
@@ -288,31 +288,31 @@ where
 /// a specific line was longer than `line_width`. Return an adjusted `alignment`
 /// with regard to the added wrapped lines.
 #[allow(clippy::comparison_chain, clippy::type_complexity)]
-pub fn wrap_plusminus_block<'c: 'a, 'a>(
+pub fn wrap_minusplus_block<'c: 'a, 'a>(
     config: &'c Config,
-    syntax: PlusMinus<Vec<LineSegments<'a, SyntectStyle>>>,
-    diff: PlusMinus<Vec<LineSegments<'a, Style>>>,
+    syntax: MinusPlus<Vec<LineSegments<'a, SyntectStyle>>>,
+    diff: MinusPlus<Vec<LineSegments<'a, Style>>>,
     alignment: &[(Option<usize>, Option<usize>)],
     line_width: &SideBySideLineWidth,
-    wrapinfo: &'a PlusMinus<Vec<bool>>,
+    wrapinfo: &'a MinusPlus<Vec<bool>>,
 ) -> (
     Vec<(Option<usize>, Option<usize>)>,
-    PlusMinus<Vec<State>>,
-    PlusMinus<Vec<LineSegments<'a, SyntectStyle>>>,
-    PlusMinus<Vec<LineSegments<'a, Style>>>,
+    MinusPlus<Vec<State>>,
+    MinusPlus<Vec<LineSegments<'a, SyntectStyle>>>,
+    MinusPlus<Vec<LineSegments<'a, Style>>>,
 ) {
     let mut new_alignment = Vec::new();
-    let mut new_states = PlusMinus::<Vec<State>>::default();
-    let mut new_wrapped_syntax = PlusMinus::default();
-    let mut new_wrapped_diff = PlusMinus::default();
+    let mut new_states = MinusPlus::<Vec<State>>::default();
+    let mut new_wrapped_syntax = MinusPlus::default();
+    let mut new_wrapped_diff = MinusPlus::default();
 
     // Turn all these into pairs of iterators so they can be advanced according
     // to the alignment and independently.
-    let mut syntax = PlusMinus::new(syntax.minus.into_iter(), syntax.plus.into_iter());
-    let mut diff = PlusMinus::new(diff.minus.into_iter(), diff.plus.into_iter());
-    let mut wrapinfo = PlusMinus::new(wrapinfo[Left].iter(), wrapinfo[Right].iter());
+    let mut syntax = MinusPlus::new(syntax.minus.into_iter(), syntax.plus.into_iter());
+    let mut diff = MinusPlus::new(diff.minus.into_iter(), diff.plus.into_iter());
+    let mut wrapinfo = MinusPlus::new(wrapinfo[Left].iter(), wrapinfo[Right].iter());
 
-    let fill_style = PlusMinus::new(&config.minus_style, &config.plus_style);
+    let fill_style = MinusPlus::new(&config.minus_style, &config.plus_style);
 
     // Internal helper function to perform wrapping for both the syntax and the
     // diff highlighting (SyntectStyle and Style).