Mirrors/nushell
2
0
Fork 0
mirror of https://github.com/nushell/nushell synced 2024-12-26 04:53:09 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #1061 from thibran/fix-most-clippy-warnings

Browse source 
Fix most Clippy performance warnings
This commit is contained in:
Jonathan Turner 2019-12-06 19:26:20 -08:00 committed by GitHub
commit 9dfb6c023f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
57 changed files with 320 additions and 350 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
crates/nu-source/src/meta.rs
View file

@ -38,7 +38,7 @@ impl Spanned<String> {
pub fn items<'a, U>(
items: impl Iterator<Item = &'a Spanned<String>>,
) -> impl Iterator<Item = &'a str> {
items.into_iter().map(|item| &item.item[..])
items.map(|item| &item.item[..])
}
}
@ -156,7 +156,7 @@ impl<T> Tagged<T> {
Tagged {
item: self.item,
tag: tag,
tag,
}
}

2
crates/nu-source/src/pretty.rs
View file

@ -316,7 +316,7 @@ impl DebugDocBuilder {
result = result + item;
}
result.into()
result
}
fn styled(string: impl std::fmt::Display, style: ShellStyle) -> DebugDocBuilder {

10
src/cli.rs
View file

@ -38,7 +38,7 @@ fn load_plugin(path: &std::path::Path, context: &mut Context) -> Result<(), Shel
let request = JsonRpc::new("config", Vec::<Value>::new());
let request_raw = serde_json::to_string(&request)?;
stdin.write(format!("{}\n", request_raw).as_bytes())?;
stdin.write_all(format!("{}\n", request_raw).as_bytes())?;
let path = dunce::canonicalize(path)?;
let mut input = String::new();
@ -58,7 +58,7 @@ fn load_plugin(path: &std::path::Path, context: &mut Context) -> Result<(), Shel
let name = params.name.clone();
let fname = fname.to_string();
if let Some(_) = context.get_command(&name) {
if context.get_command(&name).is_some() {
trace!("plugin {:?} already loaded.", &name);
} else {
if params.is_filter {
@ -222,7 +222,7 @@ impl History {
p.push(FNAME);
p
})
.unwrap_or(PathBuf::from(FNAME))
.unwrap_or_else(|_| PathBuf::from(FNAME))
}
}
@ -609,8 +609,8 @@ fn classify_pipeline(
context: &Context,
source: &Text,
) -> Result<ClassifiedPipeline, ShellError> {
let mut pipeline_list = vec![pipeline.clone()];
let mut iterator = TokensIterator::all(&mut pipeline_list, source.clone(), pipeline.span());
let pipeline_list = vec![pipeline.clone()];
let mut iterator = TokensIterator::all(&pipeline_list, source.clone(), pipeline.span());
let result = expand_syntax(
&PipelineShape,

14
src/commands/classified/external.rs
View file

@ -68,7 +68,7 @@ pub(crate) async fn run_external_command(
trace!(target: "nu::run::external", "-> {}", command.name);
trace!(target: "nu::run::external", "inputs = {:?}", inputs);
let mut arg_string = format!("{}", command.name);
let mut arg_string = command.name.to_owned();
for arg in command.args.iter() {
arg_string.push_str(&arg);
}
@ -170,11 +170,11 @@ pub(crate) async fn run_external_command(
if let Ok(mut popen) = popen {
match stream_next {
StreamNext::Last => {
let _ = popen.detach();
popen.detach();
loop {
match popen.poll() {
None => {
let _ = std::thread::sleep(std::time::Duration::new(0, 100000000));
std::thread::sleep(std::time::Duration::new(0, 100_000_000));
}
_ => {
let _ = popen.terminate();
@ -185,12 +185,12 @@ pub(crate) async fn run_external_command(
Ok(ClassifiedInputStream::new())
}
StreamNext::External => {
let _ = popen.detach();
popen.detach();
let stdout = popen.stdout.take().unwrap();
Ok(ClassifiedInputStream::from_stdout(stdout))
}
StreamNext::Internal => {
let _ = popen.detach();
popen.detach();
let stdout = popen.stdout.take().unwrap();
let file = futures::io::AllowStdIo::new(stdout);
let stream = Framed::new(file, LinesCodec {});
@ -201,10 +201,10 @@ pub(crate) async fn run_external_command(
}
}
} else {
return Err(ShellError::labeled_error(
Err(ShellError::labeled_error(
"Command not found",
"command not found",
name_tag,
));
))
}
}

2
src/commands/command.rs
View file

@ -566,7 +566,7 @@ impl WholeStreamCommand for FnFilterCommand {
);
match func(args) {
Err(err) => return OutputStream::from(vec![Err(err)]).values,
Err(err) => OutputStream::from(vec![Err(err)]).values,
Ok(stream) => stream.values,
}
});

2
src/commands/enter.rs
View file

@ -47,7 +47,7 @@ impl PerItemCommand for Enter {
let tag_clone = tag.clone();
if location.starts_with("help") {
let spec = location_string.split(":").collect::<Vec<&str>>();
let spec = location_string.split(':').collect::<Vec<&str>>();
let (_, command) = (spec[0], spec[1]);

2
src/commands/evaluate_by.rs
View file

@ -94,7 +94,7 @@ pub fn evaluate(
..
} => {
let datasets: Vec<_> = datasets
.into_iter()
.iter()
.map(|subsets| match subsets {
Value {
value: UntaggedValue::Table(subsets),

10
src/commands/fetch.rs
View file

@ -129,7 +129,7 @@ pub async fn fetch(
location: &str,
span: Span,
) -> Result<(Option<String>, UntaggedValue, Tag), ShellError> {
if let Err(_) = url::Url::parse(location) {
if url::Url::parse(location).is_err() {
return Err(ShellError::labeled_error(
"Incomplete or incorrect url",
"expected a full url",
@ -275,19 +275,17 @@ pub async fn fetch(
}
None => Ok((
None,
UntaggedValue::string(format!("No content type found")),
UntaggedValue::string("No content type found".to_owned()),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)),
},
Err(_) => {
return Err(ShellError::labeled_error(
Err(_) => Err(ShellError::labeled_error(
"URL could not be opened",
"url not found",
span,
));
}
)),
}
}

4
src/commands/from_bson.rs
View file

@ -30,7 +30,7 @@ impl WholeStreamCommand for FromBSON {
}
}
fn bson_array(input: &Vec<Bson>, tag: Tag) -> Result<Vec<Value>, ShellError> {
fn bson_array(input: &[Bson], tag: Tag) -> Result<Vec<Value>, ShellError> {
let mut out = vec![];
for value in input {
@ -81,7 +81,7 @@ fn convert_bson_value_to_nu_value(v: &Bson, tag: impl Into<Tag>) -> Result<Value
ShellError::range_error(
ExpectedRange::BigDecimal,
&n.spanned(span),
format!("converting BSON Decimal128 to BigDecimal"),
"converting BSON Decimal128 to BigDecimal".to_owned(),
)
})?;
UntaggedValue::Primitive(Primitive::Decimal(decimal)).into_value(&tag)

2
src/commands/from_ini.rs
View file

@ -31,7 +31,7 @@ impl WholeStreamCommand for FromINI {
fn convert_ini_second_to_nu_value(v: &HashMap<String, String>, tag: impl Into<Tag>) -> Value {
let mut second = TaggedDictBuilder::new(tag);
for (key, value) in v.into_iter() {
for (key, value) in v.iter() {
second.insert_untagged(key.clone(), Primitive::String(value.clone()));
}

2
src/commands/from_sqlite.rs
View file

@ -97,7 +97,7 @@ fn convert_sqlite_row_to_nu_value(
convert_sqlite_value_to_nu_value(row.get_raw(i), tag.clone()),
);
}
return Ok(collected.into_value());
Ok(collected.into_value())
}
fn convert_sqlite_value_to_nu_value(value: ValueRef, tag: impl Into<Tag> + Clone) -> Value {

6
src/commands/from_xml.rs
View file

@ -45,11 +45,7 @@ fn from_node_to_value<'a, 'd>(n: &roxmltree::Node<'a, 'd>, tag: impl Into<Tag>)
value: UntaggedValue::Primitive(Primitive::String(f)),
..
} => {
if f.trim() == "" {
false
} else {
true
}
!f.trim().is_empty() // non-whitespace characters?
}
_ => true,
})

6
src/commands/get.rs
View file

@ -70,7 +70,7 @@ pub fn get_column_path(path: &ColumnPath, obj: &Value) -> Result<Value, ShellErr
),
column_path_tried.span,
if total == 1 {
format!("The table only has 1 row")
"The table only has 1 row".to_owned()
} else {
format!("The table only has {} rows (0 to {})", total, total - 1)
},
@ -91,7 +91,7 @@ pub fn get_column_path(path: &ColumnPath, obj: &Value) -> Result<Value, ShellErr
None => {}
}
return error;
error
}),
)
}
@ -100,7 +100,7 @@ pub fn get(
GetArgs { rest: mut fields }: GetArgs,
RunnableContext { input, .. }: RunnableContext,
) -> Result<OutputStream, ShellError> {
if fields.len() == 0 {
if fields.is_empty() {
let stream = async_stream! {
let values = input.values;
pin_mut!(values);

2
src/commands/group_by.rs
View file

@ -84,7 +84,7 @@ pub fn group(
possible_matches.sort();
if possible_matches.len() > 0 {
if !possible_matches.is_empty() {
return Err(ShellError::labeled_error(
"Unknown column",
format!("did you mean '{}'?", possible_matches[0].1),

14
src/commands/help.rs
View file

@ -82,16 +82,16 @@ impl PerItemCommand for Help {
}
if signature.rest_positional.is_some() {
one_liner.push_str(&format!(" ...args",));
one_liner.push_str(" ...args");
}
if signature.named.len() > 0 {
if !signature.named.is_empty() {
one_liner.push_str("{flags} ");
}
long_desc.push_str(&format!("\nUsage:\n > {}\n", one_liner));
if signature.positional.len() > 0 || signature.rest_positional.is_some() {
if !signature.positional.is_empty() || signature.rest_positional.is_some() {
long_desc.push_str("\nparameters:\n");
for positional in signature.positional {
match positional.0 {
@ -117,7 +117,7 @@ impl PerItemCommand for Help {
));
}
}
if signature.named.len() > 0 {
if !signature.named.is_empty() {
long_desc.push_str("\nflags:\n");
for (flag, ty) in signature.named {
match ty.0 {
@ -125,7 +125,7 @@ impl PerItemCommand for Help {
long_desc.push_str(&format!(
" --{}{} {}\n",
flag,
if ty.1.len() > 0 { ":" } else { "" },
if !ty.1.is_empty() { ":" } else { "" },
ty.1
));
}
@ -134,7 +134,7 @@ impl PerItemCommand for Help {
" --{} <{}> (required parameter){} {}\n",
flag,
m.display(),
if ty.1.len() > 0 { ":" } else { "" },
if !ty.1.is_empty() { ":" } else { "" },
ty.1
));
}
@ -143,7 +143,7 @@ impl PerItemCommand for Help {
" --{} <{}>{} {}\n",
flag,
o.display(),
if ty.1.len() > 0 { ":" } else { "" },
if !ty.1.is_empty() { ":" } else { "" },
ty.1
));
}

8
src/commands/histogram.rs
View file

@ -88,7 +88,7 @@ pub fn histogram(
let column = (*column_name).clone();
if let Value { value: UntaggedValue::Table(start), .. } = datasets.get(0).unwrap() {
for percentage in start.into_iter() {
for percentage in start.iter() {
let mut fact = TaggedDictBuilder::new(&name);
let value: Tagged<String> = group_labels.get(idx).unwrap().clone();
@ -99,7 +99,7 @@ pub fn histogram(
fact.insert_untagged(&frequency_column_name, UntaggedValue::string(string));
}
idx = idx + 1;
idx += 1;
yield ReturnSuccess::value(fact.into_value());
}
@ -121,14 +121,14 @@ fn percentages(values: &Value, max: Value, tag: impl Into<Tag>) -> Result<Value,
..
} => {
let datasets: Vec<_> = datasets
.into_iter()
.iter()
.map(|subsets| match subsets {
Value {
value: UntaggedValue::Table(data),
..
} => {
let data =
data.into_iter()
data.iter()
.map(|d| match d {
Value {
value: UntaggedValue::Primitive(Primitive::Int(n)),

4
src/commands/map_max_by.rs
View file

@ -84,13 +84,13 @@ pub fn map_max(
..
} => {
let datasets: Vec<_> = datasets
.into_iter()
.iter()
.map(|subsets| match subsets {
Value {
value: UntaggedValue::Table(data),
..
} => {
let data = data.into_iter().fold(0, |acc, value| match value {
let data = data.iter().fold(0, |acc, value| match value {
Value {
value: UntaggedValue::Primitive(Primitive::Int(n)),
..

12
src/commands/open.rs
View file

@ -44,7 +44,7 @@ fn run(
) -> Result<OutputStream, ShellError> {
let shell_manager = &raw_args.shell_manager;
let cwd = PathBuf::from(shell_manager.path());
let full_path = PathBuf::from(cwd);
let full_path = cwd;
let path = call_info.args.nth(0).ok_or_else(|| {
ShellError::labeled_error(
@ -243,20 +243,18 @@ pub async fn fetch(
}
}
},
Err(_) => {
return Err(ShellError::labeled_error(
Err(_) => Err(ShellError::labeled_error(
"File could not be opened",
"file not found",
span,
));
}
)),
}
} else {
return Err(ShellError::labeled_error(
Err(ShellError::labeled_error(
"File could not be opened",
"file not found",
span,
));
))
}
}

2
src/commands/pick.rs
View file

@ -39,7 +39,7 @@ fn pick(
PickArgs { rest: fields }: PickArgs,
RunnableContext { input, name, .. }: RunnableContext,
) -> Result<OutputStream, ShellError> {
if fields.len() == 0 {
if fields.is_empty() {
return Err(ShellError::labeled_error(
"Pick requires columns to pick",
"needs parameter",

2
src/commands/pivot.rs
View file

@ -92,7 +92,7 @@ pub fn pivot(args: PivotArgs, context: RunnableContext) -> Result<OutputStream,
}
}
} else {
for i in 0..input.len()+1 {
for i in 0..=input.len() {
if let Some(name) = args.rest.get(i) {
headers.push(name.to_string())
} else {

10
src/commands/post.rs
View file

@ -214,7 +214,7 @@ pub async fn post(
body: &Value,
user: Option<String>,
password: Option<String>,
headers: &Vec<HeaderKind>,
headers: &[HeaderKind],
tag: Tag,
registry: &CommandRegistry,
raw_args: &RawCommandArgs,
@ -435,20 +435,18 @@ pub async fn post(
}
None => Ok((
None,
UntaggedValue::string(format!("No content type found")),
UntaggedValue::string("No content type found".to_owned()),
Tag {
anchor: Some(AnchorLocation::Url(location.to_string())),
span: tag.span,
},
)),
},
Err(_) => {
return Err(ShellError::labeled_error(
Err(_) => Err(ShellError::labeled_error(
"URL could not be opened",
"url not found",
tag,
));
}
)),
}
} else {
Err(ShellError::labeled_error(

14
src/commands/range.rs
View file

@ -42,7 +42,7 @@ fn range(
RangeArgs { area: rows }: RangeArgs,
RunnableContext { input, name, .. }: RunnableContext,
) -> Result<OutputStream, ShellError> {
match rows.item.find(".") {
match rows.item.find('.') {
Some(value) => {
let (first, last) = rows.item.split_at(value);
let first = match first.parse::<u64>() {
@ -59,7 +59,7 @@ fn range(
}
}
};
let last = match last.trim_start_matches(".").parse::<u64>() {
let last = match last.trim_start_matches('.').parse::<u64>() {
Ok(postion) => postion,
Err(_) => {
if last == ".." {
@ -73,16 +73,14 @@ fn range(
}
}
};
return Ok(OutputStream::from_input(
Ok(OutputStream::from_input(
input.values.skip(first).take(last - first + 1),
));
))
}
None => {
return Err(ShellError::labeled_error(
None => Err(ShellError::labeled_error(
"No correct formatted range found",
"format: <from>..<to>",
name,
));
}
)),
}
}

4
src/commands/reduce_by.rs
View file

@ -118,7 +118,7 @@ pub fn reduce(
..
} => {
let datasets: Vec<_> = datasets
.into_iter()
.iter()
.map(|subsets| {
let mut acc = 0;
match subsets {
@ -127,7 +127,7 @@ pub fn reduce(
..
} => {
let data = data
.into_iter()
.iter()
.map(|d| {
if let Value {
value: UntaggedValue::Table(x),

2
src/commands/reject.rs
View file

@ -38,7 +38,7 @@ fn reject(
RejectArgs { rest: fields }: RejectArgs,
RunnableContext { input, name, .. }: RunnableContext,
) -> Result<OutputStream, ShellError> {
if fields.len() == 0 {
if fields.is_empty() {
return Err(ShellError::labeled_error(
"Reject requires fields",
"needs parameter",

4
src/commands/save.rs
View file

@ -226,10 +226,10 @@ fn save(
Ok(OutputStream::new(stream))
}
fn string_from(input: &Vec<Value>) -> String {
fn string_from(input: &[Value]) -> String {
let mut save_data = String::new();
if input.len() > 0 {
if !input.is_empty() {
let mut first = true;
for i in input.iter() {
if !first {

11
src/commands/split_column.rs
View file

@ -74,7 +74,7 @@ fn split_column(
let positional: Vec<_> = rest.iter().map(|f| f.item.clone()).collect();
// If they didn't provide column names, make up our own
if positional.len() == 0 {
if positional.is_empty() {
let mut gen_columns = vec![];
for i in 0..split_result.len() {
gen_columns.push(format!("Column{}", i + 1));
@ -85,15 +85,6 @@ fn split_column(
dict.insert_untagged(v.clone(), Primitive::String(k.into()));
}
ReturnSuccess::value(dict.into_value())
} else if split_result.len() == positional.len() {
let mut dict = TaggedDictBuilder::new(&v.tag);
for (&k, v) in split_result.iter().zip(positional.iter()) {
dict.insert_untagged(
v,
UntaggedValue::Primitive(Primitive::String(k.into())),
);
}
ReturnSuccess::value(dict.into_value())
} else {
let mut dict = TaggedDictBuilder::new(&v.tag);

8
src/commands/t_sort_by.rs
View file

@ -128,7 +128,7 @@ pub fn columns_sorted(
keys.into_iter().map(|k| k.tagged(&origin_tag)).collect()
}
_ => vec![format!("default").tagged(&origin_tag)],
_ => vec!["default".to_owned().tagged(&origin_tag)],
}
}
@ -197,12 +197,12 @@ pub fn t_sort(
outer.push_value(UntaggedValue::Table(i).into_value(&origin_tag));
}
return Ok(UntaggedValue::Table(outer.list).into_value(&origin_tag));
Ok(UntaggedValue::Table(outer.list).into_value(&origin_tag))
}
Some(_) => return Ok(UntaggedValue::nothing().into_value(&origin_tag)),
Some(_) => Ok(UntaggedValue::nothing().into_value(&origin_tag)),
}
}
None => return Ok(UntaggedValue::nothing().into_value(&origin_tag)),
None => Ok(UntaggedValue::nothing().into_value(&origin_tag)),
}
}
#[cfg(test)]

47
src/commands/to_bson.rs
View file

@ -94,10 +94,9 @@ fn object_value_to_bson(o: &Dictionary) -> Result<Bson, ShellError> {
Some((options, tagged_opts_value)) if options == "$options" => {
let r: Result<String, _> = tagged_regex_value.try_into();
let opts: Result<String, _> = tagged_opts_value.try_into();
if r.is_err() || opts.is_err() {
generic_object_value_to_bson(o)
} else {
Ok(Bson::RegExp(r.unwrap(), opts.unwrap()))
match (r, opts) {
(Ok(r), Ok(opts)) => Ok(Bson::RegExp(r, opts)),
_ => generic_object_value_to_bson(o),
}
}
_ => generic_object_value_to_bson(o),
@ -107,15 +106,17 @@ fn object_value_to_bson(o: &Dictionary) -> Result<Bson, ShellError> {
Some((scope, tagged_scope_value)) if scope == "$scope" => {
let js: Result<String, _> = tagged_javascript_value.try_into();
let s: Result<&Dictionary, _> = tagged_scope_value.try_into();
if js.is_err() || s.is_err() {
generic_object_value_to_bson(o)
} else {
if let Bson::Document(doc) = object_value_to_bson(s.unwrap())? {
Ok(Bson::JavaScriptCodeWithScope(js.unwrap(), doc))
match (js, s) {
(Ok(js), Ok(s)) => {
if let Bson::Document(doc) = object_value_to_bson(s)? {
Ok(Bson::JavaScriptCodeWithScope(js, doc))
} else {
generic_object_value_to_bson(o)
}
}
_ => generic_object_value_to_bson(o),
}
}
None => {
let js: Result<String, _> = tagged_javascript_value.try_into();
@ -130,10 +131,10 @@ fn object_value_to_bson(o: &Dictionary) -> Result<Bson, ShellError> {
}
Some((timestamp, tagged_timestamp_value)) if timestamp == "$timestamp" => {
let ts: Result<i64, _> = tagged_timestamp_value.try_into();
if ts.is_err() {
generic_object_value_to_bson(o)
if let Ok(ts) = ts {
Ok(Bson::TimeStamp(ts))
} else {
Ok(Bson::TimeStamp(ts.unwrap()))
generic_object_value_to_bson(o)
}
}
Some((binary_subtype, tagged_binary_subtype_value))
@ -154,30 +155,32 @@ fn object_value_to_bson(o: &Dictionary) -> Result<Bson, ShellError> {
}
Some((object_id, tagged_object_id_value)) if object_id == "$object_id" => {
let obj_id: Result<String, _> = tagged_object_id_value.try_into();
if obj_id.is_err() {
generic_object_value_to_bson(o)
if let Ok(obj_id) = obj_id {
let obj_id = ObjectId::with_string(&obj_id);
if let Ok(obj_id) = obj_id {
Ok(Bson::ObjectId(obj_id))
} else {
let obj_id = ObjectId::with_string(&obj_id.unwrap());
if obj_id.is_err() {
generic_object_value_to_bson(o)
} else {
Ok(Bson::ObjectId(obj_id.unwrap()))
}
} else {
generic_object_value_to_bson(o)
}
}
Some((symbol, tagged_symbol_value)) if symbol == "$symbol" => {
let sym: Result<String, _> = tagged_symbol_value.try_into();
if sym.is_err() {
generic_object_value_to_bson(o)
if let Ok(sym) = sym {
Ok(Bson::Symbol(sym))
} else {
Ok(Bson::Symbol(sym.unwrap()))
generic_object_value_to_bson(o)
}
}
_ => generic_object_value_to_bson(o),
}
}
fn get_binary_subtype<'a>(tagged_value: &'a Value) -> Result<BinarySubtype, ShellError> {
fn get_binary_subtype(tagged_value: &Value) -> Result<BinarySubtype, ShellError> {
match &tagged_value.value {
UntaggedValue::Primitive(Primitive::String(s)) => Ok(match s.as_ref() {
"generic" => BinarySubtype::Generic,

33
src/commands/to_delimited_data.rs
View file

@ -29,7 +29,7 @@ fn from_value_to_delimited_string(
wtr.write_record(fields).expect("can not write.");
wtr.write_record(values).expect("can not write.");
return Ok(String::from_utf8(wtr.into_inner().map_err(|_| {
let v = String::from_utf8(wtr.into_inner().map_err(|_| {
ShellError::labeled_error(
"Could not convert record",
"original value",
@ -42,7 +42,8 @@ fn from_value_to_delimited_string(
"original value",
&tagged_value.tag,
)
})?);
})?;
Ok(v)
}
UntaggedValue::Table(list) => {
let mut wtr = WriterBuilder::new()
@ -68,8 +69,7 @@ fn from_value_to_delimited_string(
}
wtr.write_record(&row).expect("can not write");
}
return Ok(String::from_utf8(wtr.into_inner().map_err(|_| {
let v = String::from_utf8(wtr.into_inner().map_err(|_| {
ShellError::labeled_error(
"Could not convert record",
"original value",
@ -82,9 +82,10 @@ fn from_value_to_delimited_string(
"original value",
&tagged_value.tag,
)
})?);
})?;
Ok(v)
}
_ => return to_string_tagged_value(tagged_value),
_ => to_string_tagged_value(tagged_value),
}
}
@ -98,7 +99,7 @@ pub fn clone_tagged_value(v: &Value) -> Value {
UntaggedValue::Primitive(Primitive::Nothing)
}
UntaggedValue::Primitive(Primitive::Boolean(b)) => {
UntaggedValue::Primitive(Primitive::Boolean(b.clone()))
UntaggedValue::Primitive(Primitive::Boolean(*b))
}
UntaggedValue::Primitive(Primitive::Decimal(f)) => {
UntaggedValue::Primitive(Primitive::Decimal(f.clone()))
@ -110,10 +111,10 @@ pub fn clone_tagged_value(v: &Value) -> Value {
UntaggedValue::Primitive(Primitive::Path(x.clone()))
}
UntaggedValue::Primitive(Primitive::Bytes(b)) => {
UntaggedValue::Primitive(Primitive::Bytes(b.clone()))
UntaggedValue::Primitive(Primitive::Bytes(*b))
}
UntaggedValue::Primitive(Primitive::Date(d)) => {
UntaggedValue::Primitive(Primitive::Date(d.clone()))
UntaggedValue::Primitive(Primitive::Date(*d))
}
UntaggedValue::Row(o) => UntaggedValue::Row(o.clone()),
UntaggedValue::Table(l) => UntaggedValue::Table(l.clone()),
@ -135,17 +136,15 @@ fn to_string_tagged_value(v: &Value) -> Result<String, ShellError> {
UntaggedValue::Primitive(Primitive::Decimal(_)) => Ok(v.as_string()?.to_string()),
UntaggedValue::Primitive(Primitive::Int(_)) => Ok(v.as_string()?.to_string()),
UntaggedValue::Primitive(Primitive::Path(_)) => Ok(v.as_string()?.to_string()),
UntaggedValue::Table(_) => return Ok(String::from("[Table]")),
UntaggedValue::Row(_) => return Ok(String::from("[Row]")),
UntaggedValue::Primitive(Primitive::Line(s)) => return Ok(s.to_string()),
UntaggedValue::Primitive(Primitive::String(s)) => return Ok(s.to_string()),
_ => {
return Err(ShellError::labeled_error(
UntaggedValue::Table(_) => Ok(String::from("[Table]")),
UntaggedValue::Row(_) => Ok(String::from("[Row]")),
UntaggedValue::Primitive(Primitive::Line(s)) => Ok(s.to_string()),
UntaggedValue::Primitive(Primitive::String(s)) => Ok(s.to_string()),
_ => Err(ShellError::labeled_error(
"Unexpected value",
"",
v.tag.clone(),
))
}
)),
}
}

2
src/commands/to_json.rs
View file

@ -94,7 +94,7 @@ pub fn value_to_json_value(v: &Value) -> Result<serde_json::Value, ShellError> {
})
}
fn json_list(input: &Vec<Value>) -> Result<Vec<serde_json::Value>, ShellError> {
fn json_list(input: &[Value]) -> Result<Vec<serde_json::Value>, ShellError> {
let mut out = vec![];
for value in input {

2
src/commands/to_sqlite.rs
View file

@ -70,7 +70,7 @@ fn comma_concat(acc: String, current: String) -> String {
}
}
fn get_columns(rows: &Vec<Value>) -> Result<String, std::io::Error> {
fn get_columns(rows: &[Value]) -> Result<String, std::io::Error> {
match &rows[0].value {
UntaggedValue::Row(d) => Ok(d
.entries

2
src/commands/to_toml.rs
View file

@ -82,7 +82,7 @@ pub fn value_to_toml_value(v: &Value) -> Result<toml::Value, ShellError> {
})
}
fn collect_values(input: &Vec<Value>) -> Result<Vec<toml::Value>, ShellError> {
fn collect_values(input: &[Value]) -> Result<Vec<toml::Value>, ShellError> {
let mut out = vec![];
for value in input {

2
src/commands/which_.rs
View file

@ -38,7 +38,7 @@ pub fn which(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStre
let tag = args.call_info.name_tag.clone();
if let Some(v) = &args.call_info.args.positional {
if v.len() > 0 {
if !v.is_empty() {
match &v[0] {
Value {
value: UntaggedValue::Primitive(Primitive::String(s)),

4
src/context.rs
View file

@ -45,7 +45,7 @@ impl CommandRegistry {
pub(crate) fn get_command(&self, name: &str) -> Option<Arc<Command>> {
let registry = self.registry.lock().unwrap();
registry.get(name).map(|c| c.clone())
registry.get(name).cloned()
}
pub(crate) fn expect_command(&self, name: &str) -> Arc<Command> {
@ -175,7 +175,7 @@ impl Context {
self.registry.expect_command(name)
}
pub(crate) fn run_command<'a>(
pub(crate) fn run_command(
&mut self,
command: Arc<Command>,
name_tag: Tag,

6
src/data/base.rs
View file

@ -40,7 +40,7 @@ interfaces!(Block: dyn ObjectHash);
#[typetag::serde]
impl EvaluateTrait for Block {
fn invoke(&self, scope: &Scope) -> Result<Value, ShellError> {
if self.expressions.len() == 0 {
if self.expressions.is_empty() {
return Ok(UntaggedValue::nothing().into_value(&self.tag));
}
@ -189,8 +189,8 @@ fn coerce_compare_primitive(
(Line(left), String(right)) => CompareValues::String(left.clone(), right.clone()),
(String(left), Line(right)) => CompareValues::String(left.clone(), right.clone()),
(Line(left), Line(right)) => CompareValues::String(left.clone(), right.clone()),
(Date(left), Date(right)) => CompareValues::Date(left.clone(), right.clone()),
(Date(left), Duration(right)) => CompareValues::DateDuration(left.clone(), right.clone()),
(Date(left), Date(right)) => CompareValues::Date(*left, *right),
(Date(left), Duration(right)) => CompareValues::DateDuration(*left, *right),
_ => return Err((left.type_name(), right.type_name())),
})
}

16
src/data/base/property_get.rs
View file

@ -144,7 +144,7 @@ pub(crate) fn get_data_by_member(value: &Value, name: &PathMember) -> Result<Val
}
}
if out.len() == 0 {
if out.is_empty() {
Err(ShellError::missing_property(
"table".spanned(value.tag.span),
string.spanned(name.span),
@ -203,7 +203,7 @@ pub fn get_data_by_column_path(
pub fn insert_data_at_path(value: &Value, path: &str, new_value: Value) -> Option<Value> {
let mut new_obj = value.clone();
let split_path: Vec<_> = path.split(".").collect();
let split_path: Vec<_> = path.split('.').collect();
if let UntaggedValue::Row(ref mut o) = new_obj.value {
let mut current = o;
@ -256,9 +256,10 @@ pub fn insert_data_at_member(
) -> Result<(), ShellError> {
match &mut value.value {
UntaggedValue::Row(dict) => match &member.unspanned {
UnspannedPathMember::String(key) => Ok({
UnspannedPathMember::String(key) => {
dict.insert_data_at_key(key, new_value);
}),
Ok(())
}
UnspannedPathMember::Int(_) => Err(ShellError::type_error(
"column name",
"integer".spanned(member.span),
@ -269,7 +270,7 @@ pub fn insert_data_at_member(
"list index",
"string".spanned(member.span),
)),
UnspannedPathMember::Int(int) => Ok({
UnspannedPathMember::Int(int) => {
let int = int.to_usize().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::Usize,
@ -279,7 +280,8 @@ pub fn insert_data_at_member(
})?;
insert_data_at_index(array, int.tagged(member.span), new_value.clone())?;
}),
Ok(())
}
},
other => match &member.unspanned {
UnspannedPathMember::String(_) => Err(ShellError::type_error(
@ -473,7 +475,7 @@ pub(crate) fn get_data_by_key(value: &Value, name: Spanned<&str>) -> Option<Valu
}
}
if out.len() > 0 {
if !out.is_empty() {
Some(UntaggedValue::Table(out).into_value(name.span))
} else {
None

35
src/data/base/shape.rs
View file

@ -196,7 +196,7 @@ impl<'a> PrettyDebug for DebugEntry<'a> {
fn pretty(&self) -> DebugDocBuilder {
(b::key(match self.key {
Column::String(string) => string.clone(),
Column::Value => format!("<value>"),
Column::Value => "<value>".to_owned(),
}) + b::delimit("(", self.value.pretty(), ")").as_kind())
}
}
@ -251,7 +251,7 @@ impl InlineShape {
Primitive::ColumnPath(path) => InlineShape::ColumnPath(path.clone()),
Primitive::Pattern(pattern) => InlineShape::Pattern(pattern.clone()),
Primitive::Boolean(boolean) => InlineShape::Boolean(*boolean),
Primitive::Date(date) => InlineShape::Date(date.clone()),
Primitive::Date(date) => InlineShape::Date(*date),
Primitive::Duration(duration) => InlineShape::Duration(*duration),
Primitive::Path(path) => InlineShape::Path(path.clone()),
Primitive::Binary(_) => InlineShape::Binary,
@ -329,23 +329,26 @@ impl PrettyDebug for FormatInlineShape {
(b::primitive(format!("{}", byte.get_value())) + b::space() + b::kind("B"))
.group()
}
_ => b::primitive(format!("{}", byte.format(1))),
_ => b::primitive(byte.format(1).to_string()),
}
}
InlineShape::String(string) => b::primitive(format!("{}", string)),
InlineShape::Line(string) => b::primitive(format!("{}", string)),
InlineShape::String(string) => b::primitive(string),
InlineShape::Line(string) => b::primitive(string),
InlineShape::ColumnPath(path) => {
b::intersperse(path.iter().map(|member| member.pretty()), b::keyword("."))
}
InlineShape::Pattern(pattern) => b::primitive(pattern),
InlineShape::Boolean(boolean) => b::primitive(match (boolean, column) {
(true, None) => format!("Yes"),
(false, None) => format!("No"),
(true, Some(Column::String(s))) if !s.is_empty() => format!("{}", s),
(false, Some(Column::String(s))) if !s.is_empty() => format!(""),
(true, Some(_)) => format!("Yes"),
(false, Some(_)) => format!("No"),
}),
InlineShape::Boolean(boolean) => b::primitive(
match (boolean, column) {
(true, None) => "Yes",
(false, None) => "No",
(true, Some(Column::String(s))) if !s.is_empty() => s,
(false, Some(Column::String(s))) if !s.is_empty() => "",
(true, Some(_)) => "Yes",
(false, Some(_)) => "No",
}
.to_owned(),
),
InlineShape::Date(date) => b::primitive(date.humanize()),
InlineShape::Duration(duration) => {
b::description(format_primitive(&Primitive::Duration(*duration), None))
@ -443,12 +446,12 @@ where
None => {
self.values.insert(key, {
let mut group = G::new();
group.merge(value.into());
group.merge(value);
group
});
}
Some(group) => {
group.merge(value.into());
group.merge(value);
}
}
}
@ -514,7 +517,7 @@ impl Shape {
d.iter()
.map(|c| match c {
Column::String(s) => s.clone(),
Column::Value => format!("<value>"),
Column::Value => "<value>".to_owned(),
})
.join(", ")
),

2
src/data/command.rs
View file

@ -53,7 +53,7 @@ fn signature_dict(signature: Signature, tag: impl Into<Tag>) -> Value {
sig.push_value(for_spec(arg.0.name(), "argument", is_required, &tag));
}
if let Some(_) = signature.rest_positional {
if signature.rest_positional.is_some() {
let is_required = false;
sig.push_value(for_spec("rest", "argument", is_required, &tag));
}

4
src/data/dict.rs
View file

@ -16,7 +16,7 @@ impl<'a> PrettyDebug for DebugEntry<'a> {
}
pub trait DictionaryExt {
fn get_data(&self, desc: &String) -> MaybeOwned<'_, Value>;
fn get_data(&self, desc: &str) -> MaybeOwned<'_, Value>;
fn keys(&self) -> indexmap::map::Keys<String, Value>;
fn get_data_by_key(&self, name: Spanned<&str>) -> Option<Value>;
@ -25,7 +25,7 @@ pub trait DictionaryExt {
}
impl DictionaryExt for Dictionary {
fn get_data(&self, desc: &String) -> MaybeOwned<'_, Value> {
fn get_data(&self, desc: &str) -> MaybeOwned<'_, Value> {
match self.entries.get(desc) {
Some(v) => MaybeOwned::Borrowed(v),
None => MaybeOwned::Owned(

33
src/data/primitive.rs
View file

@ -29,15 +29,15 @@ pub fn format_primitive(primitive: &Primitive, field_name: Option<&String>) -> S
match byte.get_unit() {
byte_unit::ByteUnit::B => format!("{} B ", byte.get_value()),
_ => format!("{}", byte.format(1)),
_ => byte.format(1).to_string(),
}
}
Primitive::Duration(sec) => format_duration(*sec),
Primitive::Int(i) => format!("{}", i),
Primitive::Decimal(decimal) => format!("{}", decimal),
Primitive::Pattern(s) => format!("{}", s),
Primitive::String(s) => format!("{}", s),
Primitive::Line(s) => format!("{}", s),
Primitive::Int(i) => i.to_string(),
Primitive::Decimal(decimal) => decimal.to_string(),
Primitive::Pattern(s) => s.to_string(),
Primitive::String(s) => s.to_owned(),
Primitive::Line(s) => s.to_owned(),
Primitive::ColumnPath(p) => {
let mut members = p.iter();
let mut f = String::new();
@ -57,15 +57,16 @@ pub fn format_primitive(primitive: &Primitive, field_name: Option<&String>) -> S
f
}
Primitive::Boolean(b) => match (b, field_name) {
(true, None) => format!("Yes"),
(false, None) => format!("No"),
(true, Some(s)) if !s.is_empty() => format!("{}", s),
(false, Some(s)) if !s.is_empty() => format!(""),
(true, Some(_)) => format!("Yes"),
(false, Some(_)) => format!("No"),
},
Primitive::Binary(_) => format!("<binary>"),
Primitive::Date(d) => format!("{}", d.humanize()),
(true, None) => "Yes",
(false, None) => "No",
(true, Some(s)) if !s.is_empty() => s,
(false, Some(s)) if !s.is_empty() => "",
(true, Some(_)) => "Yes",
(false, Some(_)) => "No",
}
.to_owned(),
Primitive::Binary(_) => "<binary>".to_owned(),
Primitive::Date(d) => d.humanize().to_string(),
}
}
@ -83,7 +84,7 @@ fn format_duration(sec: u64) -> String {
let (days, hours) = (hours / 24, hours % 24);
match (days, hours, minutes, seconds) {
(0, 0, 0, 1) => format!("1 sec"),
(0, 0, 0, 1) => "1 sec".to_owned(),
(0, 0, 0, s) => format!("{} secs", s),
(0, 0, m, s) => format!("{}:{:02}", m, s),
(0, h, m, s) => format!("{}:{:02}:{:02}", h, m, s),

2
src/data/value.rs
View file

@ -22,7 +22,7 @@ pub fn date_from_str(s: Tagged<&str>) -> Result<UntaggedValue, ShellError> {
}
pub fn compare_values(
operator: &Operator,
operator: Operator,
left: &UntaggedValue,
right: &UntaggedValue,
) -> Result<bool, (&'static str, &'static str)> {

18
src/deserializer.rs
View file

@ -43,11 +43,11 @@ impl<'de> ConfigDeserializer<'de> {
Some(UntaggedValue::Table(positional).into_untagged_value()) // TODO: correct tag
} else {
if self.call.args.has(name) {
self.call.args.get(name).map(|x| x.clone())
self.call.args.get(name).cloned()
} else {
let position = self.position;
self.position += 1;
self.call.args.nth(position).map(|x| x.clone())
self.call.args.nth(position).cloned()
}
};
@ -316,7 +316,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut ConfigDeserializer<'de> {
let json_cursor = std::io::Cursor::new(json.into_bytes());
let mut json_de = serde_json::Deserializer::from_reader(json_cursor);
let r = json_de.deserialize_struct(name, fields, visitor)?;
return Ok(r);
Ok(r)
}
trace!(
@ -409,12 +409,10 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut ConfigDeserializer<'de> {
..
} => visit::<Tagged<String>, _>(string.tagged(tag), name, fields, visitor),
other => {
return Err(ShellError::type_error(
other => Err(ShellError::type_error(
name,
other.type_name().spanned(other.span()),
))
}
)),
}
}
fn deserialize_enum<V>(
@ -471,7 +469,7 @@ impl<'a, 'de: 'a, I: Iterator<Item = Value>> de::SeqAccess<'de> for SeqDeseriali
}
fn size_hint(&self) -> Option<usize> {
return self.vals.size_hint().1;
self.vals.size_hint().1
}
}
@ -493,7 +491,7 @@ impl<'a, 'de: 'a> de::SeqAccess<'de> for StructDeserializer<'a, 'de> {
where
T: de::DeserializeSeed<'de>,
{
if self.fields.len() == 0 {
if self.fields.is_empty() {
return Ok(None);
}
@ -505,7 +503,7 @@ impl<'a, 'de: 'a> de::SeqAccess<'de> for StructDeserializer<'a, 'de> {
}
fn size_hint(&self) -> Option<usize> {
return Some(self.fields.len());
Some(self.fields.len())
}
}

6
src/evaluate/evaluator.rs
View file

@ -40,7 +40,7 @@ pub(crate) fn evaluate_baseline_expr(
trace!("left={:?} right={:?}", left.value, right.value);
match apply_operator(binary.op(), &left, &right) {
match apply_operator(**binary.op(), &left, &right) {
Ok(result) => Ok(result.into_value(tag)),
Err((left_type, right_type)) => Err(ShellError::coerce_error(
left_type.spanned(binary.left().span),
@ -83,7 +83,7 @@ pub(crate) fn evaluate_baseline_expr(
possible_matches.sort();
if possible_matches.len() > 0 {
if !possible_matches.is_empty() {
return Err(ShellError::labeled_error(
"Unknown column",
format!("did you mean '{}'?", possible_matches[0].1),
@ -174,7 +174,7 @@ fn evaluate_reference(
x => Ok(scope
.vars
.get(x)
.map(|v| v.clone())
.cloned()
.unwrap_or_else(|| UntaggedValue::nothing().into_value(tag))),
},
}

4
src/evaluate/operator.rs
View file

@ -4,11 +4,11 @@ use nu_protocol::{Primitive, ShellTypeName, UntaggedValue, Value};
use std::ops::Not;
pub fn apply_operator(
op: &Operator,
op: Operator,
left: &Value,
right: &Value,
) -> Result<UntaggedValue, (&'static str, &'static str)> {
match *op {
match op {
Operator::Equal
| Operator::NotEqual
| Operator::LessThan

2
src/format/entries.rs
View file

@ -35,7 +35,7 @@ impl EntriesView {
impl RenderView for EntriesView {
fn render_view(&self, _host: &mut dyn Host) -> Result<(), ShellError> {
if self.entries.len() == 0 {
if self.entries.is_empty() {
return Ok(());
}

5
src/format/generic.rs
View file

@ -16,7 +16,10 @@ impl RenderView for GenericView<'_> {
fn render_view(&self, host: &mut dyn Host) -> Result<(), ShellError> {
let tag = &self.value.tag;
match &self.value.value {
UntaggedValue::Primitive(p) => Ok(host.stdout(&format_primitive(p, None))),
UntaggedValue::Primitive(p) => {
host.stdout(&format_primitive(p, None));
Ok(())
}
UntaggedValue::Table(l) => {
let view = TableView::from_list(l, 0);

81
src/format/table.rs
View file

@ -30,7 +30,7 @@ impl TableView {
for value in values {
let descs = value.data_descriptors();
if descs.len() == 0 {
if descs.is_empty() {
if !ret.contains(&value_column) {
ret.push("<value>".to_string());
}
@ -46,13 +46,13 @@ impl TableView {
}
pub fn from_list(values: &[Value], starting_idx: usize) -> Option<TableView> {
if values.len() == 0 {
if values.is_empty() {
return None;
}
let mut headers = TableView::merge_descriptors(values);
if headers.len() == 0 {
if headers.is_empty() {
headers.push("<value>".to_string());
}
@ -68,10 +68,10 @@ impl TableView {
value: UntaggedValue::Row(..),
..
} => (
format_leaf(&UntaggedValue::nothing()).plain_string(100000),
format_leaf(&UntaggedValue::nothing()).plain_string(100_000),
style_leaf(&UntaggedValue::nothing()),
),
_ => (format_leaf(value).plain_string(100000), style_leaf(value)),
_ => (format_leaf(value).plain_string(100_000), style_leaf(value)),
}
} else {
match value {
@ -81,12 +81,12 @@ impl TableView {
} => {
let data = value.get_data(d);
(
format_leaf(data.borrow()).plain_string(100000),
format_leaf(data.borrow()).plain_string(100_000),
style_leaf(data.borrow()),
)
}
_ => (
format_leaf(&UntaggedValue::nothing()).plain_string(100000),
format_leaf(&UntaggedValue::nothing()).plain_string(100_000),
style_leaf(&UntaggedValue::nothing()),
),
}
@ -96,7 +96,7 @@ impl TableView {
if values.len() > 1 {
// Indices are black, bold, right-aligned:
row.insert(0, (format!("{}", (starting_idx + idx).to_string()), "Fdbr"));
row.insert(0, ((starting_idx + idx).to_string(), "Fdbr"));
}
entries.push(row);
@ -105,22 +105,21 @@ impl TableView {
let mut max_per_column = vec![];
if values.len() > 1 {
headers.insert(0, format!("#"));
headers.insert(0, "#".to_owned());
}
for head in 0..headers.len() {
for i in 0..headers.len() {
let mut current_col_max = 0;
for row in 0..values.len() {
let value_length = entries[row][head].0.chars().count();
let iter = entries.iter().take(values.len());
for entry in iter {
let value_length = entry[i].0.chars().count();
if value_length > current_col_max {
current_col_max = value_length;
}
}
max_per_column.push(std::cmp::max(
current_col_max,
headers[head].chars().count(),
));
max_per_column.push(std::cmp::max(current_col_max, headers[i].chars().count()));
}
// Different platforms want different amounts of buffer, not sure why
@ -132,13 +131,14 @@ impl TableView {
// If we have too many columns, truncate the table
if max_num_of_columns < headers.len() {
headers.truncate(max_num_of_columns);
for row in 0..entries.len() {
entries[row].truncate(max_num_of_columns);
for entry in &mut entries {
entry.truncate(max_num_of_columns);
}
headers.push("...".to_string());
for row in 0..entries.len() {
entries[row].push(("...".to_string(), "c")); // ellipsis is centred
headers.push("...".to_owned());
for entry in &mut entries {
entry.push(("...".to_owned(), "c")); // ellipsis is centred
}
}
@ -149,22 +149,23 @@ impl TableView {
let mut num_overages = 0;
let mut underage_sum = 0;
let mut overage_separator_sum = 0;
for idx in 0..headers.len() {
if max_per_column[idx] > max_naive_column_width {
let iter = max_per_column.iter().enumerate().take(headers.len());
for (i, &column_max) in iter {
if column_max > max_naive_column_width {
num_overages += 1;
if idx != (headers.len() - 1) {
if i != (headers.len() - 1) {
overage_separator_sum += 3;
}
if idx == 0 {
if i == 0 {
overage_separator_sum += 1;
}
} else {
underage_sum += max_per_column[idx];
underage_sum += column_max;
// if column isn't last, add 3 for its separator
if idx != (headers.len() - 1) {
if i != (headers.len() - 1) {
underage_sum += 3;
}
if idx == 0 {
if i == 0 {
underage_sum += 1;
}
}
@ -180,24 +181,25 @@ impl TableView {
// This width isn't quite right, as we're rounding off some of our space
num_overages = 0;
overage_separator_sum = 0;
for idx in 0..headers.len() {
if max_per_column[idx] > max_naive_column_width {
if max_per_column[idx] <= max_column_width {
underage_sum += max_per_column[idx];
let iter = max_per_column.iter().enumerate().take(headers.len());
for (i, &column_max) in iter {
if column_max > max_naive_column_width {
if column_max <= max_column_width {
underage_sum += column_max;
// if column isn't last, add 3 for its separator
if idx != (headers.len() - 1) {
if i != (headers.len() - 1) {
underage_sum += 3;
}
if idx == 0 {
if i == 0 {
underage_sum += 1;
}
} else {
// Column is still too large, so let's count it
num_overages += 1;
if idx != (headers.len() - 1) {
if i != (headers.len() - 1) {
overage_separator_sum += 3;
}
if idx == 0 {
if i == 0 {
overage_separator_sum += 1;
}
}
@ -214,8 +216,9 @@ impl TableView {
for head in 0..headers.len() {
if max_per_column[head] > max_naive_column_width {
headers[head] = fill(&headers[head], max_column_width);
for row in 0..entries.len() {
entries[row][head].0 = fill(&entries[row][head].0, max_column_width);
for entry in &mut entries {
entry[head].0 = fill(&entry[head].0, max_column_width);
}
}
}
@ -226,7 +229,7 @@ impl TableView {
impl RenderView for TableView {
fn render_view(&self, host: &mut dyn Host) -> Result<(), ShellError> {
if self.entries.len() == 0 {
if self.entries.is_empty() {
return Ok(());
}

2
src/plugins/format.rs
View file

@ -21,7 +21,7 @@ fn format(input: &str) -> IResult<&str, Vec<FormatCommand>> {
let mut loop_input = input;
loop {
let (input, before) = take_while(|c| c != '{')(loop_input)?;
if before.len() > 0 {
if !before.is_empty() {
output.push(FormatCommand::Text(before.to_string()));
}
if input != "" {

34
src/plugins/inc.rs
View file

@ -90,13 +90,13 @@ impl Inc {
}
UntaggedValue::Table(values) => {
if values.len() == 1 {
return Ok(UntaggedValue::Table(vec![self.inc(values[0].clone())?])
.into_value(value.tag()));
Ok(UntaggedValue::Table(vec![self.inc(values[0].clone())?])
.into_value(value.tag()))
} else {
return Err(ShellError::type_error(
Err(ShellError::type_error(
"incrementable value",
value.type_name().spanned(value.span()),
));
))
}
}
@ -108,20 +108,16 @@ impl Inc {
&f,
Box::new(move |(obj_source, column_path_tried, _)| {
match did_you_mean(&obj_source, &column_path_tried) {
Some(suggestions) => {
return ShellError::labeled_error(
Some(suggestions) => ShellError::labeled_error(
"Unknown column",
format!("did you mean '{}'?", suggestions[0].1),
span_for_spanned_list(fields.iter().map(|p| p.span)),
)
}
None => {
return ShellError::labeled_error(
),
None => ShellError::labeled_error(
"Unknown column",
"row does not contain this column",
span_for_spanned_list(fields.iter().map(|p| p.span)),
)
}
),
}
}),
);
@ -133,14 +129,12 @@ impl Inc {
&f,
replacement.value.clone().into_untagged_value(),
) {
Some(v) => return Ok(v),
None => {
return Err(ShellError::labeled_error(
Some(v) => Ok(v),
None => Err(ShellError::labeled_error(
"inc could not find field to replace",
"column name",
value.tag(),
))
}
)),
}
}
None => Err(ShellError::untagged_runtime_error(
@ -201,13 +195,11 @@ impl Plugin for Inc {
}
match &self.error {
Some(reason) => {
return Err(ShellError::untagged_runtime_error(format!(
Some(reason) => Err(ShellError::untagged_runtime_error(format!(
"{}: {}",
reason,
Inc::usage()
)))
}
))),
None => Ok(vec![]),
}
}

4
src/plugins/parse.rs
View file

@ -22,7 +22,7 @@ fn parse(input: &str) -> IResult<&str, Vec<ParseCommand>> {
let mut loop_input = input;
loop {
let (input, before) = take_while(|c| c != '{')(loop_input)?;
if before.len() > 0 {
if !before.is_empty() {
output.push(ParseCommand::Text(before.to_string()));
}
if input != "" {
@ -73,7 +73,7 @@ fn build_regex(commands: &[ParseCommand]) -> String {
}
}
return output;
output
}
struct Parse {
regex: Regex,

18
src/plugins/str.rs
View file

@ -126,7 +126,7 @@ impl Str {
_ => v[0].trim().parse().unwrap(),
};
let end: usize = match v[1] {
"" => usize::max_value().clone(),
"" => usize::max_value(),
_ => v[1].trim().parse().unwrap(),
};
if start > end {
@ -169,14 +169,12 @@ impl Str {
&f,
Box::new(move |(obj_source, column_path_tried, error)| {
match did_you_mean(&obj_source, &column_path_tried) {
Some(suggestions) => {
return ShellError::labeled_error(
Some(suggestions) => ShellError::labeled_error(
"Unknown column",
format!("did you mean '{}'?", suggestions[0].1),
span_for_spanned_list(fields.iter().map(|p| p.span)),
)
}
None => return error,
),
None => error,
}
}),
);
@ -188,7 +186,7 @@ impl Str {
&f,
replacement.value.clone().into_untagged_value(),
) {
Some(v) => return Ok(v),
Some(v) => Ok(v),
None => Err(ShellError::labeled_error(
"str could not find field to replace",
"column name",
@ -293,13 +291,11 @@ impl Plugin for Str {
}
match &self.error {
Some(reason) => {
return Err(ShellError::untagged_runtime_error(format!(
Some(reason) => Err(ShellError::untagged_runtime_error(format!(
"{}: {}",
reason,
Str::usage()
)))
}
))),
None => Ok(vec![]),
}
}

6
src/shell/completer.rs
View file

@ -28,11 +28,11 @@ impl NuCompleter {
completion.replacement = completion.replacement.replace("\\(", "(");
}
if completion.replacement.contains(" ") || completion.replacement.contains("(") {
if !completion.replacement.starts_with("\"") {
if completion.replacement.contains(' ') || completion.replacement.contains('(') {
if !completion.replacement.starts_with('\"') {
completion.replacement = format!("\"{}", completion.replacement);
}
if !completion.replacement.ends_with("\"") {
if !completion.replacement.ends_with('\"') {
completion.replacement = format!("{}\"", completion.replacement);
}
}

20
src/shell/filesystem_shell.rs
View file

@ -104,7 +104,7 @@ impl Shell for FilesystemShell {
//If it's not a glob, try to display the contents of the entry if it's a directory
let lossy_path = full_path.to_string_lossy();
if !lossy_path.contains("*") && !lossy_path.contains("?") {
if !lossy_path.contains('*') && !lossy_path.contains('?') {
let entry = Path::new(&full_path);
if entry.is_dir() {
let entries = std::fs::read_dir(&entry);
@ -344,7 +344,7 @@ impl Shell for FilesystemShell {
new_dst.push(fragment);
}
Ok((PathBuf::from(&source_file), PathBuf::from(new_dst)))
Ok((PathBuf::from(&source_file), new_dst))
};
let sources = sources.paths_applying_with(strategy)?;
@ -418,7 +418,7 @@ impl Shell for FilesystemShell {
new_dst.push(fragment);
}
Ok((PathBuf::from(&source_file), PathBuf::from(new_dst)))
Ok((PathBuf::from(&source_file), new_dst))
};
let sources = sources.paths_applying_with(strategy)?;
@ -530,7 +530,7 @@ impl Shell for FilesystemShell {
) -> Result<OutputStream, ShellError> {
let full_path = PathBuf::from(path);
if directories.len() == 0 {
if directories.is_empty() {
return Err(ShellError::labeled_error(
"mkdir requires directory paths",
"needs parameter",
@ -861,13 +861,11 @@ impl Shell for FilesystemShell {
}
} else {
if destination.exists() {
if !sources.iter().all(|x| {
if let Ok(entry) = x.as_ref() {
entry.is_file()
} else {
false
}
}) {
let is_file = |x: &Result<PathBuf, _>| {
x.as_ref().map(|entry| entry.is_file()).unwrap_or_default()
};
if !sources.iter().all(is_file) {
return Err(ShellError::labeled_error(
"Rename aborted (directories found). Renaming in patterns not supported yet (try moving the directory directly)",
"Rename aborted (directories found). Renaming in patterns not supported yet (try moving the directory directly)",

9
src/shell/help_shell.rs
View file

@ -108,13 +108,11 @@ impl HelpShell {
impl Shell for HelpShell {
fn name(&self) -> String {
let anchor_name = self.value.anchor_name();
format!(
"{}",
match anchor_name {
Some(x) => format!("{{{}}}", x),
None => format!("<{}>", self.value.type_name()),
}
)
}
fn homedir(&self) -> Option<PathBuf> {
@ -140,10 +138,7 @@ impl Shell for HelpShell {
_context: &RunnableContext,
_full: bool,
) -> Result<OutputStream, ShellError> {
Ok(self
.commands()
.map(|x| ReturnSuccess::value(x))
.to_output_stream())
Ok(self.commands().map(ReturnSuccess::value).to_output_stream())
}
fn cd(&self, args: EvaluatedWholeStreamCommandArgs) -> Result<OutputStream, ShellError> {

6
src/shell/value_shell.rs
View file

@ -76,13 +76,11 @@ impl ValueShell {
impl Shell for ValueShell {
fn name(&self) -> String {
let anchor_name = self.value.anchor_name();
format!(
"{}",
match anchor_name {
Some(x) => format!("{{{}}}", x),
None => format!("<{}>", self.value.type_name()),
}
)
}
fn homedir(&self) -> Option<PathBuf> {
@ -124,7 +122,7 @@ impl Shell for ValueShell {
Ok(self
.members_under(full_path.as_path())
.map(|x| ReturnSuccess::value(x))
.map(ReturnSuccess::value)
.to_output_stream())
}

2
src/stream.rs
View file

@ -142,7 +142,7 @@ impl From<VecDeque<Value>> for OutputStream {
OutputStream {
values: input
.into_iter()
.map(|i| ReturnSuccess::value(i))
.map(ReturnSuccess::value)
.collect::<VecDeque<ReturnValue>>()
.boxed(),
}

8
src/utils.rs
View file

@ -22,7 +22,7 @@ pub fn did_you_mean(obj_source: &Value, field_tried: &PathMember) -> Option<Vec<
})
.collect();
if possible_matches.len() > 0 {
if !possible_matches.is_empty() {
possible_matches.sort();
Some(possible_matches)
} else {
@ -96,7 +96,7 @@ impl Div<&str> for &AbsolutePath {
type Output = AbsolutePath;
fn div(self, rhs: &str) -> Self::Output {
let parts = rhs.split("/");
let parts = rhs.split('/');
let mut result = self.inner.clone();
for part in parts {
@ -133,7 +133,7 @@ impl<T: AsRef<str>> Div<T> for &RelativePath {
type Output = RelativePath;
fn div(self, rhs: T) -> Self::Output {
let parts = rhs.as_ref().split("/");
let parts = rhs.as_ref().split('/');
let mut result = self.inner.clone();
for part in parts {
@ -276,7 +276,7 @@ impl FileStructure {
}
pub fn contains_files(&self) -> bool {
self.resources.len() > 0
!self.resources.is_empty()
}
pub fn paths_applying_with<F>(