diff --git a/crates/nu-command/src/default_context.rs b/crates/nu-command/src/default_context.rs index 01858f02d6..672eea1006 100644 --- a/crates/nu-command/src/default_context.rs +++ b/crates/nu-command/src/default_context.rs @@ -188,8 +188,6 @@ pub fn add_shell_command_context(mut engine_state: EngineState) -> EngineState { EncodeBase32Hex, DecodeBase64, EncodeBase64, - DecodeBase64Old, - EncodeBase64Old, DetectColumns, Parse, Split, diff --git a/crates/nu-command/src/strings/base/base64.rs b/crates/nu-command/src/strings/base/base64.rs index 3a1ccad9ef..9c68112b33 100644 --- a/crates/nu-command/src/strings/base/base64.rs +++ b/crates/nu-command/src/strings/base/base64.rs @@ -38,11 +38,11 @@ pub struct DecodeBase64; impl Command for DecodeBase64 { fn name(&self) -> &str { - "decode new-base64" + "decode base64" } fn signature(&self) -> Signature { - Signature::build("decode new-base64") + Signature::build("decode base64") .input_output_types(vec![(Type::String, Type::Binary)]) .allow_variants_without_examples(true) .switch("url", "Decode the URL-safe Base64 version.", None) @@ -62,17 +62,17 @@ impl Command for DecodeBase64 { vec![ Example { description: "Decode a Base64 string", - example: r#""U29tZSBEYXRh" | decode new-base64 | decode"#, + example: r#""U29tZSBEYXRh" | decode base64 | decode"#, result: None, }, Example { description: "Decode arbitrary data", - example: r#""/w==" | decode new-base64"#, + example: r#""/w==" | decode base64"#, result: Some(Value::test_binary(vec![0xFF])), }, Example { description: "Decode a URL-safe Base64 string", - example: r#""_w==" | decode new-base64 --url"#, + example: r#""_w==" | decode base64 --url"#, result: Some(Value::test_binary(vec![0xFF])), }, ] @@ -109,11 +109,11 @@ pub struct EncodeBase64; impl Command for EncodeBase64 { fn name(&self) -> &str { - "encode new-base64" + "encode base64" } fn signature(&self) -> Signature { - Signature::build("encode new-base64") + Signature::build("encode base64") .input_output_types(vec![ (Type::String, Type::String), (Type::Binary, Type::String), @@ -135,17 +135,17 @@ impl Command for EncodeBase64 { vec![ Example { description: "Encode a string with Base64", - example: r#""Alphabet from A to Z" | encode new-base64"#, + example: r#""Alphabet from A to Z" | encode base64"#, result: Some(Value::test_string("QWxwaGFiZXQgZnJvbSBBIHRvIFo=")), }, Example { description: "Encode arbitrary data", - example: r#"0x[BE EE FF] | encode new-base64"#, + example: r#"0x[BE EE FF] | encode base64"#, result: Some(Value::test_string("vu7/")), }, Example { description: "Use a URL-safe alphabet", - example: r#"0x[BE EE FF] | encode new-base64 --url"#, + example: r#"0x[BE EE FF] | encode base64 --url"#, result: Some(Value::test_string("vu7_")), }, ] diff --git a/crates/nu-command/src/strings/encode_decode/base64.rs b/crates/nu-command/src/strings/encode_decode/base64.rs deleted file mode 100644 index dd9289a141..0000000000 --- a/crates/nu-command/src/strings/encode_decode/base64.rs +++ /dev/null @@ -1,377 +0,0 @@ -use base64::{ - alphabet, - engine::{ - general_purpose::{NO_PAD, PAD}, - GeneralPurpose, - }, - Engine, -}; -use nu_cmd_base::input_handler::{operate as general_operate, CmdArgument}; -use nu_protocol::{ - ast::CellPath, - engine::{Call, EngineState}, - PipelineData, ShellError, Span, Spanned, Value, -}; - -pub const CHARACTER_SET_DESC: &str = "specify the character rules for encoding the input.\n\ - \tValid values are 'standard', 'standard-no-padding', 'url-safe', 'url-safe-no-padding',\ - 'binhex', 'bcrypt', 'crypt', 'mutf7'"; - -#[derive(Clone)] -pub struct Base64Config { - pub character_set: Spanned, - pub action_type: ActionType, -} - -#[derive(Clone, Copy, PartialEq, Eq)] -pub enum ActionType { - Encode, - Decode, -} - -struct Arguments { - cell_paths: Option>, - binary: bool, - encoding_config: Base64Config, -} - -impl CmdArgument for Arguments { - fn take_cell_paths(&mut self) -> Option> { - self.cell_paths.take() - } -} - -pub(super) struct Base64CommandArguments { - pub(super) character_set: Option>, - pub(super) action_type: ActionType, - pub(super) binary: bool, -} - -pub fn operate( - engine_state: &EngineState, - call: &Call, - input: PipelineData, - cell_paths: Vec, - args: Base64CommandArguments, -) -> Result { - let head = call.head; - let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths); - - // Default the character set to standard if the argument is not specified. - let character_set = match args.character_set { - Some(inner_tag) => inner_tag, - None => Spanned { - item: "standard".to_string(), - span: head, // actually this span is always useless, because default character_set is always valid. - }, - }; - - let args = Arguments { - encoding_config: Base64Config { - character_set, - action_type: args.action_type, - }, - binary: args.binary, - cell_paths, - }; - - general_operate(action, args, input, call.head, engine_state.signals()) -} - -fn action( - input: &Value, - // only used for `decode` action - args: &Arguments, - command_span: Span, -) -> Value { - let base64_config = &args.encoding_config; - let output_binary = args.binary; - - let config_character_set = &base64_config.character_set; - let base64_engine: GeneralPurpose = match config_character_set.item.as_str() { - "standard" => GeneralPurpose::new(&alphabet::STANDARD, PAD), - "standard-no-padding" => GeneralPurpose::new(&alphabet::STANDARD, NO_PAD), - "url-safe" => GeneralPurpose::new(&alphabet::URL_SAFE, PAD), - "url-safe-no-padding" => GeneralPurpose::new(&alphabet::URL_SAFE, NO_PAD), - "bcrypt" => GeneralPurpose::new(&alphabet::BCRYPT, NO_PAD), - "binhex" => GeneralPurpose::new(&alphabet::BIN_HEX, NO_PAD), - "crypt" => GeneralPurpose::new(&alphabet::CRYPT, NO_PAD), - "mutf7" => GeneralPurpose::new(&alphabet::IMAP_MUTF7, NO_PAD), - not_valid => return Value::error ( - ShellError::GenericError { - error: "value is not an accepted character set".into(), - msg: format!( - "{not_valid} is not a valid character-set.\nPlease use `help encode base64` to see a list of valid character sets." - ), - span: Some(config_character_set.span), - help: None, - inner: vec![], - }, config_character_set.span) - }; - let value_span = input.span(); - match input { - // Propagate existing errors. - Value::Error { .. } => input.clone(), - Value::Binary { val, .. } => match base64_config.action_type { - ActionType::Encode => { - let mut enc_vec = vec![0; val.len() * 4 / 3 + 4]; - let bytes_written = match base64_engine.encode_slice(val, &mut enc_vec) { - Ok(bytes_written) => bytes_written, - Err(e) => { - return Value::error( - ShellError::GenericError { - error: "Error encoding data".into(), - msg: e.to_string(), - span: Some(value_span), - help: None, - inner: vec![], - }, - value_span, - ) - } - }; - enc_vec.truncate(bytes_written); - Value::string(std::str::from_utf8(&enc_vec).unwrap_or(""), command_span) - } - ActionType::Decode => Value::error( - ShellError::UnsupportedInput { - msg: "Binary data can only be encoded".to_string(), - input: "value originates from here".into(), - msg_span: command_span, - input_span: input.span(), - }, - command_span, - ), - }, - Value::String { val, .. } => { - match base64_config.action_type { - ActionType::Encode => { - let mut enc_str = String::new(); - base64_engine.encode_string(val, &mut enc_str); - Value::string(enc_str, command_span) - } - - ActionType::Decode => { - // for decode, input val may contains invalid new line character, which is ok to omitted them by default. - let val = val.clone(); - let val = val.replace("\r\n", "").replace('\n', ""); - - match base64_engine.decode(val) { - Ok(decoded_value) => { - if output_binary { - Value::binary(decoded_value, command_span) - } else { - match String::from_utf8(decoded_value) { - Ok(string_value) => Value::string(string_value, command_span), - Err(e) => Value::error( - ShellError::GenericError { - error: "base64 payload isn't a valid utf-8 sequence" - .into(), - msg: e.to_string(), - span: Some(value_span), - help: Some( - "consider using the `--binary` flag".to_owned(), - ), - inner: vec![], - }, - value_span, - ), - } - } - } - Err(_) => Value::error( - ShellError::GenericError { - error: "value could not be base64 decoded".into(), - msg: format!( - "invalid base64 input for character set {}", - &config_character_set.item - ), - span: Some(command_span), - help: None, - inner: vec![], - }, - command_span, - ), - } - } - } - } - other => Value::error( - ShellError::TypeMismatch { - err_message: format!("string or binary, not {}", other.get_type()), - span: other.span(), - }, - other.span(), - ), - } -} - -#[cfg(test)] -mod tests { - use super::{action, ActionType, Arguments, Base64Config}; - use nu_protocol::{Span, Spanned, Value}; - - #[test] - fn base64_encode_standard() { - let word = Value::test_string("Some Data Padding"); - let expected = Value::test_string("U29tZSBEYXRhIFBhZGRpbmc="); - - let actual = action( - &word, - &Arguments { - encoding_config: Base64Config { - character_set: Spanned { - item: "standard".to_string(), - span: Span::test_data(), - }, - action_type: ActionType::Encode, - }, - binary: true, - cell_paths: None, - }, - Span::test_data(), - ); - assert_eq!(actual, expected); - } - - #[test] - fn base64_encode_standard_no_padding() { - let word = Value::test_string("Some Data Padding"); - let expected = Value::test_string("U29tZSBEYXRhIFBhZGRpbmc"); - - let actual = action( - &word, - &Arguments { - encoding_config: Base64Config { - character_set: Spanned { - item: "standard-no-padding".to_string(), - span: Span::test_data(), - }, - action_type: ActionType::Encode, - }, - binary: true, - cell_paths: None, - }, - Span::test_data(), - ); - assert_eq!(actual, expected); - } - - #[test] - fn base64_encode_url_safe() { - let word = Value::test_string("this is for url"); - let expected = Value::test_string("dGhpcyBpcyBmb3IgdXJs"); - - let actual = action( - &word, - &Arguments { - encoding_config: Base64Config { - character_set: Spanned { - item: "url-safe".to_string(), - span: Span::test_data(), - }, - action_type: ActionType::Encode, - }, - binary: true, - cell_paths: None, - }, - Span::test_data(), - ); - assert_eq!(actual, expected); - } - - #[test] - fn base64_decode_binhex() { - let word = Value::test_string(r#"B5"LD@jSCAJJG'9cG!"#); - let expected = Value::binary(b"a binhex test".as_slice(), Span::test_data()); - - let actual = action( - &word, - &Arguments { - encoding_config: Base64Config { - character_set: Spanned { - item: "binhex".to_string(), - span: Span::test_data(), - }, - action_type: ActionType::Decode, - }, - binary: true, - cell_paths: None, - }, - Span::test_data(), - ); - assert_eq!(actual, expected); - } - - #[test] - fn base64_decode_binhex_with_new_line_input() { - let word = Value::test_string("B5\"LD@jSC\nAJJG'9cG!"); - let expected = Value::binary(b"a binhex test".as_slice(), Span::test_data()); - - let actual = action( - &word, - &Arguments { - encoding_config: Base64Config { - character_set: Spanned { - item: "binhex".to_string(), - span: Span::test_data(), - }, - action_type: ActionType::Decode, - }, - binary: true, - cell_paths: None, - }, - Span::test_data(), - ); - assert_eq!(actual, expected); - } - - #[test] - fn base64_encode_binary() { - let word = Value::binary(vec![77, 97, 110], Span::test_data()); - let expected = Value::test_string("TWFu"); - - let actual = action( - &word, - &Arguments { - encoding_config: Base64Config { - character_set: Spanned { - item: "standard".to_string(), - span: Span::test_data(), - }, - action_type: ActionType::Encode, - }, - binary: true, - cell_paths: None, - }, - Span::test_data(), - ); - assert_eq!(actual, expected); - } - - #[test] - fn base64_decode_binary_expect_error() { - let word = Value::binary(vec![77, 97, 110], Span::test_data()); - - let actual = action( - &word, - &Arguments { - encoding_config: Base64Config { - character_set: Spanned { - item: "standard".to_string(), - span: Span::test_data(), - }, - action_type: ActionType::Decode, - }, - binary: true, - cell_paths: None, - }, - Span::test_data(), - ); - - match actual { - Value::Error { .. } => {} - _ => panic!("the result should be Value::Error"), - } - } -} diff --git a/crates/nu-command/src/strings/encode_decode/decode_base64.rs b/crates/nu-command/src/strings/encode_decode/decode_base64.rs deleted file mode 100644 index f3c2b7fcde..0000000000 --- a/crates/nu-command/src/strings/encode_decode/decode_base64.rs +++ /dev/null @@ -1,130 +0,0 @@ -use super::base64::{operate, ActionType, Base64CommandArguments, CHARACTER_SET_DESC}; -use nu_engine::command_prelude::*; -use nu_protocol::report_shell_warning; - -#[derive(Clone)] -pub struct DecodeBase64Old; - -impl Command for DecodeBase64Old { - fn name(&self) -> &str { - "decode base64" - } - - fn signature(&self) -> Signature { - Signature::build("decode base64") - .input_output_types(vec![ - (Type::String, Type::Any), - ( - Type::List(Box::new(Type::String)), - Type::List(Box::new(Type::Any)), - ), - (Type::table(), Type::table()), - (Type::record(), Type::record()), - ]) - .allow_variants_without_examples(true) - .named( - "character-set", - SyntaxShape::String, - CHARACTER_SET_DESC, - Some('c'), - ) - .switch( - "binary", - "Output a binary value instead of decoding payload as UTF-8", - Some('b'), - ) - .rest( - "rest", - SyntaxShape::CellPath, - "For a data structure input, decode data at the given cell paths.", - ) - .category(Category::Hash) - } - - fn description(&self) -> &str { - "Base64 decode a value." - } - - fn extra_description(&self) -> &str { - r#"Will attempt to decode binary payload as an UTF-8 string by default. Use the `--binary(-b)` argument to force binary output."# - } - - fn examples(&self) -> Vec { - vec![ - Example { - description: "Base64 decode a value and output as UTF-8 string", - example: "'U29tZSBEYXRh' | decode base64", - result: Some(Value::test_string("Some Data")), - }, - Example { - description: "Base64 decode a value and output as binary", - example: "'U29tZSBEYXRh' | decode base64 --binary", - result: Some(Value::binary( - [0x53, 0x6f, 0x6d, 0x65, 0x20, 0x44, 0x61, 0x74, 0x61], - Span::test_data(), - )), - }, - ] - } - - fn is_const(&self) -> bool { - true - } - - fn run( - &self, - engine_state: &EngineState, - stack: &mut Stack, - call: &Call, - input: PipelineData, - ) -> Result { - report_shell_warning( - engine_state, - &ShellError::Deprecated { - old_command: "decode base64".into(), - new_suggestion: "the new `decode new-base64` version".into(), - span: call.head, - url: "`help decode new-base64`".into(), - }, - ); - - let character_set: Option> = - call.get_flag(engine_state, stack, "character-set")?; - let binary = call.has_flag(engine_state, stack, "binary")?; - let cell_paths: Vec = call.rest(engine_state, stack, 0)?; - let args = Base64CommandArguments { - action_type: ActionType::Decode, - binary, - character_set, - }; - operate(engine_state, call, input, cell_paths, args) - } - - fn run_const( - &self, - working_set: &StateWorkingSet, - call: &Call, - input: PipelineData, - ) -> Result { - let character_set: Option> = - call.get_flag_const(working_set, "character-set")?; - let binary = call.has_flag_const(working_set, "binary")?; - let cell_paths: Vec = call.rest_const(working_set, 0)?; - let args = Base64CommandArguments { - action_type: ActionType::Decode, - binary, - character_set, - }; - operate(working_set.permanent(), call, input, cell_paths, args) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_examples() { - crate::test_examples(DecodeBase64Old) - } -} diff --git a/crates/nu-command/src/strings/encode_decode/encode_base64.rs b/crates/nu-command/src/strings/encode_decode/encode_base64.rs deleted file mode 100644 index 0181f94aef..0000000000 --- a/crates/nu-command/src/strings/encode_decode/encode_base64.rs +++ /dev/null @@ -1,134 +0,0 @@ -use super::base64::{operate, ActionType, Base64CommandArguments, CHARACTER_SET_DESC}; -use nu_engine::command_prelude::*; -use nu_protocol::report_shell_warning; - -#[derive(Clone)] -pub struct EncodeBase64Old; - -impl Command for EncodeBase64Old { - fn name(&self) -> &str { - "encode base64" - } - - fn signature(&self) -> Signature { - Signature::build("encode base64") - .input_output_types(vec![ - (Type::String, Type::String), - (Type::Binary, Type::String), - ( - Type::List(Box::new(Type::String)), - Type::List(Box::new(Type::String)), - ), - ( - Type::List(Box::new(Type::Binary)), - Type::List(Box::new(Type::String)), - ), - // Relaxed for heterogeneous list. - // Should be removed as soon as the type system supports better restrictions - ( - Type::List(Box::new(Type::Any)), - Type::List(Box::new(Type::String)), - ), - (Type::table(), Type::table()), - (Type::record(), Type::record()), - ]) - .allow_variants_without_examples(true) - .named( - "character-set", - SyntaxShape::String, - CHARACTER_SET_DESC, - Some('c'), - ) - .rest( - "rest", - SyntaxShape::CellPath, - "For a data structure input, encode data at the given cell paths.", - ) - .category(Category::Hash) - } - - fn description(&self) -> &str { - "Encode a string or binary value using Base64." - } - - fn examples(&self) -> Vec { - vec![ - Example { - description: "Encode binary data", - example: "0x[09 F9 11 02 9D 74 E3 5B D8 41 56 C5 63 56 88 C0] | encode base64", - result: Some(Value::test_string("CfkRAp1041vYQVbFY1aIwA==")), - }, - Example { - description: "Encode a string with default settings", - example: "'Some Data' | encode base64", - result: Some(Value::test_string("U29tZSBEYXRh")), - }, - Example { - description: "Encode a string with the binhex character set", - example: "'Some Data' | encode base64 --character-set binhex", - result: Some(Value::test_string(r#"8fpYC5"%BA4K"#)), - }, - ] - } - - fn is_const(&self) -> bool { - true - } - - fn run( - &self, - engine_state: &EngineState, - stack: &mut Stack, - call: &Call, - input: PipelineData, - ) -> Result { - report_shell_warning( - engine_state, - &ShellError::Deprecated { - old_command: "encode base64".into(), - new_suggestion: "the new `encode new-base64` version".into(), - span: call.head, - url: "`help encode new-base64`".into(), - }, - ); - - let character_set: Option> = - call.get_flag(engine_state, stack, "character-set")?; - let binary = call.has_flag(engine_state, stack, "binary")?; - let cell_paths: Vec = call.rest(engine_state, stack, 0)?; - let args = Base64CommandArguments { - action_type: ActionType::Encode, - binary, - character_set, - }; - operate(engine_state, call, input, cell_paths, args) - } - - fn run_const( - &self, - working_set: &StateWorkingSet, - call: &Call, - input: PipelineData, - ) -> Result { - let character_set: Option> = - call.get_flag_const(working_set, "character-set")?; - let binary = call.has_flag_const(working_set, "binary")?; - let cell_paths: Vec = call.rest_const(working_set, 0)?; - let args = Base64CommandArguments { - action_type: ActionType::Encode, - binary, - character_set, - }; - operate(working_set.permanent(), call, input, cell_paths, args) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_examples() { - crate::test_examples(EncodeBase64Old) - } -} diff --git a/crates/nu-command/src/strings/encode_decode/mod.rs b/crates/nu-command/src/strings/encode_decode/mod.rs index 5dde14e0f2..350fbf779c 100644 --- a/crates/nu-command/src/strings/encode_decode/mod.rs +++ b/crates/nu-command/src/strings/encode_decode/mod.rs @@ -1,11 +1,6 @@ -mod base64; mod decode; -mod decode_base64; mod encode; -mod encode_base64; mod encoding; pub use self::decode::Decode; -pub use self::decode_base64::DecodeBase64Old; pub use self::encode::Encode; -pub use self::encode_base64::EncodeBase64Old; diff --git a/crates/nu-command/tests/commands/base/base64.rs b/crates/nu-command/tests/commands/base/base64.rs index ac3554352c..5100667c81 100644 --- a/crates/nu-command/tests/commands/base/base64.rs +++ b/crates/nu-command/tests/commands/base/base64.rs @@ -2,18 +2,18 @@ use nu_test_support::nu; #[test] fn canonical() { - super::test_canonical("new-base64"); - super::test_canonical("new-base64 --url"); - super::test_canonical("new-base64 --nopad"); - super::test_canonical("new-base64 --url --nopad"); + super::test_canonical("base64"); + super::test_canonical("base64 --url"); + super::test_canonical("base64 --nopad"); + super::test_canonical("base64 --url --nopad"); } #[test] fn const_() { - super::test_const("new-base64"); - super::test_const("new-base64 --url"); - super::test_const("new-base64 --nopad"); - super::test_const("new-base64 --url --nopad"); + super::test_const("base64"); + super::test_const("base64 --url"); + super::test_const("base64 --nopad"); + super::test_const("base64 --url --nopad"); } #[test] @@ -21,7 +21,7 @@ fn encode() { let text = "Ș̗͙̂̏o̲̲̗͗̌͊m̝̊̓́͂ë̡̦̞̤́̌̈́̀ ̥̝̪̎̿ͅf̧̪̻͉͗̈́̍̆u̮̝͌̈́ͅn̹̞̈́̊k̮͇̟͎̂͘y̧̲̠̾̆̕ͅ ̙͖̭͔̂̐t̞́́͘e̢̨͕̽x̥͋t͍̑̔͝"; let encoded = "U8yCzI/MpsyXzZlvzZfMjM2KzLLMssyXbcyKzJPMgc2CzJ1lzYTMjM2EzIDMpsyhzJ7MpCDMjsy/zYXMpcydzKpmzZfNhMyNzIbMqsy7zKfNiXXNjM2EzK7Mnc2Fbs2EzIrMucyea82YzILMrs2HzJ/NjnnMvsyVzIbNhcyyzKfMoCDMgsyQzJnNlsytzZR0zIHNmMyBzJ5lzL3Mos2VzKh4zYvMpXTMkcyUzZ3NjQ=="; - let outcome = nu!("'{}' | encode new-base64", text); + let outcome = nu!("'{}' | encode base64", text); assert_eq!(outcome.out, encoded); } @@ -30,7 +30,7 @@ fn decode_string() { let text = "Very important data"; let encoded = "VmVyeSBpbXBvcnRhbnQgZGF0YQ=="; - let outcome = nu!("'{}' | decode new-base64 | decode", encoded); + let outcome = nu!("'{}' | decode base64 | decode", encoded); assert_eq!(outcome.out, text); } @@ -40,10 +40,10 @@ fn decode_pad_nopad() { let encoded_pad = "4oCdwqUuw6RAwrBiWsO2wqI="; let encoded_nopad = "4oCdwqUuw6RAwrBiWsO2wqI"; - let outcome = nu!("'{}' | decode new-base64 | decode", encoded_pad); + let outcome = nu!("'{}' | decode base64 | decode", encoded_pad); assert_eq!(outcome.out, text); - let outcome = nu!("'{}' | decode new-base64 --nopad | decode", encoded_nopad); + let outcome = nu!("'{}' | decode base64 --nopad | decode", encoded_nopad); assert_eq!(outcome.out, text); } @@ -53,10 +53,10 @@ fn decode_url() { let encoded = "cDpn15jdvt+rdCs/"; let encoded_url = "cDpn15jdvt-rdCs_"; - let outcome = nu!("'{}' | decode new-base64 | decode", encoded); + let outcome = nu!("'{}' | decode base64 | decode", encoded); assert_eq!(outcome.out, text); - let outcome = nu!("'{}' | decode new-base64 --url | decode", encoded_url); + let outcome = nu!("'{}' | decode base64 --url | decode", encoded_url); assert_eq!(outcome.out, text); } @@ -65,9 +65,9 @@ fn reject_pad_nopad() { let encoded_nopad = "YQ"; let encoded_pad = "YQ=="; - let outcome = nu!("'{}' | decode new-base64", encoded_nopad); + let outcome = nu!("'{}' | decode base64", encoded_nopad); assert!(!outcome.err.is_empty()); - let outcome = nu!("'{}' | decode new-base64 --nopad", encoded_pad); + let outcome = nu!("'{}' | decode base64 --nopad", encoded_pad); assert!(!outcome.err.is_empty()) } diff --git a/crates/nu-command/tests/commands/hash_/mod.rs b/crates/nu-command/tests/commands/hash_/mod.rs index 76ae86f6e7..1f09b5ec52 100644 --- a/crates/nu-command/tests/commands/hash_/mod.rs +++ b/crates/nu-command/tests/commands/hash_/mod.rs @@ -10,43 +10,48 @@ fn base64_defaults_to_encoding_with_standard_character_type() { } #[test] -fn base64_encode_characterset_binhex() { +fn base64_defaults_to_encoding_with_nopad() { let actual = nu!(r#" - echo 'username:password' | encode base64 --character-set binhex + echo 'username:password' | encode base64 --nopad "#); - assert_eq!(actual.out, "GA0PFQjKE@8kF'&cFhG[FQ3"); + assert_eq!(actual.out, "dXNlcm5hbWU6cGFzc3dvcmQ"); } #[test] -fn error_when_invalid_character_set_given() { +fn base64_decode_value() { let actual = nu!(r#" - echo 'username:password' | encode base64 --character-set 'this is invalid' + echo 'YWJjeHl6' | decode base64 | decode "#); - assert!(actual - .err - .contains("this is invalid is not a valid character-set")); + assert_eq!(actual.out, "abcxyz"); } #[test] -fn base64_decode_characterset_binhex() { - let actual = nu!( - r#""GA0PFQjKE@8kF'&cFhG[FQ3" | decode base64 --character-set binhex --binary | decode utf-8"# - ); +fn base64_decode_with_nopad() { + let actual = nu!(r#" + echo 'R29vZCBsdWNrIHRvIHlvdQ' | decode base64 --nopad | decode + "#); - assert_eq!(actual.out, "username:password"); + assert_eq!(actual.out, "Good luck to you"); +} + +#[test] +fn base64_decode_with_url() { + let actual = nu!(r#" + echo 'vu7_' | decode base64 --url | decode + "#); + + assert_eq!(actual.out, "¾îÿ"); } #[test] fn error_invalid_decode_value() { let actual = nu!(r#" - echo "this should not be a valid encoded value" | decode base64 --character-set url-safe + echo "this should not be a valid encoded value" | decode base64 "#); - assert!(actual - .err - .contains("invalid base64 input for character set url-safe")); + assert!(actual.err.contains("nu::shell::incorrect_value")); } #[test]