Move the remainder of the plugins to crates

crates/nu-protocol/Cargo.toml

@@ -26,6 +26,9 @@ nom_locate = "1.0.0"
 nom-tracable = "0.4.1"
 typetag = "0.1.4"
 query_interface = "0.3.5"
+byte-unit = "3.0.3"
+chrono-humanize = "0.0.11"
+natural = "0.3.0"
 
 # implement conversions
 subprocess = "0.1.18"

crates/nu-protocol/src/lib.rs

@@ -17,8 +17,9 @@ pub use crate::return_value::{CommandAction, ReturnSuccess, ReturnValue};
 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::column_path::{did_you_mean, ColumnPath, PathMember, UnspannedPathMember};
 pub use crate::value::dict::{Dictionary, TaggedDictBuilder};
 pub use crate::value::evaluate::{Evaluate, EvaluateTrait, Scope};
+pub use crate::value::primitive::format_primitive;
 pub use crate::value::primitive::Primitive;
 pub use crate::value::{UntaggedValue, Value};

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

@@ -1,3 +1,4 @@
+use crate::Value;
 use derive_new::new;
 use getset::Getters;
 use nu_source::{b, span_for_spanned_list, DebugDocBuilder, HasFallibleSpan, PrettyDebug, Span};
@@ -85,3 +86,29 @@ impl PathMember {
         UnspannedPathMember::Int(int.into()).into_path_member(span)
     }
 }
+
+pub fn did_you_mean(obj_source: &Value, field_tried: &PathMember) -> Option<Vec<(usize, String)>> {
+    let field_tried = match &field_tried.unspanned {
+        UnspannedPathMember::String(string) => string.clone(),
+        UnspannedPathMember::Int(int) => format!("{}", int),
+    };
+
+    let possibilities = obj_source.data_descriptors();
+
+    let mut possible_matches: Vec<_> = possibilities
+        .into_iter()
+        .map(|x| {
+            let word = x.clone();
+            let distance = natural::distance::levenshtein_distance(&word, &field_tried);
+
+            (distance, word)
+        })
+        .collect();
+
+    if !possible_matches.is_empty() {
+        possible_matches.sort();
+        Some(possible_matches)
+    } else {
+        None
+    }
+}

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

@@ -3,6 +3,8 @@ use crate::value::column_path::ColumnPath;
 use crate::value::{serde_bigdecimal, serde_bigint};
 use bigdecimal::BigDecimal;
 use chrono::{DateTime, Utc};
+use chrono_humanize::Humanize;
+use nu_source::PrettyDebug;
 use num_bigint::BigInt;
 use num_traits::cast::FromPrimitive;
 use serde::{Deserialize, Serialize};
@@ -65,3 +67,74 @@ impl ShellTypeName for Primitive {
         }
     }
 }
+
+pub fn format_primitive(primitive: &Primitive, field_name: Option<&String>) -> String {
+    match primitive {
+        Primitive::Nothing => String::new(),
+        Primitive::BeginningOfStream => String::new(),
+        Primitive::EndOfStream => String::new(),
+        Primitive::Path(p) => format!("{}", p.display()),
+        Primitive::Bytes(b) => {
+            let byte = byte_unit::Byte::from_bytes(*b as u128);
+
+            if byte.get_bytes() == 0u128 {
+                return "—".to_string();
+            }
+
+            let byte = byte.get_appropriate_unit(false);
+
+            match byte.get_unit() {
+                byte_unit::ByteUnit::B => format!("{} B ", byte.get_value()),
+                _ => byte.format(1).to_string(),
+            }
+        }
+        Primitive::Duration(sec) => format_duration(*sec),
+        Primitive::Int(i) => i.to_string(),
+        Primitive::Decimal(decimal) => decimal.to_string(),
+        Primitive::Pattern(s) => s.to_string(),
+        Primitive::String(s) => s.to_owned(),
+        Primitive::Line(s) => s.to_owned(),
+        Primitive::ColumnPath(p) => {
+            let mut members = p.iter();
+            let mut f = String::new();
+
+            f.push_str(
+                &members
+                    .next()
+                    .expect("BUG: column path with zero members")
+                    .display(),
+            );
+
+            for member in members {
+                f.push_str(".");
+                f.push_str(&member.display())
+            }
+
+            f
+        }
+        Primitive::Boolean(b) => match (b, field_name) {
+            (true, None) => "Yes",
+            (false, None) => "No",
+            (true, Some(s)) if !s.is_empty() => s,
+            (false, Some(s)) if !s.is_empty() => "",
+            (true, Some(_)) => "Yes",
+            (false, Some(_)) => "No",
+        }
+        .to_owned(),
+        Primitive::Binary(_) => "<binary>".to_owned(),
+        Primitive::Date(d) => d.humanize().to_string(),
+    }
+}
+fn format_duration(sec: u64) -> String {
+    let (minutes, seconds) = (sec / 60, sec % 60);
+    let (hours, minutes) = (minutes / 60, minutes % 60);
+    let (days, hours) = (hours / 24, hours % 24);
+
+    match (days, hours, minutes, seconds) {
+        (0, 0, 0, 1) => "1 sec".to_owned(),
+        (0, 0, 0, s) => format!("{} secs", s),
+        (0, 0, m, s) => format!("{}:{:02}", m, s),
+        (0, h, m, s) => format!("{}:{:02}:{:02}", h, m, s),
+        (d, h, m, s) => format!("{}:{:02}:{:02}:{:02}", d, h, m, s),
+    }
+}

crates/nu-value-ext/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "nu-value-ext"
+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"
+description = "A source string characterizer for Nushell"
+license = "MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+nu-source = { path = "../nu-source" }
+nu-errors = { path = "../nu-errors" }
+nu-parser = { path = "../nu-parser" }
+nu-protocol = { path = "../nu-protocol" }
+
+num-traits = "0.2.10"
+itertools = "0.8.2"
+
+[build-dependencies]
+nu-build = { version = "0.1.0", path = "../nu-build" }

crates/nu-value-ext/build.rs

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

crates/nu-value-ext/src/lib.rs

