Extract ps and sys subcrates. Move helper methods to UntaggedValue

crates/nu-protocol/src/lib.rs

@@ -18,7 +18,7 @@ pub use crate::signature::{NamedType, PositionalType, Signature};
 pub use crate::syntax_shape::SyntaxShape;
 pub use crate::type_name::{PrettyType, ShellTypeName, SpannedTypeName};
 pub use crate::value::column_path::{ColumnPath, PathMember, UnspannedPathMember};
-pub use crate::value::dict::Dictionary;
+pub use crate::value::dict::{Dictionary, TaggedDictBuilder};
 pub use crate::value::evaluate::{Evaluate, EvaluateTrait, Scope};
 pub use crate::value::primitive::Primitive;
 pub use crate::value::{UntaggedValue, Value};

crates/nu-protocol/src/value.rs

@@ -11,10 +11,15 @@ use crate::type_name::{ShellTypeName, SpannedTypeName};
 use crate::value::dict::Dictionary;
 use crate::value::evaluate::Evaluate;
 use crate::value::primitive::Primitive;
+use crate::{ColumnPath, PathMember};
+use bigdecimal::BigDecimal;
+use indexmap::IndexMap;
 use nu_errors::ShellError;
 use nu_source::{AnchorLocation, HasSpan, Span, Tag};
+use num_bigint::BigInt;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use std::time::SystemTime;
 
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Serialize, Deserialize)]
 pub enum UntaggedValue {
@@ -103,6 +108,69 @@ impl UntaggedValue {
             _ => panic!("expect_string assumes that the value must be a string"),
         }
     }
+
+    #[allow(unused)]
+    pub fn row(entries: IndexMap<String, Value>) -> UntaggedValue {
+        UntaggedValue::Row(entries.into())
+    }
+
+    pub fn table(list: &Vec<Value>) -> UntaggedValue {
+        UntaggedValue::Table(list.to_vec())
+    }
+
+    pub fn string(s: impl Into<String>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::String(s.into()))
+    }
+
+    pub fn line(s: impl Into<String>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Line(s.into()))
+    }
+
+    pub fn column_path(s: Vec<impl Into<PathMember>>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::ColumnPath(ColumnPath::new(
+            s.into_iter().map(|p| p.into()).collect(),
+        )))
+    }
+
+    pub fn int(i: impl Into<BigInt>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Int(i.into()))
+    }
+
+    pub fn pattern(s: impl Into<String>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::String(s.into()))
+    }
+
+    pub fn path(s: impl Into<PathBuf>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Path(s.into()))
+    }
+
+    pub fn bytes(s: impl Into<u64>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Bytes(s.into()))
+    }
+
+    pub fn decimal(s: impl Into<BigDecimal>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Decimal(s.into()))
+    }
+
+    pub fn binary(binary: Vec<u8>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Binary(binary))
+    }
+
+    pub fn boolean(s: impl Into<bool>) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Boolean(s.into()))
+    }
+
+    pub fn duration(secs: u64) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Duration(secs))
+    }
+
+    pub fn system_date(s: SystemTime) -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Date(s.into()))
+    }
+
+    pub fn nothing() -> UntaggedValue {
+        UntaggedValue::Primitive(Primitive::Nothing)
+    }
 }
 
 #[derive(Debug, Clone, PartialOrd, PartialEq, Ord, Eq, Serialize, Deserialize)]

crates/nu-protocol/src/value/dict.rs

@@ -138,3 +138,59 @@ impl Dictionary {
         self.entries.insert(name.to_string(), value);
     }
 }
+
+#[derive(Debug)]
+pub struct TaggedDictBuilder {
+    tag: Tag,
+    dict: IndexMap<String, Value>,
+}
+
+impl TaggedDictBuilder {
+    pub fn new(tag: impl Into<Tag>) -> TaggedDictBuilder {
+        TaggedDictBuilder {
+            tag: tag.into(),
+            dict: IndexMap::default(),
+        }
+    }
+
+    pub fn build(tag: impl Into<Tag>, block: impl FnOnce(&mut TaggedDictBuilder)) -> Value {
+        let mut builder = TaggedDictBuilder::new(tag);
+        block(&mut builder);
+        builder.into_value()
+    }
+
+    pub fn with_capacity(tag: impl Into<Tag>, n: usize) -> TaggedDictBuilder {
+        TaggedDictBuilder {
+            tag: tag.into(),
+            dict: IndexMap::with_capacity(n),
+        }
+    }
+
+    pub fn insert_untagged(&mut self, key: impl Into<String>, value: impl Into<UntaggedValue>) {
+        self.dict
+            .insert(key.into(), value.into().into_value(&self.tag));
+    }
+
+    pub fn insert_value(&mut self, key: impl Into<String>, value: impl Into<Value>) {
+        self.dict.insert(key.into(), value.into());
+    }
+
+    pub fn into_value(self) -> Value {
+        let tag = self.tag.clone();
+        self.into_untagged_value().into_value(tag)
+    }
+
+    pub fn into_untagged_value(self) -> UntaggedValue {
+        UntaggedValue::Row(Dictionary { entries: self.dict })
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.dict.is_empty()
+    }
+}
+
+impl From<TaggedDictBuilder> for Value {
+    fn from(input: TaggedDictBuilder) -> Value {
+        input.into_value()
+    }
+}

