bencode_lib 0.1.2

# bencode_lib


A Rust library for parsing, constructing, and converting Bencode data. In addition to round‑tripping Bencode, it can render parsed data to JSON, YAML, and XML.

Bencode is a compact serialization format commonly used by BitTorrent. It supports four types: integers, byte strings, lists, and dictionaries.

## Features


- Parse Bencode into a typed tree (`Node`)
- Serialize `Node` back to canonical Bencode
- Convert `Node` to JSON, YAML, or XML
- Read/write from files or in‑memory buffers
- Small, focused API

## Installation


Add to your Cargo.toml:

- If published on crates.io:
```
toml
[dependencies]
bencode_lib = "0.1.0"
```
- Or as a workspace/path dependency:
```
toml
[dependencies]
bencode_lib = { path = "library" }
```
## Quick examples

Parse a `.torrent` (or any bencode) file and write it as YAML:
```
rust
use bencode_lib::{FileSource, FileDestination, parse, to_yaml};
use std::path::Path;

fn main() -> Result<(), String> {
let input_path = "example.torrent";
let output_path = Path::new(input_path).with_extension("yaml");

    // Read and parse bencode
    let mut src = FileSource::new(input_path)?;
    let node = parse(&mut src)?;

    // Convert to YAML and write out
    let mut dst = FileDestination::new(output_path.to_string_lossy().as_ref())?;
    to_yaml(&node, &mut dst);
    Ok(())
}
```
Round‑trip a Bencode buffer:
```
rust
use bencode_lib::{BufferSource, BufferDestination, parse, stringify};

fn main() -> Result<(), String> {
let raw = b"d3:foo3:bar4:spamli1ei2ei3eee".to_vec();
let mut src = BufferSource::new(raw);

    // Parse from memory
    let node = parse(&mut src)?;

    // Serialize back to bencode into memory
    let mut dst = BufferDestination::new();
    stringify(&node, &mut dst);

    // If your BufferDestination exposes the bytes, you can inspect them:
    // let bytes = dst.into_bytes();
    Ok(())
}
```
Construct a `Node` and render as JSON:
```
rust
use bencode_lib::{Node, to_json, BufferDestination};

fn main() {
let node = Node::Dict(vec![
(b"info".to_vec(), Node::List(vec![
Node::Integer(42),
Node::String(b"hello".to_vec()),
])),
]);

    let mut dst = BufferDestination::new();
    to_json(&node, &mut dst);
    let json = String::from_utf8(dst.into_bytes()).unwrap();
    println!("{}", json);
}
```
Read and write whole files with helpers:
```
rust
use bencode_lib::{read_file, write_file, Node};

fn main() -> Result<(), String> {
let node = read_file("input.bencode")?;
// ... mutate or inspect `node` ...
write_file("output.bencode", &node)?;
Ok(())
}
```
## Data model


- Integer: `Node::Integer(i64)`
- String (byte string): `Node::String(Vec<u8>)`
- List: `Node::List(Vec<Node>)`
- Dictionary: `Node::Dict(Vec<(Vec<u8>, Node)>)`
    - Keys are byte strings (raw bytes) to preserve exact data.

## API overview


- Sources/Destinations
    - `FileSource`, `FileDestination`
    - `BufferSource`, `BufferDestination`
- Core
    - `Node` — in‑memory representation of Bencode
    - `parse(&mut Source) -> Result<Node, String>`
    - `stringify(&Node, &mut Destination)`
- Converters
    - `to_json(&Node, &mut Destination)`
    - `to_yaml(&Node, &mut Destination)`
    - `to_xml(&Node, &mut Destination)`
- Utilities
    - `version() -> String` — library version
    - `read_file(path) -> Result<Node, String>`
    - `write_file(path, &Node) -> Result<(), String>`

## Error handling


- Parsing typically returns `Result<Node, String>`.
- File source/destination constructors return `Result<…, String>`.
- Serialization/conversion functions write into provided destinations.

## Minimum Supported Rust Version


- Rust 1.88.0

## License


This project is licensed under the MIT License. See the LICENSE file for details.