@@ -0,0 +1,515 @@
+use itertools::Itertools;
+use nu_errors::{ExpectedRange, ShellError};
+use nu_protocol::{
+    ColumnPath, MaybeOwned, PathMember, Primitive, ShellTypeName, SpannedTypeName,
+    UnspannedPathMember, UntaggedValue, Value,
+};
+use nu_source::{HasSpan, PrettyDebug, Spanned, SpannedItem, Tag, Tagged, TaggedItem};
+use num_traits::cast::ToPrimitive;
+
+pub trait ValueExt {
+    fn into_parts(self) -> (UntaggedValue, Tag);
+    fn get_data(&self, desc: &String) -> MaybeOwned<'_, Value>;
+    fn get_data_by_key(&self, name: Spanned<&str>) -> Option<Value>;
+    fn get_data_by_member(&self, name: &PathMember) -> Result<Value, ShellError>;
+    fn get_data_by_column_path(
+        &self,
+        path: &ColumnPath,
+        callback: Box<dyn FnOnce((&Value, &PathMember, ShellError)) -> ShellError>,
+    ) -> Result<Value, ShellError>;
+    fn insert_data_at_path(&self, path: &str, new_value: Value) -> Option<Value>;
+    fn insert_data_at_member(
+        &mut self,
+        member: &PathMember,
+        new_value: Value,
+    ) -> Result<(), ShellError>;
+    fn insert_data_at_column_path(
+        &self,
+        split_path: &ColumnPath,
+        new_value: Value,
+    ) -> Result<Value, ShellError>;
+    fn replace_data_at_column_path(
+        &self,
+        split_path: &ColumnPath,
+        replaced_value: Value,
+    ) -> Option<Value>;
+    fn as_column_path(&self) -> Result<Tagged<ColumnPath>, ShellError>;
+    fn as_path_member(&self) -> Result<PathMember, ShellError>;
+    fn as_string(&self) -> Result<String, ShellError>;
+}
+
+impl ValueExt for Value {
+    fn into_parts(self) -> (UntaggedValue, Tag) {
+        (self.value, self.tag)
+    }
+
+    fn get_data(&self, desc: &String) -> MaybeOwned<'_, Value> {
+        get_data(self, desc)
+    }
+
+    fn get_data_by_key(&self, name: Spanned<&str>) -> Option<Value> {
+        get_data_by_key(self, name)
+    }
+
+    fn get_data_by_member(&self, name: &PathMember) -> Result<Value, ShellError> {
+        get_data_by_member(self, name)
+    }
+
+    fn get_data_by_column_path(
+        &self,
+        path: &ColumnPath,
+        callback: Box<dyn FnOnce((&Value, &PathMember, ShellError)) -> ShellError>,
+    ) -> Result<Value, ShellError> {
+        get_data_by_column_path(self, path, callback)
+    }
+
+    fn insert_data_at_path(&self, path: &str, new_value: Value) -> Option<Value> {
+        insert_data_at_path(self, path, new_value)
+    }
+
+    fn insert_data_at_member(
+        &mut self,
+        member: &PathMember,
+        new_value: Value,
+    ) -> Result<(), ShellError> {
+        insert_data_at_member(self, member, new_value)
+    }
+
+    fn insert_data_at_column_path(
+        &self,
+        split_path: &ColumnPath,
+        new_value: Value,
+    ) -> Result<Value, ShellError> {
+        insert_data_at_column_path(self, split_path, new_value)
+    }
+
+    fn replace_data_at_column_path(
+        &self,
+        split_path: &ColumnPath,
+        replaced_value: Value,
+    ) -> Option<Value> {
+        replace_data_at_column_path(self, split_path, replaced_value)
+    }
+
+    fn as_column_path(&self) -> Result<Tagged<ColumnPath>, ShellError> {
+        as_column_path(self)
+    }
+
+    fn as_path_member(&self) -> Result<PathMember, ShellError> {
+        as_path_member(self)
+    }
+
+    fn as_string(&self) -> Result<String, ShellError> {
+        as_string(self)
+    }
+}
+
+pub(crate) fn get_data_by_member(value: &Value, name: &PathMember) -> Result<Value, ShellError> {
+    match &value.value {
+        // If the value is a row, the member is a column name
+        UntaggedValue::Row(o) => match &name.unspanned {
+            // If the member is a string, get the data
+            UnspannedPathMember::String(string) => o
+                .get_data_by_key(string[..].spanned(name.span))
+                .ok_or_else(|| {
+                    ShellError::missing_property(
+                        "row".spanned(value.tag.span),
+                        string.spanned(name.span),
+                    )
+                }),
+
+            // If the member is a number, it's an error
+            UnspannedPathMember::Int(_) => Err(ShellError::invalid_integer_index(
+                "row".spanned(value.tag.span),
+                name.span,
+            )),
+        },
+
+        // If the value is a table
+        UntaggedValue::Table(l) => {
+            match &name.unspanned {
+                // If the member is a string, map over the member
+                UnspannedPathMember::String(string) => {
+                    let mut out = vec![];
+
+                    for item in l {
+                        if let Value {
+                            value: UntaggedValue::Row(o),
+                            ..
+                        } = item
+                        {
+                            if let Some(v) = o.get_data_by_key(string[..].spanned(name.span)) {
+                                out.push(v)
+                            }
+                        }
+                    }
+
+                    if out.is_empty() {
+                        Err(ShellError::missing_property(
+                            "table".spanned(value.tag.span),
+                            string.spanned(name.span),
+                        ))
+                    } else {
+                        Ok(UntaggedValue::Table(out)
+                            .into_value(Tag::new(value.anchor(), name.span)))
+                    }
+                }
+                UnspannedPathMember::Int(int) => {
+                    let index = int.to_usize().ok_or_else(|| {
+                        ShellError::range_error(
+                            ExpectedRange::Usize,
+                            &"massive integer".spanned(name.span),
+                            "indexing",
+                        )
+                    })?;
+
+                    match get_data_by_index(value, index.spanned(value.tag.span)) {
+                        Some(v) => Ok(v.clone()),
+                        None => Err(ShellError::range_error(
+                            0..(l.len()),
+                            &int.spanned(name.span),
+                            "indexing",
+                        )),
+                    }
+                }
+            }
+        }
+        other => Err(ShellError::type_error(
+            "row or table",
+            other.type_name().spanned(value.tag.span),
+        )),
+    }
+}
+
+pub fn get_data_by_column_path(
+    value: &Value,
+    path: &ColumnPath,
+    callback: Box<dyn FnOnce((&Value, &PathMember, ShellError)) -> ShellError>,
+) -> Result<Value, ShellError> {
+    let mut current = value.clone();
+
+    for p in path.iter() {
+        let value = get_data_by_member(&current, p);
+
+        match value {
+            Ok(v) => current = v.clone(),
+            Err(e) => return Err(callback((&current.clone(), &p.clone(), e))),
+        }
+    }
+
+    Ok(current)
+}
+
+pub fn insert_data_at_path(value: &Value, path: &str, new_value: Value) -> Option<Value> {
+    let mut new_obj = value.clone();
+
+    let split_path: Vec<_> = path.split('.').collect();
+
+    if let UntaggedValue::Row(ref mut o) = new_obj.value {
+        let mut current = o;
+
+        if split_path.len() == 1 {
+            // Special case for inserting at the top level
+            current.entries.insert(
+                path.to_string(),
+                new_value.value.clone().into_value(&value.tag),
+            );
+            return Some(new_obj);
+        }
+
+        for idx in 0..split_path.len() {
+            match current.entries.get_mut(split_path[idx]) {
+                Some(next) => {
+                    if idx == (split_path.len() - 2) {
+                        if let UntaggedValue::Row(o) = &mut next.value {
+                            o.entries.insert(
+                                split_path[idx + 1].to_string(),
+                                new_value.value.clone().into_value(&value.tag),
+                            );
+                        }
+                        return Some(new_obj.clone());
+                    } else {
+                        match next.value {
+                            UntaggedValue::Row(ref mut o) => {
+                                current = o;
+                            }
+                            _ => return None,
+                        }
+                    }
+                }
+                _ => return None,
+            }
+        }
+    }
+
+    None
+}
+
+pub fn insert_data_at_member(
+    value: &mut Value,
+    member: &PathMember,
+    new_value: Value,
+) -> Result<(), ShellError> {
+    match &mut value.value {
+        UntaggedValue::Row(dict) => match &member.unspanned {
+            UnspannedPathMember::String(key) => {
+                dict.insert_data_at_key(key, new_value);
+                Ok(())
+            }
+            UnspannedPathMember::Int(_) => Err(ShellError::type_error(
+                "column name",
+                "integer".spanned(member.span),
+            )),
+        },
+        UntaggedValue::Table(array) => match &member.unspanned {
+            UnspannedPathMember::String(_) => Err(ShellError::type_error(
+                "list index",
+                "string".spanned(member.span),
+            )),
+            UnspannedPathMember::Int(int) => {
+                let int = int.to_usize().ok_or_else(|| {
+                    ShellError::range_error(
+                        ExpectedRange::Usize,
+                        &"bigger number".spanned(member.span),
+                        "inserting into a list",
+                    )
+                })?;
+
+                insert_data_at_index(array, int.tagged(member.span), new_value.clone())?;
+                Ok(())
+            }
+        },
+        other => match &member.unspanned {
+            UnspannedPathMember::String(_) => Err(ShellError::type_error(
+                "row",
+                other.type_name().spanned(value.span()),
+            )),
+            UnspannedPathMember::Int(_) => Err(ShellError::type_error(
+                "table",
+                other.type_name().spanned(value.span()),
+            )),
+        },
+    }
+}
+
+pub fn insert_data_at_column_path(
+    value: &Value,
+    split_path: &ColumnPath,
+    new_value: Value,
+) -> Result<Value, ShellError> {
+    let (last, front) = split_path.split_last();
+    let mut original = value.clone();
+
+    let mut current: &mut Value = &mut original;
+
+    for member in front {
+        let type_name = current.spanned_type_name();
+
+        current = get_mut_data_by_member(current, &member).ok_or_else(|| {
+            ShellError::missing_property(
+                member.plain_string(std::usize::MAX).spanned(member.span),
+                type_name,
+            )
+        })?
+    }
+
+    insert_data_at_member(current, &last, new_value)?;
+
+    Ok(original)
+}
+
+pub fn replace_data_at_column_path(
+    value: &Value,
+    split_path: &ColumnPath,
+    replaced_value: Value,
+) -> Option<Value> {
+    let mut new_obj: Value = value.clone();
+    let mut current = &mut new_obj;
+    let split_path = split_path.members();
+
+    for idx in 0..split_path.len() {
+        match get_mut_data_by_member(current, &split_path[idx]) {
+            Some(next) => {
+                if idx == (split_path.len() - 1) {
+                    *next = replaced_value.value.into_value(&value.tag);
+                    return Some(new_obj);
+                } else {
+                    current = next;
+                }
+            }
+            None => {
+                return None;
+            }
+        }
+    }
+
+    None
+}
+
+pub fn as_column_path(value: &Value) -> Result<Tagged<ColumnPath>, ShellError> {
+    match &value.value {
+        UntaggedValue::Table(table) => {
+            let mut out: Vec<PathMember> = vec![];
+
+            for item in table {
+                out.push(as_path_member(item)?);
+            }
+
+            Ok(ColumnPath::new(out).tagged(&value.tag))
+        }
+
+        UntaggedValue::Primitive(Primitive::String(s)) => {
+            Ok(ColumnPath::new(vec![PathMember::string(s, &value.tag.span)]).tagged(&value.tag))
+        }
+
+        UntaggedValue::Primitive(Primitive::ColumnPath(path)) => {
+            Ok(path.clone().tagged(value.tag.clone()))
+        }
+
+        other => Err(ShellError::type_error(
+            "column path",
+            other.type_name().spanned(value.span()),
+        )),
+    }
+}
+
+pub fn as_path_member(value: &Value) -> Result<PathMember, ShellError> {
+    match &value.value {
+        UntaggedValue::Primitive(primitive) => match primitive {
+            Primitive::Int(int) => Ok(PathMember::int(int.clone(), value.tag.span)),
+            Primitive::String(string) => Ok(PathMember::string(string, value.tag.span)),
+            other => Err(ShellError::type_error(
+                "path member",
+                other.type_name().spanned(value.span()),
+            )),
+        },
+        other => Err(ShellError::type_error(
+            "path member",
+            other.type_name().spanned(value.span()),
+        )),
+    }
+}
+
+pub fn as_string(value: &Value) -> Result<String, ShellError> {
+    match &value.value {
+        UntaggedValue::Primitive(Primitive::String(s)) => Ok(s.clone()),
+        UntaggedValue::Primitive(Primitive::Boolean(x)) => Ok(format!("{}", x)),
+        UntaggedValue::Primitive(Primitive::Decimal(x)) => Ok(format!("{}", x)),
+        UntaggedValue::Primitive(Primitive::Int(x)) => Ok(format!("{}", x)),
+        UntaggedValue::Primitive(Primitive::Bytes(x)) => Ok(format!("{}", x)),
+        UntaggedValue::Primitive(Primitive::Path(x)) => Ok(format!("{}", x.display())),
+        UntaggedValue::Primitive(Primitive::ColumnPath(path)) => {
+            Ok(path.iter().map(|member| member.display()).join("."))
+        }
+
+        // TODO: this should definitely be more general with better errors
+        other => Err(ShellError::labeled_error(
+            "Expected string",
+            other.type_name(),
+            &value.tag,
+        )),
+    }
+}
+
+fn insert_data_at_index(
+    list: &mut Vec<Value>,
+    index: Tagged<usize>,
+    new_value: Value,
+) -> Result<(), ShellError> {
+    if list.len() >= index.item {
+        Err(ShellError::range_error(
+            0..(list.len()),
+            &format_args!("{}", index.item).spanned(index.tag.span),
+            "insert at index",
+        ))
+    } else {
+        list[index.item] = new_value;
+        Ok(())
+    }
+}
+
+pub fn get_data<'value>(value: &'value Value, desc: &String) -> MaybeOwned<'value, Value> {
+    match &value.value {
+        UntaggedValue::Primitive(_) => MaybeOwned::Borrowed(value),
+        UntaggedValue::Row(o) => o.get_data(desc),
+        UntaggedValue::Block(_) | UntaggedValue::Table(_) | UntaggedValue::Error(_) => {
+            MaybeOwned::Owned(UntaggedValue::nothing().into_untagged_value())
+        }
+    }
+}
+
+pub(crate) fn get_data_by_index(value: &Value, idx: Spanned<usize>) -> Option<Value> {
+    match &value.value {
+        UntaggedValue::Table(value_set) => {
+            let value = value_set.get(idx.item)?;
+            Some(
+                value
+                    .value
+                    .clone()
+                    .into_value(Tag::new(value.anchor(), idx.span)),
+            )
+        }
+        _ => None,
+    }
+}
+
+pub(crate) fn get_data_by_key(value: &Value, name: Spanned<&str>) -> Option<Value> {
+    match &value.value {
+        UntaggedValue::Row(o) => o.get_data_by_key(name),
+        UntaggedValue::Table(l) => {
+            let mut out = vec![];
+            for item in l {
+                match item {
+                    Value {
+                        value: UntaggedValue::Row(o),
+                        ..
+                    } => match o.get_data_by_key(name) {
+                        Some(v) => out.push(v),
+                        None => out.push(UntaggedValue::nothing().into_untagged_value()),
+                    },
+                    _ => out.push(UntaggedValue::nothing().into_untagged_value()),
+                }
+            }
+
+            if !out.is_empty() {
+                Some(UntaggedValue::Table(out).into_value(name.span))
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+pub(crate) fn get_mut_data_by_member<'value>(
+    value: &'value mut Value,
+    name: &PathMember,
+) -> Option<&'value mut Value> {
+    match &mut value.value {
+        UntaggedValue::Row(o) => match &name.unspanned {
+            UnspannedPathMember::String(string) => o.get_mut_data_by_key(&string),
+            UnspannedPathMember::Int(_) => None,
+        },
+        UntaggedValue::Table(l) => match &name.unspanned {
+            UnspannedPathMember::String(string) => {
+                for item in l {
+                    if let Value {
+                        value: UntaggedValue::Row(o),
+                        ..
+                    } = item
+                    {
+                        if let Some(v) = o.get_mut_data_by_key(&string) {
+                            return Some(v);
+                        }
+                    }
+                }
+                None
+            }
+            UnspannedPathMember::Int(int) => {
+                let index = int.to_usize()?;
+                l.get_mut(index)
+            }
+        },
+        _ => None,
+    }
+}

crates/nu_plugin_average/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "nu_plugin_average"
+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_average/build.rs

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

crates/nu_plugin_average/src/main.rs

@@ -0,0 +1,117 @@
+use nu_errors::{CoerceInto, ShellError};
+use nu_protocol::{
+    serve_plugin, CallInfo, Plugin, Primitive, ReturnSuccess, ReturnValue, Signature,
+    UntaggedValue, Value,
+};
+use nu_source::TaggedItem;
+
+#[derive(Debug)]
+struct Average {
+    total: Option<Value>,
+    count: u64,
+}
+
+impl Average {
+    fn new() -> Average {
+        Average {
+            total: None,
+            count: 0,
+        }
+    }
+
+    fn average(&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,
+                }) => {
+                    self.total = Some(UntaggedValue::int(i + j).into_value(tag));
+                    self.count += 1;
+                    Ok(())
+                }
+                None => {
+                    self.total = Some(value.clone());
+                    self.count += 1;
+                    Ok(())
+                }
+                _ => Err(ShellError::labeled_error(
+                    "Could calculate average of 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,
+                }) => {
+                    self.total = Some(UntaggedValue::bytes(b + j).into_value(tag));
+                    self.count += 1;
+                    Ok(())
+                }
+                None => {
+                    self.total = Some(value);
+                    self.count += 1;
+                    Ok(())
+                }
+                _ => Err(ShellError::labeled_error(
+                    "Could calculate average of 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 Average {
+    fn config(&mut self) -> Result<Signature, ShellError> {
+        Ok(Signature::build("average")
+            .desc("Compute the average of a column of numerical 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.average(input)?;
+        Ok(vec![])
+    }
+
+    fn end_filter(&mut self) -> Result<Vec<ReturnValue>, ShellError> {
+        match self.total {
+            None => Ok(vec![]),
+            Some(ref inner) => match &inner.value {
+                UntaggedValue::Primitive(Primitive::Int(i)) => {
+                    let total: u64 = i
+                        .tagged(inner.tag.clone())
+                        .coerce_into("converting for average")?;
+                    let avg = total as f64 / self.count as f64;
+                    let primitive_value: UntaggedValue = Primitive::from(avg).into();
+                    let value = primitive_value.into_value(inner.tag.clone());
+                    Ok(vec![ReturnSuccess::value(value)])
+                }
+                UntaggedValue::Primitive(Primitive::Bytes(bytes)) => {
+                    let avg = *bytes as f64 / self.count as f64;
+                    let primitive_value: UntaggedValue = Primitive::from(avg).into();
+                    let tagged_value = primitive_value.into_value(inner.tag.clone());
+                    Ok(vec![ReturnSuccess::value(tagged_value)])
+                }
+                _ => Ok(vec![]),
+            },
+        }
+    }
+}
+
+fn main() {
+    serve_plugin(&mut Average::new());
+}

crates/nu_plugin_inc/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "nu_plugin_inc"
+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" }
+nu-value-ext = { path = "../nu-value-ext" }
+indexmap = "1.3.0"
+semver = "0.9.0"
+
+[build-dependencies]
+nu-build = { version = "0.1.0", path = "../nu-build" }

crates/nu_plugin_inc/build.rs

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

crates/nu_plugin_inc/src/main.rs

@@ -0,0 +1,456 @@
+use nu_errors::ShellError;
+use nu_protocol::{
+    did_you_mean, serve_plugin, CallInfo, ColumnPath, Plugin, Primitive, ReturnSuccess,
+    ReturnValue, ShellTypeName, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::{span_for_spanned_list, HasSpan, SpannedItem, Tagged};
+use nu_value_ext::ValueExt;
+
+enum Action {
+    SemVerAction(SemVerAction),
+    Default,
+}
+
+pub enum SemVerAction {
+    Major,
+    Minor,
+    Patch,
+}
+
+struct Inc {
+    field: Option<Tagged<ColumnPath>>,
+    error: Option<String>,
+    action: Option<Action>,
+}
+
+impl Inc {
+    fn new() -> Inc {
+        Inc {
+            field: None,
+            error: None,
+            action: None,
+        }
+    }
+
+    fn apply(&self, input: &str) -> Result<UntaggedValue, ShellError> {
+        let applied = match &self.action {
+            Some(Action::SemVerAction(act_on)) => {
+                let mut ver = match semver::Version::parse(&input) {
+                    Ok(parsed_ver) => parsed_ver,
+                    Err(_) => return Ok(UntaggedValue::string(input.to_string())),
+                };
+
+                match act_on {
+                    SemVerAction::Major => ver.increment_major(),
+                    SemVerAction::Minor => ver.increment_minor(),
+                    SemVerAction::Patch => ver.increment_patch(),
+                }
+
+                UntaggedValue::string(ver.to_string())
+            }
+            Some(Action::Default) | None => match input.parse::<u64>() {
+                Ok(v) => UntaggedValue::string(format!("{}", v + 1)),
+                Err(_) => UntaggedValue::string(input),
+            },
+        };
+
+        Ok(applied)
+    }
+
+    fn for_semver(&mut self, part: SemVerAction) {
+        if self.permit() {
+            self.action = Some(Action::SemVerAction(part));
+        } else {
+            self.log_error("can only apply one");
+        }
+    }
+
+    fn permit(&mut self) -> bool {
+        self.action.is_none()
+    }
+
+    fn log_error(&mut self, message: &str) {
+        self.error = Some(message.to_string());
+    }
+
+    pub fn usage() -> &'static str {
+        "Usage: inc field [--major|--minor|--patch]"
+    }
+
+    fn inc(&self, value: Value) -> Result<Value, ShellError> {
+        match &value.value {
+            UntaggedValue::Primitive(Primitive::Int(i)) => {
+                Ok(UntaggedValue::int(i + 1).into_value(value.tag()))
+            }
+            UntaggedValue::Primitive(Primitive::Bytes(b)) => {
+                Ok(UntaggedValue::bytes(b + 1 as u64).into_value(value.tag()))
+            }
+            UntaggedValue::Primitive(Primitive::String(ref s)) => {
+                Ok(self.apply(&s)?.into_value(value.tag()))
+            }
+            UntaggedValue::Table(values) => {
+                if values.len() == 1 {
+                    Ok(UntaggedValue::Table(vec![self.inc(values[0].clone())?])
+                        .into_value(value.tag()))
+                } else {
+                    Err(ShellError::type_error(
+                        "incrementable value",
+                        value.type_name().spanned(value.span()),
+                    ))
+                }
+            }
+
+            UntaggedValue::Row(_) => match self.field {
+                Some(ref f) => {
+                    let fields = f.clone();
+
+                    let replace_for = value.get_data_by_column_path(
+                        &f,
+                        Box::new(move |(obj_source, column_path_tried, _)| {
+                            match did_you_mean(&obj_source, &column_path_tried) {
+                                Some(suggestions) => ShellError::labeled_error(
+                                    "Unknown column",
+                                    format!("did you mean '{}'?", suggestions[0].1),
+                                    span_for_spanned_list(fields.iter().map(|p| p.span)),
+                                ),
+                                None => ShellError::labeled_error(
+                                    "Unknown column",
+                                    "row does not contain this column",
+                                    span_for_spanned_list(fields.iter().map(|p| p.span)),
+                                ),
+                            }
+                        }),
+                    );
+
+                    let got = replace_for?;
+                    let replacement = self.inc(got.clone())?;
+
+                    match value.replace_data_at_column_path(
+                        &f,
+                        replacement.value.clone().into_untagged_value(),
+                    ) {
+                        Some(v) => Ok(v),
+                        None => Err(ShellError::labeled_error(
+                            "inc could not find field to replace",
+                            "column name",
+                            value.tag(),
+                        )),
+                    }
+                }
+                None => Err(ShellError::untagged_runtime_error(
+                    "inc needs a field when incrementing a column in a table",
+                )),
+            },
+            _ => Err(ShellError::type_error(
+                "incrementable value",
+                value.type_name().spanned(value.span()),
+            )),
+        }
+    }
+}
+
+impl Plugin for Inc {
+    fn config(&mut self) -> Result<Signature, ShellError> {
+        Ok(Signature::build("inc")
+            .desc("Increment a value or version. Optionally use the column of a table.")
+            .switch("major", "increment the major version (eg 1.2.1 -> 2.0.0)")
+            .switch("minor", "increment the minor version (eg 1.2.1 -> 1.3.0)")
+            .switch("patch", "increment the patch version (eg 1.2.1 -> 1.2.2)")
+            .rest(SyntaxShape::ColumnPath, "the column(s) to update")
+            .filter())
+    }
+
+    fn begin_filter(&mut self, call_info: CallInfo) -> Result<Vec<ReturnValue>, ShellError> {
+        if call_info.args.has("major") {
+            self.for_semver(SemVerAction::Major);
+        }
+        if call_info.args.has("minor") {
+            self.for_semver(SemVerAction::Minor);
+        }
+        if call_info.args.has("patch") {
+            self.for_semver(SemVerAction::Patch);
+        }
+
+        if let Some(args) = call_info.args.positional {
+            for arg in args {
+                match arg {
+                    table @ Value {
+                        value: UntaggedValue::Primitive(Primitive::ColumnPath(_)),
+                        ..
+                    } => {
+                        self.field = Some(table.as_column_path()?);
+                    }
+                    value => {
+                        return Err(ShellError::type_error(
+                            "table",
+                            value.type_name().spanned(value.span()),
+                        ))
+                    }
+                }
+            }
+        }
+
+        if self.action.is_none() {
+            self.action = Some(Action::Default);
+        }
+
+        match &self.error {
+            Some(reason) => Err(ShellError::untagged_runtime_error(format!(
+                "{}: {}",
+                reason,
+                Inc::usage()
+            ))),
+            None => Ok(vec![]),
+        }
+    }
+
+    fn filter(&mut self, input: Value) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(vec![ReturnSuccess::value(self.inc(input)?)])
+    }
+}
+
+fn main() {
+    serve_plugin(&mut Inc::new());
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::{Inc, SemVerAction};
+    use indexmap::IndexMap;
+    use nu_protocol::{
+        CallInfo, EvaluatedArgs, PathMember, ReturnSuccess, UnspannedPathMember, UntaggedValue,
+        Value,
+    };
+    use nu_protocol::{Plugin, TaggedDictBuilder};
+    use nu_source::{Span, Tag};
+
+    struct CallStub {
+        positionals: Vec<Value>,
+        flags: IndexMap<String, Value>,
+    }
+
+    impl CallStub {
+        fn new() -> CallStub {
+            CallStub {
+                positionals: vec![],
+                flags: indexmap::IndexMap::new(),
+            }
+        }
+
+        fn with_long_flag(&mut self, name: &str) -> &mut Self {
+            self.flags.insert(
+                name.to_string(),
+                UntaggedValue::boolean(true).into_value(Tag::unknown()),
+            );
+            self
+        }
+
+        fn with_parameter(&mut self, name: &str) -> &mut Self {
+            let fields: Vec<PathMember> = name
+                .split(".")
+                .map(|s| {
+                    UnspannedPathMember::String(s.to_string()).into_path_member(Span::unknown())
+                })
+                .collect();
+
+            self.positionals
+                .push(UntaggedValue::column_path(fields).into_untagged_value());
+            self
+        }
+
+        fn create(&self) -> CallInfo {
+            CallInfo {
+                args: EvaluatedArgs::new(Some(self.positionals.clone()), Some(self.flags.clone())),
+                name_tag: Tag::unknown(),
+            }
+        }
+    }
+
+    fn cargo_sample_record(with_version: &str) -> Value {
+        let mut package = TaggedDictBuilder::new(Tag::unknown());
+        package.insert_untagged("version", UntaggedValue::string(with_version));
+        package.into_value()
+    }
+
+    #[test]
+    fn inc_plugin_configuration_flags_wired() {
+        let mut plugin = Inc::new();
+
+        let configured = plugin.config().expect("Can not configure plugin");
+
+        for action_flag in &["major", "minor", "patch"] {
+            assert!(configured.named.get(*action_flag).is_some());
+        }
+    }
+
+    #[test]
+    fn inc_plugin_accepts_major() {
+        let mut plugin = Inc::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_long_flag("major").create())
+            .is_ok());
+        assert!(plugin.action.is_some());
+    }
+
+    #[test]
+    fn inc_plugin_accepts_minor() {
+        let mut plugin = Inc::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_long_flag("minor").create())
+            .is_ok());
+        assert!(plugin.action.is_some());
+    }
+
+    #[test]
+    fn inc_plugin_accepts_patch() {
+        let mut plugin = Inc::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_long_flag("patch").create())
+            .is_ok());
+        assert!(plugin.action.is_some());
+    }
+
+    #[test]
+    fn inc_plugin_accepts_only_one_action() {
+        let mut plugin = Inc::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_long_flag("major")
+                    .with_long_flag("minor")
+                    .create(),
+            )
+            .is_err());
+        assert_eq!(plugin.error, Some("can only apply one".to_string()));
+    }
+
+    #[test]
+    fn inc_plugin_accepts_field() {
+        let mut plugin = Inc::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_parameter("package.version").create())
+            .is_ok());
+
+        assert_eq!(
+            plugin
+                .field
+                .map(|f| f.iter().map(|f| f.unspanned.clone()).collect()),
+            Some(vec![
+                UnspannedPathMember::String("package".to_string()),
+                UnspannedPathMember::String("version".to_string())
+            ])
+        );
+    }
+
+    #[test]
+    fn incs_major() {
+        let mut inc = Inc::new();
+        inc.for_semver(SemVerAction::Major);
+        assert_eq!(inc.apply("0.1.3").unwrap(), UntaggedValue::string("1.0.0"));
+    }
+
+    #[test]
+    fn incs_minor() {
+        let mut inc = Inc::new();
+        inc.for_semver(SemVerAction::Minor);
+        assert_eq!(inc.apply("0.1.3").unwrap(), UntaggedValue::string("0.2.0"));
+    }
+
+    #[test]
+    fn incs_patch() {
+        let mut inc = Inc::new();
+        inc.for_semver(SemVerAction::Patch);
+        assert_eq!(inc.apply("0.1.3").unwrap(), UntaggedValue::string("0.1.4"));
+    }
+
+    #[test]
+    fn inc_plugin_applies_major() {
+        let mut plugin = Inc::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_long_flag("major")
+                    .with_parameter("version")
+                    .create()
+            )
+            .is_ok());
+
+        let subject = cargo_sample_record("0.1.3");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Row(o),
+                ..
+            }) => assert_eq!(
+                *o.get_data(&String::from("version")).borrow(),
+                UntaggedValue::string(String::from("1.0.0")).into_untagged_value()
+            ),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn inc_plugin_applies_minor() {
+        let mut plugin = Inc::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_long_flag("minor")
+                    .with_parameter("version")
+                    .create()
+            )
+            .is_ok());
+
+        let subject = cargo_sample_record("0.1.3");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Row(o),
+                ..
+            }) => assert_eq!(
+                *o.get_data(&String::from("version")).borrow(),
+                UntaggedValue::string(String::from("0.2.0")).into_untagged_value()
+            ),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn inc_plugin_applies_patch() {
+        let field = String::from("version");
+        let mut plugin = Inc::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_long_flag("patch")
+                    .with_parameter(&field)
+                    .create()
+            )
+            .is_ok());
+
+        let subject = cargo_sample_record("0.1.3");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Row(o),
+                ..
+            }) => assert_eq!(
+                *o.get_data(&field).borrow(),
+                UntaggedValue::string(String::from("0.1.4")).into_untagged_value()
+            ),
+            _ => {}
+        }
+    }
+}

