Camo

Documentation | Repository | Releases

Camo is a library for converting Rust type definitions into corresponding definitions in other languages.

• Abstract syntax tree - Camo provides a collection of data structures that describe a subset of the Rust syntax. The syntax tree is rooted in core::Container, which types provide via the core::Camo trait.

• Derive macro - The derive::Camo derive macro automates the work of creating the syntax tree for your type. The macro takes serde attributes into account, ensuring that generated types accurately describe the values that serde would produce.

• TypeScript backend - The typescript module provides a ready-to-use TypeScript backend. Convert a core::Container into a typescript::Definition, and write it to a file.

Getting started

Add Camo as a dependency:

# `derive` is included by default
cargo add camo
# optionally add the typescript backend
cargo add camo --features typescript

Add the Camo derive macro to your type:

use camo::{
    // The trait (so we can use `Book::camo()`)
    core::Camo as _,
    // The macro (so we can use `#[derive(Camo)]`)
    derive::Camo
};

#[derive(Camo)]
struct Book {
    title: String,
    author: String,
    page_count: usize,
    chapters: Vec<String>,
}

Use the generated Camo::camo() implementation:

fn main() {
    let book = Book::camo();
    println!("{:?}", book);
}

With the typescript feature enabled, create a TypeScript definition:

use camo::{
    /* ... */
    typescript::Definition,
};

/* ... */

fn main() {

    /* ... */

    let ty: Definition = book.into();

    println!("{}", ty);
    // interface Book {
    //     title: string;
    //     author: string;
    //     page_count: number;
    //     chapters: string[];
    // }
}

See more examples here.

Features

Crates

This project is composed of multiple crates in order to organize features.

Note that only camo is intended for general use.

License

camo is distributed under the terms of the MIT license. See LICENSE for details.