crates/nu_plugin_binaryview/Cargo.toml

@@ -7,13 +7,11 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-syntect = { version = "3.2.0" }
 ansi_term = "0.12.1"
 crossterm = { version = "0.10.2" }
 nu-protocol = { path = "../nu-protocol" }
 nu-source = { path = "../nu-source" }
 nu-errors = { path = "../nu-errors" }
-url = "2.1.0"
 pretty-hex = "0.1.1"
 image = { version = "0.22.2", default_features = false, features = ["png_codec", "jpeg"] }
 rawkey = "0.1.2"

crates/nu_plugin_ps/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "nu_plugin_ps"
+version = "0.1.0"
+authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>", "Andrés N. Robalino <andres@androbtech.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+nu-protocol = { path = "../nu-protocol" }
+nu-source = { path = "../nu-source" }
+nu-errors = { path = "../nu-errors" }
+futures-preview = { version = "=0.3.0-alpha.19", features = ["compat", "io-compat"] }
+heim = "0.0.8"
+futures-timer = "2.0.0"
+pin-utils = "0.1.0-alpha.4"
+
+[build-dependencies]
+nu-build = { version = "0.1.0", path = "../nu-build" }

crates/nu_plugin_ps/build.rs

@@ -0,0 +1,3 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    nu_build::build()
+}

crates/nu_plugin_ps/src/main.rs

@@ -0,0 +1,83 @@
+use futures::executor::block_on;
+use futures::stream::{StreamExt, TryStreamExt};
+
+use heim::process::{self as process, Process, ProcessResult};
+use heim::units::{ratio, Ratio};
+use std::usize;
+
+use nu_errors::ShellError;
+use nu_protocol::{
+    serve_plugin, CallInfo, Plugin, ReturnSuccess, ReturnValue, Signature, TaggedDictBuilder,
+    UntaggedValue, Value,
+};
+use nu_source::Tag;
+
+use std::time::Duration;
+
+struct Ps;
+impl Ps {
+    fn new() -> Ps {
+        Ps
+    }
+}
+
+async fn usage(process: Process) -> ProcessResult<(process::Process, Ratio)> {
+    let usage_1 = process.cpu_usage().await?;
+    futures_timer::Delay::new(Duration::from_millis(100)).await;
+    let usage_2 = process.cpu_usage().await?;
+
+    Ok((process, usage_2 - usage_1))
+}
+
+async fn ps(tag: Tag) -> Vec<Value> {
+    let processes = process::processes()
+        .map_ok(|process| {
+            // Note that there is no `.await` here,
+            // as we want to pass the returned future
+            // into the `.try_buffer_unordered`.
+            usage(process)
+        })
+        .try_buffer_unordered(usize::MAX);
+    pin_utils::pin_mut!(processes);
+
+    let mut output = vec![];
+    while let Some(res) = processes.next().await {
+        if let Ok((process, usage)) = res {
+            let mut dict = TaggedDictBuilder::new(&tag);
+            dict.insert_untagged("pid", UntaggedValue::int(process.pid()));
+            if let Ok(name) = process.name().await {
+                dict.insert_untagged("name", UntaggedValue::string(name));
+            }
+            if let Ok(status) = process.status().await {
+                dict.insert_untagged("status", UntaggedValue::string(format!("{:?}", status)));
+            }
+            dict.insert_untagged("cpu", UntaggedValue::decimal(usage.get::<ratio::percent>()));
+            output.push(dict.into_value());
+        }
+    }
+
+    output
+}
+
+impl Plugin for Ps {
+    fn config(&mut self) -> Result<Signature, ShellError> {
+        Ok(Signature::build("ps")
+            .desc("View information about system processes.")
+            .filter())
+    }
+
+    fn begin_filter(&mut self, callinfo: CallInfo) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(block_on(ps(callinfo.name_tag))
+            .into_iter()
+            .map(ReturnSuccess::value)
+            .collect())
+    }
+
+    fn filter(&mut self, _: Value) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(vec![])
+    }
+}
+
+fn main() {
+    serve_plugin(&mut Ps::new());
+}

