From 3024fefcb9d338919e0a3b5b1b90fb77d2313330 Mon Sep 17 00:00:00 2001 From: Matthias Beyer Date: Sat, 26 Aug 2017 17:48:23 +0200 Subject: [PATCH] Remove toml_ext module --- lib/core/libimagstore/src/lib.rs | 1 - lib/core/libimagstore/src/store.rs | 20 +- lib/core/libimagstore/src/toml_ext.rs | 803 -------------------------- 3 files changed, 1 insertion(+), 823 deletions(-) delete mode 100644 lib/core/libimagstore/src/toml_ext.rs diff --git a/lib/core/libimagstore/src/lib.rs b/lib/core/libimagstore/src/lib.rs index ae205b83..c879e230 100644 --- a/lib/core/libimagstore/src/lib.rs +++ b/lib/core/libimagstore/src/lib.rs @@ -58,5 +58,4 @@ pub mod error; pub mod store; mod configuration; pub mod file_abstraction; -pub mod toml_ext; diff --git a/lib/core/libimagstore/src/store.rs b/lib/core/libimagstore/src/store.rs index aba0583d..af7e5aaf 100644 --- a/lib/core/libimagstore/src/store.rs +++ b/lib/core/libimagstore/src/store.rs @@ -42,7 +42,7 @@ use error::{StoreError as SE, StoreErrorKind as SEK, ParserError, ParserErrorKin use error::MapErrInto; use storeid::{IntoStoreId, StoreId, StoreIdIterator}; use file_abstraction::FileAbstractionInstance; -use toml_ext::*; + // We re-export the following things so tests can use them pub use file_abstraction::FileAbstraction; pub use file_abstraction::FSFileAbstraction; @@ -1222,8 +1222,6 @@ mod test { #[test] fn test_imag_section() { - use toml_ext::has_main_section; - let mut map = BTreeMap::new(); map.insert("imag".into(), Value::Table(BTreeMap::new())); @@ -1232,8 +1230,6 @@ mod test { #[test] fn test_imag_invalid_section_type() { - use toml_ext::has_main_section; - let mut map = BTreeMap::new(); map.insert("imag".into(), Value::Boolean(false)); @@ -1242,8 +1238,6 @@ mod test { #[test] fn test_imag_abscent_main_section() { - use toml_ext::has_main_section; - let mut map = BTreeMap::new(); map.insert("not_imag".into(), Value::Boolean(false)); @@ -1252,8 +1246,6 @@ mod test { #[test] fn test_main_section_without_version() { - use toml_ext::has_imag_version_in_main_section; - let mut map = BTreeMap::new(); map.insert("imag".into(), Value::Table(BTreeMap::new())); @@ -1262,8 +1254,6 @@ mod test { #[test] fn test_main_section_with_version() { - use toml_ext::has_imag_version_in_main_section; - let mut map = BTreeMap::new(); let mut sub = BTreeMap::new(); sub.insert("version".into(), Value::String("0.0.0".into())); @@ -1274,8 +1264,6 @@ mod test { #[test] fn test_main_section_with_version_in_wrong_type() { - use toml_ext::has_imag_version_in_main_section; - let mut map = BTreeMap::new(); let mut sub = BTreeMap::new(); sub.insert("version".into(), Value::Boolean(false)); @@ -1286,8 +1274,6 @@ mod test { #[test] fn test_verification_good() { - use toml_ext::verify_header_consistency; - let mut header = BTreeMap::new(); let sub = { let mut sub = BTreeMap::new(); @@ -1303,8 +1289,6 @@ mod test { #[test] fn test_verification_invalid_versionstring() { - use toml_ext::verify_header_consistency; - let mut header = BTreeMap::new(); let sub = { let mut sub = BTreeMap::new(); @@ -1321,8 +1305,6 @@ mod test { #[test] fn test_verification_current_version() { - use toml_ext::verify_header_consistency; - let mut header = BTreeMap::new(); let sub = { let mut sub = BTreeMap::new(); diff --git a/lib/core/libimagstore/src/toml_ext.rs b/lib/core/libimagstore/src/toml_ext.rs deleted file mode 100644 index 1e51ffd8..00000000 --- a/lib/core/libimagstore/src/toml_ext.rs +++ /dev/null @@ -1,803 +0,0 @@ -// -// imag - the personal information management suite for the commandline -// Copyright (C) 2015, 2016 Matthias Beyer and contributors -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; version -// 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA -// - -use std::result::Result as RResult; -use std::collections::BTreeMap; - -use toml::Value; - -use store::Result; -use error::StoreError as SE; -use error::StoreErrorKind as SEK; -use error::{ParserErrorKind, ParserError}; -use libimagerror::into::IntoError; - -type Table = BTreeMap; - -pub trait TomlValueExt { - fn insert_with_sep(&mut self, spec: &str, sep: char, v: Value) -> Result; - fn set_with_sep(&mut self, spec: &str, sep: char, v: Value) -> Result>; - fn read_with_sep(&self, spec: &str, splitchr: char) -> Result>; - fn delete_with_sep(&mut self, spec: &str, splitchr: char) -> Result>; - - #[inline] - fn insert(&mut self, spec: &str, v: Value) -> Result { - self.insert_with_sep(spec, '.', v) - } - - #[inline] - fn set(&mut self, spec: &str, v: Value) -> Result> { - self.set_with_sep(spec, '.', v) - } - - #[inline] - fn read(&self, spec: &str) -> Result> { - self.read_with_sep(spec, '.') - } - - #[inline] - fn delete(&mut self, spec: &str) -> Result> { - self.delete_with_sep(spec, '.') - } -} - -#[derive(Debug, Clone, PartialEq, Eq)] -enum Token { - Key(String), - Index(usize), -} - -impl TomlValueExt for Value { - /** - * Insert a header field by a string-spec - * - * ```ignore - * insert("something.in.a.field", Boolean(true)); - * ``` - * - * If an array field was accessed which is _out of bounds_ of the array available, the element - * is appended to the array. - * - * Inserts a Boolean in the section "something" -> "in" -> "a" -> "field" - * A JSON equivalent would be - * - * { - * something: { - * in: { - * a: { - * field: true - * } - * } - * } - * } - * - * Returns true if header field was set, false if there is already a value - */ - fn insert_with_sep(&mut self, spec: &str, sep: char, v: Value) -> Result { - let (destination, value) = try!(setup(self, spec, sep)); - - // There is already an value at this place - if value.extract(&destination).is_ok() { - return Ok(false); - } - - match destination { - // if the destination shall be an map key - Token::Key(ref s) => match *value { - /* - * Put it in there if we have a map - */ - Value::Table(ref mut t) => { t.insert(s.clone(), v); }, - - /* - * Fail if there is no map here - */ - _ => return Err(SEK::HeaderPathTypeFailure.into_error()), - }, - - // if the destination shall be an array - Token::Index(i) => match *value { - - /* - * Put it in there if we have an array - */ - Value::Array(ref mut a) => { - a.push(v); // push to the end of the array - - // if the index is inside the array, we swap-remove the element at this - // index - if a.len() < i { - a.swap_remove(i); - } - }, - - /* - * Fail if there is no array here - */ - _ => return Err(SEK::HeaderPathTypeFailure.into_error()), - }, - } - - Ok(true) - } - - /** - * Set a header field by a string-spec - * - * ```ignore - * set("something.in.a.field", Boolean(true)); - * ``` - * - * Sets a Boolean in the section "something" -> "in" -> "a" -> "field" - * A JSON equivalent would be - * - * { - * something: { - * in: { - * a: { - * field: true - * } - * } - * } - * } - * - * If there is already a value at this place, this value will be overridden and the old value - * will be returned - */ - fn set_with_sep(&mut self, spec: &str, sep: char, v: Value) -> Result> { - let (destination, value) = try!(setup(self, spec, sep)); - - match destination { - // if the destination shall be an map key->value - Token::Key(ref s) => match *value { - /* - * Put it in there if we have a map - */ - Value::Table(ref mut t) => { - debug!("Matched Key->Table"); - return Ok(t.insert(s.clone(), v)); - } - - /* - * Fail if there is no map here - */ - _ => { - debug!("Matched Key->NON-Table"); - return Err(SEK::HeaderPathTypeFailure.into_error()); - } - }, - - // if the destination shall be an array - Token::Index(i) => match *value { - - /* - * Put it in there if we have an array - */ - Value::Array(ref mut a) => { - debug!("Matched Index->Array"); - a.push(v); // push to the end of the array - - // if the index is inside the array, we swap-remove the element at this - // index - if a.len() > i { - debug!("Swap-Removing in Array {:?}[{:?}] <- {:?}", a, i, a[a.len()-1]); - return Ok(Some(a.swap_remove(i))); - } - - debug!("Appended"); - return Ok(None); - }, - - /* - * Fail if there is no array here - */ - _ => { - debug!("Matched Index->NON-Array"); - return Err(SEK::HeaderPathTypeFailure.into_error()); - }, - }, - } - } - - /** - * Read a header field by a string-spec - * - * ```ignore - * let value = read("something.in.a.field"); - * ``` - * - * Reads a Value in the section "something" -> "in" -> "a" -> "field" - * A JSON equivalent would be - * - * { - * something: { - * in: { - * a: { - * field: true - * } - * } - * } - * } - * - * If there is no a value at this place, None will be returned. This also holds true for Arrays - * which are accessed at an index which is not yet there, even if the accessed index is much - * larger than the array length. - */ - fn read_with_sep(&self, spec: &str, splitchr: char) -> Result> { - let tokens = try!(tokenize(spec, splitchr)); - - let mut header_clone = self.clone(); // we clone as READing is simpler this way - // walk N-1 tokens - match walk_header(&mut header_clone, tokens) { - Err(e) => match e.err_type() { - // We cannot find the header key, as there is no path to it - SEK::HeaderKeyNotFound => Ok(None), - _ => Err(e), - }, - Ok(v) => Ok(Some(v.clone())), - } - } - - fn delete_with_sep(&mut self, spec: &str, splitchr: char) -> Result> { - let (destination, value) = try!(setup(self, spec, splitchr)); - - match destination { - // if the destination shall be an map key->value - Token::Key(ref s) => match *value { - Value::Table(ref mut t) => { - debug!("Matched Key->Table, removing {:?}", s); - return Ok(t.remove(s)); - }, - _ => { - debug!("Matched Key->NON-Table"); - return Err(SEK::HeaderPathTypeFailure.into_error()); - } - }, - - // if the destination shall be an array - Token::Index(i) => match *value { - - // if the index is inside the array, we swap-remove the element at this - // index - Value::Array(ref mut a) => if a.len() > i { - debug!("Removing in Array {:?}[{:?}]", a, i); - return Ok(Some(a.remove(i))); - } else { - return Ok(None); - }, - _ => { - debug!("Matched Index->NON-Array"); - return Err(SEK::HeaderPathTypeFailure.into_error()); - }, - }, - } - } - -} - -fn setup<'a>(v: &'a mut Value, spec: &str, sep: char) - -> Result<(Token, &'a mut Value)> -{ - let tokens = try!(tokenize(spec, sep)); - debug!("tokens = {:?}", tokens); - - let destination = try!(tokens.iter().last().cloned().ok_or(SEK::HeaderPathSyntaxError.into_error())); - debug!("destination = {:?}", destination); - - let path_to_dest : Vec = tokens[..(tokens.len() - 1)].into(); // N - 1 tokens - let value = try!(walk_header(v, path_to_dest)); // walk N-1 tokens - - debug!("walked value = {:?}", value); - - Ok((destination, value)) -} - -fn tokenize(spec: &str, splitchr: char) -> Result> { - use std::str::FromStr; - - spec.split(splitchr) - .map(|s| usize::from_str(s).map(Token::Index).or_else(|_| Ok(Token::Key(String::from(s))))) - .collect() -} - -fn walk_header(v: &mut Value, tokens: Vec) -> Result<&mut Value> { - use std::vec::IntoIter; - - fn walk_iter<'a>(v: Result<&'a mut Value>, i: &mut IntoIter) -> Result<&'a mut Value> { - let next = i.next(); - v.and_then(move |value| if let Some(token) = next { - walk_iter(value.extract(&token), i) - } else { - Ok(value) - }) - } - - walk_iter(Ok(v), &mut tokens.into_iter()) -} - -trait Extract { - fn extract<'a>(&'a mut self, &Token) -> Result<&'a mut Self>; -} - -impl Extract for Value { - fn extract<'a>(&'a mut self, token: &Token) -> Result<&'a mut Value> { - match *token { - // on Token::Key extract from Value::Table - Token::Key(ref s) => match *self { - Value::Table(ref mut t) => - t.get_mut(&s[..]).ok_or(SEK::HeaderKeyNotFound.into_error()), - - _ => Err(SEK::HeaderPathTypeFailure.into_error()), - }, - - // on Token::Index extract from Value::Array - Token::Index(i) => match *self { - Value::Array(ref mut a) => if a.len() < i { - Err(SEK::HeaderKeyNotFound.into_error()) - } else { - Ok(&mut a[i]) - }, - - _ => Err(SEK::HeaderPathTypeFailure.into_error()), - } - } - } -} - -pub type EntryResult = RResult; - -#[cfg(test)] -mod test { - extern crate env_logger; - use super::TomlValueExt; - use super::{tokenize, walk_header}; - use super::Token; - - use std::collections::BTreeMap; - - use toml::Value; - - #[test] - fn test_walk_header_simple() { - let tokens = tokenize("a", '.').unwrap(); - assert!(tokens.len() == 1, "1 token was expected, {} were parsed", tokens.len()); - assert!(tokens.iter().next().unwrap() == &Token::Key(String::from("a")), - "'a' token was expected, {:?} was parsed", tokens.iter().next()); - - let mut header = BTreeMap::new(); - header.insert(String::from("a"), Value::Integer(1)); - - let mut v_header = Value::Table(header); - let res = walk_header(&mut v_header, tokens); - assert_eq!(&mut Value::Integer(1), res.unwrap()); - } - - #[test] - fn test_walk_header_with_array() { - let tokens = tokenize("a.0", '.').unwrap(); - assert!(tokens.len() == 2, "2 token was expected, {} were parsed", tokens.len()); - assert!(tokens.iter().next().unwrap() == &Token::Key(String::from("a")), - "'a' token was expected, {:?} was parsed", tokens.iter().next()); - - let mut header = BTreeMap::new(); - let ary = Value::Array(vec![Value::Integer(1)]); - header.insert(String::from("a"), ary); - - - let mut v_header = Value::Table(header); - let res = walk_header(&mut v_header, tokens); - assert_eq!(&mut Value::Integer(1), res.unwrap()); - } - - #[test] - fn test_walk_header_extract_array() { - let tokens = tokenize("a", '.').unwrap(); - assert!(tokens.len() == 1, "1 token was expected, {} were parsed", tokens.len()); - assert!(tokens.iter().next().unwrap() == &Token::Key(String::from("a")), - "'a' token was expected, {:?} was parsed", tokens.iter().next()); - - let mut header = BTreeMap::new(); - let ary = Value::Array(vec![Value::Integer(1)]); - header.insert(String::from("a"), ary); - - let mut v_header = Value::Table(header); - let res = walk_header(&mut v_header, tokens); - assert_eq!(&mut Value::Array(vec![Value::Integer(1)]), res.unwrap()); - } - - /** - * Creates a big testing header. - * - * JSON equivalent: - * - * ```json - * { - * "a": { - * "array": [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] - * }, - * "b": { - * "array": [ "string1", "string2", "string3", "string4" ] - * }, - * "c": { - * "array": [ 1, "string2", 3, "string4" ] - * }, - * "d": { - * "array": [ - * { - * "d1": 1 - * }, - * { - * "d2": 2 - * }, - * { - * "d3": 3 - * }, - * ], - * - * "something": "else", - * - * "and": { - * "something": { - * "totally": "different" - * } - * } - * } - * } - * ``` - * - * The sections "a", "b", "c", "d" are created in the respective helper functions - * create_header_section_a, create_header_section_b, create_header_section_c and - * create_header_section_d. - * - * These functions can also be used for testing. - * - */ - fn create_header() -> Value { - let a = create_header_section_a(); - let b = create_header_section_b(); - let c = create_header_section_c(); - let d = create_header_section_d(); - - let mut header = BTreeMap::new(); - header.insert(String::from("a"), a); - header.insert(String::from("b"), b); - header.insert(String::from("c"), c); - header.insert(String::from("d"), d); - - Value::Table(header) - } - - fn create_header_section_a() -> Value { - // 0..10 is exclusive 10 - let a_ary = Value::Array((0..10).map(|x| Value::Integer(x)).collect()); - - let mut a_obj = BTreeMap::new(); - a_obj.insert(String::from("array"), a_ary); - Value::Table(a_obj) - } - - fn create_header_section_b() -> Value { - let b_ary = Value::Array((0..9) - .map(|x| Value::String(format!("string{}", x))) - .collect()); - - let mut b_obj = BTreeMap::new(); - b_obj.insert(String::from("array"), b_ary); - Value::Table(b_obj) - } - - fn create_header_section_c() -> Value { - let c_ary = Value::Array( - vec![ - Value::Integer(1), - Value::String(String::from("string2")), - Value::Integer(3), - Value::String(String::from("string4")) - ]); - - let mut c_obj = BTreeMap::new(); - c_obj.insert(String::from("array"), c_ary); - Value::Table(c_obj) - } - - fn create_header_section_d() -> Value { - let d_ary = Value::Array( - vec![ - { - let mut tab = BTreeMap::new(); - tab.insert(String::from("d1"), Value::Integer(1)); - tab - }, - { - let mut tab = BTreeMap::new(); - tab.insert(String::from("d2"), Value::Integer(2)); - tab - }, - { - let mut tab = BTreeMap::new(); - tab.insert(String::from("d3"), Value::Integer(3)); - tab - }, - ].into_iter().map(Value::Table).collect()); - - let and_obj = Value::Table({ - let mut tab = BTreeMap::new(); - let something_tab = Value::Table({ - let mut tab = BTreeMap::new(); - tab.insert(String::from("totally"), Value::String(String::from("different"))); - tab - }); - tab.insert(String::from("something"), something_tab); - tab - }); - - let mut d_obj = BTreeMap::new(); - d_obj.insert(String::from("array"), d_ary); - d_obj.insert(String::from("something"), Value::String(String::from("else"))); - d_obj.insert(String::from("and"), and_obj); - Value::Table(d_obj) - } - - #[test] - fn test_walk_header_big_a() { - test_walk_header_extract_section("a", &create_header_section_a()); - } - - #[test] - fn test_walk_header_big_b() { - test_walk_header_extract_section("b", &create_header_section_b()); - } - - #[test] - fn test_walk_header_big_c() { - test_walk_header_extract_section("c", &create_header_section_c()); - } - - #[test] - fn test_walk_header_big_d() { - test_walk_header_extract_section("d", &create_header_section_d()); - } - - fn test_walk_header_extract_section(secname: &str, expected: &Value) { - let tokens = tokenize(secname, '.').unwrap(); - assert!(tokens.len() == 1, "1 token was expected, {} were parsed", tokens.len()); - assert!(tokens.iter().next().unwrap() == &Token::Key(String::from(secname)), - "'{}' token was expected, {:?} was parsed", secname, tokens.iter().next()); - - let mut header = create_header(); - let res = walk_header(&mut header, tokens); - assert_eq!(expected, res.unwrap()); - } - - #[test] - fn test_walk_header_extract_numbers() { - test_extract_number("a", 0, 0); - test_extract_number("a", 1, 1); - test_extract_number("a", 2, 2); - test_extract_number("a", 3, 3); - test_extract_number("a", 4, 4); - test_extract_number("a", 5, 5); - test_extract_number("a", 6, 6); - test_extract_number("a", 7, 7); - test_extract_number("a", 8, 8); - test_extract_number("a", 9, 9); - - test_extract_number("c", 0, 1); - test_extract_number("c", 2, 3); - } - - fn test_extract_number(sec: &str, idx: usize, exp: i64) { - let tokens = tokenize(&format!("{}.array.{}", sec, idx)[..], '.').unwrap(); - assert!(tokens.len() == 3, "3 token was expected, {} were parsed", tokens.len()); - { - let mut iter = tokens.iter(); - - let tok = iter.next().unwrap(); - let exp = Token::Key(String::from(sec)); - assert!(tok == &exp, "'{}' token was expected, {:?} was parsed", sec, tok); - - let tok = iter.next().unwrap(); - let exp = Token::Key(String::from("array")); - assert!(tok == &exp, "'array' token was expected, {:?} was parsed", tok); - - let tok = iter.next().unwrap(); - let exp = Token::Index(idx); - assert!(tok == &exp, "'{}' token was expected, {:?} was parsed", idx, tok); - } - - let mut header = create_header(); - let res = walk_header(&mut header, tokens); - assert_eq!(&mut Value::Integer(exp), res.unwrap()); - } - - #[test] - fn test_header_read() { - let h = create_header(); - - assert!(if let Ok(Some(Value::Table(_))) = h.read("a") { true } else { false }); - assert!(if let Ok(Some(Value::Array(_))) = h.read("a.array") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("a.array.1") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("a.array.9") { true } else { false }); - - assert!(if let Ok(Some(Value::Table(_))) = h.read("c") { true } else { false }); - assert!(if let Ok(Some(Value::Array(_))) = h.read("c.array") { true } else { false }); - assert!(if let Ok(Some(Value::String(_))) = h.read("c.array.1") { true } else { false }); - assert!(if let Ok(None) = h.read("c.array.9") { true } else { false }); - - assert!(if let Ok(Some(Value::Integer(_))) = h.read("d.array.0.d1") { true } else { false }); - assert!(if let Ok(None) = h.read("d.array.0.d2") { true } else { false }); - assert!(if let Ok(None) = h.read("d.array.0.d3") { true } else { false }); - - assert!(if let Ok(None) = h.read("d.array.1.d1") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("d.array.1.d2") { true } else { false }); - assert!(if let Ok(None) = h.read("d.array.1.d3") { true } else { false }); - - assert!(if let Ok(None) = h.read("d.array.2.d1") { true } else { false }); - assert!(if let Ok(None) = h.read("d.array.2.d2") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("d.array.2.d3") { true } else { false }); - - assert!(if let Ok(Some(Value::String(_))) = h.read("d.something") { true } else { false }); - assert!(if let Ok(Some(Value::Table(_))) = h.read("d.and") { true } else { false }); - assert!(if let Ok(Some(Value::Table(_))) = h.read("d.and.something") { true } else { false }); - assert!(if let Ok(Some(Value::String(_))) = h.read("d.and.something.totally") { true } else { false }); - } - - #[test] - fn test_header_set_override() { - let _ = env_logger::init(); - let mut h = create_header(); - - println!("Testing index 0"); - assert_eq!(h.read("a.array.0").unwrap().unwrap(), Value::Integer(0)); - - println!("Altering index 0"); - assert_eq!(h.set("a.array.0", Value::Integer(42)).unwrap().unwrap(), Value::Integer(0)); - - println!("Values now: {:?}", h); - - println!("Testing all indexes"); - assert_eq!(h.read("a.array.0").unwrap().unwrap(), Value::Integer(42)); - assert_eq!(h.read("a.array.1").unwrap().unwrap(), Value::Integer(1)); - assert_eq!(h.read("a.array.2").unwrap().unwrap(), Value::Integer(2)); - assert_eq!(h.read("a.array.3").unwrap().unwrap(), Value::Integer(3)); - assert_eq!(h.read("a.array.4").unwrap().unwrap(), Value::Integer(4)); - assert_eq!(h.read("a.array.5").unwrap().unwrap(), Value::Integer(5)); - assert_eq!(h.read("a.array.6").unwrap().unwrap(), Value::Integer(6)); - assert_eq!(h.read("a.array.7").unwrap().unwrap(), Value::Integer(7)); - assert_eq!(h.read("a.array.8").unwrap().unwrap(), Value::Integer(8)); - assert_eq!(h.read("a.array.9").unwrap().unwrap(), Value::Integer(9)); - } - - #[test] - fn test_header_set_new() { - let _ = env_logger::init(); - let mut h = create_header(); - - assert!(h.read("a.foo").is_ok()); - assert!(h.read("a.foo").unwrap().is_none()); - - { - let v = h.set("a.foo", Value::Integer(42)); - assert!(v.is_ok()); - assert!(v.unwrap().is_none()); - - assert!(if let Ok(Some(Value::Table(_))) = h.read("a") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("a.foo") { true } else { false }); - } - - { - let v = h.set("new", Value::Table(BTreeMap::new())); - assert!(v.is_ok()); - assert!(v.unwrap().is_none()); - - let v = h.set("new.subset", Value::Table(BTreeMap::new())); - assert!(v.is_ok()); - assert!(v.unwrap().is_none()); - - let v = h.set("new.subset.dest", Value::Integer(1337)); - assert!(v.is_ok()); - assert!(v.unwrap().is_none()); - - assert!(if let Ok(Some(Value::Table(_))) = h.read("new") { true } else { false }); - assert!(if let Ok(Some(Value::Table(_))) = h.read("new.subset") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("new.subset.dest") { true } else { false }); - } - } - - - #[test] - fn test_header_insert_override() { - let _ = env_logger::init(); - let mut h = create_header(); - - println!("Testing index 0"); - assert_eq!(h.read("a.array.0").unwrap().unwrap(), Value::Integer(0)); - - println!("Altering index 0"); - assert_eq!(h.insert("a.array.0", Value::Integer(42)).unwrap(), false); - println!("...should have failed"); - - println!("Testing all indexes"); - assert_eq!(h.read("a.array.0").unwrap().unwrap(), Value::Integer(0)); - assert_eq!(h.read("a.array.1").unwrap().unwrap(), Value::Integer(1)); - assert_eq!(h.read("a.array.2").unwrap().unwrap(), Value::Integer(2)); - assert_eq!(h.read("a.array.3").unwrap().unwrap(), Value::Integer(3)); - assert_eq!(h.read("a.array.4").unwrap().unwrap(), Value::Integer(4)); - assert_eq!(h.read("a.array.5").unwrap().unwrap(), Value::Integer(5)); - assert_eq!(h.read("a.array.6").unwrap().unwrap(), Value::Integer(6)); - assert_eq!(h.read("a.array.7").unwrap().unwrap(), Value::Integer(7)); - assert_eq!(h.read("a.array.8").unwrap().unwrap(), Value::Integer(8)); - assert_eq!(h.read("a.array.9").unwrap().unwrap(), Value::Integer(9)); - } - - #[test] - fn test_header_insert_new() { - let _ = env_logger::init(); - let mut h = create_header(); - - assert!(h.read("a.foo").is_ok()); - assert!(h.read("a.foo").unwrap().is_none()); - - { - let v = h.insert("a.foo", Value::Integer(42)); - assert!(v.is_ok()); - assert_eq!(v.unwrap(), true); - - assert!(if let Ok(Some(Value::Table(_))) = h.read("a") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("a.foo") { true } else { false }); - } - - { - let v = h.insert("new", Value::Table(BTreeMap::new())); - assert!(v.is_ok()); - assert_eq!(v.unwrap(), true); - - let v = h.insert("new.subset", Value::Table(BTreeMap::new())); - assert!(v.is_ok()); - assert_eq!(v.unwrap(), true); - - let v = h.insert("new.subset.dest", Value::Integer(1337)); - assert!(v.is_ok()); - assert_eq!(v.unwrap(), true); - - assert!(if let Ok(Some(Value::Table(_))) = h.read("new") { true } else { false }); - assert!(if let Ok(Some(Value::Table(_))) = h.read("new.subset") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("new.subset.dest") { true } else { false }); - } - } - - #[test] - fn test_header_delete() { - let _ = env_logger::init(); - let mut h = create_header(); - - assert!(if let Ok(Some(Value::Table(_))) = h.read("a") { true } else { false }); - assert!(if let Ok(Some(Value::Array(_))) = h.read("a.array") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("a.array.1") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(_))) = h.read("a.array.9") { true } else { false }); - - assert!(if let Ok(Some(Value::Integer(1))) = h.delete("a.array.1") { true } else { false }); - assert!(if let Ok(Some(Value::Integer(9))) = h.delete("a.array.8") { true } else { false }); - assert!(if let Ok(Some(Value::Array(_))) = h.delete("a.array") { true } else { false }); - assert!(if let Ok(Some(Value::Table(_))) = h.delete("a") { true } else { false }); - - } - -} -