Crate json_str

Json String Literal Generator

Write json with Rust syntax instead of hard to read inline strings. This crate doesn’t evaluate any expressions, it just converts a Rust token tree into a minified json string.

Usage

This crate is on crates.io.

There are two ways to reference json_str in your projects, depending on whether you’re on the stable/beta or nightly channels.

Stable

To get started, add json_str to your Cargo.toml:

[dependencies]
json_str = "*"

And reference it in your crate root:

#[macro_use]
extern crate json_str;

Nightly

To get started, add json_str to your Cargo.toml:

[dependencies]
json_str = { version = "*", features = "nightly" }

And reference it in your crate root:

#![feature(plugin)]
#![plugin(json_str)]

If you’re on the nightly channel, it’s better to use the above plugin version with the nightly feature because the conversion and sanitisation takes place at compile-time instead of runtime, saving precious runtime cycles.

Examples

Literals

The json_str! macro will take an inline token tree and return a sanitised json String:

let json = json_str!({
    "query": {
        "filtered": {
            "query": {
                "match_all": {}
            },
            "filter": {
                "geo_distance": {
                    "distance": "20km",
                    "location": {
                        "lat": 37.776,
                        "lon": -122.41
                    }
                }
            }
        }
    }
});

This will also work for unquoted keys for something a bit more rusty:

let json = json_str!({
    query: {
        filtered: {
            query: {
                match_all: {}
            },
            filter: {
                geo_distance: {
                    distance: "20km",
                    location: {
                        lat: 37.776,
                        lon: -122.41
                    }
                }
            }
        }
    }
});

On nightly, there’s an additional plugin called json_lit that returns a &'static str instead of a String, so you can avoid allocating each time. The syntax is otherwise the same as json_str:

let json = json_lit!({
    query: {
        filtered: {
            query: {
                match_all: {}
            },
            filter: {
                geo_distance: {
                    distance: "20km",
                    location: {
                        lat: 37.776,
                        lon: -122.41
                    }
                }
            }
        }
    }
});

Replacement values

The json_fn macro will convert a set of replacement tokens and token tree and returns a lambda function that substitutes them:

// Declares an inline Fn(&str, &str, &str) -> String
let f = json_fn!(|dst, lat, lon| {
    query: {
        filtered: {
            query: {
                match_all: {}
            },
            filter: {
                geo_distance: {
                    distance: $dst,
                    location: {
                        lat: $lat,
                        lon: $lon
                    }
                }
            }
        }
    }
});
 
// Call the lambda and return the substituted json
let json = f("\"20km\"", "37.776", "-122.41");

All input arguments are a &str, and the output is a String. Only simple variable substitution is supported, no repeating or sanitisation of the replacement values.

Modules

parse

Raw parsers for sanitising a stream of json.

Macros

json_fn

json_str