extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-08-09 00:44:57 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add general refactorings (#3996)

Browse Source
This commit is contained in:
Marcin Puc
2021-09-10 00:44:22 +02:00
committed by GitHub
parent ae9f4135c0
commit 51c74eebd0
165 changed files with 540 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
crates/nu-protocol/src/dataframe/compute_between.rs
View File

@ -88,7 +88,7 @@ pub fn between_dataframes(
Ok(df) => Ok(df.into_untagged()),
Err(e) => Ok(UntaggedValue::Error(ShellError::labeled_error(
"Appending error",
format!("{}", e),
e.to_string(),
operation_span,
))),
},
@ -110,19 +110,19 @@ pub fn compute_between_series(
Operator::Plus => {
let mut res = lhs + rhs;
let name = format!("sum_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Operator::Minus => {
let mut res = lhs - rhs;
let name = format!("sub_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Operator::Multiply => {
let mut res = lhs * rhs;
let name = format!("mul_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Operator::Divide => {
@ -130,12 +130,12 @@ pub fn compute_between_series(
match res {
Ok(mut res) => {
let name = format!("div_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Err(e) => Ok(UntaggedValue::Error(ShellError::labeled_error(
"Division error",
format!("{}", e),
e.to_string(),
operation_span,
))),
}
@ -143,37 +143,37 @@ pub fn compute_between_series(
Operator::Equal => {
let mut res = Series::eq(lhs, rhs).into_series();
let name = format!("eq_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Operator::NotEqual => {
let mut res = Series::neq(lhs, rhs).into_series();
let name = format!("neq_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Operator::LessThan => {
let mut res = Series::lt(lhs, rhs).into_series();
let name = format!("lt_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Operator::LessThanOrEqual => {
let mut res = Series::lt_eq(lhs, rhs).into_series();
let name = format!("lte_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Operator::GreaterThan => {
let mut res = Series::gt(lhs, rhs).into_series();
let name = format!("gt_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Operator::GreaterThanOrEqual => {
let mut res = Series::gt_eq(lhs, rhs).into_series();
let name = format!("gte_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
Operator::And => match lhs.dtype() {
@ -185,7 +185,7 @@ pub fn compute_between_series(
(Ok(l), Ok(r)) => {
let mut res = l.bitand(r).into_series();
let name = format!("and_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
_ => Ok(UntaggedValue::Error(ShellError::labeled_error(
@ -210,7 +210,7 @@ pub fn compute_between_series(
(Ok(l), Ok(r)) => {
let mut res = l.bitor(r).into_series();
let name = format!("or_{}_{}", lhs.name(), rhs.name());
res.rename(name.as_ref());
res.rename(&name);
Ok(NuDataFrame::series_to_untagged(res, operation_span))
}
_ => Ok(UntaggedValue::Error(ShellError::labeled_error(
@ -612,7 +612,7 @@ where
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Casting error",
format!("{}", e),
e.to_string(),
span,
)),
}
@ -649,7 +649,7 @@ where
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Casting error",
format!("{}", e),
e.to_string(),
span,
)),
}
@ -676,7 +676,7 @@ where
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Casting error",
format!("{}", e),
e.to_string(),
span,
)),
}
@ -719,7 +719,7 @@ where
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Casting error",
format!("{}", e),
e.to_string(),
span,
)),
}
@ -740,7 +740,7 @@ where
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Casting error",
format!("{}", e),
e.to_string(),
span,
)),
}
@ -777,7 +777,7 @@ where
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Casting error",
format!("{}", e),
e.to_string(),
span,
)),
}
@ -804,7 +804,7 @@ where
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Casting error",
format!("{}", e),
e.to_string(),
span,
)),
}
@ -847,7 +847,7 @@ where
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Casting error",
format!("{}", e),
e.to_string(),
span,
)),
}
@ -866,14 +866,14 @@ fn contains_series_pat(series: &Series, pat: &str, span: &Span) -> UntaggedValue
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Search error",
format!("{}", e),
e.to_string(),
span,
)),
}
}
Err(e) => UntaggedValue::Error(ShellError::labeled_error(
"Casting error",
format!("{}", e),
e.to_string(),
span,
)),
}

16
crates/nu-protocol/src/dataframe/conversion.rs
View File

