Change PlusMinus to the correct MinusPlus, add documentation

src/features/line_numbers.rs

@@ -10,7 +10,7 @@ use crate::features::side_by_side::PanelSide;
 use crate::features::side_by_side::PanelSide::{Left, 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)> {
@@ -142,24 +142,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(),
         }
@@ -170,7 +170,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;
@@ -197,7 +197,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]),
         )
@@ -453,23 +453,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 {

src/features/side_by_side.rs

@@ -11,9 +11,9 @@ use crate::delta::State;
 use crate::features::line_numbers;
 use crate::features::side_by_side_wrap;
 use crate::features::OptionValueFunction;
+use crate::minusplus::*;
 use crate::paint::Painter;
 use crate::paint::{BgFillMethod, BgShouldFill};
-use crate::plusminus::*;
 use crate::style::Style;
 
 pub fn make_feature() -> Vec<(String, OptionValueFunction)> {
@@ -35,8 +35,8 @@ pub struct Panel {
     pub offset: usize,
 }
 
-// Same as plusminus::PlusMinusIndex but with Left/Right instead
-// of Minus/Plus enum names. Only used in a side-by-side context.
+/// Same as [`plusminus::MinusPlusIndex`](crate::minusplus::MinusPlusIndex) but with Left/Right instead
+/// of Plus/Minus enum names. Only used in a side-by-side context.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PanelSide {
     Left,
@@ -45,7 +45,7 @@ pub enum PanelSide {
 
 use PanelSide::*;
 
-impl<T> Index<PanelSide> for PlusMinus<T> {
+impl<T> Index<PanelSide> for MinusPlus<T> {
     type Output = T;
     fn index(&self, side: PanelSide) -> &Self::Output {
         match side {
@@ -55,7 +55,7 @@ impl<T> Index<PanelSide> for PlusMinus<T> {
     }
 }
 
-impl<T> IndexMut<PanelSide> for PlusMinus<T> {
+impl<T> IndexMut<PanelSide> for MinusPlus<T> {
     fn index_mut(&mut self, side: PanelSide) -> &mut Self::Output {
         match side {
             PanelSide::Left => &mut self.minus,
@@ -64,11 +64,12 @@ impl<T> IndexMut<PanelSide> for PlusMinus<T> {
     }
 }
 
-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,

src/features/side_by_side_wrap.rs

@@ -10,7 +10,7 @@ use crate::features::line_numbers::SideBySideLineWidth;
 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::PanelSide::*;
-use crate::plusminus::*;
+use crate::minusplus::*;
 use crate::style::Style;
 
 /// See [`wrap_line`] for documentation.
@@ -280,31 +280,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<Vec<(SyntectStyle, &'a str)>>>,
-    diff: PlusMinus<Vec<Vec<(Style, &'a str)>>>,
+    syntax: MinusPlus<Vec<Vec<(SyntectStyle, &'a str)>>>,
+    diff: MinusPlus<Vec<Vec<(Style, &'a str)>>>,
     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<Vec<(SyntectStyle, &'a str)>>>,
-    PlusMinus<Vec<Vec<(Style, &'a str)>>>,
+    MinusPlus<Vec<State>>,
+    MinusPlus<Vec<Vec<(SyntectStyle, &'a str)>>>,
+    MinusPlus<Vec<Vec<(Style, &'a str)>>>,
 ) {
     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).

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 subcommands;

src/plusminus.rs → src/minusplus.rs

@@ -1,47 +1,47 @@
 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,
         }
     }
 }
 
-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,
         }
     }
 }
 
-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(),

src/paint.rs

@@ -15,8 +15,8 @@ use crate::features::side_by_side;
 use crate::features::side_by_side::available_line_width;
 use crate::features::side_by_side::PanelSide;
 use crate::features::side_by_side_wrap;
+use crate::minusplus::*;
 use crate::paint::superimpose_style_sections::superimpose_style_sections;
-use crate::plusminus::*;
 use crate::style::Style;
 
 pub struct Painter<'a> {
@@ -165,16 +165,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())
@@ -185,7 +185,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.
@@ -198,11 +198,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);
@@ -213,7 +213,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
-                side_by_side_wrap::wrap_plusminus_block(
+                side_by_side_wrap::wrap_minusplus_block(
                     self.config,
                     syntax_left_right,
                     diff_left_right,