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