Adding reserved commands

Adding some utility commands that will be reserved for tome's core
functionality:

- commands
- exec
- help
- tome

These help provide some utility functionality as laid out in
docs/proposals/0001-cli-design.md.

Author: toumorokoshi

Cargo.lock

@@ -7,6 +7,7 @@ license = "MIT"
 
 [dependencies]
 clap = { version = "3.0.7", features = ["derive"]}
+lazy_static = {}
 
 
 

Cargo.toml

@@ -13,4 +13,5 @@ import sys
 if len(sys.argv) > 1 and sys.argv[1] == "--complete":
     sys.stdout.write("file autocomplete example")
 else:
-    print("hello")
+    sys.stdout.write("file autocomplete example")
+    # print("hello")

example/file_example

@@ -0,0 +1,50 @@
+use super::help::help;
+use std::collections::HashMap;
+
+pub struct Command {
+    pub func: fn(&str, &[String]) -> Result<String, String>,
+    pub help_text: &'static str,
+}
+
+lazy_static! {
+    pub static ref BUILTIN_COMMANDS: HashMap<String, Command> = {
+        let mut m = HashMap::new();
+        m.insert(
+            "commands".to_owned(),
+            Command {
+                func: help_command as fn(&str, &[String]) -> Result<String, String>,
+                help_text: "print all commands",
+            },
+        );
+        m.insert(
+            "exec".to_owned(),
+            Command {
+                func: noop_command as fn(&str, &[String]) -> Result<String, String>,
+                help_text: "execute a command",
+            },
+        );
+        m.insert(
+            "help".to_owned(),
+            Command {
+                func: help_command as fn(&str, &[String]) -> Result<String, String>,
+                help_text: "print help for the command",
+            },
+        );
+        m.insert(
+            "tome".to_owned(),
+            Command {
+                func: noop_command as fn(&str, &[String]) -> Result<String, String>,
+                help_text: "currently a no-op. reserved namespace for future tome commands",
+            },
+        );
+        m
+    };
+}
+
+fn help_command(root: &str, _: &[String]) -> Result<String, String> {
+    help(root)
+}
+
+fn noop_command(_: &str, _: &[String]) -> Result<String, String> {
+    Ok("".to_owned())
+}

src/commands/builtins.rs

@@ -2,6 +2,7 @@ use super::super::{
     directory, script,
     types::{CommandType, TargetType},
 };
