feat: refactoring + helpers + improved CI (#1)

* feat: refactoring + helpers + improved CI
* chore: adds codecov badge to README

.github/workflows/rust.yml

@@ -14,8 +14,43 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
-      - name: Build
-        run: cargo build --verbose
-      - name: Run tests
-        run: cargo test --verbose
+      - uses: actions/checkout@v4
+
+      - name: Install rust
+        uses: dtolnay/rust-toolchain@master
+        with:
+            toolchain: stable
+            components: clippy, rustfmt
+
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
+
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-rust-test-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Run cargo fmt
+        run: cargo fmt -- --check
+
+      - name: Run clippy
+        run: cargo clippy -- -D warnings
+
+      - name: Run cargo check
+        run: cargo check --all-features --locked --release
+
+      - name: Run cargo build
+        run: cargo build --locked --release
+
+      - name: Generate code coverage
+        run: cargo llvm-cov --all-features --lcov --output-path lcov.info
+
+      - name: Upload coverage to codecov
+        uses: codecov/codecov-action@v3
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: lcov.info
+          fail_ci_if_error: true

.gitignore

@@ -1 +1,2 @@
 /target
+*.profraw

Cargo.toml

@@ -13,3 +13,4 @@ readme = "README.md"
 
 [dependencies]
 nom = "7.1.3"
+thiserror = "1.0.57"

README.md

@@ -1,21 +1,38 @@
 # tinyresp
 
 [![Build Status](https://github.com/lmammino/tinyresp/actions/workflows/rust.yml/badge.svg)](https://github.com/lmammino/tinyresp/actions/workflows/rust.yml)
+[![codecov](https://codecov.io/gh/lmammino/tinyresp/graph/badge.svg?token=2a5OOr6Um4)](https://codecov.io/gh/lmammino/tinyresp)
 [![Crates.io](https://img.shields.io/crates/v/tinyresp.svg)](https://crates.io/crates/tinyresp)
 [![docs.rs](https://docs.rs/tinyresp/badge.svg)](https://docs.rs/tinyresp)
 
 A tiny Rust library implementing the Redis Serialization Protocol (RESP)
 
-> ⚠️ **WARNING**: This library is still under heavy development and it is not ready for production use yet
-
 <!-- cargo-sync-readme start -->
 
-A simple parser for the RESP protocol
-Still under heavy  development
+A simple parser for the RESP protocol (REdis Serialization Protocol).
 
 For an overview of the procol check out the official
 [Redis SErialization Protocol (RESP) documentation](https://redis.io/topics/protocol)
 
+This library is written using [`nom`](https://crates.io/crates/nom) and therefore uses an incremental parsing approach.
+This means that using the [`parse`] method will return a `Result` containing a tuple with 2 elements:
+- The remaining input (which can be an empty string if the message was fully parsed)
+- The parsed value (if the message was fully parsed)
+
+# Example
+
+```rust
+use tinyresp::{parse_message, Value};
+
+let message = "*2\r\n$5\r\nhello\r\n$5\r\nworld\r\n";
+let (remaining_input, value) = parse_message(message).unwrap();
+assert_eq!(remaining_input, "");
+assert_eq!(value, Value::Array(vec![
+    Value::BulkString("hello"),
+    Value::BulkString("world")
+]));
+```
+
 <!-- cargo-sync-readme end -->
 
 ## Contributing

src/lib.rs

@@ -1,8 +1,26 @@
-//! A simple parser for the RESP protocol
-//! Still under heavy  development
+//! A simple parser for the RESP protocol (REdis Serialization Protocol).
 //!
 //! For an overview of the procol check out the official
 //! [Redis SErialization Protocol (RESP) documentation](https://redis.io/topics/protocol)
+//!
+//! This library is written using [`nom`](https://crates.io/crates/nom) and therefore uses an incremental parsing approach.
+//! This means that using the [`parse`] method will return a `Result` containing a tuple with 2 elements:
+//! - The remaining input (which can be an empty string if the message was fully parsed)
+//! - The parsed value (if the message was fully parsed)
+//!
+//! # Example
+//!
+//! ```
+//! use tinyresp::{parse_message, Value};
+//!
+//! let message = "*2\r\n$5\r\nhello\r\n$5\r\nworld\r\n";
+//! let (remaining_input, value) = parse_message(message).unwrap();
+//! assert_eq!(remaining_input, "");
+//! assert_eq!(value, Value::Array(vec![
+//!     Value::BulkString("hello"),
+//!     Value::BulkString("world")
+//! ]));
+//! ```
 
 use nom::{
     branch::alt,
@@ -14,32 +32,42 @@ use nom::{
     sequence::terminated,
     IResult,
 };
-use std::collections::BTreeSet;
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
-pub enum Value<'a> {
-    SimpleString(&'a str),
-    SimpleError(&'a str),
-    Integer(i64),
-    BulkString(&'a str),
-    Array(Vec<Value<'a>>),
-    Null,
-    Boolean(bool),
-    Double(String),
-    BigNumber(&'a str),
-    BulkError(&'a str),
-    VerbatimString((&'a str, &'a str)),
-    Map((Vec<Value<'a>>, Vec<Value<'a>>)),
-    Set(BTreeSet<Value<'a>>),
-    Pushes(Vec<Value<'a>>),
-}
 
+mod value;
+pub use value::*;
+
+/// Parses a RESP message using an incremental parsing approach.
+/// This means that the parser will return a `Result` containing a tuple with 2 elements:
+/// - The remaining input (which can be an empty string if the message was fully parsed)
+/// - The parsed value (if the message was fully parsed)
+///
+/// # Example
+///
+/// ```
+/// use tinyresp::{parse_message, Value};
+///
+/// let message = "*2\r\n$5\r\nhello\r\n$5\r\nworld\r\n";
+/// let (remaining_input, value) = parse_message(message).unwrap();
+/// assert_eq!(remaining_input, "");
+/// assert_eq!(value, Value::Array(vec![
+///     Value::BulkString("hello"),
+///     Value::BulkString("world")
+/// ]));
+/// ```
 pub fn parse_message(input: &str) -> IResult<&str, Value> {
     let (input, value) = terminated(parse_value, eof)(input)?;
     Ok((input, value))
 }
 
-pub fn parse_value(input: &str) -> IResult<&str, Value> {
+/// Parses a RESP message and returns the parsed value.
+/// This is a convenience function that uses `parse_message` internally and returns the parsed value.
+/// To get better error reporting and be able to check if there's unparsed data, use [`parse_message`] instead.
+pub fn parse(input: &str) -> Result<Value, String> {
+    let (_, value) = parse_message(input).map_err(|e| format!("{}", e))?;
+    Ok(value)
+}
+
+fn parse_value(input: &str) -> IResult<&str, Value> {
     alt((
         parse_simple_string,
         parse_simple_error,
@@ -165,7 +193,7 @@ fn parse_verbatim_string(input: &str) -> IResult<&str, Value> {
     let (input, length) = terminated(u32, crlf)(input)?;
     let (input, encoding) = terminated(take(3usize), tag(":"))(input)?;
     let (input, value) = terminated(take(length as usize - 4usize), crlf)(input)?;
-    Ok((input, Value::VerbatimString((encoding, value))))
+    Ok((input, Value::VerbatimString(encoding, value)))
 }
 
 fn parse_map(input: &str) -> IResult<&str, Value> {
@@ -185,7 +213,7 @@ fn parse_map(input: &str) -> IResult<&str, Value> {
         },
     );
 
-    Ok((input, Value::Map((keys, values))))
+    Ok((input, Value::Map(keys, values)))
 }
 
 fn parse_set(input: &str) -> IResult<&str, Value> {
@@ -421,15 +449,15 @@ mod tests {
     fn test_verbatim_string() {
         assert_eq!(
             parse_message("=15\r\ntxt:Some string\r\n"),
-            Ok(("", Value::VerbatimString(("txt", "Some string"))))
+            Ok(("", Value::VerbatimString("txt", "Some string")))
         );
         assert_eq!(
             parse_message("=5\r\ntxt:1\r\n"),
-            Ok(("", Value::VerbatimString(("txt", "1"))))
+            Ok(("", Value::VerbatimString("txt", "1")))
         );
         assert_eq!(
             parse_message("=5\r\nraw:1\r\n"),
-            Ok(("", Value::VerbatimString(("raw", "1"))))
+            Ok(("", Value::VerbatimString("raw", "1")))
         );
         assert!(parse_message("=5\r\nraw:1\r\nTHIS_SHOULD_NOT_BE_HERE").is_err());
     }
@@ -440,10 +468,10 @@ mod tests {
             parse_message("%2\r\n+first\r\n:1\r\n+second\r\n:2\r\n"),
             Ok((
                 "",
-                Value::Map((
+                Value::Map(
                     vec![Value::SimpleString("first"), Value::SimpleString("second")],
                     vec![Value::Integer(1), Value::Integer(2)]
-                ))
+                )
             ))
         );
     }
@@ -477,4 +505,17 @@ mod tests {
             ))
         );
     }
+
+    #[test]
+    fn test_parse() {
+        let message = "*2\r\n$5\r\nhello\r\n$5\r\nworld\r\n";
+        let value = parse(message).unwrap();
+        assert_eq!(
+            value,
+            Value::Array(vec![Value::BulkString("hello"), Value::BulkString("world")])
+        );
+
+        let message = "BOGUS";
+        assert!(parse(message).is_err());
+    }
 }