@ -498,7 +498,7 @@ pub fn insert_row(column_values: &mut ColumnMap, dictionary: Dictionary) -> Resu
// The names for the columns are the enumerated numbers from the values
pub fn insert_table(column_values: &mut ColumnMap, table: Vec<Value>) -> Result<(), ShellError> {
for (index, value) in table.into_iter().enumerate() {
let key = format!("{}", index);
let key = index.to_string();
insert_value(value, key, column_values)?;
}
@ -617,7 +617,7 @@ pub fn from_parsed_columns(
let mut builder =
ObjectChunkedBuilder::<Value>::new(&name, column.values.len());
for v in column.values.iter() {
for v in &column.values {
builder.append_value(v.clone());
}
@ -658,12 +658,10 @@ pub fn from_parsed_columns(
match df {
Ok(df) => Ok(NuDataFrame::new(df)),
Err(e) => {
return Err(ShellError::labeled_error(
"Error while creating dataframe",
format!("{}", e),
span,
))
}
Err(e) => Err(ShellError::labeled_error(
"Error while creating dataframe",
e.to_string(),
span,
)),
}
}

18
crates/nu-protocol/src/dataframe/nu_dataframe.rs
View File

@ -176,7 +176,7 @@ impl NuDataFrame {
| UntaggedValue::Primitive(Primitive::Boolean(_))
| UntaggedValue::Primitive(Primitive::Date(_))
| UntaggedValue::DataFrame(_) => {
let key = format!("{}", 0);
let key = "0".to_string();
insert_value(value, key, &mut column_values)?
}
_ => {
@ -211,7 +211,7 @@ impl NuDataFrame {
for column in columns {
let name = column.name().to_string();
for value in column.into_iter() {
for value in column {
insert_value(value, name.clone(), &mut column_values)?;
}
}
@ -253,13 +253,13 @@ impl NuDataFrame {
}
pub fn column(&self, column: &str, tag: &Tag) -> Result<Self, ShellError> {
let s = self.as_ref().column(column).map_err(|e| {
ShellError::labeled_error("Column not found", format!("{}", e), tag.span)
})?;
let s = self
.as_ref()
.column(column)
.map_err(|e| ShellError::labeled_error("Column not found", e.to_string(), tag.span))?;
let dataframe = DataFrame::new(vec![s.clone()]).map_err(|e| {
ShellError::labeled_error("DataFrame error", format!("{}", e), tag.span)
})?;
let dataframe = DataFrame::new(vec![s.clone()])
.map_err(|e| ShellError::labeled_error("DataFrame error", e.to_string(), tag.span))?;
Ok(Self { dataframe })
}
@ -375,7 +375,7 @@ impl NuDataFrame {
.map(|i| {
let mut dictionary_row = Dictionary::default();
for (name, col) in iterators.iter_mut() {
for (name, col) in &mut iterators {
let dict_val = match col.next() {
Some(v) => v,
None => {

2
crates/nu-protocol/src/dataframe/nu_groupby.rs
View File

@ -50,7 +50,7 @@ impl NuGroupBy {
let df = self.dataframe.as_ref();
let by = df.select_series(&self.by).map_err(|e| {
ShellError::labeled_error("Error creating groupby", format!("{}", e), Tag::unknown())
ShellError::labeled_error("Error creating groupby", e.to_string(), Tag::unknown())
})?;
Ok(GroupBy::new(df, by, self.groups.clone(), None))

8
crates/nu-protocol/src/dataframe/operations.rs
View File

@ -40,7 +40,7 @@ impl NuDataFrame {
.as_ref()
.get_columns()
.iter()
.chain(other.as_ref().get_columns().iter())
.chain(other.as_ref().get_columns())
.map(|s| {
let name = if columns.contains(&s.name()) {
format!("{}_{}", s.name(), "x")
@ -50,13 +50,13 @@ impl NuDataFrame {
};
let mut series = s.clone();
series.rename(name.as_str());
series.rename(&name);
series
})
.collect::<Vec<Series>>();
let df_new = DataFrame::new(new_cols).map_err(|e| {
ShellError::labeled_error("Appending error", format!("{}", e), span)
ShellError::labeled_error("Appending error", e.to_string(), span)
})?;
Ok(NuDataFrame::new(df_new))
@ -110,7 +110,7 @@ impl NuDataFrame {
.collect::<Result<Vec<Series>, ShellError>>()?;
let df_new = DataFrame::new(new_cols).map_err(|e| {
ShellError::labeled_error("Appending error", format!("{}", e), span)
ShellError::labeled_error("Appending error", e.to_string(), span)
})?;
Ok(NuDataFrame::new(df_new))

35
crates/nu-protocol/src/hir.rs
View File

@ -3,6 +3,7 @@ use std::hash::{Hash, Hasher};
use std::path::PathBuf;
use std::{convert::From, sync::Arc};
use indexmap::map::Iter;
use serde::{Deserialize, Serialize};
use crate::Signature;
@ -384,7 +385,7 @@ impl PrettyDebugWithSource for Member {
fn pretty_debug(&self, source: &str) -> DebugDocBuilder {
match self {
Member::String(outer, _) => DbgDocBldr::value(outer.slice(source)),
Member::Int(int, _) => DbgDocBldr::value(format!("{}", int)),
Member::Int(int, _) => DbgDocBldr::value(int),
Member::Bare(span) => DbgDocBldr::value(span.span.slice(source)),
}
}
@ -786,13 +787,10 @@ impl PrettyDebugWithSource for SpannedExpression {
Expression::Table(_headers, cells) => DbgDocBldr::delimit(
"[",
DbgDocBldr::intersperse(
cells
.iter()
.map(|row| {
row.iter()
.map(|item| item.refined_pretty_debug(refine, source))
})
.flatten(),
cells.iter().flat_map(|row| {
row.iter()
.map(|item| item.refined_pretty_debug(refine, source))
}),
DbgDocBldr::space(),
),
"]",
@ -846,8 +844,7 @@ impl PrettyDebugWithSource for SpannedExpression {
DbgDocBldr::intersperse(
cells
.iter()
.map(|row| row.iter().map(|item| item.pretty_debug(source)))
.flatten(),
.flat_map(|row| row.iter().map(|item| item.pretty_debug(source))),
DbgDocBldr::space(),
),
"]",
@ -1014,7 +1011,7 @@ impl PrettyDebugWithSource for SpannedLiteral {
Literal::String(string) => DbgDocBldr::primitive(format!("{:?}", string)), //string.slice(source))),
Literal::GlobPattern(pattern) => DbgDocBldr::primitive(pattern),
Literal::ColumnPath(path) => {
DbgDocBldr::intersperse_with_source(path.iter(), DbgDocBldr::space(), source)
DbgDocBldr::intersperse_with_source(path, DbgDocBldr::space(), source)
}
Literal::Bare(bare) => {
DbgDocBldr::delimit("b\"", DbgDocBldr::primitive(bare), "\"")
@ -1039,7 +1036,7 @@ impl PrettyDebugWithSource for SpannedLiteral {
}
Literal::ColumnPath(path) => DbgDocBldr::typed(
"column path",
DbgDocBldr::intersperse_with_source(path.iter(), DbgDocBldr::space(), source),
DbgDocBldr::intersperse_with_source(path, DbgDocBldr::space(), source),
),
Literal::Bare(bare) => DbgDocBldr::typed("bare", DbgDocBldr::primitive(bare)),
Literal::Operator(operator) => {
@ -1359,7 +1356,7 @@ impl Call {
}
pub fn set_initial_flags(&mut self, signature: &crate::Signature) {
for (named, value) in signature.named.iter() {
for (named, value) in &signature.named {
if self.named.is_none() {
self.named = Some(NamedArguments::new());
}
@ -1570,7 +1567,7 @@ impl NamedArguments {
pub fn get_free_variables(&self, known_variables: &mut Vec<String>) -> Vec<String> {
let mut free_variables = vec![];
for (_, val) in self.named.iter() {
for (_, val) in &self.named {
free_variables.extend(val.get_free_variables(known_variables));
}
free_variables
@ -1646,6 +1643,16 @@ impl PrettyDebugWithSource for NamedArguments {
}
}
impl<'a> IntoIterator for &'a NamedArguments {
type Item = (&'a String, &'a NamedValue);
type IntoIter = Iter<'a, String, NamedValue>;
fn into_iter(self) -> Self::IntoIter {
self.named.iter()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum FlagKind {
Shorthand,

8
crates/nu-protocol/src/type_shape.rs
View File

@ -167,7 +167,7 @@ impl Type {
pub fn from_dictionary(dictionary: &Dictionary) -> Type {
let mut map = IndexMap::new();
for (key, value) in dictionary.entries.iter() {
for (key, value) in &dictionary.entries {
let column = Column::String(key.clone());
map.insert(column, Type::from_value(value));
}
@ -179,7 +179,7 @@ impl Type {
pub fn from_table<'a>(table: impl IntoIterator<Item = &'a Value>) -> Type {
let mut vec = vec![];
for item in table.into_iter() {
for item in table {
vec.push(Type::from_value(item))
}
@ -191,7 +191,7 @@ impl Type {
match value.into() {
UntaggedValue::Primitive(p) => Type::from_primitive(p),
UntaggedValue::Row(row) => Type::from_dictionary(row),
UntaggedValue::Table(table) => Type::from_table(table.iter()),
UntaggedValue::Table(table) => Type::from_table(table),
UntaggedValue::Error(_) => Type::Error,
UntaggedValue::Block(_) => Type::Block,
#[cfg(feature = "dataframe")]
@ -328,7 +328,7 @@ impl<'a> PrettyDebug for DebugEntry<'a> {
/// Helper to create a pretty-print for the type
fn ty(name: impl std::fmt::Display) -> DebugDocBuilder {
DbgDocBldr::kind(format!("{}", name))
DbgDocBldr::kind(name)
}
pub trait GroupedValue: Debug + Clone {

10
crates/nu-protocol/src/value.rs
View File

@ -401,11 +401,11 @@ impl Value {
match &self.value {
UntaggedValue::Primitive(Primitive::String(s)) => s.clone(),
UntaggedValue::Primitive(Primitive::Date(dt)) => dt.format("%Y-%m-%d").to_string(),
UntaggedValue::Primitive(Primitive::Boolean(x)) => format!("{}", x),
UntaggedValue::Primitive(Primitive::Decimal(x)) => format!("{}", x),
UntaggedValue::Primitive(Primitive::Int(x)) => format!("{}", x),
UntaggedValue::Primitive(Primitive::Filesize(x)) => format!("{}", x),
UntaggedValue::Primitive(Primitive::FilePath(x)) => format!("{}", x.display()),
UntaggedValue::Primitive(Primitive::Boolean(x)) => x.to_string(),
UntaggedValue::Primitive(Primitive::Decimal(x)) => x.to_string(),
UntaggedValue::Primitive(Primitive::Int(x)) => x.to_string(),
UntaggedValue::Primitive(Primitive::Filesize(x)) => x.to_string(),
UntaggedValue::Primitive(Primitive::FilePath(x)) => x.display().to_string(),
UntaggedValue::Primitive(Primitive::ColumnPath(path)) => {
let joined: String = path
.iter()

14
crates/nu-protocol/src/value/column_path.rs
View File

@ -38,7 +38,7 @@ impl PrettyDebug for &PathMember {
fn pretty(&self) -> DebugDocBuilder {
match &self.unspanned {
UnspannedPathMember::String(string) => DbgDocBldr::primitive(format!("{:?}", string)),
UnspannedPathMember::Int(int) => DbgDocBldr::primitive(format!("{}", int)),
UnspannedPathMember::Int(int) => DbgDocBldr::primitive(int),
}
}
}
@ -170,6 +170,16 @@ impl HasFallibleSpan for ColumnPath {
}
}
impl<'a> IntoIterator for &'a ColumnPath {
type Item = &'a PathMember;
type IntoIter = std::slice::Iter<'a, PathMember>;
fn into_iter(self) -> Self::IntoIter {
self.members.iter()
}
}
impl PathMember {
/// Create a string path member
pub fn string(string: impl Into<String>, span: impl Into<Span>) -> PathMember {
@ -184,7 +194,7 @@ impl PathMember {
pub fn as_string(&self) -> String {
match &self.unspanned {
UnspannedPathMember::String(string) => string.clone(),
UnspannedPathMember::Int(int) => format!("{}", int),
UnspannedPathMember::Int(int) => int.to_string(),
}
}
}

40
crates/nu-protocol/src/value/primitive.rs
View File

@ -90,14 +90,14 @@ impl Primitive {
Primitive::Int(int) => int.to_usize().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::U64,
&format!("{}", int).spanned(span),
&int.to_string().spanned(span),
"converting an integer into an unsigned 64-bit integer",
)
}),
Primitive::Decimal(decimal) => decimal.to_usize().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::U64,
&format!("{}", decimal).spanned(span),
&decimal.to_string().spanned(span),
"converting a decimal into an unsigned 64-bit integer",
)
}),
@ -114,14 +114,14 @@ impl Primitive {
Primitive::Int(int) => int.to_u64().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::U64,
&format!("{}", int).spanned(span),
&int.to_string().spanned(span),
"converting an integer into an unsigned 64-bit integer",
)
}),
Primitive::Decimal(decimal) => decimal.to_u64().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::U64,
&format!("{}", decimal).spanned(span),
&decimal.to_string().spanned(span),
"converting a decimal into an unsigned 64-bit integer",
)
}),
@ -138,14 +138,14 @@ impl Primitive {
Primitive::Int(int) => int.to_f64().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::F64,
&format!("{}", int).spanned(span),
&int.to_string().spanned(span),
"converting an integer into a 64-bit floating point",
)
}),
Primitive::Decimal(decimal) => decimal.to_f64().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::F64,
&format!("{}", decimal).spanned(span),
&decimal.to_string().spanned(span),
"converting a decimal into a 64-bit floating point",
)
}),
@ -162,21 +162,21 @@ impl Primitive {
Primitive::Int(int) => int.to_i64().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::I64,
&format!("{}", int).spanned(span),
&int.to_string().spanned(span),
"converting an integer into a signed 64-bit integer",
)
}),
Primitive::Decimal(decimal) => decimal.to_i64().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::I64,
&format!("{}", decimal).spanned(span),
&decimal.to_string().spanned(span),
"converting a decimal into a signed 64-bit integer",
)
}),
Primitive::Duration(duration) => duration.to_i64().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::I64,
&format!("{}", duration).spanned(span),
&duration.to_string().spanned(span),
"converting a duration into a signed 64-bit integer",
)
}),
@ -193,14 +193,14 @@ impl Primitive {
Primitive::Int(int) => int.to_u32().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::U32,
&format!("{}", int).spanned(span),
&int.to_string().spanned(span),
"converting an integer into a unsigned 32-bit integer",
)
}),
Primitive::Decimal(decimal) => decimal.to_u32().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::U32,
&format!("{}", decimal).spanned(span),
&decimal.to_string().spanned(span),
"converting a decimal into a unsigned 32-bit integer",
)
}),
@ -216,14 +216,14 @@ impl Primitive {
Primitive::Int(int) => int.to_i32().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::I32,
&format!("{}", int).spanned(span),
&int.to_string().spanned(span),
"converting an integer into a signed 32-bit integer",
)
}),
Primitive::Decimal(decimal) => decimal.to_i32().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::I32,
&format!("{}", decimal).spanned(span),
&decimal.to_string().spanned(span),
"converting a decimal into a signed 32-bit integer",
)
}),
@ -239,14 +239,14 @@ impl Primitive {
Primitive::Int(int) => int.to_i16().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::I16,
&format!("{}", int).spanned(span),
&int.to_string().spanned(span),
"converting an integer into a signed 16-bit integer",
)
}),
Primitive::Decimal(decimal) => decimal.to_i16().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::I16,
&format!("{}", decimal).spanned(span),
&decimal.to_string().spanned(span),
"converting a decimal into a signed 16-bit integer",
)
}),
@ -262,14 +262,14 @@ impl Primitive {
Primitive::Int(int) => int.to_f32().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::F32,
&format!("{}", int).spanned(span),
&int.to_string().spanned(span),
"converting an integer into a signed 32-bit float",
)
}),
Primitive::Decimal(decimal) => decimal.to_f32().ok_or_else(|| {
ShellError::range_error(
ExpectedRange::F32,
&format!("{}", decimal).spanned(span),
&decimal.to_string().spanned(span),
"converting a decimal into a signed 32-bit float",
)
}),
@ -460,7 +460,7 @@ pub fn format_primitive(primitive: &Primitive, field_name: Option<&String>) -> S
Primitive::Nothing => String::new(),
Primitive::BeginningOfStream => String::new(),
Primitive::EndOfStream => String::new(),
Primitive::FilePath(p) => format!("{}", p.display()),
Primitive::FilePath(p) => p.display().to_string(),
Primitive::Filesize(num_bytes) => {
if let Some(value) = num_bytes.to_u128() {
let byte = byte_unit::Byte::from_bytes(value);
@ -489,7 +489,7 @@ pub fn format_primitive(primitive: &Primitive, field_name: Option<&String>) -> S
if decimal_places.len() == 2 && decimal_places[1].len() > 4 {
format!("{:.4}", decimal)
} else {
format!("{}", decimal)
decimal.to_string()
}
}
Primitive::Range(range) => format!(
@ -595,5 +595,5 @@ pub fn format_duration(duration: &BigInt) -> String {
/// Format a date value into a humanized string (eg "1 week ago" instead of a formal date string)
pub fn format_date(d: &DateTime<FixedOffset>) -> String {
format!("{}", HumanTime::from(*d))
HumanTime::from(*d).to_string()
}