Merge branch 'nushell:main' into main

crates/nu-protocol/src/ast/expr.rs

@@ -1,5 +1,5 @@
 use super::{Call, CellPath, Expression, FullCellPath, Operator, RangeOperator};
-use crate::{BlockId, Signature, Span, VarId};
+use crate::{BlockId, Signature, Span, Spanned, Unit, VarId};
 
 #[derive(Debug, Clone)]
 pub enum Expr {
@@ -23,6 +23,9 @@ pub enum Expr {
     List(Vec<Expression>),
     Table(Vec<Expression>, Vec<Vec<Expression>>),
     Keyword(Vec<u8>, Span, Box<Expression>),
+    ValueWithUnit(Box<Expression>, Spanned<Unit>),
+    Filepath(String),
+    GlobPattern(String),
     String(String), // FIXME: improve this in the future?
     CellPath(CellPath),
     FullCellPath(Box<FullCellPath>),

crates/nu-protocol/src/engine/engine_state.rs

@@ -12,12 +12,12 @@ pub struct EngineState {
     vars: Vec<Type>,
     decls: Vec<Box<dyn Command>>,
     blocks: Vec<Block>,
-    scope: Vec<ScopeFrame>,
+    pub scope: Vec<ScopeFrame>,
 }
 
 #[derive(Debug)]
 pub struct ScopeFrame {
-    vars: HashMap<Vec<u8>, VarId>,
+    pub vars: HashMap<Vec<u8>, VarId>,
     decls: HashMap<Vec<u8>, DeclId>,
     aliases: HashMap<Vec<u8>, Vec<Span>>,
     modules: HashMap<Vec<u8>, BlockId>,
@@ -375,7 +375,7 @@ impl<'a> StateWorkingSet<'a> {
 
             if let Some(decl_id) = scope.decls.get(name) {
                 if !hiding.contains(decl_id) {
-                    // Do not hide already hidden decl
+                    // Hide decl only if it's not already hidden
                     last_scope_frame.hiding.insert(*decl_id);
                     return Some(*decl_id);
                 }
@@ -409,8 +409,6 @@ impl<'a> StateWorkingSet<'a> {
     }
 
     pub fn activate_overlay(&mut self, overlay: Vec<(Vec<u8>, DeclId)>) {
-        // TODO: This will overwrite all existing definitions in a scope. When we add deactivate,
-        // we need to re-think how make it recoverable.
         let scope_frame = self
             .delta
             .scope

crates/nu-protocol/src/span.rs

@@ -1,7 +1,11 @@
 use miette::SourceSpan;
 use serde::{Deserialize, Serialize};
 
-pub struct Spanned<T> {
+#[derive(Clone, Debug)]
+pub struct Spanned<T>
+where
+    T: Clone + std::fmt::Debug,
+{
     pub item: T,
     pub span: Span,
 }

crates/nu-protocol/src/syntax_shape.rs

@@ -28,7 +28,7 @@ pub enum SyntaxShape {
     Int,
 
     /// A filepath is allowed
-    FilePath,
+    Filepath,
 
     /// A glob pattern is allowed, eg `foo*`
     GlobPattern,
@@ -86,7 +86,7 @@ impl SyntaxShape {
             SyntaxShape::Custom(custom, _) => custom.to_type(),
             SyntaxShape::Duration => Type::Duration,
             SyntaxShape::Expression => Type::Unknown,
-            SyntaxShape::FilePath => Type::String,
+            SyntaxShape::Filepath => Type::String,
             SyntaxShape::Filesize => Type::Filesize,
             SyntaxShape::FullCellPath => Type::Unknown,
             SyntaxShape::GlobPattern => Type::String,

crates/nu-protocol/src/ty.rs

@@ -12,7 +12,7 @@ pub enum Type {
     Block,
     CellPath,
     Duration,
-    FilePath,
+    Date,
     Filesize,
     List(Box<Type>),
     Number,
@@ -31,8 +31,8 @@ impl Display for Type {
             Type::Block => write!(f, "block"),
             Type::Bool => write!(f, "bool"),
             Type::CellPath => write!(f, "cell path"),
+            Type::Date => write!(f, "date"),
             Type::Duration => write!(f, "duration"),
-            Type::FilePath => write!(f, "filepath"),
             Type::Filesize => write!(f, "filesize"),
             Type::Float => write!(f, "float"),
             Type::Int => write!(f, "int"),

crates/nu-protocol/src/value/mod.rs

@@ -1,11 +1,15 @@
 mod range;
 mod row;
 mod stream;
+mod unit;
 
+use chrono::{DateTime, FixedOffset};
+use chrono_humanize::HumanTime;
 pub use range::*;
 pub use row::*;
 use serde::{Deserialize, Serialize};
 pub use stream::*;
+pub use unit::*;
 
 use std::fmt::Debug;
 
@@ -26,11 +30,15 @@ pub enum Value {
         span: Span,
     },
     Filesize {
-        val: u64,
+        val: i64,
         span: Span,
     },
     Duration {
-        val: u64,
+        val: i64,
+        span: Span,
+    },
+    Date {
+        val: DateTime<FixedOffset>,
         span: Span,
     },
     Range {
@@ -95,6 +103,7 @@ impl Value {
             Value::Float { span, .. } => *span,
             Value::Filesize { span, .. } => *span,
             Value::Duration { span, .. } => *span,
+            Value::Date { span, .. } => *span,
             Value::Range { span, .. } => *span,
             Value::String { span, .. } => *span,
             Value::Record { span, .. } => *span,
@@ -115,6 +124,7 @@ impl Value {
             Value::Float { span, .. } => *span = new_span,
             Value::Filesize { span, .. } => *span = new_span,
             Value::Duration { span, .. } => *span = new_span,
+            Value::Date { span, .. } => *span = new_span,
             Value::Range { span, .. } => *span = new_span,
             Value::String { span, .. } => *span = new_span,
             Value::Record { span, .. } => *span = new_span,
@@ -138,6 +148,7 @@ impl Value {
             Value::Float { .. } => Type::Float,
             Value::Filesize { .. } => Type::Filesize,
             Value::Duration { .. } => Type::Duration,
+            Value::Date { .. } => Type::Date,
             Value::Range { .. } => Type::Range,
             Value::String { .. } => Type::String,
             Value::Record { cols, vals, .. } => {
@@ -159,8 +170,9 @@ impl Value {
             Value::Bool { val, .. } => val.to_string(),
             Value::Int { val, .. } => val.to_string(),
             Value::Float { val, .. } => val.to_string(),
-            Value::Filesize { val, .. } => format!("{} bytes", val),
-            Value::Duration { val, .. } => format!("{} ns", val),
+            Value::Filesize { val, .. } => format_filesize(val),
+            Value::Duration { val, .. } => format_duration(val),
+            Value::Date { val, .. } => HumanTime::from(val).to_string(),
             Value::Range { val, .. } => {
                 format!(
                     "range: [{}]",
@@ -202,6 +214,7 @@ impl Value {
             Value::Float { val, .. } => val.to_string(),
             Value::Filesize { val, .. } => format!("{} bytes", val),
             Value::Duration { val, .. } => format!("{} ns", val),
+            Value::Date { val, .. } => format!("{:?}", val),
             Value::Range { val, .. } => val
                 .into_iter()
                 .map(|x| x.into_string())
@@ -390,6 +403,18 @@ impl Value {
                 val: lhs.to_string() + rhs,
                 span,
             }),
+            (Value::Duration { val: lhs, .. }, Value::Duration { val: rhs, .. }) => {
+                Ok(Value::Duration {
+                    val: *lhs + *rhs,
+                    span,
+                })
+            }
+            (Value::Filesize { val: lhs, .. }, Value::Filesize { val: rhs, .. }) => {
+                Ok(Value::Filesize {
+                    val: *lhs + *rhs,
+                    span,
+                })
+            }
 
             _ => Err(ShellError::OperatorMismatch {
                 op_span: op,
@@ -420,6 +445,18 @@ impl Value {
                 val: lhs - rhs,
                 span,
             }),
+            (Value::Duration { val: lhs, .. }, Value::Duration { val: rhs, .. }) => {
+                Ok(Value::Duration {
+                    val: *lhs - *rhs,
+                    span,
+                })
+            }
+            (Value::Filesize { val: lhs, .. }, Value::Filesize { val: rhs, .. }) => {
+                Ok(Value::Filesize {
+                    val: *lhs - *rhs,
+                    span,
+                })
+            }
 
             _ => Err(ShellError::OperatorMismatch {
                 op_span: op,
@@ -541,6 +578,19 @@ impl Value {
                 val: lhs < rhs,
                 span,
             }),
+            (Value::Duration { val: lhs, .. }, Value::Duration { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs < rhs,
+                    span,
+                })
+            }
+            (Value::Filesize { val: lhs, .. }, Value::Filesize { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs < rhs,
+                    span,
+                })
+            }
+
             _ => Err(ShellError::OperatorMismatch {
                 op_span: op,
                 lhs_ty: self.get_type(),
@@ -570,6 +620,18 @@ impl Value {
                 val: lhs <= rhs,
                 span,
             }),
+            (Value::Duration { val: lhs, .. }, Value::Duration { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs <= rhs,
+                    span,
+                })
+            }
+            (Value::Filesize { val: lhs, .. }, Value::Filesize { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs <= rhs,
+                    span,
+                })
+            }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: op,
                 lhs_ty: self.get_type(),
@@ -599,6 +661,18 @@ impl Value {
                 val: lhs > rhs,
                 span,
             }),
+            (Value::Duration { val: lhs, .. }, Value::Duration { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs > rhs,
+                    span,
+                })
+            }
+            (Value::Filesize { val: lhs, .. }, Value::Filesize { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs > rhs,
+                    span,
+                })
+            }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: op,
                 lhs_ty: self.get_type(),
@@ -628,6 +702,18 @@ impl Value {
                 val: lhs >= rhs,
                 span,
             }),
+            (Value::Duration { val: lhs, .. }, Value::Duration { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs >= rhs,
+                    span,
+                })
+            }
+            (Value::Filesize { val: lhs, .. }, Value::Filesize { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs >= rhs,
+                    span,
+                })
+            }
             _ => Err(ShellError::OperatorMismatch {
                 op_span: op,
                 lhs_ty: self.get_type(),
@@ -664,6 +750,18 @@ impl Value {
                 val: lhs == rhs,
                 span,
             }),
+            (Value::Duration { val: lhs, .. }, Value::Duration { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs == rhs,
+                    span,
+                })
+            }
+            (Value::Filesize { val: lhs, .. }, Value::Filesize { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs == rhs,
+                    span,
+                })
+            }
             (Value::List { vals: lhs, .. }, Value::List { vals: rhs, .. }) => Ok(Value::Bool {
                 val: lhs == rhs,
                 span,
@@ -719,6 +817,18 @@ impl Value {
                 val: lhs != rhs,
                 span,
             }),
+            (Value::Duration { val: lhs, .. }, Value::Duration { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs != rhs,
+                    span,
+                })
+            }
+            (Value::Filesize { val: lhs, .. }, Value::Filesize { val: rhs, .. }) => {
+                Ok(Value::Bool {
+                    val: lhs != rhs,
+                    span,
+                })
+            }
             (Value::List { vals: lhs, .. }, Value::List { vals: rhs, .. }) => Ok(Value::Bool {
                 val: lhs != rhs,
                 span,
@@ -749,3 +859,69 @@ impl Value {
         }
     }
 }
+
+/// Format a duration in nanoseconds into a string
+pub fn format_duration(duration: i64) -> String {
+    let (sign, duration) = if duration >= 0 {
+        (1, duration)
+    } else {
+        (-1, -duration)
+    };
+    let (micros, nanos): (i64, i64) = (duration / 1000, duration % 1000);
+    let (millis, micros): (i64, i64) = (micros / 1000, micros % 1000);
+    let (secs, millis): (i64, i64) = (millis / 1000, millis % 1000);
+    let (mins, secs): (i64, i64) = (secs / 60, secs % 60);
+    let (hours, mins): (i64, i64) = (mins / 60, mins % 60);
+    let (days, hours): (i64, i64) = (hours / 24, hours % 24);
+
+    let mut output_prep = vec![];
+
+    if days != 0 {
+        output_prep.push(format!("{}day", days));
+    }
+
+    if hours != 0 {
+        output_prep.push(format!("{}hr", hours));
+    }
+
+    if mins != 0 {
+        output_prep.push(format!("{}min", mins));
+    }
+    // output 0sec for zero duration
+    if duration == 0 || secs != 0 {
+        output_prep.push(format!("{}sec", secs));
+    }
+
+    if millis != 0 {
+        output_prep.push(format!("{}ms", millis));
+    }
+
+    if micros != 0 {
+        output_prep.push(format!("{}us", micros));
+    }
+
+    if nanos != 0 {
+        output_prep.push(format!("{}ns", nanos));
+    }
+
+    format!(
+        "{}{}",
+        if sign == -1 { "-" } else { "" },
+        output_prep.join(" ")
+    )
+}
+
+fn format_filesize(num_bytes: i64) -> String {
+    let byte = byte_unit::Byte::from_bytes(num_bytes as u128);
+
+    if byte.get_bytes() == 0u128 {
+        return "—".to_string();
+    }
+
+    let byte = byte.get_appropriate_unit(false);
+
+    match byte.get_unit() {
+        byte_unit::ByteUnit::B => format!("{} B ", byte.get_value()),
+        _ => byte.format(1),
+    }
+}

crates/nu-protocol/src/value/unit.rs

@@ -0,0 +1,27 @@
+#[derive(Debug, Clone, Copy)]
+pub enum Unit {
+    // Filesize units: metric
+    Byte,
+    Kilobyte,
+    Megabyte,
+    Gigabyte,
+    Terabyte,
+    Petabyte,
+
+    // Filesize units: ISO/IEC 80000
+    Kibibyte,
+    Mebibyte,
+    Gibibyte,
+    Tebibyte,
+    Pebibyte,
+
+    // Duration units
+    Nanosecond,
+    Microsecond,
+    Millisecond,
+    Second,
+    Minute,
+    Hour,
+    Day,
+    Week,
+}