Mirrors/nushell
2
0
Fork 0
mirror of https://github.com/nushell/nushell synced 2024-11-10 07:04:13 +00:00
Code Issues Projects Releases Packages Wiki Activity

enable cd to work with directory abbreviations (#5452)

Browse source 
* enable cd to work with abbreviations

* add abbreviation example

* fix tests

* make it configurable
This commit is contained in:
Darren Schroeder 2022-05-06 07:58:32 -05:00 committed by GitHub
parent 78a1879e36
commit 768ff47d28
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 666 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
Cargo.lock generated
View file

@ -62,6 +62,12 @@ dependencies = [
"alloc-no-stdlib",
]
[[package]]
name = "alphanumeric-sort"
version = "1.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77e9c9abb82613923ec78d7a461595d52491ba7240f3c64c0bbe0e6d98e0fce0"
[[package]]
name = "ansi-parser"
version = "0.8.0"
@ -2486,6 +2492,7 @@ name = "nu-command"
version = "0.62.0"
dependencies = [
"Inflector",
"alphanumeric-sort",
"base64",
"bytesize",
"calamine",
@ -2532,6 +2539,7 @@ dependencies = [
"num 0.4.0",
"pathdiff",
"polars",
"powierza-coefficient",
"quick-xml 0.22.0",
"quickcheck",
"quickcheck_macros",
@ -3360,6 +3368,12 @@ dependencies = [
"nom 7.1.1",
]
[[package]]
name = "powierza-coefficient"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9caa43783252cf8c4c66dd1cc381a5929cc95f6530da7abd1f9cdb97e2065842"
[[package]]
name = "ppv-lite86"
version = "0.2.16"

2
crates/nu-command/Cargo.toml
View file

@ -26,6 +26,7 @@ nu-utils = { path = "../nu-utils", version = "0.62.0" }
nu-ansi-term = "0.45.1"
# Potential dependencies for extras
alphanumeric-sort = "1.4.4"
base64 = "0.13.0"
bytesize = "1.1.0"
calamine = "0.18.0"
@ -56,6 +57,7 @@ mime = "0.3.16"
notify = "4.0.17"
num = { version = "0.4.0", optional = true }
pathdiff = "0.2.1"
powierza-coefficient = "1.0"
quick-xml = "0.22"
rand = "0.8"
rayon = "1.5.1"

84
crates/nu-command/src/filesystem/cd.rs
View file

@ -1,3 +1,4 @@
use crate::filesystem::cd_query::query;
use nu_engine::{current_dir, CallExt};
use nu_protocol::ast::Call;
use nu_protocol::engine::{Command, EngineState, Stack};
@ -36,6 +37,8 @@ impl Command for Cd {
) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
let path_val: Option<Spanned<String>> = call.opt(engine_state, stack, 0)?;
let cwd = current_dir(engine_state, stack)?;
let config = engine_state.get_config();
let use_abbrev = config.cd_with_abbreviations;
let (path, span) = match path_val {
Some(v) => {
@ -44,13 +47,25 @@ impl Command for Cd {
if let Some(oldpwd) = oldpwd {
let path = oldpwd.as_path()?;
let path = match nu_path::canonicalize_with(path, &cwd) {
let path = match nu_path::canonicalize_with(path.clone(), &cwd) {
Ok(p) => p,
Err(e) => {
return Err(ShellError::DirectoryNotFound(
v.span,
Some(format!("IO Error: {:?}", e)),
))
Err(e1) => {
if use_abbrev {
match query(&path, None, v.span) {
Ok(p) => p,
Err(e) => {
return Err(ShellError::DirectoryNotFound(
v.span,
Some(format!("IO Error: {:?}", e)),
))
}
}
} else {
return Err(ShellError::DirectoryNotFound(
v.span,
Some(format!("IO Error: {:?}", e1)),
));
}
}
};
(path.to_string_lossy().to_string(), v.span)
@ -64,16 +79,42 @@ impl Command for Cd {
let path = match nu_path::canonicalize_with(path_no_whitespace, &cwd) {
Ok(p) => {
if !p.is_dir() {
return Err(ShellError::NotADirectory(v.span));
}
if use_abbrev {
// if it's not a dir, let's check to see if it's something abbreviated
match query(&p, None, v.span) {
Ok(path) => path,
Err(e) => {
return Err(ShellError::DirectoryNotFound(
v.span,
Some(format!("IO Error: {:?}", e)),
))
}
};
} else {
return Err(ShellError::NotADirectory(v.span));
}
};
p
}
Err(e) => {
return Err(ShellError::DirectoryNotFound(
v.span,
Some(format!("IO Error: {:?}", e)),
))
// if canonicalize failed, let's check to see if it's abbreviated
Err(e1) => {
if use_abbrev {
match query(&path_no_whitespace, None, v.span) {
Ok(path) => path,
Err(e) => {
return Err(ShellError::DirectoryNotFound(
v.span,
Some(format!("IO Error: {:?}", e)),
))
}
}
} else {
return Err(ShellError::DirectoryNotFound(
v.span,
Some(format!("IO Error: {:?}", e1)),
));
}
}
};
(path.to_string_lossy().to_string(), v.span)
@ -136,10 +177,17 @@ impl Command for Cd {
}
fn examples(&self) -> Vec<Example> {
vec![Example {
description: "Change to your home directory",
example: r#"cd ~"#,
result: None,
}]
vec![
Example {
description: "Change to your home directory",
example: r#"cd ~"#,
result: None,
},
Example {
description: "Change to a directory via abbreviations",
example: r#"cd d/s/9"#,
result: None,
},
]
}
}

549
crates/nu-command/src/filesystem/cd_query.rs Normal file
View file

@ -0,0 +1,549 @@
// Attribution:
// Thanks kn team https://github.com/micouy/kn
use alphanumeric_sort::compare_os_str;
use nu_protocol::ShellError;
use nu_protocol::Span;
use powierza_coefficient::powierża_coefficient;
use std::cmp::{Ord, Ordering};
use std::{
convert::AsRef,
ffi::{OsStr, OsString},
fs::DirEntry,
mem,
path::{Component, Path, PathBuf},
};
/// A path matching an abbreviation.
///
/// Stores [`Congruence`](Congruence)'s of its ancestors, with that of the
/// closest ancestors first (so that it can be compared
/// [lexicographically](std::cmp::Ord#lexicographical-comparison).
struct Finding {
file_name: OsString,
path: PathBuf,
congruence: Vec<Congruence>,
}
/// Returns an interator over directory's children matching the abbreviation.
fn get_matching_children<'a, P>(
path: &'a P,
abbr: &'a Abbr,
parent_congruence: &'a [Congruence],
) -> impl Iterator<Item = Finding> + 'a
where
P: AsRef<Path>,
{
let filter_map_entry = move |entry: DirEntry| {
let file_type = entry.file_type().ok()?;
if file_type.is_dir() || file_type.is_symlink() {
let file_name: String = entry.file_name().into_string().ok()?;
if let Some(congruence) = abbr.compare(&file_name) {
let mut entry_congruence = parent_congruence.to_vec();
entry_congruence.insert(0, congruence);
return Some(Finding {
file_name: entry.file_name(),
congruence: entry_congruence,
path: entry.path(),
});
}
}
None
};
path.as_ref()
.read_dir()
.ok()
.map(|reader| {
reader
.filter_map(|entry| entry.ok())
.filter_map(filter_map_entry)
})
.into_iter()
.flatten()
}
/// The `query` subcommand.
///
/// It takes two args — `--abbr` and `--exclude` (optionally). The value of
/// `--abbr` gets split into a prefix containing components like `c:/`, `/`,
/// `~/`, and dots, and [`Abbr`](Abbr)'s. If there is more than one dir matching
/// the query, the value of `--exclude` is excluded from the search.
pub fn query<P>(arg: &P, excluded: Option<PathBuf>, span: Span) -> Result<PathBuf, ShellError>
where
P: AsRef<Path>,
{
// If the arg is a real path and not an abbreviation, return it. It
// prevents potential unexpected behavior due to abbreviation expansion.
// For example, `kn` doesn't allow for any component other than `Normal` in
// the abbreviation but the arg itself may be a valid path. `kn` should only
// behave differently from `cd` in situations where `cd` would fail.
if arg.as_ref().is_dir() {
return Ok(arg.as_ref().into());
}
let (prefix, abbrs) = parse_arg(&arg)?;
let start_dir = match prefix {
Some(start_dir) => start_dir,
None => std::env::current_dir()?,
};
match abbrs.as_slice() {
[] => Ok(start_dir),
[first_abbr, abbrs @ ..] => {
let mut current_level =
get_matching_children(&start_dir, first_abbr, &[]).collect::<Vec<_>>();
let mut next_level = vec![];
for abbr in abbrs {
let children = current_level.iter().flat_map(|parent| {
get_matching_children(&parent.path, abbr, &parent.congruence)
});
next_level.clear();
next_level.extend(children);
mem::swap(&mut next_level, &mut current_level);
}
let cmp_findings = |finding_a: &Finding, finding_b: &Finding| {
finding_a
.congruence
.cmp(&finding_b.congruence)
.then(compare_os_str(&finding_a.file_name, &finding_b.file_name))
};
let found_path = match excluded {
Some(excluded) if current_level.len() > 1 => current_level
.into_iter()
.filter(|finding| finding.path != excluded)
.min_by(cmp_findings)
.map(|Finding { path, .. }| path),
_ => current_level
.into_iter()
.min_by(cmp_findings)
.map(|Finding { path, .. }| path),
};
found_path.ok_or(ShellError::NotADirectory(span))
}
}
}
/// Checks if the component contains only dots and returns the equivalent number
/// of [`ParentDir`](Component::ParentDir) components if it does.
///
/// It is the number of dots, less one. For example, `...` is converted to
/// `../..`, `....` to `../../..` etc.
fn parse_dots(component: &str) -> Option<usize> {
component
.chars()
.try_fold(
0,
|n_dots, c| if c == '.' { Some(n_dots + 1) } else { None },
)
.and_then(|n_dots| if n_dots > 1 { Some(n_dots - 1) } else { None })
}
/// Extracts leading components of the path that are not parts of the
/// abbreviation.
///
/// The prefix is the path where the search starts. If there is no prefix (when
/// the path consists only of normal components), the search starts in the
/// current directory, just as you'd expect. The function collects each
/// [`Prefix`](Component::Prefix), [`RootDir`](Component::RootDir),
/// [`CurDir`](Component::CurDir), and [`ParentDir`](Component::ParentDir)
/// components and stops at the first [`Normal`](Component::Normal) component
/// **unless** it only contains dots. In this case, it converts it to as many
/// [`ParentDir`](Component::ParentDir)'s as there are dots in this component,
/// less one. For example, `...` is converted to `../..`, `....` to `../../..`
/// etc.
fn extract_prefix<'a, P>(
arg: &'a P,
) -> Result<(Option<PathBuf>, impl Iterator<Item = Component<'a>> + 'a), ShellError>
where
P: AsRef<Path> + ?Sized + 'a,
{
use Component::*;
let mut components = arg.as_ref().components().peekable();
let mut prefix: Option<PathBuf> = None;
let mut push_to_prefix = |component: Component| match &mut prefix {
None => prefix = Some(PathBuf::from(&component)),
Some(prefix) => prefix.push(component),
};
let parse_dots_os = |component_os: &OsStr| {
component_os
.to_os_string()
.into_string()
.map_err(|_| ShellError::NonUnicodeInput)
.map(|component| parse_dots(&component))
};
while let Some(component) = components.peek() {
match component {
Prefix(_) | RootDir | CurDir | ParentDir => push_to_prefix(*component),
Normal(component_os) => {
if let Some(n_dots) = parse_dots_os(component_os)? {
(0..n_dots).for_each(|_| push_to_prefix(ParentDir));
} else {
break;
}
}
}
let _consumed = components.next();
}
Ok((prefix, components))
}
/// Converts each component into [`Abbr`](Abbr) without checking
/// the component's type.
///
/// This may change in the future.
fn parse_abbrs<'a, I>(components: I) -> Result<Vec<Abbr>, ShellError>
where
I: Iterator<Item = Component<'a>> + 'a,
{
use Component::*;
let abbrs = components
.into_iter()
.map(|component| match component {
Prefix(_) | RootDir | CurDir | ParentDir => {
let component_string = component
.as_os_str()
.to_os_string()
.to_string_lossy()
.to_string();
Err(ShellError::UnexpectedAbbrComponent(component_string))
}
Normal(component_os) => component_os
.to_os_string()
.into_string()
.map_err(|_| ShellError::NonUnicodeInput)
.map(|string| Abbr::new_sanitized(&string)),
})
.collect::<Result<Vec<_>, _>>()?;
Ok(abbrs)
}
/// Parses the provided argument into a prefix and [`Abbr`](Abbr)'s.
fn parse_arg<P>(arg: &P) -> Result<(Option<PathBuf>, Vec<Abbr>), ShellError>
where
P: AsRef<Path>,
{
let (prefix, suffix) = extract_prefix(arg)?;
let abbrs = parse_abbrs(suffix)?;
Ok((prefix, abbrs))
}
#[cfg(test)]
mod test {
use super::*;
// // #[cfg(any(test, doc))]
// // #[macro_export]
// // macro_rules! assert_variant {
// // ($expression_in:expr , $( pat )|+ $( if $guard: expr )? $( => $expression_out:expr )? ) => {
// // match $expression_in {
// // $( $pattern )|+ $( if $guard )? => { $( $expression_out )? },
// // variant => panic!("{:?}", variant),
// // }
// // };
// // ($expression_in:expr , $( pat )|+ $( if $guard: expr )? $( => $expression_out:expr)? , $panic:expr) => {
// // match $expression_in {
// // $( $pattern )|+ $( if $guard )? => { $( $expression_out )? },
// // _ => panic!($panic),
// // }
// // };
// // }
// /// Asserts that the expression matches the variant. Optionally returns a value.
// ///
// /// Inspired by [`std::matches`](https://doc.rust-lang.org/stable/std/macro.matches.html).
// ///
// /// # Examples
// ///
// /// ```
// /// # fn main() -> Option<()> {
// /// use kn::Congruence::*;
// ///
// /// let abbr = Abbr::new_sanitized("abcjkl");
// /// let coeff_1 = assert_variant!(abbr.compare("abc_jkl"), Some(Subsequence(coeff)) => coeff);
// /// let coeff_2 = assert_variant!(abbr.compare("ab_cj_kl"), Some(Subsequence(coeff)) => coeff);
// /// assert!(coeff_1 < coeff_2);
// /// # Ok(())
// /// # }
// /// ```
// #[cfg(any(test, doc))]
// #[macro_export]
// macro_rules! assert_variant {
// ($expression_in:expr , $( $pattern:pat )+ $( if $guard: expr )? $( => $expression_out:expr )? ) => {
// match $expression_in {
// $( $pattern )|+ $( if $guard )? => { $( $expression_out )? },
// variant => panic!("{:?}", variant),
// }
// };
// ($expression_in:expr , $( $pattern:pat )+ $( if $guard: expr )? $( => $expression_out:expr)? , $panic:expr) => {
// match $expression_in {
// $( $pattern )|+ $( if $guard )? => { $( $expression_out )? },
// _ => panic!($panic),
// }
// };
// }
// #[test]
// fn test_parse_dots() {
// assert_variant!(parse_dots(""), None);
// assert_variant!(parse_dots("."), None);
// assert_variant!(parse_dots(".."), Some(1));
// assert_variant!(parse_dots("..."), Some(2));
// assert_variant!(parse_dots("...."), Some(3));
// assert_variant!(parse_dots("xyz"), None);
// assert_variant!(parse_dots("...dot"), None);
// }
#[test]
fn test_extract_prefix() {
{
let (prefix, suffix) = extract_prefix("suf/fix").unwrap();
let suffix = suffix.collect::<PathBuf>();
assert_eq!(prefix, None);
assert_eq!(as_path(&suffix), as_path("suf/fix"));
}
{
let (prefix, suffix) = extract_prefix("./.././suf/fix").unwrap();
let suffix = suffix.collect::<PathBuf>();
assert_eq!(prefix.unwrap(), as_path("./.."));
assert_eq!(as_path(&suffix), as_path("suf/fix"));
}
{
let (prefix, suffix) = extract_prefix(".../.../suf/fix").unwrap();
let suffix = suffix.collect::<PathBuf>();
assert_eq!(prefix.unwrap(), as_path("../../../.."));
assert_eq!(as_path(&suffix), as_path("suf/fix"));
}
}
#[test]
fn test_parse_arg_invalid_unicode() {
#[cfg(unix)]
{
use std::ffi::OsStr;
use std::os::unix::ffi::OsStrExt;
let source = [0x66, 0x6f, 0x80, 0x6f];
let non_unicode_input = OsStr::from_bytes(&source[..]).to_os_string();
let result = parse_arg(&non_unicode_input);
assert!(result.is_err());
}
#[cfg(windows)]
{
use std::os::windows::prelude::*;
let source = [0x0066, 0x006f, 0xd800, 0x006f];
let os_string = OsString::from_wide(&source[..]);
let result = parse_arg(&os_string);
assert!(result.is_err());
}
}
#[test]
fn test_congruence_ordering() {
assert!(Complete < Prefix);
assert!(Complete < Subsequence(1));
assert!(Prefix < Subsequence(1));
assert!(Subsequence(1) < Subsequence(1000));
}
// #[test]
// fn test_compare_abbr() {
// let abbr = Abbr::new_sanitized("abcjkl");
// assert_variant!(abbr.compare("abcjkl"), Some(Complete));
// assert_variant!(abbr.compare("abcjkl_"), Some(Prefix));
// assert_variant!(abbr.compare("_abcjkl"), Some(Subsequence(0)));
// assert_variant!(abbr.compare("abc_jkl"), Some(Subsequence(1)));
// assert_variant!(abbr.compare("xyz"), None);
// assert_variant!(abbr.compare(""), None);
// }
// #[test]
// fn test_compare_abbr_different_cases() {
// let abbr = Abbr::new_sanitized("AbCjKl");
// assert_variant!(abbr.compare("aBcJkL"), Some(Complete));
// assert_variant!(abbr.compare("AbcJkl_"), Some(Prefix));
// assert_variant!(abbr.compare("_aBcjKl"), Some(Subsequence(0)));
// assert_variant!(abbr.compare("abC_jkL"), Some(Subsequence(1)));
// }
// #[test]
// fn test_empty_abbr_empty_component() {
// let empty = "";
// let abbr = Abbr::new_sanitized(empty);
// assert_variant!(abbr.compare("non empty component"), None);
// let abbr = Abbr::new_sanitized("non empty abbr");
// assert_variant!(abbr.compare(empty), None);
// }
#[test]
fn test_order_paths() {
fn sort<'a>(paths: &'a Vec<&'a str>, abbr: &str) -> Vec<&'a str> {
let abbr = Abbr::new_sanitized(abbr);
let mut paths = paths.clone();
paths.sort_by_key(|path| abbr.compare(path).unwrap());
paths
}
let paths = vec!["playground", "plotka"];
assert_eq!(paths, sort(&paths, "pla"));
let paths = vec!["veccentric", "vehiccles"];
assert_eq!(paths, sort(&paths, "vecc"));
}
}
/// Shorthand for `AsRef<Path>::as_ref(&x)`.
#[cfg(any(test, doc))]
pub fn as_path<P>(path: &P) -> &Path
where
P: AsRef<Path> + ?Sized,
{
path.as_ref()
}
/// A component of the user's query.
///
/// It is used in comparing and ordering of found paths. Read more in
/// [`Congruence`'s docs](Congruence).
#[derive(Debug, Clone)]
pub enum Abbr {
/// Wildcard matches every component with congruence
/// [`Complete`](Congruence::Complete).
Wildcard,
/// Literal abbreviation.
Literal(String),
}
impl Abbr {
/// Constructs [`Abbr::Wildcard`](Abbr::Wildcard) if the
/// string slice is '-', otherwise constructs
/// wrapped [`Abbr::Literal`](Abbr::Literal) with the abbreviation
/// mapped to its ASCII lowercase equivalent.
pub fn new_sanitized(abbr: &str) -> Self {
if abbr == "-" {
Self::Wildcard
} else {
Self::Literal(abbr.to_ascii_lowercase())
}
}
/// Compares a component against the abbreviation.
pub fn compare(&self, component: &str) -> Option<Congruence> {
// What about characters with accents? [https://eev.ee/blog/2015/09/12/dark-corners-of-unicode/]
let component = component.to_ascii_lowercase();
match self {
Self::Wildcard => Some(Congruence::Complete),
Self::Literal(literal) => {
if literal.is_empty() || component.is_empty() {
None
} else if *literal == component {
Some(Congruence::Complete)
} else if component.starts_with(literal) {
Some(Congruence::Prefix)
} else {
powierża_coefficient(literal, &component).map(Congruence::Subsequence)
}
}
}
}
}
/// The strength of the match between an abbreviation and a component.
///
/// [`Congruence`](Congruence) is used to order path components in the following
/// way:
///
/// 1. Components are first ordered based on how well they match the
/// abbreviation — first [`Complete`](Congruence::Complete), then
/// [`Prefix`](Congruence::Prefix), then
/// [`Subsequence`](Congruence::Subsequence).
/// 2. Components with congruence [`Subsequence`](Congruence::Subsequence) are
/// ordered by their [Powierża coefficient](https://github.com/micouy/powierza-coefficient).
/// 3. If the order of two components cannot be determined based on the above, [`alphanumeric_sort`](https://docs.rs/alphanumeric-sort) is used.
///
/// Below are the results of matching components against abbreviation `abc`:
///
/// | Component | Match strength |
/// |-------------|------------------------------------------|
/// | `abc` | [`Complete`](Congruence::Complete) |
/// | `abc___` | [`Prefix`](Congruence::Prefix) |
/// | `_a_b_c_` | [`Subsequence`](Congruence::Subsequence) |
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Congruence {
/// Either the abbreviation and the component are the same or the
/// abbreviation is a wildcard.
Complete,
/// The abbreviation is a prefix of the component.
Prefix,
/// The abbreviation's characters form a subsequence of the component's
/// characters. The field contains the Powierża coefficient of the pair of
/// strings.
Subsequence(u32),
}
use Congruence::*;
impl PartialOrd for Congruence {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(Ord::cmp(self, other))
}
}
impl Ord for Congruence {
fn cmp(&self, other: &Self) -> Ordering {
use Ordering::*;
match (self, other) {
(Complete, Complete) => Equal,
(Complete, Prefix) => Less,
(Complete, Subsequence(_)) => Less,
(Prefix, Complete) => Greater,
(Prefix, Prefix) => Equal,
(Prefix, Subsequence(_)) => Less,
(Subsequence(_), Complete) => Greater,
(Subsequence(_), Prefix) => Greater,
(Subsequence(dist_a), Subsequence(dist_b)) => dist_a.cmp(dist_b),
}
}
}

2
crates/nu-command/src/filesystem/mod.rs
View file

@ -1,4 +1,5 @@
mod cd;
mod cd_query;
mod cp;
mod glob;
mod ls;
@ -12,6 +13,7 @@ mod util;
mod watch;
pub use cd::Cd;
pub use cd_query::query;
pub use cp::Cp;
pub use glob::Glob;
pub use ls::Ls;

19
crates/nu-command/tests/format_conversions/html.rs
View file

@ -56,7 +56,7 @@ fn test_cd_html_color_flag_dark_false() {
);
assert_eq!(
actual.out,
r"<html><style>body { background-color:white;color:black; }</style><body>Change directory.<br><br>Usage:<br> &gt; cd (path) <br><br>Flags:<br> -h, --help<br> Display this help message<br><br>Parameters:<br> (optional) path: the path to change to<br><br>Examples:<br> Change to your home directory<br> &gt; <span style='color:#037979;font-weight:bold;'>cd<span style='color:black;font-weight:normal;'> </span></span><span style='color:#037979;'>~<span style='color:black;font-weight:normal;'><br><br></body></html></span></span>"
r"<html><style>body { background-color:white;color:black; }</style><body>Change directory.<br><br>Usage:<br> &gt; cd (path) <br><br>Flags:<br> -h, --help<br> Display this help message<br><br>Parameters:<br> (optional) path: the path to change to<br><br>Examples:<br> Change to your home directory<br> &gt; <span style='color:#037979;font-weight:bold;'>cd<span style='color:black;font-weight:normal;'> </span></span><span style='color:#037979;'>~<span style='color:black;font-weight:normal;'><br><br> Change to a directory via abbreviations<br> &gt; </span><span style='color:#037979;font-weight:bold;'>cd<span style='color:black;font-weight:normal;'> </span></span></span><span style='color:#037979;'>d/s/9<span style='color:black;font-weight:normal;'><br><br></body></html></span></span>"
);
}
@ -71,21 +71,6 @@ fn test_no_color_flag() {
);
assert_eq!(
actual.out,
r"<html><style>body { background-color:white;color:black; }</style><body>Change directory.<br><br>Usage:<br> &gt; cd (path) <br><br>Flags:<br> -h, --help<br> Display this help message<br><br>Parameters:<br> (optional) path: the path to change to<br><br>Examples:<br> Change to your home directory<br> &gt; cd ~<br><br></body></html>"
);
}
#[test]
fn test_html_color_cd_flag_dark_false() {
let actual = nu!(
cwd: ".", pipeline(
r#"
cd --help | to html --html-color
"#
)
);
assert_eq!(
actual.out,
r"<html><style>body { background-color:white;color:black; }</style><body>Change directory.<br><br>Usage:<br> &gt; cd (path) <br><br>Flags:<br> -h, --help<br> Display this help message<br><br>Parameters:<br> (optional) path: the path to change to<br><br>Examples:<br> Change to your home directory<br> &gt; <span style='color:#037979;font-weight:bold;'>cd<span style='color:black;font-weight:normal;'> </span></span><span style='color:#037979;'>~<span style='color:black;font-weight:normal;'><br><br></body></html></span></span>"
r"<html><style>body { background-color:white;color:black; }</style><body>Change directory.<br><br>Usage:<br> &gt; cd (path) <br><br>Flags:<br> -h, --help<br> Display this help message<br><br>Parameters:<br> (optional) path: the path to change to<br><br>Examples:<br> Change to your home directory<br> &gt; cd ~<br><br> Change to a directory via abbreviations<br> &gt; cd d/s/9<br><br></body></html>"
);
}

10
crates/nu-protocol/src/config.rs
View file

@ -49,6 +49,7 @@ pub struct Config {
pub shell_integration: bool,
pub buffer_editor: String,
pub disable_table_indexes: bool,
pub cd_with_abbreviations: bool,
}
impl Default for Config {
@ -77,6 +78,7 @@ impl Default for Config {
shell_integration: false,
buffer_editor: String::new(),
disable_table_indexes: false,
cd_with_abbreviations: false,
}
}
}
@ -265,7 +267,6 @@ impl Value {
eprintln!("$config.buffer_editor is not a string")
}
}
"disable_table_indexes" => {
if let Ok(b) = value.as_bool() {
config.disable_table_indexes = b;
@ -273,6 +274,13 @@ impl Value {
eprintln!("$config.disable_table_indexes is not a bool")
}
}
"cd_with_abbreviations" => {
if let Ok(b) = value.as_bool() {
config.cd_with_abbreviations = b;
} else {
eprintln!("$config.disable_table_indexes is not a bool")
}
}
x => {
eprintln!("$config.{} is an unknown config setting", x)
}

21
crates/nu-protocol/src/shell_error.rs
View file

@ -636,6 +636,27 @@ Either make sure {0} is a string, or add a 'to_string' entry for it in ENV_CONVE
String,
#[label = "'{0}' is deprecated. Please use '{1}' instead."] Span,
),
/// Non-Unicode input received.
///
/// ## Resolution
///
/// Check that your path is UTF-8 compatible.
#[error("Non-Unicode input received.")]
#[diagnostic(code(nu::shell::non_unicode_input), url(docsrs))]
NonUnicodeInput,
// /// Path not found.
// #[error("Path not found.")]
// PathNotFound,
/// Unexpected abbr component.
///
/// ## Resolution
///
/// Check the path abbreviation to ensure that it is valid.
#[error("Unexpected abbr component `{0}`.")]
#[diagnostic(code(nu::shell::unexpected_path_abbreviateion), url(docsrs))]
UnexpectedAbbrComponent(String),
}
impl From<std::io::Error> for ShellError {

1
docs/sample_config/default_config.nu
View file

@ -198,6 +198,7 @@ let-env config = {
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
shell_integration: true # enables terminal markers and a workaround to arrow keys stop working issue
disable_table_indexes: false # set to true to remove the index column from tables
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
menus: [
# Configuration for default nushell menus
# Note the lack of souce parameter