Refactor (#12)

* keep lib.rs simple

* refactor project structure

* use stable and check all

* fix wasm

Author: xlc

.github/workflows/test.yml

@@ -19,14 +19,14 @@ jobs:
       uses: actions-rs/toolchain@v1
       with:
         profile: minimal
-        toolchain: nightly-2019-12-04
+        toolchain: stable
         components: rustfmt
         target: wasm32-unknown-unknown
         default: true
     - name: Check format
       run: cargo fmt --all -- --check
     - name: Check Wasm
-      run: cargo check --no-default-features --target=wasm32-unknown-unknown
+      run: cargo check --no-default-features --target=wasm32-unknown-unknown --all
     - name: Build
       run: cargo build --locked
     - name: Run tests

Cargo.toml

@@ -12,11 +12,18 @@ categories = [
 ]
 
 [dependencies]
-paste = "0.1"
+lite-parser = { path = "parser", default-features = false }
 num-traits = { version = "0.2", optional = true, default-features = false }
 
 [features]
 default = ["std"]
-std = []
+std = [
+    "lite-parser/std"
+]
 # Enables converting values to floats in no-`std` environment
 float = ["num-traits"]
+
+[workspace]
+members = [
+    "parser"
+]

parser/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "lite-parser"
+version = "0.1.0"
+authors = ["Bryan Chen <[email protected]>"]
+description = "Simple parser library. Wasm / no_std ready."
+license = "Apache-2.0"
+edition = "2018"
+keywords = [ "parser", "wasm", "no_std" ]
+repository = "https://github.com/xlc/lite-json"
+categories = [
+    "no-std",
+]
+
+[dependencies]
+paste = "0.1"
+
+[features]
+default = ["std"]
+std = []

src/impls.rs renamed to parser/src/impls.rs

@@ -1,10 +1,10 @@
-use crate::parser::{Error, Position};
+use crate::traits::{Error, Position};
 
 #[cfg(not(feature = "std"))]
 extern crate alloc;
 
 #[cfg(not(feature = "std"))]
-use crate::parser::alloc::fmt::Formatter;
+use alloc::fmt::Formatter;
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 

parser/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod impls;
+pub mod parser;
+pub mod traits;
+pub use paste;

src/parser.rs renamed to parser/src/parser.rs

@@ -1,37 +1,12 @@
+#[cfg(not(feature = "std"))]
 pub extern crate alloc;
 
 use crate::impls::{SimpleError, SimplePosition};
+use crate::traits::{Error, Input, Position, ResultOf};
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 use core::marker::PhantomData;
 
-pub trait Position: core::ops::Sub<Self, Output = i32> + Copy {
-    fn index(&self) -> u32;
-    fn line(&self) -> u32;
-    fn column(&self) -> u32;
-}
-
-pub trait Error {
-    type Position;
-    fn reasons(&self) -> &[(Self::Position, &'static str)];
-    fn add_reason(self, position: Self::Position, reason: &'static str) -> Self;
-}
-
-pub trait Input: Default {
-    type Position: Position;
-    type Error: Error<Position = Self::Position>;
-    fn next(&self, pos: Self::Position) -> Result<(char, Self::Position), Self::Error>;
-    fn next_range(
-        &self,
-        start: Self::Position,
-        counts: u32,
-    ) -> Result<(&str, Self::Position), Self::Error>;
-    fn error_at(&self, pos: Self::Position, reason: &'static str) -> Self::Error;
-    fn is_end(&self, pos: Self::Position) -> bool;
-}
-
-pub type ResultOf<I, O> = Result<(O, <I as Input>::Position), <I as Input>::Error>;
-
 #[cfg_attr(feature = "std", derive(Debug, PartialEq, Eq))]
 #[derive(Clone)]
 pub struct ParserOptions {
@@ -264,7 +239,7 @@ macro_rules! literals {
         $( #[ $attr:meta ] )*
         $vis:vis $name:ident => $($value:tt)+
 	) => (
-	    paste::item! {
+	    $crate::paste::item! {
 	        $vis struct [< $name Predicate >];
             impl $crate::parser::Predicate<char> for [< $name Predicate >] {
                 fn eval(c: &char) -> bool {
@@ -291,11 +266,11 @@ macro_rules! parsers {
     ) => {
         $(
             $vis struct $name;
-            impl<I: $crate::parser::Input> $crate::parser::Parser<I> for $name {
+            impl<I: $crate::traits::Input> $crate::parser::Parser<I> for $name {
                 type Output = $output_type;
-                fn parse(input: &I, current: I::Position, context: &ParserContext) -> $crate::parser::ResultOf<I, Self::Output> {
+                fn parse(input: &I, current: I::Position, context: &ParserContext) -> $crate::traits::ResultOf<I, Self::Output> {
                     let ($output, pos) = <$type as $crate::parser::Parser<I>>::parse(input, current, context)
-                        .map_err(|e| <I::Error as $crate::parser::Error>::add_reason(e, current, stringify!($name)))?;
+                        .map_err(|e| <I::Error as $crate::traits::Error>::add_reason(e, current, stringify!($name)))?;
                     let res = $body;
                     Ok((res, pos))
                 }

parser/src/traits.rs

@@ -0,0 +1,26 @@
+pub trait Position: core::ops::Sub<Self, Output = i32> + Copy {
+    fn index(&self) -> u32;
+    fn line(&self) -> u32;
+    fn column(&self) -> u32;
+}
+
+pub trait Error {
+    type Position;
+    fn reasons(&self) -> &[(Self::Position, &'static str)];
+    fn add_reason(self, position: Self::Position, reason: &'static str) -> Self;
+}
+
+pub trait Input: Default {
+    type Position: Position;
+    type Error: Error<Position = Self::Position>;
+    fn next(&self, pos: Self::Position) -> Result<(char, Self::Position), Self::Error>;
+    fn next_range(
+        &self,
+        start: Self::Position,
+        counts: u32,
+    ) -> Result<(&str, Self::Position), Self::Error>;
+    fn error_at(&self, pos: Self::Position, reason: &'static str) -> Self::Error;
+    fn is_end(&self, pos: Self::Position) -> bool;
+}
+
+pub type ResultOf<I, O> = Result<(O, <I as Input>::Position), <I as Input>::Error>;

src/json.rs

@@ -7,6 +7,8 @@ use alloc::vec::Vec;
 #[cfg(not(feature = "std"))]
 use alloc::string::ToString;
 
+use crate::traits::Serialize;
+
 #[cfg_attr(feature = "std", derive(Debug))]
 #[derive(Clone, PartialEq)]
 pub struct NumberValue {
@@ -48,20 +50,6 @@ pub enum JsonValue {
     Null,
 }
 
-pub trait Serialize {
-    fn serialize(&self) -> Vec<u8> {
-        let mut res = Vec::new();
-        self.serialize_to(&mut res, 0, 0);
-        res
-    }
-    fn format(&self, indent: u32) -> Vec<u8> {
-        let mut res = Vec::new();
-        self.serialize_to(&mut res, indent, 0);
-        res
-    }
-    fn serialize_to(&self, buffer: &mut Vec<u8>, indent: u32, level: u32);
-}
-
 impl Serialize for NumberValue {
     fn serialize_to(&self, buffer: &mut Vec<u8>, _indent: u32, _level: u32) {
         buffer.extend_from_slice(self.integer.to_string().as_bytes());

src/json_parser.rs

@@ -5,11 +5,16 @@ extern crate alloc;
 use alloc::vec::Vec;
 
 use crate::json::{JsonObject, JsonValue, NumberValue};
-use crate::parser::{
-    Concat, Concat3, Either, Error, Input, OneOf, OneOrMore, Parser, ParserContext, ResultOf,
-    ZeroOrMore, ZeroOrOne,
+use lite_parser::{
+    impls::SimpleError,
+    literals,
+    parser::{
+        Concat, Concat3, Either, OneOf, OneOrMore, Parser, ParserContext, ParserOptions,
+        ZeroOrMore, ZeroOrOne,
+    },
+    parsers,
+    traits::{Error, Input, ResultOf},
 };
-use crate::{literals, parsers};
 
 use core::convert::TryInto;
 
@@ -349,3 +354,139 @@ impl<I: Input> Parser<I> for Json {
         }
     }
 }
+
+pub fn parse_json(input: &str) -> Result<JsonValue, SimpleError> {
+    parse_json_with_options(input, Default::default())
+}
+
+pub fn parse_json_with_options(
+    input: &str,
+    options: ParserOptions,
+) -> Result<JsonValue, SimpleError> {
+    Json::parse(&input, Default::default(), &ParserContext::new(options)).map(|(ret, _)| ret)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::NumberValue;
+    use lite_parser::impls::SimplePosition;
+
+    #[test]
+    fn it_works() {
+        assert_eq!(
+            parse_json(&r#"{ "test": 1, "test2": [1e-4, 2.041e2, true, false, null, "\"1\n\""] }"#),
+            Ok(JsonValue::Object(vec![
+                (
+                    vec!['t', 'e', 's', 't'],
+                    JsonValue::Number(NumberValue {
+                        integer: 1,
+                        fraction: 0,
+                        fraction_length: 0,
+                        exponent: 0
+                    })
+                ),
+                (
+                    vec!['t', 'e', 's', 't', '2'],
+                    JsonValue::Array(vec![
+                        JsonValue::Number(NumberValue {
+                            integer: 1,
+                            fraction: 0,
+                            fraction_length: 0,
+                            exponent: -4,
+                        }),
+                        JsonValue::Number(NumberValue {
+                            integer: 2,
+                            fraction: 41,
+                            fraction_length: 3,
+                            exponent: 2,
+                        }),
+                        JsonValue::Boolean(true),
+                        JsonValue::Boolean(false),
+                        JsonValue::Null,
+                        JsonValue::String(vec!['\"', '1', 'n', '\"'])
+                    ])
+                )
+            ]))
+        )
+    }
+
+    #[test]
+    fn it_should_consume_all() {
+        assert_eq!(
+            parse_json(&r#""1"a"#),
+            Err(SimpleError {
+                reasons: vec![(
+                    SimplePosition {
+                        index: 3,
+                        line: 0,
+                        column: 3
+                    },
+                    "Expect end of input"
+                )]
+            })
+        )
+    }
+
+    #[test]
+    fn it_accepts_nest_level() {
+        assert_eq!(
+            parse_json_with_options(
+                &r#"{ "test": 1 }"#,
+                ParserOptions {
+                    max_nest_level: Some(1)
+                }
+            ),
+            Ok(JsonValue::Object(vec![(
+                vec!['t', 'e', 's', 't'],
+                JsonValue::Number(NumberValue {
+                    integer: 1,
+                    fraction: 0,
+                    fraction_length: 0,
+                    exponent: 0
+                })
+            ),]))
+        );
+    }
+
+    #[test]
+    fn it_accepts_more_nest_level() {
+        assert_eq!(
+            parse_json_with_options(
+                &r#"{ "test": { "a": [ {} ] } }"#,
+                ParserOptions {
+                    max_nest_level: Some(5)
+                }
+            ),
+            Ok(JsonValue::Object(vec![(
+                vec!['t', 'e', 's', 't'],
+                JsonValue::Object(vec![(
+                    vec!['a'],
+                    JsonValue::Array(vec![JsonValue::Object(vec![])])
+                )])
+            )]))
+        );
+    }
+
+    #[test]
+    fn it_error_on_too_deep_nest() {
+        assert_eq!(
+            parse_json_with_options(
+                &r#"{ "test": { "a": [ {} ] } }"#,
+                ParserOptions {
+                    max_nest_level: Some(3)
+                }
+            ),
+            Err(SimpleError {
+                reasons: vec![(
+                    SimplePosition {
+                        index: 0,
+                        line: 0,
+                        column: 0
+                    },
+                    "Value"
+                )]
+            })
+        );
+    }
+}