move NuMatcher to nu-protocol

Author: blindFS

Cargo.lock

@@ -47,7 +47,6 @@ is_executable = { workspace = true }
 log = { workspace = true }
 lscolors = { workspace = true, default-features = false, features = ["nu-ansi-term"] }
 miette = { workspace = true, features = ["fancy-no-backtrace"] }
-nucleo-matcher = { workspace = true }
 percent-encoding = { workspace = true }
 sysinfo = { workspace = true }
 strum = { workspace = true }

crates/nu-cli/Cargo.toml

@@ -2,12 +2,14 @@ use crate::{
     FileCompletion, NuCompleter,
     completions::{
         CommandCompletion, Completer, DirectoryCompletion, DotNuCompletion, ExportableCompletion,
-        SemanticSuggestion, completer::Context, completion_options::NuMatcher,
+        SemanticSuggestion,
+        completer::Context,
+        matcher_helper::{add_semantic_suggestion, suggestion_results},
     },
 };
 use nu_parser::parse_module_file_or_dir;
 use nu_protocol::{
-    CompletionOptions, DynamicCompletionCallRef, Span,
+    CompletionOptions, DynamicCompletionCallRef, NuMatcher, Span,
     ast::{Argument, Call, Expr, Expression, ListItem},
     engine::{ArgType, Stack, StateWorkingSet},
 };
@@ -62,9 +64,9 @@ impl<'a> Completer for ArgValueCompletion<'a> {
                         },
                         None,
                     );
-                    matcher.add_semantic_suggestion(suggestion);
+                    add_semantic_suggestion(&mut matcher, suggestion);
                 }
