diff --git a/crates/nu-command/src/default_context.rs b/crates/nu-command/src/default_context.rs index c97759eb91..33da80fdf1 100644 --- a/crates/nu-command/src/default_context.rs +++ b/crates/nu-command/src/default_context.rs @@ -149,6 +149,7 @@ pub fn create_default_context() -> EngineState { Ls, Mkdir, Mv, + Open, Rm, Touch, }; diff --git a/crates/nu-command/src/filesystem/ls.rs b/crates/nu-command/src/filesystem/ls.rs index c8537fd2f6..d672785b99 100644 --- a/crates/nu-command/src/filesystem/ls.rs +++ b/crates/nu-command/src/filesystem/ls.rs @@ -1,10 +1,10 @@ use chrono::{DateTime, Utc}; -use nu_engine::eval_expression; +use nu_engine::CallExt; use nu_protocol::ast::Call; use nu_protocol::engine::{Command, EngineState, Stack}; use nu_protocol::{ Category, DataSource, IntoInterruptiblePipelineData, PipelineData, PipelineMetadata, - ShellError, Signature, Span, SyntaxShape, Value, + ShellError, Signature, Span, Spanned, SyntaxShape, Value, }; use std::io::ErrorKind; @@ -42,11 +42,11 @@ impl Command for Ls { "Only print the file names and not the path", Some('s'), ) - .switch( - "du", - "Display the apparent directory size in place of the directory metadata size", - Some('d'), - ) + // .switch( + // "du", + // "Display the apparent directory size in place of the directory metadata size", + // Some('d'), + // ) .category(Category::FileSystem) } @@ -63,22 +63,20 @@ impl Command for Ls { let call_span = call.head; - let (pattern, arg_span) = if let Some(expr) = call.positional.get(0) { - let result = eval_expression(engine_state, stack, expr)?; - let mut result = result.as_string()?; - - let path = std::path::Path::new(&result); - if path.is_dir() { - if !result.ends_with(std::path::MAIN_SEPARATOR) { - result.push(std::path::MAIN_SEPARATOR); + let (pattern, arg_span) = + if let Some(mut result) = call.opt::>(engine_state, stack, 0)? { + let path = std::path::Path::new(&result.item); + if path.is_dir() { + if !result.item.ends_with(std::path::MAIN_SEPARATOR) { + result.item.push(std::path::MAIN_SEPARATOR); + } + result.item.push('*'); } - result.push('*'); - } - (result, expr.span) - } else { - ("*".into(), call_span) - }; + (result.item, result.span) + } else { + ("*".into(), call_span) + }; let glob = glob::glob(&pattern).map_err(|err| { nu_protocol::ShellError::SpannedLabeledError( diff --git a/crates/nu-command/src/filesystem/mod.rs b/crates/nu-command/src/filesystem/mod.rs index db5bc4bea6..cc018756b9 100644 --- a/crates/nu-command/src/filesystem/mod.rs +++ b/crates/nu-command/src/filesystem/mod.rs @@ -3,6 +3,7 @@ mod cp; mod ls; mod mkdir; mod mv; +mod open; mod rm; mod touch; mod util; @@ -12,5 +13,6 @@ pub use cp::Cp; pub use ls::Ls; pub use mkdir::Mkdir; pub use mv::Mv; +pub use open::Open; pub use rm::Rm; pub use touch::Touch; diff --git a/crates/nu-command/src/filesystem/open.rs b/crates/nu-command/src/filesystem/open.rs new file mode 100644 index 0000000000..0115e4a321 --- /dev/null +++ b/crates/nu-command/src/filesystem/open.rs @@ -0,0 +1,160 @@ +use nu_engine::CallExt; +use nu_protocol::ast::Call; +use nu_protocol::engine::{Command, EngineState, Stack}; +use nu_protocol::{ + ByteStream, Category, PipelineData, ShellError, Signature, Spanned, SyntaxShape, Value, +}; +use std::io::{BufRead, BufReader, Read}; + +#[cfg(unix)] +use std::os::unix::fs::PermissionsExt; +use std::path::Path; + +#[derive(Clone)] +pub struct Open; + +//NOTE: this is not a real implementation :D. It's just a simple one to test with until we port the real one. +impl Command for Open { + fn name(&self) -> &str { + "open" + } + + fn usage(&self) -> &str { + "List the files in a directory." + } + + fn signature(&self) -> nu_protocol::Signature { + Signature::build("open") + .required( + "filename", + SyntaxShape::GlobPattern, + "the glob pattern to use", + ) + .switch("raw", "open file as binary", Some('r')) + .category(Category::FileSystem) + } + + fn run( + &self, + engine_state: &EngineState, + stack: &mut Stack, + call: &Call, + _input: PipelineData, + ) -> Result { + let raw = call.has_flag("raw"); + + let call_span = call.head; + let ctrlc = engine_state.ctrlc.clone(); + + let path = call.req::>(engine_state, stack, 0)?; + let arg_span = path.span; + let path = Path::new(&path.item); + + if permission_denied(&path) { + #[cfg(unix)] + let error_msg = format!( + "The permissions of {:o} do not allow access for this user", + path.metadata() + .expect("this shouldn't be called since we already know there is a dir") + .permissions() + .mode() + & 0o0777 + ); + #[cfg(not(unix))] + let error_msg = String::from("Permission denied"); + Ok(PipelineData::Value( + Value::Error { + error: ShellError::SpannedLabeledError( + "Permission denied".into(), + error_msg, + arg_span, + ), + }, + None, + )) + } else { + let file = match std::fs::File::open(path) { + Ok(file) => file, + Err(err) => { + return Ok(PipelineData::Value( + Value::Error { + error: ShellError::SpannedLabeledError( + "Permission denied".into(), + err.to_string(), + arg_span, + ), + }, + None, + )); + } + }; + + let buf_reader = BufReader::new(file); + + let output = PipelineData::ByteStream( + ByteStream { + stream: Box::new(BufferedReader { input: buf_reader }), + ctrlc, + }, + call_span, + None, + ); + + let ext = if raw { + None + } else { + path.extension() + .map(|name| name.to_string_lossy().to_string()) + }; + + if let Some(ext) = ext { + match engine_state.find_decl(format!("from {}", ext).as_bytes()) { + Some(converter_id) => engine_state.get_decl(converter_id).run( + engine_state, + stack, + &Call::new(), + output, + ), + None => Ok(output), + } + } else { + Ok(output) + } + } + } +} + +fn permission_denied(dir: impl AsRef) -> bool { + match dir.as_ref().read_dir() { + Err(e) => matches!(e.kind(), std::io::ErrorKind::PermissionDenied), + Ok(_) => false, + } +} + +pub struct BufferedReader { + input: BufReader, +} + +impl Iterator for BufferedReader { + type Item = Result, ShellError>; + + fn next(&mut self) -> Option { + let buffer = self.input.fill_buf(); + match buffer { + Ok(s) => { + let result = s.to_vec(); + + let buffer_len = s.len(); + + if buffer_len == 0 { + None + } else { + self.input.consume(buffer_len); + + Some(Ok(result)) + } + } + Err(e) => Some(Err(ShellError::IOError(e.to_string()))), + } + } +} diff --git a/crates/nu-command/src/filters/each.rs b/crates/nu-command/src/filters/each.rs index 436786b517..334bbb2c88 100644 --- a/crates/nu-command/src/filters/each.rs +++ b/crates/nu-command/src/filters/each.rs @@ -113,7 +113,10 @@ impl Command for Each { .into_iter() .enumerate() .map(move |(idx, x)| { - let x = Value::Binary { val: x, span }; + let x = match x { + Ok(x) => Value::Binary { val: x, span }, + Err(err) => return Value::Error { error: err }, + }; if let Some(var) = block.signature.get_positional(0) { if let Some(var_id) = &var.var_id { diff --git a/crates/nu-command/src/filters/par_each.rs b/crates/nu-command/src/filters/par_each.rs index 13016e4403..0344a6e937 100644 --- a/crates/nu-command/src/filters/par_each.rs +++ b/crates/nu-command/src/filters/par_each.rs @@ -227,7 +227,11 @@ impl Command for ParEach { .enumerate() .par_bridge() .map(move |(idx, x)| { - let x = Value::Binary { val: x, span }; + let x = match x { + Ok(x) => Value::Binary { val: x, span }, + Err(err) => return Value::Error { error: err }.into_pipeline_data(), + }; + let block = engine_state.get_block(block_id); let mut stack = stack.clone(); diff --git a/crates/nu-command/src/filters/wrap.rs b/crates/nu-command/src/filters/wrap.rs index 4309882a30..9e7f808ed9 100644 --- a/crates/nu-command/src/filters/wrap.rs +++ b/crates/nu-command/src/filters/wrap.rs @@ -56,7 +56,7 @@ impl Command for Wrap { } .into_pipeline_data()), PipelineData::ByteStream(stream, ..) => Ok(Value::Binary { - val: stream.into_vec(), + val: stream.into_vec()?, span, } .into_pipeline_data()), diff --git a/crates/nu-command/src/strings/decode.rs b/crates/nu-command/src/strings/decode.rs index 0616511fc2..18db03aede 100644 --- a/crates/nu-command/src/strings/decode.rs +++ b/crates/nu-command/src/strings/decode.rs @@ -45,7 +45,7 @@ impl Command for Decode { match input { PipelineData::ByteStream(stream, ..) => { - let bytes: Vec = stream.flatten().collect(); + let bytes: Vec = stream.into_vec()?; let encoding = match Encoding::for_label(encoding.item.as_bytes()) { None => Err(ShellError::SpannedLabeledError( diff --git a/crates/nu-command/src/system/run_external.rs b/crates/nu-command/src/system/run_external.rs index 7113c767b7..db2fcbb272 100644 --- a/crates/nu-command/src/system/run_external.rs +++ b/crates/nu-command/src/system/run_external.rs @@ -359,11 +359,11 @@ impl ChannelReceiver { } impl Iterator for ChannelReceiver { - type Item = Vec; + type Item = Result, ShellError>; fn next(&mut self) -> Option { match self.rx.recv() { - Ok(v) => Some(v), + Ok(v) => Some(Ok(v)), Err(_) => None, } } diff --git a/crates/nu-command/src/viewers/table.rs b/crates/nu-command/src/viewers/table.rs index 4ad9749a75..1cedad77c6 100644 --- a/crates/nu-command/src/viewers/table.rs +++ b/crates/nu-command/src/viewers/table.rs @@ -65,9 +65,9 @@ impl Command for Table { StringStream::from_stream( stream.map(move |x| { Ok(if x.iter().all(|x| x.is_ascii()) { - format!("{}", String::from_utf8_lossy(&x)) + format!("{}", String::from_utf8_lossy(&x?)) } else { - format!("{}\n", nu_pretty_hex::pretty_hex(&x)) + format!("{}\n", nu_pretty_hex::pretty_hex(&x?)) }) }), ctrlc, diff --git a/crates/nu-plugin/src/plugin/declaration.rs b/crates/nu-plugin/src/plugin/declaration.rs index 62c41c3445..500cf86955 100644 --- a/crates/nu-plugin/src/plugin/declaration.rs +++ b/crates/nu-plugin/src/plugin/declaration.rs @@ -89,7 +89,7 @@ impl Command for PluginDeclaration { } } PipelineData::ByteStream(stream, ..) => { - let val = stream.into_vec(); + let val = stream.into_vec()?; Value::Binary { val, diff --git a/crates/nu-protocol/src/pipeline_data.rs b/crates/nu-protocol/src/pipeline_data.rs index b6c85991a8..75fc9799e5 100644 --- a/crates/nu-protocol/src/pipeline_data.rs +++ b/crates/nu-protocol/src/pipeline_data.rs @@ -87,10 +87,21 @@ impl PipelineData { span, // FIXME? } } - PipelineData::ByteStream(s, ..) => Value::Binary { - val: s.flatten().collect(), - span, // FIXME? - }, + PipelineData::ByteStream(s, ..) => { + let mut output = vec![]; + + for item in s { + match item { + Ok(s) => output.extend(&s), + Err(err) => return Value::Error { error: err }, + } + } + + Value::Binary { + val: output, + span, // FIXME? + } + } } } @@ -110,7 +121,7 @@ impl PipelineData { PipelineData::ListStream(s, ..) => Ok(s.into_string(separator, config)), PipelineData::StringStream(s, ..) => s.into_string(separator), PipelineData::ByteStream(s, ..) => { - Ok(String::from_utf8_lossy(&s.flatten().collect::>()).to_string()) + Ok(String::from_utf8_lossy(&s.into_vec()?).to_string()) } } } @@ -324,9 +335,12 @@ impl Iterator for PipelineIterator { }, Err(err) => Value::Error { error: err }, }), - PipelineData::ByteStream(stream, span, ..) => stream.next().map(|x| Value::Binary { - val: x, - span: *span, + PipelineData::ByteStream(stream, span, ..) => stream.next().map(|x| match x { + Ok(x) => Value::Binary { + val: x, + span: *span, + }, + Err(err) => Value::Error { error: err }, }), } } diff --git a/crates/nu-protocol/src/value/stream.rs b/crates/nu-protocol/src/value/stream.rs index 9497886541..3529b086ea 100644 --- a/crates/nu-protocol/src/value/stream.rs +++ b/crates/nu-protocol/src/value/stream.rs @@ -10,12 +10,17 @@ use std::{ /// A single buffer of binary data streamed over multiple parts. Optionally contains ctrl-c that can be used /// to break the stream. pub struct ByteStream { - pub stream: Box> + Send + 'static>, + pub stream: Box, ShellError>> + Send + 'static>, pub ctrlc: Option>, } impl ByteStream { - pub fn into_vec(self) -> Vec { - self.flatten().collect::>() + pub fn into_vec(self) -> Result, ShellError> { + let mut output = vec![]; + for item in self.stream { + output.append(&mut item?); + } + + Ok(output) } } impl Debug for ByteStream { @@ -25,7 +30,7 @@ impl Debug for ByteStream { } impl Iterator for ByteStream { - type Item = Vec; + type Item = Result, ShellError>; fn next(&mut self) -> Option { if let Some(ctrlc) = &self.ctrlc { diff --git a/src/main.rs b/src/main.rs index 9653f7e03a..4ede9ef4ea 100644 --- a/src/main.rs +++ b/src/main.rs @@ -594,9 +594,9 @@ fn print_pipeline_data( PipelineData::ByteStream(stream, _, _) => { for v in stream { let s = if v.iter().all(|x| x.is_ascii()) { - format!("{}", String::from_utf8_lossy(&v)) + format!("{}", String::from_utf8_lossy(&v?)) } else { - format!("{}\n", nu_pretty_hex::pretty_hex(&v)) + format!("{}\n", nu_pretty_hex::pretty_hex(&v?)) }; println!("{}", s); }