mirror of
https://github.com/nushell/nushell.git
synced 2025-08-10 10:48:37 +02:00
Fix compile errors
This commit is contained in:
@ -108,8 +108,7 @@ impl Iterator for UpdateCellIterator {
|
||||
let span = val.span();
|
||||
match val {
|
||||
Value::Record { val, .. } => Some(Value::record(
|
||||
val.into_owned()
|
||||
.into_iter()
|
||||
val.into_iter()
|
||||
.map(|(col, val)| match &self.columns {
|
||||
Some(cols) if !cols.contains(&col) => (col, val),
|
||||
_ => (
|
||||
|
@ -500,7 +500,7 @@ pub fn nu_value_to_params(value: Value) -> Result<NuSqlParams, ShellError> {
|
||||
Value::Record { val, .. } => {
|
||||
let mut params = Vec::with_capacity(val.len());
|
||||
|
||||
for (mut column, value) in val.into_owned().into_iter() {
|
||||
for (mut column, value) in val {
|
||||
let sql_type_erased = value_to_sql(value)?;
|
||||
|
||||
if !column.starts_with([':', '@', '$']) {
|
||||
|
@ -199,7 +199,7 @@ mod util {
|
||||
let span = value.span();
|
||||
match value {
|
||||
Value::Record { val: record, .. } => {
|
||||
let (cols, vals): (Vec<_>, Vec<_>) = record.into_owned().into_iter().unzip();
|
||||
let (cols, vals): (Vec<_>, Vec<_>) = record.into_iter().unzip();
|
||||
(
|
||||
cols,
|
||||
vec![vals
|
||||
|
2
crates/nu-command/src/env/load_env.rs
vendored
2
crates/nu-command/src/env/load_env.rs
vendored
@ -40,7 +40,7 @@ impl Command for LoadEnv {
|
||||
let record = match arg {
|
||||
Some(record) => record,
|
||||
None => match input {
|
||||
PipelineData::Value(Value::Record { val, .. }, ..) => val.into_owned(),
|
||||
PipelineData::Value(Value::Record { val, .. }, ..) => val,
|
||||
_ => {
|
||||
return Err(ShellError::UnsupportedInput {
|
||||
msg: "'load-env' expects a single record".into(),
|
||||
|
4
crates/nu-command/src/env/with_env.rs
vendored
4
crates/nu-command/src/env/with_env.rs
vendored
@ -82,7 +82,7 @@ fn with_env(
|
||||
// single row([[X W]; [Y Z]])
|
||||
match &table[0] {
|
||||
Value::Record { val, .. } => {
|
||||
for (k, v) in &**val {
|
||||
for (k, v) in val {
|
||||
env.insert(k.to_string(), v.clone());
|
||||
}
|
||||
}
|
||||
@ -116,7 +116,7 @@ fn with_env(
|
||||
}
|
||||
// when get object by `open x.json` or `from json`
|
||||
Value::Record { val, .. } => {
|
||||
for (k, v) in &**val {
|
||||
for (k, v) in val {
|
||||
env.insert(k.clone(), v.clone());
|
||||
}
|
||||
}
|
||||
|
@ -118,7 +118,6 @@ fn getcol(
|
||||
})
|
||||
}
|
||||
Value::Record { val, .. } => Ok(val
|
||||
.into_owned()
|
||||
.into_iter()
|
||||
.map(move |(x, _)| Value::string(x, head))
|
||||
.into_pipeline_data(ctrlc)
|
||||
|
@ -92,7 +92,7 @@ fn default(
|
||||
} => {
|
||||
let mut found = false;
|
||||
|
||||
for (col, val) in record.to_mut().iter_mut() {
|
||||
for (col, val) in record.iter_mut() {
|
||||
if *col == column.item {
|
||||
found = true;
|
||||
if matches!(val, Value::Nothing { .. }) {
|
||||
@ -102,7 +102,7 @@ fn default(
|
||||
}
|
||||
|
||||
if !found {
|
||||
record.to_mut().push(column.item.clone(), value.clone());
|
||||
record.push(column.item.clone(), value.clone());
|
||||
}
|
||||
|
||||
item
|
||||
|
@ -123,7 +123,7 @@ fn drop_cols(
|
||||
..
|
||||
} => {
|
||||
let len = record.len().saturating_sub(columns);
|
||||
record.to_mut().truncate(len);
|
||||
record.truncate(len);
|
||||
Ok(v.into_pipeline_data_with_metadata(metadata))
|
||||
}
|
||||
// Propagate errors
|
||||
@ -144,7 +144,7 @@ fn drop_cols(
|
||||
fn drop_cols_set(val: &mut Value, head: Span, drop: usize) -> Result<HashSet<String>, ShellError> {
|
||||
if let Value::Record { val: record, .. } = val {
|
||||
let len = record.len().saturating_sub(drop);
|
||||
Ok(record.to_mut().drain(len..).map(|(col, _)| col).collect())
|
||||
Ok(record.drain(len..).map(|(col, _)| col).collect())
|
||||
} else {
|
||||
Err(unsupported_value_error(val, head))
|
||||
}
|
||||
@ -156,7 +156,7 @@ fn drop_record_cols(
|
||||
drop_cols: &HashSet<String>,
|
||||
) -> Result<(), ShellError> {
|
||||
if let Value::Record { val, .. } = val {
|
||||
val.to_mut().retain(|col, _| !drop_cols.contains(col));
|
||||
val.retain(|col, _| !drop_cols.contains(col));
|
||||
Ok(())
|
||||
} else {
|
||||
Err(unsupported_value_error(val, head))
|
||||
|
@ -156,7 +156,7 @@ fn flat_value(columns: &[CellPath], item: Value, all: bool) -> Vec<Value> {
|
||||
let mut out = IndexMap::<String, Value>::new();
|
||||
let mut inner_table = None;
|
||||
|
||||
for (column_index, (column, value)) in val.into_owned().into_iter().enumerate() {
|
||||
for (column_index, (column, value)) in val.into_iter().enumerate() {
|
||||
let column_requested = columns.iter().find(|c| c.to_string() == column);
|
||||
let need_flatten = { columns.is_empty() || column_requested.is_some() };
|
||||
let span = value.span();
|
||||
@ -164,7 +164,7 @@ fn flat_value(columns: &[CellPath], item: Value, all: bool) -> Vec<Value> {
|
||||
match value {
|
||||
Value::Record { ref val, .. } => {
|
||||
if need_flatten {
|
||||
for (col, val) in val.clone().into_owned() {
|
||||
for (col, val) in val.clone() {
|
||||
if out.contains_key(&col) {
|
||||
out.insert(format!("{column}_{col}"), val);
|
||||
} else {
|
||||
|
@ -149,7 +149,6 @@ fn replace_headers(
|
||||
if let Value::Record { val: record, .. } = value {
|
||||
Ok(Value::record(
|
||||
record
|
||||
.into_owned()
|
||||
.into_iter()
|
||||
.filter_map(|(col, val)| {
|
||||
old_headers
|
||||
|
@ -55,7 +55,6 @@ impl Command for Items {
|
||||
Value::Record { val, .. } => {
|
||||
let mut closure = ClosureEval::new(engine_state, stack, closure);
|
||||
Ok(val
|
||||
.into_owned()
|
||||
.into_iter()
|
||||
.map_while(move |(col, val)| {
|
||||
let result = closure
|
||||
|
@ -148,8 +148,7 @@ fn rename(
|
||||
Value::Record { val: record, .. } => {
|
||||
let record =
|
||||
if let Some(closure) = &mut closure {
|
||||
record
|
||||
.into_owned().into_iter()
|
||||
record.into_iter()
|
||||
.map(|(col, val)| {
|
||||
let col = Value::string(col, span);
|
||||
let data = closure.run_with_value(col)?;
|
||||
@ -163,7 +162,7 @@ fn rename(
|
||||
// record columns are unique so we can track the number
|
||||
// of renamed columns to check if any were missed
|
||||
let mut renamed = 0;
|
||||
let record = record.into_owned().into_iter().map(|(col, val)| {
|
||||
let record = record.into_iter().map(|(col, val)| {
|
||||
let col = if let Some(col) = columns.get(&col) {
|
||||
renamed += 1;
|
||||
col.clone()
|
||||
@ -194,7 +193,7 @@ fn rename(
|
||||
}
|
||||
}
|
||||
None => Ok(record
|
||||
.into_owned().into_iter()
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
.map(|(i, (col, val))| {
|
||||
(columns.get(i).cloned().unwrap_or(col), val)
|
||||
|
@ -144,14 +144,7 @@ impl Command for Sort {
|
||||
// Records have two sorting methods, toggled by presence or absence of -v
|
||||
PipelineData::Value(Value::Record { val, .. }, ..) => {
|
||||
let sort_by_value = call.has_flag(engine_state, stack, "values")?;
|
||||
let record = sort_record(
|
||||
val.into_owned(),
|
||||
span,
|
||||
sort_by_value,
|
||||
reverse,
|
||||
insensitive,
|
||||
natural,
|
||||
);
|
||||
let record = sort_record(val, span, sort_by_value, reverse, insensitive, natural);
|
||||
Ok(record.into_pipeline_data())
|
||||
}
|
||||
// Other values are sorted here
|
||||
|
@ -187,11 +187,11 @@ pub fn data_split(
|
||||
let span = v.span();
|
||||
match v {
|
||||
Value::Record { val: grouped, .. } => {
|
||||
for (outer_key, list) in grouped.into_owned() {
|
||||
for (outer_key, list) in grouped {
|
||||
match data_group(&list, splitter, span) {
|
||||
Ok(grouped_vals) => {
|
||||
if let Value::Record { val: sub, .. } = grouped_vals {
|
||||
for (inner_key, subset) in sub.into_owned() {
|
||||
for (inner_key, subset) in sub {
|
||||
let s: &mut IndexMap<String, Value> =
|
||||
splits.entry(inner_key).or_default();
|
||||
|
||||
|
@ -194,7 +194,6 @@ fn sort_attributes(val: Value) -> Value {
|
||||
Value::Record { val, .. } => {
|
||||
// TODO: sort inplace
|
||||
let sorted = val
|
||||
.into_owned()
|
||||
.into_iter()
|
||||
.sorted_by(|a, b| a.0.cmp(&b.0))
|
||||
.collect_vec();
|
||||
|
@ -106,7 +106,7 @@ pub fn get_values<'a>(
|
||||
for item in input {
|
||||
match item {
|
||||
Value::Record { val, .. } => {
|
||||
for (k, v) in &**val {
|
||||
for (k, v) in val {
|
||||
if let Some(vec) = output.get_mut(k) {
|
||||
vec.push(v.clone());
|
||||
} else {
|
||||
@ -171,7 +171,6 @@ fn values(
|
||||
})?,
|
||||
};
|
||||
Ok(record
|
||||
.into_owned()
|
||||
.into_values()
|
||||
.into_pipeline_data_with_metadata(metadata, ctrlc))
|
||||
}
|
||||
|
@ -130,7 +130,7 @@ pub fn value_to_json_value(v: &Value) -> Result<nu_json::Value, ShellError> {
|
||||
}
|
||||
Value::Record { val, .. } => {
|
||||
let mut m = nu_json::Map::new();
|
||||
for (k, v) in &**val {
|
||||
for (k, v) in val {
|
||||
m.insert(k.clone(), value_to_json_value(v)?);
|
||||
}
|
||||
nu_json::Value::Object(m)
|
||||
|
@ -125,7 +125,6 @@ fn local_into_string(value: Value, separator: &str, config: &Config) -> String {
|
||||
.collect::<Vec<_>>()
|
||||
.join(separator),
|
||||
Value::Record { val, .. } => val
|
||||
.into_owned()
|
||||
.into_iter()
|
||||
.map(|(x, y)| format!("{}: {}", x, local_into_string(y, ", ", config)))
|
||||
.collect::<Vec<_>>()
|
||||
|
@ -57,7 +57,7 @@ fn helper(engine_state: &EngineState, v: &Value) -> Result<toml::Value, ShellErr
|
||||
Value::String { val, .. } | Value::Glob { val, .. } => toml::Value::String(val.clone()),
|
||||
Value::Record { val, .. } => {
|
||||
let mut m = toml::map::Map::new();
|
||||
for (k, v) in &**val {
|
||||
for (k, v) in val {
|
||||
m.insert(k.clone(), helper(engine_state, v)?);
|
||||
}
|
||||
toml::Value::Table(m)
|
||||
|
@ -325,7 +325,7 @@ impl Job {
|
||||
// alternatives like {tag: a attributes: {} content: []}, {tag: a attribbutes: null
|
||||
// content: null}, {tag: a}. See to_xml_entry for more
|
||||
let attrs = match attrs {
|
||||
Value::Record { val, .. } => val.into_owned(),
|
||||
Value::Record { val, .. } => val,
|
||||
Value::Nothing { .. } => Record::new(),
|
||||
_ => {
|
||||
return Err(ShellError::CantConvert {
|
||||
|
@ -54,7 +54,7 @@ pub fn value_to_yaml_value(v: &Value) -> Result<serde_yaml::Value, ShellError> {
|
||||
}
|
||||
Value::Record { val, .. } => {
|
||||
let mut m = serde_yaml::Mapping::new();
|
||||
for (k, v) in &**val {
|
||||
for (k, v) in val {
|
||||
m.insert(
|
||||
serde_yaml::Value::String(k.clone()),
|
||||
value_to_yaml_value(v)?,
|
||||
|
@ -112,7 +112,7 @@ used as the next argument to the closure, otherwise generation stops.
|
||||
match value {
|
||||
// {out: ..., next: ...} -> output and continue
|
||||
Value::Record { val, .. } => {
|
||||
let iter = val.into_owned().into_iter();
|
||||
let iter = val.into_iter();
|
||||
let mut out = None;
|
||||
let mut next = None;
|
||||
let mut err = None;
|
||||
|
@ -152,7 +152,7 @@ pub fn highlight_search_in_table(
|
||||
});
|
||||
};
|
||||
|
||||
let has_match = record.to_mut().iter_mut().try_fold(
|
||||
let has_match = record.iter_mut().try_fold(
|
||||
false,
|
||||
|acc: bool, (col, val)| -> Result<bool, ShellError> {
|
||||
if !searched_cols.contains(&col.as_str()) {
|
||||
|
@ -27,7 +27,7 @@ fn helper_for_tables(
|
||||
for val in values {
|
||||
match val {
|
||||
Value::Record { val, .. } => {
|
||||
for (key, value) in &**val {
|
||||
for (key, value) in val {
|
||||
column_values
|
||||
.entry(key.clone())
|
||||
.and_modify(|v: &mut Vec<Value>| v.push(value.clone()))
|
||||
@ -80,15 +80,13 @@ pub fn calculate(
|
||||
),
|
||||
_ => mf(vals, span, name),
|
||||
},
|
||||
PipelineData::Value(Value::Record { val, .. }, ..) => {
|
||||
let mut record = val.into_owned();
|
||||
record
|
||||
.iter_mut()
|
||||
PipelineData::Value(Value::Record { mut val, .. }, ..) => {
|
||||
val.iter_mut()
|
||||
.try_for_each(|(_, val)| -> Result<(), ShellError> {
|
||||
*val = mf(slice::from_ref(val), span, name)?;
|
||||
Ok(())
|
||||
})?;
|
||||
Ok(Value::record(record, span))
|
||||
Ok(Value::record(val, span))
|
||||
}
|
||||
PipelineData::Value(Value::Range { val, .. }, ..) => {
|
||||
let new_vals: Result<Vec<Value>, ShellError> = val
|
||||
|
@ -222,7 +222,7 @@ pub fn send_request(
|
||||
Value::Record { val, .. } if body_type == BodyType::Form => {
|
||||
let mut data: Vec<(String, String)> = Vec::with_capacity(val.len());
|
||||
|
||||
for (col, val) in val.into_owned() {
|
||||
for (col, val) in val {
|
||||
data.push((col, val.coerce_into_string()?))
|
||||
}
|
||||
|
||||
@ -336,7 +336,7 @@ pub fn request_add_custom_headers(
|
||||
|
||||
match &headers {
|
||||
Value::Record { val, .. } => {
|
||||
for (k, v) in &**val {
|
||||
for (k, v) in val {
|
||||
custom_headers.insert(k.to_string(), v.clone());
|
||||
}
|
||||
}
|
||||
@ -346,7 +346,7 @@ pub fn request_add_custom_headers(
|
||||
// single row([key1 key2]; [val1 val2])
|
||||
match &table[0] {
|
||||
Value::Record { val, .. } => {
|
||||
for (k, v) in &**val {
|
||||
for (k, v) in val {
|
||||
custom_headers.insert(k.to_string(), v.clone());
|
||||
}
|
||||
}
|
||||
|
@ -65,7 +65,7 @@ fn to_url(input: PipelineData, head: Span) -> Result<PipelineData, ShellError> {
|
||||
match value {
|
||||
Value::Record { ref val, .. } => {
|
||||
let mut row_vec = vec![];
|
||||
for (k, v) in &**val {
|
||||
for (k, v) in val {
|
||||
match v.coerce_string() {
|
||||
Ok(s) => {
|
||||
row_vec.push((k.clone(), s));
|
||||
|
@ -92,7 +92,6 @@ impl Command for SubCommand {
|
||||
match value {
|
||||
Value::Record { val, .. } => {
|
||||
let url_components = val
|
||||
.into_owned()
|
||||
.into_iter()
|
||||
.try_fold(UrlComponents::new(), |url, (k, v)| {
|
||||
url.add_component(k, v, span, engine_state)
|
||||
@ -180,7 +179,6 @@ impl UrlComponents {
|
||||
return match value {
|
||||
Value::Record { val, .. } => {
|
||||
let mut qs = val
|
||||
.into_owned()
|
||||
.into_iter()
|
||||
.map(|(k, v)| match v.coerce_into_string() {
|
||||
Ok(val) => Ok(format!("{k}={val}")),
|
||||
|
@ -108,7 +108,7 @@ prints out the list properly."#
|
||||
// dbg!("value::record");
|
||||
let mut items = vec![];
|
||||
|
||||
for (i, (c, v)) in val.into_owned().into_iter().enumerate() {
|
||||
for (i, (c, v)) in val.into_iter().enumerate() {
|
||||
items.push((i, c, v.to_expanded_string(", ", config)))
|
||||
}
|
||||
|
||||
|
@ -392,7 +392,7 @@ fn handle_table_command(
|
||||
}
|
||||
PipelineData::Value(Value::Record { val, .. }, ..) => {
|
||||
input.data = PipelineData::Empty;
|
||||
handle_record(input, cfg, val.into_owned())
|
||||
handle_record(input, cfg, val)
|
||||
}
|
||||
PipelineData::Value(Value::LazyRecord { val, .. }, ..) => {
|
||||
input.data = val.collect()?.into_pipeline_data();
|
||||
@ -557,7 +557,7 @@ fn handle_row_stream(
|
||||
stream.map(move |mut x| match &mut x {
|
||||
Value::Record { val: record, .. } => {
|
||||
// Only the name column gets special colors, for now
|
||||
if let Some(value) = record.to_mut().get_mut("name") {
|
||||
if let Some(value) = record.get_mut("name") {
|
||||
let span = value.span();
|
||||
if let Value::String { val, .. } = value {
|
||||
if let Some(val) = render_path_name(val, &config, &ls_colors, span)
|
||||
@ -583,7 +583,7 @@ fn handle_row_stream(
|
||||
ListStream::from_stream(
|
||||
stream.map(move |mut x| match &mut x {
|
||||
Value::Record { val: record, .. } => {
|
||||
for (rec_col, rec_val) in record.to_mut().iter_mut() {
|
||||
for (rec_col, rec_val) in record.iter_mut() {
|
||||
// Every column in the HTML theme table except 'name' is colored
|
||||
if rec_col != "name" {
|
||||
continue;
|
||||
|
Reference in New Issue
Block a user