crates/nu_plugin_match/Cargo.toml

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

crates/nu_plugin_match/build.rs

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

crates/nu_plugin_match/src/main.rs

@@ -0,0 +1,106 @@
+use nu_errors::ShellError;
+use nu_protocol::{
+    serve_plugin, CallInfo, Plugin, Primitive, ReturnSuccess, ReturnValue, Signature, SyntaxShape,
+    UntaggedValue, Value,
+};
+
+use regex::Regex;
+
+struct Match {
+    column: String,
+    regex: Regex,
+}
+
+impl Match {
+    fn new() -> Self {
+        Match {
+            column: String::new(),
+            regex: Regex::new("").unwrap(),
+        }
+    }
+}
+
+impl Plugin for Match {
+    fn config(&mut self) -> Result<Signature, ShellError> {
+        Ok(Signature::build("match")
+            .desc("filter rows by regex")
+            .required("member", SyntaxShape::Member, "the column name to match")
+            .required("regex", SyntaxShape::String, "the regex to match with")
+            .filter())
+    }
+    fn begin_filter(&mut self, call_info: CallInfo) -> Result<Vec<ReturnValue>, ShellError> {
+        if let Some(args) = call_info.args.positional {
+            match &args[0] {
+                Value {
+                    value: UntaggedValue::Primitive(Primitive::String(s)),
+                    ..
+                } => {
+                    self.column = s.clone();
+                }
+                Value { tag, .. } => {
+                    return Err(ShellError::labeled_error(
+                        "Unrecognized type in params",
+                        "value",
+                        tag,
+                    ));
+                }
+            }
+            match &args[1] {
+                Value {
+                    value: UntaggedValue::Primitive(Primitive::String(s)),
+                    ..
+                } => {
+                    self.regex = Regex::new(s).unwrap();
+                }
+                Value { tag, .. } => {
+                    return Err(ShellError::labeled_error(
+                        "Unrecognized type in params",
+                        "value",
+                        tag,
+                    ));
+                }
+            }
+        }
+        Ok(vec![])
+    }
+
+    fn filter(&mut self, input: Value) -> Result<Vec<ReturnValue>, ShellError> {
+        let flag: bool;
+        match &input {
+            Value {
+                value: UntaggedValue::Row(dict),
+                tag,
+            } => {
+                if let Some(val) = dict.entries.get(&self.column) {
+                    if let Ok(s) = val.as_string() {
+                        flag = self.regex.is_match(&s);
+                    } else {
+                        return Err(ShellError::labeled_error(
+                            "expected string",
+                            "value",
+                            val.tag(),
+                        ));
+                    }
+                } else {
+                    return Err(ShellError::labeled_error(
+                        format!("column not in row! {:?} {:?}", &self.column, dict),
+                        "row",
+                        tag,
+                    ));
+                }
+            }
+            Value { tag, .. } => {
+                return Err(ShellError::labeled_error("Expected row", "value", tag));
+            }
+        }
+        if flag {
+            Ok(vec![Ok(ReturnSuccess::Value(input))])
+        } else {
+            Ok(vec![])
+        }
+    }
+}
+
+fn main() {
+    serve_plugin(&mut Match::new());
+}

