Restructure nu-protocol in more meaningful units (#11917)

This is partially "feng-shui programming" of moving things to new
separate places.

The later commits include "`git blame` tollbooths" by moving out chunks
of code into new files, which requires an extra step to track things
with `git blame`. We can negiotiate if you want to keep particular
things in their original place.

If egregious I tried to add a bit of documentation. If I see something
that is unused/unnecessarily `pub` I will try to remove that.


- Move `nu_protocol::Exportable` to `nu-parser`
- Guess doccomment for `Exportable`
- Move `Unit` enum from `value` to `AST`
- Move engine state `Variable` def into its folder
- Move error-related files in `nu-protocol` subdir
- Move `pipeline_data` module into its own folder
- Move `stream.rs` over into the `pipeline_data` mod
- Move `PipelineMetadata` into its own file
- Doccomment `PipelineMetadata`
- Remove unused `is_leap_year` in `value/mod`
- Note about criminal `type_compatible` helper
- Move duration fmting into new `value/duration.rs`
- Move filesize fmting logic to new `value/filesize`
- Split reexports from standard imports in `value/mod`
- Doccomment trait `CustomValue`
- Polish doccomments and intradoc links

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

@@ -5,7 +5,7 @@ use super::{
     Call, CellPath, Expression, ExternalArgument, FullCellPath, MatchPattern, Operator,
     RangeOperator,
 };
-use crate::{ast::ImportPattern, BlockId, Signature, Span, Spanned, Unit, VarId};
+use crate::{ast::ImportPattern, ast::Unit, BlockId, Signature, Span, Spanned, VarId};
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum Expr {

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

@@ -7,6 +7,7 @@ mod import_pattern;
 mod match_pattern;
 mod operator;
 mod pipeline;
+mod unit;
 
 pub use block::*;
 pub use call::*;
@@ -17,3 +18,4 @@ pub use import_pattern::*;
 pub use match_pattern::*;
 pub use operator::*;
 pub use pipeline::*;
+pub use unit::*;

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

@@ -0,0 +1,110 @@
+use crate::{ShellError, Span, Value};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Unit {
+    // Filesize units: metric
+    Byte,
+    Kilobyte,
+    Megabyte,
+    Gigabyte,
+    Terabyte,
+    Petabyte,
+    Exabyte,
+
+    // Filesize units: ISO/IEC 80000
+    Kibibyte,
+    Mebibyte,
+    Gibibyte,
+    Tebibyte,
+    Pebibyte,
+    Exbibyte,
+
+    // Duration units
+    Nanosecond,
+    Microsecond,
+    Millisecond,
+    Second,
+    Minute,
+    Hour,
+    Day,
+    Week,
+}
+
+impl Unit {
+    pub fn to_value(&self, size: i64, span: Span) -> Result<Value, ShellError> {
+        match self {
+            Unit::Byte => Ok(Value::filesize(size, span)),
+            Unit::Kilobyte => Ok(Value::filesize(size * 1000, span)),
+            Unit::Megabyte => Ok(Value::filesize(size * 1000 * 1000, span)),
+            Unit::Gigabyte => Ok(Value::filesize(size * 1000 * 1000 * 1000, span)),
+            Unit::Terabyte => Ok(Value::filesize(size * 1000 * 1000 * 1000 * 1000, span)),
+            Unit::Petabyte => Ok(Value::filesize(
+                size * 1000 * 1000 * 1000 * 1000 * 1000,
+                span,
+            )),
+            Unit::Exabyte => Ok(Value::filesize(
+                size * 1000 * 1000 * 1000 * 1000 * 1000 * 1000,
+                span,
+            )),
+
+            Unit::Kibibyte => Ok(Value::filesize(size * 1024, span)),
+            Unit::Mebibyte => Ok(Value::filesize(size * 1024 * 1024, span)),
+            Unit::Gibibyte => Ok(Value::filesize(size * 1024 * 1024 * 1024, span)),
+            Unit::Tebibyte => Ok(Value::filesize(size * 1024 * 1024 * 1024 * 1024, span)),
+            Unit::Pebibyte => Ok(Value::filesize(
+                size * 1024 * 1024 * 1024 * 1024 * 1024,
+                span,
+            )),
+            Unit::Exbibyte => Ok(Value::filesize(
+                size * 1024 * 1024 * 1024 * 1024 * 1024 * 1024,
+                span,
+            )),
+
+            Unit::Nanosecond => Ok(Value::duration(size, span)),
+            Unit::Microsecond => Ok(Value::duration(size * 1000, span)),
+            Unit::Millisecond => Ok(Value::duration(size * 1000 * 1000, span)),
+            Unit::Second => Ok(Value::duration(size * 1000 * 1000 * 1000, span)),
+            Unit::Minute => match size.checked_mul(1000 * 1000 * 1000 * 60) {
+                Some(val) => Ok(Value::duration(val, span)),
+                None => Err(ShellError::GenericError {
+                    error: "duration too large".into(),
+                    msg: "duration too large".into(),
+                    span: Some(span),
+                    help: None,
+                    inner: vec![],
+                }),
+            },
+            Unit::Hour => match size.checked_mul(1000 * 1000 * 1000 * 60 * 60) {
+                Some(val) => Ok(Value::duration(val, span)),
+                None => Err(ShellError::GenericError {
+                    error: "duration too large".into(),
+                    msg: "duration too large".into(),
+                    span: Some(span),
+                    help: None,
+                    inner: vec![],
+                }),
+            },
+            Unit::Day => match size.checked_mul(1000 * 1000 * 1000 * 60 * 60 * 24) {
+                Some(val) => Ok(Value::duration(val, span)),
+                None => Err(ShellError::GenericError {
+                    error: "duration too large".into(),
+                    msg: "duration too large".into(),
+                    span: Some(span),
+                    help: None,
+                    inner: vec![],
+                }),
+            },
+            Unit::Week => match size.checked_mul(1000 * 1000 * 1000 * 60 * 60 * 24 * 7) {
+                Some(val) => Ok(Value::duration(val, span)),
+                None => Err(ShellError::GenericError {
+                    error: "duration too large".into(),
+                    msg: "duration too large".into(),
+                    span: Some(span),
+                    help: None,
+                    inner: vec![],
+                }),
+            },
+        }
+    }
+}