+use super::builtins::BUILTIN_COMMANDS;
 use std::{fs, io, path::PathBuf};
 
 pub fn complete(command_directory_path: &str, args: &[String]) -> Result<String, String> {
@@ -32,30 +33,37 @@ pub fn complete(command_directory_path: &str, args: &[String]) -> Result<String,
     let remaining_args: Vec<_> = args_peekable.collect();
     return match target_type {
         TargetType::Directory => {
-            let mut result = vec![];
-            let paths_raw: io::Result<_> = fs::read_dir(target.to_str().unwrap_or(""));
-            // TODO(zph) deftly fix panics when this code path is triggered with empty string: ie sc dir_example bar<TAB>
-            // current implementation avoids the panic but is crude.
+            let paths_raw: io::Result<_> = fs::read_dir(target.to_str().unwrap());
             let mut paths: Vec<_> = match paths_raw {
                 Err(_a) => return Err("Invalid argument to completion".to_string()),
                 Ok(a) => a,
             }
-            .map(|r| r.unwrap())
-            .collect();
-            paths.sort_by_key(|f| f.path());
-            for path_buf in paths {
-                let path = path_buf.path();
-                if path.is_dir() && !directory::is_tome_script_directory(&path) {
-                    continue;
+            .filter_map(|r| match r {
+                Ok(path_buf) => {
+                    let path = path_buf.path();
+                    if path.is_dir() && !directory::is_tome_script_directory(&path) {
+                        return None;
+                    }
+                    if path.is_file()
+                        && !script::is_tome_script(
+                            path_buf.file_name().to_str().unwrap_or_default(),
+                        )
+                    {
+                        return None;
+                    }
+                    Some(path.file_name().unwrap().to_str().unwrap_or("").to_owned())
                 }
-                if path.is_file()
-                    && !script::is_tome_script(path_buf.file_name().to_str().unwrap_or_default())
-                {
-                    continue;
+                Err(_) => None,
+            })
+            .collect();
+            // if this is the root directory, add the builtin commands
+            if target.to_str().unwrap() == command_directory_path {
+                for command in BUILTIN_COMMANDS.keys() {
+                    paths.push(command.to_owned());
                 }
-                result.push(path.file_name().unwrap().to_str().unwrap_or("").to_owned());
             }
-            Ok(result.join(" "))
+            paths.sort_by_key(|f| f.to_owned());
+            Ok(paths.join(" "))
         }
         TargetType::File => match script::Script::load(target.to_str().unwrap_or_default()) {
             Ok(script) => script.get_execution_body(CommandType::Completion, &remaining_args),

src/commands/complete.rs

@@ -2,7 +2,7 @@ use super::super::{
     script,
     types::{CommandType, TargetType},
 };
-use super::help;
+use super::{builtins::BUILTIN_COMMANDS, help};
 use std::path::PathBuf;
 
 pub fn execute(command_directory_path: &str, args: &[String]) -> Result<String, String> {
@@ -16,6 +16,16 @@ pub fn execute(command_directory_path: &str, args: &[String]) -> Result<String,
     if args_peekable.peek().is_none() {
         return help::help(command_directory_path);
     }
+    // special handling for root subcommmand for reserved
+    // commands
+    match args_peekable.peek() {
+        Some(&command_name) => match BUILTIN_COMMANDS.get(command_name) {
+            Some(command) => return (command.func)(command_directory_path, args),
+            None => {}
+        },
+        None => {}
+    }
+    // generic handling
     while let Some(arg) = args_peekable.peek() {
         target.push(arg);
         if target.is_file() {

src/commands/execute.rs

@@ -1,17 +1,30 @@
 use super::super::directory::scan_directory;
+use super::builtins::BUILTIN_COMMANDS;
 
 macro_rules! help_template {
     () => {
         r#"echo -e
 'This is an instance of tome, running against the directory {}.
 \nThe commands are namespaced by the directory structure.
+\nBuiltin commands available to all instance of tome are:
+\n    {}
 \nFull list of commands available are:
 \n    {}
 ';"#
     };
 }
 
 pub fn help(root: &str) -> Result<String, String> {
+    let mut builtins_with_help = vec![];
+    // print builtins first
+    for (command, command_struct) in BUILTIN_COMMANDS.iter() {
+        builtins_with_help.push(format!(
+            "    {}: {}",
+            escape_slashes(&command),
+            escape_slashes(&command_struct.help_text),
+        ))
+    }
+
     let mut commands_with_help = vec![];
     let commands_and_scripts = match scan_directory(root, &mut vec![]) {
         Ok(result) => result,
@@ -24,10 +37,12 @@ pub fn help(root: &str) -> Result<String, String> {
             escape_slashes(&script.summary_string)
         ))
     }
+
     Ok(format!(
         help_template!(),
         root,
-        commands_with_help.join("\\n")
+        builtins_with_help.join("\\n"),
+        commands_with_help.join("\\n"),
     ))
 }
 

src/commands/help.rs

@@ -1,3 +1,4 @@
+pub mod builtins;
 pub mod complete;
 pub mod execute;
 pub mod help;

src/commands/mod.rs

@@ -9,8 +9,8 @@ pub fn scan_directory(
     previous_commands: &mut Vec<String>,
 ) -> io::Result<Vec<(String, Script)>> {
     let mut result = vec![];
-    let mut paths: Vec<_> = read_dir(root).unwrap().map(|r| r.unwrap()).collect();
-    paths.sort_by_key(|f| f.path());
+    let paths: Vec<_> = read_dir(root).unwrap().map(|r| r.unwrap()).collect();
+    // paths.sort_by_key(|f| f.path());
     for entry in paths {
         let path = entry.path();
         previous_commands.push(

src/directory.rs

@@ -1,5 +1,8 @@
 use clap::Parser;
 
+#[macro_use]
+extern crate lazy_static;
+
 pub mod cli;
 pub mod commands;
 pub mod directory;