From 7479173811c1e5bc0b5eead36a6ba57ff075eaeb Mon Sep 17 00:00:00 2001 From: Leon Date: Sun, 20 Nov 2022 03:52:09 +1000 Subject: [PATCH] Grouped config commands better (closes #6911) (#6983) * Grouped config commands better * Tweaked test slightly * Fix merge conflict(?) * Remove recently-added test case * Revert rm.always_trash default * Untweak rm help messages * Formatting * Remove example * Add deprecation warning * Remove deprecation timeline Not sure we want to commit to a specific timeline just yet Co-authored-by: Reilly Wood <26268125+rgwood@users.noreply.github.com> --- crates/nu-command/src/filesystem/rm.rs | 14 +- crates/nu-protocol/src/config.rs | 666 ++++++++++++++---- .../src/sample_config/default_config.nu | 66 +- 3 files changed, 557 insertions(+), 189 deletions(-) diff --git a/crates/nu-command/src/filesystem/rm.rs b/crates/nu-command/src/filesystem/rm.rs index 1608d735d..87ad835cd 100644 --- a/crates/nu-command/src/filesystem/rm.rs +++ b/crates/nu-command/src/filesystem/rm.rs @@ -88,12 +88,12 @@ impl Command for Rm { } fn examples(&self) -> Vec { - let mut examples = vec![ - Example { - description: "Delete or move a file to the system trash (depending on 'rm_always_trash' config option)", - example: "rm file.txt", - result: None, - }]; + let mut examples = vec![Example { + description: + "Delete or move a file to the trash (depending on 'always_trash' config option)", + example: "rm file.txt", + result: None, + }]; #[cfg(all( feature = "trash-support", not(target_os = "android"), @@ -164,7 +164,7 @@ fn rm( if rm_always_trash { return Err(ShellError::GenericError( "Cannot execute `rm`; the current configuration specifies \ - `rm_always_trash = true`, but the current nu executable was not \ + `always_trash = true`, but the current nu executable was not \ built with feature `trash_support` or trash is not supported on \ your platform." .into(), diff --git a/crates/nu-protocol/src/config.rs b/crates/nu-protocol/src/config.rs index 13fe55bc4..f049ceb80 100644 --- a/crates/nu-protocol/src/config.rs +++ b/crates/nu-protocol/src/config.rs @@ -189,35 +189,337 @@ impl Value { let mut config = Config::default(); + let mut legacy_options_used = false; + if let Ok(v) = v { for (key, value) in v.0.iter().zip(v.1) { - match key.as_str() { - "filesize_metric" => { - if let Ok(b) = value.as_bool() { - config.filesize_metric = b; + let key = key.as_str(); + match key { + // Grouped options + "ls" => { + if let Ok((cols, inner_vals)) = value.as_record() { + for (key2, value) in cols.iter().zip(inner_vals) { + let key2 = key2.as_str(); + match key2 { + "use_ls_colors" => { + if let Ok(b) = value.as_bool() { + config.use_ls_colors = b; + } else { + eprintln!("$env.config.{}.{} is not a bool", key, key2) + } + } + "clickable_links" => { + if let Ok(b) = value.as_bool() { + config.show_clickable_links_in_ls = b; + } else { + eprintln!("$env.config.{}.{} is not a bool", key, key2) + } + } + x => { + eprintln!( + "$env.config.{}.{} is an unknown config setting", + key, x + ) + } + } + } } else { - eprintln!("$config.filesize_metric is not a bool") + eprintln!("$env.config.{} is not a record", key); } } - "external_completer" => { - if let Ok(v) = value.as_block() { - config.external_completer = Some(v) - } - } - "table_mode" => { - if let Ok(v) = value.as_string() { - config.table_mode = v; + "cd" => { + if let Ok((cols, inner_vals)) = value.as_record() { + for (key2, value) in cols.iter().zip(inner_vals) { + let key2 = key2.as_str(); + match key2 { + "abbreviations" => { + if let Ok(b) = value.as_bool() { + config.cd_with_abbreviations = b; + } else { + eprintln!("$env.config.{}.{} is not a bool", key, key2) + } + } + x => { + eprintln!( + "$env.config.{}.{} is an unknown config setting", + key, x + ) + } + } + } } else { - eprintln!("$config.table_mode is not a string") + eprintln!("$env.config.{} is not a record", key); } } - "use_ls_colors" => { - if let Ok(b) = value.as_bool() { - config.use_ls_colors = b; + "rm" => { + if let Ok((cols, inner_vals)) = value.as_record() { + for (key2, value) in cols.iter().zip(inner_vals) { + let key2 = key2.as_str(); + match key2 { + "always_trash" => { + if let Ok(b) = value.as_bool() { + config.rm_always_trash = b; + } else { + eprintln!("$env.config.{}.{} is not a bool", key, key2) + } + } + x => { + eprintln!( + "$env.config.{}.{} is an unknown config setting", + key, x + ) + } + } + } } else { - eprintln!("$config.use_ls_colors is not a bool") + eprintln!("$env.config.{} is not a record", key); } } + "history" => { + if let Ok((cols, inner_vals)) = value.as_record() { + for (key2, value) in cols.iter().zip(inner_vals) { + let key2 = key2.as_str(); + match key2 { + "sync_on_enter" => { + if let Ok(b) = value.as_bool() { + config.sync_history_on_enter = b; + } else { + eprintln!("$env.config.{}.{} is not a bool", key, key2) + } + } + "max_size" => { + if let Ok(i) = value.as_i64() { + config.max_history_size = i; + } else { + eprintln!( + "$env.config.{}.{} is not an integer", + key, key2 + ) + } + } + "file_format" => { + if let Ok(v) = value.as_string() { + let val_str = v.to_lowercase(); + config.history_file_format = match val_str.as_ref() { + "sqlite" => HistoryFileFormat::Sqlite, + "plaintext" => HistoryFileFormat::PlainText, + _ => { + eprintln!( + "unrecognized $config.{}.{} '{val_str}'; expected either 'sqlite' or 'plaintext'", + key, key2, + ); + HistoryFileFormat::PlainText + } + }; + } else { + eprintln!( + "$env.config.{}.{} is not a string", + key, key2 + ) + } + } + x => { + eprintln!( + "$env.config.{}.{} is an unknown config setting", + key, x + ) + } + } + } + } else { + eprintln!("$env.config.{} is not a record", key) + } + } + "completions" => { + if let Ok((cols, inner_vals)) = value.as_record() { + for (key2, value) in cols.iter().zip(inner_vals) { + let key2 = key2.as_str(); + match key2 { + "quick" => { + if let Ok(b) = value.as_bool() { + config.quick_completions = b; + } else { + eprintln!("$env.config.{}.{} is not a bool", key, key2) + } + } + "partial" => { + if let Ok(b) = value.as_bool() { + config.partial_completions = b; + } else { + eprintln!("$env.config.{}.{} is not a bool", key, key2) + } + } + "algorithm" => { + if let Ok(v) = value.as_string() { + let val_str = v.to_lowercase(); + config.completion_algorithm = match val_str.as_ref() { + // This should match the MatchAlgorithm enum in completions::completion_options + "prefix" => val_str, + "fuzzy" => val_str, + _ => { + eprintln!( + "unrecognized $config.{}.{} '{val_str}'; expected either 'prefix' or 'fuzzy'", + key, key2 + ); + String::from("prefix") + } + }; + } else { + eprintln!( + "$env.config.{}.{} is not a string", + key, key2 + ) + } + } + "case_sensitive" => { + if let Ok(b) = value.as_bool() { + config.case_sensitive_completions = b; + } else { + eprintln!("$env.config.{}.{} is not a bool", key, key2) + } + } + "external" => { + if let Ok((cols, inner_vals)) = value.as_record() { + for (key3, value) in cols.iter().zip(inner_vals) { + let key3 = key3.as_str(); + match key3 { + "max_results" => { + if let Ok(i) = value.as_integer() { + config + .max_external_completion_results = + i; + } else { + eprintln!("$env.config.{}.{}.{} is not an integer", key, key2, key3) + } + } + "completer" => { + if let Ok(v) = value.as_block() { + config.external_completer = Some(v) + } else { + match value { + Value::Nothing { .. } => {} + _ => { + eprintln!("$env.config.{}.{}.{} is not a block or null", key, key2, key3) + } + } + } + } + "enable" => { + if let Ok(b) = value.as_bool() { + config.enable_external_completion = b; + } else { + eprintln!("$env.config.{}.{}.{} is not a bool", key, key2, key3) + } + } + x => { + eprintln!("$env.config.{}.{}.{} is an unknown config setting", key, key2, x) + } + } + } + } else { + eprintln!( + "$env.config.{}.{} is not a record", + key, key2 + ); + } + } + x => { + eprintln!( + "$env.config.{}.{} is an unknown config setting", + key, x + ) + } + } + } + } else { + eprintln!("$env.config.{} is not a record", key) + } + } + "table" => { + if let Ok((cols, inner_vals)) = value.as_record() { + for (key2, value) in cols.iter().zip(inner_vals) { + let key2 = key2.as_str(); + match key2 { + "mode" => { + if let Ok(v) = value.as_string() { + config.table_mode = v; + } else { + eprintln!( + "$env.config.{}.{} is not a string", + key, key2 + ) + } + } + "index_mode" => { + if let Ok(b) = value.as_string() { + let val_str = b.to_lowercase(); + match val_str.as_ref() { + "always" => config.table_index_mode = TableIndexMode::Always, + "never" => config.table_index_mode = TableIndexMode::Never, + "auto" => config.table_index_mode = TableIndexMode::Auto, + _ => eprintln!( + "unrecognized $env.config.{}.{} '{val_str}'; expected either 'never', 'always' or 'auto'", + key, key2 + ), + } + } else { + eprintln!( + "$env.config.{}.{} is not a string", + key, key2 + ) + } + } + "trim" => { + config.trim_strategy = + try_parse_trim_strategy(value, &config)? + } + x => { + eprintln!( + "$env.config.{}.{} is an unknown config setting", + key, x + ) + } + } + } + } else { + eprintln!("$env.config.{} is not a record", key) + } + } + "filesize" => { + if let Ok((cols, inner_vals)) = value.as_record() { + for (key2, value) in cols.iter().zip(inner_vals) { + let key2 = key2.as_str(); + match key2 { + "metric" => { + if let Ok(b) = value.as_bool() { + config.filesize_metric = b; + } else { + eprintln!("$env.config.{}.{} is not a bool", key, key2) + } + } + "format" => { + if let Ok(v) = value.as_string() { + config.filesize_format = v.to_lowercase(); + } else { + eprintln!( + "$env.config.{}.{} is not a string", + key, key2 + ) + } + } + x => { + eprintln!( + "$env.config.{}.{} is an unknown config setting", + key, x + ) + } + } + } + } else { + eprintln!("$env.config.{} is not a record", key) + } + } + // Misc. options "color_config" => { if let Ok(map) = create_map(value, &config) { config.color_config = map; @@ -229,7 +531,7 @@ impl Value { if let Ok(b) = value.as_bool() { config.use_grid_icons = b; } else { - eprintln!("$config.use_grid_icons is not a bool") + eprintln!("$env.config.{} is not a bool", key) } } "footer_mode" => { @@ -245,128 +547,55 @@ impl Value { }, }; } else { - eprintln!("$config.footer_mode is not a string") + eprintln!("$env.config.{} is not a string", key) } } "float_precision" => { if let Ok(i) = value.as_integer() { config.float_precision = i; } else { - eprintln!("$config.float_precision is not an integer") + eprintln!("$env.config.{} is not an integer", key) } } "use_ansi_coloring" => { if let Ok(b) = value.as_bool() { config.use_ansi_coloring = b; } else { - eprintln!("$config.use_ansi_coloring is not a bool") - } - } - "quick_completions" => { - if let Ok(b) = value.as_bool() { - config.quick_completions = b; - } else { - eprintln!("$config.quick_completions is not a bool") - } - } - "partial_completions" => { - if let Ok(b) = value.as_bool() { - config.partial_completions = b; - } else { - eprintln!("$config.partial_completions is not a bool") - } - } - "max_external_completion_results" => { - if let Ok(i) = value.as_integer() { - config.max_external_completion_results = i; - } else { - eprintln!("$config.max_external_completion_results is not an integer") - } - } - "completion_algorithm" => { - if let Ok(v) = value.as_string() { - config.completion_algorithm = v.to_lowercase(); - } else { - eprintln!("$config.completion_algorithm is not a string") - } - } - "rm_always_trash" => { - if let Ok(b) = value.as_bool() { - config.rm_always_trash = b; - } else { - eprintln!("$config.rm_always_trash is not a bool") - } - } - "filesize_format" => { - if let Ok(v) = value.as_string() { - config.filesize_format = v.to_lowercase(); - } else { - eprintln!("$config.filesize_format is not a string") + eprintln!("$env.config.{} is not a bool", key) } } "edit_mode" => { if let Ok(v) = value.as_string() { config.edit_mode = v.to_lowercase(); } else { - eprintln!("$config.edit_mode is not a string") - } - } - "history_file_format" => { - if let Ok(b) = value.as_string() { - let val_str = b.to_lowercase(); - config.history_file_format = match val_str.as_ref() { - "sqlite" => HistoryFileFormat::Sqlite, - "plaintext" => HistoryFileFormat::PlainText, - _ => { - eprintln!( - "unrecognized $config.history_file_format '{val_str}'" - ); - HistoryFileFormat::PlainText - } - }; - } else { - eprintln!("$config.history_file_format is not a string") - } - } - "max_history_size" => { - if let Ok(i) = value.as_i64() { - config.max_history_size = i; - } else { - eprintln!("$config.max_history_size is not an integer") - } - } - "sync_history_on_enter" => { - if let Ok(b) = value.as_bool() { - config.sync_history_on_enter = b; - } else { - eprintln!("$config.sync_history_on_enter is not a bool") + eprintln!("$env.config.{} is not a string", key) } } "log_level" => { if let Ok(v) = value.as_string() { config.log_level = v.to_lowercase(); } else { - eprintln!("$config.log_level is not a string") + eprintln!("$env.config.{} is not a string", key) } } "menus" => match create_menus(value) { Ok(map) => config.menus = map, Err(e) => { - eprintln!("$config.menus is not a valid list of menus"); + eprintln!("$env.config.{} is not a valid list of menus", key); eprintln!("{:?}", e); } }, "keybindings" => match create_keybindings(value) { Ok(keybindings) => config.keybindings = keybindings, Err(e) => { - eprintln!("$config.keybindings is not a valid keybindings list"); + eprintln!("$env.config.{} is not a valid keybindings list", key); eprintln!("{:?}", e); } }, "hooks" => match create_hooks(value) { Ok(hooks) => config.hooks = hooks, Err(e) => { - eprintln!("$config.hooks is not a valid hooks list"); + eprintln!("$env.config.{} is not a valid hooks list", key); eprintln!("{:?}", e); } }, @@ -374,76 +603,196 @@ impl Value { if let Ok(b) = value.as_bool() { config.shell_integration = b; } else { - eprintln!("$config.shell_integration is not a bool") + eprintln!("$env.config.{} is not a bool", key); } } "buffer_editor" => { if let Ok(v) = value.as_string() { config.buffer_editor = v.to_lowercase(); } else { - eprintln!("$config.buffer_editor is not a string") + eprintln!("$env.config.{} is not a string", key); } } - "table_index_mode" => { - if let Ok(b) = value.as_string() { - let val_str = b.to_lowercase(); - match val_str.as_ref() { - "always" => config.table_index_mode = TableIndexMode::Always, - "never" => config.table_index_mode = TableIndexMode::Never, - "auto" => config.table_index_mode = TableIndexMode::Auto, - _ => eprintln!( - "$config.table_index_mode must be a never, always or auto" - ), - } - } else { - eprintln!("$config.table_index_mode is not a string") - } - } - "cd_with_abbreviations" => { - if let Ok(b) = value.as_bool() { - config.cd_with_abbreviations = b; - } else { - eprintln!("$config.cd_with_abbreviations is not a bool") - } - } - "case_sensitive_completions" => { - if let Ok(b) = value.as_bool() { - config.case_sensitive_completions = b; - } else { - eprintln!("$config.case_sensitive_completions is not a bool") - } - } - "enable_external_completion" => { - if let Ok(b) = value.as_bool() { - config.enable_external_completion = b; - } else { - eprintln!("$config.enable_external_completion is not a bool") - } - } - "table_trim" => config.trim_strategy = try_parse_trim_strategy(value, &config)?, "show_banner" => { if let Ok(b) = value.as_bool() { config.show_banner = b; } else { - eprintln!("$config.show_banner is not a bool") - } - } - "show_clickable_links_in_ls" => { - if let Ok(b) = value.as_bool() { - config.show_clickable_links_in_ls = b; - } else { - eprintln!("$config.show_clickable_links_in_ls is not a bool") + eprintln!("$env.config.{} is not a bool", key); } } "render_right_prompt_on_last_line" => { if let Ok(b) = value.as_bool() { config.render_right_prompt_on_last_line = b; } else { - eprintln!("$config.render_right_prompt_on_last_line is not a bool") + eprintln!("$env.config.{} is not a bool", key); } } + // Legacy config options (deprecated as of 2022-11-02) + "use_ls_colors" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.use_ls_colors = b; + } else { + eprintln!("$env.config.use_ls_colors is not a bool") + } + } + "rm_always_trash" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.rm_always_trash = b; + } else { + eprintln!("$env.config.rm_always_trash is not a bool") + } + } + "history_file_format" => { + legacy_options_used = true; + if let Ok(b) = value.as_string() { + let val_str = b.to_lowercase(); + config.history_file_format = match val_str.as_ref() { + "sqlite" => HistoryFileFormat::Sqlite, + "plaintext" => HistoryFileFormat::PlainText, + _ => { + eprintln!( + "unrecognized $env.config.history_file_format '{val_str}'" + ); + HistoryFileFormat::PlainText + } + }; + } else { + eprintln!("$env.config.history_file_format is not a string") + } + } + "sync_history_on_enter" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.sync_history_on_enter = b; + } else { + eprintln!("$env.config.sync_history_on_enter is not a bool") + } + } + "max_history_size" => { + legacy_options_used = true; + if let Ok(i) = value.as_i64() { + config.max_history_size = i; + } else { + eprintln!("$env.config.max_history_size is not an integer") + } + } + "quick_completions" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.quick_completions = b; + } else { + eprintln!("$env.config.quick_completions is not a bool") + } + } + "partial_completions" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.partial_completions = b; + } else { + eprintln!("$env.config.partial_completions is not a bool") + } + } + "max_external_completion_results" => { + legacy_options_used = true; + if let Ok(i) = value.as_integer() { + config.max_external_completion_results = i; + } else { + eprintln!( + "$env.config.max_external_completion_results is not an integer" + ) + } + } + "completion_algorithm" => { + legacy_options_used = true; + if let Ok(v) = value.as_string() { + let val_str = v.to_lowercase(); + config.completion_algorithm = match val_str.as_ref() { + // This should match the MatchAlgorithm enum in completions::completion_options + "prefix" => val_str, + "fuzzy" => val_str, + _ => { + eprintln!( + "unrecognized $env.config.completions.algorithm '{val_str}'; expected either 'prefix' or 'fuzzy'" + ); + val_str + } + }; + } else { + eprintln!("$env.config.completion_algorithm is not a string") + } + } + "case_sensitive_completions" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.case_sensitive_completions = b; + } else { + eprintln!("$env.config.case_sensitive_completions is not a bool") + } + } + "enable_external_completion" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.enable_external_completion = b; + } else { + eprintln!("$env.config.enable_external_completion is not a bool") + } + } + + "external_completer" => { + legacy_options_used = true; + if let Ok(v) = value.as_block() { + config.external_completer = Some(v) + } + } + "table_mode" => { + legacy_options_used = true; + if let Ok(v) = value.as_string() { + config.table_mode = v; + } else { + eprintln!("$env.config.table_mode is not a string") + } + } + "table_trim" => { + legacy_options_used = true; + config.trim_strategy = try_parse_trim_strategy(value, &config)? + } + "show_clickable_links_in_ls" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.show_clickable_links_in_ls = b; + } else { + eprintln!("$env.config.show_clickable_links_in_ls is not a bool") + } + } + "cd_with_abbreviations" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.cd_with_abbreviations = b; + } else { + eprintln!("$env.config.cd_with_abbreviations is not a bool") + } + } + "filesize_metric" => { + legacy_options_used = true; + if let Ok(b) = value.as_bool() { + config.filesize_metric = b; + } else { + eprintln!("$env.config.filesize_metric is not a bool") + } + } + "filesize_format" => { + legacy_options_used = true; + if let Ok(v) = value.as_string() { + config.filesize_format = v.to_lowercase(); + } else { + eprintln!("$env.config.filesize_format is not a string") + } + } + // End legacy options x => { - eprintln!("$config.{} is an unknown config setting", x) + eprintln!("$env.config.{} is an unknown config setting", x) } } } @@ -451,13 +800,20 @@ impl Value { eprintln!("$env.config is not a record"); } + if legacy_options_used { + eprintln!( + r#"The format of $env.config has recently changed, and several options have been grouped into sub-records. You may need to update your config.nu file. +Please consult https://www.nushell.sh/blog/2022-11-29-nushell-0.72.html for details. Support for the old format will be removed in an upcoming Nu release."# + ); + } + Ok(config) } } fn try_parse_trim_strategy(value: &Value, config: &Config) -> Result { let map = create_map(value, config).map_err(|e| { - eprintln!("$env.config.table_trim is not a record"); + eprintln!("$env.config.table.trim is not a record"); e })?; @@ -467,7 +823,7 @@ fn try_parse_trim_strategy(value: &Value, config: &Config) -> Result return Ok(TRIM_STRATEGY_DEFAULT), }, None => { - eprintln!("$config.table_trim.methodology was not provided"); + eprintln!("$env.config.table.trim.methodology was not provided"); return Ok(TRIM_STRATEGY_DEFAULT); } }; @@ -478,7 +834,7 @@ fn try_parse_trim_strategy(value: &Value, config: &Config) -> Result Result Option { }); } "truncating" => return Some(TrimStrategy::Truncate { suffix: None }), - _ => eprintln!("unrecognized $config.trim_methodology value; expected values ['truncating', 'wrapping']"), + _ => eprintln!("unrecognized $config.table.trim.methodology value; expected either 'truncating' or 'wrapping'"), }, - Err(_) => eprintln!("$config.trim_methodology is not a string"), + Err(_) => eprintln!("$env.config.table.trim.methodology is not a string"), } None diff --git a/crates/nu-utils/src/sample_config/default_config.nu b/crates/nu-utils/src/sample_config/default_config.nu index a5a711c29..412e768c2 100644 --- a/crates/nu-utils/src/sample_config/default_config.nu +++ b/crates/nu-utils/src/sample_config/default_config.nu @@ -243,43 +243,55 @@ let light_theme = { # The default config record. This is where much of your global configuration is setup. let-env config = { - external_completer: null # check 'carapace_completer' above to as example - filesize_metric: false # true => (KB, MB, GB), false => (KiB, MiB, GiB) - table_mode: rounded # basic, compact, compact_double, light, thin, with_love, rounded, reinforced, heavy, none, other - use_ls_colors: true - rm_always_trash: false + ls: { + use_ls_colors: true # use the LS_COLORS environment variable to colorize output + clickable_links: true # enable or disable clickable links. Your terminal has to support links. + } + rm: { + always_trash: false # always act as if -t was given. Can be overridden with -p + } + cd: { + abbreviations: true # allows `cd s/o/f` to expand to `cd some/other/folder` + } + table: { + mode: rounded # basic, compact, compact_double, light, thin, with_love, rounded, reinforced, heavy, none, other + index_mode: always # "always" show indexes, "never" show indexes, "auto" = show indexes when a table has "index" column + trim: { + methodology: wrapping # wrapping or truncating + wrapping_try_keep_words: true # A strategy used by the 'wrapping' methodology + truncating_suffix: "..." # A suffix used by the 'truncating' methodology + } + } + history: { + max_size: 10000 # Session has to be reloaded for this to take effect + sync_on_enter: true # Enable to share history between multiple sessions, else you have to close the session to write history to file + file_format: "plaintext" # "sqlite" or "plaintext" + } + completions: { + case_sensitive: false # set to true to enable case-sensitive completions + quick: true # set this to false to prevent auto-selecting completions when only one remains + partial: true # set this to false to prevent partial filling of the prompt + algorithm: "prefix" # prefix or fuzzy + external: { + enable: true # set to false to prevent nushell looking into $env.PATH to find more suggestions, `false` recommended for WSL users as this look up my be very slow + max_results: 100 # setting it lower can improve completion performance at the cost of omitting some options + completer: null # check 'carapace_completer' above as an example + } + } + filesize: { + metric: true # true => KB, MB, GB (ISO standard), false => KiB, MiB, GiB (Windows standard) + format: "auto" # b, kb, kib, mb, mib, gb, gib, tb, tib, pb, pib, eb, eib, zb, zib, auto + } color_config: $dark_theme # if you want a light theme, replace `$dark_theme` to `$light_theme` use_grid_icons: true footer_mode: "25" # always, never, number_of_rows, auto - quick_completions: true # set this to false to prevent auto-selecting completions when only one remains - partial_completions: true # set this to false to prevent partial filling of the prompt - completion_algorithm: "prefix" # prefix, fuzzy float_precision: 2 # buffer_editor: "emacs" # command that will be used to edit the current line buffer with ctrl+o, if unset fallback to $env.EDITOR and $env.VISUAL use_ansi_coloring: true - filesize_format: "auto" # b, kb, kib, mb, mib, gb, gib, tb, tib, pb, pib, eb, eib, zb, zib, auto edit_mode: emacs # emacs, vi - max_history_size: 10000 # Session has to be reloaded for this to take effect - sync_history_on_enter: true # Enable to share the history between multiple sessions, else you have to close the session to persist history to file - history_file_format: "plaintext" # "sqlite" or "plaintext" shell_integration: true # enables terminal markers and a workaround to arrow keys stop working issue - table_index_mode: always # "always" show indexes, "never" show indexes, "auto" = show indexes when a table has "index" column - cd_with_abbreviations: false # set to true to allow you to do things like cd s/o/f and nushell expand it to cd some/other/folder - case_sensitive_completions: false # set to true to enable case-sensitive completions - enable_external_completion: true # set to false to prevent nushell looking into $env.PATH to find more suggestions, `false` recommended for WSL users as this look up my be very slow - max_external_completion_results: 100 # setting it lower can improve completion performance at the cost of omitting some options - # A strategy of managing table view in case of limited space. - table_trim: { - methodology: wrapping, # truncating - # A strategy which will be used by 'wrapping' methodology - wrapping_try_keep_words: true, - # A suffix which will be used with 'truncating' methodology - # truncating_suffix: "..." - } show_banner: true # true or false to enable or disable the banner - show_clickable_links_in_ls: true # true or false to enable or disable clickable links in the ls listing. your terminal has to support links. render_right_prompt_on_last_line: false # true or false to enable or disable right prompt to be rendered on last line of the prompt. - hooks: { pre_prompt: [{ $nothing # replace with source code to run before the prompt is shown