serialzero 0.1.0

# SerialZero

A minimalist JSON parsing and serialization library for Rust.

## Features

* **Zero dependencies**: No external libraries, keeping your project lean.
* **Optimized for speed**: Written with performance in mind, for both parsing and serializing JSON.
* **Minimal API**: Simple, clean API that's easy to use without boilerplate.
* **Customizable**: Allows customization for use cases like date formatting or naming conventions (camelCase, snake_case).
* **Portable**: Ideal for projects with strict size limitations (embedded systems, webassembly, etc.).

## Installation

Add SerialZero to your `Cargo.toml`:

```toml
[dependencies]
serialzero = "0.1.0"
```

## Quick Start

```rust
use serialzero::{json, parse, to_string_pretty, JsonValueExt};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Parse JSON
    let input = r#"{"name":"SerialZero","version":"0.1.0"}"#;
    let parsed = parse(input)?;
    
    // Access values
    let name = parsed.get("name").and_then(|v| v.as_string()).unwrap_or_default();
    println!("Name: {}", name);
    
    // Create JSON with macro
    let data = json!({
        "id" => 1234,
        "username" => "rustacean",
        "tags" => ["json", "rust", "serialization"]
    });
    
    // Serialize to pretty-printed JSON
    let output = to_string_pretty(&data);
    println!("JSON: \n{}", output);
    
    Ok(())
}
```

## Working with JSON Values

SerialZero makes it easy to create, access, and modify JSON data:

```rust
use serialzero::{JsonValue, json};
use std::collections::HashMap;

// Create JSON values
let null = JsonValue::Null;
let bool_value = JsonValue::Boolean(true);
let number = JsonValue::Number(42.5);
let string = JsonValue::String("hello".to_string());
let array = JsonValue::Array(vec![JsonValue::Number(1.0), JsonValue::Number(2.0)]);

// Build an object
let mut obj = HashMap::new();
obj.insert("name".to_string(), JsonValue::String("SerialZero".to_string()));
obj.insert("version".to_string(), JsonValue::String("0.1.0".to_string()));
let object = JsonValue::Object(obj);

// Or use the convenient macro
let user = json!({
    "id" => 1234,
    "name" => "Alice",
    "emails" => ["alice@example.com", "alice.work@example.com"]
});

// Access data with the extension trait
if let Some(id) = user.get("id").and_then(|v| v.as_number()) {
    println!("User ID: {}", id);
}

// Navigate nested structures
if let Some(emails) = user.get("emails").and_then(|v| v.as_array()) {
    for email in emails {
        if let Some(email_str) = email.as_string() {
            println!("Email: {}", email_str);
        }
    }
}
```

## Customization Options

SerialZero provides customization options for serialization:

```rust
use serialzero::{JsonValue, SerializeOptions, to_string_with_options};

let options = SerializeOptions {
    pretty: true,
    indent: "    ".to_string(), // 4 spaces
    use_snake_case: true,       // Convert camelCase to snake_case
    date_format: Some("%Y-%m-%d".to_string()),
};

let json = to_string_with_options(&value, &options);
```

## Error Handling

SerialZero provides detailed error information:

```rust
use serialzero::{parse, JsonError};

match parse("{invalid json}") {
    Ok(value) => println!("Parsed: {:?}", value),
    Err(JsonError::UnexpectedToken(c)) => println!("Unexpected token: {}", c),
    Err(e) => println!("Error: {}", e),
}
```

## Why SerialZero?

SerialZero aims to fill the niche between full-featured libraries like serde_json and minimalist parsers. It offers:

1. Zero dependencies for leaner projects
2. Simplified API for common JSON operations
3. Fast parsing and serialization with minimal overhead
4. Format customization (camelCase/snake_case, pretty-printing)
5. Helper functions and traits for ergonomic JSON manipulation

## Performance Considerations

SerialZero is designed with performance in mind, but it prioritizes a clean API and zero dependencies over absolute maximum performance. For extremely performance-critical applications where you need the fastest possible JSON handling, consider benchmarking against alternatives.

## License

[MIT](LICENSE)