Input trait

.travis.yml

@@ -5,8 +5,8 @@ rust:
   - stable
   - beta
   - nightly
-  # Minimum supported version (bitflags fails on 1.1):
-  - 1.2.0
+  # Minimum supported version (bitflags fails on 1.7 due to op_assign_traits not being stable):
+  - 1.8.0
 
 # necessary for `travis-cargo coveralls --no-sudo`
 addons:

CHANGELOG.md

@@ -7,6 +7,29 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 
+- `prelude` module containing basic types, parsers and combinators.
+
+  This is supposed to be the equivalent of Attoparsec's main package.
+
+- `run_parser` which executes a parser on any given `Input` type.
+
+- `buffer::InputBuf` which contains a slice and an incomplete flag, much as the old `Input` struct.
+
+- `Input<Token=T, Buffer=&[T]>` implementation for `&[T]` where `T: Copy + PartialEq`.
+
+- `Input<Token=char, Buffer=&str>` implementation for `&str`.
+
+- `types::Buffer` trait which is implemented for all buffers providing common logic to perform the
+  final parsing on a buffer without knowing the exact buffer implementation.
+
+- `types::U8Input` trait alias for `Input<Token=u8>`.
+
+- `primitives::Primitives` trait providing access to the primitive methods of the `Input` trait.
+
+  This is used for building fundamental parsers/combinators.
+
+- `ParseResult::inspect` allowing code to observe the success value.
+
 - `chomp::Error` now includes a backtrace in `test` and `debug` build profiles thanks to the
   [debugtrace crate](https://github.com/m4rw3r/debugtrace_rs). Backtraces can also be activated
   permanently using the `backtrace` feature but this will incur the significant cost of allocating
@@ -17,6 +40,27 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changes
 
+- **Backwards-incompatible:** `Input` is now a trait with associated types `Token` and `Buffer`.
+
+  This removes all incomplete logic from the parsers themselves and moves it into the `InputBuf`
+  type. This `InputBuf` is used if a partial buffer is in memory. It also allows the parsers to
+  operate directly on slices or use more effective means of storing buffers depending on the
+  `Input` implementation.
+
+  To upgrade you replace the previous concrete `Input` type with a generic, use its associated
+  type if required, and refer to the `Buffer` associated type to allow for zero-copy parsing::
+
+      -fn http_version(i: Input<u8>) -> U8Result<&[u8]>;
+      +fn http_version<I: Input<Token=u8>>(i: I) -> SimpleResult<I, I::Buffer>;
+
+  The associated types can be restricted if requried:
+
+      fn request<I: U8Input>(i: I) -> SimpleResult<I, (Request<I::Buffer>, Vec<Header<I::Buffer>>)>
+        where I::Buffer: ::std::ops::Deref<Target=[u8]>;
+
+- **Backwards-incompatible:** Moved types into a more logical module structure, prelude now
+  exists as a `prelude` module.
+
 - **Backwards-incompatible:** `chomp::Error` is no longer an enum, this is to facillitate the
   support of backtraces while keeping code compatible between the different build profiles.
 
@@ -26,10 +70,19 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Removed
 
+- `Input::incomplete`
 - `Input::new`
 - `ParseResult::expect`
-- `ParseResult::unwrap`
 - `ParseResult::unwrap_err`
+- `ParseResult::unwrap`
+- `buffer::IntoStream`
+- `primitives::InputClone`
+- `primitives::State`
+
+## Bugfixes
+
+- `combinators::bounded` now have a defined behavior when a `Range<usize>` has `start == end`: They will parse exactly `start` times. This also fixed a few overflows and unreachable code being reachable.
+- `combinators::bounded::many_till` got fixed for an overflow happening when `0: usize` was used to limit the number of iterations.
 
 ## [0.2.6] - 2016-07-07
 

Cargo.toml

@@ -22,13 +22,15 @@ include = [
 ]
 
 [dependencies]
-bitflags   = "0.5.0"
-conv       = { version = "0.3", default-features = false, features = ["std"] }
+bitflags   = "0.7.0"
+conv       = { version = "0.3.3", default-features = false, features = ["std"] }
 debugtrace = { version = "0.1.0" }
+tendril    = { version = "0.2.2", optional = true }
 
 # Technically a dev-dependency, but dev-dependencies are not allowed to be optional,
 # compiletest_rs fails to compile on stable and beta
 compiletest_rs = { version = "0.2.1", optional = true }
+clippy         = { version = ">0.0.1", optional = true }
 
 [features]
 # Feature for running extra (compiletime fail) tests on nightly

README.md

@@ -47,14 +47,14 @@ fn f() -> (u8, u8, u8) {
 A Chomp parser with a similar structure looks like this:
 
 ```rust
-fn f(i: Input<u8>) -> U8Result<(u8, u8, u8)> {
+fn f<I: U8Input>(i: I) -> SimpleResult<I, (u8, u8, u8)> {
     parse!{i;
-        let a = read_digit();
-        let b = read_digit();
-        string(b"missiles");
-        ret (a, b, a + b);
+        let a = digit();
+        let b = digit();
+                string(b"missiles");
+        ret (a, b, a + b)
     }
-} 
+}
 ```
 
 And to implement `read_digit` we can utilize the `map` function to manipulate any success value while preserving any error or incomplete state:
@@ -68,7 +68,7 @@ fn read_digit() -> u8 {
 }
 
 // Chomp, error handling built in, and we make sure we only get a number:
-fn read_digit(i: Input<u8>) -> U8Result<u8> {
+fn read_digit<I: U8Input>(i: I) -> SimpleResult<I, u8> {
     satisfy(i, |c| b'0' <= c && c <= b'9').map(|c| c - b'0')
 }
 ```

benches/combinators.rs

@@ -7,83 +7,122 @@ use test::Bencher;
 
 use std::iter;
 
-use chomp::*;
-use chomp::buffer::{Stream, IntoStream};
+use chomp::prelude::*;
+use chomp::buffer::InputBuf;
 
 #[bench]
 fn count_vec_1k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(1024).collect::<Vec<u8>>();
 
-    fn count_vec<I: Copy>(i: Input<I>) -> ParseResult<I, Vec<I>, Error<I>> {
+    fn count_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
         count(i, 1024, any)
     }
 
     b.iter(|| {
-        data.into_stream().parse(count_vec)
+        parse_only(count_vec, &data)
     })
 }
 
 #[bench]
 fn count_vec_10k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
 
-    fn count_vec<I: Copy>(i: Input<I>) -> ParseResult<I, Vec<I>, Error<I>> {
+    fn count_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
         count(i, 10024, any)
     }
 
     b.iter(|| {
-        data.into_stream().parse(count_vec)
+        parse_only(count_vec, &data)
     })
 }
 
 #[bench]
 fn many_vec_1k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(1024).collect::<Vec<u8>>();
 
-    fn many_vec<I: Copy>(i: Input<I>) -> ParseResult<I, Vec<I>, Error<I>> {
+    fn many_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
         many(i, any)
     }
 
     b.iter(|| {
-        data.into_stream().parse(many_vec)
+        parse_only(many_vec, &data)
     })
 }
 
 #[bench]
 fn many_vec_10k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
 
-    fn many_vec<I: Copy>(i: Input<I>) -> ParseResult<I, Vec<I>, Error<I>> {
+    fn many_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
         many(i, any)
     }
 
     b.iter(|| {
-        data.into_stream().parse(many_vec)
+        parse_only(many_vec, &data)
     })
 }
 
 #[bench]
 fn many1_vec_1k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(1024).collect::<Vec<u8>>();
 
-    fn many1_vec<I: Copy>(i: Input<I>) -> ParseResult<I, Vec<I>, Error<I>> {
+    fn many1_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
         many1(i, any)
     }
 
     b.iter(|| {
-        data.into_stream().parse(many1_vec)
+        parse_only(many1_vec, &data)
     })
 }
 
 #[bench]
 fn many1_vec_10k(b: &mut Bencher) {
     let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
 
-    fn many1_vec<I: Copy>(i: Input<I>) -> ParseResult<I, Vec<I>, Error<I>> {
+    fn many1_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
         many1(i, any)
     }
 
     b.iter(|| {
-        data.into_stream().parse(many1_vec)
+        parse_only(many1_vec, &data)
+    })
+}
+
+#[bench]
+fn count_vec_10k_maybe_incomplete(b: &mut Bencher) {
+    let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
+
+    fn count_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
+        count(i, 10024, any)
+    }
+
+    b.iter(|| {
+        count_vec(InputBuf::new(&data))
+    })
+}
+
+#[bench]
+fn many_vec_10k_maybe_incomplete(b: &mut Bencher) {
+    let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
+
+    fn many_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
+        many(i, any)
+    }
+
+    b.iter(|| {
+        many_vec(InputBuf::new(&data))
+    })
+}
+
+#[bench]
+fn many1_vec_10k_maybe_incomplete(b: &mut Bencher) {
+    let data = iter::repeat(b'a').take(10024).collect::<Vec<u8>>();
+
+    fn many1_vec<I: Input>(i: I) -> ParseResult<I, Vec<I::Token>, Error<I::Token>> {
+        many1(i, any)
+    }
+
+    b.iter(|| {
+        many1_vec(InputBuf::new(&data))
     })
 }

benches/http_bench.rs

@@ -4,20 +4,19 @@ extern crate test;
 extern crate chomp;
 
 use test::Bencher;
-use chomp::*;
-use chomp::buffer::{Stream, IntoStream};
+use chomp::prelude::*;
 
 #[derive(Debug)]
-struct Request<'a> {
-    method:  &'a [u8],
-    uri:     &'a [u8],
-    version: &'a [u8],
+struct Request<B> {
+    method:  B,
+    uri:     B,
+    version: B,
 }
 
 #[derive(Debug)]
-struct Header<'a> {
-    name:  &'a [u8],
-    value: Vec<&'a [u8]>,
+struct Header<B> {
+    name:  B,
+    value: Vec<B>,
 }
 
 fn is_token(c: u8) -> bool {
@@ -52,22 +51,18 @@ fn is_not_space(c: u8)        -> bool { c != b' ' }
 fn is_end_of_line(c: u8)      -> bool { c == b'\r' || c == b'\n' }
 fn is_http_version(c: u8)     -> bool { c >= b'0' && c <= b'9' || c == b'.' }
 
-fn end_of_line(i: Input<u8>) -> U8Result<u8> {
-    or(i, |i| parse!{i;
-               token(b'\r');
-               token(b'\n');
-               ret b'\r'},
-          |i| token(i, b'\n'))
+fn end_of_line<I: U8Input>(i: I) -> SimpleResult<I, u8> {
+    parse!{i; (token(b'\r') <|> ret b'\0') >> token(b'\n')}
 }
 
-fn http_version(i: Input<u8>) -> U8Result<&[u8]> {
+fn http_version<I: U8Input>(i: I) -> SimpleResult<I, I::Buffer> {
     parse!{i;
         string(b"HTTP/");
         take_while1(is_http_version)
     }
 }
 
-fn request_line(i: Input<u8>) -> U8Result<Request> {
+fn request_line<I: U8Input>(i: I) -> SimpleResult<I, Request<I::Buffer>> {
     parse!{i;
         let method  = take_while1(is_token);
                       take_while1(is_space);
@@ -83,7 +78,7 @@ fn request_line(i: Input<u8>) -> U8Result<Request> {
     }
 }
 
-fn message_header_line(i: Input<u8>) -> U8Result<&[u8]> {
+fn message_header_line<I: U8Input>(i: I) -> SimpleResult<I, I::Buffer> {
     parse!{i;
                    take_while1(is_horizontal_space);
         let line = take_till(is_end_of_line);
@@ -93,7 +88,7 @@ fn message_header_line(i: Input<u8>) -> U8Result<&[u8]> {
     }
 }
 
-fn message_header(i: Input<u8>) -> U8Result<Header> {
+fn message_header<I: U8Input>(i: I) -> SimpleResult<I, Header<I::Buffer>> {
     parse!{i;
         let name  = take_while1(is_token);
                     token(b':');
@@ -106,7 +101,8 @@ fn message_header(i: Input<u8>) -> U8Result<Header> {
     }
 }
 
-fn request(i: Input<u8>) -> U8Result<(Request, Vec<Header>)> {
+#[inline(never)]
+fn request<I: U8Input>(i: I) -> SimpleResult<I, (Request<I::Buffer>, Vec<Header<I::Buffer>>)> {
     parse!{i;
         let r = request_line();
                 end_of_line();
@@ -130,7 +126,7 @@ Connection: keep-alive\r
 \r";
 
     b.iter(|| {
-        data.into_stream().parse(request)
+        parse_only(request, data)
     })
 }
 
@@ -142,7 +138,7 @@ Host: localhost\r
 \r";
 
     b.iter(|| {
-        data.into_stream().parse(request)
+        parse_only(request, data)
     })
 }
 
@@ -161,7 +157,7 @@ Cookie: azk=ue1-5eb08aeed9a7401c9195cb933eb7c966\r
 \r";
 
     b.iter(|| {
-        data.into_stream().parse(request)
+        parse_only(request, data)
     })
 }
 
@@ -170,6 +166,8 @@ fn multiple_requests(b: &mut Bencher) {
     let data = include_bytes!("./data/http-requests.txt");
 
     b.iter(|| {
-        data.into_stream().parse::<_, Vec<_>, _>(parser!{many(request)})
+        let r: Result<Vec<_>, _> = parse_only(parser!{many(request)}, data);
+
+        r
     })
 }