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::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

Feature	Default	Description
derive	Yes	Enables the derive::Camo derive macro.
typescript	No	Enables the TypeScript backend, rooted in typescript::Definition.

Crates

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

Note that only camo is intended for general use.

Crate	Description
camo	This crate consolidates the subcrates, and is the only crate intended for general use. It exposes camo-core, and optionally exposes camo-derive and camo-typescript via feature switches.
camo-core	This crate defines the AST at the core of camo, and is thus the foundation that the other crates build upon.
camo-derive	This crate defines the derive macro Camo.
camo-typescript	This crate implements a translation layer from the Camo AST to TypeScript definitions that can be written out directly, e.g. a file.

License

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