crates/nu_plugin_str/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "nu_plugin_str"
+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" }
+nu-value-ext = { path = "../nu-value-ext" }
+
+futures-preview = { version = "=0.3.0-alpha.19", features = ["compat", "io-compat"] }
+regex = "1"
+indexmap = "1.3.0"
+num-bigint = "0.2.3"
+
+[build-dependencies]
+nu-build = { version = "0.1.0", path = "../nu-build" }

crates/nu_plugin_str/build.rs

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

crates/nu_plugin_str/src/main.rs

@@ -0,0 +1,980 @@
+use nu_errors::ShellError;
+use nu_protocol::{
+    did_you_mean, serve_plugin, CallInfo, ColumnPath, Plugin, Primitive, ReturnSuccess,
+    ReturnValue, ShellTypeName, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::{span_for_spanned_list, Tagged};
+use nu_value_ext::ValueExt;
+
+use regex::Regex;
+use std::cmp;
+
+#[derive(Debug, Eq, PartialEq)]
+enum Action {
+    Downcase,
+    Upcase,
+    ToInteger,
+    Substring(usize, usize),
+    Replace(ReplaceAction),
+}
+
+#[derive(Debug, Eq, PartialEq)]
+enum ReplaceAction {
+    Direct(String),
+    FindAndReplace(String, String),
+}
+
+struct Str {
+    field: Option<Tagged<ColumnPath>>,
+    error: Option<String>,
+    action: Option<Action>,
+}
+
+impl Str {
+    fn new() -> Str {
+        Str {
+            field: None,
+            error: None,
+            action: None,
+        }
+    }
+
+    fn apply(&self, input: &str) -> Result<UntaggedValue, ShellError> {
+        let applied = match self.action.as_ref() {
+            Some(Action::Downcase) => UntaggedValue::string(input.to_ascii_lowercase()),
+            Some(Action::Upcase) => UntaggedValue::string(input.to_ascii_uppercase()),
+            Some(Action::Substring(s, e)) => {
+                let end: usize = cmp::min(*e, input.len());
+                let start: usize = *s;
+                if start > input.len() - 1 {
+                    UntaggedValue::string("")
+                } else {
+                    UntaggedValue::string(
+                        &input
+                            .chars()
+                            .skip(start)
+                            .take(end - start)
+                            .collect::<String>(),
+                    )
+                }
+            }
+            Some(Action::Replace(mode)) => match mode {
+                ReplaceAction::Direct(replacement) => UntaggedValue::string(replacement.as_str()),
+                ReplaceAction::FindAndReplace(find, replacement) => {
+                    let regex = Regex::new(find.as_str());
+
+                    match regex {
+                        Ok(re) => UntaggedValue::string(
+                            re.replace(input, replacement.as_str()).to_owned(),
+                        ),
+                        Err(_) => UntaggedValue::string(input),
+                    }
+                }
+            },
+            Some(Action::ToInteger) => match input.trim() {
+                other => match other.parse::<i64>() {
+                    Ok(v) => UntaggedValue::int(v),
+                    Err(_) => UntaggedValue::string(input),
+                },
+            },
+            None => UntaggedValue::string(input),
+        };
+
+        Ok(applied)
+    }
+
+    fn for_field(&mut self, column_path: Tagged<ColumnPath>) {
+        self.field = Some(column_path);
+    }
+
+    fn permit(&mut self) -> bool {
+        self.action.is_none()
+    }
+
+    fn log_error(&mut self, message: &str) {
+        self.error = Some(message.to_string());
+    }
+
+    fn for_to_int(&mut self) {
+        if self.permit() {
+            self.action = Some(Action::ToInteger);
+        } else {
+            self.log_error("can only apply one");
+        }
+    }
+
+    fn for_downcase(&mut self) {
+        if self.permit() {
+            self.action = Some(Action::Downcase);
+        } else {
+            self.log_error("can only apply one");
+        }
+    }
+
+    fn for_upcase(&mut self) {
+        if self.permit() {
+            self.action = Some(Action::Upcase);
+        } else {
+            self.log_error("can only apply one");
+        }
+    }
+
+    fn for_substring(&mut self, s: String) {
+        let v: Vec<&str> = s.split(',').collect();
+        let start: usize = match v[0] {
+            "" => 0,
+            _ => v[0].trim().parse().unwrap(),
+        };
+        let end: usize = match v[1] {
+            "" => usize::max_value(),
+            _ => v[1].trim().parse().unwrap(),
+        };
+        if start > end {
+            self.log_error("End must be greater than or equal to Start");
+        } else if self.permit() {
+            self.action = Some(Action::Substring(start, end));
+        } else {
+            self.log_error("can only apply one");
+        }
+    }
+
+    fn for_replace(&mut self, mode: ReplaceAction) {
+        if self.permit() {
+            self.action = Some(Action::Replace(mode));
+        } else {
+            self.log_error("can only apply one");
+        }
+    }
+
+    pub fn usage() -> &'static str {
+        "Usage: str field [--downcase|--upcase|--to-int|--substring \"start,end\"|--replace|--find-replace [pattern replacement]]]"
+    }
+}
+
+impl Str {
+    fn strutils(&self, value: Value) -> Result<Value, ShellError> {
+        match &value.value {
+            UntaggedValue::Primitive(Primitive::String(ref s)) => {
+                Ok(self.apply(&s)?.into_value(value.tag()))
+            }
+            UntaggedValue::Primitive(Primitive::Line(ref s)) => {
+                Ok(self.apply(&s)?.into_value(value.tag()))
+            }
+            UntaggedValue::Row(_) => match self.field {
+                Some(ref f) => {
+                    let fields = f.clone();
+
+                    let replace_for =
+                        value.get_data_by_column_path(
+                            &f,
+                            Box::new(move |(obj_source, column_path_tried, error)| {
+                                match did_you_mean(&obj_source, &column_path_tried) {
+                                    Some(suggestions) => ShellError::labeled_error(
+                                        "Unknown column",
+                                        format!("did you mean '{}'?", suggestions[0].1),
+                                        span_for_spanned_list(fields.iter().map(|p| p.span)),
+                                    ),
+                                    None => error,
+                                }
+                            }),
+                        );
+
+                    let got = replace_for?;
+                    let replacement = self.strutils(got.clone())?;
+
+                    match value.replace_data_at_column_path(
+                        &f,
+                        replacement.value.clone().into_untagged_value(),
+                    ) {
+                        Some(v) => Ok(v),
+                        None => Err(ShellError::labeled_error(
+                            "str could not find field to replace",
+                            "column name",
+                            value.tag(),
+                        )),
+                    }
+                }
+                None => Err(ShellError::untagged_runtime_error(format!(
+                    "{}: {}",
+                    "str needs a column when applied to a value in a row",
+                    Str::usage()
+                ))),
+            },
+            _ => Err(ShellError::labeled_error(
+                "Unrecognized type in stream",
+                value.type_name(),
+                value.tag,
+            )),
+        }
+    }
+}
+
+impl Plugin for Str {
+    fn config(&mut self) -> Result<Signature, ShellError> {
+        Ok(Signature::build("str")
+            .desc("Apply string function. Optional use the column of a table")
+            .switch("downcase", "convert string to lowercase")
+            .switch("upcase", "convert string to uppercase")
+            .switch("to-int", "convert string to integer")
+            .named("replace", SyntaxShape::String, "replaces the string")
+            .named(
+                "find-replace",
+                SyntaxShape::Any,
+                "finds and replaces [pattern replacement]",
+            )
+            .named(
+                "substring",
+                SyntaxShape::String,
+                "convert string to portion of original, requires \"start,end\"",
+            )
+            .rest(SyntaxShape::ColumnPath, "the column(s) to convert")
+            .filter())
+    }
+
+    fn begin_filter(&mut self, call_info: CallInfo) -> Result<Vec<ReturnValue>, ShellError> {
+        let args = call_info.args;
+
+        if args.has("downcase") {
+            self.for_downcase();
+        }
+        if args.has("upcase") {
+            self.for_upcase();
+        }
+        if args.has("to-int") {
+            self.for_to_int();
+        }
+        if args.has("substring") {
+            if let Some(start_end) = args.get("substring") {
+                match start_end {
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::String(s)),
+                        ..
+                    } => {
+                        self.for_substring(s.to_string());
+                    }
+                    _ => {
+                        return Err(ShellError::labeled_error(
+                            "Unrecognized type in params",
+                            start_end.type_name(),
+                            &start_end.tag,
+                        ))
+                    }
+                }
+            }
+        }
+        if args.has("replace") {
+            if let Some(Value {
+                value: UntaggedValue::Primitive(Primitive::String(replacement)),
+                ..
+            }) = args.get("replace")
+            {
+                self.for_replace(ReplaceAction::Direct(replacement.clone()));
+            }
+        }
+
+        if args.has("find-replace") {
+            if let Some(Value {
+                value: UntaggedValue::Table(arguments),
+                ..
+            }) = args.get("find-replace")
+            {
+                self.for_replace(ReplaceAction::FindAndReplace(
+                    arguments.get(0).unwrap().as_string()?.to_string(),
+                    arguments.get(1).unwrap().as_string()?.to_string(),
+                ));
+            }
+        }
+
+        if let Some(possible_field) = args.nth(0) {
+            let possible_field = possible_field.as_column_path()?;
+            self.for_field(possible_field);
+        }
+
+        match &self.error {
+            Some(reason) => Err(ShellError::untagged_runtime_error(format!(
+                "{}: {}",
+                reason,
+                Str::usage()
+            ))),
+            None => Ok(vec![]),
+        }
+    }
+
+    fn filter(&mut self, input: Value) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(vec![ReturnSuccess::value(self.strutils(input)?)])
+    }
+}
+
+fn main() {
+    serve_plugin(&mut Str::new());
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Action, ReplaceAction, Str};
+    use indexmap::IndexMap;
+    use nu_protocol::{
+        CallInfo, EvaluatedArgs, Plugin, Primitive, ReturnSuccess, TaggedDictBuilder,
+        UntaggedValue, Value,
+    };
+    use nu_source::Tag;
+    use nu_value_ext::ValueExt;
+    use num_bigint::BigInt;
+
+    fn string(input: impl Into<String>) -> Value {
+        UntaggedValue::string(input.into()).into_untagged_value()
+    }
+
+    fn table(list: &Vec<Value>) -> Value {
+        UntaggedValue::table(list).into_untagged_value()
+    }
+
+    fn column_path(paths: &Vec<Value>) -> Value {
+        UntaggedValue::Primitive(Primitive::ColumnPath(
+            table(&paths.iter().cloned().collect())
+                .as_column_path()
+                .unwrap()
+                .item,
+        ))
+        .into_untagged_value()
+    }
+    struct CallStub {
+        positionals: Vec<Value>,
+        flags: IndexMap<String, Value>,
+    }
+
+    impl CallStub {
+        fn new() -> CallStub {
+            CallStub {
+                positionals: vec![],
+                flags: indexmap::IndexMap::new(),
+            }
+        }
+
+        fn with_named_parameter(&mut self, name: &str, value: Value) -> &mut Self {
+            self.flags.insert(name.to_string(), value);
+            self
+        }
+
+        fn with_long_flag(&mut self, name: &str) -> &mut Self {
+            self.flags.insert(
+                name.to_string(),
+                UntaggedValue::boolean(true).into_value(Tag::unknown()),
+            );
+            self
+        }
+
+        fn with_parameter(&mut self, name: &str) -> &mut Self {
+            let fields: Vec<Value> = name
+                .split(".")
+                .map(|s| UntaggedValue::string(s.to_string()).into_value(Tag::unknown()))
+                .collect();
+
+            self.positionals.push(column_path(&fields));
+            self
+        }
+
+        fn create(&self) -> CallInfo {
+            CallInfo {
+                args: EvaluatedArgs::new(Some(self.positionals.clone()), Some(self.flags.clone())),
+                name_tag: Tag::unknown(),
+            }
+        }
+    }
+
+    fn structured_sample_record(key: &str, value: &str) -> Value {
+        let mut record = TaggedDictBuilder::new(Tag::unknown());
+        record.insert_untagged(key.clone(), UntaggedValue::string(value));
+        record.into_value()
+    }
+
+    fn unstructured_sample_record(value: &str) -> Value {
+        UntaggedValue::string(value).into_value(Tag::unknown())
+    }
+
+    #[test]
+    fn str_plugin_configuration_flags_wired() {
+        let mut plugin = Str::new();
+
+        let configured = plugin.config().unwrap();
+
+        for action_flag in &[
+            "downcase",
+            "upcase",
+            "to-int",
+            "substring",
+            "replace",
+            "find-replace",
+        ] {
+            assert!(configured.named.get(*action_flag).is_some());
+        }
+    }
+
+    #[test]
+    fn str_plugin_accepts_downcase() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_long_flag("downcase").create())
+            .is_ok());
+        assert_eq!(plugin.action.unwrap(), Action::Downcase);
+    }
+
+    #[test]
+    fn str_plugin_accepts_upcase() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_long_flag("upcase").create())
+            .is_ok());
+        assert_eq!(plugin.action.unwrap(), Action::Upcase);
+    }
+
+    #[test]
+    fn str_plugin_accepts_to_int() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_long_flag("to-int").create())
+            .is_ok());
+        assert_eq!(plugin.action.unwrap(), Action::ToInteger);
+    }
+
+    #[test]
+    fn str_plugin_accepts_replace() {
+        let mut plugin = Str::new();
+
+        let argument = String::from("replace_text");
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter("replace", string(&argument))
+                    .create()
+            )
+            .is_ok());
+
+        match plugin.action {
+            Some(Action::Replace(ReplaceAction::Direct(replace_with))) => {
+                assert_eq!(replace_with, argument)
+            }
+            Some(_) | None => panic!("Din't accept."),
+        }
+    }
+
+    #[test]
+    fn str_plugin_accepts_find_replace() {
+        let mut plugin = Str::new();
+
+        let search_argument = String::from("kittens");
+        let replace_argument = String::from("jotandrehuda");
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter(
+                        "find-replace",
+                        table(&vec![string(&search_argument), string(&replace_argument)])
+                    )
+                    .create()
+            )
+            .is_ok());
+
+        match plugin.action {
+            Some(Action::Replace(ReplaceAction::FindAndReplace(find_with, replace_with))) => {
+                assert_eq!(find_with, search_argument);
+                assert_eq!(replace_with, replace_argument);
+            }
+            Some(_) | None => panic!("Din't accept."),
+        }
+    }
+    #[test]
+    fn str_plugin_accepts_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_parameter("package.description")
+                    .create()
+            )
+            .is_ok());
+
+        let actual = &*plugin.field.unwrap();
+        let actual = UntaggedValue::Primitive(Primitive::ColumnPath(actual.clone()));
+        let actual = actual.into_value(Tag::unknown());
+
+        assert_eq!(
+            actual,
+            column_path(&vec![string("package"), string("description")])
+        )
+    }
+
+    #[test]
+    fn str_plugin_accepts_only_one_action() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_long_flag("upcase")
+                    .with_long_flag("downcase")
+                    .with_long_flag("to-int")
+                    .with_long_flag("substring")
+                    .create(),
+            )
+            .is_err());
+        assert_eq!(plugin.error, Some("can only apply one".to_string()));
+    }
+
+    #[test]
+    fn str_downcases() {
+        let mut strutils = Str::new();
+        strutils.for_downcase();
+        assert_eq!(
+            strutils.apply("ANDRES").unwrap(),
+            UntaggedValue::string("andres")
+        );
+    }
+
+    #[test]
+    fn str_upcases() {
+        let mut strutils = Str::new();
+        strutils.for_upcase();
+        assert_eq!(
+            strutils.apply("andres").unwrap(),
+            UntaggedValue::string("ANDRES")
+        );
+    }
+
+    #[test]
+    fn str_to_int() {
+        let mut strutils = Str::new();
+        strutils.for_to_int();
+        assert_eq!(
+            strutils.apply("9999").unwrap(),
+            UntaggedValue::int(9999 as i64)
+        );
+    }
+
+    #[test]
+    fn str_replace() {
+        let mut strutils = Str::new();
+        strutils.for_replace(ReplaceAction::Direct("robalino".to_string()));
+
+        assert_eq!(
+            strutils.apply("andres").unwrap(),
+            UntaggedValue::string("robalino")
+        );
+    }
+
+    #[test]
+    fn str_find_replace() {
+        let mut strutils = Str::new();
+        strutils.for_replace(ReplaceAction::FindAndReplace(
+            "kittens".to_string(),
+            "jotandrehuda".to_string(),
+        ));
+        assert_eq!(
+            strutils.apply("wykittens").unwrap(),
+            UntaggedValue::string("wyjotandrehuda")
+        );
+    }
+
+    #[test]
+    fn str_plugin_applies_upcase_with_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_long_flag("upcase")
+                    .with_parameter("name")
+                    .create()
+            )
+            .is_ok());
+
+        let subject = structured_sample_record("name", "jotandrehuda");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Row(o),
+                ..
+            }) => assert_eq!(
+                *o.get_data(&String::from("name")).borrow(),
+                UntaggedValue::string(String::from("JOTANDREHUDA")).into_untagged_value()
+            ),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_upcase_without_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_long_flag("upcase").create())
+            .is_ok());
+
+        let subject = unstructured_sample_record("jotandrehuda");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::String(s)),
+                ..
+            }) => assert_eq!(*s, String::from("JOTANDREHUDA")),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_downcase_with_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_long_flag("downcase")
+                    .with_parameter("name")
+                    .create()
+            )
+            .is_ok());
+
+        let subject = structured_sample_record("name", "JOTANDREHUDA");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Row(o),
+                ..
+            }) => assert_eq!(
+                *o.get_data(&String::from("name")).borrow(),
+                UntaggedValue::string(String::from("jotandrehuda")).into_untagged_value()
+            ),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_downcase_without_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_long_flag("downcase").create())
+            .is_ok());
+
+        let subject = unstructured_sample_record("JOTANDREHUDA");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::String(s)),
+                ..
+            }) => assert_eq!(*s, String::from("jotandrehuda")),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_to_int_with_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_long_flag("to-int")
+                    .with_parameter("Nu_birthday")
+                    .create()
+            )
+            .is_ok());
+
+        let subject = structured_sample_record("Nu_birthday", "10");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Row(o),
+                ..
+            }) => assert_eq!(
+                *o.get_data(&String::from("Nu_birthday")).borrow(),
+                UntaggedValue::int(10).into_untagged_value()
+            ),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_to_int_without_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(CallStub::new().with_long_flag("to-int").create())
+            .is_ok());
+
+        let subject = unstructured_sample_record("10");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::Int(i)),
+                ..
+            }) => assert_eq!(*i, BigInt::from(10)),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_substring_without_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter("substring", string("0,1"))
+                    .create()
+            )
+            .is_ok());
+
+        let subject = unstructured_sample_record("0123456789");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::String(s)),
+                ..
+            }) => assert_eq!(*s, String::from("0")),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_substring_exceeding_string_length() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter("substring", string("0,11"))
+                    .create()
+            )
+            .is_ok());
+
+        let subject = unstructured_sample_record("0123456789");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::String(s)),
+                ..
+            }) => assert_eq!(*s, String::from("0123456789")),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_substring_returns_blank_if_start_exceeds_length() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter("substring", string("20,30"))
+                    .create()
+            )
+            .is_ok());
+
+        let subject = unstructured_sample_record("0123456789");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::String(s)),
+                ..
+            }) => assert_eq!(*s, String::from("")),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_substring_treats_blank_start_as_zero() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter("substring", string(",5"))
+                    .create()
+            )
+            .is_ok());
+
+        let subject = unstructured_sample_record("0123456789");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::String(s)),
+                ..
+            }) => assert_eq!(*s, String::from("01234")),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_substring_treats_blank_end_as_length() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter("substring", string("2,"))
+                    .create()
+            )
+            .is_ok());
+
+        let subject = unstructured_sample_record("0123456789");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::String(s)),
+                ..
+            }) => assert_eq!(*s, String::from("23456789")),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_substring_returns_error_if_start_exceeds_end() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter("substring", string("3,1"))
+                    .create()
+            )
+            .is_err());
+        assert_eq!(
+            plugin.error,
+            Some("End must be greater than or equal to Start".to_string())
+        );
+    }
+
+    #[test]
+    fn str_plugin_applies_replace_with_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_parameter("rustconf")
+                    .with_named_parameter("replace", string("22nd August 2019"))
+                    .create()
+            )
+            .is_ok());
+
+        let subject = structured_sample_record("rustconf", "1st January 1970");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Row(o),
+                ..
+            }) => assert_eq!(
+                *o.get_data(&String::from("rustconf")).borrow(),
+                Value {
+                    value: UntaggedValue::string(String::from("22nd August 2019")),
+                    tag: Tag::unknown()
+                }
+            ),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_replace_without_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter("replace", string("22nd August 2019"))
+                    .create()
+            )
+            .is_ok());
+
+        let subject = unstructured_sample_record("1st January 1970");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::String(s)),
+                ..
+            }) => assert_eq!(*s, String::from("22nd August 2019")),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_find_replace_with_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_parameter("staff")
+                    .with_named_parameter(
+                        "find-replace",
+                        table(&vec![string("kittens"), string("jotandrehuda")])
+                    )
+                    .create()
+            )
+            .is_ok());
+
+        let subject = structured_sample_record("staff", "wykittens");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Row(o),
+                ..
+            }) => assert_eq!(
+                *o.get_data(&String::from("staff")).borrow(),
+                Value {
+                    value: UntaggedValue::string(String::from("wyjotandrehuda")),
+                    tag: Tag::unknown()
+                }
+            ),
+            _ => {}
+        }
+    }
+
+    #[test]
+    fn str_plugin_applies_find_replace_without_field() {
+        let mut plugin = Str::new();
+
+        assert!(plugin
+            .begin_filter(
+                CallStub::new()
+                    .with_named_parameter(
+                        "find-replace",
+                        table(&vec![string("kittens"), string("jotandrehuda")])
+                    )
+                    .create()
+            )
+            .is_ok());
+
+        let subject = unstructured_sample_record("wykittens");
+        let output = plugin.filter(subject).unwrap();
+
+        match output[0].as_ref().unwrap() {
+            ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(Primitive::String(s)),
+                ..
+            }) => assert_eq!(*s, String::from("wyjotandrehuda")),
+            _ => {}
+        }
+    }
+}

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());
+}

