extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-05-01 08:34:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

Clippy fixes for new Rust version (#3392)

Browse Source
This commit is contained in:
JT 2021-05-07 07:58:21 +12:00 committed by GitHub
parent 0f8e31af06
commit 91a929b2a9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 109 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
crates/nu-cli/src/types/deduction.rs
View File

@ -377,10 +377,7 @@ impl VarSyntaxShapeDeductor {
.iter() .iter()
.map(|decl| { .map(|decl| {
let usage: VarUsage = decl.into(); let usage: VarUsage = decl.into();
let deduction = match deducer.inferences.get(&usage) { let deduction = deducer.inferences.get(&usage).cloned();
Some(vec) => Some(vec.clone()),
None => None,
};
(decl.clone(), deduction) (decl.clone(), deduction)
}) })
.collect()) .collect())
@ -1023,7 +1020,7 @@ impl VarSyntaxShapeDeductor {
Some(combination) Some(combination)
} }
}) })
.filter_map(|elem| elem) .flatten()
.collect() .collect()
} }
//No any's intersection of both is result //No any's intersection of both is result
@ -1044,7 +1041,7 @@ impl VarSyntaxShapeDeductor {
Some(combination) Some(combination)
} }
}) })
.filter_map(|elem| elem) .flatten()
.collect(); .collect();
if intersection.is_empty() { if intersection.is_empty() {
//TODO pass all labels somehow //TODO pass all labels somehow

2
crates/nu-command/src/commands/each/window.rs
View File

@ -87,7 +87,7 @@ impl WholeStreamCommand for EachWindow {
None None
} }
}) })
.filter_map(|x| x) .flatten()
.flatten() .flatten()
.to_action_stream()) .to_action_stream())
} }

10
crates/nu-command/src/commands/get.rs
View File

@ -228,8 +228,8 @@ pub fn get_column_from_row_error(
} => { } => {
let primary_label = format!("There isn't a column named '{}'", &column); let primary_label = format!("There isn't a column named '{}'", &column);
if let Some(suggestions) = did_you_mean(&obj_source, column_path_tried.as_string()) { did_you_mean(&obj_source, column_path_tried.as_string()).map(|suggestions| {
Some(ShellError::labeled_error_with_secondary( ShellError::labeled_error_with_secondary(
"Unknown column", "Unknown column",
primary_label, primary_label,
column_path_tried.span, column_path_tried.span,
@ -239,10 +239,8 @@ pub fn get_column_from_row_error(
&obj_source.data_descriptors().join(", ") &obj_source.data_descriptors().join(", ")
), ),
column_path_tried.span.since(path_members_span), column_path_tried.span.since(path_members_span),
)) )
} else { })
None
}
} }
PathMember { PathMember {
unspanned: UnspannedPathMember::Int(idx), unspanned: UnspannedPathMember::Int(idx),

8
crates/nu-command/src/commands/histogram.rs
View File

@ -76,10 +76,10 @@ pub fn histogram(args: CommandArgs) -> Result<ActionStream, ShellError> {
}; };
let column_grouper = if !columns.is_empty() { let column_grouper = if !columns.is_empty() {
match columns.remove(0).split_last() { columns
Some((key, _)) => Some(key.as_string().tagged(&name)), .remove(0)
None => None, .split_last()
} .map(|(key, _)| key.as_string().tagged(&name))
} else { } else {
None None
}; };

10
crates/nu-command/src/commands/move_/command.rs
View File

@ -272,10 +272,7 @@ fn move_after(table: &Value, columns: &[String], from: &ColumnPath) -> Result<Va
Ok(select_fields( Ok(select_fields(
table, table,
&reordered_columns &reordered_columns.into_iter().flatten().collect::<Vec<_>>(),
.into_iter()
.filter_map(|v| v)
.collect::<Vec<_>>(),
&table.tag, &table.tag,
)) ))
} }
@ -321,10 +318,7 @@ fn move_before(table: &Value, columns: &[String], from: &ColumnPath) -> Result<V
Ok(select_fields( Ok(select_fields(
table, table,
&reordered_columns &reordered_columns.into_iter().flatten().collect::<Vec<_>>(),
.into_iter()
.filter_map(|v| v)
.collect::<Vec<_>>(),
&table.tag, &table.tag,
)) ))
} }

2
crates/nu-command/src/commands/where_.rs
View File