crates/nu_plugin_sys/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "nu_plugin_sys"
+version = "0.1.0"
+authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>", "Andrés N. Robalino <andres@androbtech.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+nu-protocol = { path = "../nu-protocol" }
+nu-source = { path = "../nu-source" }
+nu-errors = { path = "../nu-errors" }
+futures-preview = { version = "=0.3.0-alpha.19", features = ["compat", "io-compat"] }
+heim = "0.0.8"
+futures-timer = "2.0.0"
+pin-utils = "0.1.0-alpha.4"
+battery = "0.7.4"
+
+[build-dependencies]
+nu-build = { version = "0.1.0", path = "../nu-build" }

crates/nu_plugin_sys/build.rs

@@ -0,0 +1,3 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    nu_build::build()
+}

crates/nu_plugin_sys/src/main.rs

@@ -0,0 +1,354 @@
+use std::ffi::OsStr;
+
+use futures::executor::block_on;
+use futures::stream::StreamExt;
+use heim::units::{frequency, information, thermodynamic_temperature, time};
+use heim::{disk, host, memory, net, sensors};
+use nu_errors::ShellError;
+use nu_protocol::{
+    serve_plugin, CallInfo, Plugin, ReturnSuccess, ReturnValue, Signature, TaggedDictBuilder,
+    UntaggedValue, Value,
+};
+use nu_source::Tag;
+
+struct Sys;
+impl Sys {
+    fn new() -> Sys {
+        Sys
+    }
+}
+
+async fn cpu(tag: Tag) -> Option<Value> {
+    match futures::future::try_join(heim::cpu::logical_count(), heim::cpu::frequency()).await {
+        Ok((num_cpu, cpu_speed)) => {
+            let mut cpu_idx = TaggedDictBuilder::with_capacity(tag, 4);
+            cpu_idx.insert_untagged("cores", UntaggedValue::int(num_cpu));
+
+            let current_speed =
+                (cpu_speed.current().get::<frequency::hertz>() as f64 / 1_000_000_000.0 * 100.0)
+                    .round()
+                    / 100.0;
+            cpu_idx.insert_untagged("current ghz", UntaggedValue::decimal(current_speed));
+
+            if let Some(min_speed) = cpu_speed.min() {
+                let min_speed =
+                    (min_speed.get::<frequency::hertz>() as f64 / 1_000_000_000.0 * 100.0).round()
+                        / 100.0;
+                cpu_idx.insert_untagged("min ghz", UntaggedValue::decimal(min_speed));
+            }
+
+            if let Some(max_speed) = cpu_speed.max() {
+                let max_speed =
+                    (max_speed.get::<frequency::hertz>() as f64 / 1_000_000_000.0 * 100.0).round()
+                        / 100.0;
+                cpu_idx.insert_untagged("max ghz", UntaggedValue::decimal(max_speed));
+            }
+
+            Some(cpu_idx.into_value())
+        }
+        Err(_) => None,
+    }
+}
+
+async fn mem(tag: Tag) -> Value {
+    let mut dict = TaggedDictBuilder::with_capacity(tag, 4);
+
+    let (memory_result, swap_result) =
+        futures::future::join(memory::memory(), memory::swap()).await;
+
+    if let Ok(memory) = memory_result {
+        dict.insert_untagged(
+            "total",
+            UntaggedValue::bytes(memory.total().get::<information::byte>()),
+        );
+        dict.insert_untagged(
+            "free",
+            UntaggedValue::bytes(memory.free().get::<information::byte>()),
+        );
+    }
+
+    if let Ok(swap) = swap_result {
+        dict.insert_untagged(
+            "swap total",
+            UntaggedValue::bytes(swap.total().get::<information::byte>()),
+        );
+        dict.insert_untagged(
+            "swap free",
+            UntaggedValue::bytes(swap.free().get::<information::byte>()),
+        );
+    }
+
+    dict.into_value()
+}
+
+async fn host(tag: Tag) -> Value {
+    let mut dict = TaggedDictBuilder::with_capacity(&tag, 6);
+
+    let (platform_result, uptime_result) =
+        futures::future::join(host::platform(), host::uptime()).await;
+
+    // OS
+    if let Ok(platform) = platform_result {
+        dict.insert_untagged("name", UntaggedValue::string(platform.system()));
+        dict.insert_untagged("release", UntaggedValue::string(platform.release()));
+        dict.insert_untagged("hostname", UntaggedValue::string(platform.hostname()));
+        dict.insert_untagged(
+            "arch",
+            UntaggedValue::string(platform.architecture().as_str()),
+        );
+    }
+
+    // Uptime
+    if let Ok(uptime) = uptime_result {
+        let mut uptime_dict = TaggedDictBuilder::with_capacity(&tag, 4);
+
+        let uptime = uptime.get::<time::second>().round() as i64;
+        let days = uptime / (60 * 60 * 24);
+        let hours = (uptime - days * 60 * 60 * 24) / (60 * 60);
+        let minutes = (uptime - days * 60 * 60 * 24 - hours * 60 * 60) / 60;
+        let seconds = uptime % 60;
+
+        uptime_dict.insert_untagged("days", UntaggedValue::int(days));
+        uptime_dict.insert_untagged("hours", UntaggedValue::int(hours));
+        uptime_dict.insert_untagged("mins", UntaggedValue::int(minutes));
+        uptime_dict.insert_untagged("secs", UntaggedValue::int(seconds));
+
+        dict.insert_value("uptime", uptime_dict);
+    }
+
+    // Users
+    let mut users = host::users();
+    let mut user_vec = vec![];
+    while let Some(user) = users.next().await {
+        if let Ok(user) = user {
+            user_vec.push(Value {
+                value: UntaggedValue::string(user.username()),
+                tag: tag.clone(),
+            });
+        }
+    }
+    let user_list = UntaggedValue::Table(user_vec);
+    dict.insert_untagged("users", user_list);
+
+    dict.into_value()
+}
+
+async fn disks(tag: Tag) -> Option<UntaggedValue> {
+    let mut output = vec![];
+    let mut partitions = disk::partitions_physical();
+    while let Some(part) = partitions.next().await {
+        if let Ok(part) = part {
+            let mut dict = TaggedDictBuilder::with_capacity(&tag, 6);
+            dict.insert_untagged(
+                "device",
+                UntaggedValue::string(
+                    part.device()
+                        .unwrap_or_else(|| OsStr::new("N/A"))
+                        .to_string_lossy(),
+                ),
+            );
+
+            dict.insert_untagged("type", UntaggedValue::string(part.file_system().as_str()));
+            dict.insert_untagged(
+                "mount",
+                UntaggedValue::string(part.mount_point().to_string_lossy()),
+            );
+
+            if let Ok(usage) = disk::usage(part.mount_point().to_path_buf()).await {
+                dict.insert_untagged(
+                    "total",
+                    UntaggedValue::bytes(usage.total().get::<information::byte>()),
+                );
+                dict.insert_untagged(
+                    "used",
+                    UntaggedValue::bytes(usage.used().get::<information::byte>()),
+                );
+                dict.insert_untagged(
+                    "free",
+                    UntaggedValue::bytes(usage.free().get::<information::byte>()),
+                );
+            }
+
+            output.push(dict.into_value());
+        }
+    }
+
+    if !output.is_empty() {
+        Some(UntaggedValue::Table(output))
+    } else {
+        None
+    }
+}
+
+async fn battery(tag: Tag) -> Option<UntaggedValue> {
+    let mut output = vec![];
+
+    if let Ok(manager) = battery::Manager::new() {
+        if let Ok(batteries) = manager.batteries() {
+            for battery in batteries {
+                if let Ok(battery) = battery {
+                    let mut dict = TaggedDictBuilder::new(&tag);
+                    if let Some(vendor) = battery.vendor() {
+                        dict.insert_untagged("vendor", UntaggedValue::string(vendor));
+                    }
+                    if let Some(model) = battery.model() {
+                        dict.insert_untagged("model", UntaggedValue::string(model));
+                    }
+                    if let Some(cycles) = battery.cycle_count() {
+                        dict.insert_untagged("cycles", UntaggedValue::int(cycles));
+                    }
+                    if let Some(time_to_full) = battery.time_to_full() {
+                        dict.insert_untagged(
+                            "mins to full",
+                            UntaggedValue::decimal(
+                                time_to_full.get::<battery::units::time::minute>(),
+                            ),
+                        );
+                    }
+                    if let Some(time_to_empty) = battery.time_to_empty() {
+                        dict.insert_untagged(
+                            "mins to empty",
+                            UntaggedValue::decimal(
+                                time_to_empty.get::<battery::units::time::minute>(),
+                            ),
+                        );
+                    }
+                    output.push(dict.into_value());
+                }
+            }
+        }
+    }
+
+    if !output.is_empty() {
+        Some(UntaggedValue::Table(output))
+    } else {
+        None
+    }
+}
+
+async fn temp(tag: Tag) -> Option<UntaggedValue> {
+    let mut output = vec![];
+
+    let mut sensors = sensors::temperatures();
+    while let Some(sensor) = sensors.next().await {
+        if let Ok(sensor) = sensor {
+            let mut dict = TaggedDictBuilder::new(&tag);
+            dict.insert_untagged("unit", UntaggedValue::string(sensor.unit()));
+            if let Some(label) = sensor.label() {
+                dict.insert_untagged("label", UntaggedValue::string(label));
+            }
+            dict.insert_untagged(
+                "temp",
+                UntaggedValue::decimal(
+                    sensor
+                        .current()
+                        .get::<thermodynamic_temperature::degree_celsius>(),
+                ),
+            );
+            if let Some(high) = sensor.high() {
+                dict.insert_untagged(
+                    "high",
+                    UntaggedValue::decimal(high.get::<thermodynamic_temperature::degree_celsius>()),
+                );
+            }
+            if let Some(critical) = sensor.critical() {
+                dict.insert_untagged(
+                    "critical",
+                    UntaggedValue::decimal(
+                        critical.get::<thermodynamic_temperature::degree_celsius>(),
+                    ),
+                );
+            }
+
+            output.push(dict.into_value());
+        }
+    }
+
+    if !output.is_empty() {
+        Some(UntaggedValue::Table(output))
+    } else {
+        None
+    }
+}
+
+async fn net(tag: Tag) -> Option<UntaggedValue> {
+    let mut output = vec![];
+    let mut io_counters = net::io_counters();
+    while let Some(nic) = io_counters.next().await {
+        if let Ok(nic) = nic {
+            let mut network_idx = TaggedDictBuilder::with_capacity(&tag, 3);
+            network_idx.insert_untagged("name", UntaggedValue::string(nic.interface()));
+            network_idx.insert_untagged(
+                "sent",
+                UntaggedValue::bytes(nic.bytes_sent().get::<information::byte>()),
+            );
+            network_idx.insert_untagged(
+                "recv",
+                UntaggedValue::bytes(nic.bytes_recv().get::<information::byte>()),
+            );
+            output.push(network_idx.into_value());
+        }
+    }
+    if !output.is_empty() {
+        Some(UntaggedValue::Table(output))
+    } else {
+        None
+    }
+}
+
+async fn sysinfo(tag: Tag) -> Vec<Value> {
+    let mut sysinfo = TaggedDictBuilder::with_capacity(&tag, 7);
+
+    let (host, cpu, disks, memory, temp) = futures::future::join5(
+        host(tag.clone()),
+        cpu(tag.clone()),
+        disks(tag.clone()),
+        mem(tag.clone()),
+        temp(tag.clone()),
+    )
+    .await;
+    let (net, battery) = futures::future::join(net(tag.clone()), battery(tag.clone())).await;
+
+    sysinfo.insert_value("host", host);
+    if let Some(cpu) = cpu {
+        sysinfo.insert_value("cpu", cpu);
+    }
+    if let Some(disks) = disks {
+        sysinfo.insert_untagged("disks", disks);
+    }
+    sysinfo.insert_value("mem", memory);
+    if let Some(temp) = temp {
+        sysinfo.insert_untagged("temp", temp);
+    }
+    if let Some(net) = net {
+        sysinfo.insert_untagged("net", net);
+    }
+    if let Some(battery) = battery {
+        sysinfo.insert_untagged("battery", battery);
+    }
+
+    vec![sysinfo.into_value()]
+}
+
+impl Plugin for Sys {
+    fn config(&mut self) -> Result<Signature, ShellError> {
+        Ok(Signature::build("sys")
+            .desc("View information about the current system.")
+            .filter())
+    }
+
+    fn begin_filter(&mut self, callinfo: CallInfo) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(block_on(sysinfo(callinfo.name_tag))
+            .into_iter()
+            .map(ReturnSuccess::value)
+            .collect())
+    }
+
+    fn filter(&mut self, _: Value) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(vec![])
+    }
+}
+
+fn main() {
+    serve_plugin(&mut Sys::new());
+}