feat: continue single-line comments

helix-core/src/chars.rs

@@ -1,5 +1,7 @@
 //! Utility functions to categorize a `char`.
 
+use ropey::RopeSlice;
+
 use crate::LineEnding;
 
 #[derive(Debug, Eq, PartialEq)]
@@ -85,6 +87,10 @@ pub fn char_is_word(ch: char) -> bool {
     ch.is_alphanumeric() || ch == '_'
 }
 
+pub fn find_first_non_whitespace_char(line: &RopeSlice) -> Option<usize> {
+    line.chars().position(|ch| !ch.is_whitespace())
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

helix-core/src/comment.rs

@@ -1,9 +1,9 @@
-//! This module contains the functionality toggle comments on lines over the selection
-//! using the comment character defined in the user's `languages.toml`
+//! This module contains the functionality for the following comment-related features
+//! using the comment character defined in the user's `languages.toml`:
+//! * toggle comments on lines over the selection
+//! * continue comment when opening a new line
 
-use crate::{
-    find_first_non_whitespace_char, Change, Rope, RopeSlice, Selection, Tendril, Transaction,
-};
+use crate::{chars, Change, Rope, RopeSlice, Selection, Tendril, Transaction};
 use std::borrow::Cow;
 
 /// Given text, a comment token, and a set of line indices, returns the following:
@@ -27,7 +27,7 @@ fn find_line_comment(
     let token_len = token.chars().count();
     for line in lines {
         let line_slice = text.line(line);
-        if let Some(pos) = find_first_non_whitespace_char(line_slice) {
+        if let Some(pos) = chars::find_first_non_whitespace_char(&line_slice) {
             let len = line_slice.len_chars();
 
             if pos < min {
@@ -94,12 +94,56 @@ pub fn toggle_line_comments(doc: &Rope, selection: &Selection, token: Option<&st
     Transaction::change(doc, changes.into_iter())
 }
 
+/// Return the comment token of the current line if it is commented.
+///
+/// Return None otherwise.
+pub fn get_comment_token<'a>(line: &RopeSlice, tokens: &'a [String]) -> Option<&'a str> {
+    // TODO: don't continue shebangs
+    if tokens.is_empty() {
+        return None;
+    }
+
+    let mut result = None;
+
+    if let Some(pos) = chars::find_first_non_whitespace_char(line) {
+        let len = line.len_chars();
+
+        for token in tokens {
+            // line can be shorter than pos + token length
+            let fragment = Cow::from(line.slice(pos..std::cmp::min(pos + token.len(), len)));
+
+            if fragment == *token {
+                // We don't necessarily want to break upon finding the first matching comment token
+                // Instead, we check against all of the comment tokens and end up returning the longest
+                // comment token that matches
+                result = Some(token.as_str());
+            }
+        }
+    }
+
+    result
+}
+
+/// Determines whether the new line following the given line should be
+/// prepended with a comment token. If it does, the `text` string is
+/// appended with the appropriate comment token.
+pub fn handle_comment_continue<'a>(
+    line: &'a RopeSlice,
+    text: &'a mut String,
+    comment_tokens: &'a [String],
+) {
+    if let Some(token) = get_comment_token(line, comment_tokens) {
+        let new_line = format!("{} ", token);
+        text.push_str(new_line.as_str());
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
 
     #[test]
-    fn test_find_line_comment() {
+    fn test_toggle_line_comments() {
         // four lines, two space indented, except for line 1 which is blank.
         let mut doc = Rope::from("  1\n\n  2\n  3");
         // select whole document
@@ -149,4 +193,97 @@ mod test {
 
         // TODO: account for uncommenting with uneven comment indentation
     }
+
+    #[test]
+    fn test_get_comment_token() {
+        let tokens = vec![
+            String::from("//"),
+            String::from("///"),
+            String::from("//!"),
+            String::from(";"),
+        ];
+
+        assert_eq!(get_comment_token(&RopeSlice::from("# 1\n"), &tokens), None);
+        assert_eq!(
+            get_comment_token(&RopeSlice::from("    // 2    \n"), &tokens),
+            Some("//")
+        );
+        assert_eq!(
+            get_comment_token(&RopeSlice::from("///3\n"), &tokens),
+            Some("///")
+        );
+        assert_eq!(
+            get_comment_token(&RopeSlice::from("/// 4\n"), &tokens),
+            Some("///")
+        );
+        assert_eq!(
+            get_comment_token(&RopeSlice::from("//! 5\n"), &tokens),
+            Some("//!")
+        );
+        assert_eq!(
+            get_comment_token(&RopeSlice::from("//! /// 6\n"), &tokens),
+            Some("//!")
+        );
+        assert_eq!(
+            get_comment_token(&RopeSlice::from("7 ///\n"), &tokens),
+            None
+        );
+        assert_eq!(
+            get_comment_token(&RopeSlice::from(";8\n"), &tokens),
+            Some(";")
+        );
+        assert_eq!(
+            get_comment_token(&RopeSlice::from("//////////// 9"), &tokens),
+            Some("///")
+        );
+    }
+
+    #[test]
+    fn test_handle_comment_continue() {
+        let comment_tokens = vec![String::from("//"), String::from("///")];
+        let mut line = RopeSlice::from("// 1\n");
+        let mut text = String::from(line);
+
+        handle_comment_continue(&line, &mut text, &comment_tokens);
+
+        assert_eq!(text, String::from("// 1\n// "));
+
+        line = RopeSlice::from("///2\n");
+        text = String::from(line);
+
+        handle_comment_continue(&line, &mut text, &comment_tokens);
+
+        assert_eq!(text, String::from("///2\n/// "));
+
+        line = RopeSlice::from("      // 3\n");
+        text = String::from(line);
+
+        handle_comment_continue(&line, &mut text, &comment_tokens);
+
+        assert_eq!(text, String::from("      // 3\n      // "));
+
+        line = RopeSlice::from("///          4\n");
+        text = String::from(line);
+
+        handle_comment_continue(&line, &mut text, &comment_tokens);
+
+        assert_eq!(text, String::from("///          4\n///          "));
+
+        line = RopeSlice::from("// \n");
+        text = String::from(line);
+
+        handle_comment_continue(&line, &mut text, &comment_tokens);
+
+        assert_eq!(text, String::from("// \n// "));
+
+        line = RopeSlice::from("     // Lorem Ipsum\n     // dolor sit amet\n");
+        text = String::from(line);
+
+        handle_comment_continue(&line, &mut text, &comment_tokens);
+
+        assert_eq!(
+            text,
+            String::from("     // Lorem Ipsum\n     // dolor sit amet\n     // ")
+        );
+    }
 }

helix-core/src/indent.rs

@@ -184,16 +184,38 @@ pub fn auto_detect_indent_style(document_text: &Rope) -> Option<IndentStyle> {
 /// To determine indentation of a newly inserted line, figure out the indentation at the last col
 /// of the previous line.
 pub fn indent_level_for_line(line: RopeSlice, tab_width: usize, indent_width: usize) -> usize {
+    if let Some(indent_level) = indent_level_at(&line, tab_width, indent_width, 0) {
+        indent_level
+    } else {
+        0
+    }
+}
+
+/// Determine the indentation level starting from the specified position index in the line.
+///
+/// Returns None if the specified index is out of bounds of the line.
+pub fn indent_level_at(
+    line: &RopeSlice,
+    tab_width: usize,
+    indent_width: usize,
+    starting_pos: usize,
+) -> Option<usize> {
+    let line_len = line.len_chars();
+
+    if starting_pos >= line_len {
+        return None;
+    }
+
     let mut len = 0;
-    for ch in line.chars() {
+    for ch in line.chars_at(starting_pos) {
         match ch {
             '\t' => len += tab_width_at(len, tab_width as u16),
             ' ' => len += 1,
             _ => break,
         }
     }
 
-    len / indent_width
+    Some(len / indent_width)
 }
 
 /// Computes for node and all ancestors whether they are the first node on their line.

helix-core/src/lib.rs

@@ -38,9 +38,6 @@ pub mod unicode {
 
 pub use helix_loader::find_workspace;
 
-pub fn find_first_non_whitespace_char(line: RopeSlice) -> Option<usize> {
-    line.chars().position(|ch| !ch.is_whitespace())
-}
 mod rope_reader;
 
 pub use rope_reader::RopeReader;

helix-core/src/syntax.rs

@@ -102,7 +102,9 @@ pub struct LanguageConfiguration {
     #[serde(default)]
     pub shebangs: Vec<String>, // interpreter(s) associated with language
     pub roots: Vec<String>,        // these indicate project roots <.git, Cargo.toml>
-    pub comment_token: Option<String>,
+    pub comment_token: Option<String>, // TODO: Replace all usages of `comment_token` with `comment_tokens`
+    #[serde(default)]
+    pub comment_tokens: Vec<String>,
     pub text_width: Option<usize>,
     pub soft_wrap: Option<SoftWrap>,
 

helix-core/tests/indent.rs

@@ -205,7 +205,7 @@ fn test_treesitter_indent(
         if ignored_lines.iter().any(|range| range.contains(&(i + 1))) {
             continue;
         }
-        if let Some(pos) = helix_core::find_first_non_whitespace_char(line) {
+        if let Some(pos) = helix_core::chars::find_first_non_whitespace_char(&line) {
             let tab_width: usize = 4;
             let suggested_indent = treesitter_indent_for_pos(
                 indent_query,

helix-term/src/commands.rs

@@ -10,9 +10,9 @@ use tui::widgets::Row;
 pub use typed::*;
 
 use helix_core::{
-    char_idx_at_visual_offset, comment,
+    char_idx_at_visual_offset, chars, comment,
     doc_formatter::TextFormat,
-    encoding, find_first_non_whitespace_char, find_workspace, graphemes,
+    encoding, find_workspace, graphemes,
     history::UndoKind,
     increment, indent,
     indent::IndentStyle,
@@ -814,7 +814,7 @@ fn kill_to_line_start(cx: &mut Context) {
             let head = if anchor == first_char && line != 0 {
                 // select until previous line
                 line_end_char_index(&text, line - 1)
-            } else if let Some(pos) = find_first_non_whitespace_char(text.line(line)) {
+            } else if let Some(pos) = chars::find_first_non_whitespace_char(&text.line(line)) {
                 if first_char + pos < anchor {
                     // select until first non-blank in line if cursor is after it
                     first_char + pos
@@ -876,7 +876,7 @@ fn goto_first_nonwhitespace_impl(view: &mut View, doc: &mut Document, movement:
     let selection = doc.selection(view.id).clone().transform(|range| {
         let line = range.cursor_line(text);
 
-        if let Some(pos) = find_first_non_whitespace_char(text.line(line)) {
+        if let Some(pos) = chars::find_first_non_whitespace_char(&text.line(line)) {
             let pos = pos + text.line_to_char(line);
             range.put_cursor(text, pos, movement == Movement::Extend)
         } else {
@@ -3004,7 +3004,7 @@ fn insert_with_indent(cx: &mut Context, cursor_fallback: IndentFallbackPos) {
             // move cursor to the fallback position
             let pos = match cursor_fallback {
                 IndentFallbackPos::LineStart => {
-                    find_first_non_whitespace_char(text.line(cursor_line))
+                    chars::find_first_non_whitespace_char(&text.line(cursor_line))
                         .map(|ws_offset| ws_offset + cursor_line_start)
                         .unwrap_or(cursor_line_start)
                 }
@@ -3077,6 +3077,7 @@ fn open(cx: &mut Context, open: Open) {
     enter_insert_mode(cx);
     let (view, doc) = current!(cx.editor);
 
+    let config = doc.config.load();
     let text = doc.text().slice(..);
     let contents = doc.text();
     let selection = doc.selection(view.id);
@@ -3125,6 +3126,11 @@ fn open(cx: &mut Context, open: Open) {
         let mut text = String::with_capacity(1 + indent_len);
         text.push_str(doc.line_ending.as_str());
         text.push_str(&indent);
+
+        if config.continue_comments {
+            handle_comment_continue(doc, &mut text, cursor_line);
+        }
+
         let text = text.repeat(count);
 
         // calculate new selection ranges
@@ -3144,6 +3150,21 @@ fn open(cx: &mut Context, open: Open) {
     transaction = transaction.with_selection(Selection::new(ranges, selection.primary_index()));
 
     doc.apply(&transaction, view.id);
+
+    // Since we might have added a comment token, move to the end of the line.
+    goto_line_end_newline(cx);
+}
+
+// Currently only continues single-line comments
+// TODO: Handle block comments as well
+fn handle_comment_continue(doc: &Document, text: &mut String, cursor_line: usize) {
+    let line = doc.text().line(cursor_line);
+
+    if let Some(lang_config) = doc.language_config() {
+        let comment_tokens = &lang_config.comment_tokens;
+
+        comment::handle_comment_continue(&line, text, comment_tokens);
+    }
 }
 
 // o inserts a new line after each line with a selection
@@ -3613,6 +3634,7 @@ pub mod insert {
 
     pub fn insert_newline(cx: &mut Context) {
         let (view, doc) = current_ref!(cx.editor);
+        let config = doc.config.load();
         let text = doc.text().slice(..);
 
         let contents = doc.text();
@@ -3681,6 +3703,11 @@ pub mod insert {
                     new_text.reserve_exact(1 + indent.len());
                     new_text.push_str(doc.line_ending.as_str());
                     new_text.push_str(&indent);
+
+                    if config.continue_comments {
+                        handle_comment_continue(doc, &mut new_text, current_line);
+                    }
+
                     new_text.chars().count()
                 };
 
@@ -4514,7 +4541,6 @@ pub fn completion(cx: &mut Context) {
     // TODO: trigger_offset should be the cursor offset but we also need a starting offset from where we want to apply
     // completion filtering. For example logger.te| should filter the initial suggestion list with "te".
 
-    use helix_core::chars;
     let mut iter = text.chars_at(cursor);
     iter.reverse();
     let offset = iter.take_while(|ch| chars::char_is_word(*ch)).count();
@@ -4583,7 +4609,7 @@ fn toggle_comments(cx: &mut Context) {
     let (view, doc) = current!(cx.editor);
     let token = doc
         .language_config()
-        .and_then(|lc| lc.comment_token.as_ref())
+        .and_then(|lc| lc.comment_tokens.get(0))
         .map(|tc| tc.as_ref());
     let transaction = comment::toggle_line_comments(doc.text(), doc.selection(view.id), token);