-                return matcher.suggestion_results();
+                return suggestion_results(matcher);
             }
             Err(e) => {
                 log::error!(

crates/nu-cli/src/completions/arg_value_completion.rs

@@ -1,7 +1,10 @@
-use super::{SemanticSuggestion, completion_options::NuMatcher};
-use crate::completions::Completer;
+use super::SemanticSuggestion;
+use crate::completions::{
+    Completer,
+    matcher_helper::{add_semantic_suggestion, suggestion_results},
+};
 use nu_protocol::{
-    CompletionOptions, Span, SuggestionKind,
+    CompletionOptions, NuMatcher, Span, SuggestionKind,
     engine::{Stack, StateWorkingSet},
 };
 use reedline::Suggestion;
@@ -26,22 +29,25 @@ impl Completer for AttributeCompletion {
 
         for (decl_id, name, desc, ty) in attr_commands {
             let name = name.strip_prefix(b"attr ").unwrap_or(&name);
-            matcher.add_semantic_suggestion(SemanticSuggestion {
-                suggestion: Suggestion {
-                    value: String::from_utf8_lossy(name).into_owned(),
-                    description: desc,
-                    span: reedline::Span {
-                        start: span.start - offset,
-                        end: span.end - offset,
+            add_semantic_suggestion(
+                &mut matcher,
+                SemanticSuggestion {
+                    suggestion: Suggestion {
+                        value: String::from_utf8_lossy(name).into_owned(),
+                        description: desc,
+                        span: reedline::Span {
+                            start: span.start - offset,
+                            end: span.end - offset,
+                        },
+                        append_whitespace: false,
+                        ..Default::default()
                     },
-                    append_whitespace: false,
-                    ..Default::default()
+                    kind: Some(SuggestionKind::Command(ty, Some(decl_id))),
                 },
-                kind: Some(SuggestionKind::Command(ty, Some(decl_id))),
-            });
+            );
         }
 
-        matcher.suggestion_results()
+        suggestion_results(matcher)
     }
 }
 
@@ -62,25 +68,28 @@ impl Completer for AttributableCompletion {
                 .find_decl(s.as_bytes())
                 .expect("internal error, builtin declaration not found");
             let cmd = working_set.get_decl(decl_id);
-            matcher.add_semantic_suggestion(SemanticSuggestion {
-                suggestion: Suggestion {
-                    value: cmd.name().into(),
-                    description: Some(cmd.description().into()),
-                    span: reedline::Span {
-                        start: span.start - offset,
-                        end: span.end - offset,
+            add_semantic_suggestion(
+                &mut matcher,
+                SemanticSuggestion {
+                    suggestion: Suggestion {
+                        value: cmd.name().into(),
+                        description: Some(cmd.description().into()),
+                        span: reedline::Span {
+                            start: span.start - offset,
+                            end: span.end - offset,
+                        },
+                        append_whitespace: true,
+                        ..Default::default()
                     },
-                    append_whitespace: true,
-                    ..Default::default()
+                    kind: Some(SuggestionKind::Command(
+                        cmd.command_type(),
+                        // for snippet completion in LSP
+                        working_set.find_decl(s.as_bytes()),
+                    )),
                 },
-                kind: Some(SuggestionKind::Command(
-                    cmd.command_type(),
-                    // for snippet completion in LSP
-                    working_set.find_decl(s.as_bytes()),
-                )),
-            });
+            );
         }
 
-        matcher.suggestion_results()
+        suggestion_results(matcher)
     }
 }

crates/nu-cli/src/completions/attribute_completions.rs

@@ -1,17 +1,18 @@
 use std::borrow::Cow;
 
-use crate::completions::{Completer, SemanticSuggestion};
+use crate::completions::{
+    Completer, SemanticSuggestion,
+    matcher_helper::{add_semantic_suggestion, suggestion_results},
+};
 use nu_engine::{column::get_columns, eval_variable};
 use nu_protocol::{
-    CompletionOptions, ShellError, Span, SuggestionKind, Type, Value,
+    CompletionOptions, NuMatcher, ShellError, Span, SuggestionKind, Type, Value,
     ast::{Expr, Expression, FullCellPath, PathMember},
     engine::{Stack, StateWorkingSet},
     eval_const::eval_constant,
 };
 use reedline::Suggestion;
 
-use super::completion_options::NuMatcher;
-
 pub struct CellPathCompletion<'a> {
     pub full_cell_path: &'a FullCellPath,
     pub position: usize,
@@ -70,15 +71,15 @@ impl Completer for CellPathCompletion<'_> {
 
         if let Ok(value) = value {
             for suggestion in get_suggestions_by_value(&value, current_span) {
-                matcher.add_semantic_suggestion(suggestion);
+                add_semantic_suggestion(&mut matcher, suggestion);
             }
         } else if let Some(ty) = self.full_cell_path.head.ty.follow_cell_path(path_members) {
             for suggestion in get_suggestions_by_type(&ty, current_span) {
-                matcher.add_semantic_suggestion(suggestion);
+                add_semantic_suggestion(&mut matcher, suggestion);
             }
         }
 
-        matcher.suggestion_results()
+        suggestion_results(matcher)
     }
 }
 

crates/nu-cli/src/completions/cell_path_completions.rs

@@ -1,13 +1,16 @@
 use std::collections::HashSet;
 
-use crate::completions::Completer;
+use crate::completions::{
+    Completer,
+    matcher_helper::{add_semantic_suggestion, suggestion_results},
+};
 use nu_protocol::{
-    Category, CompletionOptions, Span, SuggestionKind,
+    Category, CompletionOptions, NuMatcher, Span, SuggestionKind,
     engine::{CommandType, Stack, StateWorkingSet},
 };
 use reedline::Suggestion;
 
-use super::{SemanticSuggestion, completion_options::NuMatcher};
+use super::SemanticSuggestion;
 
 // TODO: Add a toggle for quoting multi word commands. Useful for: `which` and `attr complete`
 pub struct CommandCompletion {
@@ -88,7 +91,7 @@ impl CommandCompletion {
             }
         }
 
-        matcher.suggestion_results()
+        suggestion_results(matcher)
     }
 
     fn is_executable_command(path: impl AsRef<std::path::Path>) -> bool {
@@ -130,24 +133,27 @@ impl Completer for CommandCompletion {
                 if command.signature().category == Category::Removed {
                     return;
                 }
-                let matched = matcher.add_semantic_suggestion(SemanticSuggestion {
-                    suggestion: Suggestion {
-                        value: name.to_string(),
-                        description: Some(command.description().to_string()),
-                        span: sugg_span,
-                        append_whitespace: true,
-                        ..Suggestion::default()
+                let matched = add_semantic_suggestion(
+                    &mut matcher,
+                    SemanticSuggestion {
+                        suggestion: Suggestion {
+                            value: name.to_string(),
+                            description: Some(command.description().to_string()),
+                            span: sugg_span,
+                            append_whitespace: true,
+                            ..Suggestion::default()
+                        },
+                        kind: Some(SuggestionKind::Command(
+                            command.command_type(),
+                            Some(decl_id),
+                        )),
                     },
-                    kind: Some(SuggestionKind::Command(
-                        command.command_type(),
-                        Some(decl_id),
-                    )),
-                });
+                );
                 if matched {
                     internal_suggs.insert(name.to_string());
                 }
             });
-            res.extend(matcher.suggestion_results());
+            res.extend(suggestion_results(matcher));
         }
 
         if self.externals {

crates/nu-cli/src/completions/command_completions.rs

@@ -1,10 +1,9 @@
-use super::completion_options::NuMatcher;
 use nu_ansi_term::Style;
 use nu_engine::env_to_string;
 use nu_path::dots::expand_ndots;
 use nu_path::{expand_to_real_path, home_dir};
 use nu_protocol::{
-    CompletionAlgorithm, CompletionOptions, Span,
+    CompletionAlgorithm, CompletionOptions, NuMatcher, Span,
     engine::{EngineState, Stack, StateWorkingSet},
 };
 use nu_utils::IgnoreCaseExt;

crates/nu-cli/src/completions/completion_common.rs

@@ -1,10 +1,10 @@
-use crate::completions::{Completer, SemanticSuggestion};
+use crate::completions::{Completer, SemanticSuggestion, matcher_helper::suggestion_results};
 use nu_color_config::{color_record_to_nustyle, lookup_ansi_color_style};
 use nu_engine::{compile, eval_call};
 use nu_parser::flatten_expression;
 use nu_protocol::{
-    BlockId, CompletionAlgorithm, CompletionOptions, DeclId, GetSpan, IntoSpanned, PipelineData,
-    Record, ShellError, Span, Spanned, SuggestionKind, Type, Value, VarId,
+    BlockId, CompletionAlgorithm, CompletionOptions, DeclId, GetSpan, IntoSpanned, NuMatcher,
+    PipelineData, Record, ShellError, Span, Spanned, SuggestionKind, Type, Value, VarId,
     ast::{Argument, Call, Expr, Expression},
     debugger::WithoutDebug,
     engine::{Closure, EngineState, Stack, StateWorkingSet},
@@ -13,8 +13,6 @@ use nu_utils::{SharedCow, strip_ansi_string_unlikely};
 use reedline::Suggestion;
 use std::{collections::HashMap, str::FromStr, sync::Arc};
 
-use super::completion_options::NuMatcher;
-
 fn map_value_completions<'a>(
     list: impl Iterator<Item = &'a Value>,
     span: Span,
@@ -238,8 +236,8 @@ impl<T: Completer> Completer for CustomCompletion<T> {
                         }
                         if let Some(algorithm) = options
                             .get("completion_algorithm")
-                            .and_then(|option| option.coerce_string().ok())
-                            .and_then(|option| CompletionAlgorithm::from_str(option.as_str()).ok())
+                            .and_then(|option| option.coerce_str().ok())
+                            .and_then(|option| CompletionAlgorithm::from_str(&option).ok())
                         {
                             completion_options.match_algorithm = algorithm;
                             if let Some(false) = positional
@@ -294,7 +292,7 @@ impl<T: Completer> Completer for CustomCompletion<T> {
                 sugg,
             );
         }
-        matcher.suggestion_results()
+        suggestion_results(matcher)
     }
 }