allow str from to convert more things to string (#2977)

* allow str from to convert more things to string

* fixed FileSize so it reports with units configured

* added tests

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

@@ -1,8 +1,8 @@
 use derive_new::new;
 use getset::Getters;
 use nu_source::{
-    b, span_for_spanned_list, DebugDocBuilder, HasFallibleSpan, PrettyDebug, Span, Spanned,
-    SpannedItem,
+    span_for_spanned_list, DbgDocBldr, DebugDocBuilder, HasFallibleSpan, PrettyDebug, Span,
+    Spanned, SpannedItem,
 };
 use num_bigint::BigInt;
 use serde::{Deserialize, Serialize};
@@ -38,8 +38,8 @@ impl PrettyDebug for &PathMember {
     /// Gets the PathMember ready to be pretty-printed
     fn pretty(&self) -> DebugDocBuilder {
         match &self.unspanned {
-            UnspannedPathMember::String(string) => b::primitive(format!("{:?}", string)),
-            UnspannedPathMember::Int(int) => b::primitive(format!("{}", int)),
+            UnspannedPathMember::String(string) => DbgDocBldr::primitive(format!("{:?}", string)),
+            UnspannedPathMember::Int(int) => DbgDocBldr::primitive(format!("{}", int)),
         }
     }
 }
@@ -96,9 +96,11 @@ impl PrettyDebug for ColumnPath {
         let members: Vec<DebugDocBuilder> =
             self.members.iter().map(|member| member.pretty()).collect();
 
-        b::delimit(
+        DbgDocBldr::delimit(
             "(",
-            b::description("path") + b::equals() + b::intersperse(members, b::space()),
+            DbgDocBldr::description("path")
+                + DbgDocBldr::equals()
+                + DbgDocBldr::intersperse(members, DbgDocBldr::space()),
             ")",
         )
         .nest()

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

@@ -1,7 +1,7 @@
 use crate::type_name::PrettyType;
 use crate::value::primitive::Primitive;
 use crate::value::{UntaggedValue, Value};
-use nu_source::{b, DebugDocBuilder, PrettyDebug};
+use nu_source::{DbgDocBldr, DebugDocBuilder, PrettyDebug};
 
 impl PrettyDebug for &Value {
     /// Get a borrowed Value ready to be pretty-printed
@@ -16,11 +16,14 @@ impl PrettyDebug for Value {
         match &self.value {
             UntaggedValue::Primitive(p) => p.pretty(),
             UntaggedValue::Row(row) => row.pretty_builder().nest(1).group().into(),
-            UntaggedValue::Table(table) => {
-                b::delimit("[", b::intersperse(table, b::space()), "]").nest()
-            }
-            UntaggedValue::Error(_) => b::error("error"),
-            UntaggedValue::Block(_) => b::opaque("block"),
+            UntaggedValue::Table(table) => DbgDocBldr::delimit(
+                "[",
+                DbgDocBldr::intersperse(table, DbgDocBldr::space()),
+                "]",
+            )
+            .nest(),
+            UntaggedValue::Error(_) => DbgDocBldr::error("error"),
+            UntaggedValue::Block(_) => DbgDocBldr::opaque("block"),
         }
     }
 }
@@ -42,8 +45,8 @@ impl PrettyType for Primitive {
             Primitive::Duration(_) => ty("duration"),
             Primitive::FilePath(_) => ty("path"),
             Primitive::Binary(_) => ty("binary"),
-            Primitive::BeginningOfStream => b::keyword("beginning-of-stream"),
-            Primitive::EndOfStream => b::keyword("end-of-stream"),
+            Primitive::BeginningOfStream => DbgDocBldr::keyword("beginning-of-stream"),
+            Primitive::EndOfStream => DbgDocBldr::keyword("end-of-stream"),
         }
     }
 }
@@ -52,19 +55,19 @@ impl PrettyDebug for Primitive {
     /// Get a Primitive value ready to be pretty-printed
     fn pretty(&self) -> DebugDocBuilder {
         match self {
-            Primitive::Nothing => b::primitive("nothing"),
+            Primitive::Nothing => DbgDocBldr::primitive("nothing"),
             Primitive::Int(int) => prim(format_args!("{}", int)),
             Primitive::Decimal(decimal) => prim(format_args!("{}", decimal)),
             Primitive::Range(range) => {
                 let (left, left_inclusion) = &range.from;
                 let (right, right_inclusion) = &range.to;
 
-                b::typed(
+                DbgDocBldr::typed(
                     "range",
                     (left_inclusion.debug_left_bracket()
                         + left.pretty()
-                        + b::operator(",")
-                        + b::space()
+                        + DbgDocBldr::operator(",")
+                        + DbgDocBldr::space()
                         + right.pretty()
                         + right_inclusion.debug_right_bracket())
                     .group(),
@@ -75,27 +78,28 @@ impl PrettyDebug for Primitive {
             Primitive::ColumnPath(path) => path.pretty(),
             Primitive::GlobPattern(pattern) => primitive_doc(pattern, "pattern"),
             Primitive::Boolean(boolean) => match boolean {
-                true => b::primitive("$yes"),
-                false => b::primitive("$no"),
+                true => DbgDocBldr::primitive("$yes"),
+                false => DbgDocBldr::primitive("$no"),
             },
             Primitive::Date(date) => primitive_doc(date, "date"),
             Primitive::Duration(duration) => primitive_doc(duration, "nanoseconds"),
             Primitive::FilePath(path) => primitive_doc(path, "path"),
-            Primitive::Binary(_) => b::opaque("binary"),
-            Primitive::BeginningOfStream => b::keyword("beginning-of-stream"),
-            Primitive::EndOfStream => b::keyword("end-of-stream"),
+            Primitive::Binary(_) => DbgDocBldr::opaque("binary"),
+            Primitive::BeginningOfStream => DbgDocBldr::keyword("beginning-of-stream"),
+            Primitive::EndOfStream => DbgDocBldr::keyword("end-of-stream"),
         }
     }
 }
 
 fn prim(name: impl std::fmt::Debug) -> DebugDocBuilder {
-    b::primitive(format!("{:?}", name))
+    DbgDocBldr::primitive(format!("{:?}", name))
 }
 
 fn primitive_doc(name: impl std::fmt::Debug, ty: impl Into<String>) -> DebugDocBuilder {
-    b::primitive(format!("{:?}", name)) + b::delimit("(", b::kind(ty.into()), ")")
+    DbgDocBldr::primitive(format!("{:?}", name))
+        + DbgDocBldr::delimit("(", DbgDocBldr::kind(ty.into()), ")")
 }
 
 fn ty(name: impl std::fmt::Debug) -> DebugDocBuilder {
-    b::kind(format!("{:?}", name))
+    DbgDocBldr::kind(format!("{:?}", name))
 }

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

@@ -4,7 +4,7 @@ use crate::value::{UntaggedValue, Value};
 use derive_new::new;
 use getset::Getters;
 use indexmap::IndexMap;
-use nu_source::{b, DebugDocBuilder, PrettyDebug, Spanned, SpannedItem, Tag};
+use nu_source::{DbgDocBldr, DebugDocBuilder, PrettyDebug, Spanned, SpannedItem, Tag};
 use serde::{Deserialize, Serialize};
 use std::cmp::{Ord, Ordering, PartialOrd};
 use std::hash::{Hash, Hasher};
@@ -78,20 +78,23 @@ struct DebugEntry<'a> {
 impl<'a> PrettyDebug for DebugEntry<'a> {
     /// Build the the information to pretty-print the DebugEntry
     fn pretty(&self) -> DebugDocBuilder {
-        (b::key(self.key.to_string()) + b::equals() + self.value.pretty().into_value()).group()
+        (DbgDocBldr::key(self.key.to_string())
+            + DbgDocBldr::equals()
+            + self.value.pretty().into_value())
+        .group()
     }
 }
 
 impl PrettyDebug for Dictionary {
     /// Get a Dictionary ready to be pretty-printed
     fn pretty(&self) -> DebugDocBuilder {
-        b::delimit(
+        DbgDocBldr::delimit(
             "(",
-            b::intersperse(
+            DbgDocBldr::intersperse(
                 self.entries()
                     .iter()
                     .map(|(key, value)| DebugEntry::new(key, value)),
-                b::space(),
+                DbgDocBldr::space(),
             ),
             ")",
         )

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

@@ -1,6 +1,6 @@
 use crate::value::Primitive;
 use derive_new::new;
-use nu_source::{b, DebugDocBuilder, Spanned};
+use nu_source::{DbgDocBldr, DebugDocBuilder, Spanned};
 use serde::{Deserialize, Serialize};
 
 /// The two types of ways to include a range end. Inclusive means to include the value (eg 1..3 inclusive would include the 3 value).
@@ -14,7 +14,7 @@ pub enum RangeInclusion {
 impl RangeInclusion {
     /// Get a RangeInclusion left bracket ready for pretty printing
     pub fn debug_left_bracket(self) -> DebugDocBuilder {
-        b::delimiter(match self {
+        DbgDocBldr::delimiter(match self {
             RangeInclusion::Exclusive => "(",
             RangeInclusion::Inclusive => "[",
         })
@@ -22,7 +22,7 @@ impl RangeInclusion {
 
     /// Get a RangeInclusion right bracket ready for pretty printing
     pub fn debug_right_bracket(self) -> DebugDocBuilder {
-        b::delimiter(match self {
+        DbgDocBldr::delimiter(match self {
             RangeInclusion::Exclusive => ")",
             RangeInclusion::Inclusive => "]",
         })