Nu plugins now depend on nu-plugin crate.

crates/nu-plugin/src/lib.rs

@@ -0,0 +1,4 @@
+mod plugin;
+pub mod test_helpers;
+
+pub use crate::plugin::{serve_plugin, Plugin};

crates/nu-plugin/src/plugin.rs

@@ -0,0 +1,159 @@
+use nu_errors::ShellError;
+use nu_protocol::{outln, CallInfo, ReturnValue, Signature, Value};
+use serde::{Deserialize, Serialize};
+use std::io;
+
+pub trait Plugin {
+    fn config(&mut self) -> Result<Signature, ShellError>;
+
+    fn begin_filter(&mut self, _call_info: CallInfo) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(vec![])
+    }
+
+    fn filter(&mut self, _input: Value) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(vec![])
+    }
+
+    fn end_filter(&mut self) -> Result<Vec<ReturnValue>, ShellError> {
+        Ok(vec![])
+    }
+
+    fn sink(&mut self, _call_info: CallInfo, _input: Vec<Value>) {}
+
+    fn quit(&mut self) {}
+}
+
+pub fn serve_plugin(plugin: &mut dyn Plugin) {
+    let args = std::env::args();
+    if args.len() > 1 {
+        let input = args.skip(1).next();
+
+        let input = match input {
+            Some(arg) => std::fs::read_to_string(arg),
+            None => {
+                send_response(ShellError::untagged_runtime_error("No input given."));
+                return;
+            }
+        };
+
+        if let Ok(input) = input {
+            let command = serde_json::from_str::<NuCommand>(&input);
+            match command {
+                Ok(NuCommand::config) => {
+                    send_response(plugin.config());
+                    return;
+                }
+                Ok(NuCommand::begin_filter { params }) => {
+                    send_response(plugin.begin_filter(params));
+                }
+                Ok(NuCommand::filter { params }) => {
+                    send_response(plugin.filter(params));
+                }
+                Ok(NuCommand::end_filter) => {
+                    send_response(plugin.end_filter());
+                    return;
+                }
+
+                Ok(NuCommand::sink { params }) => {
+                    plugin.sink(params.0, params.1);
+                    return;
+                }
+                Ok(NuCommand::quit) => {
+                    plugin.quit();
+                    return;
+                }
+                e => {
+                    send_response(ShellError::untagged_runtime_error(format!(
+                        "Could not handle plugin message: {} {:?}",
+                        input, e
+                    )));
+                    return;
+                }
+            }
+        }
+    } else {
+        loop {
+            let mut input = String::new();
+            match io::stdin().read_line(&mut input) {
+                Ok(_) => {
+                    let command = serde_json::from_str::<NuCommand>(&input);
+                    match command {
+                        Ok(NuCommand::config) => {
+                            send_response(plugin.config());
+                            break;
+                        }
+                        Ok(NuCommand::begin_filter { params }) => {
+                            send_response(plugin.begin_filter(params));
+                        }
+                        Ok(NuCommand::filter { params }) => {
+                            send_response(plugin.filter(params));
+                        }
+                        Ok(NuCommand::end_filter) => {
+                            send_response(plugin.end_filter());
+                            break;
+                        }
+                        Ok(NuCommand::sink { params }) => {
+                            plugin.sink(params.0, params.1);
+                            break;
+                        }
+                        Ok(NuCommand::quit) => {
+                            plugin.quit();
+                            break;
+                        }
+                        e => {
+                            send_response(ShellError::untagged_runtime_error(format!(
+                                "Could not handle plugin message: {} {:?}",
+                                input, e
+                            )));
+                            break;
+                        }
+                    }
+                }
+                e => {
+                    send_response(ShellError::untagged_runtime_error(format!(
+                        "Could not handle plugin message: {:?}",
+                        e,
+                    )));
+                    break;
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct JsonRpc<T> {
+    jsonrpc: String,
+    pub method: String,
+    pub params: T,
+}
+impl<T> JsonRpc<T> {
+    pub fn new<U: Into<String>>(method: U, params: T) -> Self {
+        JsonRpc {
+            jsonrpc: "2.0".into(),
+            method: method.into(),
+            params,
+        }
+    }
+}
+
+fn send_response<T: Serialize>(result: T) {
+    let response = JsonRpc::new("response", result);
+    let response_raw = serde_json::to_string(&response);
+
+    match response_raw {
+        Ok(response) => outln!("{}", response),
+        Err(err) => outln!("{}", err),
+    }
+}
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "method")]
+#[allow(non_camel_case_types)]
+pub enum NuCommand {
+    config,
+    begin_filter { params: CallInfo },
+    filter { params: Value },
+    end_filter,
+    sink { params: (CallInfo, Vec<Value>) },
+    quit,
+}

crates/nu-plugin/src/test_helpers.rs

@@ -0,0 +1,159 @@
+use crate::Plugin;
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use nu_protocol::{CallInfo, EvaluatedArgs, Primitive, ReturnValue, UntaggedValue, Value};
+use nu_source::Tag;
+use nu_value_ext::ValueExt;
+
+pub struct PluginTest<'a, T: Plugin> {
+    plugin: &'a mut T,
+    call_info: CallInfo,
+    input: Value,
+}
+
+impl<'a, T: Plugin> PluginTest<'a, T> {
+    pub fn for_plugin(plugin: &'a mut T) -> Self {
+        PluginTest {
+            plugin: plugin,
+            call_info: CallStub::new().create(),
+            input: UntaggedValue::nothing().into_value(Tag::unknown()),
+        }
+    }
+
+    pub fn args(&mut self, call_info: CallInfo) -> &mut PluginTest<'a, T> {
+        self.call_info = call_info;
+        self
+    }
+
+    pub fn configure(&mut self, callback: impl FnOnce(Vec<String>)) -> &mut PluginTest<'a, T> {
+        let signature = self
+            .plugin
+            .config()
+            .expect("There was a problem configuring the plugin.");
+        callback(signature.named.keys().map(String::from).collect());
+        self
+    }
+
+    pub fn input(&mut self, value: Value) -> &mut PluginTest<'a, T> {
+        self.input = value;
+        self
+    }
+
+    pub fn test(&mut self) -> Result<Vec<ReturnValue>, ShellError> {
+        let return_values = self.plugin.filter(self.input.clone());
+
+        let mut return_values = match return_values {
+            Ok(filtered) => filtered,
+            Err(reason) => return Err(reason),
+        };
+
+        let end = self.plugin.end_filter();
+
+        match end {
+            Ok(filter_ended) => return_values.extend(filter_ended),
+            Err(reason) => return Err(reason),
+        }
+
+        self.plugin.quit();
+        Ok(return_values)
+    }
+
+    pub fn setup(
+        &mut self,
+        callback: impl FnOnce(&mut T, Result<Vec<ReturnValue>, ShellError>),
+    ) -> &mut PluginTest<'a, T> {
+        let call_stub = self.call_info.clone();
+
+        self.configure(|flags_configured| {
+            let flags_registered = &call_stub.args.named;
+
+            let flag_passed = match flags_registered {
+                Some(names) => Some(names.keys().map(String::from).collect::<Vec<String>>()),
+                None => None,
+            };
+
+            if let Some(flags) = flag_passed {
+                for flag in flags {
+                    assert!(
+                        flags_configured.iter().any(|f| *f == flag),
+                        format!(
+                            "The flag you passed ({}) is not configured in the plugin.",
+                            flag
+                        )
+                    );
+                }
+            }
+        });
+
+        let began = self.plugin.begin_filter(call_stub);
+
+        let return_values = match began {
+            Ok(values) => Ok(values),
+            Err(reason) => Err(reason),
+        };
+
+        callback(self.plugin, return_values);
+        self
+    }
+}
+
+pub fn plugin<T: Plugin>(plugin: &mut T) -> PluginTest<T> {
+    PluginTest::for_plugin(plugin)
+}
+
+pub fn table(list: &Vec<Value>) -> Value {
+    UntaggedValue::table(list).into_untagged_value()
+}
+
+pub fn column_path(paths: &Vec<Value>) -> Value {
+    UntaggedValue::Primitive(Primitive::ColumnPath(
+        table(&paths.iter().cloned().collect())
+            .as_column_path()
+            .unwrap()
+            .item,
+    ))
+    .into_untagged_value()
+}
+pub struct CallStub {
+    positionals: Vec<Value>,
+    flags: IndexMap<String, Value>,
+}
+
+impl CallStub {
+    pub fn new() -> CallStub {
+        CallStub {
+            positionals: vec![],
+            flags: indexmap::IndexMap::new(),
+        }
+    }
+
+    pub fn with_named_parameter(&mut self, name: &str, value: Value) -> &mut Self {
+        self.flags.insert(name.to_string(), value);
+        self
+    }
+
+    pub fn with_long_flag(&mut self, name: &str) -> &mut Self {
+        self.flags.insert(
+            name.to_string(),
+            UntaggedValue::boolean(true).into_value(Tag::unknown()),
+        );
+        self
+    }
+
+    pub 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
+    }
+
+    pub fn create(&self) -> CallInfo {
+        CallInfo {
+            args: EvaluatedArgs::new(Some(self.positionals.clone()), Some(self.flags.clone())),
+            name_tag: Tag::unknown(),
+        }
+    }
+}