Internals cleanup and | select ...fields

src/commands.rs

@@ -3,6 +3,7 @@ crate mod cd;
 crate mod command;
 crate mod ls;
 crate mod ps;
+crate mod select;
 crate mod take;
 crate mod to_array;
 

src/commands/select.rs

@@ -0,0 +1,46 @@
+use crate::errors::ShellError;
+use crate::object::base::select;
+use crate::object::process::Process;
+use crate::object::{DirEntry, ShellObject, Value};
+use crate::prelude::*;
+use crate::Args;
+use derive_new::new;
+use std::path::{Path, PathBuf};
+use sysinfo::SystemExt;
+
+#[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>,
+}
+
+impl crate::Command for Select {
+    fn run(&mut self, stream: VecDeque<Value>) -> Result<VecDeque<ReturnValue>, ShellError> {
+        let objects = stream
+            .iter()
+            .map(|item| Value::Object(Box::new(select(item, &self.fields))))
+            .map(|item| ReturnValue::Value(item))
+            .collect();
+
+        Ok(objects)
+    }
+}

src/errors.rs

@@ -1,3 +1,4 @@
+use crate::prelude::*;
 use crate::Value;
 use derive_new::new;
 
@@ -11,6 +12,13 @@ impl ShellError {
     crate fn string(title: impl Into<String>) -> ShellError {
         ShellError::new(title.into(), Value::nothing())
     }
+
+    crate fn copy_error(&self) -> ShellError {
+        ShellError {
+            title: self.title.clone(),
+            error: self.error.copy(),
+        }
+    }
 }
 
 impl std::fmt::Display for ShellError {

src/format/generic.rs

@@ -13,7 +13,7 @@ pub struct GenericView<'value> {
 impl RenderView for GenericView<'value> {
     fn render_view(&self, host: &dyn Host) -> Vec<String> {
         match self.value {
-            Value::Primitive(p) => vec![p.format()],
+            Value::Primitive(p) => vec![p.format(None)],
             Value::List(l) => {
                 let view = TableView::from_list(l);
 
@@ -43,6 +43,8 @@ impl RenderView for GenericView<'value> {
                 let out = view.render_view(host);
                 out
             }
+
+            Value::Error(e) => vec![format!("{}", e)],
         }
     }
 }

src/format/table.rs

@@ -25,14 +25,15 @@ impl TableView {
         let item = &values[0];
         let descs = item.data_descriptors();
 
-        let headers = descs.iter().map(|d| d.name.clone()).collect();
+        let headers: Vec<String> = descs.iter().map(|d| d.name.clone()).collect();
 
         let mut entries = vec![];
 
         for value in values {
             let row = descs
                 .iter()
-                .map(|d| value.get_data(d).borrow().format_leaf())
+                .enumerate()
+                .map(|(i, d)| value.get_data(d).borrow().format_leaf(Some(&headers[i])))
                 .collect();
 
             entries.push(row);

src/main.rs

@@ -66,6 +66,7 @@ fn main() -> Result<(), Box<Error>> {
             ("ls", Box::new(ls::LsBlueprint)),
             ("cd", Box::new(cd::CdBlueprint)),
             ("take", Box::new(take::TakeBlueprint)),
+            ("select", Box::new(select::SelectBlueprint)),
             ("to-array", Box::new(to_array::ToArrayBlueprint)),
         ]);
     }

src/object/base.rs

@@ -1,28 +1,49 @@
 use crate::errors::ShellError;
 use crate::format::{EntriesView, GenericView};
 use crate::object::desc::DataDescriptor;
-use chrono::NaiveDateTime;
+use chrono::{DateTime, Utc};
+use chrono_humanize::Humanize;
 use std::fmt::Debug;