crates/nu_plugin_tree/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "nu_plugin_tree"
+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" }
+ptree = {version = "0.2" }
+derive-new = "0.5.8"
+
+[build-dependencies]
+nu-build = { version = "0.1.0", path = "../nu-build" }

crates/nu_plugin_tree/build.rs

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

crates/nu_plugin_tree/src/main.rs

@@ -0,0 +1,102 @@
+use derive_new::new;
+use nu_errors::ShellError;
+use nu_protocol::{
+    format_primitive, serve_plugin, CallInfo, Plugin, Signature, UntaggedValue, Value,
+};
+use ptree::item::StringItem;
+use ptree::output::print_tree_with;
+use ptree::print_config::PrintConfig;
+use ptree::style::{Color, Style};
+use ptree::TreeBuilder;
+
+#[derive(new)]
+pub struct TreeView {
+    tree: StringItem,
+}
+
+impl TreeView {
+    fn from_value_helper(value: &UntaggedValue, mut builder: &mut TreeBuilder) {
+        match value {
+            UntaggedValue::Primitive(p) => {
+                let _ = builder.add_empty_child(format_primitive(p, None));
+            }
+            UntaggedValue::Row(o) => {
+                for (k, v) in o.entries.iter() {
+                    builder = builder.begin_child(k.clone());
+                    Self::from_value_helper(v, builder);
+                    builder = builder.end_child();
+                }
+            }
+            UntaggedValue::Table(l) => {
+                for elem in l.iter() {
+                    Self::from_value_helper(elem, builder);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn from_value(value: &Value) -> TreeView {
+        let descs = value.data_descriptors();
+
+        let mut tree = TreeBuilder::new("".to_string());
+        let mut builder = &mut tree;
+
+        for desc in descs {
+            let value = match &value.value {
+                UntaggedValue::Row(d) => d.get_data(&desc).borrow().clone(),
+                _ => value.clone(),
+            };
+            builder = builder.begin_child(desc.clone());
+            Self::from_value_helper(&value, &mut builder);
+            builder = builder.end_child();
+            //entries.push((desc.name.clone(), value.borrow().copy()))
+        }
+
+        TreeView::new(builder.build())
+    }
+
+    fn render_view(&self) -> Result<(), ShellError> {
+        // Set up the print configuration
+        let config = {
+            let mut config = PrintConfig::from_env();
+            config.branch = Style {
+                foreground: Some(Color::Green),
+                dimmed: true,
+                ..Style::default()
+            };
+            config.leaf = Style {
+                bold: true,
+                ..Style::default()
+            };
+            config.indent = 4;
+            config
+        };
+
+        // Print out the tree using custom formatting
+        print_tree_with(&self.tree, &config)?;
+
+        Ok(())
+    }
+}
+
+struct TreeViewer;
+
+impl Plugin for TreeViewer {
+    fn config(&mut self) -> Result<Signature, ShellError> {
+        Ok(Signature::build("tree").desc("View the contents of the pipeline as a tree."))
+    }
+
+    fn sink(&mut self, _call_info: CallInfo, input: Vec<Value>) {
+        if input.len() > 0 {
+            for i in input.iter() {
+                let view = TreeView::from_value(&i);
+                let _ = view.render_view();
+            }
+        }
+    }
+}
+
+fn main() {
+    serve_plugin(&mut TreeViewer);
+}