@ -95,10 +95,10 @@ fn where_command(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
}; };
Ok(WhereIterator { Ok(WhereIterator {
block,
condition, condition,
context, context,
input, input,
block,
} }
.to_output_stream()) .to_output_stream())
} }

20
crates/nu-command/src/utils/test_bins.rs
View File

@ -68,18 +68,16 @@ pub fn chop() {
let stdin = io::stdin(); let stdin = io::stdin();
let mut stdout = io::stdout(); let mut stdout = io::stdout();
for line in stdin.lock().lines() { for given in stdin.lock().lines().flatten() {
if let Ok(given) = line { let chopped = if given.is_empty() {
let chopped = if given.is_empty() { &given
&given } else {
} else { let to = given.len() - 1;
let to = given.len() - 1; &given[..to]
&given[..to] };
};
if let Err(_e) = writeln!(stdout, "{}", chopped) { if let Err(_e) = writeln!(stdout, "{}", chopped) {
break; break;
}
} }
} }

2
crates/nu-data/src/config/nuconfig.rs
View File

@ -59,8 +59,8 @@ impl NuConfig {
}; };
Ok(NuConfig { Ok(NuConfig {
file_path,
vars, vars,
file_path,
modified_at, modified_at,
}) })
} }

12
crates/nu-data/src/utils/internal.rs
View File

