holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add general refactorings (#3996)

Browse Source
This commit is contained in:
Marcin Puc
2021-09-10 00:44:22 +02:00
committed by GitHub
parent ae9f4135c0
commit 51c74eebd0
165 changed files with 540 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -245,7 +245,7 @@ fn perform_groupby_aggregation(
None => &col[..],
};
res.rename(col.as_str(), new_col)
res.rename(&col, new_col)
.expect("Column is always there. Looping with known names");
}
}

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

@ -107,7 +107,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
let other: Value = args.req_named("other")?;
let axis: Tagged<String> = args.req_named("axis")?;
let axis = Axis::try_from_str(axis.item.as_str(), &axis.tag.span)?;
let axis = Axis::try_from_str(&axis.item, &axis.tag.span)?;
let df_other = match other.value {
UntaggedValue::DataFrame(df) => Ok(df),

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

@ -53,7 +53,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
let res = df
.as_ref()
.column(column.item.as_ref())
.column(&column.item)
.map_err(|e| parse_polars_error::<&str>(&e, &column.tag.span, None))?;
let df = NuDataFrame::try_from_series(vec![res.clone()], &tag.span)?;

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

@ -195,7 +195,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
let name = format!("{} ({})", col.name(), col.dtype());
ChunkedArray::<Float64Type>::new_from_opt_slice(
name.as_str(),
&name,
&[
Some(count),
sum,

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

@ -72,7 +72,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
.expect("using name from list of names from dataframe")
.dtype();
let dtype_str = format!("{}", dtype);
let dtype_str = dtype.to_string();
dtypes.push(Value {
value: dtype_str.into(),
tag: Tag::default(),

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

@ -177,7 +177,7 @@ fn check_column_datatypes<T: AsRef<str>>(
));
}
for (l, r) in l_cols.iter().zip(r_cols.iter()) {
for (l, r) in l_cols.iter().zip(r_cols) {
let l_series = df_l
.column(l.as_ref())
.map_err(|e| parse_polars_error::<&str>(&e, l_col_span, None))?;

4
crates/nu-command/src/commands/dataframe/melt.rs
View File

@ -135,12 +135,12 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
.map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
if let Some(name) = &variable_name {
res.rename("variable", name.item.as_str())
res.rename("variable", &name.item)
.map_err(|e| parse_polars_error::<&str>(&e, &name.tag.span, None))?;
}
if let Some(name) = &value_name {
res.rename("value", name.item.as_str())
res.rename("value", &name.item)
.map_err(|e| parse_polars_error::<&str>(&e, &name.tag.span, None))?;
}

6
crates/nu-command/src/commands/dataframe/pivot.rs
View File

@ -100,7 +100,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
let mut groupby = nu_groupby.to_groupby()?;
let pivot = groupby.pivot(pivot_col.item.as_ref(), value_col.item.as_ref());
let pivot = groupby.pivot(&pivot_col.item, &value_col.item);
let res = match op {
Operation::Mean => pivot.mean(),
@ -120,7 +120,7 @@ fn check_pivot_column(
col: &Tagged<String>,
) -> Result<(), ShellError> {
let series = df
.column(col.item.as_ref())
.column(&col.item)
.map_err(|e| parse_polars_error::<&str>(&e, &col.tag.span, None))?;
match series.dtype() {
@ -146,7 +146,7 @@ fn check_value_column(
col: &Tagged<String>,
) -> Result<(), ShellError> {
let series = df
.column(col.item.as_ref())
.column(&col.item)
.map_err(|e| parse_polars_error::<&str>(&e, &col.tag.span, None))?;
match series.dtype() {

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

@ -61,7 +61,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
let (mut df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
df.as_mut()
.rename(from.item.as_str(), to.item.as_str())
.rename(&from.item, &to.item)
.map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
Ok(OutputStream::one(df.into_value(tag)))

2
crates/nu-command/src/commands/dataframe/series/contains.rs
View File

@ -68,7 +68,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
})?;
let res = chunked
.contains(pattern.as_str())
.contains(&pattern.item)
.map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
let df = NuDataFrame::try_from_series(vec![res.into_series()], &tag.span)?;

2
crates/nu-command/src/commands/dataframe/series/cumulative.rs
View File

@ -99,7 +99,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
));
}
let cum_type = CumType::from_str(cum_type.item.as_str(), &cum_type.tag.span)?;
let cum_type = CumType::from_str(&cum_type.item, &cum_type.tag.span)?;
let mut res = match cum_type {
CumType::Max => series.cum_max(reverse),
CumType::Min => series.cum_min(reverse),

2
crates/nu-command/src/commands/dataframe/series/rename.rs
View File

@ -60,7 +60,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
let mut series = df.as_series(&df_tag.span)?;
series.rename(name.item.as_ref());
series.rename(&name.item);
let df = NuDataFrame::try_from_series(vec![series], &tag.span)?;
Ok(OutputStream::one(df.into_value(df_tag)))

2
crates/nu-command/src/commands/dataframe/series/replace.rs
View File

@ -77,7 +77,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
})?;
let mut res = chunked
.replace(pattern.as_str(), replace.as_str())
.replace(&pattern.item, &replace.item)
.map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
res.rename(series.name());

2
crates/nu-command/src/commands/dataframe/series/replace_all.rs
View File

@ -77,7 +77,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
})?;
let mut res = chunked
.replace_all(pattern.as_str(), replace.as_str())
.replace_all(&pattern.item, &replace.item)
.map_err(|e| parse_polars_error::<&str>(&e, &tag.span, None))?;
res.rename(series.name());

2
crates/nu-command/src/commands/dataframe/series/rolling.rs
View File

@ -125,7 +125,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
));
}
let roll_type = RollType::from_str(roll_type.item.as_str(), &roll_type.tag.span)?;
let roll_type = RollType::from_str(&roll_type.item, &roll_type.tag.span)?;
let res = match roll_type {
RollType::Max => series.rolling_max(
window_size.item as u32,

2
crates/nu-command/src/commands/dataframe/series/strftime.rs
View File

@ -61,7 +61,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
.date64()
.map_err(|e| parse_polars_error::<&str>(&e, &df_tag.span, None))?;
let res = casted.strftime(fmt.item.as_str()).into_series();
let res = casted.strftime(&fmt.item).into_series();
let df = NuDataFrame::try_from_series(vec![res], &tag.span)?;
Ok(OutputStream::one(df.into_value(df_tag)))
}

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

@ -64,14 +64,10 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
let delimiter: Option<Tagged<String>> = args.get_flag("delimiter")?;
let no_header: bool = args.has_flag("no_header");
let (mut df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
let mut file = File::create(&file_name.item).map_err(|e| {
ShellError::labeled_error(
"Error with file name",
format!("{}", e),
&file_name.tag.span,
)
ShellError::labeled_error("Error with file name", e.to_string(), &file_name.tag.span)
})?;
let writer = CsvWriter::new(&mut file);
@ -103,7 +99,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
};
writer
.finish(df.as_mut())
.finish(df.as_ref())
.map_err(|e| parse_polars_error::<&str>(&e, &file_name.tag.span, None))?;
let tagged_value = Value {

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

@ -48,18 +48,14 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
let tag = args.call_info.name_tag.clone();
let file_name: Tagged<PathBuf> = args.req(0)?;
let (mut df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
let file = File::create(&file_name.item).map_err(|e| {
ShellError::labeled_error(
"Error with file name",
format!("{}", e),
&file_name.tag.span,
)
ShellError::labeled_error("Error with file name", e.to_string(), &file_name.tag.span)
})?;
ParquetWriter::new(file)
.finish(df.as_mut())
.finish(df.as_ref())
.map_err(|e| parse_polars_error::<&str>(&e, &file_name.tag.span, None))?;
let tagged_value = Value {

46
crates/nu-command/src/commands/dataframe/utils.rs
View File

@ -46,30 +46,32 @@ pub(crate) fn parse_polars_error<T: AsRef<str>>(
span: &Span,
secondary: Option<T>,
) -> ShellError {
let (msg, label) = match e {
PolarsError::PolarsArrowError(_) => ("PolarsArrow Error", format!("{}", e)),
PolarsError::ArrowError(_) => ("Arrow Error", format!("{}", e)),
PolarsError::InvalidOperation(_) => ("Invalid Operation", format!("{}", e)),
PolarsError::DataTypeMisMatch(_) => ("Data Type Mismatch", format!("{}", e)),
PolarsError::NotFound(_) => ("Not Found", format!("{}", e)),
PolarsError::ShapeMisMatch(_) => ("Shape Mismatch", format!("{}", e)),
PolarsError::Other(_) => ("Other", format!("{}", e)),
PolarsError::OutOfBounds(_) => ("Out Of Bounds", format!("{}", e)),
PolarsError::NoSlice => ("No Slice", format!("{}", e)),
PolarsError::NoData(_) => ("No Data", format!("{}", e)),
PolarsError::ValueError(_) => ("Value Error", format!("{}", e)),
PolarsError::MemoryNotAligned => ("Memory Not Aligned", format!("{}", e)),
PolarsError::ParquetError(_) => ("Parquet Error", format!("{}", e)),
PolarsError::RandError(_) => ("Rand Error", format!("{}", e)),
PolarsError::HasNullValues(_) => ("Has Null Values", format!("{}", e)),
PolarsError::UnknownSchema(_) => ("Unknown Schema", format!("{}", e)),
PolarsError::Various(_) => ("Various", format!("{}", e)),
PolarsError::Io(_) => ("Io Error", format!("{}", e)),
PolarsError::Regex(_) => ("Regex Error", format!("{}", e)),
PolarsError::Duplicate(_) => ("Duplicate Error", format!("{}", e)),
PolarsError::ImplementationError => ("Implementation Error", format!("{}", e)),
let msg = match e {
PolarsError::PolarsArrowError(_) => "PolarsArrow Error",
PolarsError::ArrowError(_) => "Arrow Error",
PolarsError::InvalidOperation(_) => "Invalid Operation",
PolarsError::DataTypeMisMatch(_) => "Data Type Mismatch",
PolarsError::NotFound(_) => "Not Found",
PolarsError::ShapeMisMatch(_) => "Shape Mismatch",
PolarsError::Other(_) => "Other",
PolarsError::OutOfBounds(_) => "Out Of Bounds",
PolarsError::NoSlice => "No Slice",
PolarsError::NoData(_) => "No Data",
PolarsError::ValueError(_) => "Value Error",
PolarsError::MemoryNotAligned => "Memory Not Aligned",
PolarsError::ParquetError(_) => "Parquet Error",
PolarsError::RandError(_) => "Rand Error",
PolarsError::HasNullValues(_) => "Has Null Values",
PolarsError::UnknownSchema(_) => "Unknown Schema",
PolarsError::Various(_) => "Various",
PolarsError::Io(_) => "Io Error",
PolarsError::Regex(_) => "Regex Error",
PolarsError::Duplicate(_) => "Duplicate Error",
PolarsError::ImplementationError => "Implementation Error",
};
let label = e.to_string();
match secondary {
None => ShellError::labeled_error(msg, label, span),
Some(s) => ShellError::labeled_error_with_secondary(msg, label, span, s.as_ref(), span),

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

@ -82,7 +82,7 @@ fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
let mut series = df.as_series(&value.tag.span)?;
let series = series.rename(name.item.as_ref()).clone();
let series = series.rename(&name.item).clone();
let (mut df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;