toggling of block comments (helix-editor#4718)

book/src/keymap.md

@@ -12,6 +12,7 @@
  - [Match mode](#match-mode)
  - [Window mode](#window-mode)
  - [Space mode](#space-mode)
+ - [Comment mode](#comment-mode)
  - [Popup](#popup)
  - [Unimpaired](#unimpaired)
 - [Insert mode](#insert-mode)
@@ -289,6 +290,9 @@ This layer is a kludge of mappings, mostly pickers.
 | `h` | Select symbol references (**LSP**) | `select_references_to_symbol_under_cursor` |
 | `'` | Open last fuzzy picker | `last_picker` |
 | `w` | Enter [window mode](#window-mode) | N/A |
+| `c` | Comment/uncomment selections | `toggle_comments` |
+| `C` | Block comment/uncomment selections | `toggle_block_comments` |
+| `Alt-c` | Line comment/uncomment selections | `toggle_line_comments` |
 | `p` | Paste system clipboard after selections | `paste_clipboard_after` |
 | `P` | Paste system clipboard before selections | `paste_clipboard_before` |
 | `y` | Yank selections to clipboard | `yank_to_clipboard` |

book/src/languages.md

@@ -42,7 +42,7 @@ name = "mylang"
 scope = "source.mylang"
 injection-regex = "mylang"
 file-types = ["mylang", "myl"]
-comment-token = "#"
+comment-tokens = "#"
 indent = { tab-width = 2, unit = " " }
 formatter = { command = "mylang-formatter" , args = ["--stdin"] }
 language-servers = [ "mylang-lsp" ]
@@ -61,7 +61,8 @@ These configuration keys are available:
 | `roots` | A set of marker files to look for when trying to find the workspace root. For example `Cargo.lock`, `yarn.lock` |
 | `auto-format` | Whether to autoformat this language when saving |
 | `diagnostic-severity` | Minimal severity of diagnostic for it to be displayed. (Allowed values: `Error`, `Warning`, `Info`, `Hint`) |
-| `comment-token` | The token to use as a comment-token |
+| `comment-tokens` | The tokens to use as a comment token, either a single token `"//"` or an array `["//", "///", "//!"]` (the first token will be used for commenting). Also configurable as `comment-token` for backwards compatibility|
+| `block-comment-tokens`| The start and end tokens for a multiline comment either an array or single table of `{ start = "/*", end = "*/"}`. The first set of tokens will be used for commenting, any pairs in the array can be uncommented |
 | `indent` | The indent to use. Has sub keys `unit` (the text inserted into the document when indenting; usually set to N spaces or `"\t"` for tabs) and `tab-width` (the number of spaces rendered for a tab) |
 | `language-servers` | The Language Servers used for this language. See below for more information in the section [Configuring Language Servers for a language](#configuring-language-servers-for-a-language) |
 | `grammar` | The tree-sitter grammar to use (defaults to the value of `name`) |

helix-core/src/comment.rs

@@ -1,9 +1,12 @@
 //! This module contains the functionality toggle comments on lines over the selection
 //! using the comment character defined in the user's `languages.toml`
 
+use smallvec::SmallVec;
+
 use crate::{
- find_first_non_whitespace_char, Change, Rope, RopeSlice, Selection, Tendril, Transaction,
+ syntax::BlockCommentToken, Change, Range, Rope, RopeSlice, Selection, Tendril, Transaction,
 };
+use helix_stdx::rope::RopeSliceExt;
 use std::borrow::Cow;
 
 /// Given text, a comment token, and a set of line indices, returns the following:
@@ -22,12 +25,12 @@ fn find_line_comment(
 ) -> (bool, Vec<usize>, usize, usize) {
  let mut commented = true;
  let mut to_change = Vec::new();
- let mut min = usize::MAX; // minimum col for find_first_non_whitespace_char
+ let mut min = usize::MAX; // minimum col for first_non_whitespace_char
  let mut margin = 1;
  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) = line_slice.first_non_whitespace_char() {
  let len = line_slice.len_chars();
 
  if pos < min {
@@ -94,6 +97,222 @@ pub fn toggle_line_comments(doc: &Rope, selection: &Selection, token: Option<&st
  Transaction::change(doc, changes.into_iter())
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum CommentChange {
+ Commented {
+ range: Range,
+ start_pos: usize,
+ end_pos: usize,
+ start_margin: bool,
+ end_margin: bool,
+ start_token: String,
+ end_token: String,
+ },
+ Uncommented {
+ range: Range,
+ start_pos: usize,
+ end_pos: usize,
+ start_token: String,
+ end_token: String,
+ },
+ Whitespace {
+ range: Range,
+ },
+}
+
+pub fn find_block_comments(
+ tokens: &[BlockCommentToken],
+ text: RopeSlice,
+ selection: &Selection,
+) -> (bool, Vec<CommentChange>) {
+ let mut commented = true;
+ let mut only_whitespace = true;
+ let mut comment_changes = Vec::with_capacity(selection.len());
+ let default_tokens = tokens.first().cloned().unwrap_or_default();
+ // TODO: check if this can be removed on MSRV bump
+ #[allow(clippy::redundant_clone)]
+ let mut start_token = default_tokens.start.clone();
+ #[allow(clippy::redundant_clone)]
+ let mut end_token = default_tokens.end.clone();
+
+ let mut tokens = tokens.to_vec();
+ // sort the tokens by length, so longer tokens will match first
+ tokens.sort_by(|a, b| {
+ if a.start.len() == b.start.len() {
+ b.end.len().cmp(&a.end.len())
+ } else {
+ b.start.len().cmp(&a.start.len())
+ }
+ });
+ for range in selection {
+ let selection_slice = range.slice(text);
+ if let (Some(start_pos), Some(end_pos)) = (
+ selection_slice.first_non_whitespace_char(),
+ selection_slice.last_non_whitespace_char(),
+ ) {
+ let mut line_commented = false;
+ let mut after_start = 0;
+ let mut before_end = 0;
+ let len = (end_pos + 1) - start_pos;
+
+ for BlockCommentToken { start, end } in &tokens {
+ let start_len = start.chars().count();
+ let end_len = end.chars().count();
+ after_start = start_pos + start_len;
+ before_end = end_pos.saturating_sub(end_len);
+
+ if len >= start_len + end_len {
+ let start_fragment = selection_slice.slice(start_pos..after_start);
+ let end_fragment = selection_slice.slice(before_end + 1..end_pos + 1);
+
+ // block commented with these tokens
+ if start_fragment == start.as_str() && end_fragment == end.as_str() {
+ start_token = start.to_string();
+ end_token = end.to_string();
+ line_commented = true;
+ break;
+ }
+ }
+ }
+
+ if !line_commented {
+ comment_changes.push(CommentChange::Uncommented {
+ range: *range,
+ start_pos,
+ end_pos,
+ start_token: default_tokens.start.clone(),
+ end_token: default_tokens.end.clone(),
+ });
+ commented = false;
+ } else {
+ comment_changes.push(CommentChange::Commented {
+ range: *range,
+ start_pos,
+ end_pos,
+ start_margin: selection_slice
+ .get_char(after_start)
+ .map_or(false, |c| c == ' '),
+ end_margin: after_start != before_end
+ && selection_slice
+ .get_char(before_end)
+ .map_or(false, |c| c == ' '),
+ start_token: start_token.to_string(),
+ end_token: end_token.to_string(),
+ });
+ }
+ only_whitespace = false;
+ } else {
+ comment_changes.push(CommentChange::Whitespace { range: *range });
+ }
+ }
+ if only_whitespace {
+ commented = false;
+ }
+ (commented, comment_changes)
+}
+
+#[must_use]
+pub fn create_block_comment_transaction(
+ doc: &Rope,
+ selection: &Selection,
+ commented: bool,
+ comment_changes: Vec<CommentChange>,
+) -> (Transaction, SmallVec<[Range; 1]>) {
+ let mut changes: Vec<Change> = Vec::with_capacity(selection.len() * 2);
+ let mut ranges: SmallVec<[Range; 1]> = SmallVec::with_capacity(selection.len());
+ let mut offs = 0;
+ for change in comment_changes {
+ if commented {
+ if let CommentChange::Commented {
+ range,
+ start_pos,
+ end_pos,
+ start_token,
+ end_token,
+ start_margin,
+ end_margin,
+ } = change
+ {
+ let from = range.from();
+ changes.push((
+ from + start_pos,
+ from + start_pos + start_token.len() + start_margin as usize,
+ None,
+ ));
+ changes.push((
+ from + end_pos - end_token.len() - end_margin as usize + 1,
+ from + end_pos + 1,
+ None,
+ ));
+ }
+ } else {
+ // uncommented so manually map ranges through changes
+ match change {
+ CommentChange::Uncommented {
+ range,
+ start_pos,
+ end_pos,
+ start_token,
+ end_token,
+ } => {
+ let from = range.from();
+ changes.push((
+ from + start_pos,
+ from + start_pos,
+ Some(Tendril::from(format!("{} ", start_token))),
+ ));
+ changes.push((
+ from + end_pos + 1,
+ from + end_pos + 1,
+ Some(Tendril::from(format!(" {}", end_token))),
+ ));
+
+ let offset = start_token.chars().count() + end_token.chars().count() + 2;
+ ranges.push(
+ Range::new(from + offs, from + offs + end_pos + 1 + offset)
+ .with_direction(range.direction()),
+ );
+ offs += offset;
+ }
+ CommentChange::Commented { range, .. } | CommentChange::Whitespace { range } => {
+ ranges.push(Range::new(range.from() + offs, range.to() + offs));
+ }
+ }
+ }
+ }
+ (Transaction::change(doc, changes.into_iter()), ranges)
+}
+
+#[must_use]
+pub fn toggle_block_comments(
+ doc: &Rope,
+ selection: &Selection,
+ tokens: &[BlockCommentToken],
+) -> Transaction {
+ let text = doc.slice(..);
+ let (commented, comment_changes) = find_block_comments(tokens, text, selection);
+ let (mut transaction, ranges) =
+ create_block_comment_transaction(doc, selection, commented, comment_changes);
+ if !commented {
+ transaction = transaction.with_selection(Selection::new(ranges, selection.primary_index()));
+ }
+ transaction
+}
+
+pub fn split_lines_of_selection(text: RopeSlice, selection: &Selection) -> Selection {
+ let mut ranges = SmallVec::new();
+ for range in selection.ranges() {
+ let (line_start, line_end) = range.line_range(text.slice(..));
+ let mut pos = text.line_to_char(line_start);
+ for line in text.slice(pos..text.line_to_char(line_end + 1)).lines() {
+ let start = pos;
+ pos += line.len_chars();
+ ranges.push(Range::new(start, pos));
+ }
+ }
+ Selection::new(ranges, 0)
+}
+
 #[cfg(test)]
 mod test {
  use super::*;
@@ -149,4 +368,49 @@ mod test {
 
  // TODO: account for uncommenting with uneven comment indentation
  }
+
+ #[test]
+ fn test_find_block_comments() {
+ // three lines 5 characters.
+ let mut doc = Rope::from("1\n2\n3");
+ // select whole document
+ let selection = Selection::single(0, doc.len_chars());
+
+ let text = doc.slice(..);
+
+ let res = find_block_comments(&[BlockCommentToken::default()], text, &selection);
+
+ assert_eq!(
+ res,
+ (
+ false,
+ vec![CommentChange::Uncommented {
+ range: Range::new(0, 5),
+ start_pos: 0,
+ end_pos: 4,
+ start_token: "/*".to_string(),
+ end_token: "*/".to_string(),
+ }]
+ )
+ );
+
+ // comment
+ let transaction = toggle_block_comments(&doc, &selection, &[BlockCommentToken::default()]);
+ transaction.apply(&mut doc);
+
+ assert_eq!(doc, "/* 1\n2\n3 */");
+
+ // uncomment
+ let selection = Selection::single(0, doc.len_chars());
+ let transaction = toggle_block_comments(&doc, &selection, &[BlockCommentToken::default()]);
+ transaction.apply(&mut doc);
+ assert_eq!(doc, "1\n2\n3");
+
+ // don't panic when there is just a space in comment
+ doc = Rope::from("/* */");
+ let selection = Selection::single(0, doc.len_chars());
+ let transaction = toggle_block_comments(&doc, &selection, &[BlockCommentToken::default()]);
+ transaction.apply(&mut doc);
+ assert_eq!(doc, "");
+ }
 }

helix-core/src/indent.rs

@@ -1,10 +1,10 @@
 use std::{borrow::Cow, collections::HashMap};
 
+use helix_stdx::rope::RopeSliceExt;
 use tree_sitter::{Query, QueryCursor, QueryPredicateArg};
 
 use crate::{
  chars::{char_is_line_ending, char_is_whitespace},
- find_first_non_whitespace_char,
  graphemes::{grapheme_width, tab_width_at},
  syntax::{IndentationHeuristic, LanguageConfiguration, RopeProvider, Syntax},
  tree_sitter::Node,
@@ -970,7 +970,7 @@ pub fn indent_for_newline(
  let mut num_attempts = 0;
  for line_idx in (0..=line_before).rev() {
  let line = text.line(line_idx);
- let first_non_whitespace_char = match find_first_non_whitespace_char(line) {
+ let first_non_whitespace_char = match line.first_non_whitespace_char() {
  Some(i) => i,
  None => {
  continue;

helix-core/src/lib.rs

@@ -37,9 +37,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;