Ignore the "ver" meta entry when decoding from JSON

Ignore the "ver" meta entry when decoding from JSON Fixes issue #10
j2inn · Sep 30, 2022 · 18a4506 · 18a4506
1 parent 57ffd43
commit 18a4506
Show file tree

Hide file tree

Showing 8 changed files with 119 additions and 41 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "libhaystack"
-version = "1.0.8"
+version = "1.0.9"
 description = "Rust implementation of the Haystack 4 data types, defs, filter, units, and encodings"
 authors = ["J2 Innovations", "Radu Racariu <[email protected]>"]
 edition = "2021"

diff --git a/src/haystack/encoding/json/decode.rs b/src/haystack/encoding/json/decode.rs
@@ -10,6 +10,7 @@ use crate::haystack::val::{
 
 use crate::haystack::timezone::make_date_time_with_tz;
 use crate::units::get_unit;
+use crate::val::GRID_FORMAT_VERSION;
 
 use chrono::{Offset, Utc};
 use serde::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
@@ -300,52 +301,52 @@ impl<'de> Visitor<'de> for HValVisitor {
 
         match kind.as_str() {
             "number" => match parse_number(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson Number. {err}"))),
             },
 
             "ref" => match parse_ref(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson Ref. {err}"))),
             },
 
             "symbol" => match parse_symbol(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson Symbol. {err}"))),
             },
 
             "uri" => match parse_uri(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson Uri. {err}"))),
             },
 
             "date" => match parse_date(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson Date. {err}"))),
             },
 
             "time" => match parse_time(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson Time. {err}"))),
             },
 
             "dateTime" => match parse_datetime(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson DateTime. {err}"))),
             },
 
             "coord" => match parse_coord(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson Coord. {err}"))),
             },
 
             "xstr" => match parse_xstr(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson XStr. {err}"))),
             },
 
             "grid" => match parse_grid(&dict) {
-                Ok(num) => Ok(num),
+                Ok(val) => Ok(val),
                 Err(err) => Err(A::Error::custom(format!("Invalid Hayson Grid. {err}"))),
             },
             _ => Ok(HVal::make_dict(dict)),
@@ -469,9 +470,16 @@ fn parse_grid(dict: &Dict) -> Result<HVal, JsonErr> {
     match dict.get_list("rows") {
         Some(rows) => match dict.get_list("cols") {
             Some(cols) => {
-                let grid = Grid {
-                    meta: dict.get_dict("meta").cloned(),
+                let mut grid_ver = GRID_FORMAT_VERSION.to_string();
 
+                let grid = Grid {
+                    meta: dict.get_dict("meta").cloned().map(|mut meta| {
+                        if let Some(ver) = meta.get_str("ver") {
+                            grid_ver = ver.value.to_owned();
+                        };
+                        meta.remove("ver");
+                        meta
+                    }),
                     columns: {
                         let cols: Result<Vec<Column>, JsonErr> = cols
                             .iter()
@@ -508,6 +516,7 @@ fn parse_grid(dict: &Dict) -> Result<HVal, JsonErr> {
                             .collect();
                         rows?
                     },
+                    ver: grid_ver,
                 };
                 Ok(grid.into())
             }

diff --git a/src/haystack/encoding/zinc/decode/complex/grid.rs b/src/haystack/encoding/zinc/decode/complex/grid.rs
@@ -58,7 +58,7 @@ fn parse_grid_content<'a, 'b: 'a, R: Read>(
 ) -> Result<(Grid, RowParser<'a, 'b, R>), Error> {
     let has_nested_grid_start = parse_nested_grid_start(parser)?;
 
-    parse_grid_ver(parser)?;
+    let ver = parse_grid_ver(parser)?;
 
     parser.lexer.read()?;
 
@@ -74,6 +74,7 @@ fn parse_grid_content<'a, 'b: 'a, R: Read>(
         meta: if meta.is_empty() { None } else { Some(meta) },
         columns,
         rows: Vec::default(),
+        ver,
     };
 
     Ok((
@@ -432,6 +433,7 @@ mod test {
                     }
                 ],
                 rows: vec![dict! {"id" => Value::make_ref("foo")}],
+                ver: GRID_FORMAT_VERSION.to_string()
             })
         )
     }
@@ -472,6 +474,7 @@ mod test {
                     dict! {"id" => Value::make_ref("foo")},
                     dict! {"id" => Value::make_ref("bar")}
                 ],
+                ver: GRID_FORMAT_VERSION.to_string()
             })
         )
     }

diff --git a/src/haystack/encoding/zinc/encode.rs b/src/haystack/encoding/zinc/encode.rs
@@ -4,14 +4,11 @@
 
 use crate::haystack::val::{
     Bool, Column, Coord, Date, DateTime, Dict, Grid, List, Marker, Na, Number, Ref, Remove, Str,
-    Symbol, Time, Uri, Value, XStr,
+    Symbol, Time, Uri, Value, XStr, GRID_FORMAT_VERSION,
 };
 use chrono::SecondsFormat;
 use std::fmt::Display;
 
-/// Zinc encoding version
-pub const VER: f32 = 3.0;
-
 /// Zinc encoding trait implemented by scalar and collection types
 pub trait ToZinc {
     fn to_zinc<W: std::io::Write>(&self, writer: &mut W) -> Result<()>;
@@ -282,7 +279,7 @@ impl ZincEncode for Grid {
             writer.write_all(b"<<\n")?;
         }
 
-        writer.write_fmt(format_args!("ver:\"{:.1}\"\n", VER))?;
+        writer.write_fmt(format_args!("ver:\"{GRID_FORMAT_VERSION}\"\n"))?;
 
         // Grid meta
         if let Some(meta) = &self.meta {

diff --git a/src/haystack/val/grid.rs b/src/haystack/val/grid.rs
@@ -18,6 +18,9 @@ pub struct Column {
     pub meta: Option<Dict>,
 }
 
+/// The version of the grid format supported by this library
+pub const GRID_FORMAT_VERSION: &str = "3.0";
+
 /// Haystack Grid
 ///
 /// # Example
@@ -53,6 +56,8 @@ pub struct Grid {
     pub columns: Vec<Column>,
     /// List of the row for this `Grid`
     pub rows: Vec<Dict>,
+    /// The version of this grid
+    pub ver: String,
 }
 
 impl Grid {
@@ -65,6 +70,7 @@ impl Grid {
                 meta: None,
             }],
             rows: Vec::default(),
+            ver: GRID_FORMAT_VERSION.to_string(),
         }
     }
 
@@ -91,6 +97,7 @@ impl Grid {
             meta: None,
             columns,
             rows,
+            ver: GRID_FORMAT_VERSION.to_string(),
         }
     }
 
@@ -134,6 +141,7 @@ impl Grid {
                 meta: None,
             }],
             rows: Vec::default(),
+            ver: GRID_FORMAT_VERSION.to_string(),
         }
     }
 
@@ -164,6 +172,7 @@ impl Default for Grid {
             columns: Vec::default(),
             meta: None,
             rows: Vec::default(),
+            ver: GRID_FORMAT_VERSION.to_string(),
         }
     }
 }