@ -16,19 +16,11 @@ pub struct Labels {
impl Labels { impl Labels {
pub fn at(&self, idx: usize) -> Option<&str> { pub fn at(&self, idx: usize) -> Option<&str> {
if let Some(k) = self.x.get(idx) { self.x.get(idx).map(|k| &k[..])
Some(&k[..])
} else {
None
}
} }
pub fn at_split(&self, idx: usize) -> Option<&str> { pub fn at_split(&self, idx: usize) -> Option<&str> {
if let Some(k) = self.y.get(idx) { self.y.get(idx).map(|k| &k[..])
Some(&k[..])
} else {
None
}
} }
pub fn grouped(&self) -> impl Iterator<Item = &String> { pub fn grouped(&self) -> impl Iterator<Item = &String> {

5
crates/nu-engine/src/env/host.rs vendored
View File

@ -114,10 +114,7 @@ impl Host for FakeHost {
fn env_get(&mut self, key: OsString) -> Option<OsString> { fn env_get(&mut self, key: OsString) -> Option<OsString> {
let key = key.into_string().expect("Couldn't convert to string."); let key = key.into_string().expect("Couldn't convert to string.");
match self.env_vars.get(&key) { self.env_vars.get(&key).map(OsString::from)
Some(env) => Some(OsString::from(env)),
None => None,
}
} }
fn env_set(&mut self, key: OsString, value: OsString) { fn env_set(&mut self, key: OsString, value: OsString) {

8
crates/nu-engine/src/evaluation_context.rs
View File

@ -178,10 +178,8 @@ impl EvaluationContext {
Some(env_paths) Some(env_paths)
} else if let Some(env_paths) = self.scope.get_env("Path") { } else if let Some(env_paths) = self.scope.get_env("Path") {
Some(env_paths) Some(env_paths)
} else if let Some(env_paths) = self.scope.get_env("path") {
Some(env_paths)
} else { } else {
None self.scope.get_env("path")
}; };
if let Some(env_paths) = env_paths { if let Some(env_paths) = env_paths {
@ -249,10 +247,8 @@ impl EvaluationContext {
Some(env_paths) Some(env_paths)
} else if let Some(env_paths) = self.scope.get_env("Path") { } else if let Some(env_paths) = self.scope.get_env("Path") {
Some(env_paths) Some(env_paths)
} else if let Some(env_paths) = self.scope.get_env("path") {
Some(env_paths)
} else { } else {
None self.scope.get_env("path")
}; };
if let Some(env_paths) = env_paths { if let Some(env_paths) = env_paths {

138
crates/nu-engine/src/filesystem/filesystem_shell.rs
View File

@ -386,82 +386,80 @@ impl Shell for FilesystemShell {
)); ));
} }
for entry in sources { for entry in sources.into_iter().flatten() {
if let Ok(entry) = entry { let mut sources = FileStructure::new();
let mut sources = FileStructure::new(); sources.walk_decorate(&entry)?;
sources.walk_decorate(&entry)?;
if entry.is_file() { if entry.is_file() {
let sources = sources.paths_applying_with(|(source_file, _depth_level)| { let sources = sources.paths_applying_with(|(source_file, _depth_level)| {
if destination.is_dir() { if destination.is_dir() {
let mut dest = canonicalize(&path, &dst.item)?; let mut dest = canonicalize(&path, &dst.item)?;
if let Some(name) = entry.file_name() { if let Some(name) = entry.file_name() {
dest.push(name); dest.push(name);
}
Ok((source_file, dest))
} else {
Ok((source_file, destination.clone()))
} }
})?; Ok((source_file, dest))
} else {
Ok((source_file, destination.clone()))
}
})?;
for (src, dst) in sources { for (src, dst) in sources {
if src.is_file() { if src.is_file() {
std::fs::copy(src, dst).map_err(|e| { std::fs::copy(src, dst).map_err(|e| {
ShellError::labeled_error(e.to_string(), e.to_string(), &name_tag) ShellError::labeled_error(e.to_string(), e.to_string(), &name_tag)
})?; })?;
}
}
} else if entry.is_dir() {
let destination = if !destination.exists() {
destination.clone()
} else {
match entry.file_name() {
Some(name) => destination.join(name),
None => {
return Err(ShellError::labeled_error(
"Copy aborted. Not a valid path",
"not a valid path",
dst.tag,
))
} }
} }
} else if entry.is_dir() { };
let destination = if !destination.exists() {
destination.clone()
} else {
match entry.file_name() {
Some(name) => destination.join(name),
None => {
return Err(ShellError::labeled_error(
"Copy aborted. Not a valid path",
"not a valid path",
dst.tag,
))
}
}
};
std::fs::create_dir_all(&destination).map_err(|e| { std::fs::create_dir_all(&destination).map_err(|e| {
ShellError::labeled_error(e.to_string(), e.to_string(), &dst.tag) ShellError::labeled_error(e.to_string(), e.to_string(), &dst.tag)
})?; })?;
let sources = sources.paths_applying_with(|(source_file, depth_level)| { let sources = sources.paths_applying_with(|(source_file, depth_level)| {
let mut dest = destination.clone(); let mut dest = destination.clone();
let path = canonicalize(&path, &source_file)?; let path = canonicalize(&path, &source_file)?;
let comps: Vec<_> = path let comps: Vec<_> = path
.components() .components()
.map(|fragment| fragment.as_os_str()) .map(|fragment| fragment.as_os_str())
.rev() .rev()
.take(1 + depth_level) .take(1 + depth_level)
.collect(); .collect();
for fragment in comps.into_iter().rev() { for fragment in comps.into_iter().rev() {
dest.push(fragment); dest.push(fragment);
} }
Ok((PathBuf::from(&source_file), dest)) Ok((PathBuf::from(&source_file), dest))
})?; })?;
let dst_tag = &dst.tag; let dst_tag = &dst.tag;
for (src, dst) in sources { for (src, dst) in sources {
if src.is_dir() && !dst.exists() { if src.is_dir() && !dst.exists() {
std::fs::create_dir_all(&dst).map_err(|e| { std::fs::create_dir_all(&dst).map_err(|e| {
ShellError::labeled_error(e.to_string(), e.to_string(), dst_tag) ShellError::labeled_error(e.to_string(), e.to_string(), dst_tag)
})?; })?;
} }
if src.is_file() { if src.is_file() {
std::fs::copy(&src, &dst).map_err(|e| { std::fs::copy(&src, &dst).map_err(|e| {
ShellError::labeled_error(e.to_string(), e.to_string(), &name_tag) ShellError::labeled_error(e.to_string(), e.to_string(), &name_tag)
})?; })?;
}
} }
} }
} }
@ -574,13 +572,11 @@ impl Shell for FilesystemShell {
.collect(); .collect();
} }
for entry in sources { for entry in sources.into_iter().flatten() {
if let Ok(entry) = entry { move_file(
move_file( TaggedPathBuf(&entry, &src.tag),
TaggedPathBuf(&entry, &src.tag), TaggedPathBuf(&destination, &dst.tag),
TaggedPathBuf(&destination, &dst.tag), )?
)?
}
} }
Ok(ActionStream::empty()) Ok(ActionStream::empty())

2
crates/nu-engine/src/maybe_text_codec.rs
View File

@ -27,8 +27,8 @@ pub struct BufCodecReader<R: Read> {
impl<R: Read> BufCodecReader<R> { impl<R: Read> BufCodecReader<R> {
pub fn new(input: BufReader<R>, maybe_text_codec: MaybeTextCodec) -> Self { pub fn new(input: BufReader<R>, maybe_text_codec: MaybeTextCodec) -> Self {
BufCodecReader { BufCodecReader {
input,
maybe_text_codec, maybe_text_codec,
input,
} }
} }
} }

2
crates/nu-json/src/value.rs
View File

@ -937,7 +937,7 @@ impl<'de> de::Deserializer<'de> for Value {
} }
}; };
visitor.visit_enum(EnumDeserializer { value, variant }) visitor.visit_enum(EnumDeserializer { variant, value })
} }
#[inline] #[inline]

7
crates/nu-plugin/src/test_helpers.rs
View File

@ -62,10 +62,9 @@ impl<'a, T: Plugin> PluginTest<'a, T> {
self.configure(|flags_configured| { self.configure(|flags_configured| {
let flags_registered = &call_stub.args.named; let flags_registered = &call_stub.args.named;
let flag_passed = match flags_registered { let flag_passed = flags_registered
Some(names) => Some(names.keys().map(String::from).collect::<Vec<String>>()), .as_ref()
None => None, .map(|names| names.keys().map(String::from).collect::<Vec<String>>());
};
if let Some(flags) = flag_passed { if let Some(flags) = flag_passed {
for flag in flags { for flag in flags {

8
crates/nu-protocol/src/value/dict.rs
View File

@ -181,14 +181,10 @@ impl Dictionary {
/// Get a mutable entry that matches a key, if possible /// Get a mutable entry that matches a key, if possible
pub fn get_mut_data_by_key(&mut self, name: &str) -> Option<&mut Value> { pub fn get_mut_data_by_key(&mut self, name: &str) -> Option<&mut Value> {
match self self.entries
.entries
.iter_mut() .iter_mut()
.find(|(desc_name, _)| *desc_name == name) .find(|(desc_name, _)| *desc_name == name)
{ .map(|(_, v)| v)
Some((_, v)) => Some(v),
None => None,
}
} }
/// Insert a new key/value pair into the dictionary /// Insert a new key/value pair into the dictionary

10
crates/nu-source/src/meta.rs
View File

@ -794,10 +794,7 @@ where
impl<T> HasFallibleSpan for Option<Spanned<T>> { impl<T> HasFallibleSpan for Option<Spanned<T>> {
fn maybe_span(&self) -> Option<Span> { fn maybe_span(&self) -> Option<Span> {
match self { self.as_ref().map(|value| value.span)
None => None,
Some(value) => Some(value.span),
}
} }
} }
@ -815,10 +812,7 @@ where
impl<T> HasFallibleSpan for Option<Tagged<T>> { impl<T> HasFallibleSpan for Option<Tagged<T>> {
fn maybe_span(&self) -> Option<Span> { fn maybe_span(&self) -> Option<Span> {
match self { self.as_ref().map(|value| value.tag.span)
None => None,
Some(value) => Some(value.tag.span),
}
} }
} }

10
crates/nu_plugin_binaryview/src/binaryview.rs
View File

@ -213,15 +213,9 @@ pub fn view_contents(
skip: Option<&Value>, skip: Option<&Value>,
length: Option<&Value>, length: Option<&Value>,
) -> Result<(), Box<dyn std::error::Error>> { ) -> Result<(), Box<dyn std::error::Error>> {
let skip_bytes = match skip { let skip_bytes = skip.map(|s| s.as_usize().unwrap_or(0));
Some(s) => Some(s.as_usize().unwrap_or(0)),
None => None,
};
let num_bytes = match length { let num_bytes = length.map(|b| b.as_usize().unwrap_or(0));
Some(b) => Some(b.as_usize().unwrap_or(0)),
None => None,
};
let config = HexConfig { let config = HexConfig {
title: true, title: true,

2
crates/nu_plugin_start/src/nu/mod.rs
View File

@ -19,6 +19,6 @@ impl Plugin for Start {
} }
fn begin_filter(&mut self, call_info: CallInfo) -> Result<Vec<ReturnValue>, ShellError> { fn begin_filter(&mut self, call_info: CallInfo) -> Result<Vec<ReturnValue>, ShellError> {
self.parse(call_info)?; self.parse(call_info)?;
self.exec().map(|_| vec![]) self.exec().map(|_| Vec::new())
} }
} }