extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2024-12-16 12:12:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update the rest of into

Browse Source
This commit is contained in:
JT 2021-11-05 17:57:24 +13:00
parent 183d200b9f
commit 5837cdb3f1
3 changed files with 86 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
crates/nu-command/src/conversions/into/binary.rs
View File

@ -1,5 +1,6 @@
use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
ast::{Call, CellPath},
engine::{Command, EngineState, Stack},
Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
@ -27,11 +28,11 @@ impl Command for SubCommand {
fn run(
&self,
engine_state: &EngineState,
_stack: &mut Stack,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
into_binary(engine_state, call, input)
into_binary(engine_state, stack, call, input)
}
fn examples(&self) -> Vec<Example> {
@ -87,27 +88,29 @@ impl Command for SubCommand {
fn into_binary(
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
let head = call.head;
// let column_paths: Vec<CellPath> = call.rest(context, 0)?;
let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
input.map(
move |v| {
action(v, head)
// FIXME: Add back in cell_path support
// if column_paths.is_empty() {
// action(v, head)
// } else {
// let mut ret = v;
// for path in &column_paths {
// ret =
// ret.swap_data_by_cell_path(path, Box::new(move |old| action(old, old.tag())))?;
// }
if column_paths.is_empty() {
action(&v, head)
} else {
let mut ret = v;
for path in &column_paths {
let r =
ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
if let Err(error) = r {
return Value::Error { error };
}
}
// Ok(ret)
// }
ret
}
},
engine_state.ctrlc.clone(),
)
@ -129,19 +132,19 @@ fn float_to_endian(n: f64) -> Vec<u8> {
}
}
pub fn action(input: Value, span: Span) -> Value {
pub fn action(input: &Value, span: Span) -> Value {
match input {
Value::Binary { .. } => input,
Value::Binary { .. } => input.clone(),
Value::Int { val, .. } => Value::Binary {
val: int_to_endian(val),
val: int_to_endian(*val),
span,
},
Value::Float { val, .. } => Value::Binary {
val: float_to_endian(val),
val: float_to_endian(*val),
span,
},
Value::Filesize { val, .. } => Value::Binary {
val: int_to_endian(val),
val: int_to_endian(*val),
span,
},
Value::String { val, .. } => Value::Binary {
@ -149,7 +152,7 @@ pub fn action(input: Value, span: Span) -> Value {
span,
},
Value::Bool { val, .. } => Value::Binary {
val: int_to_endian(if val { 1i64 } else { 0 }),
val: int_to_endian(if *val { 1i64 } else { 0 }),
span,
},
Value::Date { val, .. } => Value::Binary {

94
crates/nu-command/src/conversions/into/filesize.rs
View File

@ -1,5 +1,6 @@
use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
ast::{Call, CellPath},
engine::{Command, EngineState, Stack},
Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
@ -27,56 +28,20 @@ impl Command for SubCommand {
fn run(
&self,
engine_state: &EngineState,
_stack: &mut Stack,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
into_filesize(engine_state, call, input)
into_filesize(engine_state, stack, call, input)
}
fn examples(&self) -> Vec<Example> {
vec![
// Example {
// description: "Convert string to filesize in table",
// example: "[[bytes]; ['5'] [3.2] [4] [2kb]] | into filesize bytes",
// result: Some(Value::List {
// vals: vec![
// Value::Record {
// cols: vec!["bytes".to_string()],
// vals: vec![Value::Filesize {
// val: 5,
// span: Span::unknown(),
// }],
// span: Span::unknown(),
// },
// Value::Record {
// cols: vec!["bytes".to_string()],
// vals: vec![Value::Filesize {
// val: 3,
// span: Span::unknown(),
// }],
// span: Span::unknown(),
// },
// Value::Record {
// cols: vec!["bytes".to_string()],
// vals: vec![Value::Filesize {
// val: 4,
// span: Span::unknown(),
// }],
// span: Span::unknown(),
// },
// Value::Record {
// cols: vec!["bytes".to_string()],
// vals: vec![Value::Filesize {
// val: 2000,
// span: Span::unknown(),
// }],
// span: Span::unknown(),
// },
// ],
// span: Span::unknown(),
// }),
// },
Example {
description: "Convert string to filesize in table",
example: "[[bytes]; ['5'] [3.2] [4] [2kb]] | into filesize bytes",
result: None,
},
Example {
description: "Convert string to filesize",
example: "'2' | into filesize",
@ -115,44 +80,43 @@ impl Command for SubCommand {
fn into_filesize(
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
let head = call.head;
// let call_paths: Vec<ColumnPath> = args.rest(0)?;
let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
input.map(
move |v| {
action(v, head)
if column_paths.is_empty() {
action(&v, head)
} else {
let mut ret = v;
for path in &column_paths {
let r =
ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
if let Err(error) = r {
return Value::Error { error };
}
}
// FIXME: Add back cell_path support
// if column_paths.is_empty() {
// action(&v, v.tag())
// } else {
// let mut ret = v;
// for path in &column_paths {
// ret = ret.swap_data_by_column_path(
// path,
// Box::new(move |old| action(old, old.tag())),
// )?;
// }
// Ok(ret)
// }
ret
}
},
engine_state.ctrlc.clone(),
)
}
pub fn action(input: Value, span: Span) -> Value {
pub fn action(input: &Value, span: Span) -> Value {
match input {
Value::Filesize { .. } => input,
Value::Int { val, .. } => Value::Filesize { val, span },
Value::Filesize { .. } => input.clone(),
Value::Int { val, .. } => Value::Filesize { val: *val, span },
Value::Float { val, .. } => Value::Filesize {
val: val as i64,
val: *val as i64,
span,
},
Value::String { val, .. } => match int_from_string(&val, span) {
Value::String { val, .. } => match int_from_string(val, span) {
Ok(val) => Value::Filesize { val, span },
Err(error) => Value::Error { error },
},

45
crates/nu-command/src/conversions/into/string.rs
View File

@ -1,6 +1,6 @@
use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
ast::{Call, CellPath},
engine::{Command, EngineState, Stack},
Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
@ -18,11 +18,11 @@ impl Command for SubCommand {
fn signature(&self) -> Signature {
Signature::build("into string")
// FIXME - need to support column paths
// .rest(
// "rest",
// SyntaxShape::ColumnPaths(),
// "column paths to convert to string (for table input)",
// )
.rest(
"rest",
SyntaxShape::CellPath,
"column paths to convert to string (for table input)",
)
.named(
"decimals",
SyntaxShape::Int,
@ -135,6 +135,7 @@ fn string_helper(
let decimals = call.has_flag("decimals");
let head = call.head;
let decimals_value: Option<i64> = call.get_flag(engine_state, stack, "decimals")?;
let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
if decimals && decimals_value.is_some() && decimals_value.unwrap().is_negative() {
return Err(ShellError::UnsupportedInput(
@ -144,13 +145,30 @@ fn string_helper(
}
input.map(
move |v| action(v, head, decimals, decimals_value, false),
move |v| {
if column_paths.is_empty() {
action(&v, head, decimals, decimals_value, false)
} else {
let mut ret = v;
for path in &column_paths {
let r = ret.update_cell_path(
&path.members,
Box::new(move |old| action(old, head, decimals, decimals_value, false)),
);
if let Err(error) = r {
return Value::Error { error };
}
}
ret
}
},
engine_state.ctrlc.clone(),
)
}
pub fn action(
input: Value,
input: &Value,
span: Span,
decimals: bool,
digits: Option<i64>,
@ -159,7 +177,7 @@ pub fn action(
match input {
Value::Int { val, .. } => {
let res = if group_digits {
format_int(val) // int.to_formatted_string(*locale)
format_int(*val) // int.to_formatted_string(*locale)
} else {
val.to_string()
};
@ -188,12 +206,13 @@ pub fn action(
val: val.format("%c").to_string(),
span,
},
Value::String { val, .. } => Value::String { val, span },
Value::String { val, .. } => Value::String {
val: val.to_string(),
span,
},
// FIXME - we do not have a FilePath type anymore. Do we need to support this?
// Value::FilePath(a_filepath) => a_filepath.as_path().display().to_string(),
Value::Filesize { val: _, .. } => Value::String {
val: input.into_string(),
val: input.clone().into_string(),
span,
},
Value::Nothing { .. } => Value::String {