Move the remainder of the plugins to crates

crates/nu_plugin_sum/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "nu_plugin_sum"
+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" }
+
+[build-dependencies]
+nu-build = { version = "0.1.0", path = "../nu-build" }

crates/nu_plugin_sum/build.rs

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

crates/nu_plugin_sum/src/main.rs

@@ -0,0 +1,95 @@
+use nu_errors::ShellError;
+use nu_protocol::{
+    serve_plugin, CallInfo, Plugin, Primitive, ReturnSuccess, ReturnValue, Signature,
+    UntaggedValue, Value,
+};
+
+struct Sum {
+    total: Option<Value>,
+}
+impl Sum {
+    fn new() -> Sum {
+        Sum { total: None }
+    }
+
+    fn sum(&mut self, value: Value) -> Result<(), ShellError> {
+        match &value.value {
+            UntaggedValue::Primitive(Primitive::Nothing) => Ok(()),
+            UntaggedValue::Primitive(Primitive::Int(i)) => {
+                match &self.total {
+                    Some(Value {
+                        value: UntaggedValue::Primitive(Primitive::Int(j)),
+                        tag,
+                    }) => {
+                        //TODO: handle overflow
+                        self.total = Some(UntaggedValue::int(i + j).into_value(tag));
+                        Ok(())
+                    }
+                    None => {
+                        self.total = Some(value.clone());
+                        Ok(())
+                    }
+                    _ => Err(ShellError::labeled_error(
+                        "Could not sum non-integer or unrelated types",
+                        "source",
+                        value.tag,
+                    )),
+                }
+            }
+            UntaggedValue::Primitive(Primitive::Bytes(b)) => {
+                match &self.total {
+                    Some(Value {
+                        value: UntaggedValue::Primitive(Primitive::Bytes(j)),
+                        tag,
+                    }) => {
+                        //TODO: handle overflow
+                        self.total = Some(UntaggedValue::bytes(b + j).into_value(tag));
+                        Ok(())
+                    }
+                    None => {
+                        self.total = Some(value);
+                        Ok(())
+                    }
+                    _ => Err(ShellError::labeled_error(
+                        "Could not sum non-integer or unrelated types",
+                        "source",
+                        value.tag,
+                    )),
+                }
+            }
+            x => Err(ShellError::labeled_error(
+                format!("Unrecognized type in stream: {:?}", x),
+                "source",
+                value.tag,
+            )),
+        }
+    }
+}
+
+impl Plugin for Sum {
+    fn config(&mut self) -> Result<Signature, ShellError> {
+        Ok(Signature::build("sum")
+            .desc("Sum a column of values.")
+            .filter())
+    }
+
+    fn begin_filter(&mut self, _: CallInfo) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(vec![])
+    }
+
+    fn filter(&mut self, input: Value) -> Result<Vec<ReturnValue>, ShellError> {
+        self.sum(input)?;
+        Ok(vec![])
+    }
+
+    fn end_filter(&mut self) -> Result<Vec<ReturnValue>, ShellError> {
+        match self.total {
+            None => Ok(vec![]),
+            Some(ref v) => Ok(vec![ReturnSuccess::value(v.clone())]),
+        }
+    }
+}
+
+fn main() {
+    serve_plugin(&mut Sum::new());
+}