Reorganized code for subcommand modularity

Author: josephrhobbs

Cargo.lock

@@ -1,21 +1,43 @@
+[workspace]
+resolver = "2"
+members = [
+    "carlotk",
+    "subcommands/repl",
+    "subcommands/latex",
+    "subcommands/version",
+    "subcommands/help",
+]
+
 [package]
 name = "carlo"
 description = "A simple interpreted programming language."
 license = "MIT"
 repository = "https://github.com/hobbsbros/carlo.git"
-version = "0.10.0"
+version = "0.11.0"
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[lib]
-name = "carlotk"
-path = "src/lib.rs"
-
 [[bin]]
 name = "carlo"
 path = "src/main.rs"
 
 [dependencies]
 colored = "2.1.0"
 rustyline = "13.0.0"
+
+[dependencies.carlotk]
+path = "./carlotk"
+
+[dependencies.help]
+path = "./subcommands/help"
+
+[dependencies.latex]
+path = "./subcommands/latex"
+
+[dependencies.run]
+path = "./subcommands/run"
+
+[dependencies.repl]
+path = "./subcommands/repl"
+
+[dependencies.version]
+path = "./subcommands/version"

Cargo.toml

@@ -13,19 +13,15 @@ version number.
 
 The following instructions will guide you to adding a Carlo langauge subcommand.
 
-1. Create `src/subcommands/your-new-subcommand.rs`.  Write a new function corresponding
-to your subcommand
+1. Create a Cargo library package in the `subcommands` directory with the name `sc`, where `sc` is your desired subcommand name.
 
-2. Open `src/main.rs`.  Add `Subcommand::YourNewSubcommand` to the `main` function match
-statement.
+2. Create a function in your subcommand library named `sc::sc`.  It is recommended that you import `carlotk::prelude::*` so you can use the Carlo tokenizer, parser, and environment utilities.  Your function must have the following signature: `fn(CliArgs) -> ()`.
 
-3. Open `src/lib.rs`.  Add `./subcommands/help_your-new-subcommand.txt` to the `HELP`
-hashmap.
+3. Create the following entry in `Cargo.toml`.
 
-4. Open `src/subcommands/mod.rs`.  Add `YourNewSubcommand` to the `Subcommand` enumeration.
-Add `"your-new-subcommand" => YourNewSubcommand` in the `From<&str>` trait implementation
-block.
+```
+[dependencies.sc]
+path = "./subcommands/sc"
+```
 
-5. Open `src/help.txt`.  Add `your-new-subcommand` to the help menu.
-
-6. Create a file called `src/subcommands/help_your-new-subcommand.txt`.  Add a help menu.
+4. In `src/main.rs`, add `subcommand sc` (on a new line) to the `include_subcommands!` macro invocation.

DEVELOPER_GUIDE.md

@@ -0,0 +1,15 @@
+[package]
+name = "carlotk"
+description = "The main library for Carlo, a simple interpreted programming language."
+license = "MIT"
+repository = "https://github.com/hobbsbros/carlo.git"
+version = "0.11.0"
+edition = "2021"
+
+[lib]
+name = "carlotk"
+path = "src/lib.rs"
+
+[dependencies]
+colored = "2.1.0"
+rustyline = "13.0.0"

carlotk/Cargo.toml

@@ -5,10 +5,7 @@ use std::{
     path::PathBuf,
 };
 
-use crate::{
-    Error,
-    Subcommand,
-};
+use crate::Error;
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 /// Flags for the Carlo language executable.
@@ -49,7 +46,7 @@ impl From<char> for Flag {
 /// Command-line arguments for the Carlo language executable.
 pub struct CliArgs {
     /// Executable subcommand
-    pub subcommand: Subcommand,
+    pub subcommand: String,
 
     /// Argument to subcommand
     pub argument: Option<String>,
@@ -71,15 +68,15 @@ impl CliArgs {
 
         // Parse subcommand
         let subcommand = if args.len() > 1 {
-            args[1].as_str().into()
+            args[1].to_owned()
         } else {
-            Subcommand::Repl
+            "repl".to_string()
         };
 
         // Parse argument or input file
-        if subcommand == Subcommand::Help && args.len() > 2 && !args[2].starts_with("-") {
+        if subcommand == "help" && args.len() > 2 && !args[2].starts_with("-") {
             argument = Some (args[2].to_owned());
-        } else if subcommand != Subcommand::Help && args.len() > 2 && !args[2].starts_with("-") {
+        } else if subcommand != "help" && args.len() > 2 && !args[2].starts_with("-") {
             inputfile = Some (args[2].as_str().into());
         }
 

src/binary_operation.rs carlotk/src/binary_operation.rs

@@ -6,7 +6,6 @@ mod environment;
 mod error;
 mod expression;
 mod parser;
-pub mod subcommands;
 mod tokenizer;
 mod unit;
 
@@ -44,23 +43,12 @@ pub use tokenizer::{
 
 pub use parser::Parser;
 
-pub use subcommands::Subcommand;
-
 pub use unit::{
     PREFIXES,
     UNITS,
 };
 
-pub const VERSION: &str = "0.10.0";
-
-pub const HELP: [(&str, &str); 6] = [
-    ("", include_str!("./help.txt")),
-    ("repl", include_str!("./subcommands/help_repl.txt")),
-    ("run", include_str!("./subcommands/help_run.txt")),
-    ("latex", include_str!("./subcommands/help_latex.txt")),
-    ("help", include_str!("./subcommands/help_help.txt")),
-    ("version", include_str!("./subcommands/help_version.txt")),
-];
+pub const VERSION: &str = "0.11.0";
 
 /// A prelude for writing subcommands.
 pub mod prelude {
@@ -75,9 +63,10 @@ pub mod prelude {
     pub use rustyline::DefaultEditor;
 
     pub use crate::{
+        CliArgs,
         Environment,
         Error,
-        HELP,
+        Flag,
         read,
         parse,
         Parser,
@@ -138,4 +127,18 @@ pub fn read(prompt: &str) -> String {
     };
 
     buffer.trim().to_owned()
+}
+
+#[macro_export]
+/// Includes subcommands in the Carlo binary.
+macro_rules! include_subcommands {
+    (
+        using $args: ident
+        $(subcommand $subcommand: ident)*
+    ) => {
+        match $args.subcommand.as_str() {
+            $( stringify!($subcommand) => $subcommand::$subcommand($args), )*
+            _ => repl::repl($args),
+        };
+    };
 }

src/cli.rs carlotk/src/cli.rs

@@ -2,34 +2,19 @@
 
 use carlotk::{
     CliArgs,
-    Flag,
-    Subcommand,
-    subcommands::*,
+    include_subcommands,
 };
 
 fn main() {
-    use Flag::*;
-    use Subcommand::*;
-
     let args = CliArgs::parse();
 
-    match args.subcommand {
-        Help => help(
-            &args.argument.clone().unwrap_or(String::new()),
-            args.contains(Interactive),
-        ),
-        Repl => repl(
-            args.inputfile.clone(),
-            args.contains(Debug),
-        ),
-        Run => run(
-            args.inputfile.clone(),
-            args.contains(Debug),
-        ),
-        Latex => latex(
-            args.inputfile.clone(),
-            args.contains(Debug),
-        ),
-        Version => version(),
+    include_subcommands!{
+        using args
+
+        subcommand run
+        subcommand repl
+        subcommand help
+        subcommand latex
+        subcommand version
     };
 }