mirror of
https://github.com/nushell/nushell.git
synced 2024-10-17 15:52:50 +02:00
467 lines
16 KiB
Rust
467 lines
16 KiB
Rust
use crate::errors::ShellError;
|
|
use crate::evaluate::{evaluate_expr, Scope};
|
|
use crate::object::DataDescriptor;
|
|
use crate::parser::ast::{self, Operator};
|
|
use crate::prelude::*;
|
|
use ansi_term::Color;
|
|
use chrono::{DateTime, Utc};
|
|
use chrono_humanize::Humanize;
|
|
use derive_new::new;
|
|
use ordered_float::OrderedFloat;
|
|
use std::time::SystemTime;
|
|
|
|
use serde::{Serialize, Serializer};
|
|
use serde_derive::Serialize;
|
|
|
|
type OF64 = OrderedFloat<f64>;
|
|
|
|
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
|
|
pub enum Primitive {
|
|
Nothing,
|
|
Int(i64),
|
|
#[allow(unused)]
|
|
Float(OF64),
|
|
Bytes(u128),
|
|
String(String),
|
|
Boolean(bool),
|
|
Date(DateTime<Utc>),
|
|
}
|
|
|
|
impl Serialize for Primitive {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
match self {
|
|
Primitive::Nothing => serializer.serialize_i32(0),
|
|
Primitive::Int(i) => serializer.serialize_i64(*i),
|
|
Primitive::Float(f) => serializer.serialize_f64(f.into_inner()),
|
|
Primitive::Bytes(b) => serializer.serialize_u128(*b),
|
|
Primitive::String(ref s) => serializer.serialize_str(s),
|
|
Primitive::Boolean(b) => serializer.serialize_bool(*b),
|
|
Primitive::Date(d) => serializer.serialize_str(&d.to_string()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Primitive {
|
|
crate fn format(&self, field_name: Option<&str>) -> String {
|
|
match self {
|
|
Primitive::Nothing => format!("{}", Color::Black.bold().paint("-")),
|
|
Primitive::Bytes(b) => {
|
|
let byte = byte_unit::Byte::from_bytes(*b);
|
|
|
|
if byte.get_bytes() == 0u128 {
|
|
return Color::Black.bold().paint("Empty".to_string()).to_string();
|
|
}
|
|
|
|
let byte = byte.get_appropriate_unit(false);
|
|
|
|
match byte.get_unit() {
|
|
byte_unit::ByteUnit::B => format!("{}", byte.format(0)),
|
|
_ => format!("{}", byte.format(1)),
|
|
}
|
|
}
|
|
Primitive::Int(i) => format!("{}", i),
|
|
Primitive::Float(f) => format!("{:.*}", 2, f.into_inner()),
|
|
Primitive::String(s) => format!("{}", s),
|
|
Primitive::Boolean(b) => match (b, field_name) {
|
|
(true, None) => format!("Yes"),
|
|
(false, None) => format!("No"),
|
|
(true, Some(s)) => format!("{}", s),
|
|
(false, Some(_)) => format!(""),
|
|
},
|
|
Primitive::Date(d) => format!("{}", d.humanize()),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone, new, Serialize)]
|
|
pub struct Operation {
|
|
crate left: Value,
|
|
crate operator: Operator,
|
|
crate right: Value,
|
|
}
|
|
|
|
#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone, new)]
|
|
pub struct Block {
|
|
crate expression: ast::Expression,
|
|
}
|
|
|
|
impl Serialize for Block {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
serializer.serialize_str(&self.expression.print())
|
|
}
|
|
}
|
|
|
|
impl Block {
|
|
pub fn invoke(&self, value: &Value) -> Result<Value, ShellError> {
|
|
let scope = Scope::new(value.copy());
|
|
evaluate_expr(&self.expression, &scope)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone)]
|
|
pub enum Value {
|
|
Primitive(Primitive),
|
|
Object(crate::object::Dictionary),
|
|
List(Vec<Value>),
|
|
Block(Block),
|
|
|
|
#[allow(unused)]
|
|
Error(Box<ShellError>),
|
|
}
|
|
|
|
impl Serialize for Value {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
match self {
|
|
Value::Primitive(p) => p.serialize(serializer),
|
|
Value::Object(o) => o.serialize(serializer),
|
|
Value::List(l) => l.serialize(serializer),
|
|
Value::Block(b) => b.serialize(serializer),
|
|
Value::Error(e) => e.serialize(serializer),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Value {
|
|
crate fn data_descriptors(&self) -> Vec<DataDescriptor> {
|
|
match self {
|
|
Value::Primitive(_) => vec![DataDescriptor::value_of()],
|
|
Value::Object(o) => o.data_descriptors(),
|
|
Value::Block(_) => vec![DataDescriptor::value_of()],
|
|
Value::List(_) => vec![],
|
|
Value::Error(_) => vec![DataDescriptor::value_of()],
|
|
}
|
|
}
|
|
|
|
crate fn get_data_by_key(&'a self, name: &str) -> Option<&Value> {
|
|
match self {
|
|
Value::Object(o) => o.get_data_by_key(name),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
crate fn get_data(&'a self, desc: &DataDescriptor) -> MaybeOwned<'a, Value> {
|
|
match self {
|
|
p @ Value::Primitive(_) => MaybeOwned::Borrowed(p),
|
|
Value::Object(o) => o.get_data(desc),
|
|
Value::Block(_) => MaybeOwned::Owned(Value::nothing()),
|
|
Value::List(_) => MaybeOwned::Owned(Value::nothing()),
|
|
Value::Error(e) => MaybeOwned::Owned(Value::string(&format!("{:#?}", e))),
|
|
}
|
|
}
|
|
|
|
crate fn copy(&self) -> Value {
|
|
match self {
|
|
Value::Primitive(p) => Value::Primitive(p.clone()),
|
|
Value::Object(o) => Value::Object(o.copy_dict()),
|
|
Value::Block(b) => Value::Block(b.clone()),
|
|
Value::List(l) => {
|
|
let list = l.iter().map(|i| i.copy()).collect();
|
|
Value::List(list)
|
|
}
|
|
Value::Error(e) => Value::Error(Box::new(e.copy_error())),
|
|
}
|
|
}
|
|
|
|
crate fn format_leaf(&self, field_name: Option<&str>) -> String {
|
|
match self {
|
|
Value::Primitive(p) => p.format(field_name),
|
|
Value::Block(b) => b.expression.print(),
|
|
Value::Object(_) => format!("[object Object]"),
|
|
Value::List(_) => format!("[list List]"),
|
|
Value::Error(e) => format!("{}", e),
|
|
}
|
|
}
|
|
|
|
crate fn compare(&self, operator: ast::Operator, other: &Value) -> Option<bool> {
|
|
match operator {
|
|
_ => {
|
|
let coerced = coerce_compare(self, other)?;
|
|
let ordering = coerced.compare();
|
|
|
|
use std::cmp::Ordering;
|
|
|
|
let result = match (operator, ordering) {
|
|
(Operator::Equal, Ordering::Equal) => true,
|
|
(Operator::NotEqual, Ordering::Less)
|
|
| (Operator::NotEqual, Ordering::Greater) => true,
|
|
(Operator::LessThan, Ordering::Less) => true,
|
|
(Operator::GreaterThan, Ordering::Greater) => true,
|
|
(Operator::GreaterThanOrEqual, Ordering::Greater)
|
|
| (Operator::GreaterThanOrEqual, Ordering::Equal) => true,
|
|
(Operator::LessThanOrEqual, Ordering::Less)
|
|
| (Operator::LessThanOrEqual, Ordering::Equal) => true,
|
|
_ => false,
|
|
};
|
|
|
|
Some(result)
|
|
}
|
|
}
|
|
}
|
|
|
|
crate fn as_string(&self) -> Result<String, ShellError> {
|
|
match self {
|
|
Value::Primitive(Primitive::String(s)) => Ok(s.to_string()),
|
|
// TODO: this should definitely be more general with better errors
|
|
other => Err(ShellError::string(format!(
|
|
"Expected string, got {:?}",
|
|
other
|
|
))),
|
|
}
|
|
}
|
|
|
|
crate fn as_i64(&self) -> Result<i64, ShellError> {
|
|
match self {
|
|
Value::Primitive(Primitive::Int(i)) => Ok(*i),
|
|
Value::Primitive(Primitive::Bytes(b)) if *b <= std::i64::MAX as u128 => Ok(*b as i64),
|
|
// TODO: this should definitely be more general with better errors
|
|
other => Err(ShellError::string(format!(
|
|
"Expected integer, got {:?}",
|
|
other
|
|
))),
|
|
}
|
|
}
|
|
|
|
crate fn as_block(&self) -> Result<Block, ShellError> {
|
|
match self {
|
|
Value::Block(block) => Ok(block.clone()),
|
|
// TODO: this should definitely be more general with better errors
|
|
other => Err(ShellError::string(format!(
|
|
"Expected block, got {:?}",
|
|
other
|
|
))),
|
|
}
|
|
}
|
|
|
|
#[allow(unused)]
|
|
crate fn as_bool(&self) -> Result<bool, ShellError> {
|
|
match self {
|
|
Value::Primitive(Primitive::Boolean(b)) => Ok(*b),
|
|
// TODO: this should definitely be more general with better errors
|
|
other => Err(ShellError::string(format!(
|
|
"Expected integer, got {:?}",
|
|
other
|
|
))),
|
|
}
|
|
}
|
|
|
|
crate fn is_true(&self) -> bool {
|
|
match self {
|
|
Value::Primitive(Primitive::Boolean(true)) => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
crate fn block(e: ast::Expression) -> Value {
|
|
Value::Block(Block::new(e))
|
|
}
|
|
|
|
crate fn string(s: impl Into<String>) -> Value {
|
|
Value::Primitive(Primitive::String(s.into()))
|
|
}
|
|
|
|
crate fn bytes(s: impl Into<u128>) -> Value {
|
|
Value::Primitive(Primitive::Bytes(s.into()))
|
|
}
|
|
|
|
crate fn int(s: impl Into<i64>) -> Value {
|
|
Value::Primitive(Primitive::Int(s.into()))
|
|
}
|
|
|
|
crate fn float(s: impl Into<OF64>) -> Value {
|
|
Value::Primitive(Primitive::Float(s.into()))
|
|
}
|
|
|
|
#[allow(unused)]
|
|
crate fn bool(s: impl Into<bool>) -> Value {
|
|
Value::Primitive(Primitive::Boolean(s.into()))
|
|
}
|
|
|
|
crate fn system_date(s: SystemTime) -> Value {
|
|
Value::Primitive(Primitive::Date(s.into()))
|
|
}
|
|
|
|
#[allow(unused)]
|
|
crate fn system_date_result(s: Result<SystemTime, std::io::Error>) -> Value {
|
|
match s {
|
|
Ok(time) => Value::Primitive(Primitive::Date(time.into())),
|
|
Err(err) => Value::Error(Box::new(ShellError::string(format!("{}", err)))),
|
|
}
|
|
}
|
|
|
|
crate fn boolean(s: impl Into<bool>) -> Value {
|
|
Value::Primitive(Primitive::Boolean(s.into()))
|
|
}
|
|
|
|
crate fn nothing() -> Value {
|
|
Value::Primitive(Primitive::Nothing)
|
|
}
|
|
|
|
#[allow(unused)]
|
|
crate fn list(values: impl Into<Vec<Value>>) -> Value {
|
|
Value::List(values.into())
|
|
}
|
|
}
|
|
|
|
crate fn select_fields(obj: &Value, fields: &[String]) -> crate::object::Dictionary {
|
|
let mut out = crate::object::Dictionary::default();
|
|
|
|
let descs = obj.data_descriptors();
|
|
|
|
for field in fields {
|
|
match descs.iter().find(|d| d.name.is_string(field)) {
|
|
None => out.add(DataDescriptor::for_string_name(field), Value::nothing()),
|
|
Some(desc) => out.add(desc.copy(), obj.get_data(desc).borrow().copy()),
|
|
}
|
|
}
|
|
|
|
out
|
|
}
|
|
|
|
crate fn reject_fields(obj: &Value, fields: &[String]) -> crate::object::Dictionary {
|
|
let mut out = crate::object::Dictionary::default();
|
|
|
|
let descs = obj.data_descriptors();
|
|
|
|
for desc in descs {
|
|
match desc.name.as_string() {
|
|
None => continue,
|
|
Some(s) if fields.iter().any(|field| field == s) => continue,
|
|
Some(_) => out.add(desc.copy(), obj.get_data(&desc).borrow().copy()),
|
|
}
|
|
}
|
|
|
|
out
|
|
}
|
|
|
|
#[allow(unused)]
|
|
crate fn find(obj: &Value, field: &str, op: &Operator, rhs: &Value) -> bool {
|
|
let descs = obj.data_descriptors();
|
|
match descs.iter().find(|d| d.name.is_string(field)) {
|
|
None => false,
|
|
Some(desc) => {
|
|
let v = obj.get_data(desc).borrow().copy();
|
|
|
|
match v {
|
|
Value::Primitive(Primitive::Boolean(b)) => match (op, rhs) {
|
|
(Operator::Equal, Value::Primitive(Primitive::Boolean(b2))) => b == *b2,
|
|
(Operator::NotEqual, Value::Primitive(Primitive::Boolean(b2))) => b != *b2,
|
|
_ => false,
|
|
},
|
|
Value::Primitive(Primitive::Bytes(i)) => match (op, rhs) {
|
|
(Operator::LessThan, Value::Primitive(Primitive::Int(i2))) => i < (*i2 as u128),
|
|
(Operator::GreaterThan, Value::Primitive(Primitive::Int(i2))) => {
|
|
i > (*i2 as u128)
|
|
}
|
|
(Operator::LessThanOrEqual, Value::Primitive(Primitive::Int(i2))) => {
|
|
i <= (*i2 as u128)
|
|
}
|
|
(Operator::GreaterThanOrEqual, Value::Primitive(Primitive::Int(i2))) => {
|
|
i >= (*i2 as u128)
|
|
}
|
|
(Operator::Equal, Value::Primitive(Primitive::Int(i2))) => i == (*i2 as u128),
|
|
(Operator::NotEqual, Value::Primitive(Primitive::Int(i2))) => {
|
|
i != (*i2 as u128)
|
|
}
|
|
_ => false,
|
|
},
|
|
Value::Primitive(Primitive::Int(i)) => match (op, rhs) {
|
|
(Operator::LessThan, Value::Primitive(Primitive::Int(i2))) => i < *i2,
|
|
(Operator::GreaterThan, Value::Primitive(Primitive::Int(i2))) => i > *i2,
|
|
(Operator::LessThanOrEqual, Value::Primitive(Primitive::Int(i2))) => i <= *i2,
|
|
(Operator::GreaterThanOrEqual, Value::Primitive(Primitive::Int(i2))) => {
|
|
i >= *i2
|
|
}
|
|
(Operator::Equal, Value::Primitive(Primitive::Int(i2))) => i == *i2,
|
|
(Operator::NotEqual, Value::Primitive(Primitive::Int(i2))) => i != *i2,
|
|
_ => false,
|
|
},
|
|
Value::Primitive(Primitive::Float(i)) => match (op, rhs) {
|
|
(Operator::LessThan, Value::Primitive(Primitive::Float(i2))) => i < *i2,
|
|
(Operator::GreaterThan, Value::Primitive(Primitive::Float(i2))) => i > *i2,
|
|
(Operator::LessThanOrEqual, Value::Primitive(Primitive::Float(i2))) => i <= *i2,
|
|
(Operator::GreaterThanOrEqual, Value::Primitive(Primitive::Float(i2))) => {
|
|
i >= *i2
|
|
}
|
|
(Operator::Equal, Value::Primitive(Primitive::Float(i2))) => i == *i2,
|
|
(Operator::NotEqual, Value::Primitive(Primitive::Float(i2))) => i != *i2,
|
|
(Operator::LessThan, Value::Primitive(Primitive::Int(i2))) => {
|
|
(i.into_inner()) < *i2 as f64
|
|
}
|
|
(Operator::GreaterThan, Value::Primitive(Primitive::Int(i2))) => {
|
|
i.into_inner() > *i2 as f64
|
|
}
|
|
(Operator::LessThanOrEqual, Value::Primitive(Primitive::Int(i2))) => {
|
|
i.into_inner() <= *i2 as f64
|
|
}
|
|
(Operator::GreaterThanOrEqual, Value::Primitive(Primitive::Int(i2))) => {
|
|
i.into_inner() >= *i2 as f64
|
|
}
|
|
(Operator::Equal, Value::Primitive(Primitive::Int(i2))) => {
|
|
i.into_inner() == *i2 as f64
|
|
}
|
|
(Operator::NotEqual, Value::Primitive(Primitive::Int(i2))) => {
|
|
i.into_inner() != *i2 as f64
|
|
}
|
|
|
|
_ => false,
|
|
},
|
|
Value::Primitive(Primitive::String(s)) => match (op, rhs) {
|
|
(Operator::Equal, Value::Primitive(Primitive::String(s2))) => s == *s2,
|
|
(Operator::NotEqual, Value::Primitive(Primitive::String(s2))) => s != *s2,
|
|
_ => false,
|
|
},
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
enum CompareValues {
|
|
Ints(i64, i64),
|
|
Floats(OF64, OF64),
|
|
Bytes(i128, i128),
|
|
String(String, String),
|
|
}
|
|
|
|
impl CompareValues {
|
|
fn compare(&self) -> std::cmp::Ordering {
|
|
match self {
|
|
CompareValues::Ints(left, right) => left.cmp(right),
|
|
CompareValues::Floats(left, right) => left.cmp(right),
|
|
CompareValues::Bytes(left, right) => left.cmp(right),
|
|
CompareValues::String(left, right) => left.cmp(right),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn coerce_compare(left: &Value, right: &Value) -> Option<CompareValues> {
|
|
match (left, right) {
|
|
(Value::Primitive(left), Value::Primitive(right)) => coerce_compare_primitive(left, right),
|
|
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn coerce_compare_primitive(left: &Primitive, right: &Primitive) -> Option<CompareValues> {
|
|
use Primitive::*;
|
|
|
|
match (left, right) {
|
|
(Int(left), Int(right)) => Some(CompareValues::Ints(*left, *right)),
|
|
(Float(left), Int(right)) => Some(CompareValues::Floats(*left, (*right as f64).into())),
|
|
(Int(left), Float(right)) => Some(CompareValues::Floats((*left as f64).into(), *right)),
|
|
(Int(left), Bytes(right)) => Some(CompareValues::Bytes(*left as i128, *right as i128)),
|
|
(Bytes(left), Int(right)) => Some(CompareValues::Bytes(*left as i128, *right as i128)),
|
|
(String(left), String(right)) => Some(CompareValues::String(left.clone(), right.clone())),
|
|
_ => None,
|
|
}
|
|
}
|