diff --git a/crates/nu-command/src/default_context.rs b/crates/nu-command/src/default_context.rs index d6556a1c63..756412c540 100644 --- a/crates/nu-command/src/default_context.rs +++ b/crates/nu-command/src/default_context.rs @@ -65,6 +65,7 @@ pub fn create_default_context() -> EngineState { Mv, ParEach, Ps, + Range, Rm, Select, Size, diff --git a/crates/nu-command/src/filters/mod.rs b/crates/nu-command/src/filters/mod.rs index 595fe396cd..f322ca3092 100644 --- a/crates/nu-command/src/filters/mod.rs +++ b/crates/nu-command/src/filters/mod.rs @@ -4,6 +4,7 @@ mod last; mod length; mod lines; mod par_each; +mod range; mod select; mod where_; mod wrap; @@ -14,6 +15,7 @@ pub use last::Last; pub use length::Length; pub use lines::Lines; pub use par_each::ParEach; +pub use range::Range; pub use select::Select; pub use where_::Where; pub use wrap::Wrap; diff --git a/crates/nu-command/src/filters/range.rs b/crates/nu-command/src/filters/range.rs new file mode 100644 index 0000000000..0280f51822 --- /dev/null +++ b/crates/nu-command/src/filters/range.rs @@ -0,0 +1,127 @@ +use nu_engine::CallExt; + +use nu_protocol::ast::Call; +use nu_protocol::engine::{Command, EngineState, Stack}; +use nu_protocol::{ + Example, IntoInterruptiblePipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape, + Value, +}; + +#[derive(Clone)] +pub struct Range; + +impl Command for Range { + fn name(&self) -> &str { + "range" + } + + fn signature(&self) -> Signature { + Signature::build("range").optional( + "rows", + SyntaxShape::Range, + "range of rows to return: Eg) 4..7 (=> from 4 to 7)", + ) + } + + fn usage(&self) -> &str { + "Return only the selected rows." + } + + fn examples(&self) -> Vec { + vec![ + Example { + example: "[0,1,2,3,4,5] | range 4..5", + description: "Get the last 2 items", + result: Some(Value::List { + vals: vec![Value::test_int(4), Value::test_int(5)], + span: Span::unknown(), + }), + }, + Example { + example: "[0,1,2,3,4,5] | range (-2)..", + description: "Get the last 2 items", + result: Some(Value::List { + vals: vec![Value::test_int(4), Value::test_int(5)], + span: Span::unknown(), + }), + }, + Example { + example: "[0,1,2,3,4,5] | range (-3)..-2", + description: "Get the next to last 2 items", + result: Some(Value::List { + vals: vec![Value::test_int(3), Value::test_int(4)], + span: Span::unknown(), + }), + }, + ] + } + + fn run( + &self, + engine_state: &EngineState, + stack: &mut Stack, + call: &Call, + input: PipelineData, + ) -> Result { + let rows: nu_protocol::Range = call.req(engine_state, stack, 0)?; + + let rows_from = get_range_val(rows.from); + let rows_to = get_range_val(rows.to); + + // only collect the input if we have any negative indices + if rows_from < 0 || rows_to < 0 { + let v: Vec<_> = input.into_iter().collect(); + let vlen: i64 = v.len() as i64; + + let from = if rows_from < 0 { + (vlen + rows_from) as usize + } else { + rows_from as usize + }; + + let to = if rows_to < 0 { + (vlen + rows_to) as usize + } else if rows_to > v.len() as i64 { + v.len() + } else { + rows_to as usize + }; + + if from > to { + Ok(PipelineData::Value(Value::Nothing { span: call.head })) + } else { + let iter = v.into_iter().skip(from).take(to - from + 1); + Ok(iter.into_pipeline_data(engine_state.ctrlc.clone())) + } + } else { + let from = rows_from as usize; + let to = rows_to as usize; + + if from > to { + Ok(PipelineData::Value(Value::Nothing { span: call.head })) + } else { + let iter = input.into_iter().skip(from).take(to - from + 1); + Ok(iter.into_pipeline_data(engine_state.ctrlc.clone())) + } + } + } +} + +fn get_range_val(rows_val: Value) -> i64 { + match rows_val { + Value::Int { val: x, .. } => x, + _ => 0, + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn test_examples() { + use crate::test_examples; + + test_examples(Range {}) + } +} diff --git a/crates/nu-engine/src/eval.rs b/crates/nu-engine/src/eval.rs index 2a568b7901..396eab3839 100644 --- a/crates/nu-engine/src/eval.rs +++ b/crates/nu-engine/src/eval.rs @@ -1,7 +1,7 @@ use nu_protocol::ast::{Block, Call, Expr, Expression, Operator, Statement}; use nu_protocol::engine::{EngineState, Stack}; use nu_protocol::{ - IntoPipelineData, PipelineData, Range, ShellError, Span, Spanned, Type, Unit, Value, + IntoPipelineData, PipelineData, Range, ShellError, Span, Spanned, Type, Unit, Value, VarId, }; use crate::get_full_help; @@ -210,9 +210,7 @@ pub fn eval_expression( span: expr.span, }) } - Expr::Var(var_id) => stack - .get_var(*var_id) - .map_err(move |_| ShellError::VariableNotFoundAtRuntime(expr.span)), + Expr::Var(var_id) => eval_variable(engine_state, stack, *var_id, expr.span), Expr::VarDecl(_) => Ok(Value::Nothing { span: expr.span }), Expr::CellPath(cell_path) => Ok(Value::CellPath { val: cell_path.clone(), @@ -372,6 +370,73 @@ pub fn eval_block( Ok(input) } +pub fn eval_variable( + _engine_state: &EngineState, + stack: &Stack, + var_id: VarId, + span: Span, +) -> Result { + if var_id == 0 { + // $nu + let mut output_cols = vec![]; + let mut output_vals = vec![]; + + let env_columns: Vec<_> = stack.get_env_vars().keys().map(|x| x.to_string()).collect(); + let env_values: Vec<_> = stack + .get_env_vars() + .values() + .map(|x| Value::String { + val: x.to_string(), + span, + }) + .collect(); + + output_cols.push("env".into()); + output_vals.push(Value::Record { + cols: env_columns, + vals: env_values, + span, + }); + + if let Some(mut config_path) = nu_path::config_dir() { + config_path.push("nushell"); + + let mut history_path = config_path.clone(); + + history_path.push("history.txt"); + + output_cols.push("history-path".into()); + output_vals.push(Value::String { + val: history_path.to_string_lossy().to_string(), + span, + }); + + config_path.push("config.nu"); + + output_cols.push("config-path".into()); + output_vals.push(Value::String { + val: config_path.to_string_lossy().to_string(), + span, + }); + } + + if let Ok(cwd) = std::env::var("PWD") { + output_cols.push("pwd".into()); + output_vals.push(Value::String { val: cwd, span }) + } + + Ok(Value::Record { + cols: output_cols, + vals: output_vals, + span, + }) + } else { + stack + .get_var(var_id) + .map_err(move |_| ShellError::VariableNotFoundAtRuntime(span)) + } +} + pub fn compute(size: i64, unit: Unit, span: Span) -> Value { match unit { Unit::Byte => Value::Filesize { val: size, span }, diff --git a/crates/nu-parser/src/parser.rs b/crates/nu-parser/src/parser.rs index 893c5f492e..14a437d8e0 100644 --- a/crates/nu-parser/src/parser.rs +++ b/crates/nu-parser/src/parser.rs @@ -1182,6 +1182,16 @@ pub fn parse_variable_expr( }, None, ); + } else if contents == b"$nu" { + return ( + Expression { + expr: Expr::Var(0), + span, + ty: Type::Unknown, + custom_completion: None, + }, + None, + ); } let (id, err) = parse_variable(working_set, span); diff --git a/crates/nu-protocol/src/engine/engine_state.rs b/crates/nu-protocol/src/engine/engine_state.rs index c9333ec7d7..36d1fe5227 100644 --- a/crates/nu-protocol/src/engine/engine_state.rs +++ b/crates/nu-protocol/src/engine/engine_state.rs @@ -102,7 +102,7 @@ impl EngineState { Self { files: im::vector![], file_contents: im::vector![], - vars: im::vector![], + vars: im::vector![Type::Unknown], decls: im::vector![], blocks: im::vector![], scope: im::vector![ScopeFrame::new()], diff --git a/src/main.rs b/src/main.rs index 5fff81f558..aecb0041aa 100644 --- a/src/main.rs +++ b/src/main.rs @@ -122,6 +122,10 @@ fn main() -> Result<()> { let mut stack = nu_protocol::engine::Stack::new(); + for (k, v) in std::env::vars() { + stack.env_vars.insert(k, v); + } + match eval_block(&engine_state, &mut stack, &block, PipelineData::new()) { Ok(pipeline_data) => { println!("{}", pipeline_data.collect_string()); @@ -146,6 +150,10 @@ fn main() -> Result<()> { let mut nu_prompt = NushellPrompt::new(); let mut stack = nu_protocol::engine::Stack::new(); + for (k, v) in std::env::vars() { + stack.env_vars.insert(k, v); + } + // Load config startup file if let Some(mut config_path) = nu_path::config_dir() { config_path.push("nushell");