nu-cli: directory syntax shape + completions (#5299)

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

@@ -1,6 +1,6 @@
 use crate::completions::{
-    CommandCompletion, Completer, CustomCompletion, DotNuCompletion, FileCompletion,
-    FlagCompletion, VariableCompletion,
+    CommandCompletion, Completer, CustomCompletion, DirectoryCompletion, DotNuCompletion,
+    FileCompletion, FlagCompletion, VariableCompletion,
 };
 use nu_parser::{flatten_expression, parse, FlatShape};
 use nu_protocol::{
@@ -153,6 +153,19 @@ impl NuCompleter {
                                     pos,
                                 );
                             }
+                            FlatShape::Directory => {
+                                let mut completer =
+                                    DirectoryCompletion::new(self.engine_state.clone());
+
+                                return self.process_completion(
+                                    &mut completer,
+                                    &working_set,
+                                    prefix,
+                                    new_span,
+                                    offset,
+                                    pos,
+                                );
+                            }
                             FlatShape::Filepath | FlatShape::GlobPattern => {
                                 let mut completer = FileCompletion::new(self.engine_state.clone());
 

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

@@ -0,0 +1,101 @@
+use crate::completions::{file_path_completion, Completer};
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    levenshtein_distance, Span,
+};
+use reedline::Suggestion;
+use std::path::Path;
+use std::sync::Arc;
+
+const SEP: char = std::path::MAIN_SEPARATOR;
+
+#[derive(Clone)]
+pub struct DirectoryCompletion {
+    engine_state: Arc<EngineState>,
+}
+
+impl DirectoryCompletion {
+    pub fn new(engine_state: Arc<EngineState>) -> Self {
+        Self { engine_state }
+    }
+}
+
+impl Completer for DirectoryCompletion {
+    fn fetch(
+        &mut self,
+        _: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+    ) -> Vec<Suggestion> {
+        let cwd = if let Some(d) = self.engine_state.env_vars.get("PWD") {
+            match d.as_string() {
+                Ok(s) => s,
+                Err(_) => "".to_string(),
+            }
+        } else {
+            "".to_string()
+        };
+        let prefix = String::from_utf8_lossy(&prefix).to_string();
+
+        // Filter only the folders
+        let output: Vec<_> = file_path_completion(span, &prefix, &cwd)
+            .into_iter()
+            .filter_map(move |x| {
+                if x.1.ends_with(SEP) {
+                    return Some(Suggestion {
+                        value: x.1,
+                        description: None,
+                        extra: None,
+                        span: reedline::Span {
+                            start: x.0.start - offset,
+                            end: x.0.end - offset,
+                        },
+                    });
+                }
+
+                None
+            })
+            .collect();
+
+        output
+    }
+
+    // Sort results prioritizing the non hidden folders
+    fn sort(&self, items: Vec<Suggestion>, prefix: Vec<u8>) -> Vec<Suggestion> {
+        let prefix_str = String::from_utf8_lossy(&prefix).to_string();
+
+        // Sort items
+        let mut sorted_items = items;
+        sorted_items.sort_by(|a, b| a.value.cmp(&b.value));
+        sorted_items.sort_by(|a, b| {
+            let a_distance = levenshtein_distance(&prefix_str, &a.value);
+            let b_distance = levenshtein_distance(&prefix_str, &b.value);
+            a_distance.cmp(&b_distance)
+        });
+
+        // Separate the results between hidden and non hidden
+        let mut hidden: Vec<Suggestion> = vec![];
+        let mut non_hidden: Vec<Suggestion> = vec![];
+
+        for item in sorted_items.into_iter() {
+            let item_path = Path::new(&item.value);
+
+            if let Some(value) = item_path.file_name() {
+                if let Some(value) = value.to_str() {
+                    if value.starts_with('.') {
+                        hidden.push(item);
+                    } else {
+                        non_hidden.push(item);
+                    }
+                }
+            }
+        }
+
+        // Append the hidden folders to the non hidden vec to avoid creating a new vec
+        non_hidden.append(&mut hidden);
+
+        non_hidden
+    }
+}

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

@@ -3,6 +3,7 @@ mod command_completions;
 mod completer;
 mod completion_options;
 mod custom_completions;
+mod directory_completions;
 mod dotnu_completions;
 mod file_completions;
 mod flag_completions;
@@ -13,6 +14,7 @@ pub use command_completions::CommandCompletion;
 pub use completer::NuCompleter;
 pub use completion_options::{CompletionOptions, SortBy};
 pub use custom_completions::CustomCompletion;
+pub use directory_completions::DirectoryCompletion;
 pub use dotnu_completions::DotNuCompletion;
 pub use file_completions::{file_path_completion, partial_from, FileCompletion};
 pub use flag_completions::FlagCompletion;

crates/nu-cli/src/syntax_highlight.rs

@@ -178,6 +178,11 @@ impl Highlighter for NuHighlighter {
                     get_shape_color(shape.1.to_string(), &self.config),
                     next_token,
                 )),
+                FlatShape::Directory => output.push((
+                    // nushell Directory
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
                 FlatShape::GlobPattern => output.push((
                     // nushell GlobPattern
                     get_shape_color(shape.1.to_string(), &self.config),