Simplify commands

src/commands/cd.rs

@@ -1,42 +1,22 @@
 use crate::errors::ShellError;
-use crate::object::Value;
 use crate::prelude::*;
 use derive_new::new;
-use std::path::PathBuf;
 
 #[derive(new)]
-pub struct CdBlueprint;
+pub struct Cd;
 
-impl crate::CommandBlueprint for CdBlueprint {
-    fn create(
-        &self,
-        args: Vec<Value>,
-        _host: &dyn Host,
-        env: &mut Environment,
-    ) -> Result<Box<dyn Command>, ShellError> {
-        let target = match args.first() {
+impl crate::Command for Cd {
+    fn run(&self, args: CommandArgs<'caller>) -> Result<VecDeque<ReturnValue>, ShellError> {
+        let target = match args.args.first() {
             // TODO: This needs better infra
             None => return Err(ShellError::string(format!("cd must take one arg"))),
             Some(v) => v.as_string()?.clone(),
         };
 
-        Ok(Box::new(Cd {
-            cwd: env.cwd().to_path_buf(),
-            target,
-        }))
-    }
-}
+        let cwd = args.env.cwd().to_path_buf();
 
-#[derive(new)]
-pub struct Cd {
-    cwd: PathBuf,
-    target: String,
-}
-
-impl crate::Command for Cd {
-    fn run(&mut self, _stream: VecDeque<Value>) -> Result<VecDeque<ReturnValue>, ShellError> {
         let mut stream = VecDeque::new();
-        let path = dunce::canonicalize(self.cwd.join(&self.target).as_path())?;
+        let path = dunce::canonicalize(cwd.join(&target).as_path())?;
         stream.push_back(ReturnValue::change_cwd(path));
         Ok(stream)
     }

src/commands/command.rs

@@ -3,6 +3,13 @@ use crate::object::Value;
 use crate::prelude::*;
 use std::path::PathBuf;
 
+pub struct CommandArgs<'caller> {
+    pub host: &'caller dyn Host,
+    pub env: &'caller crate::Environment,
+    pub args: Vec<Value>,
+    pub input: VecDeque<Value>,
+}
+
 pub trait CommandBlueprint {
     fn create(
         &self,
@@ -36,5 +43,5 @@ impl ReturnValue {
 }
 
 pub trait Command {
-    fn run(&mut self, stream: VecDeque<Value>) -> Result<VecDeque<ReturnValue>, ShellError>;
+    fn run(&self, args: CommandArgs<'caller>) -> Result<VecDeque<ReturnValue>, ShellError>;
 }

src/commands/ls.rs

@@ -1,35 +1,17 @@
 use crate::errors::ShellError;
 use crate::object::{dir_entry_dict, Value};
 use crate::prelude::*;
-use crate::Command;
 use derive_new::new;
-use std::path::PathBuf;
 
 #[derive(new)]
-pub struct LsBlueprint;
-
-impl crate::CommandBlueprint for LsBlueprint {
-    fn create(
-        &self,
-        _args: Vec<Value>,
-        _host: &dyn crate::Host,
-        env: &mut crate::Environment,
-    ) -> Result<Box<dyn Command>, ShellError> {
-        Ok(Box::new(Ls {
-            cwd: env.cwd().to_path_buf(),
-        }))
-    }
-}
-
-#[derive(new)]
-pub struct Ls {
-    cwd: PathBuf,
-}
+pub struct Ls;
 
 impl crate::Command for Ls {
-    fn run(&mut self, _stream: VecDeque<Value>) -> Result<VecDeque<ReturnValue>, ShellError> {
+    fn run(&self, args: CommandArgs<'value>) -> Result<VecDeque<ReturnValue>, ShellError> {
+        let cwd = args.env.cwd().to_path_buf();
+
         let entries =
-            std::fs::read_dir(&self.cwd).map_err(|e| ShellError::string(format!("{:?}", e)))?;
+            std::fs::read_dir(&cwd).map_err(|e| ShellError::string(format!("{:?}", e)))?;
 
         let mut shell_entries = VecDeque::new();
 

src/commands/ps.rs

@@ -2,29 +2,14 @@ use crate::errors::ShellError;
 use crate::object::process::process_dict;
 use crate::object::Value;
 use crate::prelude::*;
-use crate::Command;
 use derive_new::new;
 use sysinfo::SystemExt;
 
-#[derive(new)]
-pub struct PsBlueprint;
-
-impl crate::CommandBlueprint for PsBlueprint {
-    fn create(
-        &self,
-        _args: Vec<Value>,
-        _host: &dyn crate::Host,
-        _env: &mut crate::Environment,
-    ) -> Result<Box<dyn Command>, ShellError> {
-        Ok(Box::new(Ps::new()))
-    }
-}
-
 #[derive(new)]
 pub struct Ps;
 
 impl crate::Command for Ps {
-    fn run(&mut self, _stream: VecDeque<Value>) -> Result<VecDeque<ReturnValue>, ShellError> {
+    fn run(&self, _args: CommandArgs<'caller>) -> Result<VecDeque<ReturnValue>, ShellError> {
         let mut system = sysinfo::System::new();
         system.refresh_all();
 

src/commands/reject.rs

@@ -5,35 +5,21 @@ use crate::prelude::*;
 use derive_new::new;
 
 #[derive(new)]
-pub struct RejectBlueprint;
-
-impl crate::CommandBlueprint for RejectBlueprint {
-    fn create(
-        &self,
-        args: Vec<Value>,
-        _host: &dyn Host,
-        _env: &mut Environment,
-    ) -> Result<Box<dyn Command>, ShellError> {
-        if args.is_empty() {
-            return Err(ShellError::string("take requires an integer"));
-        }
-
-        let fields: Result<_, _> = args.iter().map(|a| a.as_string()).collect();
-
-        Ok(Box::new(Reject { fields: fields? }))
-    }
-}
-
-#[derive(new)]
-pub struct Reject {
-    fields: Vec<String>,
-}
+pub struct Reject;
 
 impl crate::Command for Reject {
-    fn run(&mut self, stream: VecDeque<Value>) -> Result<VecDeque<ReturnValue>, ShellError> {
-        let objects = stream
+    fn run(&self, args: CommandArgs<'value>) -> Result<VecDeque<ReturnValue>, ShellError> {
+        if args.args.is_empty() {
+            return Err(ShellError::string("select requires a field"));
+        }
+
+        let fields: Result<Vec<String>, _> = args.args.iter().map(|a| a.as_string()).collect();
+        let fields = fields?;
+
+        let objects = args
+            .input
             .iter()
-            .map(|item| Value::Object(reject(item, &self.fields)))
+            .map(|item| Value::Object(reject(item, &fields)))
             .map(|item| ReturnValue::Value(item))
             .collect();
 

src/commands/select.rs

@@ -5,35 +5,21 @@ use crate::prelude::*;
 use derive_new::new;
 
 #[derive(new)]
-pub struct SelectBlueprint;
-
-impl crate::CommandBlueprint for SelectBlueprint {
-    fn create(
-        &self,
-        args: Vec<Value>,
-        _host: &dyn Host,
-        _env: &mut Environment,
-    ) -> Result<Box<dyn Command>, ShellError> {
-        if args.is_empty() {
-            return Err(ShellError::string("take requires an integer"));
-        }
-
-        let fields: Result<_, _> = args.iter().map(|a| a.as_string()).collect();
-
-        Ok(Box::new(Select { fields: fields? }))
-    }
-}
-
-#[derive(new)]
-pub struct Select {
-    fields: Vec<String>,
-}
+pub struct Select;
 
 impl crate::Command for Select {
-    fn run(&mut self, stream: VecDeque<Value>) -> Result<VecDeque<ReturnValue>, ShellError> {
-        let objects = stream
+    fn run(&self, args: CommandArgs<'caller>) -> Result<VecDeque<ReturnValue>, ShellError> {
+        if args.args.is_empty() {
+            return Err(ShellError::string("select requires a field"));
+        }
+
+        let fields: Result<Vec<String>, _> = args.args.iter().map(|a| a.as_string()).collect();
+        let fields = fields?;
+
+        let objects = args
+            .input
             .iter()
-            .map(|item| Value::Object(select(item, &self.fields)))
+            .map(|item| Value::Object(select(item, &fields)))
             .map(|item| ReturnValue::Value(item))
             .collect();
 

src/commands/take.rs

@@ -1,42 +1,24 @@
 use crate::errors::ShellError;
-use crate::object::Value;
 use crate::prelude::*;
 use derive_new::new;
 
 #[derive(new)]
-pub struct TakeBlueprint;
+pub struct Take;
 
-impl crate::CommandBlueprint for TakeBlueprint {
-    fn create(
-        &self,
-        args: Vec<Value>,
-        _host: &dyn Host,
-        _env: &mut Environment,
-    ) -> Result<Box<dyn Command>, ShellError> {
-        if args.is_empty() {
-            return Err(ShellError::string("take requires an integer"));
-        }
-
-        let amount = args[0].as_int()?;
-
-        Ok(Box::new(Take { amount }))
-    }
-}
-
-#[derive(new)]
-pub struct Take {
-    amount: i64,
-}
+// TODO: "Amount remaining" wrapper
 
 impl crate::Command for Take {
-    fn run(&mut self, stream: VecDeque<Value>) -> Result<VecDeque<ReturnValue>, ShellError> {
-        let amount = if stream.len() > self.amount as usize {
-            self.amount as usize
+    fn run(&self, args: CommandArgs<'caller>) -> Result<VecDeque<ReturnValue>, ShellError> {
+        let amount = args.args[0].as_int()?;
+
+        let amount = if args.input.len() > amount as usize {
+            amount as usize
         } else {
-            stream.len()
+            args.input.len()
         };
 
-        let out: VecDeque<ReturnValue> = stream
+        let out: VecDeque<ReturnValue> = args
+            .input
             .into_iter()
             .take(amount)
             .map(|v| ReturnValue::Value(v))

src/commands/to_array.rs

@@ -3,26 +3,12 @@ use crate::object::Value;
 use crate::prelude::*;
 use derive_new::new;
 
-#[derive(new)]
-pub struct ToArrayBlueprint;
-
-impl crate::CommandBlueprint for ToArrayBlueprint {
-    fn create(
-        &self,
-        _args: Vec<Value>,
-        _host: &dyn Host,
-        _env: &mut Environment,
-    ) -> Result<Box<dyn Command>, ShellError> {
-        Ok(Box::new(ToArray))
-    }
-}
-
 #[derive(new)]
 pub struct ToArray;
 
 impl crate::Command for ToArray {
-    fn run(&mut self, stream: VecDeque<Value>) -> Result<VecDeque<ReturnValue>, ShellError> {
-        let out = stream.into_iter().collect();
+    fn run(&self, args: CommandArgs<'caller>) -> Result<VecDeque<ReturnValue>, ShellError> {
+        let out = args.input.into_iter().collect();
         Ok(ReturnValue::single(Value::List(out)))
     }
 }