aboutsummaryrefslogtreecommitdiff
path: root/helix-core/src
diff options
context:
space:
mode:
Diffstat (limited to 'helix-core/src')
-rw-r--r--helix-core/src/indent.rs176
1 files changed, 126 insertions, 50 deletions
diff --git a/helix-core/src/indent.rs b/helix-core/src/indent.rs
index 8dfc1f1e..dfb33939 100644
--- a/helix-core/src/indent.rs
+++ b/helix-core/src/indent.rs
@@ -210,6 +210,46 @@ fn whitespace_with_same_width(text: RopeSlice) -> String {
s
}
+fn add_indent_level(
+ mut base_indent: String,
+ added_indent_level: isize,
+ indent_style: &IndentStyle,
+ tab_width: usize,
+) -> String {
+ if added_indent_level >= 0 {
+ // Adding a non-negative indent is easy, we can simply append the indent string
+ base_indent.push_str(&indent_style.as_str().repeat(added_indent_level as usize));
+ base_indent
+ } else {
+ // In this case, we want to return a prefix of `base_indent`.
+ // Since the width of a tab depends on its offset, we cannot simply iterate over
+ // the chars of `base_indent` in reverse until we have the desired indent reduction,
+ // instead we iterate over them twice in forward direction.
+ let mut base_indent_width: usize = 0;
+ for c in base_indent.chars() {
+ base_indent_width += match c {
+ '\t' => tab_width_at(base_indent_width, tab_width as u16),
+ // This is only true since `base_indent` consists only of tabs and spaces
+ _ => 1,
+ };
+ }
+ let target_indent_width = base_indent_width
+ .saturating_sub((-added_indent_level) as usize * indent_style.indent_width(tab_width));
+ let mut reduced_indent_width = 0;
+ for (i, c) in base_indent.char_indices() {
+ if reduced_indent_width >= target_indent_width {
+ base_indent.truncate(i);
+ return base_indent;
+ }
+ reduced_indent_width += match c {
+ '\t' => tab_width_at(base_indent_width, tab_width as u16),
+ _ => 1,
+ };
+ }
+ base_indent
+ }
+}
+
/// Computes for node and all ancestors whether they are the first node on their line.
/// The first entry in the return value represents the root node, the last one the node itself
fn get_first_in_line(mut node: Node, new_line_byte_pos: Option<usize>) -> Vec<bool> {
@@ -334,59 +374,25 @@ impl<'a> Indentation<'a> {
// we can simply take `other_leading_whitespace` and add some indent / outdent to it (in the second
// case, the alignment should already be accounted for in `other_leading_whitespace`).
let indent_diff = self.net_indent() - other_computed_indent.net_indent();
- if indent_diff >= 0 {
- let mut indent = other_leading_whitespace.to_string();
- indent.push_str(&indent_style.as_str().repeat(indent_diff as usize));
- Some(indent)
- } else {
- // It's not entirely clear how to subtract a given indent level from the other line if its indentation is
- // complex (e.g. a weird alignment or a mixture of tabs and spaces). Therefore, we only consider the indent level
- // of `baseline_leading_whitespace`, add `indent_diff` to it and convert this indent level back to a string. If we ever encounter
- // cases where some other behavior is expected, the behavior for strings that don't exactly correspond to some indent
- // level could be re-evaluated.
- let actual_baseline_indent_level = indent_level_for_line(
- other_leading_whitespace,
- tab_width,
- indent_style.indent_width(tab_width),
- );
- let total_indent = actual_baseline_indent_level as isize + indent_diff;
- if total_indent < 0 {
- log::warn!(
- "Computed negative indent during a relative indent computation (actual baseline indent: {}, computed baseline indent: {}, computed line indent: {})",
- actual_baseline_indent_level,
- other_computed_indent.net_indent(),
- self.net_indent(),
- );
- Some(String::new())
- } else {
- Some(indent_style.as_str().repeat(total_indent as usize))
- }
- }
- } else if self.align.is_some() {
- Some(self.to_string(indent_style))
+ Some(add_indent_level(
+ String::from(other_leading_whitespace),
+ indent_diff,
+ indent_style,
+ tab_width,
+ ))
} else {
- // If the other line has some alignment and `self` does not, there is no reasonable way to take
- // into account `other_leading_whitespace`.
+ // If the alignment of both lines is different, we cannot compare their indentation in any meaningful way
None
}
}
- pub fn to_string(&self, indent_style: &IndentStyle) -> String {
- let indent = self.indent_always + self.indent;
- let outdent = self.outdent_always + self.outdent;
-
- let indent_level = if indent >= outdent {
- indent - outdent
- } else {
- log::warn!("Encountered more outdent than indent nodes while calculating indentation: {} outdent, {} indent", self.outdent, self.indent);
- 0
- };
- let mut indent_string = if let Some(align) = self.align {
- whitespace_with_same_width(align)
- } else {
- String::new()
- };
- indent_string.push_str(&indent_style.as_str().repeat(indent_level));
- indent_string
+ pub fn to_string(&self, indent_style: &IndentStyle, tab_width: usize) -> String {
+ add_indent_level(
+ self.align
+ .map_or_else(String::new, whitespace_with_same_width),
+ self.net_indent(),
+ indent_style,
+ tab_width,
+ )
}
}
@@ -992,7 +998,7 @@ pub fn indent_for_newline(
break;
}
}
- return indent.to_string(indent_style);
+ return indent.to_string(indent_style, tab_width);
};
}
// Fallback in case we either don't have indent queries or they failed for some reason
@@ -1188,4 +1194,74 @@ mod test {
)
);
}
+
+ #[test]
+ fn test_relative_indent() {
+ let indent_style = IndentStyle::Spaces(4);
+ let tab_width: usize = 4;
+ let no_align = [
+ Indentation::default(),
+ Indentation {
+ indent: 1,
+ ..Default::default()
+ },
+ Indentation {
+ indent: 5,
+ outdent: 1,
+ ..Default::default()
+ },
+ ];
+ let align = no_align.clone().map(|indent| Indentation {
+ align: Some(RopeSlice::from("12345")),
+ ..indent
+ });
+ let different_align = Indentation {
+ align: Some(RopeSlice::from("123456")),
+ ..Default::default()
+ };
+
+ // Check that relative and absolute indentation computation are the same when the line we compare to is
+ // indented as we expect.
+ let check_consistency = |indent: &Indentation, other: &Indentation| {
+ assert_eq!(
+ indent.relative_indent(
+ other,
+ RopeSlice::from(other.to_string(&indent_style, tab_width).as_str()),
+ &indent_style,
+ tab_width
+ ),
+ Some(indent.to_string(&indent_style, tab_width))
+ );
+ };
+ for a in &no_align {
+ for b in &no_align {
+ check_consistency(a, b);
+ }
+ }
+ for a in &align {
+ for b in &align {
+ check_consistency(a, b);
+ }
+ }
+
+ // Relative indent computation makes no sense if the alignment differs
+ assert_eq!(
+ align[0].relative_indent(
+ &no_align[0],
+ RopeSlice::from(" "),
+ &indent_style,
+ tab_width
+ ),
+ None
+ );
+ assert_eq!(
+ align[0].relative_indent(
+ &different_align,
+ RopeSlice::from(" "),
+ &indent_style,
+ tab_width
+ ),
+ None
+ );
+ }
}