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

Extract ps and sys subcrates. Move helper methods to UntaggedValue

Browse source
This commit is contained in:
Jonathan Turner 2019-12-05 08:52:31 +13:00
parent a4bb5d4ff5
commit d12c16a331
84 changed files with 673 additions and 600 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
Cargo.lock generated
View file

@ -1884,7 +1884,6 @@ dependencies = [
"app_dirs",
"async-stream",
"base64 0.11.0",
"battery",
"bigdecimal",
"bson",
"byte-unit",
@ -1903,13 +1902,11 @@ dependencies = [
"dirs 2.0.2",
"dunce",
"futures-preview",
"futures-timer",
"futures-util",
"futures_codec",
"getset",
"git2",
"glob",
"heim",
"hex 0.4.0",
"indexmap",
"itertools 0.8.2",
@ -1926,10 +1923,11 @@ dependencies = [
"nu-protocol",
"nu-source",
"nu_plugin_binaryview",
"nu_plugin_ps",
"nu_plugin_sys",
"nu_plugin_textview",
"num-bigint",
"num-traits 0.2.10",
"onig_sys",
"pin-utils",
"pretty",
"pretty-hex",
@ -1956,7 +1954,6 @@ dependencies = [
"sublime_fuzzy",
"subprocess",
"surf",
"syntect",
"tempfile",
"term",
"termcolor",
@ -2091,8 +2088,35 @@ dependencies = [
"nu-source",
"pretty-hex",
"rawkey",
"syntect",
"url",
]
[[package]]
name = "nu_plugin_ps"
version = "0.1.0"
dependencies = [
"futures-preview",
"futures-timer",
"heim",
"nu-build",
"nu-errors",
"nu-protocol",
"nu-source",
"pin-utils",
]
[[package]]
name = "nu_plugin_sys"
version = "0.1.0"
dependencies = [
"battery",
"futures-preview",
"futures-timer",
"heim",
"nu-build",
"nu-errors",
"nu-protocol",
"nu-source",
"pin-utils",
]
[[package]]

23
Cargo.toml
View file

@ -18,6 +18,8 @@ members = [
"crates/nu-source",
"crates/nu_plugin_textview",
"crates/nu_plugin_binaryview",
"crates/nu_plugin_ps",
"crates/nu_plugin_sys",
"crates/nu-protocol",
"crates/nu-parser",
"crates/nu-build"
@ -32,6 +34,8 @@ nu-errors = { version = "0.1.0", path = "./crates/nu-errors" }
nu-parser = { version = "0.1.0", path = "./crates/nu-parser" }
nu_plugin_textview = {version = "0.1.0", path = "./crates/nu_plugin_textview", optional=true}
nu_plugin_binaryview = {version = "0.1.0", path = "./crates/nu_plugin_binaryview", optional=true}
nu_plugin_ps = {version = "0.1.0", path = "./crates/nu_plugin_ps", optional=true}
nu_plugin_sys = {version = "0.1.0", path = "./crates/nu_plugin_sys", optional=true}
query_interface = "0.3.5"
typetag = "0.1.4"
@ -87,7 +91,6 @@ semver = "0.9.0"
which = "3.1"
textwrap = {version = "0.11.0", features = ["term_size"]}
shellexpand = "1.0.0"
futures-timer = "2.0.0"
pin-utils = "0.1.0-alpha.4"
num-bigint = { version = "0.2.3", features = ["serde"] }
bigdecimal = { version = "0.1.0", features = ["serde"] }
@ -106,21 +109,17 @@ termcolor = "1.0.5"
console = "0.9.1"
crossterm = { version = "0.10.2", optional = true }
syntect = {version = "3.2.0", optional = true }
onig_sys = {version = "=69.1.0", optional = true }
heim = {version = "0.0.8", optional = true }
battery = {version = "0.7.4", optional = true }
clipboard = {version = "0.5", optional = true }
ptree = {version = "0.2" }
starship = { version = "0.26.4", optional = true}
[features]
default = ["sys", "ps"]
sys = ["heim", "battery"]
ps = ["heim"]
sys = ["nu_plugin_ps"]
starship-prompt = ["starship"]
textview = ["nu_plugin_textview"]
binaryview = ["nu_plugin_binaryview"]
ps = ["nu_plugin_ps"]
#trace = ["nu-parser/trace"]
[dependencies.rusqlite]
@ -183,16 +182,6 @@ path = "src/plugins/skip.rs"
name = "nu_plugin_match"
path = "src/plugins/match.rs"
[[bin]]
name = "nu_plugin_sys"
path = "src/plugins/sys.rs"
required-features = ["sys"]
[[bin]]
name = "nu_plugin_ps"
path = "src/plugins/ps.rs"
required-features = ["ps"]
[[bin]]
name = "nu_plugin_tree"
path = "src/plugins/tree.rs"

2
crates/nu-protocol/src/lib.rs
View file

@ -18,7 +18,7 @@ pub use crate::signature::{NamedType, PositionalType, Signature};
pub use crate::syntax_shape::SyntaxShape;
pub use crate::type_name::{PrettyType, ShellTypeName, SpannedTypeName};
pub use crate::value::column_path::{ColumnPath, PathMember, UnspannedPathMember};
pub use crate::value::dict::Dictionary;
pub use crate::value::dict::{Dictionary, TaggedDictBuilder};
pub use crate::value::evaluate::{Evaluate, EvaluateTrait, Scope};
pub use crate::value::primitive::Primitive;
pub use crate::value::{UntaggedValue, Value};

68
crates/nu-protocol/src/value.rs
View file

@ -11,10 +11,15 @@ use crate::type_name::{ShellTypeName, SpannedTypeName};
use crate::value::dict::Dictionary;
use crate::value::evaluate::Evaluate;
use crate::value::primitive::Primitive;
use crate::{ColumnPath, PathMember};
use bigdecimal::BigDecimal;
use indexmap::IndexMap;
use nu_errors::ShellError;
use nu_source::{AnchorLocation, HasSpan, Span, Tag};
use num_bigint::BigInt;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use std::time::SystemTime;
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Serialize, Deserialize)]
pub enum UntaggedValue {
@ -103,6 +108,69 @@ impl UntaggedValue {
_ => panic!("expect_string assumes that the value must be a string"),
}
}
#[allow(unused)]
pub fn row(entries: IndexMap<String, Value>) -> UntaggedValue {
UntaggedValue::Row(entries.into())
}
pub fn table(list: &Vec<Value>) -> UntaggedValue {
UntaggedValue::Table(list.to_vec())
}
pub fn string(s: impl Into<String>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::String(s.into()))
}
pub fn line(s: impl Into<String>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Line(s.into()))
}
pub fn column_path(s: Vec<impl Into<PathMember>>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::ColumnPath(ColumnPath::new(
s.into_iter().map(|p| p.into()).collect(),
)))
}
pub fn int(i: impl Into<BigInt>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Int(i.into()))
}
pub fn pattern(s: impl Into<String>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::String(s.into()))
}
pub fn path(s: impl Into<PathBuf>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Path(s.into()))
}
pub fn bytes(s: impl Into<u64>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Bytes(s.into()))
}
pub fn decimal(s: impl Into<BigDecimal>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Decimal(s.into()))
}
pub fn binary(binary: Vec<u8>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Binary(binary))
}
pub fn boolean(s: impl Into<bool>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Boolean(s.into()))
}
pub fn duration(secs: u64) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Duration(secs))
}
pub fn system_date(s: SystemTime) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Date(s.into()))
}
pub fn nothing() -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Nothing)
}
}
#[derive(Debug, Clone, PartialOrd, PartialEq, Ord, Eq, Serialize, Deserialize)]

56
crates/nu-protocol/src/value/dict.rs
View file

@ -138,3 +138,59 @@ impl Dictionary {
self.entries.insert(name.to_string(), value);
}
}
#[derive(Debug)]
pub struct TaggedDictBuilder {
tag: Tag,
dict: IndexMap<String, Value>,
}
impl TaggedDictBuilder {
pub fn new(tag: impl Into<Tag>) -> TaggedDictBuilder {
TaggedDictBuilder {
tag: tag.into(),
dict: IndexMap::default(),
}
}
pub fn build(tag: impl Into<Tag>, block: impl FnOnce(&mut TaggedDictBuilder)) -> Value {
let mut builder = TaggedDictBuilder::new(tag);
block(&mut builder);
builder.into_value()
}
pub fn with_capacity(tag: impl Into<Tag>, n: usize) -> TaggedDictBuilder {
TaggedDictBuilder {
tag: tag.into(),
dict: IndexMap::with_capacity(n),
}
}
pub fn insert_untagged(&mut self, key: impl Into<String>, value: impl Into<UntaggedValue>) {
self.dict
.insert(key.into(), value.into().into_value(&self.tag));
}
pub fn insert_value(&mut self, key: impl Into<String>, value: impl Into<Value>) {
self.dict.insert(key.into(), value.into());
}
pub fn into_value(self) -> Value {
let tag = self.tag.clone();
self.into_untagged_value().into_value(tag)
}
pub fn into_untagged_value(self) -> UntaggedValue {
UntaggedValue::Row(Dictionary { entries: self.dict })
}
pub fn is_empty(&self) -> bool {
self.dict.is_empty()
}
}
impl From<TaggedDictBuilder> for Value {
fn from(input: TaggedDictBuilder) -> Value {
input.into_value()
}
}

2
crates/nu_plugin_binaryview/Cargo.toml
View file

@ -7,13 +7,11 @@ edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
syntect = { version = "3.2.0" }
ansi_term = "0.12.1"
crossterm = { version = "0.10.2" }
nu-protocol = { path = "../nu-protocol" }
nu-source = { path = "../nu-source" }
nu-errors = { path = "../nu-errors" }
url = "2.1.0"
pretty-hex = "0.1.1"
image = { version = "0.22.2", default_features = false, features = ["png_codec", "jpeg"] }
rawkey = "0.1.2"

19
crates/nu_plugin_ps/Cargo.toml Normal file
View file

@ -0,0 +1,19 @@
[package]
name = "nu_plugin_ps"
version = "0.1.0"
authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>", "Andrés N. Robalino <andres@androbtech.com>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
nu-protocol = { path = "../nu-protocol" }
nu-source = { path = "../nu-source" }
nu-errors = { path = "../nu-errors" }
futures-preview = { version = "=0.3.0-alpha.19", features = ["compat", "io-compat"] }
heim = "0.0.8"
futures-timer = "2.0.0"
pin-utils = "0.1.0-alpha.4"
[build-dependencies]
nu-build = { version = "0.1.0", path = "../nu-build" }

3
crates/nu_plugin_ps/build.rs Normal file
View file

@ -0,0 +1,3 @@
fn main() -> Result<(), Box<dyn std::error::Error>> {
nu_build::build()
}

14
src/plugins/ps.rs → crates/nu_plugin_ps/src/main.rs
View file

