Fix some value formatter issue

Author: 38

src/chart/context.rs

@@ -274,7 +274,7 @@ impl<'a, DB: DrawingBackend, CT: ReverseCoordTranslate> ChartContext<'a, DB, CT>
 impl<'a, DB: DrawingBackend, X: Ranged, Y: Ranged> ChartContext<'a, DB, Arc<RangedCoord<X, Y>>> {
     // TODO: All draw_series_impl is over strict on lifetime, because we don't have stable HKT,
     //       what we can ensure is for all lifetime 'b the element reference &'b E is a iterator
-    //       of points reference with the same lifetime. 
+    //       of points reference with the same lifetime.
     //       However, this doesn't work if the coordinate doesn't live longer than the backend,
     //       this is unneccessarily strct
     pub(super) fn draw_series_impl<E, R, S>(

src/coord/discrete.rs

@@ -1,5 +1,4 @@
-use super::{AsRangedCoord, Ranged};
-use std::fmt::{Debug, Formatter, Result as FmtResult};
+use super::{AsRangedCoord, Ranged, ValueFormatter};
 use std::ops::Range;
 
 /// The trait indicates the coordinate is discrete
@@ -108,25 +107,28 @@ where
 impl<R: AsRangedCoord> IntoCentric for R where R::CoordDescType: DiscreteRanged {}
 
 /// The value that used by the centric coordinate
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum CentricValues<T> {
     Exact(T),
     CenterOf(T),
     Last,
 }
 
-impl<D: Debug> Debug for CentricValues<D> {
-    fn fmt(&self, formatter: &mut Formatter) -> FmtResult {
-        match self {
-            CentricValues::Exact(value) => write!(formatter, "{:?}", value),
-            CentricValues::CenterOf(value) => write!(formatter, "{:?}", value),
-            CentricValues::Last => Ok(()),
+impl <T, D: DiscreteRanged + Ranged<ValueType = T>> ValueFormatter<CentricValues<T>> for CentricDiscreteRange<D> 
+where 
+    D: ValueFormatter<T>
+{
+    fn format(value: &CentricValues<T>) -> String {
+        match value {
+            CentricValues::Exact(ref value) => D::format(value),
+            CentricValues::CenterOf(ref value) => D::format(value),
+            _ => "".to_string()
         }
     }
 }
 
 impl<D: DiscreteRanged> Ranged for CentricDiscreteRange<D> {
-    type FormatOption = crate::coord::ranged::DefaultFormatting;
+    type FormatOption = crate::coord::ranged::NoDefaultFormatting;
     type ValueType = CentricValues<D::ValueType>;
 
     fn map(&self, value: &Self::ValueType, limit: (i32, i32)) -> i32 {

src/coord/group_by.rs

@@ -1,5 +1,5 @@
 use super::numeric::RangedCoordusize;
-use super::{AsRangedCoord, DiscreteRanged, Ranged};
+use super::{AsRangedCoord, DiscreteRanged, Ranged, ValueFormatter};
 use std::ops::Range;
 
 /// The ranged value spec that needs to be grouped.
@@ -37,8 +37,14 @@ impl<T: DiscreteRanged> DiscreteRanged for GroupBy<T> {
     }
 }
 
+impl<T, R: DiscreteRanged<ValueType = T> + ValueFormatter<T>> ValueFormatter<T> for GroupBy<R> {
+    fn format(value: &T) -> String {
+        R::format(value)
+    }
+}
+
 impl<T: DiscreteRanged> Ranged for GroupBy<T> {
-    type FormatOption = crate::coord::ranged::DefaultFormatting;
+    type FormatOption = crate::coord::ranged::NoDefaultFormatting;
     type ValueType = T::ValueType;
     fn map(&self, value: &T::ValueType, limit: (i32, i32)) -> i32 {
         self.0.map(value, limit)

src/coord/linspace.rs

@@ -1,4 +1,4 @@
-use super::{numeric::RangedCoordusize, AsRangedCoord, DiscreteRanged, Ranged};
+use super::{numeric::RangedCoordusize, AsRangedCoord, DiscreteRanged, Ranged, ValueFormatter};
 use std::cmp::{Ordering, PartialOrd};
 use std::marker::PhantomData;
 use std::ops::{Add, Range, Sub};
@@ -251,11 +251,23 @@ where
     }
 }
 
+impl<T, R, S, RM> ValueFormatter<T> for Linspace<R, S, RM>
+where
+    R: Ranged<ValueType = T> + ValueFormatter<T>,
+    RM: LinspaceRoundingMethod<T>,
+    T: Add<S, Output = T> + PartialOrd + Clone,
+    S: Clone,
+{
+    fn format(value: &T) -> String {
+        R::format(value)
+    }
+}
+
 impl<T: Ranged, S: Clone, R: LinspaceRoundingMethod<T::ValueType>> Ranged for Linspace<T, S, R>
 where
     T::ValueType: Add<S, Output = T::ValueType> + PartialOrd + Clone,
 {
-    type FormatOption = crate::coord::ranged::DefaultFormatting;
+    type FormatOption = crate::coord::ranged::NoDefaultFormatting;
     type ValueType = T::ValueType;
 
     fn range(&self) -> Range<T::ValueType> {

src/coord/nested.rs

@@ -1,9 +1,8 @@
-use super::{AsRangedCoord, DiscreteRanged, Ranged};
-use std::fmt::{Debug, Formatter, Result as FmtResult};
+use super::{AsRangedCoord, DiscreteRanged, Ranged, ValueFormatter};
 use std::ops::Range;
 
 /// Describe a value for a nested croodinate
-#[derive(PartialEq, Eq, Clone)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub enum NestedValue<C, V> {
     /// Category value
     Category(C),
@@ -40,15 +39,6 @@ impl<C, V> From<C> for NestedValue<C, V> {
     }
 }
 
-impl<C: Debug, V: Debug> Debug for NestedValue<C, V> {
-    fn fmt(&self, formatter: &mut Formatter) -> FmtResult {
-        match self {
-            NestedValue::Category(cat) => write!(formatter, "{:?}", cat),
-            NestedValue::Value(_, val) => write!(formatter, "{:?}", val),
-        }
-    }
-}
-
 /// A nested coordinate spec which is a discrete coordinate on the top level and
 /// for each value in discrete value, there is a secondary coordinate system.
 /// And the value is defined as a tuple of primary coordinate value and secondary
@@ -58,8 +48,23 @@ pub struct NestedRange<Primary: DiscreteRanged, Secondary: Ranged> {
     secondary: Vec<Secondary>,
 }
 
+impl <PT, ST, P, S> ValueFormatter<NestedValue<PT, ST>> for NestedRange<P, S>
+where
+    P: Ranged<ValueType = PT> + DiscreteRanged,
+    S: Ranged<ValueType = ST>,
+    P: ValueFormatter<PT>,
+    S: ValueFormatter<ST>,
+{
+    fn format(value: &NestedValue<PT, ST>) -> String{
+        match value {
+            NestedValue::Category(cat) => P::format(cat),
+            NestedValue::Value(_, val) => S::format(val),
+        }
+    }
+}
+
 impl<P: DiscreteRanged, S: Ranged> Ranged for NestedRange<P, S> {
-    type FormatOption = crate::coord::ranged::DefaultFormatting;
+    type FormatOption = crate::coord::ranged::NoDefaultFormatting;
     type ValueType = NestedValue<P::ValueType, S::ValueType>;
 
     fn range(&self) -> Range<Self::ValueType> {