+use std::time::SystemTime;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Primitive {
     Nothing,
     Int(i64),
     Float(f64),
+    Bytes(u128),
     String(String),
     Boolean(bool),
-    Date(NaiveDateTime),
+    Date(DateTime<Utc>),
 }
 
 impl Primitive {
-    crate fn format(&self) -> String {
+    crate fn format(&self, field_name: Option<&str>) -> String {
         match self {
             Primitive::Nothing => format!("Nothing"),
+            Primitive::Bytes(b) => {
+                let byte = byte_unit::Byte::from_bytes(*b);
+                let byte = byte.get_appropriate_unit(true);
+
+                match byte.get_unit() {
+                    byte_unit::ByteUnit::B => format!("{}", byte.format(0)),
+                    _ => format!("{}", byte.format(1)),
+                }
+            }
             Primitive::Int(i) => format!("{}", i),
             Primitive::Float(f) => format!("{}", f),
-            Primitive::String(s) => format!("{:?}", s),
-            Primitive::Boolean(b) => format!("{:?}", b),
-            Primitive::Date(d) => format!("{}", d),
+            Primitive::String(s) => format!("{}", s),
+            Primitive::Boolean(b) => match (b, field_name) {
+                (true, None) => format!("Yes"),
+                (false, None) => format!("No"),
+                (true, Some(s)) => format!("{}", s),
+                (false, Some(s)) => format!(""),
+            },
+            Primitive::Date(d) => {
+                // let date = d.format("%-m/%-d/%-y");
+                // let time =
+                format!("{}", d.humanize())
+            }
         }
     }
 }
@@ -32,14 +53,16 @@ pub enum Value {
     Primitive(Primitive),
     Object(Box<dyn ShellObject>),
     List(Vec<Value>),
+    Error(Box<ShellError>),
 }
 
 impl ShellObject for Value {
     fn to_shell_string(&self) -> String {
         match self {
-            Value::Primitive(p) => p.format(),
+            Value::Primitive(p) => p.format(None),
             Value::Object(o) => o.to_shell_string(),
             Value::List(l) => format!("[list List]"),
+            Value::Error(e) => format!("{}", e),
         }
     }
 
@@ -48,6 +71,7 @@ impl ShellObject for Value {
             Value::Primitive(p) => vec![],
             Value::Object(o) => o.data_descriptors(),
             Value::List(l) => vec![],
+            Value::Error(e) => vec![],
         }
     }
 
@@ -56,16 +80,45 @@ impl ShellObject for Value {
             Value::Primitive(p) => crate::MaybeOwned::Owned(Value::nothing()),
             Value::Object(o) => o.get_data(desc),
             Value::List(l) => crate::MaybeOwned::Owned(Value::nothing()),
+            Value::Error(e) => crate::MaybeOwned::Owned(Value::nothing()),
+        }
+    }
+
+    fn copy(&self) -> Value {
+        match self {
+            Value::Primitive(p) => Value::Primitive(p.clone()),
+            Value::Object(o) => Value::Object(Box::new(o.copy())),
+            Value::List(l) => {
+                let list = l.iter().map(|i| i.copy()).collect();
+                Value::List(list)
+            }
+            Value::Error(e) => Value::Error(Box::new(e.copy_error())),
         }
     }
 }
 
