git.iko.soy/helix
on master help sign in
Move indent-style code into `helix_core::indent`.
f88d4c1Nathan Vegdahl
helix-core/src/indent.rs+168−1
compare with master
unifiedsplit
@@ -1,10 +1,177 @@
1use crate::{
1use crate::{
2+ chars::{char_is_line_ending, char_is_whitespace},
2 find_first_non_whitespace_char,
3 find_first_non_whitespace_char,
3 syntax::{IndentQuery, LanguageConfiguration, Syntax},
4 syntax::{IndentQuery, LanguageConfiguration, Syntax},
4 tree_sitter::Node,
5 tree_sitter::Node,
5− RopeSlice,
6+ Rope, RopeSlice,
6};
7};
7
8
9+/// Enum representing indentation style.
10+///
11+/// Only values 1-8 are valid for the `Spaces` variant.
12+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
13+pub enum IndentStyle {
14+ Tabs,
15+ Spaces(u8),
16+}
17+
18+impl IndentStyle {
19+ /// Creates an `IndentStyle` from an indentation string.
20+ ///
21+ /// For example, passing `" "` (four spaces) will create `IndentStyle::Spaces(4)`.
22+ #[allow(clippy::should_implement_trait)]
23+ #[inline]
24+ pub fn from_str(indent: &str) -> Self {
25+ // XXX: do we care about validating the input more than this? Probably not...?
26+ debug_assert!(!indent.is_empty() && indent.len() <= 8);
27+
28+ if indent.starts_with(' ') {
29+ IndentStyle::Spaces(indent.len() as u8)
30+ } else {
31+ IndentStyle::Tabs
32+ }
33+ }
34+
35+ #[inline]
36+ pub fn as_str(&self) -> &'static str {
37+ match *self {
38+ IndentStyle::Tabs => "\t",
39+ IndentStyle::Spaces(1) => " ",
40+ IndentStyle::Spaces(2) => " ",
41+ IndentStyle::Spaces(3) => " ",
42+ IndentStyle::Spaces(4) => " ",
43+ IndentStyle::Spaces(5) => " ",
44+ IndentStyle::Spaces(6) => " ",
45+ IndentStyle::Spaces(7) => " ",
46+ IndentStyle::Spaces(8) => " ",
47+
48+ // Unsupported indentation style. This should never happen,
49+ // but just in case fall back to two spaces.
50+ IndentStyle::Spaces(n) => {
51+ debug_assert!(n > 0 && n <= 8); // Always triggers. `debug_panic!()` wanted.
52+ " "
53+ }
54+ }
55+ }
56+}
57+
58+/// Attempts to detect the indentation style used in a document.
59+///
60+/// Returns the indentation style if the auto-detect confidence is
61+/// reasonably high, otherwise returns `None`.
62+pub fn auto_detect_indent_style(document_text: &Rope) -> Option<IndentStyle> {
63+ // Build a histogram of the indentation *increases* between
64+ // subsequent lines, ignoring lines that are all whitespace.
65+ //
66+ // Index 0 is for tabs, the rest are 1-8 spaces.
67+ let histogram: [usize; 9] = {
68+ let mut histogram = [0; 9];
69+ let mut prev_line_is_tabs = false;
70+ let mut prev_line_leading_count = 0usize;
71+
72+ // Loop through the lines, checking for and recording indentation
73+ // increases as we go.
74+ 'outer: for line in document_text.lines().take(1000) {
75+ let mut c_iter = line.chars();
76+
77+ // Is first character a tab or space?
78+ let is_tabs = match c_iter.next() {
79+ Some('\t') => true,
80+ Some(' ') => false,
81+
82+ // Ignore blank lines.
83+ Some(c) if char_is_line_ending(c) => continue,
84+
85+ _ => {
86+ prev_line_is_tabs = false;
87+ prev_line_leading_count = 0;
88+ continue;
89+ }
90+ };
91+
92+ // Count the line's total leading tab/space characters.
93+ let mut leading_count = 1;
94+ let mut count_is_done = false;
95+ for c in c_iter {
96+ match c {
97+ '\t' if is_tabs && !count_is_done => leading_count += 1,
98+ ' ' if !is_tabs && !count_is_done => leading_count += 1,
99+
100+ // We stop counting if we hit whitespace that doesn't
101+ // qualify as indent or doesn't match the leading
102+ // whitespace, but we don't exit the loop yet because
103+ // we still want to determine if the line is blank.
104+ c if char_is_whitespace(c) => count_is_done = true,
105+
106+ // Ignore blank lines.
107+ c if char_is_line_ending(c) => continue 'outer,
108+
109+ _ => break,
110+ }
111+
112+ // Bound the worst-case execution time for weird text files.
113+ if leading_count > 256 {
114+ continue 'outer;
115+ }
116+ }
117+
118+ // If there was an increase in indentation over the previous
119+ // line, update the histogram with that increase.
120+ if (prev_line_is_tabs == is_tabs || prev_line_leading_count == 0)
121+ && prev_line_leading_count < leading_count
122+ {
123+ if is_tabs {
124+ histogram[0] += 1;
125+ } else {
126+ let amount = leading_count - prev_line_leading_count;
127+ if amount <= 8 {
128+ histogram[amount] += 1;
129+ }
130+ }
131+ }
132+
133+ // Store this line's leading whitespace info for use with
134+ // the next line.
135+ prev_line_is_tabs = is_tabs;
136+ prev_line_leading_count = leading_count;
137+ }
138+
139+ // Give more weight to tabs, because their presence is a very
140+ // strong indicator.
141+ histogram[0] *= 2;
142+
143+ histogram
144+ };
145+
146+ // Find the most frequent indent, its frequency, and the frequency of
147+ // the next-most frequent indent.
148+ let indent = histogram
149+ .iter()
150+ .enumerate()
151+ .max_by_key(|kv| kv.1)
152+ .unwrap()
153+ .0;
154+ let indent_freq = histogram[indent];
155+ let indent_freq_2 = *histogram
156+ .iter()
157+ .enumerate()
158+ .filter(|kv| kv.0 != indent)
159+ .map(|kv| kv.1)
160+ .max()
161+ .unwrap();
162+
163+ // Return the the auto-detected result if we're confident enough in its
164+ // accuracy, based on some heuristics.
165+ if indent_freq >= 1 && (indent_freq_2 as f64 / indent_freq as f64) < 0.66 {
166+ Some(match indent {
167+ 0 => IndentStyle::Tabs,
168+ _ => IndentStyle::Spaces(indent as u8),
169+ })
170+ } else {
171+ None
172+ }
173+}
174+
8/// To determine indentation of a newly inserted line, figure out the indentation at the last col
175/// To determine indentation of a newly inserted line, figure out the indentation at the last col
9/// of the previous line.
176/// of the previous line.
10#[allow(dead_code)]
177#[allow(dead_code)]
helix-term/src/commands.rs+2−1
@@ -1,5 +1,6 @@
1use helix_core::{
1use helix_core::{
2 comment, coords_at_pos, find_first_non_whitespace_char, find_root, graphemes, indent,
2 comment, coords_at_pos, find_first_non_whitespace_char, find_root, graphemes, indent,
3+ indent::IndentStyle,
3 line_ending::{get_line_ending_of_str, line_end_char_index, str_is_line_ending},
4 line_ending::{get_line_ending_of_str, line_end_char_index, str_is_line_ending},
4 match_brackets,
5 match_brackets,
5 movement::{self, Direction},
6 movement::{self, Direction},
@@ -11,7 +12,7 @@ use helix_core::{
11};
12};
12
13
13use helix_view::{
14use helix_view::{
14− document::{IndentStyle, Mode},
15+ document::Mode,
15 editor::Action,
16 editor::Action,
16 input::KeyEvent,
17 input::KeyEvent,
17 keyboard::KeyCode,
18 keyboard::KeyCode,
helix-view/src/document.rs+16−154
@@ -9,8 +9,8 @@ use std::str::FromStr;
9use std::sync::Arc;
9use std::sync::Arc;
10
10
11use helix_core::{
11use helix_core::{
12− chars::{char_is_line_ending, char_is_whitespace},
13 history::History,
12 history::History,
13+ indent::{auto_detect_indent_style, IndentStyle},
14 line_ending::auto_detect_line_ending,
14 line_ending::auto_detect_line_ending,
15 syntax::{self, LanguageConfiguration},
15 syntax::{self, LanguageConfiguration},
16 ChangeSet, Diagnostic, LineEnding, Rope, RopeBuilder, Selection, State, Syntax, Transaction,
16 ChangeSet, Diagnostic, LineEnding, Rope, RopeBuilder, Selection, State, Syntax, Transaction,
@@ -63,12 +63,6 @@ impl<'de> Deserialize<'de> for Mode {
63 }
63 }
64}
64}
65
65
66−#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
67−pub enum IndentStyle {
68− Tabs,
69− Spaces(u8),
70−}
71−
72pub struct Document {
66pub struct Document {
73 pub(crate) id: DocumentId,
67 pub(crate) id: DocumentId,
74 text: Rope,
68 text: Rope,
@@ -460,9 +454,7 @@ impl Document {
460 doc.detect_language(theme, loader);
454 doc.detect_language(theme, loader);
461 }
455 }
462
456
463− // Detect indentation style and line ending.
457+ doc.detect_indent_and_line_ending();
464− doc.detect_indent_style();
465− doc.line_ending = auto_detect_line_ending(&doc.text).unwrap_or(DEFAULT_LINE_ENDING);
466
458
467 Ok(doc)
459 Ok(doc)
468 }
460 }
@@ -580,6 +572,18 @@ impl Document {
580 }
572 }
581 }
573 }
582
574
575+ pub fn detect_indent_and_line_ending(&mut self) {
576+ self.indent_style = auto_detect_indent_style(&self.text).unwrap_or_else(|| {
577+ IndentStyle::from_str(
578+ self.language
579+ .as_ref()
580+ .and_then(|config| config.indent.as_ref())
581+ .map_or(" ", |config| config.unit.as_str()), // Fallback to 2 spaces.
582+ )
583+ });
584+ self.line_ending = auto_detect_line_ending(&self.text).unwrap_or(DEFAULT_LINE_ENDING);
585+ }
586+
583 /// Reload the document from its path.
587 /// Reload the document from its path.
584 pub fn reload(&mut self, view_id: ViewId) -> Result<(), Error> {
588 pub fn reload(&mut self, view_id: ViewId) -> Result<(), Error> {
585 let encoding = &self.encoding;
589 let encoding = &self.encoding;
@@ -598,9 +602,7 @@ impl Document {
598 self.append_changes_to_history(view_id);
602 self.append_changes_to_history(view_id);
599 self.reset_modified();
603 self.reset_modified();
600
604
601− // Detect indentation style and line ending.
605+ self.detect_indent_and_line_ending();
602− self.detect_indent_style();
603− self.line_ending = auto_detect_line_ending(&self.text).unwrap_or(DEFAULT_LINE_ENDING);
604
606
605 Ok(())
607 Ok(())
606 }
608 }
@@ -619,132 +621,6 @@ impl Document {
619 self.encoding
621 self.encoding
620 }
622 }
621
623
622− fn detect_indent_style(&mut self) {
623− // Build a histogram of the indentation *increases* between
624− // subsequent lines, ignoring lines that are all whitespace.
625− //
626− // Index 0 is for tabs, the rest are 1-8 spaces.
627− let histogram: [usize; 9] = {
628− let mut histogram = [0; 9];
629− let mut prev_line_is_tabs = false;
630− let mut prev_line_leading_count = 0usize;
631−
632− // Loop through the lines, checking for and recording indentation
633− // increases as we go.
634− 'outer: for line in self.text.lines().take(1000) {
635− let mut c_iter = line.chars();
636−
637− // Is first character a tab or space?
638− let is_tabs = match c_iter.next() {
639− Some('\t') => true,
640− Some(' ') => false,
641−
642− // Ignore blank lines.
643− Some(c) if char_is_line_ending(c) => continue,
644−
645− _ => {
646− prev_line_is_tabs = false;
647− prev_line_leading_count = 0;
648− continue;
649− }
650− };
651−
652− // Count the line's total leading tab/space characters.
653− let mut leading_count = 1;
654− let mut count_is_done = false;
655− for c in c_iter {
656− match c {
657− '\t' if is_tabs && !count_is_done => leading_count += 1,
658− ' ' if !is_tabs && !count_is_done => leading_count += 1,
659−
660− // We stop counting if we hit whitespace that doesn't
661− // qualify as indent or doesn't match the leading
662− // whitespace, but we don't exit the loop yet because
663− // we still want to determine if the line is blank.
664− c if char_is_whitespace(c) => count_is_done = true,
665−
666− // Ignore blank lines.
667− c if char_is_line_ending(c) => continue 'outer,
668−
669− _ => break,
670− }
671−
672− // Bound the worst-case execution time for weird text files.
673− if leading_count > 256 {
674− continue 'outer;
675− }
676− }
677−
678− // If there was an increase in indentation over the previous
679− // line, update the histogram with that increase.
680− if (prev_line_is_tabs == is_tabs || prev_line_leading_count == 0)
681− && prev_line_leading_count < leading_count
682− {
683− if is_tabs {
684− histogram[0] += 1;
685− } else {
686− let amount = leading_count - prev_line_leading_count;
687− if amount <= 8 {
688− histogram[amount] += 1;
689− }
690− }
691− }
692−
693− // Store this line's leading whitespace info for use with
694− // the next line.
695− prev_line_is_tabs = is_tabs;
696− prev_line_leading_count = leading_count;
697− }
698−
699− // Give more weight to tabs, because their presence is a very
700− // strong indicator.
701− histogram[0] *= 2;
702−
703− histogram
704− };
705−
706− // Find the most frequent indent, its frequency, and the frequency of
707− // the next-most frequent indent.
708− let indent = histogram
709− .iter()
710− .enumerate()
711− .max_by_key(|kv| kv.1)
712− .unwrap()
713− .0;
714− let indent_freq = histogram[indent];
715− let indent_freq_2 = *histogram
716− .iter()
717− .enumerate()
718− .filter(|kv| kv.0 != indent)
719− .map(|kv| kv.1)
720− .max()
721− .unwrap();
722−
723− // Use the auto-detected result if we're confident enough in its
724− // accuracy, based on some heuristics. Otherwise fall back to
725− // the language-based setting.
726− if indent_freq >= 1 && (indent_freq_2 as f64 / indent_freq as f64) < 0.66 {
727− // Use the auto-detected setting.
728− self.indent_style = match indent {
729− 0 => IndentStyle::Tabs,
730− _ => IndentStyle::Spaces(indent as u8),
731− };
732− } else {
733− // Fall back to language-based setting.
734− let indent = self
735− .language
736− .as_ref()
737− .and_then(|config| config.indent.as_ref())
738− .map_or(" ", |config| config.unit.as_str()); // fallback to 2 spaces
739−
740− self.indent_style = if indent.starts_with(' ') {
741− IndentStyle::Spaces(indent.len() as u8)
742− } else {
743− IndentStyle::Tabs
744− };
745− }
746− }
747−
748 pub fn set_path(&mut self, path: &Path) -> Result<(), std::io::Error> {
624 pub fn set_path(&mut self, path: &Path) -> Result<(), std::io::Error> {
749 let path = canonicalize_path(path)?;
625 let path = canonicalize_path(path)?;
750
626
@@ -1002,21 +878,7 @@ impl Document {
1002 /// TODO: we might not need this function anymore, since the information
878 /// TODO: we might not need this function anymore, since the information
1003 /// is conveniently available in `Document::indent_style` now.
879 /// is conveniently available in `Document::indent_style` now.
1004 pub fn indent_unit(&self) -> &'static str {
880 pub fn indent_unit(&self) -> &'static str {
1005− match self.indent_style {
881+ self.indent_style.as_str()
1006− IndentStyle::Tabs => "\t",
1007− IndentStyle::Spaces(1) => " ",
1008− IndentStyle::Spaces(2) => " ",
1009− IndentStyle::Spaces(3) => " ",
1010− IndentStyle::Spaces(4) => " ",
1011− IndentStyle::Spaces(5) => " ",
1012− IndentStyle::Spaces(6) => " ",
1013− IndentStyle::Spaces(7) => " ",
1014− IndentStyle::Spaces(8) => " ",
1015−
1016− // Unsupported indentation style. This should never happen,
1017− // but just in case fall back to two spaces.
1018− _ => " ",
1019− }
1020 }
882 }
1021
883
1022 #[inline]
884 #[inline]