@ -5,9 +5,11 @@ use heim::process::{self as process, Process, ProcessResult};
use heim::units::{ratio, Ratio};
use std::usize;
use nu::{serve_plugin, value, Plugin, TaggedDictBuilder};
use nu_errors::ShellError;
use nu_protocol::{CallInfo, ReturnSuccess, ReturnValue, Signature, Value};
use nu_protocol::{
serve_plugin, CallInfo, Plugin, ReturnSuccess, ReturnValue, Signature, TaggedDictBuilder,
UntaggedValue, Value,
};
use nu_source::Tag;
use std::time::Duration;
@ -42,14 +44,14 @@ async fn ps(tag: Tag) -> Vec<Value> {
while let Some(res) = processes.next().await {
if let Ok((process, usage)) = res {
let mut dict = TaggedDictBuilder::new(&tag);
dict.insert_untagged("pid", value::int(process.pid()));
dict.insert_untagged("pid", UntaggedValue::int(process.pid()));
if let Ok(name) = process.name().await {
dict.insert_untagged("name", value::string(name));
dict.insert_untagged("name", UntaggedValue::string(name));
}
if let Ok(status) = process.status().await {
dict.insert_untagged("status", value::string(format!("{:?}", status)));
dict.insert_untagged("status", UntaggedValue::string(format!("{:?}", status)));
}
dict.insert_untagged("cpu", value::number(usage.get::<ratio::percent>()));
dict.insert_untagged("cpu", UntaggedValue::decimal(usage.get::<ratio::percent>()));
output.push(dict.into_value());
}
}

20
crates/nu_plugin_sys/Cargo.toml Normal file
View file

@ -0,0 +1,20 @@
[package]
name = "nu_plugin_sys"
version = "0.1.0"
authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>", "Andrés N. Robalino <andres@androbtech.com>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
nu-protocol = { path = "../nu-protocol" }
nu-source = { path = "../nu-source" }
nu-errors = { path = "../nu-errors" }
futures-preview = { version = "=0.3.0-alpha.19", features = ["compat", "io-compat"] }
heim = "0.0.8"
futures-timer = "2.0.0"
pin-utils = "0.1.0-alpha.4"
battery = "0.7.4"
[build-dependencies]
nu-build = { version = "0.1.0", path = "../nu-build" }

3
crates/nu_plugin_sys/build.rs Normal file
View file

@ -0,0 +1,3 @@
fn main() -> Result<(), Box<dyn std::error::Error>> {
nu_build::build()
}

90
src/plugins/sys.rs → crates/nu_plugin_sys/src/main.rs
View file

@ -4,9 +4,11 @@ use futures::executor::block_on;
use futures::stream::StreamExt;
use heim::units::{frequency, information, thermodynamic_temperature, time};
use heim::{disk, host, memory, net, sensors};
use nu::{primitive, serve_plugin, value, Plugin, TaggedDictBuilder};
use nu_errors::ShellError;
use nu_protocol::{CallInfo, ReturnSuccess, ReturnValue, Signature, UntaggedValue, Value};
use nu_protocol::{
serve_plugin, CallInfo, Plugin, ReturnSuccess, ReturnValue, Signature, TaggedDictBuilder,
UntaggedValue, Value,
};
use nu_source::Tag;
struct Sys;
@ -20,26 +22,26 @@ async fn cpu(tag: Tag) -> Option<Value> {
match futures::future::try_join(heim::cpu::logical_count(), heim::cpu::frequency()).await {
Ok((num_cpu, cpu_speed)) => {
let mut cpu_idx = TaggedDictBuilder::with_capacity(tag, 4);
cpu_idx.insert_untagged("cores", primitive::number(num_cpu));
cpu_idx.insert_untagged("cores", UntaggedValue::int(num_cpu));
let current_speed =
(cpu_speed.current().get::<frequency::hertz>() as f64 / 1_000_000_000.0 * 100.0)
.round()
/ 100.0;
cpu_idx.insert_untagged("current ghz", primitive::number(current_speed));
cpu_idx.insert_untagged("current ghz", UntaggedValue::decimal(current_speed));
if let Some(min_speed) = cpu_speed.min() {
let min_speed =
(min_speed.get::<frequency::hertz>() as f64 / 1_000_000_000.0 * 100.0).round()
/ 100.0;
cpu_idx.insert_untagged("min ghz", primitive::number(min_speed));
cpu_idx.insert_untagged("min ghz", UntaggedValue::decimal(min_speed));
}
if let Some(max_speed) = cpu_speed.max() {
let max_speed =
(max_speed.get::<frequency::hertz>() as f64 / 1_000_000_000.0 * 100.0).round()
/ 100.0;
cpu_idx.insert_untagged("max ghz", primitive::number(max_speed));
cpu_idx.insert_untagged("max ghz", UntaggedValue::decimal(max_speed));
}
Some(cpu_idx.into_value())
@ -57,22 +59,22 @@ async fn mem(tag: Tag) -> Value {
if let Ok(memory) = memory_result {
dict.insert_untagged(
"total",
value::bytes(memory.total().get::<information::byte>()),
UntaggedValue::bytes(memory.total().get::<information::byte>()),
);
dict.insert_untagged(
"free",
value::bytes(memory.free().get::<information::byte>()),
UntaggedValue::bytes(memory.free().get::<information::byte>()),
);
}
if let Ok(swap) = swap_result {
dict.insert_untagged(
"swap total",
value::bytes(swap.total().get::<information::byte>()),
UntaggedValue::bytes(swap.total().get::<information::byte>()),
);
dict.insert_untagged(
"swap free",
value::bytes(swap.free().get::<information::byte>()),
UntaggedValue::bytes(swap.free().get::<information::byte>()),
);
}
@ -87,10 +89,13 @@ async fn host(tag: Tag) -> Value {
// OS
if let Ok(platform) = platform_result {
dict.insert_untagged("name", value::string(platform.system()));
dict.insert_untagged("release", value::string(platform.release()));
dict.insert_untagged("hostname", value::string(platform.hostname()));
dict.insert_untagged("arch", value::string(platform.architecture().as_str()));
dict.insert_untagged("name", UntaggedValue::string(platform.system()));
dict.insert_untagged("release", UntaggedValue::string(platform.release()));
dict.insert_untagged("hostname", UntaggedValue::string(platform.hostname()));
dict.insert_untagged(
"arch",
UntaggedValue::string(platform.architecture().as_str()),
);
}
// Uptime
@ -103,10 +108,10 @@ async fn host(tag: Tag) -> Value {
let minutes = (uptime - days * 60 * 60 * 24 - hours * 60 * 60) / 60;
let seconds = uptime % 60;
uptime_dict.insert_untagged("days", value::int(days));
uptime_dict.insert_untagged("hours", value::int(hours));
uptime_dict.insert_untagged("mins", value::int(minutes));
uptime_dict.insert_untagged("secs", value::int(seconds));
uptime_dict.insert_untagged("days", UntaggedValue::int(days));
uptime_dict.insert_untagged("hours", UntaggedValue::int(hours));
uptime_dict.insert_untagged("mins", UntaggedValue::int(minutes));
uptime_dict.insert_untagged("secs", UntaggedValue::int(seconds));
dict.insert_value("uptime", uptime_dict);
}
@ -117,7 +122,7 @@ async fn host(tag: Tag) -> Value {
while let Some(user) = users.next().await {
if let Ok(user) = user {
user_vec.push(Value {
value: value::string(user.username()),
value: UntaggedValue::string(user.username()),
tag: tag.clone(),
});
}
@ -136,28 +141,31 @@ async fn disks(tag: Tag) -> Option<UntaggedValue> {
let mut dict = TaggedDictBuilder::with_capacity(&tag, 6);
dict.insert_untagged(
"device",
value::string(
UntaggedValue::string(
part.device()
.unwrap_or_else(|| OsStr::new("N/A"))
.to_string_lossy(),
),
);
dict.insert_untagged("type", value::string(part.file_system().as_str()));
dict.insert_untagged("mount", value::string(part.mount_point().to_string_lossy()));
dict.insert_untagged("type", UntaggedValue::string(part.file_system().as_str()));
dict.insert_untagged(
"mount",
UntaggedValue::string(part.mount_point().to_string_lossy()),
);
if let Ok(usage) = disk::usage(part.mount_point().to_path_buf()).await {
dict.insert_untagged(
"total",
value::bytes(usage.total().get::<information::byte>()),
UntaggedValue::bytes(usage.total().get::<information::byte>()),
);
dict.insert_untagged(
"used",
value::bytes(usage.used().get::<information::byte>()),
UntaggedValue::bytes(usage.used().get::<information::byte>()),
);
dict.insert_untagged(
"free",
value::bytes(usage.free().get::<information::byte>()),
UntaggedValue::bytes(usage.free().get::<information::byte>()),
);
}
@ -181,24 +189,28 @@ async fn battery(tag: Tag) -> Option<UntaggedValue> {
if let Ok(battery) = battery {
let mut dict = TaggedDictBuilder::new(&tag);
if let Some(vendor) = battery.vendor() {
dict.insert_untagged("vendor", value::string(vendor));
dict.insert_untagged("vendor", UntaggedValue::string(vendor));
}
if let Some(model) = battery.model() {
dict.insert_untagged("model", value::string(model));
dict.insert_untagged("model", UntaggedValue::string(model));
}
if let Some(cycles) = battery.cycle_count() {
dict.insert_untagged("cycles", value::int(cycles));
dict.insert_untagged("cycles", UntaggedValue::int(cycles));
}
if let Some(time_to_full) = battery.time_to_full() {
dict.insert_untagged(
"mins to full",
value::number(time_to_full.get::<battery::units::time::minute>()),
UntaggedValue::decimal(
time_to_full.get::<battery::units::time::minute>(),
),
);
}
if let Some(time_to_empty) = battery.time_to_empty() {
dict.insert_untagged(
"mins to empty",
value::number(time_to_empty.get::<battery::units::time::minute>()),
UntaggedValue::decimal(
time_to_empty.get::<battery::units::time::minute>(),
),
);
}
output.push(dict.into_value());
@ -221,13 +233,13 @@ async fn temp(tag: Tag) -> Option<UntaggedValue> {
while let Some(sensor) = sensors.next().await {
if let Ok(sensor) = sensor {
let mut dict = TaggedDictBuilder::new(&tag);
dict.insert_untagged("unit", value::string(sensor.unit()));
dict.insert_untagged("unit", UntaggedValue::string(sensor.unit()));
if let Some(label) = sensor.label() {
dict.insert_untagged("label", value::string(label));
dict.insert_untagged("label", UntaggedValue::string(label));
}
dict.insert_untagged(
"temp",
value::number(
UntaggedValue::decimal(
sensor
.current()
.get::<thermodynamic_temperature::degree_celsius>(),
@ -236,13 +248,15 @@ async fn temp(tag: Tag) -> Option<UntaggedValue> {
if let Some(high) = sensor.high() {
dict.insert_untagged(
"high",
value::number(high.get::<thermodynamic_temperature::degree_celsius>()),
UntaggedValue::decimal(high.get::<thermodynamic_temperature::degree_celsius>()),
);
}
if let Some(critical) = sensor.critical() {
dict.insert_untagged(
"critical",
value::number(critical.get::<thermodynamic_temperature::degree_celsius>()),
UntaggedValue::decimal(
critical.get::<thermodynamic_temperature::degree_celsius>(),
),
);
}
@ -263,14 +277,14 @@ async fn net(tag: Tag) -> Option<UntaggedValue> {
while let Some(nic) = io_counters.next().await {
if let Ok(nic) = nic {
let mut network_idx = TaggedDictBuilder::with_capacity(&tag, 3);
network_idx.insert_untagged("name", value::string(nic.interface()));
network_idx.insert_untagged("name", UntaggedValue::string(nic.interface()));
network_idx.insert_untagged(
"sent",
value::bytes(nic.bytes_sent().get::<information::byte>()),
UntaggedValue::bytes(nic.bytes_sent().get::<information::byte>()),
);
network_idx.insert_untagged(
"recv",
value::bytes(nic.bytes_recv().get::<information::byte>()),
UntaggedValue::bytes(nic.bytes_recv().get::<information::byte>()),
);
output.push(network_idx.into_value());
}

7
src/commands/autoview.rs
View file

@ -1,5 +1,4 @@
use crate::commands::{RawCommandArgs, WholeStreamCommand};
use crate::data::value;
use crate::prelude::*;
use futures::stream::TryStreamExt;
use nu_errors::ShellError;
@ -139,7 +138,7 @@ pub fn autoview(
} if anchor.is_some() => {
if let Some(text) = text {
let mut stream = VecDeque::new();
stream.push_back(value::string(s).into_value(Tag { anchor, span }));
stream.push_back(UntaggedValue::string(s).into_value(Tag { anchor, span }));
let result = text.run(raw.with_input(stream.into()), &context.commands);
result.collect::<Vec<_>>().await;
} else {
@ -158,7 +157,7 @@ pub fn autoview(
} if anchor.is_some() => {
if let Some(text) = text {
let mut stream = VecDeque::new();
stream.push_back(value::string(s).into_value(Tag { anchor, span }));
stream.push_back(UntaggedValue::string(s).into_value(Tag { anchor, span }));
let result = text.run(raw.with_input(stream.into()), &context.commands);
result.collect::<Vec<_>>().await;
} else {
@ -227,7 +226,7 @@ pub fn autoview(
// Needed for async_stream to type check
if false {
yield ReturnSuccess::value(value::nothing().into_untagged_value());
yield ReturnSuccess::value(UntaggedValue::nothing().into_untagged_value());
}
}))
}

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

@ -5,7 +5,7 @@ use futures_codec::{Decoder, Encoder, Framed};
use log::trace;
use nu_errors::ShellError;
use nu_parser::ExternalCommand;
use nu_protocol::Value;
use nu_protocol::{UntaggedValue, Value};
use std::io::{Error, ErrorKind};
use subprocess::Exec;
@ -33,14 +33,14 @@ impl Decoder for LinesCodec {
Some(pos) if !src.is_empty() => {
let buf = src.split_to(pos + 1);
String::from_utf8(buf.to_vec())
.map(value::line)
.map(UntaggedValue::line)
.map(Some)
.map_err(|e| Error::new(ErrorKind::InvalidData, e))
}
_ if !src.is_empty() => {
let drained = src.take();
String::from_utf8(drained.to_vec())
.map(value::string)
.map(UntaggedValue::string)
.map(Some)
.map_err(|e| Error::new(ErrorKind::InvalidData, e))
}

4
src/commands/classified/internal.rs
View file

@ -60,7 +60,7 @@ pub(crate) async fn run_internal_command(
} => {
context.shell_manager.insert_at_current(Box::new(
HelpShell::for_command(
value::string(cmd).into_value(tag),
UntaggedValue::string(cmd).into_value(tag),
&context.registry(),
).unwrap(),
));
@ -114,7 +114,7 @@ pub(crate) async fn run_internal_command(
let value = String::from_utf8_lossy(buffer.as_slice());
yield Ok(value::string(value).into_untagged_value())
yield Ok(UntaggedValue::string(value).into_untagged_value())
}
Err(err) => {

4
src/commands/classified/mod.rs
View file

@ -1,5 +1,5 @@
use crate::data::value;
use crate::prelude::*;
use nu_protocol::UntaggedValue;
mod dynamic;
pub(crate) mod external;
@ -17,7 +17,7 @@ pub(crate) struct ClassifiedInputStream {
impl ClassifiedInputStream {
pub(crate) fn new() -> ClassifiedInputStream {
ClassifiedInputStream {
objects: vec![value::nothing().into_value(Tag::unknown())].into(),
objects: vec![UntaggedValue::nothing().into_value(Tag::unknown())].into(),
stdin: None,
}
}

5
src/commands/count.rs
View file

@ -1,10 +1,9 @@
use crate::commands::WholeStreamCommand;
use crate::context::CommandRegistry;
use crate::data::value;
use crate::prelude::*;
use futures::stream::StreamExt;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature, Value};
use nu_protocol::{ReturnSuccess, Signature, UntaggedValue, Value};
pub struct Count;
@ -40,7 +39,7 @@ pub fn count(
let stream = async_stream! {
let rows: Vec<Value> = input.values.collect().await;
yield ReturnSuccess::value(value::int(rows.len()).into_value(name))
yield ReturnSuccess::value(UntaggedValue::int(rows.len()).into_value(name))
};
Ok(stream.to_output_stream())

27
src/commands/date.rs
View file

@ -4,7 +4,6 @@ use nu_errors::ShellError;
use nu_protocol::{Dictionary, Value};
use crate::commands::WholeStreamCommand;
use crate::data::value;
use chrono::{Datelike, TimeZone, Timelike};
use core::fmt::Display;
use indexmap::IndexMap;
@ -42,23 +41,35 @@ where
{
let mut indexmap = IndexMap::new();
indexmap.insert("year".to_string(), value::int(dt.year()).into_value(&tag));
indexmap.insert("month".to_string(), value::int(dt.month()).into_value(&tag));
indexmap.insert("day".to_string(), value::int(dt.day()).into_value(&tag));
indexmap.insert("hour".to_string(), value::int(dt.hour()).into_value(&tag));
indexmap.insert(
"year".to_string(),
UntaggedValue::int(dt.year()).into_value(&tag),
);
indexmap.insert(
"month".to_string(),
UntaggedValue::int(dt.month()).into_value(&tag),
);
indexmap.insert(
"day".to_string(),
UntaggedValue::int(dt.day()).into_value(&tag),
);
indexmap.insert(
"hour".to_string(),
UntaggedValue::int(dt.hour()).into_value(&tag),
);
indexmap.insert(
"minute".to_string(),
value::int(dt.minute()).into_value(&tag),
UntaggedValue::int(dt.minute()).into_value(&tag),
);
indexmap.insert(
"second".to_string(),
value::int(dt.second()).into_value(&tag),
UntaggedValue::int(dt.second()).into_value(&tag),
);
let tz = dt.offset();
indexmap.insert(
"timezone".to_string(),
value::string(format!("{}", tz)).into_value(&tag),
UntaggedValue::string(format!("{}", tz)).into_value(&tag),
);
UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag)

7
src/commands/debug.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature};
use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
pub struct Debug;
@ -37,6 +36,8 @@ fn debug_value(
) -> Result<impl ToOutputStream, ShellError> {
Ok(input
.values
.map(|v| ReturnSuccess::value(value::string(format!("{:?}", v)).into_untagged_value()))
.map(|v| {
ReturnSuccess::value(UntaggedValue::string(format!("{:?}", v)).into_untagged_value())
})
.to_output_stream())
}

3
src/commands/echo.rs
View file

@ -1,4 +1,3 @@
use crate::data::value;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{CallInfo, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
@ -41,7 +40,7 @@ fn run(
match i.as_string() {
Ok(s) => {
output.push(Ok(ReturnSuccess::Value(
value::string(s).into_value(i.tag.clone()),
UntaggedValue::string(s).into_value(i.tag.clone()),
)));
}
_ => match i {

5
src/commands/enter.rs
View file

@ -1,7 +1,6 @@
use crate::commands::PerItemCommand;
use crate::commands::UnevaluatedCallInfo;
use crate::context::CommandRegistry;
use crate::data::value;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{
@ -54,12 +53,12 @@ impl PerItemCommand for Enter {
if registry.has(command) {
Ok(vec![Ok(ReturnSuccess::Action(CommandAction::EnterHelpShell(
value::string(command).into_value(Tag::unknown()),
UntaggedValue::string(command).into_value(Tag::unknown()),
)))]
.into())
} else {
Ok(vec![Ok(ReturnSuccess::Action(CommandAction::EnterHelpShell(
value::nothing().into_value(Tag::unknown()),
UntaggedValue::nothing().into_value(Tag::unknown()),
)))]
.into())
}

32
src/commands/env.rs
View file

@ -1,9 +1,8 @@
use crate::cli::History;
use crate::data::{config, value};
use crate::data::config;
use crate::prelude::*;
use crate::TaggedDictBuilder;
use nu_errors::ShellError;
use nu_protocol::{Dictionary, Signature, UntaggedValue, Value};
use nu_protocol::{Dictionary, Signature, TaggedDictBuilder, UntaggedValue, Value};
use crate::commands::WholeStreamCommand;
use indexmap::IndexMap;
@ -36,24 +35,39 @@ pub fn get_environment(tag: Tag) -> Result<Value, Box<dyn std::error::Error>> {
let mut indexmap = IndexMap::new();
let path = std::env::current_dir()?;
indexmap.insert("cwd".to_string(), value::path(path).into_value(&tag));
indexmap.insert(
"cwd".to_string(),
UntaggedValue::path(path).into_value(&tag),
);
if let Some(home) = dirs::home_dir() {
indexmap.insert("home".to_string(), value::path(home).into_value(&tag));
indexmap.insert(
"home".to_string(),
UntaggedValue::path(home).into_value(&tag),
);
}
let config = config::default_path()?;
indexmap.insert("config".to_string(), value::path(config).into_value(&tag));
indexmap.insert(
"config".to_string(),
UntaggedValue::path(config).into_value(&tag),
);
let history = History::path();
indexmap.insert("history".to_string(), value::path(history).into_value(&tag));
indexmap.insert(
"history".to_string(),
UntaggedValue::path(history).into_value(&tag),
);
let temp = std::env::temp_dir();
indexmap.insert("temp".to_string(), value::path(temp).into_value(&tag));
indexmap.insert(
"temp".to_string(),
UntaggedValue::path(temp).into_value(&tag),
);
let mut dict = TaggedDictBuilder::new(&tag);
for v in std::env::vars() {
dict.insert_untagged(v.0, value::string(v.1));
dict.insert_untagged(v.0, UntaggedValue::string(v.1));
}
if !dict.is_empty() {
indexmap.insert("vars".to_string(), dict.into_value());

13
src/commands/evaluate_by.rs
View file

@ -1,5 +1,4 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
@ -73,7 +72,7 @@ pub fn evaluate_by(
fn fetch(key: Option<String>) -> Box<dyn Fn(Value, Tag) -> Option<Value> + 'static> {
Box::new(move |value: Value, tag| match &key {
Some(key_given) => value.get_data_by_key(key_given[..].spanned(tag.span)),
None => Some(value::int(1).into_value(tag)),
None => Some(UntaggedValue::int(1).into_value(tag)),
})
}
@ -145,19 +144,19 @@ mod tests {
use nu_source::TaggedItem;
fn int(s: impl Into<BigInt>) -> Value {
value::int(s).into_untagged_value()
UntaggedValue::int(s).into_untagged_value()
}
fn string(input: impl Into<String>) -> Value {
value::string(input.into()).into_untagged_value()
UntaggedValue::string(input.into()).into_untagged_value()
}
fn row(entries: IndexMap<String, Value>) -> Value {
value::row(entries).into_untagged_value()
UntaggedValue::row(entries).into_untagged_value()
}
fn table(list: &Vec<Value>) -> Value {
value::table(list).into_untagged_value()
UntaggedValue::table(list).into_untagged_value()
}
fn nu_releases_sorted_by_date() -> Value {
@ -225,7 +224,7 @@ mod tests {
assert_eq!(
evaluator(subject, Tag::unknown()),
Some(value::int(1).into_untagged_value())
Some(UntaggedValue::int(1).into_untagged_value())
);
}

22
src/commands/fetch.rs
View file

@ -1,5 +1,4 @@
use crate::commands::UnevaluatedCallInfo;
use crate::data::value;
use crate::prelude::*;
use mime::Mime;
use nu_errors::ShellError;
@ -146,7 +145,7 @@ pub async fn fetch(
match (content_type.type_(), content_type.subtype()) {
(mime::APPLICATION, mime::XML) => Ok((
Some("xml".to_string()),
value::string(r.body_string().await.map_err(|_| {
UntaggedValue::string(r.body_string().await.map_err(|_| {
ShellError::labeled_error(
"Could not load text from remote url",
"could not load",
@ -160,7 +159,7 @@ pub async fn fetch(
)),
(mime::APPLICATION, mime::JSON) => Ok((
Some("json".to_string()),
value::string(r.body_string().await.map_err(|_| {
UntaggedValue::string(r.body_string().await.map_err(|_| {
ShellError::labeled_error(
"Could not load text from remote url",
"could not load",
@ -182,7 +181,7 @@ pub async fn fetch(
})?;
Ok((
None,
value::binary(buf),
UntaggedValue::binary(buf),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
@ -191,7 +190,7 @@ pub async fn fetch(
}
(mime::IMAGE, mime::SVG) => Ok((
Some("svg".to_string()),
value::string(r.body_string().await.map_err(|_| {
UntaggedValue::string(r.body_string().await.map_err(|_| {
ShellError::labeled_error(
"Could not load svg from remote url",
"could not load",
@ -213,7 +212,7 @@ pub async fn fetch(
})?;
Ok((
Some(image_ty.to_string()),
value::binary(buf),
UntaggedValue::binary(buf),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
@ -222,7 +221,7 @@ pub async fn fetch(
}
(mime::TEXT, mime::HTML) => Ok((
Some("html".to_string()),
value::string(r.body_string().await.map_err(|_| {
UntaggedValue::string(r.body_string().await.map_err(|_| {
ShellError::labeled_error(
"Could not load text from remote url",
"could not load",
@ -248,7 +247,7 @@ pub async fn fetch(
Ok((
path_extension,
value::string(r.body_string().await.map_err(|_| {
UntaggedValue::string(r.body_string().await.map_err(|_| {
ShellError::labeled_error(
"Could not load text from remote url",
"could not load",
@ -263,7 +262,10 @@ pub async fn fetch(
}
(ty, sub_ty) => Ok((
None,
value::string(format!("Not yet supported MIME type: {} {}", ty, sub_ty)),
UntaggedValue::string(format!(
"Not yet supported MIME type: {} {}",
ty, sub_ty
)),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
@ -273,7 +275,7 @@ pub async fn fetch(
}
None => Ok((
None,
value::string(format!("No content type found")),
UntaggedValue::string(format!("No content type found")),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),

15
src/commands/from_bson.rs
View file

@ -1,10 +1,8 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use bson::{decode_document, spec::BinarySubtype, Bson};
use nu_errors::{ExpectedRange, ShellError};
use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
use nu_source::SpannedItem;
use std::str::FromStr;
@ -74,8 +72,8 @@ fn convert_bson_value_to_nu_value(v: &Bson, tag: impl Into<Tag>) -> Result<Value
);
collected.into_value()
}
Bson::I32(n) => value::number(n).into_value(&tag),
Bson::I64(n) => value::number(n).into_value(&tag),
Bson::I32(n) => UntaggedValue::int(*n).into_value(&tag),
Bson::I64(n) => UntaggedValue::int(*n).into_value(&tag),
Bson::Decimal128(n) => {
// TODO: this really isn't great, and we should update this to do a higher
// fidelity translation
@ -110,7 +108,10 @@ fn convert_bson_value_to_nu_value(v: &Bson, tag: impl Into<Tag>) -> Result<Value
}
Bson::TimeStamp(ts) => {
let mut collected = TaggedDictBuilder::new(tag.clone());
collected.insert_value("$timestamp".to_string(), value::number(ts).into_value(&tag));
collected.insert_value(
"$timestamp".to_string(),
UntaggedValue::int(*ts).into_value(&tag),
);
collected.into_value()
}
Bson::Binary(bst, bytes) => {
@ -118,7 +119,7 @@ fn convert_bson_value_to_nu_value(v: &Bson, tag: impl Into<Tag>) -> Result<Value
collected.insert_value(
"$binary_subtype".to_string(),
match bst {
BinarySubtype::UserDefined(u) => value::number(u),
BinarySubtype::UserDefined(u) => UntaggedValue::int(*u),
_ => {
UntaggedValue::Primitive(Primitive::String(binary_subtype_to_string(*bst)))
}

3
src/commands/from_delimited_data.rs
View file

@ -1,8 +1,7 @@
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use csv::ReaderBuilder;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, TaggedDictBuilder, UntaggedValue, Value};
fn from_delimited_string_to_value(
s: String,

3
src/commands/from_ini.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
use std::collections::HashMap;
pub struct FromINI;

11
src/commands/from_json.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::{value, TaggedDictBuilder};
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
pub struct FromJSON;
@ -38,10 +37,10 @@ fn convert_json_value_to_nu_value(v: &serde_hjson::Value, tag: impl Into<Tag>) -
match v {
serde_hjson::Value::Null => UntaggedValue::Primitive(Primitive::Nothing).into_value(&tag),
serde_hjson::Value::Bool(b) => value::boolean(*b).into_value(&tag),
serde_hjson::Value::F64(n) => value::number(n).into_value(&tag),
serde_hjson::Value::U64(n) => value::number(n).into_value(&tag),
serde_hjson::Value::I64(n) => value::number(n).into_value(&tag),
serde_hjson::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(&tag),
serde_hjson::Value::F64(n) => UntaggedValue::decimal(*n).into_value(&tag),
serde_hjson::Value::U64(n) => UntaggedValue::int(*n).into_value(&tag),
serde_hjson::Value::I64(n) => UntaggedValue::int(*n).into_value(&tag),
serde_hjson::Value::String(s) => {
UntaggedValue::Primitive(Primitive::String(String::from(s))).into_value(&tag)
}

9
src/commands/from_sqlite.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::{value, TaggedDictBuilder};
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
use rusqlite::{types::ValueRef, Connection, Row, NO_PARAMS};
use std::io::Write;
use std::path::Path;
@ -106,14 +105,14 @@ fn convert_sqlite_value_to_nu_value(value: ValueRef, tag: impl Into<Tag> + Clone
ValueRef::Null => {
UntaggedValue::Primitive(Primitive::String(String::from(""))).into_value(tag)
}
ValueRef::Integer(i) => value::number(i).into_value(tag),
ValueRef::Real(f) => value::number(f).into_value(tag),
ValueRef::Integer(i) => UntaggedValue::int(i).into_value(tag),
ValueRef::Real(f) => UntaggedValue::decimal(f).into_value(tag),
t @ ValueRef::Text(_) => {
// this unwrap is safe because we know the ValueRef is Text.
UntaggedValue::Primitive(Primitive::String(t.as_str().unwrap().to_string()))
.into_value(tag)
}
ValueRef::Blob(u) => value::binary(u.to_owned()).into_value(tag),
ValueRef::Blob(u) => UntaggedValue::binary(u.to_owned()).into_value(tag),
}
}

5
src/commands/from_ssv.rs
View file

@ -1,8 +1,9 @@
use crate::commands::WholeStreamCommand;
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
use nu_protocol::{
Primitive, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
};
use nu_source::Tagged;
pub struct FromSSV;

9
src/commands/from_toml.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::{value, TaggedDictBuilder};
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
pub struct FromTOML;
@ -32,9 +31,9 @@ pub fn convert_toml_value_to_nu_value(v: &toml::Value, tag: impl Into<Tag>) -> V
let tag = tag.into();
match v {
toml::Value::Boolean(b) => value::boolean(*b).into_value(tag),
toml::Value::Integer(n) => value::number(n).into_value(tag),
toml::Value::Float(n) => value::number(n).into_value(tag),
toml::Value::Boolean(b) => UntaggedValue::boolean(*b).into_value(tag),
toml::Value::Integer(n) => UntaggedValue::int(*n).into_value(tag),
toml::Value::Float(n) => UntaggedValue::decimal(*n).into_value(tag),
toml::Value::String(s) => {
UntaggedValue::Primitive(Primitive::String(String::from(s))).into_value(tag)
}

6
src/commands/from_url.rs
View file

@ -1,9 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature, Value};
use nu_protocol::{ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
pub struct FromURL;
@ -64,7 +62,7 @@ fn from_url(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStrea
let mut row = TaggedDictBuilder::new(tag);
for (k,v) in result {
row.insert_untagged(k, value::string(v));
row.insert_untagged(k, UntaggedValue::string(v));
}
yield ReturnSuccess::value(row.into_value());

17
src/commands/from_xlsx.rs
View file

@ -1,10 +1,9 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::prelude::*;
use crate::{TaggedDictBuilder, TaggedListBuilder};
use crate::TaggedListBuilder;
use calamine::*;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
use std::io::Cursor;
pub struct FromXLSX;
@ -71,12 +70,12 @@ fn from_xlsx(
let mut row_output = TaggedDictBuilder::new(&tag);
for (i, cell) in row.iter().enumerate() {
let value = match cell {
DataType::Empty => value::nothing(),
DataType::String(s) => value::string(s),
DataType::Float(f) => value::decimal(*f),
DataType::Int(i) => value::int(*i),
DataType::Bool(b) => value::boolean(*b),
_ => value::nothing(),
DataType::Empty => UntaggedValue::nothing(),
DataType::String(s) => UntaggedValue::string(s),
DataType::Float(f) => UntaggedValue::decimal(*f),
DataType::Int(i) => UntaggedValue::int(*i),
DataType::Bool(b) => UntaggedValue::boolean(*b),
_ => UntaggedValue::nothing(),
};
row_output.insert_untagged(&format!("Column{}", i), value);

20
src/commands/from_xml.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::{value, TaggedDictBuilder};
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
pub struct FromXML;
@ -61,13 +60,13 @@ fn from_node_to_value<'a, 'd>(n: &roxmltree::Node<'a, 'd>, tag: impl Into<Tag>)
collected.into_value()
} else if n.is_comment() {
value::string("<comment>").into_value(tag)
UntaggedValue::string("<comment>").into_value(tag)
} else if n.is_pi() {
value::string("<processing_instruction>").into_value(tag)
UntaggedValue::string("<processing_instruction>").into_value(tag)
} else if n.is_text() {
value::string(n.text().unwrap()).into_value(tag)
UntaggedValue::string(n.text().unwrap()).into_value(tag)
} else {
value::string("<unknown>").into_value(tag)
UntaggedValue::string("<unknown>").into_value(tag)
}
}
@ -138,21 +137,20 @@ fn from_xml(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStrea
mod tests {
use crate::commands::from_xml;
use crate::data::value;
use indexmap::IndexMap;
use nu_protocol::Value;
use nu_protocol::{UntaggedValue, Value};
use nu_source::*;
fn string(input: impl Into<String>) -> Value {
value::string(input.into()).into_untagged_value()
UntaggedValue::string(input.into()).into_untagged_value()
}
fn row(entries: IndexMap<String, Value>) -> Value {
value::row(entries).into_untagged_value()
UntaggedValue::row(entries).into_untagged_value()
}
fn table(list: &Vec<Value>) -> Value {
value::table(list).into_untagged_value()
UntaggedValue::table(list).into_untagged_value()
}
fn parse(xml: &str) -> Value {

11
src/commands/from_yaml.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::{value, TaggedDictBuilder};
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
pub struct FromYAML;
@ -56,14 +55,14 @@ fn convert_yaml_value_to_nu_value(v: &serde_yaml::Value, tag: impl Into<Tag>) ->
let tag = tag.into();
match v {
serde_yaml::Value::Bool(b) => value::boolean(*b).into_value(tag),
serde_yaml::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(tag),
serde_yaml::Value::Number(n) if n.is_i64() => {
value::number(n.as_i64().unwrap()).into_value(tag)
UntaggedValue::int(n.as_i64().unwrap()).into_value(tag)
}
serde_yaml::Value::Number(n) if n.is_f64() => {
UntaggedValue::Primitive(Primitive::from(n.as_f64().unwrap())).into_value(tag)
UntaggedValue::decimal(n.as_f64().unwrap()).into_value(tag)
}
serde_yaml::Value::String(s) => value::string(s).into_value(tag),
serde_yaml::Value::String(s) => UntaggedValue::string(s).into_value(tag),
serde_yaml::Value::Sequence(a) => UntaggedValue::Table(
a.iter()
.map(|x| convert_yaml_value_to_nu_value(x, &tag))

14
src/commands/group_by.rs
View file

@ -1,9 +1,8 @@
use crate::commands::WholeStreamCommand;
use crate::data::base::property_get::get_data_by_key;
use crate::data::{value, TaggedDictBuilder};
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, Value};
use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value};
use nu_source::Tagged;
pub struct GroupBy;
@ -108,7 +107,7 @@ pub fn group(
let mut out = TaggedDictBuilder::new(&tag);
for (k, v) in groups.iter() {
out.insert_untagged(k, value::table(v));
out.insert_untagged(k, UntaggedValue::table(v));
}
Ok(out.into_value())
@ -117,21 +116,20 @@ pub fn group(
#[cfg(test)]
mod tests {
use crate::commands::group_by::group;
use crate::data::value;
use indexmap::IndexMap;
use nu_protocol::Value;
use nu_protocol::{UntaggedValue, Value};
use nu_source::*;
fn string(input: impl Into<String>) -> Value {
value::string(input.into()).into_untagged_value()
UntaggedValue::string(input.into()).into_untagged_value()
}
fn row(entries: IndexMap<String, Value>) -> Value {
value::row(entries).into_untagged_value()
UntaggedValue::row(entries).into_untagged_value()
}
fn table(list: &Vec<Value>) -> Value {
value::table(list).into_untagged_value()
UntaggedValue::table(list).into_untagged_value()
}
fn nu_releases_commiters() -> Vec<Value> {

10
src/commands/help.rs
View file

@ -1,11 +1,11 @@
use crate::commands::PerItemCommand;
use crate::data::base::property_get::get_data_by_key;
use crate::data::{command_dict, TaggedDictBuilder};
use crate::data::command_dict;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{
CallInfo, NamedType, PositionalType, Primitive, ReturnSuccess, Signature, SyntaxShape,
UntaggedValue, Value,
TaggedDictBuilder, UntaggedValue, Value,
};
use nu_source::SpannedItem;
@ -152,7 +152,7 @@ impl PerItemCommand for Help {
}
help.push_back(ReturnSuccess::value(
value::string(long_desc).into_value(tag.clone()),
UntaggedValue::string(long_desc).into_value(tag.clone()),
));
}
}
@ -170,7 +170,9 @@ You can also learn more at https://book.nushell.sh"#;
let mut output_stream = VecDeque::new();
output_stream.push_back(ReturnSuccess::value(value::string(msg).into_value(tag)));
output_stream.push_back(ReturnSuccess::value(
UntaggedValue::string(msg).into_value(tag),
));
Ok(output_stream.to_output_stream())
}

13
src/commands/histogram.rs
View file

@ -5,10 +5,11 @@ use crate::commands::reduce_by::reduce;
use crate::commands::t_sort_by::columns_sorted;
use crate::commands::t_sort_by::t_sort;
use crate::commands::WholeStreamCommand;
use crate::data::{value, TaggedDictBuilder};
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
use nu_protocol::{
Primitive, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
};
use nu_source::Tagged;
use num_traits::cast::ToPrimitive;
@ -91,11 +92,11 @@ pub fn histogram(
let mut fact = TaggedDictBuilder::new(&name);
let value: Tagged<String> = group_labels.get(idx).unwrap().clone();
fact.insert_value(&column, value::string(value.item).into_value(value.tag));
fact.insert_value(&column, UntaggedValue::string(value.item).into_value(value.tag));
if let Value { value: UntaggedValue::Primitive(Primitive::Int(ref num)), .. } = percentage.clone() {
let string = std::iter::repeat("*").take(num.to_i32().unwrap() as usize).collect::<String>();
fact.insert_untagged(&frequency_column_name, value::string(string));
fact.insert_untagged(&frequency_column_name, UntaggedValue::string(string));
}
idx = idx + 1;
@ -146,9 +147,9 @@ fn percentages(values: &Value, max: Value, tag: impl Into<Tag>) -> Result<Value,
let n = { n.to_i32().unwrap() * 100 / max };
value::number(n).into_value(&tag)
UntaggedValue::int(n).into_value(&tag)
}
_ => value::number(0).into_value(&tag),
_ => UntaggedValue::int(0).into_value(&tag),
})
.collect::<Vec<_>>();
UntaggedValue::Table(data).into_value(&tag)

5
src/commands/history.rs
View file

@ -1,9 +1,8 @@
use crate::cli::History as HistoryFile;
use crate::commands::PerItemCommand;
use crate::data::value;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{CallInfo, ReturnSuccess, Signature, Value};
use nu_protocol::{CallInfo, ReturnSuccess, Signature, UntaggedValue, Value};
use std::fs::File;
use std::io::{BufRead, BufReader};
@ -38,7 +37,7 @@ impl PerItemCommand for History {
let reader = BufReader::new(file);
for line in reader.lines() {
if let Ok(line) = line {
yield ReturnSuccess::value(value::string(line).into_value(tag.clone()));
yield ReturnSuccess::value(UntaggedValue::string(line).into_value(tag.clone()));
}
}
} else {

14
src/commands/map_max_by.rs
View file

@ -103,9 +103,9 @@ pub fn map_max(
}
_ => acc,
});
value::number(data).into_value(&tag)
UntaggedValue::int(data).into_value(&tag)
}
_ => value::number(0).into_value(&tag),
_ => UntaggedValue::int(0).into_value(&tag),
})
.collect();
@ -122,9 +122,9 @@ pub fn map_max(
}
_ => max,
});
value::number(datasets).into_value(&tag)
UntaggedValue::int(datasets).into_value(&tag)
}
_ => value::number(-1).into_value(&tag),
_ => UntaggedValue::int(-1).into_value(&tag),
};
Ok(results)
@ -144,15 +144,15 @@ mod tests {
use nu_source::*;
fn int(s: impl Into<BigInt>) -> Value {
value::int(s).into_untagged_value()
UntaggedValue::int(s).into_untagged_value()
}
fn string(input: impl Into<String>) -> Value {
value::string(input.into()).into_untagged_value()
UntaggedValue::string(input.into()).into_untagged_value()
}
fn row(entries: IndexMap<String, Value>) -> Value {
value::row(entries).into_untagged_value()
UntaggedValue::row(entries).into_untagged_value()
}
fn nu_releases_evaluated_by_default_one() -> Value {

17
src/commands/open.rs
View file

@ -1,5 +1,4 @@
use crate::commands::UnevaluatedCallInfo;
use crate::data::value;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{CallInfo, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
@ -140,7 +139,7 @@ pub async fn fetch(
Ok(s) => Ok((
cwd.extension()
.map(|name| name.to_string_lossy().to_string()),
value::string(s),
UntaggedValue::string(s),
Tag {
span,
anchor: Some(AnchorLocation::File(cwd.to_string_lossy().to_string())),
@ -158,7 +157,7 @@ pub async fn fetch(
Ok(s) => Ok((
cwd.extension()
.map(|name| name.to_string_lossy().to_string()),
value::string(s),
UntaggedValue::string(s),
Tag {
span,
anchor: Some(AnchorLocation::File(
@ -168,7 +167,7 @@ pub async fn fetch(
)),
Err(_) => Ok((
None,
value::binary(bytes),
UntaggedValue::binary(bytes),
Tag {
span,
anchor: Some(AnchorLocation::File(
@ -180,7 +179,7 @@ pub async fn fetch(
} else {
Ok((
None,
value::binary(bytes),
UntaggedValue::binary(bytes),
Tag {
span,
anchor: Some(AnchorLocation::File(
@ -199,7 +198,7 @@ pub async fn fetch(
Ok(s) => Ok((
cwd.extension()
.map(|name| name.to_string_lossy().to_string()),
value::string(s),
UntaggedValue::string(s),
Tag {
span,
anchor: Some(AnchorLocation::File(
@ -209,7 +208,7 @@ pub async fn fetch(
)),
Err(_) => Ok((
None,
value::binary(bytes),
UntaggedValue::binary(bytes),
Tag {
span,
anchor: Some(AnchorLocation::File(
@ -221,7 +220,7 @@ pub async fn fetch(
} else {
Ok((
None,
value::binary(bytes),
UntaggedValue::binary(bytes),
Tag {
span,
anchor: Some(AnchorLocation::File(
@ -233,7 +232,7 @@ pub async fn fetch(
}
_ => Ok((
None,
value::binary(bytes),
UntaggedValue::binary(bytes),
Tag {
span,
anchor: Some(AnchorLocation::File(

8
src/commands/pivot.rs
View file

@ -1,10 +1,8 @@
use crate::commands::WholeStreamCommand;
use crate::data::base::property_get::get_data_by_key;
use crate::data::value;
use crate::prelude::*;
use crate::TaggedDictBuilder;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, Value};
use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value};
use nu_source::{SpannedItem, Tagged};
pub struct Pivot;
@ -114,7 +112,7 @@ pub fn pivot(args: PivotArgs, context: RunnableContext) -> Result<OutputStream,
let mut dict = TaggedDictBuilder::new(&context.name);
if !args.ignore_titles && !args.header_row {
dict.insert_untagged(headers[column_num].clone(), value::string(desc.clone()));
dict.insert_untagged(headers[column_num].clone(), UntaggedValue::string(desc.clone()));
column_num += 1
}
@ -124,7 +122,7 @@ pub fn pivot(args: PivotArgs, context: RunnableContext) -> Result<OutputStream,
dict.insert_value(headers[column_num].clone(), x.clone());
}
_ => {
dict.insert_untagged(headers[column_num].clone(), value::nothing());
dict.insert_untagged(headers[column_num].clone(), UntaggedValue::nothing());
}
}
column_num += 1;

3
src/commands/plugin.rs
View file

@ -1,5 +1,4 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::prelude::*;
use derive_new::new;
use log::trace;
@ -316,7 +315,7 @@ pub fn sink_plugin(
// Needed for async_stream to type check
if false {
yield ReturnSuccess::value(value::nothing().into_untagged_value());
yield ReturnSuccess::value(UntaggedValue::nothing().into_untagged_value());
}
};
Ok(OutputStream::new(stream))

17
src/commands/post.rs
View file

@ -1,5 +1,4 @@
use crate::commands::UnevaluatedCallInfo;
use crate::data::value;
use crate::prelude::*;
use base64::encode;
use mime::Mime;
@ -320,7 +319,7 @@ pub async fn post(
match (content_type.type_(), content_type.subtype()) {
(mime::APPLICATION, mime::XML) => Ok((
Some("xml".to_string()),
value::string(r.body_string().await.map_err(|_| {
UntaggedValue::string(r.body_string().await.map_err(|_| {
ShellError::labeled_error(
"Could not load text from remote url",
"could not load",
@ -334,7 +333,7 @@ pub async fn post(
)),
(mime::APPLICATION, mime::JSON) => Ok((
Some("json".to_string()),
value::string(r.body_string().await.map_err(|_| {
UntaggedValue::string(r.body_string().await.map_err(|_| {
ShellError::labeled_error(
"Could not load text from remote url",
"could not load",
@ -356,7 +355,7 @@ pub async fn post(
})?;
Ok((
None,
value::binary(buf),
UntaggedValue::binary(buf),
Tag {
anchor: Some(AnchorLocation::Url(location.to_string())),
span: tag.span,
@ -373,7 +372,7 @@ pub async fn post(
})?;
Ok((
Some(image_ty.to_string()),
value::binary(buf),
UntaggedValue::binary(buf),
Tag {
anchor: Some(AnchorLocation::Url(location.to_string())),
span: tag.span,
@ -382,7 +381,7 @@ pub async fn post(
}
(mime::TEXT, mime::HTML) => Ok((
Some("html".to_string()),
value::string(r.body_string().await.map_err(|_| {
UntaggedValue::string(r.body_string().await.map_err(|_| {
ShellError::labeled_error(
"Could not load text from remote url",
"could not load",
@ -408,7 +407,7 @@ pub async fn post(
Ok((
path_extension,
value::string(r.body_string().await.map_err(|_| {
UntaggedValue::string(r.body_string().await.map_err(|_| {
ShellError::labeled_error(
"Could not load text from remote url",
"could not load",
@ -423,7 +422,7 @@ pub async fn post(
}
(ty, sub_ty) => Ok((
None,
value::string(format!(
UntaggedValue::string(format!(
"Not yet supported MIME type: {} {}",
ty, sub_ty
)),
@ -436,7 +435,7 @@ pub async fn post(
}
None => Ok((
None,
value::string(format!("No content type found")),
UntaggedValue::string(format!("No content type found")),
Tag {
anchor: Some(AnchorLocation::Url(location.to_string())),
span: tag.span,

12
src/commands/reduce_by.rs
View file

@ -135,9 +135,9 @@ pub fn reduce(
} = d
{
acc = reduce_with(acc, x.clone());
value::number(acc).into_value(&tag)
UntaggedValue::int(acc).into_value(&tag)
} else {
value::number(0).into_value(&tag)
UntaggedValue::int(0).into_value(&tag)
}
})
.collect::<Vec<_>>();
@ -169,19 +169,19 @@ mod tests {
use nu_source::*;
fn int(s: impl Into<BigInt>) -> Value {
value::int(s).into_untagged_value()
UntaggedValue::int(s).into_untagged_value()
}
fn string(input: impl Into<String>) -> Value {
value::string(input.into()).into_untagged_value()
UntaggedValue::string(input.into()).into_untagged_value()
}
fn row(entries: IndexMap<String, Value>) -> Value {
value::row(entries).into_untagged_value()
UntaggedValue::row(entries).into_untagged_value()
}
fn table(list: &Vec<Value>) -> Value {
value::table(list).into_untagged_value()
UntaggedValue::table(list).into_untagged_value()
}
fn nu_releases_sorted_by_date() -> Value {

3
src/commands/shells.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::Signature;
use nu_protocol::{Signature, TaggedDictBuilder};
use std::sync::atomic::Ordering;
pub struct Shells;

11
src/commands/size.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::{value, TaggedDictBuilder};
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature, Value};
use nu_protocol::{ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
pub struct Size;
@ -79,10 +78,10 @@ fn count(contents: &str, tag: impl Into<Tag>) -> Value {
let mut dict = TaggedDictBuilder::new(tag);
//TODO: add back in name when we have it in the tag
//dict.insert("name", value::string(name));
dict.insert_untagged("lines", value::int(lines));
dict.insert_untagged("words", value::int(words));
dict.insert_untagged("chars", value::int(chars));
dict.insert_untagged("max length", value::int(bytes));
dict.insert_untagged("lines", UntaggedValue::int(lines));
dict.insert_untagged("words", UntaggedValue::int(words));
dict.insert_untagged("chars", UntaggedValue::int(chars));
dict.insert_untagged("max length", UntaggedValue::int(bytes));
dict.into_value()
}

22
src/commands/split_by.rs
View file

@ -1,8 +1,9 @@
use crate::commands::WholeStreamCommand;
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature, SpannedTypeName, SyntaxShape, UntaggedValue, Value};
use nu_protocol::{
ReturnSuccess, Signature, SpannedTypeName, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
};
use nu_source::Tagged;
pub struct SplitBy;
@ -104,7 +105,7 @@ pub fn split(
.or_insert(indexmap::IndexMap::new());
s.insert(
group_key.clone(),
value::table(&subset).into_value(tag),
UntaggedValue::table(&subset).into_value(tag),
);
}
other => {
@ -144,7 +145,7 @@ pub fn split(
let mut out = TaggedDictBuilder::new(&origin_tag);
for (k, v) in splits.into_iter() {
out.insert_untagged(k, value::row(v));
out.insert_untagged(k, UntaggedValue::row(v));
}
Ok(out.into_value())
@ -154,21 +155,20 @@ mod tests {
use crate::commands::group_by::group;
use crate::commands::split_by::split;
use crate::data::value;
use indexmap::IndexMap;
use nu_protocol::Value;
use nu_protocol::{UntaggedValue, Value};
use nu_source::*;
fn string(input: impl Into<String>) -> Value {
value::string(input.into()).into_untagged_value()
UntaggedValue::string(input.into()).into_untagged_value()
}
fn row(entries: IndexMap<String, Value>) -> Value {
value::row(entries).into_untagged_value()
UntaggedValue::row(entries).into_untagged_value()
}
fn table(list: &Vec<Value>) -> Value {
value::table(list).into_untagged_value()
UntaggedValue::table(list).into_untagged_value()
}
fn nu_releases_grouped_by_date() -> Value {
@ -214,7 +214,7 @@ mod tests {
assert_eq!(
split(&for_key, &nu_releases_grouped_by_date(), Tag::unknown()).unwrap(),
value::row(indexmap! {
UntaggedValue::row(indexmap! {
"EC".into() => row(indexmap! {
"August 23-2019".into() => table(&vec![
row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => string("August 23-2019")})
@ -261,7 +261,7 @@ mod tests {
row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => string("August 23-2019")})
]),
"Sept 24-2019".into() => table(&vec![
row(indexmap!{"name".into() => value::string("JT").into_value(Tag::from(Span::new(5,10))), "date".into() => string("Sept 24-2019")})
row(indexmap!{"name".into() => UntaggedValue::string("JT").into_value(Tag::from(Span::new(5,10))), "date".into() => string("Sept 24-2019")})
]),
"October 10-2019".into() => table(&vec![
row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => string("October 10-2019")})

5
src/commands/split_column.rs
View file

@ -1,9 +1,10 @@
use crate::commands::WholeStreamCommand;
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use log::trace;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
use nu_protocol::{
Primitive, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue,
};
use nu_source::Tagged;
#[derive(Deserialize)]

20
src/commands/t_sort_by.rs
View file

@ -1,10 +1,12 @@
use crate::commands::WholeStreamCommand;
use crate::data::base::property_get::get_data_by_key;
use crate::data::{value, TaggedDictBuilder, TaggedListBuilder};
use crate::data::TaggedListBuilder;
use crate::prelude::*;
use chrono::{DateTime, NaiveDate, Utc};
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
use nu_protocol::{
Primitive, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
};
use nu_source::Tagged;
pub struct TSortBy;
@ -70,7 +72,7 @@ fn t_sort_by(
if show_columns {
for label in columns_sorted(column_grouped_by_name, &values[0], &name).into_iter() {
yield ReturnSuccess::value(value::string(label.item).into_value(label.tag));
yield ReturnSuccess::value(UntaggedValue::string(label.item).into_value(label.tag));
}
} else {
match t_sort(column_grouped_by_name, None, &values[0], name) {
@ -104,7 +106,7 @@ pub fn columns_sorted(
Ok(parsed) => UntaggedValue::Primitive(Primitive::Date(
DateTime::<Utc>::from_utc(parsed.and_hms(12, 34, 56), Utc),
)),
Err(_) => value::string(k),
Err(_) => UntaggedValue::string(k),
};
date.into_untagged_value()
@ -197,10 +199,10 @@ pub fn t_sort(
return Ok(UntaggedValue::Table(outer.list).into_value(&origin_tag));
}
Some(_) => return Ok(value::nothing().into_value(&origin_tag)),
Some(_) => return Ok(UntaggedValue::nothing().into_value(&origin_tag)),
}
}
None => return Ok(value::nothing().into_value(&origin_tag)),
None => return Ok(UntaggedValue::nothing().into_value(&origin_tag)),
}
}
#[cfg(test)]
@ -214,15 +216,15 @@ mod tests {
use nu_source::*;
fn string(input: impl Into<String>) -> Value {
value::string(input.into()).into_untagged_value()
UntaggedValue::string(input.into()).into_untagged_value()
}
fn row(entries: IndexMap<String, Value>) -> Value {
value::row(entries).into_untagged_value()
UntaggedValue::row(entries).into_untagged_value()
}
fn table(list: &Vec<Value>) -> Value {
value::table(list).into_untagged_value()
UntaggedValue::table(list).into_untagged_value()
}
fn nu_releases_grouped_by_date() -> Value {

3
src/commands/table.rs
View file

@ -1,5 +1,4 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::format::TableView;
use crate::prelude::*;
use nu_errors::ShellError;
@ -58,7 +57,7 @@ fn table(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream,
}
// Needed for async_stream to type check
if false {
yield ReturnSuccess::value(value::nothing().into_value(Tag::unknown()));
yield ReturnSuccess::value(UntaggedValue::nothing().into_value(Tag::unknown()));
}
};

11
src/commands/tags.rs
View file

@ -1,8 +1,7 @@
use crate::commands::WholeStreamCommand;
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::Signature;
use nu_protocol::{Signature, TaggedDictBuilder, UntaggedValue};
pub struct Tags;
@ -38,16 +37,16 @@ fn tags(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream,
let anchor = v.anchor();
let span = v.tag.span;
let mut dict = TaggedDictBuilder::new(v.tag());
dict.insert_untagged("start", value::int(span.start() as i64));
dict.insert_untagged("end", value::int(span.end() as i64));
dict.insert_untagged("start", UntaggedValue::int(span.start() as i64));
dict.insert_untagged("end", UntaggedValue::int(span.end() as i64));
tags.insert_value("span", dict.into_value());
match anchor {
Some(AnchorLocation::File(source)) => {
tags.insert_untagged("anchor", value::string(source));
tags.insert_untagged("anchor", UntaggedValue::string(source));
}
Some(AnchorLocation::Url(source)) => {
tags.insert_untagged("anchor", value::string(source));
tags.insert_untagged("anchor", UntaggedValue::string(source));
}
_ => {}
}

3
src/commands/to_bson.rs
View file

@ -1,5 +1,4 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::prelude::*;
use bson::{encode_document, oid::ObjectId, spec::BinarySubtype, Bson, Document};
use nu_errors::{CoerceInto, ShellError};
@ -274,7 +273,7 @@ fn to_bson(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream
match bson_value_to_bytes(bson_value, name_tag.clone()) {
Ok(x) => yield ReturnSuccess::value(
value::binary(x).into_value(&name_tag),
UntaggedValue::binary(x).into_value(&name_tag),
),
_ => yield Err(ShellError::labeled_error_with_secondary(
"Expected a table with BSON-compatible structure.tag() from pipeline",

2
src/commands/to_sqlite.rs
View file

@ -197,7 +197,7 @@ fn sqlite_input_stream_to_bytes(values: Vec<Value>) -> Result<Value, std::io::Er
}
let mut out = Vec::new();
tempfile.read_to_end(&mut out)?;
Ok(value::binary(out).into_value(tag))
Ok(UntaggedValue::binary(out).into_value(tag))
}
fn to_sqlite(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {

3
src/commands/to_url.rs
View file

@ -1,5 +1,4 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature, UntaggedValue, Value};
@ -59,7 +58,7 @@ fn to_url(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream,
match serde_urlencoded::to_string(row_vec) {
Ok(s) => {
yield ReturnSuccess::value(value::string(s).into_value(&tag));
yield ReturnSuccess::value(UntaggedValue::string(s).into_value(&tag));
}
_ => {
yield Err(ShellError::labeled_error(

4
src/commands/trim.rs
View file

@ -2,7 +2,7 @@ use crate::commands::WholeStreamCommand;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, Signature};
use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
pub struct Trim;
@ -35,7 +35,7 @@ fn trim(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream,
.values
.map(move |v| {
let string = String::extract(&v)?;
ReturnSuccess::value(value::string(string.trim()).into_value(v.tag()))
ReturnSuccess::value(UntaggedValue::string(string.trim()).into_value(v.tag()))
})
.to_output_stream())
}

2
src/commands/version.rs
View file

@ -35,7 +35,7 @@ pub fn date(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStrea
let mut indexmap = IndexMap::new();
indexmap.insert(
"version".to_string(),
value::string(clap::crate_version!()).into_value(&tag),
UntaggedValue::string(clap::crate_version!()).into_value(&tag),
);
let value = UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag);

5
src/commands/what.rs
View file

@ -1,11 +1,10 @@
use crate::commands::WholeStreamCommand;
use crate::data::value;
use crate::prelude::*;
use futures::StreamExt;
use futures_util::pin_mut;
use nu_errors::ShellError;
use nu_protocol::{ReturnSuccess, ReturnValue, Signature};
use nu_protocol::{ReturnSuccess, ReturnValue, Signature, UntaggedValue};
use nu_source::PrettyDebug;
pub struct What;
@ -45,7 +44,7 @@ pub fn what(
while let Some(row) = values.next().await {
let name = value::format_leaf(&row).plain_string(100000);
yield ReturnSuccess::value(value::string(name).into_value(Tag::unknown_anchor(row.tag.span)));
yield ReturnSuccess::value(UntaggedValue::string(name).into_value(Tag::unknown_anchor(row.tag.span)));
}
};

2
src/data.rs
View file

@ -8,5 +8,5 @@ pub(crate) mod types;
pub mod value;
pub(crate) use command::command_dict;
pub(crate) use dict::{TaggedDictBuilder, TaggedListBuilder};
pub(crate) use dict::TaggedListBuilder;
pub(crate) use files::dir_entry_dict;

43
src/data/base.rs
View file

@ -3,7 +3,6 @@ pub(crate) mod shape;
use crate::context::CommandRegistry;
use crate::data::base::property_get::ValueExt;
use crate::data::{value, TaggedDictBuilder};
use crate::evaluate::evaluate_baseline_expr;
use bigdecimal::BigDecimal;
use chrono::{DateTime, Utc};
@ -12,7 +11,8 @@ use log::trace;
use nu_errors::ShellError;
use nu_parser::{hir, Operator};
use nu_protocol::{
Evaluate, EvaluateTrait, Primitive, Scope, ShellTypeName, SpannedTypeName, UntaggedValue, Value,
Evaluate, EvaluateTrait, Primitive, Scope, ShellTypeName, SpannedTypeName, TaggedDictBuilder,
UntaggedValue, Value,
};
use nu_source::{Tag, Text};
use num_bigint::BigInt;
@ -41,7 +41,7 @@ interfaces!(Block: dyn ObjectHash);
impl EvaluateTrait for Block {
fn invoke(&self, scope: &Scope) -> Result<Value, ShellError> {
if self.expressions.len() == 0 {
return Ok(value::nothing().into_value(&self.tag));
return Ok(UntaggedValue::nothing().into_value(&self.tag));
}
let mut last = None;
@ -99,7 +99,7 @@ pub(crate) fn select_fields(obj: &Value, fields: &[String], tag: impl Into<Tag>)
for field in fields {
match descs.iter().find(|d| *d == field) {
None => out.insert_untagged(field, value::nothing()),
None => out.insert_untagged(field, UntaggedValue::nothing()),
Some(desc) => out.insert_value(desc.clone(), obj.get_data(desc).borrow().clone()),
}
}
@ -196,28 +196,27 @@ fn coerce_compare_primitive(
}
#[cfg(test)]
mod tests {
use super::value;
use crate::data::base::property_get::{as_column_path, ValueExt};
use indexmap::IndexMap;
use nu_errors::ShellError;
use nu_protocol::{ColumnPath as ColumnPathValue, PathMember, Value};
use nu_protocol::{ColumnPath as ColumnPathValue, PathMember, UntaggedValue, Value};
use nu_source::*;
use num_bigint::BigInt;
fn string(input: impl Into<String>) -> Value {
value::string(input.into()).into_untagged_value()
UntaggedValue::string(input.into()).into_untagged_value()
}
fn int(input: impl Into<BigInt>) -> Value {
value::int(input.into()).into_untagged_value()
UntaggedValue::int(input.into()).into_untagged_value()
}
fn row(entries: IndexMap<String, Value>) -> Value {
value::row(entries).into_untagged_value()
UntaggedValue::row(entries).into_untagged_value()
}
fn table(list: &Vec<Value>) -> Value {
value::table(list).into_untagged_value()
UntaggedValue::table(list).into_untagged_value()
}
fn error_callback(
@ -232,7 +231,7 @@ mod tests {
#[test]
fn gets_matching_field_from_a_row() {
let row = value::row(indexmap! {
let row = UntaggedValue::row(indexmap! {
"amigos".into() => table(&vec![string("andres"),string("jonathan"),string("yehuda")])
})
.into_untagged_value();
@ -253,7 +252,7 @@ mod tests {
let (version, tag) = string("0.4.0").into_parts();
let value = value::row(indexmap! {
let value = UntaggedValue::row(indexmap! {
"package".into() =>
row(indexmap! {
"name".into() => string("nu"),
@ -276,7 +275,7 @@ mod tests {
let (_, tag) = string("Andrés N. Robalino").into_parts();
let value = value::row(indexmap! {
let value = UntaggedValue::row(indexmap! {
"package".into() => row(indexmap! {
"name".into() => string("nu"),
"version".into() => string("0.4.0"),
@ -310,7 +309,7 @@ mod tests {
let (_, tag) = string("Andrés N. Robalino").into_parts();
let value = value::row(indexmap! {
let value = UntaggedValue::row(indexmap! {
"package".into() => row(indexmap! {
"name".into() => string("nu"),
"version".into() => string("0.4.0"),
@ -327,7 +326,7 @@ mod tests {
.into_value(tag)
.get_data_by_column_path(&field_path, Box::new(error_callback("package.authors.0")))
.unwrap(),
value::row(indexmap! {
UntaggedValue::row(indexmap! {
"name".into() => string("Andrés N. Robalino")
})
);
@ -339,7 +338,7 @@ mod tests {
let (_, tag) = string("Andrés N. Robalino").into_parts();
let value = value::row(indexmap! {
let value = UntaggedValue::row(indexmap! {
"package".into() => row(indexmap! {
"name".into() => string("nu"),
"version".into() => string("0.4.0"),
@ -359,7 +358,7 @@ mod tests {
Box::new(error_callback("package.authors.\"0\""))
)
.unwrap(),
value::row(indexmap! {
UntaggedValue::row(indexmap! {
"name".into() => string("Andrés N. Robalino")
})
);
@ -369,7 +368,7 @@ mod tests {
fn replaces_matching_field_from_a_row() {
let field_path = column_path(&vec![string("amigos")]);
let sample = value::row(indexmap! {
let sample = UntaggedValue::row(indexmap! {
"amigos".into() => table(&vec![
string("andres"),
string("jonathan"),
@ -395,7 +394,7 @@ mod tests {
string("los.3.caballeros"),
]);
let sample = value::row(indexmap! {
let sample = UntaggedValue::row(indexmap! {
"package".into() => row(indexmap! {
"authors".into() => row(indexmap! {
"los.3.mosqueteros".into() => table(&vec![string("andres::yehuda::jonathan")]),
@ -415,7 +414,7 @@ mod tests {
assert_eq!(
actual,
value::row(indexmap! {
UntaggedValue::row(indexmap! {
"package".into() => row(indexmap! {
"authors".into() => row(indexmap! {
"los.3.mosqueteros".into() => table(&vec![string("andres::yehuda::jonathan")]),
@ -432,7 +431,7 @@ mod tests {
string("nu.version.arepa"),
]);
let sample = value::row(indexmap! {
let sample = UntaggedValue::row(indexmap! {
"shell_policy".into() => row(indexmap! {
"releases".into() => table(&vec![
row(indexmap! {
@ -467,7 +466,7 @@ mod tests {
assert_eq!(
actual,
value::row(indexmap! {
UntaggedValue::row(indexmap! {
"shell_policy".into() => row(indexmap! {
"releases".into() => table(&vec![
row(indexmap! {

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

@ -1,4 +1,3 @@
use crate::data::value;
use crate::prelude::*;
use nu_errors::{ExpectedRange, ShellError};
use nu_protocol::{
@ -436,7 +435,7 @@ pub fn get_data<'value>(value: &'value Value, desc: &String) -> MaybeOwned<'valu
UntaggedValue::Primitive(_) => MaybeOwned::Borrowed(value),
UntaggedValue::Row(o) => o.get_data(desc),
UntaggedValue::Block(_) | UntaggedValue::Table(_) | UntaggedValue::Error(_) => {
MaybeOwned::Owned(value::nothing().into_untagged_value())
MaybeOwned::Owned(UntaggedValue::nothing().into_untagged_value())
}
}
}
@ -468,9 +467,9 @@ pub(crate) fn get_data_by_key(value: &Value, name: Spanned<&str>) -> Option<Valu
..
} => match o.get_data_by_key(name) {
Some(v) => out.push(v),
None => out.push(value::nothing().into_untagged_value()),
None => out.push(UntaggedValue::nothing().into_untagged_value()),
},
_ => out.push(value::nothing().into_untagged_value()),
_ => out.push(UntaggedValue::nothing().into_untagged_value()),
}
}

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

@ -6,7 +6,8 @@ use derive_new::new;
use indexmap::IndexMap;
use nu_errors::ShellError;
use nu_protocol::{
ColumnPath, Dictionary, Evaluate, Primitive, ShellTypeName, UntaggedValue, Value,
ColumnPath, Dictionary, Evaluate, Primitive, ShellTypeName, TaggedDictBuilder, UntaggedValue,
Value,
};
use nu_source::{b, DebugDoc, PrettyDebug};
use std::collections::BTreeMap;
@ -535,7 +536,7 @@ impl Shape {
.expect("Writing into a Vec can't fail");
let string = String::from_utf8_lossy(&out);
value::string(string).into_untagged_value()
UntaggedValue::string(string).into_untagged_value()
}
}
@ -563,20 +564,22 @@ impl Shapes {
if self.shapes.len() == 1 {
let shape = self.shapes.keys().nth(0).unwrap();
vec![dict! {
"type" => shape.to_value(),
"rows" => value::string("all")
}]
let mut tagged_dict = TaggedDictBuilder::new(Tag::unknown());
tagged_dict.insert_untagged("type", shape.to_value());
tagged_dict.insert_untagged("rows", UntaggedValue::string("all"));
vec![tagged_dict.into_value()]
} else {
self.shapes
.iter()
.map(|(shape, rows)| {
let rows = rows.iter().map(|i| i.to_string()).join(", ");
dict! {
"type" => shape.to_value(),
"rows" => value::string(format!("[ {} ]", rows))
}
let mut tagged_dict = TaggedDictBuilder::new(Tag::unknown());
tagged_dict.insert_untagged("type", shape.to_value());
tagged_dict
.insert_untagged("rows", UntaggedValue::string(format!("[ {} ]", rows)));
tagged_dict.into_value()
})
.collect()
}

16
src/data/command.rs
View file

@ -1,7 +1,7 @@
use crate::commands::command::Command;
use crate::data::{TaggedDictBuilder, TaggedListBuilder};
use crate::data::TaggedListBuilder;
use crate::prelude::*;
use nu_protocol::{NamedType, PositionalType, Signature, Value};
use nu_protocol::{NamedType, PositionalType, Signature, TaggedDictBuilder, UntaggedValue, Value};
use std::ops::Deref;
pub(crate) fn command_dict(command: Arc<Command>, tag: impl Into<Tag>) -> Value {
@ -9,18 +9,18 @@ pub(crate) fn command_dict(command: Arc<Command>, tag: impl Into<Tag>) -> Value
let mut cmd_dict = TaggedDictBuilder::new(&tag);
cmd_dict.insert_untagged("name", value::string(command.name()));
cmd_dict.insert_untagged("name", UntaggedValue::string(command.name()));
cmd_dict.insert_untagged(
"type",
value::string(match command.deref() {
UntaggedValue::string(match command.deref() {
Command::WholeStream(_) => "Command",
Command::PerItem(_) => "Filter",
}),
);
cmd_dict.insert_value("signature", signature_dict(command.signature(), tag));
cmd_dict.insert_untagged("usage", value::string(command.usage()));
cmd_dict.insert_untagged("usage", UntaggedValue::string(command.usage()));
cmd_dict.into_value()
}
@ -30,11 +30,11 @@ fn for_spec(name: &str, ty: &str, required: bool, tag: impl Into<Tag>) -> Value
let mut spec = TaggedDictBuilder::new(tag);
spec.insert_untagged("name", value::string(name));
spec.insert_untagged("type", value::string(ty));
spec.insert_untagged("name", UntaggedValue::string(name));
spec.insert_untagged("type", UntaggedValue::string(ty));
spec.insert_untagged(
"required",
value::string(if required { "yes" } else { "no" }),
UntaggedValue::string(if required { "yes" } else { "no" }),
);
spec.into_value()

57
src/data/dict.rs
View file

@ -1,6 +1,5 @@
use crate::prelude::*;
use derive_new::new;
use indexmap::IndexMap;
use nu_protocol::{Dictionary, Primitive, UntaggedValue, Value};
use nu_source::{b, PrettyDebug, Spanned};
@ -106,59 +105,3 @@ impl From<TaggedListBuilder> for Value {
input.into_value()
}
}
#[derive(Debug)]
pub struct TaggedDictBuilder {
tag: Tag,
dict: IndexMap<String, Value>,
}
impl TaggedDictBuilder {
pub fn new(tag: impl Into<Tag>) -> TaggedDictBuilder {
TaggedDictBuilder {
tag: tag.into(),
dict: IndexMap::default(),
}
}
pub fn build(tag: impl Into<Tag>, block: impl FnOnce(&mut TaggedDictBuilder)) -> Value {
let mut builder = TaggedDictBuilder::new(tag);
block(&mut builder);
builder.into_value()
}
pub fn with_capacity(tag: impl Into<Tag>, n: usize) -> TaggedDictBuilder {
TaggedDictBuilder {
tag: tag.into(),
dict: IndexMap::with_capacity(n),
}
}
pub fn insert_untagged(&mut self, key: impl Into<String>, value: impl Into<UntaggedValue>) {
self.dict
.insert(key.into(), value.into().into_value(&self.tag));
}
pub fn insert_value(&mut self, key: impl Into<String>, value: impl Into<Value>) {
self.dict.insert(key.into(), value.into());
}
pub fn into_value(self) -> Value {
let tag = self.tag.clone();
self.into_untagged_value().into_value(tag)
}
pub fn into_untagged_value(self) -> UntaggedValue {
UntaggedValue::Row(Dictionary { entries: self.dict })
}
pub fn is_empty(&self) -> bool {
self.dict.is_empty()
}
}
impl From<TaggedDictBuilder> for Value {
fn from(input: TaggedDictBuilder) -> Value {
input.into_value()
}
}

22
src/data/files.rs
View file

@ -1,7 +1,6 @@
use crate::data::TaggedDictBuilder;
use crate::prelude::*;
use nu_errors::ShellError;
use nu_protocol::Value;
use nu_protocol::{TaggedDictBuilder, UntaggedValue, Value};
#[derive(Debug)]
pub enum FileType {
@ -17,7 +16,7 @@ pub(crate) fn dir_entry_dict(
full: bool,
) -> Result<Value, ShellError> {
let mut dict = TaggedDictBuilder::new(tag);
dict.insert_untagged("name", value::string(filename.to_string_lossy()));
dict.insert_untagged("name", UntaggedValue::string(filename.to_string_lossy()));
let kind = if metadata.is_dir() {
FileType::Directory
@ -27,36 +26,39 @@ pub(crate) fn dir_entry_dict(
FileType::Symlink
};
dict.insert_untagged("type", value::string(format!("{:?}", kind)));
dict.insert_untagged("type", UntaggedValue::string(format!("{:?}", kind)));
if full {
dict.insert_untagged(
"readonly",
value::boolean(metadata.permissions().readonly()),
UntaggedValue::boolean(metadata.permissions().readonly()),
);
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = metadata.permissions().mode();
dict.insert_untagged("mode", value::string(umask::Mode::from(mode).to_string()));
dict.insert_untagged(
"mode",
UntaggedValue::string(umask::Mode::from(mode).to_string()),
);
}
}
dict.insert_untagged("size", value::bytes(metadata.len() as u64));
dict.insert_untagged("size", UntaggedValue::bytes(metadata.len() as u64));
match metadata.created() {
Ok(c) => dict.insert_untagged("created", value::system_date(c)),
Ok(c) => dict.insert_untagged("created", UntaggedValue::system_date(c)),
Err(_) => {}
}
match metadata.accessed() {
Ok(a) => dict.insert_untagged("accessed", value::system_date(a)),
Ok(a) => dict.insert_untagged("accessed", UntaggedValue::system_date(a)),
Err(_) => {}
}
match metadata.modified() {
Ok(m) => dict.insert_untagged("modified", value::system_date(m)),
Ok(m) => dict.insert_untagged("modified", UntaggedValue::system_date(m)),
Err(_) => {}
}

81
src/data/value.rs
View file

@ -1,86 +1,11 @@
use crate::data::base::coerce_compare;
use crate::data::base::shape::{Column, InlineShape, TypeShape};
use crate::data::primitive::style_primitive;
use crate::data::value;
use bigdecimal::BigDecimal;
use chrono::DateTime;
use indexmap::IndexMap;
use nu_errors::ShellError;
use nu_parser::Number;
use nu_parser::Operator;
use nu_protocol::{ColumnPath, PathMember, Primitive, UntaggedValue, Value};
use nu_protocol::{Primitive, UntaggedValue};
use nu_source::{DebugDocBuilder, PrettyDebug, Tagged};
use num_bigint::BigInt;
use std::path::PathBuf;
use std::time::SystemTime;
#[allow(unused)]
pub fn row(entries: IndexMap<String, Value>) -> UntaggedValue {
UntaggedValue::Row(entries.into())
}
pub fn table(list: &Vec<Value>) -> UntaggedValue {
UntaggedValue::Table(list.to_vec())
}
pub fn string(s: impl Into<String>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::String(s.into()))
}
pub fn line(s: impl Into<String>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Line(s.into()))
}
pub fn column_path(s: Vec<impl Into<PathMember>>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::ColumnPath(ColumnPath::new(
s.into_iter().map(|p| p.into()).collect(),
)))
}
pub fn int(i: impl Into<BigInt>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Int(i.into()))
}
pub fn pattern(s: impl Into<String>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::String(s.into()))
}
pub fn path(s: impl Into<PathBuf>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Path(s.into()))
}
pub fn bytes(s: impl Into<u64>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Bytes(s.into()))
}
pub fn decimal(s: impl Into<BigDecimal>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Decimal(s.into()))
}
pub fn binary(binary: Vec<u8>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Binary(binary))
}
pub fn number(s: impl Into<Number>) -> UntaggedValue {
let num = s.into();
match num {
Number::Int(int) => value::int(int),
Number::Decimal(decimal) => value::decimal(decimal),
}
}
pub fn boolean(s: impl Into<bool>) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Boolean(s.into()))
}
pub fn duration(secs: u64) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Duration(secs))
}
pub fn system_date(s: SystemTime) -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Date(s.into()))
}
pub fn date_from_str(s: Tagged<&str>) -> Result<UntaggedValue, ShellError> {
let date = DateTime::parse_from_rfc3339(s.item).map_err(|err| {
@ -96,10 +21,6 @@ pub fn date_from_str(s: Tagged<&str>) -> Result<UntaggedValue, ShellError> {
Ok(UntaggedValue::Primitive(Primitive::Date(date)))
}
pub fn nothing() -> UntaggedValue {
UntaggedValue::Primitive(Primitive::Nothing)
}
pub fn compare_values(
operator: &Operator,
left: &UntaggedValue,

3
src/deserializer.rs
View file

@ -1,5 +1,4 @@
use crate::data::base::property_get::ValueExt;
use crate::data::value;
use log::trace;
use nu_errors::{CoerceInto, ShellError};
use nu_protocol::{CallInfo, ColumnPath, Evaluate, Primitive, ShellTypeName, UntaggedValue, Value};
@ -56,7 +55,7 @@ impl<'de> ConfigDeserializer<'de> {
self.stack.push(DeserializerItem {
key_struct_field: Some((name.to_string(), name)),
val: value.unwrap_or_else(|| value::nothing().into_value(&self.call.name_tag)),
val: value.unwrap_or_else(|| UntaggedValue::nothing().into_value(&self.call.name_tag)),
});
Ok(())

5
src/evaluate/evaluate_args.rs
View file

@ -1,11 +1,10 @@
// TODO: Temporary redirect
use crate::context::CommandRegistry;
use crate::data::value;
use crate::evaluate::evaluate_baseline_expr;
use indexmap::IndexMap;
use nu_errors::ShellError;
use nu_parser::hir;
use nu_protocol::{EvaluatedArgs, Scope, Value};
use nu_protocol::{EvaluatedArgs, Scope, UntaggedValue, Value};
use nu_source::Text;
pub(crate) fn evaluate_args(
@ -35,7 +34,7 @@ pub(crate) fn evaluate_args(
for (name, value) in n.named.iter() {
match value {
hir::NamedValue::PresentSwitch(tag) => {
results.insert(name.clone(), value::boolean(true).into_value(tag));
results.insert(name.clone(), UntaggedValue::boolean(true).into_value(tag));
}
hir::NamedValue::Value(expr) => {
results.insert(

38
src/evaluate/evaluator.rs
View file

@ -1,14 +1,13 @@
use crate::context::CommandRegistry;
use crate::data::base::Block;
use crate::data::value;
use crate::evaluate::operator::apply_operator;
use crate::prelude::*;
use crate::TaggedDictBuilder;
use log::trace;
use nu_errors::{ArgumentError, ShellError};
use nu_parser::hir::{self, Expression, RawExpression};
use nu_protocol::{
ColumnPath, Evaluate, Primitive, Scope, UnspannedPathMember, UntaggedValue, Value,
ColumnPath, Evaluate, Primitive, Scope, TaggedDictBuilder, UnspannedPathMember, UntaggedValue,
Value,
};
use nu_source::Text;
@ -28,9 +27,9 @@ pub(crate) fn evaluate_baseline_expr(
"Invalid external word".spanned(tag.span),
ArgumentError::InvalidExternalWord,
)),
RawExpression::FilePath(path) => Ok(value::path(path.clone()).into_value(tag)),
RawExpression::FilePath(path) => Ok(UntaggedValue::path(path.clone()).into_value(tag)),
RawExpression::Synthetic(hir::Synthetic::String(s)) => {
Ok(value::string(s).into_untagged_value())
Ok(UntaggedValue::string(s).into_untagged_value())
}
RawExpression::Variable(var) => evaluate_reference(var, scope, source, tag),
RawExpression::Command(_) => evaluate_command(tag, scope, source),
@ -118,11 +117,22 @@ fn evaluate_literal(literal: &hir::Literal, source: &Text) -> Value {
UntaggedValue::Primitive(Primitive::ColumnPath(ColumnPath::new(members)))
.into_value(&literal.span)
}
hir::RawLiteral::Number(int) => value::number(int.clone()).into_value(literal.span),
hir::RawLiteral::Number(int) => match int {
nu_parser::Number::Int(i) => UntaggedValue::int(i.clone()).into_value(literal.span),
nu_parser::Number::Decimal(d) => {
UntaggedValue::decimal(d.clone()).into_value(literal.span)
}
},
hir::RawLiteral::Size(int, unit) => unit.compute(&int).into_value(literal.span),
hir::RawLiteral::String(tag) => value::string(tag.slice(source)).into_value(literal.span),
hir::RawLiteral::GlobPattern(pattern) => value::pattern(pattern).into_value(literal.span),
hir::RawLiteral::Bare => value::string(literal.span.slice(source)).into_value(literal.span),
hir::RawLiteral::String(tag) => {
UntaggedValue::string(tag.slice(source)).into_value(literal.span)
}
hir::RawLiteral::GlobPattern(pattern) => {
UntaggedValue::pattern(pattern).into_value(literal.span)
}
hir::RawLiteral::Bare => {
UntaggedValue::string(literal.span.slice(source)).into_value(literal.span)
}
}
}
@ -140,32 +150,32 @@ fn evaluate_reference(
let mut dict = TaggedDictBuilder::new(&tag);
for v in std::env::vars() {
if v.0 != "PATH" && v.0 != "Path" {
dict.insert_untagged(v.0, value::string(v.1));
dict.insert_untagged(v.0, UntaggedValue::string(v.1));
}
}
Ok(dict.into_value())
}
x if x == "nu:config" => {
let config = crate::data::config::read(tag.clone(), &None)?;
Ok(value::row(config).into_value(tag))
Ok(UntaggedValue::row(config).into_value(tag))
}
x if x == "nu:path" => {
let mut table = vec![];
match std::env::var_os("PATH") {
Some(paths) => {
for path in std::env::split_paths(&paths) {
table.push(value::path(path).into_value(&tag));
table.push(UntaggedValue::path(path).into_value(&tag));
}
}
_ => {}
}
Ok(value::table(&table).into_value(tag))
Ok(UntaggedValue::table(&table).into_value(tag))
}
x => Ok(scope
.vars
.get(x)
.map(|v| v.clone())
.unwrap_or_else(|| value::nothing().into_value(tag))),
.unwrap_or_else(|| UntaggedValue::nothing().into_value(tag))),
},
}
}

8
src/evaluate/operator.rs
View file

@ -15,11 +15,11 @@ pub fn apply_operator(
| Operator::GreaterThan
| Operator::LessThanOrEqual
| Operator::GreaterThanOrEqual => {
value::compare_values(op, left, right).map(value::boolean)
value::compare_values(op, left, right).map(UntaggedValue::boolean)
}
Operator::Dot => Ok(value::boolean(false)),
Operator::Contains => contains(left, right).map(value::boolean),
Operator::NotContains => contains(left, right).map(Not::not).map(value::boolean),
Operator::Dot => Ok(UntaggedValue::boolean(false)),
Operator::Contains => contains(left, right).map(UntaggedValue::boolean),
Operator::NotContains => contains(left, right).map(Not::not).map(UntaggedValue::boolean),
}
}

2
src/format/generic.rs
View file

@ -35,7 +35,7 @@ impl RenderView for GenericView<'_> {
b @ UntaggedValue::Block(_) => {
let printed = format_leaf(b).plain_string(host.width());
let view = EntriesView::from_value(&value::string(printed).into_value(tag));
let view = EntriesView::from_value(&UntaggedValue::string(printed).into_value(tag));
view.render_view(host)?;
Ok(())
}

8
src/format/table.rs
View file

@ -68,8 +68,8 @@ impl TableView {
value: UntaggedValue::Row(..),
..
} => (
format_leaf(&value::nothing()).plain_string(100000),
style_leaf(&value::nothing()),
format_leaf(&UntaggedValue::nothing()).plain_string(100000),
style_leaf(&UntaggedValue::nothing()),
),
_ => (format_leaf(value).plain_string(100000), style_leaf(value)),
}
@ -86,8 +86,8 @@ impl TableView {
)
}
_ => (
format_leaf(&value::nothing()).plain_string(100000),
style_leaf(&value::nothing()),
format_leaf(&UntaggedValue::nothing()).plain_string(100000),
style_leaf(&UntaggedValue::nothing()),
),
}
}

4
src/lib.rs
View file

@ -23,7 +23,7 @@ mod utils;
pub use crate::cli::cli;
pub use crate::data::base::property_get::ValueExt;
pub use crate::data::config::{config_path, APP_INFO};
pub use crate::data::dict::{TaggedDictBuilder, TaggedListBuilder};
pub use crate::data::dict::TaggedListBuilder;
pub use crate::data::primitive;
pub use crate::data::value;
pub use crate::env::host::BasicHost;
@ -32,4 +32,4 @@ pub use nu_parser::TokenTreeBuilder;
pub use num_traits::cast::ToPrimitive;
// TODO: Temporary redirect
pub use nu_protocol::{serve_plugin, Plugin};
pub use nu_protocol::{serve_plugin, Plugin, TaggedDictBuilder};

6
src/plugins/average.rs
View file

@ -1,4 +1,4 @@
use nu::{serve_plugin, value, Plugin};
use nu::{serve_plugin, Plugin};
use nu_errors::{CoerceInto, ShellError};
use nu_protocol::{
CallInfo, Primitive, ReturnSuccess, ReturnValue, Signature, UntaggedValue, Value,
@ -27,7 +27,7 @@ impl Average {
value: UntaggedValue::Primitive(Primitive::Int(j)),
tag,
}) => {
self.total = Some(value::int(i + j).into_value(tag));
self.total = Some(UntaggedValue::int(i + j).into_value(tag));
self.count += 1;
Ok(())
}
@ -47,7 +47,7 @@ impl Average {
value: UntaggedValue::Primitive(Primitive::Bytes(j)),
tag,
}) => {
self.total = Some(value::bytes(b + j).into_value(tag));
self.total = Some(UntaggedValue::bytes(b + j).into_value(tag));
self.count += 1;
Ok(())
}

8
src/plugins/embed.rs
View file

@ -1,7 +1,7 @@
#[macro_use]
extern crate indexmap;
use nu::{serve_plugin, value, Plugin};
use nu::{serve_plugin, Plugin};
use nu_errors::ShellError;
use nu_protocol::{
CallInfo, Primitive, ReturnSuccess, ReturnValue, Signature, SpannedTypeName, SyntaxShape,
@ -35,7 +35,7 @@ impl Embed {
self.are_all_rows = false;
self.values.push(
value::row(indexmap! {
UntaggedValue::row(indexmap! {
match &self.field {
Some(key) => key.clone(),
None => "Column".into()
@ -81,11 +81,11 @@ impl Plugin for Embed {
fn end_filter(&mut self) -> Result<Vec<ReturnValue>, ShellError> {
if self.are_all_rows {
let row = value::row(indexmap! {
let row = UntaggedValue::row(indexmap! {
match &self.field {
Some(key) => key.clone(),
None => "Column".into(),
} => value::table(&self.values).into_value(Tag::unknown()),
} => UntaggedValue::table(&self.values).into_value(Tag::unknown()),
})
.into_untagged_value();

4
src/plugins/format.rs
View file

@ -1,4 +1,4 @@
use nu::{serve_plugin, value, Plugin};
use nu::{serve_plugin, Plugin};
use nu_errors::ShellError;
use nu_protocol::{
CallInfo, Primitive, ReturnSuccess, ReturnValue, Signature, SyntaxShape, UntaggedValue, Value,
@ -115,7 +115,7 @@ impl Plugin for Format {
}
return Ok(vec![ReturnSuccess::value(
value::string(output).into_untagged_value(),
UntaggedValue::string(output).into_untagged_value(),
)]);
}
_ => {}

34
src/plugins/inc.rs
View file

@ -1,4 +1,4 @@
use nu::{did_you_mean, serve_plugin, value, Plugin, ValueExt};
use nu::{did_you_mean, serve_plugin, Plugin, ValueExt};
use nu_errors::ShellError;
use nu_protocol::{
CallInfo, ColumnPath, Primitive, ReturnSuccess, ReturnValue, ShellTypeName, Signature,
@ -37,7 +37,7 @@ impl Inc {
Some(Action::SemVerAction(act_on)) => {
let mut ver = match semver::Version::parse(&input) {
Ok(parsed_ver) => parsed_ver,
Err(_) => return Ok(value::string(input.to_string())),
Err(_) => return Ok(UntaggedValue::string(input.to_string())),
};
match act_on {
@ -46,11 +46,11 @@ impl Inc {
SemVerAction::Patch => ver.increment_patch(),
}
value::string(ver.to_string())
UntaggedValue::string(ver.to_string())
}
Some(Action::Default) | None => match input.parse::<u64>() {
Ok(v) => value::string(format!("{}", v + 1)),
Err(_) => value::string(input),
Ok(v) => UntaggedValue::string(format!("{}", v + 1)),
Err(_) => UntaggedValue::string(input),
},
};
@ -80,10 +80,10 @@ impl Inc {
fn inc(&self, value: Value) -> Result<Value, ShellError> {
match &value.value {
UntaggedValue::Primitive(Primitive::Int(i)) => {
Ok(value::int(i + 1).into_value(value.tag()))
Ok(UntaggedValue::int(i + 1).into_value(value.tag()))
}
UntaggedValue::Primitive(Primitive::Bytes(b)) => {
Ok(value::bytes(b + 1 as u64).into_value(value.tag()))
Ok(UntaggedValue::bytes(b + 1 as u64).into_value(value.tag()))
}
UntaggedValue::Primitive(Primitive::String(ref s)) => {
Ok(self.apply(&s)?.into_value(value.tag()))
@ -226,7 +226,7 @@ mod tests {
use super::{Inc, SemVerAction};
use indexmap::IndexMap;
use nu::{value, Plugin, TaggedDictBuilder};
use nu::{Plugin, TaggedDictBuilder};
use nu_protocol::{
CallInfo, EvaluatedArgs, PathMember, ReturnSuccess, UnspannedPathMember, UntaggedValue,
Value,
@ -249,7 +249,7 @@ mod tests {
fn with_long_flag(&mut self, name: &str) -> &mut Self {
self.flags.insert(
name.to_string(),
value::boolean(true).into_value(Tag::unknown()),
UntaggedValue::boolean(true).into_value(Tag::unknown()),
);
self
}
@ -263,7 +263,7 @@ mod tests {
.collect();
self.positionals
.push(value::column_path(fields).into_untagged_value());
.push(UntaggedValue::column_path(fields).into_untagged_value());
self
}
@ -277,7 +277,7 @@ mod tests {
fn cargo_sample_record(with_version: &str) -> Value {
let mut package = TaggedDictBuilder::new(Tag::unknown());
package.insert_untagged("version", value::string(with_version));
package.insert_untagged("version", UntaggedValue::string(with_version));
package.into_value()
}
@ -360,21 +360,21 @@ mod tests {
fn incs_major() {
let mut inc = Inc::new();
inc.for_semver(SemVerAction::Major);
assert_eq!(inc.apply("0.1.3").unwrap(), value::string("1.0.0"));
assert_eq!(inc.apply("0.1.3").unwrap(), UntaggedValue::string("1.0.0"));
}
#[test]
fn incs_minor() {
let mut inc = Inc::new();
inc.for_semver(SemVerAction::Minor);
assert_eq!(inc.apply("0.1.3").unwrap(), value::string("0.2.0"));
assert_eq!(inc.apply("0.1.3").unwrap(), UntaggedValue::string("0.2.0"));
}
#[test]
fn incs_patch() {
let mut inc = Inc::new();
inc.for_semver(SemVerAction::Patch);
assert_eq!(inc.apply("0.1.3").unwrap(), value::string("0.1.4"));
assert_eq!(inc.apply("0.1.3").unwrap(), UntaggedValue::string("0.1.4"));
}
#[test]
@ -399,7 +399,7 @@ mod tests {
..
}) => assert_eq!(
*o.get_data(&String::from("version")).borrow(),
value::string(String::from("1.0.0")).into_untagged_value()
UntaggedValue::string(String::from("1.0.0")).into_untagged_value()
),
_ => {}
}
@ -427,7 +427,7 @@ mod tests {
..
}) => assert_eq!(
*o.get_data(&String::from("version")).borrow(),
value::string(String::from("0.2.0")).into_untagged_value()
UntaggedValue::string(String::from("0.2.0")).into_untagged_value()
),
_ => {}
}
@ -456,7 +456,7 @@ mod tests {
..
}) => assert_eq!(
*o.get_data(&field).borrow(),
value::string(String::from("0.1.4")).into_untagged_value()
UntaggedValue::string(String::from("0.1.4")).into_untagged_value()
),
_ => {}
}

7
src/plugins/parse.rs
View file

@ -1,4 +1,4 @@
use nu::{serve_plugin, value, Plugin, TaggedDictBuilder};
use nu::{serve_plugin, Plugin, TaggedDictBuilder};
use nu_errors::ShellError;
use nu_protocol::{
CallInfo, Primitive, ReturnSuccess, ReturnValue, Signature, SyntaxShape, UntaggedValue, Value,
@ -134,7 +134,10 @@ impl Plugin for Parse {
let mut dict = TaggedDictBuilder::new(input.tag());
for (idx, column_name) in self.column_names.iter().enumerate() {
dict.insert_untagged(column_name, value::string(&cap[idx + 1].to_string()));
dict.insert_untagged(
column_name,
UntaggedValue::string(&cap[idx + 1].to_string()),
);
}
results.push(ReturnSuccess::value(dict.into_value()));

70
src/plugins/str.rs
View file

@ -1,4 +1,4 @@
use nu::{did_you_mean, serve_plugin, value, Plugin, ValueExt};
use nu::{did_you_mean, serve_plugin, Plugin, ValueExt};
use nu_errors::ShellError;
use nu_protocol::{
CallInfo, ColumnPath, Primitive, ReturnSuccess, ReturnValue, ShellTypeName, Signature,
@ -41,15 +41,15 @@ impl Str {
fn apply(&self, input: &str) -> Result<UntaggedValue, ShellError> {
let applied = match self.action.as_ref() {
Some(Action::Downcase) => value::string(input.to_ascii_lowercase()),
Some(Action::Upcase) => value::string(input.to_ascii_uppercase()),
Some(Action::Downcase) => UntaggedValue::string(input.to_ascii_lowercase()),
Some(Action::Upcase) => UntaggedValue::string(input.to_ascii_uppercase()),
Some(Action::Substring(s, e)) => {
let end: usize = cmp::min(*e, input.len());
let start: usize = *s;
if start > input.len() - 1 {
value::string("")
UntaggedValue::string("")
} else {
value::string(
UntaggedValue::string(
&input
.chars()
.skip(start)
@ -59,23 +59,25 @@ impl Str {
}
}
Some(Action::Replace(mode)) => match mode {
ReplaceAction::Direct(replacement) => value::string(replacement.as_str()),
ReplaceAction::Direct(replacement) => UntaggedValue::string(replacement.as_str()),
ReplaceAction::FindAndReplace(find, replacement) => {
let regex = Regex::new(find.as_str());
match regex {
Ok(re) => value::string(re.replace(input, replacement.as_str()).to_owned()),
Err(_) => value::string(input),
Ok(re) => UntaggedValue::string(
re.replace(input, replacement.as_str()).to_owned(),
),
Err(_) => UntaggedValue::string(input),
}
}
},
Some(Action::ToInteger) => match input.trim() {
other => match other.parse::<i64>() {
Ok(v) => value::int(v),
Err(_) => value::string(input),
Ok(v) => UntaggedValue::int(v),
Err(_) => UntaggedValue::string(input),
},
},
None => value::string(input),
None => UntaggedValue::string(input),
};
Ok(applied)
@ -315,17 +317,17 @@ fn main() {
mod tests {
use super::{Action, ReplaceAction, Str};
use indexmap::IndexMap;
use nu::{value, Plugin, TaggedDictBuilder, ValueExt};
use nu::{Plugin, TaggedDictBuilder, ValueExt};
use nu_protocol::{CallInfo, EvaluatedArgs, Primitive, ReturnSuccess, UntaggedValue, Value};
use nu_source::Tag;
use num_bigint::BigInt;
fn string(input: impl Into<String>) -> Value {
value::string(input.into()).into_untagged_value()
UntaggedValue::string(input.into()).into_untagged_value()
}
fn table(list: &Vec<Value>) -> Value {
value::table(list).into_untagged_value()
UntaggedValue::table(list).into_untagged_value()
}
fn column_path(paths: &Vec<Value>) -> Value {
@ -358,7 +360,7 @@ mod tests {
fn with_long_flag(&mut self, name: &str) -> &mut Self {
self.flags.insert(
name.to_string(),
value::boolean(true).into_value(Tag::unknown()),
UntaggedValue::boolean(true).into_value(Tag::unknown()),
);
self
}
@ -366,7 +368,7 @@ mod tests {
fn with_parameter(&mut self, name: &str) -> &mut Self {
let fields: Vec<Value> = name
.split(".")
.map(|s| value::string(s.to_string()).into_value(Tag::unknown()))
.map(|s| UntaggedValue::string(s.to_string()).into_value(Tag::unknown()))
.collect();
self.positionals.push(column_path(&fields));
@ -383,12 +385,12 @@ mod tests {
fn structured_sample_record(key: &str, value: &str) -> Value {
let mut record = TaggedDictBuilder::new(Tag::unknown());
record.insert_untagged(key.clone(), value::string(value));
record.insert_untagged(key.clone(), UntaggedValue::string(value));
record.into_value()
}
fn unstructured_sample_record(value: &str) -> Value {
value::string(value).into_value(Tag::unknown())
UntaggedValue::string(value).into_value(Tag::unknown())
}
#[test]
@ -530,21 +532,30 @@ mod tests {
fn str_downcases() {
let mut strutils = Str::new();
strutils.for_downcase();
assert_eq!(strutils.apply("ANDRES").unwrap(), value::string("andres"));
assert_eq!(
strutils.apply("ANDRES").unwrap(),
UntaggedValue::string("andres")
);
}
#[test]
fn str_upcases() {
let mut strutils = Str::new();
strutils.for_upcase();
assert_eq!(strutils.apply("andres").unwrap(), value::string("ANDRES"));
assert_eq!(
strutils.apply("andres").unwrap(),
UntaggedValue::string("ANDRES")
);
}
#[test]
fn str_to_int() {
let mut strutils = Str::new();
strutils.for_to_int();
assert_eq!(strutils.apply("9999").unwrap(), value::int(9999 as i64));
assert_eq!(
strutils.apply("9999").unwrap(),
UntaggedValue::int(9999 as i64)
);
}
#[test]
@ -552,7 +563,10 @@ mod tests {
let mut strutils = Str::new();
strutils.for_replace(ReplaceAction::Direct("robalino".to_string()));
assert_eq!(strutils.apply("andres").unwrap(), value::string("robalino"));
assert_eq!(
strutils.apply("andres").unwrap(),
UntaggedValue::string("robalino")
);
}
#[test]
@ -564,7 +578,7 @@ mod tests {
));
assert_eq!(
strutils.apply("wykittens").unwrap(),
value::string("wyjotandrehuda")
UntaggedValue::string("wyjotandrehuda")
);
}
@ -590,7 +604,7 @@ mod tests {
..
}) => assert_eq!(
*o.get_data(&String::from("name")).borrow(),
value::string(String::from("JOTANDREHUDA")).into_untagged_value()
UntaggedValue::string(String::from("JOTANDREHUDA")).into_untagged_value()
),
_ => {}
}
@ -638,7 +652,7 @@ mod tests {
..
}) => assert_eq!(
*o.get_data(&String::from("name")).borrow(),
value::string(String::from("jotandrehuda")).into_untagged_value()
UntaggedValue::string(String::from("jotandrehuda")).into_untagged_value()
),
_ => {}
}
@ -686,7 +700,7 @@ mod tests {
..
}) => assert_eq!(
*o.get_data(&String::from("Nu_birthday")).borrow(),
value::int(10).into_untagged_value()
UntaggedValue::int(10).into_untagged_value()
),
_ => {}
}
@ -872,7 +886,7 @@ mod tests {
}) => assert_eq!(
*o.get_data(&String::from("rustconf")).borrow(),
Value {
value: value::string(String::from("22nd August 2019")),
value: UntaggedValue::string(String::from("22nd August 2019")),
tag: Tag::unknown()
}
),
@ -930,7 +944,7 @@ mod tests {
}) => assert_eq!(
*o.get_data(&String::from("staff")).borrow(),
Value {
value: value::string(String::from("wyjotandrehuda")),
value: UntaggedValue::string(String::from("wyjotandrehuda")),
tag: Tag::unknown()
}
),

6
src/plugins/sum.rs
View file

@ -1,4 +1,4 @@
use nu::{serve_plugin, value, Plugin};
use nu::{serve_plugin, Plugin};
use nu_errors::ShellError;
use nu_protocol::{
CallInfo, Primitive, ReturnSuccess, ReturnValue, Signature, UntaggedValue, Value,
@ -22,7 +22,7 @@ impl Sum {
tag,
}) => {
//TODO: handle overflow
self.total = Some(value::int(i + j).into_value(tag));
self.total = Some(UntaggedValue::int(i + j).into_value(tag));
Ok(())
}
None => {
@ -43,7 +43,7 @@ impl Sum {
tag,
}) => {
//TODO: handle overflow
self.total = Some(value::bytes(b + j).into_value(tag));
self.total = Some(UntaggedValue::bytes(b + j).into_value(tag));
Ok(())
}
None => {

19
src/prelude.rs
View file

@ -68,25 +68,6 @@ macro_rules! trace_out_stream {
}};
}
#[macro_export]
macro_rules! dict {
($( $key:expr => $value:expr ),*) => {
$crate::data::dict::TaggedDictBuilder::build(Tag::unknown(), |d| {
$(
d.insert_untagged($key, $value);
)*
})
};
([tag] => $tag:expr, $( $key:expr => $value:expr ),*) => {
$crate::data::dict::TaggedDictBuilder::build($tag, |d| {
$(
d.insert_untagged($key, $value);
)*
})
}
}
pub(crate) use nu_protocol::{errln, outln};
pub(crate) use crate::commands::command::{

4
src/shell/help_shell.rs
View file

@ -3,11 +3,11 @@ use crate::commands::cp::CopyArgs;
use crate::commands::mkdir::MkdirArgs;
use crate::commands::mv::MoveArgs;
use crate::commands::rm::RemoveArgs;
use crate::data::{command_dict, TaggedDictBuilder};
use crate::data::{command_dict};
use crate::prelude::*;
use crate::shell::shell::Shell;
use nu_errors::ShellError;
use nu_protocol::{Primitive, ReturnSuccess, ShellTypeName, UntaggedValue, Value};
use nu_protocol::{Primitive, ReturnSuccess, ShellTypeName, TaggedDictBuilder, UntaggedValue, Value};
use nu_source::Tagged;
use std::ffi::OsStr;
use std::path::PathBuf;

2
src/shell/value_shell.rs
View file

@ -218,7 +218,7 @@ impl Shell for ValueShell {
fn pwd(&self, args: EvaluatedWholeStreamCommandArgs) -> Result<OutputStream, ShellError> {
let mut stream = VecDeque::new();
stream.push_back(ReturnSuccess::value(
value::string(self.path()).into_value(&args.call_info.name_tag),
UntaggedValue::string(self.path()).into_value(&args.call_info.name_tag),
));
Ok(stream.into())
}

5
src/utils.rs
View file

@ -332,8 +332,7 @@ impl FileStructure {
#[cfg(test)]
mod tests {
use super::{FileStructure, Res, ValueResource, ValueStructure};
use crate::data::{value, TaggedDictBuilder};
use nu_protocol::Value;
use nu_protocol::{TaggedDictBuilder, UntaggedValue, Value};
use nu_source::Tag;
use pretty_assertions::assert_eq;
use std::path::PathBuf;
@ -352,7 +351,7 @@ mod tests {
fn structured_sample_record(key: &str, value: &str) -> Value {
let mut record = TaggedDictBuilder::new(Tag::unknown());
record.insert_untagged(key.clone(), value::string(value));
record.insert_untagged(key.clone(), UntaggedValue::string(value));
record.into_value()
}