From bcadebef18e6a938306fba052edd2acb8b843d4c Mon Sep 17 00:00:00 2001 From: Joel Self Date: Mon, 14 Mar 2016 20:19:21 -0600 Subject: [PATCH] Changed TOMLParser to Parser and moved it to internals. Wrote a wrapper for it to only expose the parts that should be public and called it TOMLParser and put it in the library root. Changed all files that used to reference TOMLParser. Added some new fields to Cargo.toml. --- Cargo.toml | 8 +- src/bin/tomlkit.rs | 4 +- src/internals/macros.rs | 4 +- src/internals/mod.rs | 5 +- src/internals/objects.rs | 130 +++++++++++++++--------------- src/{ => internals}/parser.rs | 146 +++++++++++++++++----------------- src/internals/primitives.rs | 142 ++++++++++++++++----------------- src/internals/toml.rs | 48 +++++------ src/internals/util.rs | 20 ++--- src/lib.rs | 36 ++++++++- src/types.rs | 23 +++--- tests/assets.rs | 2 +- tests/get_set.rs | 134 +++++++++++++++++-------------- todolist.md | 2 +- 14 files changed, 382 insertions(+), 322 deletions(-) rename src/{ => internals}/parser.rs (88%) diff --git a/Cargo.toml b/Cargo.toml index 8a25527..7b2ae44 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,13 @@ [package] name = "tomllib" version = "0.1.0" -authors = ["Joel Self "] +authors = ["Joel Self "] +description = "A format-preserving TOML file parser and manipulator" +license = "MIT" +repository = "https://github.com/joelself/tomllib" +readme = "README.md" +#documentation = "http://rust.unhandledexpression.com/tomllib/" +keywords = ["toml", "parser", "encode", "decode", "nom"] [dependencies.nom] version = "^1.2.0" diff --git a/src/bin/tomlkit.rs b/src/bin/tomlkit.rs index 1977ecb..fdde93f 100644 --- a/src/bin/tomlkit.rs +++ b/src/bin/tomlkit.rs @@ -2,7 +2,7 @@ extern crate tomllib; #[macro_use] extern crate log; extern crate env_logger; use std::rc::Rc; -use tomllib::parser::TOMLParser; +use tomllib::TOMLParser; use tomllib::types::{StrType, Value, TimeOffsetAmount, TimeOffset, DateTime, Date, Time}; @@ -148,7 +148,7 @@ enabled = true // ), // ]) // )); - parser.print_keys_and_values_debug(); + //parser.print_keys_and_values_debug(); println!("before: {}", parser.get_value("title").unwrap()); diff --git a/src/internals/macros.rs b/src/internals/macros.rs index c8b1c64..a63d7a9 100644 --- a/src/internals/macros.rs +++ b/src/internals/macros.rs @@ -6,9 +6,9 @@ macro_rules! to_val( &TOMLValue::Float(ref v) => Value::Float(v.clone()), &TOMLValue::Boolean(v) => Value::Boolean(v), &TOMLValue::DateTime(ref v) => Value::DateTime(v.clone()), - &TOMLValue::Array(ref arr) => TOMLParser::sanitize_array(arr.clone()), + &TOMLValue::Array(ref arr) => Parser::sanitize_array(arr.clone()), &TOMLValue::String(ref s, t) => Value::String(s.clone(), t.clone()), - &TOMLValue::InlineTable(ref it) => TOMLParser::sanitize_inline_table(it.clone()), + &TOMLValue::InlineTable(ref it) => Parser::sanitize_inline_table(it.clone()), &TOMLValue::Table => panic!("Cannot convert a Table to a Value"), } ); diff --git a/src/internals/mod.rs b/src/internals/mod.rs index dcf8a23..9b2fdeb 100644 --- a/src/internals/mod.rs +++ b/src/internals/mod.rs @@ -1,7 +1,8 @@ #[macro_use] mod macros; -pub mod ast; +mod ast; mod toml; mod util; mod objects; -pub mod primitives; \ No newline at end of file +pub mod parser; +mod primitives; \ No newline at end of file diff --git a/src/internals/objects.rs b/src/internals/objects.rs index c096e5b..dd9d7de 100644 --- a/src/internals/objects.rs +++ b/src/internals/objects.rs @@ -1,7 +1,7 @@ use internals::ast::structs::{TableType, WSKeySep, Table, CommentNewLines, CommentOrNewLines, ArrayValue, Array, TOMLValue, InlineTable, WSSep, TableKeyVal, ArrayType, HashValue, format_tt_keys}; -use parser::TOMLParser; +use internals::parser::Parser; use internals::primitives::Key; use types::{ParseError, Children}; use std::cell::RefCell; @@ -25,7 +25,7 @@ fn map_val_to_array_type(val: &TOMLValue) -> ArrayType { } } -impl<'a> TOMLParser<'a> { +impl<'a> Parser<'a> { pub fn insert(vector: &RefCell>, insert: String) -> bool { for s in vector.borrow().iter() { @@ -79,7 +79,7 @@ impl<'a> TOMLParser<'a> { fn add_implicit_tables(map: &RefCell<&mut HashMap>>, tables: &RefCell>>>, tables_index: &RefCell>, table: Rc>) { - let (valid, mut last_key, _) = TOMLParser::get_array_table_key(map, tables, tables_index); + let (valid, mut last_key, _) = Parser::get_array_table_key(map, tables, tables_index); if !valid { return; } @@ -114,14 +114,14 @@ impl<'a> TOMLParser<'a> { if first { insert = match &o.get_mut().subkeys { - &Children::Keys(ref vec_rf) => {debug!("Inserting subkey: {}", tb.keys[i].key); TOMLParser::insert(vec_rf, tb.keys[i].key.clone().into_owned())}, + &Children::Keys(ref vec_rf) => {debug!("Inserting subkey: {}", tb.keys[i].key); Parser::insert(vec_rf, tb.keys[i].key.clone().into_owned())}, &Children::Count(ref cell) => { debug!("Incrementing subkey count: {}", cell.get() + 1); cell.set(cell.get() + 1); true }, }; first = false; } else { debug!("Inserting subkey: {}", tb.keys[i].key); insert = match &o.get_mut().subkeys { - &Children::Keys(ref vec_rf) => TOMLParser::insert(vec_rf, tb.keys[i].key.clone().into_owned()), + &Children::Keys(ref vec_rf) => Parser::insert(vec_rf, tb.keys[i].key.clone().into_owned()), _ => panic!("Implicit tables can only be Standard Tables: \"{}\"", format!("{}.{}", last_key, tb.keys[i].key)), }; } @@ -159,7 +159,7 @@ impl<'a> TOMLParser<'a> { fn increment_array_table_index(map: &RefCell<&mut HashMap>>, tables: &RefCell>>>, tables_index: &RefCell>,) { - let parent_key = TOMLParser::get_key_parent(tables, tables_index); + let parent_key = Parser::get_key_parent(tables, tables_index); debug!("increment_array_table_index: {}", parent_key); let mut borrow = map.borrow_mut(); let entry = borrow.entry(parent_key); @@ -175,19 +175,19 @@ impl<'a> TOMLParser<'a> { fn add_to_table_set(map: &RefCell<&mut HashMap>>, tables: &RefCell>>>, tables_index: &RefCell>, key: &str) -> bool{ - let parent_key = TOMLParser::get_key_parent(tables, tables_index); + let parent_key = Parser::get_key_parent(tables, tables_index); debug!("add_to_table_set: {}", parent_key); let mut borrow = map.borrow_mut(); let entry = borrow.entry(parent_key); if let Entry::Occupied(mut o) = entry { if let &Children::Keys(ref keys) = &o.get_mut().subkeys { - let contains = TOMLParser::contains(keys, key); + let contains = Parser::contains(keys, key); if contains { debug!("key already exists"); return false; } else { debug!("add_to_table_set--> {}", key); - TOMLParser::insert(keys, key.to_string()); + Parser::insert(keys, key.to_string()); } } } @@ -195,16 +195,16 @@ impl<'a> TOMLParser<'a> { } // Table - method!(pub table, &'a str, Rc >, mut self, + method!(pub table, &'a str, Rc >, mut self, alt!( complete!(call_m!(self.array_table)) | complete!(call_m!(self.std_table)) ) ); - method!(table_subkeys, &'a str, Vec >, mut self, many0!(call_m!(self.table_subkey))); + method!(table_subkeys, &'a str, Vec >, mut self, many0!(call_m!(self.table_subkey))); - method!(table_subkey, &'a str, WSKeySep>, mut self, + method!(table_subkey, &'a str, WSKeySep>, mut self, chain!( ws1: call_m!(self.ws) ~ tag_s!(".")~ @@ -216,7 +216,7 @@ impl<'a> TOMLParser<'a> { ) ); // Standard Table - method!(std_table, &'a str, Rc >, mut self, + method!(std_table, &'a str, Rc >, mut self, chain!( tag_s!("[") ~ ws1: call_m!(self.ws) ~ @@ -232,7 +232,7 @@ impl<'a> TOMLParser<'a> { let mut error = false; let keychain_len = self.keychain.borrow().len(); self.keychain.borrow_mut().truncate(keychain_len - keys_len); - if TOMLParser::is_top_std_table(&self.last_array_tables) || TOMLParser::equal_key_length(res.clone(), &self.last_array_tables) { + if Parser::is_top_std_table(&self.last_array_tables) || Parser::equal_key_length(res.clone(), &self.last_array_tables) { self.last_array_tables.borrow_mut().pop(); self.last_array_tables_index.borrow_mut().pop(); } @@ -268,7 +268,7 @@ impl<'a> TOMLParser<'a> { } else { self.last_array_tables.borrow_mut().push(res.clone()); self.last_array_tables_index.borrow_mut().push(0); - let tuple = TOMLParser::get_array_table_key(&map, &self.last_array_tables, &self.last_array_tables_index); + let tuple = Parser::get_array_table_key(&map, &self.last_array_tables, &self.last_array_tables_index); table_key = tuple.1; parent_key = tuple.2; self.last_array_tables.borrow_mut().pop(); @@ -295,7 +295,7 @@ impl<'a> TOMLParser<'a> { if error { self.last_array_tables.borrow_mut().push(res.clone()); self.last_array_tables_index.borrow_mut().push(0); - let array_table_key = TOMLParser::get_array_table_key(&map, &self.last_array_tables, + let array_table_key = Parser::get_array_table_key(&map, &self.last_array_tables, &self.last_array_tables_index).1; debug!("Setting Invalid Table {} in Standard Table", array_table_key); self.errors.borrow_mut().push(ParseError::InvalidTable( @@ -306,10 +306,10 @@ impl<'a> TOMLParser<'a> { self.last_array_tables_index.borrow_mut().pop(); self.array_error.set(true); } else { - TOMLParser::add_implicit_tables(&map, &self.last_array_tables, + Parser::add_implicit_tables(&map, &self.last_array_tables, &self.last_array_tables_index, res.clone()); if let TableType::Standard(ref tbl) = *res { - TOMLParser::add_to_table_set(&map, &self.last_array_tables, + Parser::add_to_table_set(&map, &self.last_array_tables, &self.last_array_tables_index, &tbl.keys[keys_len - 1].key); self.array_error.set(false); debug!("insert table_key: {}", table_key); @@ -326,7 +326,7 @@ impl<'a> TOMLParser<'a> { } if let Entry::Occupied(mut o) = map.borrow_mut().entry(parent_key) { match &o.get_mut().subkeys { - &Children::Keys(ref vec_rf) => {TOMLParser::insert(vec_rf, tbl.keys[keys_len - 1].key.clone().into_owned());}, + &Children::Keys(ref vec_rf) => {Parser::insert(vec_rf, tbl.keys[keys_len - 1].key.clone().into_owned());}, _ => panic!("Trying to add a key to an array: \"{}\"", table_key), } } @@ -341,7 +341,7 @@ impl<'a> TOMLParser<'a> { ); //Array Table - method!(array_table, &'a str, Rc >, mut self, + method!(array_table, &'a str, Rc >, mut self, chain!( tag_s!("[[") ~ ws1: call_m!(self.ws) ~ @@ -356,7 +356,7 @@ impl<'a> TOMLParser<'a> { ))); let keychain_len = self.keychain.borrow().len(); self.keychain.borrow_mut().truncate(keychain_len - keys_len); - if TOMLParser::is_top_std_table(&self.last_array_tables) { + if Parser::is_top_std_table(&self.last_array_tables) { self.last_array_tables.borrow_mut().pop(); self.last_array_tables_index.borrow_mut().pop(); } @@ -371,13 +371,13 @@ impl<'a> TOMLParser<'a> { debug!("current_key: {}, last_key: {}", current_key, last_key); if current_key == last_key { debug!("Increment array table index"); - TOMLParser::increment_array_table_index(&map, &self.last_array_tables, + Parser::increment_array_table_index(&map, &self.last_array_tables, &self.last_array_tables_index); } else { let subtable = res.is_subtable_of(&self.last_array_tables.borrow()[len - 1]); if subtable { debug!("Is subtable"); - TOMLParser::add_implicit_tables(&map, &self.last_array_tables, + Parser::add_implicit_tables(&map, &self.last_array_tables, &self.last_array_tables_index, res.clone()); self.last_array_tables.borrow_mut().push(res.clone()); self.last_array_tables_index.borrow_mut().push(0); @@ -392,21 +392,21 @@ impl<'a> TOMLParser<'a> { len = self.last_array_tables.borrow().len(); if len > 0 { debug!("Increment array table index the second"); - TOMLParser::increment_array_table_index(&map, &self.last_array_tables, + Parser::increment_array_table_index(&map, &self.last_array_tables, &self.last_array_tables_index); } else { debug!("Add implicit tables"); - TOMLParser::add_implicit_tables(&map, &self.last_array_tables, + Parser::add_implicit_tables(&map, &self.last_array_tables, &self.last_array_tables_index, res.clone()); self.last_array_tables.borrow_mut().push(res.clone()); self.last_array_tables_index.borrow_mut().push(0); - let parent_key = TOMLParser::get_key_parent(&self.last_array_tables, + let parent_key = Parser::get_key_parent(&self.last_array_tables, &self.last_array_tables_index); debug!("Got parent key: {}", parent_key); let contains_key = map.borrow().contains_key(&parent_key); if contains_key { debug!("Increment array table index the third"); - TOMLParser::increment_array_table_index(&map, &self.last_array_tables, + Parser::increment_array_table_index(&map, &self.last_array_tables, &self.last_array_tables_index); } } @@ -414,13 +414,13 @@ impl<'a> TOMLParser<'a> { } } else { debug!("Len == 0 add implicit tables"); - TOMLParser::add_implicit_tables(&map, &self.last_array_tables, + Parser::add_implicit_tables(&map, &self.last_array_tables, &self.last_array_tables_index, res.clone()); self.last_array_tables.borrow_mut().push(res.clone()); self.last_array_tables_index.borrow_mut().push(0); } debug!("Before call to get_array_table_key"); - let (valid, full_key, parent_key) = TOMLParser::get_array_table_key(&map, &self.last_array_tables, + let (valid, full_key, parent_key) = Parser::get_array_table_key(&map, &self.last_array_tables, &self.last_array_tables_index); if !valid { debug!("Setting Invalid Table {}", full_key); @@ -448,7 +448,7 @@ impl<'a> TOMLParser<'a> { ); // Array - method!(array_sep, &'a str, WSSep>, mut self, + method!(array_sep, &'a str, WSSep>, mut self, chain!( ws1: call_m!(self.ws) ~ tag_s!(",")~ @@ -459,9 +459,9 @@ impl<'a> TOMLParser<'a> { ) ); - method!(ws_newline, &'a str, &'a str>, self, re_find!("^( |\t|\n|(\r\n))*")); + method!(ws_newline, &'a str, &'a str>, self, re_find!("^( |\t|\n|(\r\n))*")); - method!(comment_nl, &'a str, CommentNewLines>, mut self, + method!(comment_nl, &'a str, CommentNewLines>, mut self, chain!( prewsnl: call_m!(self.ws_newline) ~ comment: call_m!(self.comment) ~ @@ -472,17 +472,17 @@ impl<'a> TOMLParser<'a> { ) ); - method!(comment_or_nl, &'a str, CommentOrNewLines>, mut self, + method!(comment_or_nl, &'a str, CommentOrNewLines>, mut self, alt!( complete!(call_m!(self.comment_nl)) => {|com| CommentOrNewLines::Comment(com)} | complete!(call_m!(self.ws_newline)) => {|nl: &'a str| CommentOrNewLines::NewLines(nl.into())} ) ); - method!(comment_or_nls, &'a str, Vec >, mut self, + method!(comment_or_nls, &'a str, Vec >, mut self, many1!(call_m!(self.comment_or_nl))); - method!(array_value, &'a str, ArrayValue>, mut self, + method!(array_value, &'a str, ArrayValue>, mut self, chain!( val: call_m!(self.val) ~ array_sep: complete!(call_m!(self.array_sep))? ~ @@ -492,7 +492,7 @@ impl<'a> TOMLParser<'a> { let len = self.last_array_type.borrow().len(); if len > 0 && self.last_array_type.borrow()[len - 1] != ArrayType::None && self.last_array_type.borrow()[len - 1] != t { - let tuple = TOMLParser::get_full_key(&RefCell::new(& mut self.map), &self.last_array_tables, + let tuple = Parser::get_full_key(&RefCell::new(& mut self.map), &self.last_array_tables, &self.last_array_tables_index, &self.keychain ); let err_len = self.errors.borrow().len(); @@ -525,7 +525,7 @@ impl<'a> TOMLParser<'a> { ) ); - method!(array_values, &'a str, Vec >, mut self, + method!(array_values, &'a str, Vec >, mut self, chain!( vals: many0!(call_m!(self.array_value)) , ||{ @@ -537,7 +537,7 @@ impl<'a> TOMLParser<'a> { ) ); - pub fn array(mut self: TOMLParser<'a>, input: &'a str) -> (TOMLParser<'a>, IResult<&'a str, Rc>>) { + pub fn array(mut self: Parser<'a>, input: &'a str) -> (Parser<'a>, IResult<&'a str, Rc>>) { // Initialize last array type to None, we need a stack because arrays can be nested //debug!("*** array called on input:\t\t\t{}", input); self.last_array_type.borrow_mut().push(ArrayType::None); @@ -549,7 +549,7 @@ impl<'a> TOMLParser<'a> { (self, res) } - method!(pub array_internal, &'a str, Rc> >, mut self, + method!(pub array_internal, &'a str, Rc> >, mut self, chain!( tag_s!("[") ~ cn1: call_m!(self.comment_or_nls) ~ @@ -564,7 +564,7 @@ impl<'a> TOMLParser<'a> { ) ); - method!(table_keyval, &'a str, TableKeyVal>, mut self, + method!(table_keyval, &'a str, TableKeyVal>, mut self, chain!( keyval: call_m!(self.keyval) ~ keyval_sep: complete!(call_m!(self.array_sep))? ~ @@ -575,9 +575,9 @@ impl<'a> TOMLParser<'a> { ) ); - method!(inline_table_keyvals_non_empty, &'a str, Vec >, mut self, many0!(call_m!(self.table_keyval))); + method!(inline_table_keyvals_non_empty, &'a str, Vec >, mut self, many0!(call_m!(self.table_keyval))); - method!(pub inline_table, &'a str, Rc> >, mut self, + method!(pub inline_table, &'a str, Rc> >, mut self, chain!( tag_s!("{") ~ ws1: call_m!(self.ws) ~ @@ -601,14 +601,14 @@ mod test { use std::cell::{RefCell, Cell}; use nom::IResult::Done; use types::{DateTime, Date, Time, TimeOffset, TimeOffsetAmount, StrType}; - use parser::TOMLParser; + use internals::parser::Parser; use internals::ast::structs::{Array, ArrayValue, WSSep, TableKeyVal, InlineTable, WSKeySep, KeyVal, CommentNewLines, Comment, CommentOrNewLines, Table, TableType, TOMLValue}; use internals::primitives::Key; #[test] fn test_table() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.table("[ _underscore_ . \"-δáƨλèƨ-\" ]").1, Done("", Rc::new(TableType::Standard(Table::new_str( WSSep::new_str(" ", " "), "_underscore_", vec![ @@ -616,7 +616,7 @@ mod test { ] )) ))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.table("[[\t NumberOne\t.\tnUMBERtWO \t]]").1, Done("", Rc::new(TableType::Array(Table::new_str( WSSep::new_str("\t ", " \t"), "NumberOne", vec![ @@ -628,7 +628,7 @@ mod test { #[test] fn test_table_subkey() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.table_subkey("\t . \t\"áƭúƨôèλôñèƭúññèôúñôèƭú\"").1, Done("", WSKeySep::new_str(WSSep::new_str("\t ", " \t"), "\"áƭúƨôèλôñèƭúññèôúñôèƭú\""), )); @@ -636,7 +636,7 @@ mod test { #[test] fn test_table_subkeys() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.table_subkeys(" .\tAPPLE.MAC . \"ßÓÓK\"").1, Done("", vec![ WSKeySep::new_str(WSSep::new_str(" ", "\t"), "APPLE"), @@ -648,7 +648,7 @@ mod test { #[test] fn test_std_table() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.std_table("[Dr-Pepper . \"ƙè¥_TWÓ\"]").1, Done("", Rc::new(TableType::Standard(Table::new_str( WSSep::new_str("", ""), "Dr-Pepper", vec![ @@ -660,7 +660,7 @@ mod test { #[test] fn test_array_table() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.array_table("[[\"ƙè¥ôñè\"\t. key_TWO]]").1, Done("", Rc::new(TableType::Array(Table::new_str( WSSep::new_str("", ""), "\"ƙè¥ôñè\"", vec![ @@ -672,19 +672,19 @@ mod test { #[test] fn test_array_sep() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.array_sep(" , ").1, Done("", WSSep::new_str(" ", " "))); } #[test] fn test_ws_newline() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.ws_newline("\t\n\n").1, Done("", "\t\n\n")); } #[test] fn test_comment_nl() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.comment_nl("\r\n\t#çô₥₥èñƭñèωℓïñè\n \n \n").1, Done("", CommentNewLines::new_str( "\r\n\t", Comment::new_str("çô₥₥èñƭñèωℓïñè"), "\n \n \n" @@ -694,25 +694,25 @@ mod test { #[test] fn test_comment_or_nl() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.comment_or_nl("#ωôřƙωôřƙ\n").1, Done("", CommentOrNewLines::Comment(CommentNewLines::new_str( "", Comment::new_str("ωôřƙωôřƙ"), "\n" )) )); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.comment_or_nl(" \t\n#ωôřƙωôřƙ\n \r\n").1, Done("", CommentOrNewLines::Comment(CommentNewLines::new_str( " \t\n", Comment::new_str("ωôřƙωôřƙ"), "\n \r\n" )) )); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.comment_or_nl("\n\t\r\n ").1, Done("", CommentOrNewLines::NewLines("\n\t\r\n ".into()))); } #[test] fn test_array_value() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); p.keychain.borrow_mut().push(Key::Index(Cell::new(0))); assert_eq!(p.array_value("54.6, \n#çô₥₥èñƭ\n\n").1, Done("",ArrayValue::new( @@ -722,14 +722,14 @@ mod test { ))] )) ); - p = TOMLParser::new(); + p = Parser::new(); p.keychain.borrow_mut().push(Key::Index(Cell::new(0))); assert_eq!(p.array_value("\"ƨƥáϱλèƭƭï\"").1, Done("",ArrayValue::new( Rc::new(RefCell::new(TOMLValue::String("ƨƥáϱλèƭƭï".into(), StrType::Basic))), None, vec![CommentOrNewLines::NewLines("".into())] )) ); - p = TOMLParser::new(); + p = Parser::new(); p.keychain.borrow_mut().push(Key::Index(Cell::new(0))); assert_eq!(p.array_value("44_9 , ").1, Done("",ArrayValue::new( @@ -741,7 +741,7 @@ mod test { #[test] fn test_array_values() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); p.keychain.borrow_mut().push(Key::Index(Cell::new(0))); assert_eq!(p.array_values("1, 2, 3").1, Done("", vec![ ArrayValue::new(Rc::new(RefCell::new(TOMLValue::Integer("1".into()))), Some(WSSep::new_str("", " ")), @@ -750,7 +750,7 @@ mod test { vec![CommentOrNewLines::NewLines("".into())]), ArrayValue::new(Rc::new(RefCell::new(TOMLValue::Integer("3".into()))), None, vec![CommentOrNewLines::NewLines("".into())]) ])); - p = TOMLParser::new(); + p = Parser::new(); p.keychain.borrow_mut().push(Key::Index(Cell::new(0))); assert_eq!(p.array_values("1, 2, #çô₥₥èñƭ\n3, ").1, Done("", vec![ ArrayValue::new(Rc::new(RefCell::new(TOMLValue::Integer("1".into()))), Some(WSSep::new_str("", " ")), @@ -764,7 +764,7 @@ mod test { #[test] fn test_non_nested_array() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.array("[2010-10-10T10:10:10.33Z, 1950-03-30T21:04:14.123+05:00]").1, Done("", Rc::new(RefCell::new(Array::new( vec![ArrayValue::new( @@ -789,7 +789,7 @@ mod test { #[test] fn test_nested_array() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.array("[[3,4], [4,5], [6]]").1, Done("", Rc::new(RefCell::new(Array::new( vec![ @@ -844,7 +844,7 @@ mod test { #[test] fn test_table_keyval() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.table_keyval("\"Ì WúƲ Húϱƨ!\"\t=\t'Mè ƭôô!' ").1, Done("", TableKeyVal::new( KeyVal::new_str( "\"Ì WúƲ Húϱƨ!\"", WSSep::new_str("\t", "\t"), Rc::new(RefCell::new(TOMLValue::String("Mè ƭôô!".into(), StrType::Literal))) @@ -856,7 +856,7 @@ mod test { #[test] fn test_inline_table_keyvals_non_empty() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.inline_table_keyvals_non_empty("Key =\t54,\"Key2\" = '34.99'").1, Done("", vec![ TableKeyVal::new( @@ -881,7 +881,7 @@ mod test { #[test] fn test_inline_table() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.inline_table("{\tKey = 3.14E+5 , \"Key2\" = '''New\nLine'''\t}").1, Done("", Rc::new(RefCell::new(InlineTable::new( vec![ diff --git a/src/parser.rs b/src/internals/parser.rs similarity index 88% rename from src/parser.rs rename to src/internals/parser.rs index 5c2c0f8..b13fb05 100644 --- a/src/parser.rs +++ b/src/internals/parser.rs @@ -1,17 +1,17 @@ use std::fmt; use std::fmt::Display; -use std::rc::Rc; -use std::cell::{RefCell, Cell}; use std::collections::{HashMap, BTreeMap}; use std::collections::hash_map::Entry; +use std::cell::{Cell, RefCell}; +use std::rc::Rc; use std::borrow::Cow; -use nom::IResult; -use internals::primitives::Key; -use internals::ast::structs::{Toml, ArrayType, HashValue, TableType, TOMLValue, Array, InlineTable, - ArrayValue, WSSep, TableKeyVal}; +use internals::ast::structs::{HashValue, ArrayType, TOMLValue, Toml, TableType, Array, InlineTable, + ArrayValue, WSSep, TableKeyVal}; use types::{ParseError, ParseResult, Value, Children}; +use internals::primitives::Key; +use nom::IResult; -pub struct TOMLParser<'a> { +pub struct Parser<'a> { pub root: RefCell>, pub map: HashMap>, pub errors: Rc>>>, @@ -28,11 +28,11 @@ pub struct TOMLParser<'a> { } // TODO change this to return a parser result -impl<'a> TOMLParser<'a> { - pub fn new() -> TOMLParser<'a> { +impl<'a> Parser<'a> { + pub fn new() -> Parser<'a> { let mut map = HashMap::new(); map.insert("$Root$".to_string(), HashValue::none_keys()); - TOMLParser{ root: RefCell::new(Toml{ exprs: vec![] }), map: map, + Parser{ root: RefCell::new(Toml{ exprs: vec![] }), map: map, errors: Rc::new(RefCell::new(vec![])), leftover: "", line_count: Cell::new(1), last_array_tables: RefCell::new(vec![]), last_array_tables_index: RefCell::new(vec![]), @@ -42,7 +42,7 @@ impl<'a> TOMLParser<'a> { failure: Cell::new(false)} } - pub fn parse(mut self: TOMLParser<'a>, input: &'a str) -> (TOMLParser<'a>, ParseResult<'a>) { + pub fn parse(mut self: Parser<'a>, input: &'a str) -> (Parser<'a>, ParseResult<'a>) { let (tmp, res) = self.toml(input); self = tmp; let line_count = self.line_count.get(); @@ -58,25 +58,24 @@ impl<'a> TOMLParser<'a> { if self.leftover.len() > 0 { let len = self.errors.borrow().len(); if len > 0 { - return (self, ParseResult::PartialError(leftover, line_count, 0)); + let errors = self.errors.clone(); + return (self, ParseResult::PartialError(leftover, line_count, 0, errors)); } else { return (self, ParseResult::Partial(leftover, line_count, 0)); } } else { let len = self.errors.borrow().len(); if len > 0 { - return (self, ParseResult::FullError); + let errors = self.errors.clone(); + return (self, ParseResult::FullError(errors)); } else { return (self, ParseResult::Full); } } } - - pub fn get_errors(self: &TOMLParser<'a>) -> Rc>>> { - return self.errors.clone(); - } - - pub fn print_keys_and_values_debug(self: &TOMLParser<'a>) { + + #[allow(dead_code)] + fn print_keys_and_values_debug(self: &Parser<'a>) { let mut btree = BTreeMap::new(); for (k, v) in self.map.iter() { btree.insert(k, v); @@ -86,7 +85,8 @@ impl<'a> TOMLParser<'a> { } } - pub fn print_keys_and_values(self: &TOMLParser<'a>) { + #[allow(dead_code)] + fn print_keys_and_values(self: &Parser<'a>) { let mut btree = BTreeMap::new(); for (k, v) in self.map.iter() { btree.insert(k, v); @@ -96,7 +96,7 @@ impl<'a> TOMLParser<'a> { } } - pub fn get_value(self: &TOMLParser<'a>, key: S) -> Option> where S: Into { + pub fn get_value(self: &Parser<'a>, key: S) -> Option> where S: Into { let s_key = key.into(); if self.map.contains_key(&s_key) { let hashval = self.map.get(&s_key).unwrap(); @@ -111,7 +111,7 @@ impl<'a> TOMLParser<'a> { } } - pub fn get_children(self: &TOMLParser<'a>, key: S) -> Option<&Children> where S: Into { + pub fn get_children(self: &Parser<'a>, key: S) -> Option<&Children> where S: Into { let s_key = key.into(); let k; if s_key == "" { @@ -127,21 +127,21 @@ impl<'a> TOMLParser<'a> { } } - pub fn set_value(self: &mut TOMLParser<'a>, key: S, tval: Value<'a>) -> bool where S: Into { + pub fn set_value(self: &mut Parser<'a>, key: S, val: Value<'a>) -> bool where S: Into { let s_key = key.into(); { - let val = match self.map.entry(s_key.clone()) { + let tval = match self.map.entry(s_key.clone()) { Entry::Occupied(entry) => entry.into_mut(), _ => return false, }; - let opt_value: &mut Option>>> = &mut val.value; + let opt_value: &mut Option>>> = &mut tval.value; let val_rf = match opt_value { &mut Some(ref mut v) => v, &mut None => return false, }; // if the inline table/array has the same structure the just replace the values - if TOMLParser::same_structure(val_rf, &tval) { - return TOMLParser::replace_values(val_rf, &tval); + if Parser::same_structure(val_rf, &val) { + return Parser::replace_values(val_rf, &val); } } // if the inline table/array has a different structure, delete the existing @@ -150,7 +150,7 @@ impl<'a> TOMLParser<'a> { for key in all_keys.iter() { self.map.remove(key); } - let new_value_opt = TOMLParser::convert_vector(&tval); + let new_value_opt = Parser::convert_vector(&val); if new_value_opt.is_none() { return false; } @@ -162,7 +162,7 @@ impl<'a> TOMLParser<'a> { TOMLValue::InlineTable(ref rc_rc) => { TOMLValue::InlineTable(rc_rc.clone()) }, - unknown => panic!("In TOMLParser.set_value, new_value should only be an Array or InlineTable. Instead it's a {:?}", unknown), + unknown => panic!("In Parser.set_value, new_value should only be an Array or InlineTable. Instead it's a {:?}", unknown), }; if self.map.contains_key(&s_key) { let existing_value = match self.map.entry(s_key.clone()) { @@ -190,7 +190,7 @@ impl<'a> TOMLParser<'a> { let mut values = vec![]; for i in 0..arr.len() { let subval = &arr[i]; - let value_opt = TOMLParser::convert_vector(subval); + let value_opt = Parser::convert_vector(subval); if value_opt.is_none() { return None; } @@ -211,7 +211,7 @@ impl<'a> TOMLParser<'a> { let mut key_values = vec![]; for i in 0..it.len() { let subval = &it[i].1; - let value_opt = TOMLParser::convert_vector(subval); + let value_opt = Parser::convert_vector(subval); let value = value_opt.unwrap(); let key_value; if i < it.len() - 1 { @@ -269,7 +269,7 @@ impl<'a> TOMLParser<'a> { } let len = borrow.values.len(); for i in 0..len { - if !TOMLParser::same_structure(&borrow.values[i].val, &t_arr[i]) { + if !Parser::same_structure(&borrow.values[i].val, &t_arr[i]) { return false; } } @@ -283,7 +283,7 @@ impl<'a> TOMLParser<'a> { let len = borrow.keyvals.len(); for i in 0..len { if borrow.keyvals[i].keyval.key != t_it[i].0 || - !TOMLParser::same_structure(&borrow.keyvals[i].keyval.val, &t_it[i].1) { + !Parser::same_structure(&borrow.keyvals[i].keyval.val, &t_it[i].1) { return false; } } @@ -297,7 +297,7 @@ impl<'a> TOMLParser<'a> { } } - fn rebuild_vector(self: &mut TOMLParser<'a>, key: String, val: Rc>>, skip: bool) { + fn rebuild_vector(self: &mut Parser<'a>, key: String, val: Rc>>, skip: bool) { match *val.borrow() { TOMLValue::Array(ref arr) => { { @@ -326,7 +326,7 @@ impl<'a> TOMLParser<'a> { } if let Children::Keys(ref child_keys) = value.subkeys { for i in 0..it.borrow().keyvals.len() { - TOMLParser::insert(child_keys, it.borrow().keyvals[i].keyval.key.clone().into_owned()); + Parser::insert(child_keys, it.borrow().keyvals[i].keyval.key.clone().into_owned()); } } } @@ -343,7 +343,7 @@ impl<'a> TOMLParser<'a> { } } - fn get_all_subkeys(self: &TOMLParser<'a>, key: &str) -> Vec{ + fn get_all_subkeys(self: &Parser<'a>, key: &str) -> Vec{ let hv_opt = self.map.get(key); let mut all_keys = vec![]; if let Some(hv) = hv_opt { @@ -374,7 +374,7 @@ impl<'a> TOMLParser<'a> { let borrow = arr.borrow(); let len = borrow.values.len(); for i in 0..len { - if !TOMLParser::replace_values(&borrow.values[i].val, &t_arr[i]) { + if !Parser::replace_values(&borrow.values[i].val, &t_arr[i]) { return false; } } @@ -384,7 +384,7 @@ impl<'a> TOMLParser<'a> { let borrow = it.borrow(); let len = borrow.keyvals.len(); for i in 0..len { - if !TOMLParser::replace_values(&borrow.keyvals[i].keyval.val, &t_it[i].1) { + if !Parser::replace_values(&borrow.keyvals[i].keyval.val, &t_it[i].1) { return false; } } @@ -418,7 +418,7 @@ impl<'a> TOMLParser<'a> { } } -impl<'a> Display for TOMLParser<'a> { +impl<'a> Display for Parser<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", *self.root.borrow()) } @@ -429,7 +429,7 @@ mod test { extern crate env_logger; use std::cell::{Cell, RefCell}; use std::rc::Rc; - use parser::TOMLParser; + use internals::parser::Parser; use types::{Value, Children, StrType, Date, Time, DateTime}; struct TT; impl TT { @@ -463,7 +463,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_bare_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_value("animal".to_string()), res2opt!(Value::basic_string("bear"))); } @@ -471,7 +471,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_key_val() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_value("car.model"), res2opt!(Value::basic_string("Civic"))); } @@ -479,7 +479,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_quoted_key_val_int() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_value("car.\"ωλèèℓƨ\""), res2opt!(Value::int_from_str("4"))); } @@ -487,7 +487,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_quoted_key_val_float() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_value("car.\"ƭôƥ ƨƥèèδ\""), res2opt!(Value::float_from_str("124.56"))); } @@ -495,7 +495,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_key_array() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_value("car.drivers[0]"), res2opt!(Value::basic_string("Bob"))); assert_eq!(p.get_value("car.drivers[1]"), res2opt!(Value::basic_string("Jane"))); @@ -508,7 +508,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_key_inline_table() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_value("car.properties.color"), res2opt!(Value::basic_string("red"))); assert_eq!(p.get_value("car.properties.\"plate number\""), res2opt!(Value::basic_string("ABC 345"))); @@ -520,7 +520,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_implicit_table() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_value("car.interior.seats.type"), res2opt!(Value::ml_literal_string("fabric"))); assert_eq!(p.get_value("car.interior.seats.count"), res2opt!(Value::int_from_str("5"))); @@ -529,7 +529,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_array_table() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_value("car.owners[0].Name"), res2opt!(Value::ml_basic_string("Bob Jones"))); assert_eq!(p.get_value("car.owners[0].Age"), Some(Value::int(25))); @@ -540,7 +540,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_get_root_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children(""), Some(&Children::Keys(RefCell::new(vec!["animal".to_string(), "car".to_string()])))); } @@ -548,7 +548,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_get_table_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children("car".to_string()), Some(&Children::Keys(RefCell::new(vec!["owners".to_string(), "interior".to_string(), "model".to_string(), "\"ωλèèℓƨ\"".to_string(), "\"ƭôƥ ƨƥèèδ\"".to_string(), @@ -559,7 +559,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_get_array_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children("car.drivers"), Some(&Children::Count(Cell::new(5)))); } @@ -567,7 +567,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_get_inline_table_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children("car.properties"), Some(&Children::Keys(RefCell::new(vec!["color".to_string(), "\"plate number\"".to_string(), "accident_dates".to_string()])))); @@ -576,7 +576,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_get_nested_inline_table_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children("car.drivers[4]"), Some(&Children::Keys(RefCell::new(vec!["disallowed".to_string(), "banned".to_string()])))); @@ -585,7 +585,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_get_nested_array_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children("car.properties.accident_dates"), Some(&Children::Count(Cell::new(3)))); } @@ -593,7 +593,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_implicit_table_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children("car.interior.seats"), Some(&Children::Keys(RefCell::new(vec!["type".to_string(), "count".to_string()])))); @@ -602,7 +602,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_get_array_of_table_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children("car.owners"), Some(&Children::Count(Cell::new(2)))); } @@ -610,7 +610,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_get_array_of_table0_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children("car.owners[0]"), Some(&Children::Keys(RefCell::new(vec!["Name".to_string(), "Age".to_string()])))); @@ -619,7 +619,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_get_array_of_table1_children() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (p, _) = p.parse(TT::get()); assert_eq!(p.get_children("car.owners[1]"), Some(&Children::Keys(RefCell::new(vec!["Name".to_string(), "Age".to_string()])))); @@ -628,7 +628,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_set_bare_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("animal", Value::ml_basic_string("shark").unwrap()); assert_eq!(p.get_value("animal"), @@ -638,7 +638,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_set_table_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.model", Value::literal_string("Accord").unwrap()); assert_eq!(p.get_value("car.model"), @@ -648,7 +648,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_set_array_element_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.drivers[1]", Value::ml_literal_string("Mark").unwrap()); assert_eq!(p.get_value("car.drivers[1]"), @@ -658,7 +658,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_set_nested_aray_element_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.properties.accident_dates[2]", Value::float(3443.34)); assert_eq!(p.get_value("car.properties.accident_dates[2]"), @@ -668,7 +668,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_set_inline_table_element_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.properties.color", Value::int(19)); assert_eq!(p.get_value("car.properties.color"), @@ -678,7 +678,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_set_nested_inline_table_element_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.drivers[4].banned", Value::datetime_from_int(2013, 9, 23, 17, 34, 2).unwrap()); assert_eq!(p.get_value("car.drivers[4].banned"), @@ -689,7 +689,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_truncate_array() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.drivers", Value::Array(Rc::new( vec![Value::basic_string("Phil").unwrap(), Value::basic_string("Mary").unwrap()] @@ -705,7 +705,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_truncate_inline_table() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.properties", Value::InlineTable(Rc::new( vec![("make".into(), Value::literal_string("Honda").unwrap()), @@ -721,7 +721,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_extend_array() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.drivers", Value::Array(Rc::new( vec![Value::int(1), Value::int(2), Value::int(3), Value::int(4), @@ -744,7 +744,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_extend_inline_table() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.properties", Value::InlineTable(Rc::new( vec![("prop1".into(), Value::bool_from_str("TrUe").unwrap()), @@ -764,7 +764,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_set_implicit_table_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.interior.seats.type", Value::basic_string("leather").unwrap()); assert_eq!(p.get_value("car.interior.seats.type"), @@ -774,7 +774,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_set_array_of_table0_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.owners[0].Age", Value::float_from_str("19.5").unwrap()); assert_eq!(p.get_value("car.owners[0].Age"), @@ -784,7 +784,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_set_array_of_table1_key() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("car.owners[1].Name", Value::ml_basic_string("Steve Parker").unwrap()); assert_eq!(p.get_value("car.owners[1].Name"), @@ -794,7 +794,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_truncate_array_check_keys() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("database.ports", Value::datetime_from_int(2000, 02, 16, 10, 31, 06).unwrap()); assert_eq!(p.get_value("database.ports[0]"), None); @@ -807,7 +807,7 @@ properties = { color = "red", "plate number" = "ABC 345", #[test] fn test_truncate_inline_table_check_keys() { let _ = env_logger::init(); - let p = TOMLParser::new(); + let p = Parser::new(); let (mut p, _) = p.parse(TT::get()); p.set_value("database.servers", Value::datetime_from_str("4000", "02", "27", "01", "59", "59").unwrap()); assert_eq!(p.get_value("database.servers.main"), None); diff --git a/src/internals/primitives.rs b/src/internals/primitives.rs index 00e4b8f..90f159f 100644 --- a/src/internals/primitives.rs +++ b/src/internals/primitives.rs @@ -7,7 +7,7 @@ use internals::ast::structs::{KeyVal, WSSep, TOMLValue, ErrorCode, HashValue, TableType, Table, get_last_keys}; use types::{Date, Time, DateTime, TimeOffset, TimeOffsetAmount, ParseError, StrType, Children, Value}; -use parser::TOMLParser; +use internals::parser::Parser; use nom; use nom::{IResult, InputLength}; @@ -44,7 +44,7 @@ pub fn count_lines(s: &str) -> usize { } } -impl<'a> TOMLParser<'a> { +impl<'a> Parser<'a> { pub fn get_key_parent(tables: &RefCell>>>, tables_index: &RefCell>) -> String { let mut key_parent: String = String::new(); @@ -166,12 +166,12 @@ impl<'a> TOMLParser<'a> { continue; } full_key.push_str(&keys[j]); - valid = valid && !TOMLParser::key_has_value(&full_key, map); + valid = valid && !Parser::key_has_value(&full_key, map); full_key.push('.'); } parent_key = full_key.clone(); full_key.push_str(&keys[keys.len() - 1]); - valid = valid && !TOMLParser::key_has_value(&full_key, map); + valid = valid && !Parser::key_has_value(&full_key, map); } } } @@ -217,8 +217,8 @@ impl<'a> TOMLParser<'a> { tables: &RefCell>>>, tables_index: &RefCell>, keychain: &RefCell>>) -> (bool, String, String) { - let (valid, array_key, _) = TOMLParser::get_array_table_key(map, tables, tables_index); - let (chain_key, parent_chain_key) = TOMLParser::get_keychain_key(keychain); + let (valid, array_key, _) = Parser::get_array_table_key(map, tables, tables_index); + let (chain_key, parent_chain_key) = Parser::get_keychain_key(keychain); debug!("array_key: {}, chain_key: {}, parent_chain_key: {}", array_key, chain_key, parent_chain_key); let mut full_key = String::new(); let mut parent_key = String::new(); @@ -251,7 +251,7 @@ impl<'a> TOMLParser<'a> { // If the value in non-empty add the key/val to the error list // If the key doesn't exist, insert it &None => { - let tuple = TOMLParser::get_keychain_key(&self.keychain); + let tuple = Parser::get_keychain_key(&self.keychain); full_key = tuple.0; parent_key = tuple.1; if parent_key == "" { @@ -279,7 +279,7 @@ impl<'a> TOMLParser<'a> { match **ttype { TableType::Standard(_) => { self.last_array_tables.borrow_mut().push(ttype.clone()); - let tuple = TOMLParser::get_full_key(&map, &self.last_array_tables, + let tuple = Parser::get_full_key(&map, &self.last_array_tables, &self.last_array_tables_index, &self.keychain); full_key = tuple.1; parent_key = tuple.2; @@ -297,7 +297,7 @@ impl<'a> TOMLParser<'a> { } }, TableType::Array(_) => { - let tuple = TOMLParser::get_full_key(&map, &self.last_array_tables, + let tuple = Parser::get_full_key(&map, &self.last_array_tables, &self.last_array_tables_index, &self.keychain); full_key = tuple.1; parent_key = tuple.2; @@ -354,7 +354,7 @@ impl<'a> TOMLParser<'a> { &Children::Count(ref c) => { debug!("parent inc to {}", c.get() + 1); c.set(c.get() + 1) }, &Children::Keys(ref vec_rf) => { if let Key::Str(ref s) = self.keychain.borrow()[self.keychain.borrow().len() - 1] { - TOMLParser::insert(vec_rf,s.clone().into_owned()); + Parser::insert(vec_rf,s.clone().into_owned()); } }, } @@ -375,10 +375,10 @@ impl<'a> TOMLParser<'a> { } // Integer - method!(pub integer, &'a str, &'a str>, self, re_find!(r#"^((\+|-)?(([1-9](\d|(_\d))+)|\d))"#)) ; + method!(pub integer, &'a str, &'a str>, self, re_find!(r#"^((\+|-)?(([1-9](\d|(_\d))+)|\d))"#)) ; // Float - method!(pub float, &'a str, &'a str>, self, + method!(pub float, &'a str, &'a str>, self, re_find!(r#"^(\+|-)?([1-9](\d|(_\d))+|\d)((\.\d(\d|(_\d))*)((e|E)(\+|-)?([1-9](\d|(_\d))+|\d))|(\.\d(\d|(_\d))*)|((e|E)(\+|-)?([1-9](\d|(_\d))+|\d)))"#)); // Basic String @@ -395,28 +395,28 @@ impl<'a> TOMLParser<'a> { named!(pub quoteless_ml_literal_string<&'a str, &'a str>, re_find!(r#"^( |[ -􏿿]|\n|(\r\n))*"#)); // Basic String - method!(raw_basic_string, &'a str, &'a str>, self, + method!(raw_basic_string, &'a str, &'a str>, self, re_find!(r#"^"( |!|[#-\[]|[\]-􏿿]|(\\")|(\\\\)|(\\/)|(\\b)|(\\f)|(\\n)|(\\r)|(\\t)|(\\u[0-9A-Z]{4})|(\\U[0-9A-Z]{8}))*?""#)); // Multiline Basic String // TODO: Convert this to take_while_s using a function that increments self.linecount - method!(raw_ml_basic_string, &'a str, &'a str>, self, + method!(raw_ml_basic_string, &'a str, &'a str>, self, chain!( string: re_find!(r#"^"""([ -\[]|[\]-􏿿]|(\\")|(\\\\)|(\\/)|(\\b)|(\\f)|(\\n)|(\\r)|(\t)|(\\u[0-9A-Z]{4})|(\\U[0-9A-Z]{8})|\n|(\r\n)|(\\(\n|(\r\n))))*?""""#), ||{self.line_count.set(self.line_count.get() + count_lines(string)); string} ) ); // Literal String - method!(raw_literal_string, &'a str, &'a str>, self, re_find!(r#"^'( |[ -&]|[\(-􏿿])*?'"#)); + method!(raw_literal_string, &'a str, &'a str>, self, re_find!(r#"^'( |[ -&]|[\(-􏿿])*?'"#)); // Multiline Literal String // TODO: Convert to take_while_s using a function that increments self.linecount - method!(raw_ml_literal_string, &'a str, &'a str>, self, + method!(raw_ml_literal_string, &'a str, &'a str>, self, chain!( string: re_find!(r#"^'''( |[ -􏿿]|\n|(\r\n))*?'''"#), ||{self.line_count.set(self.line_count.get() + count_lines(string)); string} ) ); - fn ml_basic_string(mut self: TOMLParser<'a>, input: &'a str) -> (TOMLParser<'a>, nom::IResult<&'a str, &'a str>) { + fn ml_basic_string(mut self: Parser<'a>, input: &'a str) -> (Parser<'a>, nom::IResult<&'a str, &'a str>) { let (tmp, raw) = self.raw_ml_basic_string(input); self = tmp; let r = match raw { @@ -427,7 +427,7 @@ impl<'a> TOMLParser<'a> { (self, r) } - fn basic_string(mut self: TOMLParser<'a>, input: &'a str) -> (TOMLParser<'a>, nom::IResult<&'a str, &'a str>) { + fn basic_string(mut self: Parser<'a>, input: &'a str) -> (Parser<'a>, nom::IResult<&'a str, &'a str>) { let (tmp, raw) = self.raw_basic_string(input); self = tmp; let r = match raw { @@ -438,7 +438,7 @@ impl<'a> TOMLParser<'a> { (self, r) } - fn ml_literal_string(mut self: TOMLParser<'a>, input: &'a str) -> (TOMLParser<'a>, nom::IResult<&'a str, &'a str>) { + fn ml_literal_string(mut self: Parser<'a>, input: &'a str) -> (Parser<'a>, nom::IResult<&'a str, &'a str>) { let (tmp, raw) = self.raw_ml_literal_string(input); self = tmp; let r = match raw { @@ -449,7 +449,7 @@ impl<'a> TOMLParser<'a> { (self, r) } - fn literal_string(mut self: TOMLParser<'a>, input: &'a str) -> (TOMLParser<'a>, nom::IResult<&'a str, &'a str>) { + fn literal_string(mut self: Parser<'a>, input: &'a str) -> (Parser<'a>, nom::IResult<&'a str, &'a str>) { let (tmp, raw) = self.raw_literal_string(input); self = tmp; let r = match raw { @@ -460,7 +460,7 @@ impl<'a> TOMLParser<'a> { (self, r) } - method!(string, &'a str, TOMLValue>, mut self, + method!(string, &'a str, TOMLValue>, mut self, alt!( complete!(call_m!(self.ml_literal_string)) => {|ml: &'a str| TOMLValue::String(ml.into(), StrType::MLLiteral)} | complete!(call_m!(self.ml_basic_string)) => {|mb: &'a str| TOMLValue::String(mb.into(), StrType::MLBasic)} | @@ -471,16 +471,16 @@ impl<'a> TOMLParser<'a> { // TODO: Allow alternate casing, but report it as an error // Boolean - method!(boolean, &'a str, bool>, self, alt!(complete!(tag_s!("false")) => {|_| false} | + method!(boolean, &'a str, bool>, self, alt!(complete!(tag_s!("false")) => {|_| false} | complete!(tag_s!("true")) => {|_| true})); // Datetime // I use re_capture here because I only want the number without the dot. It captures the entire match // in the 0th position and the first capture group in the 1st position - method!(fractional, &'a str, Vec<&'a str> >, self, re_capture!("^\\.([0-9]+)")); + method!(fractional, &'a str, Vec<&'a str> >, self, re_capture!("^\\.([0-9]+)")); - method!(time, &'a str, Time>, mut self, + method!(time, &'a str, Time>, mut self, chain!( tag_s!("T") ~ hour: re_find!("^[0-9]{2}") ~ @@ -501,7 +501,7 @@ impl<'a> TOMLParser<'a> { ) ); - method!(time_offset_amount, &'a str, TimeOffsetAmount >, self, + method!(time_offset_amount, &'a str, TimeOffsetAmount >, self, chain!( pos_neg: alt!(complete!(tag_s!("+")) | complete!(tag_s!("-"))) ~ hour: re_find!("^[0-9]{2}") ~ @@ -513,14 +513,14 @@ impl<'a> TOMLParser<'a> { ) ); - method!(time_offset, &'a str, TimeOffset>, mut self, + method!(time_offset, &'a str, TimeOffset>, mut self, alt!( complete!(tag_s!("Z")) => {|_| TimeOffset::Zulu} | complete!(call_m!(self.time_offset_amount)) => {|offset| TimeOffset::Time(offset)} ) ); - method!(date, &'a str, Date>, self, + method!(date, &'a str, Date>, self, chain!( year: re_find!("^([0-9]{4})") ~ tag_s!("-") ~ @@ -533,7 +533,7 @@ impl<'a> TOMLParser<'a> { ) ); - pub fn date_time(mut self: TOMLParser<'a>, input: &'a str) -> (TOMLParser<'a>, IResult<&'a str, DateTime>) { + pub fn date_time(mut self: Parser<'a>, input: &'a str) -> (Parser<'a>, IResult<&'a str, DateTime>) { let before_len = input.len(); let (tmp, result) = self.date_time_internal(input); self = tmp; @@ -542,7 +542,7 @@ impl<'a> TOMLParser<'a> { if !o.validate() { let parsed_len = before_len - i.len(); self.errors.borrow_mut().push(ParseError::InvalidDateTime( - TOMLParser::get_full_key(&RefCell::new(& mut self.map), &self.last_array_tables, + Parser::get_full_key(&RefCell::new(& mut self.map), &self.last_array_tables, &self.last_array_tables_index, &self.keychain ).1, self.line_count.get(), 0, input[0..parsed_len].into() )); @@ -553,7 +553,7 @@ impl<'a> TOMLParser<'a> { } } - method!(date_time_internal, &'a str, DateTime>, mut self, + method!(date_time_internal, &'a str, DateTime>, mut self, chain!( date: call_m!(self.date) ~ time: complete!(call_m!(self.time))? , @@ -565,11 +565,11 @@ impl<'a> TOMLParser<'a> { ); // Key-TOMLValue pairs - method!(unquoted_key, &'a str, &'a str>, self, take_while1_s!(is_keychar)); - method!(quoted_key, &'a str, &'a str>, self, + method!(unquoted_key, &'a str, &'a str>, self, take_while1_s!(is_keychar)); + method!(quoted_key, &'a str, &'a str>, self, re_find!("^\"( |!|[#-\\[]|[\\]-􏿿]|(\\\\\")|(\\\\\\\\)|(\\\\/)|(\\\\b)|(\\\\f)|(\\\\n)|(\\\\r)|(\\\\t)|(\\\\u[0-9A-Z]{4})|(\\\\U[0-9A-Z]{8}))+\"")); - method!(pub key, &'a str, &'a str>, mut self, alt!( + method!(pub key, &'a str, &'a str>, mut self, alt!( complete!(call_m!(self.quoted_key)) => {|k: &'a str| { self.keychain.borrow_mut().push(Key::Str(k.into())); k }}| @@ -577,7 +577,7 @@ impl<'a> TOMLParser<'a> { self.keychain.borrow_mut().push(Key::Str(k.into())); k}} )); - method!(keyval_sep, &'a str, WSSep>, mut self, + method!(keyval_sep, &'a str, WSSep>, mut self, chain!( ws1: call_m!(self.ws) ~ tag_s!("=") ~ @@ -588,7 +588,7 @@ impl<'a> TOMLParser<'a> { ) ); - method!(pub val, &'a str, Rc> >, mut self, + method!(pub val, &'a str, Rc> >, mut self, alt!( complete!(call_m!(self.array)) => {|arr| Rc::new(RefCell::new(TOMLValue::Array(arr)))} | complete!(call_m!(self.inline_table)) => {|it| Rc::new(RefCell::new(TOMLValue::InlineTable(it)))} | @@ -600,7 +600,7 @@ impl<'a> TOMLParser<'a> { ) ); - method!(pub keyval, &'a str, KeyVal>, mut self, + method!(pub keyval, &'a str, KeyVal>, mut self, chain!( key: call_m!(self.key) ~ ws: call_m!(self.keyval_sep) ~ @@ -634,31 +634,31 @@ mod test { InlineTable, TableKeyVal, TOMLValue, CommentOrNewLines}; use types::{DateTime, Time, Date, TimeOffsetAmount, TimeOffset, StrType}; - use parser::TOMLParser; + use internals::parser::Parser; use std::rc::Rc; use std::cell::RefCell; #[test] fn test_integer() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.integer("345_12_678").1, Done("", "345_12_678")); } #[test] fn test_float() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.float("98_7.2_34e-8_8").1, Done("", "98_7.2_34e-8_8")); } #[test] fn test_basic_string() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.basic_string("\"Tλïƨ ïƨ á βáƨïç ƨƭřïñϱ.\"").1, Done("", "Tλïƨ ïƨ á βáƨïç ƨƭřïñϱ.")); } #[test] fn test_ml_basic_string() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.ml_basic_string("\"\"\"£ïñè Óñè £ïñè Tωô £ïñè Tλřèè\"\"\"").1, Done("", r#"£ïñè Óñè @@ -668,13 +668,13 @@ mod test { #[test] fn test_literal_string() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.literal_string("'Abc ÑŸ'").1, Done("", "Abc ÑŸ")); } #[test] fn test_ml_literal_string() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.ml_literal_string(r#"''' Abc ÑŸ '''"#).1, @@ -685,9 +685,9 @@ mod test { #[test] fn test_string() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.string("\"βáƨïç_ƨƭřïñϱ\"").1, Done("", TOMLValue::String("βáƨïç_ƨƭřïñϱ".into(), StrType::Basic))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.string(r#""""₥ℓ_βáƨïç_ƨƭřïñϱ ñú₥βèř_ƭωô NÛMßÉR-THRÉÉ @@ -695,9 +695,9 @@ NÛMßÉR-THRÉÉ ñú₥βèř_ƭωô NÛMßÉR-THRÉÉ "#.into(), StrType::MLBasic))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.string("'£ÌTÉR壤TRïNG'").1, Done("", TOMLValue::String("£ÌTÉR壤TRïNG".into(), StrType::Literal))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.string(r#"'''§ƥřïƭè Çôƙè Þèƥƨï @@ -710,31 +710,31 @@ NÛMßÉR-THRÉÉ #[test] fn test_boolean() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.boolean("true").1, Done("", true)); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.boolean("false").1, Done("", false)); } #[test] fn test_fractional() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.fractional(".03856").1, Done("", vec![".03856", "03856"])); } #[test] fn test_time() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.time("T11:22:33.456").1, Done("", Time::new_str("11", "22", "33", Some("456"), None))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.time("T04:05:06").1, Done("", Time::new_str("04", "05", "06", None, None))); } #[test] fn test_time_offset_amount() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.time_offset_amount("+12:34").1, Done("", TimeOffsetAmount::new_str("+", "12", "34")) ); @@ -742,17 +742,17 @@ NÛMßÉR-THRÉÉ #[test] fn test_time_offset() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.time_offset("+12:34").1, Done("", TimeOffset::Time(TimeOffsetAmount::new_str("+", "12", "34"))) ); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.time_offset("Z").1, Done("", TimeOffset::Zulu)); } #[test] fn test_full_date() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.date("1942-12-07").1, Done("", Date::new_str("1942", "12", "07")) ); @@ -760,7 +760,7 @@ NÛMßÉR-THRÉÉ #[test] fn test_date_time() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.date_time("1999-03-21T20:15:44.5-07:00").1, Done("", DateTime::new(Date::new_str("1999", "03", "21"), Some(Time::new_str("20", "15", "44", Some("5"), @@ -771,33 +771,33 @@ NÛMßÉR-THRÉÉ #[test] fn test_unquoted_key() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.unquoted_key("Un-Quoted_Key").1, Done("", "Un-Quoted_Key")); } #[test] fn test_quoted_key() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.quoted_key("\"QúôƭèδKè¥\"").1, Done("", "\"QúôƭèδKè¥\"")); } #[test] fn test_key() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.key("\"Gřáƥèƒřúïƭ\"").1, Done("", "\"Gřáƥèƒřúïƭ\"")); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.key("_is-key").1, Done("", "_is-key")); } #[test] fn test_keyval_sep() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.keyval_sep("\t \t= \t").1, Done("", WSSep::new_str("\t \t", " \t"))); } #[test] fn test_val() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.val("[4,9]").1, Done("", Rc::new(RefCell::new(TOMLValue::Array(Rc::new(RefCell::new(Array::new( vec![ @@ -813,7 +813,7 @@ NÛMßÉR-THRÉÉ vec![CommentOrNewLines::NewLines("".into())], vec![CommentOrNewLines::NewLines("".into())] )) )))))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.val("{\"§ô₥è Þïϱ\"='Táƨƭ¥ Þôřƙ'}").1, Done("", Rc::new(RefCell::new(TOMLValue::InlineTable(Rc::new(RefCell::new(InlineTable::new( vec![ @@ -828,26 +828,26 @@ NÛMßÉR-THRÉÉ ], WSSep::new_str("", "") )))))))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.val("2112-09-30T12:33:01.345-11:30").1, Done("", Rc::new(RefCell::new(TOMLValue::DateTime( DateTime::new(Date::new_str("2112", "09", "30"), Some(Time::new_str("12", "33", "01", Some("345"), Some(TimeOffset::Time(TimeOffsetAmount::new_str("-", "11", "30")) ))))))))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.val("3487.3289E+22").1, Done("", Rc::new(RefCell::new(TOMLValue::Float("3487.3289E+22".into()))))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.val("8932838").1, Done("", Rc::new(RefCell::new(TOMLValue::Integer("8932838".into()))))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.val("false").1, Done("", Rc::new(RefCell::new(TOMLValue::Boolean(false))))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.val("true").1, Done("", Rc::new(RefCell::new(TOMLValue::Boolean(true))))); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.val("'§ô₥è §ƭřïñϱ'").1, Done("", Rc::new(RefCell::new(TOMLValue::String("§ô₥è §ƭřïñϱ".into(), StrType::Literal))))); } #[test] fn test_keyval() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.keyval("Boolean = 84.67").1, Done("", KeyVal::new_str( "Boolean", WSSep::new_str(" ", " "), Rc::new(RefCell::new(TOMLValue::Float("84.67".into()))) diff --git a/src/internals/toml.rs b/src/internals/toml.rs index ac5b3e3..66b8d6b 100644 --- a/src/internals/toml.rs +++ b/src/internals/toml.rs @@ -1,8 +1,8 @@ use internals::ast::structs::{Toml, NLExpression, Expression, WSSep}; -use parser::TOMLParser; +use internals::parser::Parser; -impl<'a> TOMLParser<'a> { - method!(pub toml, &'a str, Toml>, mut self, +impl<'a> Parser<'a> { + method!(pub toml, &'a str, Toml>, mut self, chain!( expr: call_m!(self.expression) ~ nl_exprs: call_m!(self.nl_expressions), @@ -13,9 +13,9 @@ impl<'a> TOMLParser<'a> { ) ); - method!(nl_expressions, &'a str, Vec >, mut self, many0!(call_m!(self.nl_expression))); + method!(nl_expressions, &'a str, Vec >, mut self, many0!(call_m!(self.nl_expression))); - method!(nl_expression, &'a str, NLExpression>, mut self, + method!(nl_expression, &'a str, NLExpression>, mut self, chain!( nl: call_m!(self.newline) ~ expr: call_m!(self.expression) , @@ -25,7 +25,7 @@ impl<'a> TOMLParser<'a> { ) ); - method!(expression, &'a str, Expression>, mut self, + method!(expression, &'a str, Expression>, mut self, alt!( complete!(call_m!(self.table_comment)) | complete!(call_m!(self.keyval_comment)) | @@ -34,7 +34,7 @@ impl<'a> TOMLParser<'a> { ) ); - method!(ws_expr, &'a str, Expression>, mut self, + method!(ws_expr, &'a str, Expression>, mut self, chain!( ws: call_m!(self.ws), ||{ @@ -42,7 +42,7 @@ impl<'a> TOMLParser<'a> { } )); - method!(table_comment, &'a str, Expression>, mut self, + method!(table_comment, &'a str, Expression>, mut self, chain!( ws1: call_m!(self.ws) ~ table: call_m!(self.table) ~ @@ -54,7 +54,7 @@ impl<'a> TOMLParser<'a> { ) ); - method!(keyval_comment, &'a str, Expression>, mut self, + method!(keyval_comment, &'a str, Expression>, mut self, chain!( ws1: call_m!(self.ws) ~ keyval: call_m!(self.keyval) ~ @@ -66,7 +66,7 @@ impl<'a> TOMLParser<'a> { ) ); - method!(ws_comment, &'a str, Expression>, mut self, + method!(ws_comment, &'a str, Expression>, mut self, chain!( ws: call_m!(self.ws) ~ comment: call_m!(self.comment), @@ -82,7 +82,7 @@ mod test { use std::rc::Rc; use std::cell::RefCell; use nom::IResult::Done; - use parser::TOMLParser; + use internals::parser::Parser; use types::{TimeOffsetAmount, DateTime, Date, Time, TimeOffset, StrType}; use internals::ast::structs::{Expression, Comment, WSSep, KeyVal, Table, WSKeySep, TableType, TOMLValue, NLExpression, ArrayValue, Toml, @@ -91,7 +91,7 @@ mod test { #[test] fn test_toml() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.toml( r#"# Tλïƨ ïƨ á TÓM£ δôçú₥èñƭ. @@ -223,12 +223,12 @@ enabled = true"#).1, Done("", #[test] fn test_nl_expressions() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); // allow for zero expressions assert_eq!(p.nl_expressions("aoeunth £ôřè₥ ïƥƨú₥ doℓôř ƨïƭ amet, çônƨèçƭeƭuř áδïƥïscïñϱ èℓïƭ").1, Done("aoeunth £ôřè₥ ïƥƨú₥ doℓôř ƨïƭ amet, çônƨèçƭeƭuř áδïƥïscïñϱ èℓïƭ", vec![]) ); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.nl_expressions("\n[\"δřá\"]#Mèƨsaϱè\r\nkey=\"value\"#wλïƭeƨƥáçè\n").1, Done( "", vec![ @@ -260,7 +260,7 @@ enabled = true"#).1, Done("", ] ) ); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.nl_expressions("\n[[NODOTNET.\"NÓJÂVÂ\"]]").1, Done( "", vec![ @@ -279,7 +279,7 @@ enabled = true"#).1, Done("", // named!(nl_expression<&'a str, NLExpression>, #[test] fn test_nl_expression() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.nl_expression("\r\n SimpleKey = 1_2_3_4_5 # áñ áƭƭè₥ƥƭ ƭô δèƒïñè TÓM£\r\n").1, Done("\r\n", NLExpression::new_str( "\r\n", Expression::new( @@ -294,7 +294,7 @@ enabled = true"#).1, Done("", #[test] fn test_expression() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.expression(" \t[\"δřáƒƭ\".THISKEY . \tkeythethird] \t#Mèƨƨáϱè Rèƥℓïèδ\n").1, Done("\n", Expression::new( @@ -307,7 +307,7 @@ enabled = true"#).1, Done("", Some(Comment::new_str("Mèƨƨáϱè Rèƥℓïèδ")) ) )); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.expression("\t\t\t\"řúññïñϱôúƭôƒωôřδƨ\" = 0.1 #Â₥èřïçáñ Éжƥřèƨƨ\n").1, Done("\n", Expression::new( @@ -317,13 +317,13 @@ enabled = true"#).1, Done("", None, Some(Comment::new_str("Â₥èřïçáñ Éжƥřèƨƨ")) ) )); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.expression("\t \t #Þℓèáƨè Ʋèř Your áççôúñƭ\n").1, Done("\n", Expression::new( WSSep::new_str("\t \t ", ""), None, None, Some(Comment::new_str("Þℓèáƨè Ʋèř Your áççôúñƭ")) ) )); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.expression("\t \t \t\n").1, Done("\n", Expression::new( WSSep::new_str("\t \t \t", ""), None, None, None, @@ -332,7 +332,7 @@ enabled = true"#).1, Done("", #[test] fn test_ws_expr() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.ws_expr(" \t \t \n").1, Done("\n", Expression::new(WSSep::new_str(" \t \t ", ""), None, None, None) )); @@ -340,7 +340,7 @@ enabled = true"#).1, Done("", #[test] fn test_table_comment() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.table_comment(" [table.\"ƭáβℓè\"] #úñïçôřñřôβôƭ\n").1, Done("\n", Expression::new(WSSep::new_str(" ", " "), None, Some(Rc::new(TableType::Standard(Table::new_str( @@ -355,7 +355,7 @@ enabled = true"#).1, Done("", #[test] fn test_keyval_comment() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.keyval_comment(" \"Tôƭáℓℓ¥\" = true\t#λèřè ïƨ ₥¥ çô₥₥èñƭ\n").1, Done("\n", Expression::new(WSSep::new_str(" ", "\t"), Some(KeyVal::new_str( @@ -368,7 +368,7 @@ enabled = true"#).1, Done("", #[test] fn test_ws_comment() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.ws_comment(" \t #This is RÂNÐÓM §TRÌNG\n").1, Done("\n", Expression::new(WSSep::new_str(" \t ", ""), None, None, Some(Comment::new_str("This is RÂNÐÓM §TRÌNG")) ) diff --git a/src/internals/util.rs b/src/internals/util.rs index 95eaf1d..511e431 100644 --- a/src/internals/util.rs +++ b/src/internals/util.rs @@ -1,13 +1,13 @@ use internals::ast::structs::Comment; -use parser::TOMLParser; +use internals::parser::Parser; fn not_eol(chr: char) -> bool { chr as u32 == 0x09 || (chr as u32 >= 0x20 && chr as u32 <= 0x10FFF) } -impl<'a> TOMLParser<'a> { +impl<'a> Parser<'a> { // Newline - method!(pub newline, &'a str, &'a str>, self, + method!(pub newline, &'a str, &'a str>, self, alt!( complete!(tag_s!("\r\n")) => {|s| {self.line_count.set(self.line_count.get() + 1); s}} | complete!(tag_s!("\n")) => {|s| {self.line_count.set(self.line_count.get() + 1); s}} @@ -15,10 +15,10 @@ impl<'a> TOMLParser<'a> { ); // Whitespace - method!(pub ws, &'a str, &'a str>, self, re_find!("^( |\t)*")); + method!(pub ws, &'a str, &'a str>, self, re_find!("^( |\t)*")); // Comment - method!(pub comment, &'a str, Comment>, self, + method!(pub comment, &'a str, Comment>, self, chain!( tag_s!("#") ~ comment_txt: take_while_s!(not_eol) , @@ -32,26 +32,26 @@ impl<'a> TOMLParser<'a> { #[cfg(test)] mod test { use nom::IResult::Done; - use parser::TOMLParser; + use internals::parser::Parser; use internals::ast::structs::Comment; #[test] fn test_newline() { - let mut p = TOMLParser::new(); + let mut p = Parser::new(); assert_eq!(p.newline("\r\n").1, Done("", "\r\n")); - p = TOMLParser::new(); + p = Parser::new(); assert_eq!(p.newline("\n").1, Done("", "\n")); } #[test] fn test_ws() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.ws(" \t ").1, Done("", " \t ")); } #[test] fn test_comment() { - let p = TOMLParser::new(); + let p = Parser::new(); assert_eq!(p.comment("# Hèřè'ƨ ₥¥ çô₥₥èñƭ. -?#word").1, Done("", Comment::new_str(" Hèřè'ƨ ₥¥ çô₥₥èñƭ. -?#word"))); } diff --git a/src/lib.rs b/src/lib.rs index de8da6b..4eb48e0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,4 +6,38 @@ extern crate log; #[macro_use] mod internals; pub mod types; -pub mod parser; \ No newline at end of file + +use std::fmt; +use std::fmt::Display; +use types::{ParseResult, Value, Children}; +use internals::parser::Parser; + +pub struct TOMLParser<'a> { + parser: Parser<'a>, +} + +impl<'a> TOMLParser<'a> { + pub fn new() -> TOMLParser<'a> { + TOMLParser{parser: Parser::new()} + } + pub fn parse(mut self, input: &'a str) -> (TOMLParser<'a>, ParseResult<'a>) { + let (tmp, result) = self.parser.parse(input); + self.parser = tmp; + (self, result) + } + pub fn get_value(self: &TOMLParser<'a>, key: S) -> Option> where S: Into { + self.parser.get_value(key) + } + pub fn get_children(self: &TOMLParser<'a>, key: S) -> Option<&Children> where S: Into { + self.parser.get_children(key) + } + pub fn set_value(self: &mut TOMLParser<'a>, key: S, val: Value<'a>) -> bool where S: Into { + self.parser.set_value(key, val) + } +} + +impl<'a> Display for TOMLParser<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.parser) + } +} diff --git a/src/types.rs b/src/types.rs index 1dbf568..cfb24dd 100644 --- a/src/types.rs +++ b/src/types.rs @@ -7,18 +7,19 @@ use std::error::Error; use std::fmt::Display; use std::str::FromStr; use std::borrow::Cow; -use parser::TOMLParser; +use internals::parser::Parser; use nom::IResult; #[derive(Debug, Eq, PartialEq, Clone)] pub enum ParseResult<'a> { Full, - FullError, + FullError(Rc>>>), Partial(Cow<'a, str>, usize, usize), - PartialError(Cow<'a, str>, usize, usize), + PartialError(Cow<'a, str>, usize, usize, Rc>>>), Failure(usize, usize), } +#[derive(Debug, Eq, PartialEq, Clone)] pub enum ParseError<'a> { MixedArray(String, usize, usize), DuplicateKey(String, usize, usize, Value<'a>), @@ -36,7 +37,7 @@ pub enum ParseError<'a> { GenericError(String, usize, usize, Option>, String), } -#[derive(Debug, PartialEq, Eq)] +#[derive(Debug, PartialEq, Eq, Clone)] pub enum Value<'a> { Integer(Cow<'a, str>), Float(Cow<'a, str>), @@ -437,7 +438,7 @@ impl<'a> Value<'a> { } pub fn datetime_parse(dt: S) -> Result, TOMLError> where S: Into<&'a str> { let datetime = dt.into(); - let p = TOMLParser::new(); + let p = Parser::new(); match p.date_time(datetime) { (_, IResult::Done(i, o)) => { let result = Value::DateTime(o); @@ -486,14 +487,14 @@ impl<'a> Value<'a> { pub fn validate(&self) -> bool{ match self { &Value::Integer(ref s) => { - let p = TOMLParser::new(); + let p = Parser::new(); match p.integer(s) { (_, IResult::Done(_, _)) => true, (_,_) => false, } }, &Value::Float(ref s) => { - let p = TOMLParser::new(); + let p = Parser::new(); match p.float(s) { (_, IResult::Done(_, _)) => true, (_,_) => false, @@ -503,25 +504,25 @@ impl<'a> Value<'a> { &Value::String(ref s, st) => { match st { StrType::Basic => { - match TOMLParser::quoteless_basic_string(s) { + match Parser::quoteless_basic_string(s) { IResult::Done(i,_) => i.len() == 0, _ => false, } }, StrType::MLBasic => { - match TOMLParser::quoteless_ml_basic_string(s) { + match Parser::quoteless_ml_basic_string(s) { IResult::Done(i,_) => i.len() == 0, _ => false, } }, StrType::Literal => { - match TOMLParser::quoteless_literal_string(s) { + match Parser::quoteless_literal_string(s) { IResult::Done(i,_) => i.len() == 0, _ => false, } }, StrType::MLLiteral => { - match TOMLParser::quoteless_ml_literal_string(s) { + match Parser::quoteless_ml_literal_string(s) { IResult::Done(i,_) => i.len() == 0, _ => false, } diff --git a/tests/assets.rs b/tests/assets.rs index 37cffe5..68fdbd1 100644 --- a/tests/assets.rs +++ b/tests/assets.rs @@ -2,7 +2,7 @@ use std::fs; use std::fs::File; extern crate tomllib; extern crate env_logger; -use tomllib::parser::TOMLParser; +use tomllib::TOMLParser; use tomllib::types::ParseResult; use std::io::{Read, BufReader}; diff --git a/tests/get_set.rs b/tests/get_set.rs index e9a0547..df7ae75 100644 --- a/tests/get_set.rs +++ b/tests/get_set.rs @@ -1,17 +1,17 @@ extern crate tomllib; extern crate env_logger; -use tomllib::parser::TOMLParser; +use tomllib::TOMLParser; use tomllib::types::{ParseResult, Value, ParseError, Children}; use std::rc::Rc; use std::cell::{Cell, RefCell}; - #[test] - fn test_output_after_set() { - let _ = env_logger::init(); - let p = TOMLParser::new(); - let (mut p, _) = p.parse(r#"animal = "bear" +#[test] +fn test_output_after_set() { + let _ = env_logger::init(); + let p = TOMLParser::new(); + let (mut p, _) = p.parse(r#"animal = "bear" [[car.owners]] Name = """Bob Jones""" @@ -31,36 +31,36 @@ model = "Civic" "Date of Manufacture" = 2007-05-16T10:12:13.2324+04:00 drivers = ["Bob", "Jane", "John", "Michael", { disallowed = "Chris", banned="Sally"}] properties = { color = "red", "plate number" = "ABC 345", - accident_dates = [2008-09-29, 2011-01-16, 2014-11-30T03:13:54]} + accident_dates = [2008-09-29, 2011-01-16, 2014-11-30T03:13:54]} "#); - p.set_value("car.interior.seats.type", Value::basic_string("leather").unwrap()); - p.set_value("car.interior.seats.type", Value::basic_string("vinyl").unwrap()); - p.set_value("car.owners[0].Age", Value::float_from_str("19.5").unwrap()); - p.set_value("car.owners[1].Name", Value::ml_basic_string("Steve Parker").unwrap()); - p.set_value("car.drivers[4].banned", Value::datetime_from_int(2013, 9, 23, 17, 34, 2).unwrap()); - p.set_value("car.properties.color", Value::int(19)); - p.set_value("car.properties.accident_dates[2]", Value::float(3443.34)); - p.set_value("car.drivers[1]", Value::ml_literal_string("Mark").unwrap()); - p.set_value("car.properties", Value::InlineTable(Rc::new( - vec![("make".into(), Value::literal_string("Honda").unwrap()), - ("transmission".into(), Value::bool(true))] - ))); - p.set_value("car.drivers", Value::Array(Rc::new( - vec![Value::basic_string("Phil").unwrap(), Value::basic_string("Mary").unwrap()] - ))); - p.set_value("car.properties", Value::InlineTable(Rc::new( - vec![("prop1".into(), Value::bool_from_str("TrUe").unwrap()), - ("prop2".into(), Value::bool_from_str("FALSE").unwrap()), - ("prop3".into(), Value::bool_from_str("truE").unwrap()), - ("prop4".into(), Value::bool_from_str("false").unwrap())] - ))); - p.set_value("car.drivers", Value::Array(Rc::new( - vec![Value::int(1), Value::int(2), Value::int(3), Value::int(4), - Value::int(5), Value::int(6), Value::int(7), Value::int(8)] - ))); - p.set_value("car.model", Value::literal_string("Accord").unwrap()); - p.set_value("animal", Value::ml_basic_string("shark").unwrap()); - assert_eq!(r#"animal = """shark""" + p.set_value("car.interior.seats.type", Value::basic_string("leather").unwrap()); + p.set_value("car.interior.seats.type", Value::basic_string("vinyl").unwrap()); + p.set_value("car.owners[0].Age", Value::float_from_str("19.5").unwrap()); + p.set_value("car.owners[1].Name", Value::ml_basic_string("Steve Parker").unwrap()); + p.set_value("car.drivers[4].banned", Value::datetime_from_int(2013, 9, 23, 17, 34, 2).unwrap()); + p.set_value("car.properties.color", Value::int(19)); + p.set_value("car.properties.accident_dates[2]", Value::float(3443.34)); + p.set_value("car.drivers[1]", Value::ml_literal_string("Mark").unwrap()); + p.set_value("car.properties", Value::InlineTable(Rc::new( + vec![("make".into(), Value::literal_string("Honda").unwrap()), + ("transmission".into(), Value::bool(true))] + ))); + p.set_value("car.drivers", Value::Array(Rc::new( + vec![Value::basic_string("Phil").unwrap(), Value::basic_string("Mary").unwrap()] + ))); + p.set_value("car.properties", Value::InlineTable(Rc::new( + vec![("prop1".into(), Value::bool_from_str("TrUe").unwrap()), + ("prop2".into(), Value::bool_from_str("FALSE").unwrap()), + ("prop3".into(), Value::bool_from_str("truE").unwrap()), + ("prop4".into(), Value::bool_from_str("false").unwrap())] + ))); + p.set_value("car.drivers", Value::Array(Rc::new( + vec![Value::int(1), Value::int(2), Value::int(3), Value::int(4), + Value::int(5), Value::int(6), Value::int(7), Value::int(8)] + ))); + p.set_value("car.model", Value::literal_string("Accord").unwrap()); + p.set_value("animal", Value::ml_basic_string("shark").unwrap()); + assert_eq!(r#"animal = """shark""" [[car.owners]] Name = """Bob Jones""" @@ -81,7 +81,7 @@ model = 'Accord' drivers = [1, 2, 3, 4, 5, 6, 7, 8] properties = { prop1 = true, prop2 = false, prop3 = true, prop4 = false } "#, format!("{}", p)); - } +} struct TT; impl TT { @@ -125,19 +125,18 @@ fn test_mixed_tables() { assert!(result == ParseResult::Full, "Parse of mixed tables document had errors when it shouldn't have."); } -fn check_errors(parser: &TOMLParser, result: &ParseResult) -> (bool, String){ - let mut get_errors = false; +fn check_errors(result: &ParseResult) -> (bool, String) { let mut leftover = "".to_string(); + let mut opt_errors: Option<&Rc>>> = None; match result { - &ParseResult::FullError => {get_errors = true;}, + &ParseResult::FullError(ref e) => {opt_errors = Some(e);}, &ParseResult::Partial(ref l,_,_) => {leftover = l.clone().into_owned();}, - &ParseResult::PartialError(ref l,_,_) => {get_errors = true; leftover = l.clone().into_owned();}, + &ParseResult::PartialError(ref l,_,_,ref e) => {opt_errors = Some(e); leftover = l.clone().into_owned();}, &ParseResult::Failure(ref line,_) => {assert!(false, "failed at line number: {}", line);}, _ => (), } let mut full_error = "".to_string(); - if get_errors { - let errors = parser.get_errors(); + if let Some(errors) = opt_errors { for error in errors.borrow().iter() { match error { &ParseError::MixedArray(ref key, _, _) => full_error.push_str(&format!("MixedArray error: {}\n", key)), @@ -148,7 +147,6 @@ fn check_errors(parser: &TOMLParser, result: &ParseResult) -> (bool, String){ } } } - parser.print_keys_and_values_debug(); if leftover != "" { full_error.push_str(&format!("$$ Leftover =\n\"{}\"", leftover)); return (false, full_error); @@ -161,15 +159,19 @@ fn test_mixed_mixed_array_fail() { let _ = env_logger::init(); let parser = TOMLParser::new(); - let (parser, result) = parser.parse(r#"[[foo."bar"]] + let (_, result) = parser.parse(r#"[[foo."bar"]] baz = 2016-03-10T12:31:02+07:30 qux = """ƒáβúℓôúƨ δïñôƨáúř""" array = [1, 2, {you = ["good", """bye"""], fire = "truck"}, 3] [owner] a_key = "a value" "#); - assert!(check_errors(&parser, &result).0, "There should have been a mixed array error, but there wasn't."); - let errors = parser.get_errors(); + assert!(check_errors(&result).0, "There should have been a mixed array error, but there wasn't."); + let errors = match result { + ParseResult::FullError(e) => e, + ParseResult::PartialError(_,_,_,e) => e, + _ => panic!("There should have been a mixed array error, but there wasn't."), + }; let error = &errors.borrow()[0]; if let &ParseError::MixedArray(ref key, line, _col) = error { assert!(key == "foo.\"bar\"[0].array" && line == 4, @@ -185,14 +187,18 @@ fn test_mixed_mixed_array_in_inline_table_fail() { let _ = env_logger::init(); let parser = TOMLParser::new(); - let (parser, result) = parser.parse(r#"[foo.quality.machine.parts.service] + let (_, result) = parser.parse(r#"[foo.quality.machine.parts.service] "ƥèřïôδ" = 24.7 "inline table" = { drink = 5.5, meal = [ 6, { start = 1980-05-14, end = 2002-10-19 } ], dessert = '''cake''' } [owner] a_key = "a value" "#); - assert!(check_errors(&parser, &result).0, "There should have been a mixed array error, but there wasn't."); - let errors = parser.get_errors(); + assert!(check_errors(&result).0, "There should have been a mixed array error, but there wasn't."); + let errors = match result { + ParseResult::FullError(e) => e, + ParseResult::PartialError(_,_,_,e) => e, + _ => panic!("There should have been a mixed array error, but there wasn't."), + }; let error = &errors.borrow()[0]; if let &ParseError::MixedArray(ref key, line, _col) = error { assert!(key == "foo.quality.machine.parts.service.\"inline table\".meal" && line == 3, @@ -362,7 +368,7 @@ fn test_invalid_table_fail() { let _ = env_logger::init(); let parser = TOMLParser::new(); - let (parser, result) = parser.parse(r#"[foo.quality] + let (_, result) = parser.parse(r#"[foo.quality] "ƥèřïôδ" = 24.7 [owner] a_key = "a value" @@ -370,8 +376,12 @@ a_key = "a value" KEYONE = "VALUEONE" KEYTWO = "VALUETWO" "#); - assert!(check_errors(&parser, &result).0, "There should have been an invalid table error, but there wasn't."); - let errors = parser.get_errors(); + assert!(check_errors(&result).0, "There should have been an invalid table error, but there wasn't."); + let errors = match result { + ParseResult::FullError(e) => e, + ParseResult::PartialError(_,_,_,e) => e, + _ => panic!("There should have been an invalid table error, but there wasn't."), + }; let error = &errors.borrow()[0]; if let &ParseError::InvalidTable(ref key, line, _col, ref rc_hm) = error { assert!(key == "foo.quality" && line == 5, @@ -389,7 +399,7 @@ fn test_duplicate_key_fail() { let _ = env_logger::init(); let parser = TOMLParser::new(); - let (parser, result) = parser.parse(r#"[foo.quality] + let (_, result) = parser.parse(r#"[foo.quality] "ƥèřïôδ" = 24.7 [owner] a_key = "a value" @@ -397,8 +407,12 @@ a_key = 'ANOTHER VALUE' [foo.quality] KEYONE = "VALUEONE" "#); - assert!(check_errors(&parser, &result).0, "There should have been a duplicate key error, but there wasn't."); - let errors = parser.get_errors(); + assert!(check_errors(&result).0, "There should have been a duplicate key error, but there wasn't."); + let errors = match result { + ParseResult::FullError(e) => e, + ParseResult::PartialError(_,_,_,e) => e, + _ => panic!("There should have been a duplicate key error, but there wasn't."), + }; let error = &errors.borrow()[0]; if let &ParseError::DuplicateKey(ref key, line, _col, ref val) = error { assert!(key == "owner.a_key" && line == 5, @@ -415,7 +429,7 @@ fn test_invalid_datetime_fail() { let _ = env_logger::init(); let parser = TOMLParser::new(); - let (parser, result) = parser.parse(r#"[foo.quality] + let (_, result) = parser.parse(r#"[foo.quality] "ƥèřïôδ" = 24.7 [owner] a_key = "a value" @@ -423,8 +437,12 @@ b_key = 2010-02-29T03:03:03.3333Z [foo.quality] KEYONE = "VALUEONE" "#); - assert!(check_errors(&parser, &result).0, "There should have been an invalid datetime error, but there wasn't."); - let errors = parser.get_errors(); + assert!(check_errors(&result).0, "There should have been an invalid datetime error, but there wasn't."); + let errors = match result { + ParseResult::FullError(e) => e, + ParseResult::PartialError(_,_,_,e) => e, + _ => panic!("There should have been an invalid datetime error, but there wasn't."), + }; let error = &errors.borrow()[0]; if let &ParseError::InvalidDateTime(ref key, line, _col, ref val) = error { assert!(key == "owner.b_key" && line == 5 && val == "2010-02-29T03:03:03.3333Z", diff --git a/todolist.md b/todolist.md index 2b6fed2..8988f52 100644 --- a/todolist.md +++ b/todolist.md @@ -4,7 +4,7 @@ - [x] Add line numbers to errors - [ ] **Add documentation to public enums, structs, functions, methods and macros** - [x] Switch names of TOMLValue and Value - - [x] Rename TOMLParser to TOMLTOMLParser + - [x] Rename Parser to TOMLParser * primitives.rs - [x] Implement get_keychain_key