Remove X11 requirement

src/commands/clip.rs

@@ -1,77 +1,81 @@
-use crate::commands::{CommandArgs, WholeStreamCommand};
-use crate::context::CommandRegistry;
-use crate::errors::{labelled, ShellError};
-use crate::prelude::*;
-use clipboard::{ClipboardContext, ClipboardProvider};
-use futures::stream::StreamExt;
-use futures_async_stream::async_stream_block;
+#[cfg(feature = "clipboard")]
+pub mod clipboard {
+    use crate::commands::WholeStreamCommand;
+    use crate::context::CommandRegistry;
+    use crate::errors::ShellError;
+    use crate::prelude::*;
+    use futures::stream::StreamExt;
+    use futures_async_stream::async_stream_block;
 
-pub struct Clip;
+    use clipboard::{ClipboardContext, ClipboardProvider};
 
-#[derive(Deserialize)]
-pub struct ClipArgs {}
+    pub struct Clip;
 
-impl WholeStreamCommand for Clip {
-    fn name(&self) -> &str {
-        "clip"
-    }
-    fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        args.process(registry, clip)?.run()
-    }
+    #[derive(Deserialize)]
+    pub struct ClipArgs {}
 
-    fn signature(&self) -> Signature {
-        Signature::build("clip")
-    }
-}
+    impl WholeStreamCommand for Clip {
+        fn name(&self) -> &str {
+            "clip"
+        }
+        fn run(
+            &self,
+            args: CommandArgs,
+            registry: &CommandRegistry,
+        ) -> Result<OutputStream, ShellError> {
+            args.process(registry, clip)?.run()
+        }
 
-pub fn clip(
-    ClipArgs {}: ClipArgs,
-    RunnableContext { input, name, .. }: RunnableContext,
-) -> Result<OutputStream, ShellError> {
-    let stream = async_stream_block! {
-        let values: Vec<Tagged<Value>> = input.values.collect().await;
-
-        inner_clip(values, name).await;
-    };
-
-    let stream: BoxStream<'static, ReturnValue> = stream.boxed();
-
-    Ok(OutputStream::from(stream))
-}
-
-async fn inner_clip(input: Vec<Tagged<Value>>, name: Span) -> OutputStream {
-    let mut clip_context: ClipboardContext = ClipboardProvider::new().unwrap();
-    let mut new_copy_data = String::new();
-
-    if input.len() > 0 {
-        let mut first = true;
-        for i in input.iter() {
-            if !first {
-                new_copy_data.push_str("\n");
-            } else {
-                first = false;
-            }
-
-            let s = i.as_string().map_err(labelled(
-                name,
-                "Given non-string data",
-                "expected strings from pipeline",
-            ));
-
-            let string: String = match s {
-                Ok(string) => string,
-                Err(err) => return OutputStream::one(Err(err)),
-            };
-
-            new_copy_data.push_str(&string);
+        fn signature(&self) -> Signature {
+            Signature::build("clip")
         }
     }
 
-    clip_context.set_contents(new_copy_data).unwrap();
+    pub fn clip(
+        ClipArgs {}: ClipArgs,
+        RunnableContext { input, name, .. }: RunnableContext,
+    ) -> Result<OutputStream, ShellError> {
+        let stream = async_stream_block! {
+            let values: Vec<Tagged<Value>> = input.values.collect().await;
 
-    OutputStream::empty()
+            inner_clip(values, name).await;
+        };
+
+        let stream: BoxStream<'static, ReturnValue> = stream.boxed();
+
+        Ok(OutputStream::from(stream))
+    }
+
+    async fn inner_clip(input: Vec<Tagged<Value>>, name: Span) -> OutputStream {
+        let mut clip_context: ClipboardContext = ClipboardProvider::new().unwrap();
+        let mut new_copy_data = String::new();
+
+        if input.len() > 0 {
+            let mut first = true;
+            for i in input.iter() {
+                if !first {
+                    new_copy_data.push_str("\n");
+                } else {
+                    first = false;
+                }
+
+                let string: String = match i.as_string() {
+                    Ok(string) => string,
+                    Err(_) => {
+                        return OutputStream::one(Err(ShellError::labeled_error(
+                            "Given non-string data",
+                            "expected strings from pipeline",
+                            name,
+                        )))
+                    }
+                };
+
+                new_copy_data.push_str(&string);
+            }
+        }
+
+        clip_context.set_contents(new_copy_data).unwrap();
+
+        OutputStream::empty()
+    }
 }

src/commands/command.rs

@@ -102,9 +102,6 @@ pub struct CommandArgs {
     pub host: Arc<Mutex<dyn Host>>,
     pub shell_manager: ShellManager,
     pub call_info: UnevaluatedCallInfo,
-    // pub host: Arc<Mutex<dyn Host + Send>>,
-    // pub shell_manager: ShellManager,
-    // pub call_info: CallInfo,
     pub input: InputStream,
 }