+impl ShellObject for &Value {
+    fn to_shell_string(&self) -> String {
+        (*self).to_shell_string()
+    }
+    fn data_descriptors(&self) -> Vec<DataDescriptor> {
+        (*self).data_descriptors()
+    }
+    fn get_data(&'a self, desc: &DataDescriptor) -> crate::MaybeOwned<'a, Value> {
+        (*self).get_data(desc)
+    }
+    fn copy(&self) -> Value {
+        (*self).copy()
+    }
+}
+
 impl Value {
-    crate fn format_leaf(&self) -> String {
+    crate fn format_leaf(&self, field_name: Option<&str>) -> String {
         match self {
-            Value::Primitive(p) => p.format(),
+            Value::Primitive(p) => p.format(field_name),
             Value::Object(o) => format!("[object Object]"),
             Value::List(l) => format!("[list List]"),
+            Value::Error(e) => format!("{}", e),
         }
     }
 
@@ -96,10 +149,25 @@ impl Value {
         Value::Primitive(Primitive::String(s.into()))
     }
 
+    crate fn bytes(s: impl Into<u128>) -> Value {
+        Value::Primitive(Primitive::Bytes(s.into()))
+    }
+
     crate fn int(s: impl Into<i64>) -> Value {
         Value::Primitive(Primitive::Int(s.into()))
     }
 
+    crate fn system_date(s: SystemTime) -> Value {
+        Value::Primitive(Primitive::Date(s.into()))
+    }
+
+    crate fn system_date_result(s: Result<SystemTime, std::io::Error>) -> Value {
+        match s {
+            Ok(time) => Value::Primitive(Primitive::Date(time.into())),
+            Err(err) => Value::Error(Box::new(ShellError::string(format!("{}", err)))),
+        }
+    }
+
     crate fn boolean(s: impl Into<bool>) -> Value {
         Value::Primitive(Primitive::Boolean(s.into()))
     }
@@ -121,6 +189,22 @@ pub trait ShellObject: Debug {
     fn to_shell_string(&self) -> String;
     fn data_descriptors(&self) -> Vec<DataDescriptor>;
     fn get_data(&'a self, desc: &DataDescriptor) -> crate::MaybeOwned<'a, Value>;
+    fn copy(&self) -> Value;
+}
+
+crate fn select(obj: impl ShellObject, fields: &[String]) -> crate::object::Dictionary {
+    let mut out = crate::object::Dictionary::default();
+
+    let descs = obj.data_descriptors();
+
+    for field in fields {
+        match descs.iter().find(|d| d.name == *field) {
+            None => out.add(field.to_string(), Value::nothing()),
+            Some(desc) => out.add(field.to_string(), obj.get_data(desc).borrow().copy()),
+        }
+    }
+
+    out
 }
 
 pub trait ToEntriesView {
@@ -139,9 +223,10 @@ where
             let value = self.get_data(&desc);
 
             let formatted_value = match value.borrow() {
-                Value::Primitive(p) => p.format(),
+                Value::Primitive(p) => p.format(None),
                 Value::Object(o) => format!("[object Object]"),
                 Value::List(l) => format!("[object List]"),
+                Value::Error(e) => format!("{}", e),
             };
 
             entries.push((desc.name.clone(), formatted_value))
@@ -162,6 +247,10 @@ impl ShellObject for Box<dyn ShellObject> {
     fn get_data(&'a self, desc: &DataDescriptor) -> crate::MaybeOwned<'a, Value> {
         (**self).get_data(desc)
     }
+
+    fn copy(&self) -> Value {
+        (**self).copy()
+    }
 }
 
 pub trait ToGenericView {

src/object/dict.rs

@@ -1,20 +1,31 @@
 use crate::object::desc::DataDescriptor;
 use crate::object::{Primitive, Value};
+use crate::prelude::*;
 use crate::MaybeOwned;
 use derive_new::new;
+use indexmap::IndexMap;
 use std::cell::RefCell;
-use std::collections::BTreeMap;
 use std::rc::Rc;
 
 #[derive(Debug, Default)]
 pub struct Dictionary {
-    entries: BTreeMap<String, Value>,
+    entries: IndexMap<String, Value>,
 }
 
 impl Dictionary {
     crate fn add(&mut self, name: impl Into<String>, value: Value) {
         self.entries.insert(name.into(), value);
     }
+
+    crate fn copy_dict(&self) -> Dictionary {
+        let mut out = Dictionary::default();
+
+        for (key, value) in self.entries.iter() {
+            out.add(key.clone(), value.copy());
+        }
+
+        out
+    }
 }
 
 impl crate::object::ShellObject for Dictionary {
@@ -37,37 +48,8 @@ impl crate::object::ShellObject for Dictionary {
             None => MaybeOwned::Owned(Value::Primitive(Primitive::Nothing)),
         }
     }
-}
 
-#[derive(Debug, Default)]
-pub struct ScopedDictionary<'parent> {
-    entries: BTreeMap<String, MaybeOwned<'parent, Value>>,
-}
-
-impl ScopedDictionary<'parent> {
-    crate fn add(&mut self, name: impl Into<String>, value: impl Into<MaybeOwned<'parent, Value>>) {
-        self.entries.insert(name.into(), value.into());
-    }
-}
-
-impl crate::object::ShellObject for ScopedDictionary<'parent> {
-    fn to_shell_string(&self) -> String {
-        format!("[object Object] lol")
-    }
-
-    fn data_descriptors(&self) -> Vec<DataDescriptor> {
-        self.entries
-            .iter()
-            .map(|(name, value)| {
-                DataDescriptor::new(name.clone(), true, Box::new(crate::object::types::AnyShell))
-            })
-            .collect()
-    }
-
-    fn get_data(&'a self, desc: &DataDescriptor) -> MaybeOwned<'a, Value> {
-        match self.entries.get(&desc.name) {
-            Some(v) => MaybeOwned::Borrowed(v.borrow()),
-            None => MaybeOwned::Owned(Value::Primitive(Primitive::Nothing)),
-        }
+    fn copy(&self) -> Value {
+        Value::Object(Box::new(self.copy_dict()))
     }
 }

src/object/files.rs

@@ -4,13 +4,12 @@ use crate::MaybeOwned;
 
 #[derive(Debug)]
 pub struct DirEntry {
-    inner: std::fs::DirEntry,
     dict: Dictionary,
 }
 
 #[derive(Debug)]
 pub enum FileType {
-    Dir,
+    Directory,
     File,
     Symlink,
 }
@@ -19,26 +18,34 @@ impl DirEntry {
     crate fn new(inner: std::fs::DirEntry) -> Result<DirEntry, ShellError> {
         let mut dict = Dictionary::default();
         let filename = inner.file_name();
-        dict.add("file_name", Value::string(filename.to_string_lossy()));
+        dict.add("file name", Value::string(filename.to_string_lossy()));
 
         let metadata = inner.metadata()?;
         // let file_type = inner.file_type()?;
 
         let kind = if metadata.is_dir() {
-            FileType::Dir
+            FileType::Directory
         } else if metadata.is_file() {
             FileType::File
         } else {
             FileType::Symlink
         };
 
-        dict.add("file_type", Value::string(format!("{:?}", kind)));
+        dict.add("file type", Value::string(format!("{:?}", kind)));
         dict.add(
             "readonly",
             Value::boolean(metadata.permissions().readonly()),
         );
 
-        Ok(DirEntry { inner, dict })
+        dict.add("size", Value::bytes(metadata.len() as u128));
+
+        dict.add("created", Value::system_date_result(metadata.created()));
+        dict.add("accessed", Value::system_date_result(metadata.accessed()));
+        dict.add("modified", Value::system_date_result(metadata.modified()));
+
+        // dict.add("created_at", Value::date())
+
+        Ok(DirEntry { dict })
     }
 }
 
@@ -54,4 +61,12 @@ impl ShellObject for DirEntry {
     fn get_data(&'a self, desc: &DataDescriptor) -> MaybeOwned<'a, Value> {
         self.dict.get_data(desc)
     }
+
+    fn copy(&self) -> Value {
+        let copy = DirEntry {
+            dict: self.dict.copy_dict(),
+        };
+
+        Value::Object(Box::new(copy))
+    }
 }

src/object/process.rs

@@ -8,7 +8,6 @@ use sysinfo::ProcessExt;
 
 #[derive(Debug)]
 pub struct Process {
-    inner: sysinfo::Process,
     dict: Dictionary,
 }
 
@@ -29,13 +28,13 @@ impl Process {
         dict.add("pid", Value::int(inner.pid() as i64));
         dict.add("status", Value::int(inner.status() as i64));
 
-        Process { inner, dict }
+        Process { dict }
     }
 }
 
 impl ShellObject for Process {
     fn to_shell_string(&self) -> String {
-        format!("{} - {}", self.inner.name(), self.inner.pid())
+        format!("Process")
     }
 
     fn data_descriptors(&self) -> Vec<DataDescriptor> {
@@ -45,4 +44,10 @@ impl ShellObject for Process {
     fn get_data(&'a self, desc: &DataDescriptor) -> MaybeOwned<'a, Value> {
         self.dict.get_data(desc)
     }
+
+    fn copy(&self) -> Value {
+        let copy = self.dict.copy_dict();
+
+        Value::Object(Box::new(copy))
+    }
 }

src/prelude.rs

@@ -3,5 +3,5 @@ crate use crate::commands::command::{Command, CommandAction, CommandBlueprint, R
 crate use crate::env::{Environment, Host};
 crate use crate::errors::ShellError;
 crate use crate::format::RenderView;
-crate use crate::object::{Primitive, Value};
+crate use crate::object::{Primitive, ShellObject, Value};
 crate use std::collections::VecDeque;