json_macros 0.3.2

Convenience macros for constructing JSON objects from literals. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

# json_macros

[![Crates.io](https://img.shields.io/crates/v/json_macros.svg)](https://crates.io/crates/json_macros)
[![Build Status](https://travis-ci.org/tomjakubowski/json_macros.svg?branch=master)]
(https://travis-ci.org/tomjakubowski/json_macros)

``` rust
let properties = json! {
    "menu": {
        "id": "file",
        "value": "File",
        "popup": {
            "menuitem": [
                {"value": "New", "onclick": "CreateNewDoc()"},
                {"value": "Open", "onclick": "OpenDoc()"},
                {"value": "Close", "onclick": "CloseDoc()"}
            ]
        }
    }
};

let menu_value = properties.find_path(["menu", "value"])
    .map(|x| x.as_string());

assert_eq!(menu_value, Some("File"));
```

Use JSON-like literals in Rust to construct [`serde_json`][] `Value`s
or [`rustc-serialize`][] `Json` values.

Because `json_macros` is a compiler plugin, it's only compatible with
the Rust [nightly channel][rust-nightly].

Depending on your project's needs, you may ask `json_macros` to
generate code that constructs [`serde_json`][] values or code that
constructs [`rustc-serialize`][] values.

## Using json_macros with rustc-serialize

By default, `json_macros` generates code for `rustc-serialize`.  In a
future release, the default may switch to `serde_json`, but
`json_macros` should be at least optionally compatible with
`rustc-serialize` for as long as that crate is supported.

To use `json_macros` with `rustc-serialize`, add both packages as
dependencies to your `Cargo.toml`.

```toml
[dependencies]
json_macros = "^0.3"
rustc-serialize = "^0.3"
```

Your crate will also need to link with `rustc_serialize` and `use` it
in any submodule that uses the `json!()` macro.

```rust
extern crate rustc_serialize;

// ...

mod foo {
    use rustc_serialize;
    // ...
}
```

### Example

```rust
#![feature(plugin)]
#![plugin(json_macros)]

extern crate rustc_serialize;

pub fn main() {
    let x = 123i32;
    println!("{}", json!({ // object literal
        "foo": "foooooo", // string literal keys and values
        "bar": [true, null, 123, 123.4], // array, boolean, null, numeric literals
        "quux": { // nest as deeply as you like
          "a": [1, 2, 3, 4],
          "b": { "a": null },
          "c": false
        },
        "waldo": (192 - x) // wrap in parens to splice ToJson expressions directly
    }).pretty().to_string());
}
```

## Using json_macros with serde_json

To use `json_macros` with `serde_json`, add both packages as
dependencies to your `Cargo.toml`.  Enable the `with-serde_json`
feature for `json_macros` and disable the default features so as to
not depend on `rustc-serialize`.

```toml
[dependencies]
rustc-serialize = "^0.3"

[dependencies.json_macros]
version = "^0.3"
default-features = false
features = ["with-serde"]
```

Your crate will also need to link with `serde_json` and `use` it in
any submodule that uses the `json!()` macro.

```rust
extern crate serde_json;

// ...

mod foo {
    use serde_json;
    // ...
}
```

### Example

```rust
#![feature(plugin)]
#![plugin(json_macros)]

extern crate serde_json;

pub fn main() {
    let x = 123i32;
    println!("{}", serde_json::to_string_pretty(&json!({ // object literal
        "foo": "foooooo", // string literal keys and values
        "bar": [true, null, 123, 123.4], // array, boolean, null, numeric literals
        "quux": { // nest as deeply as you like
          "a": [1, 2, 3, 4],
          "b": { "a": null },
          "c": false
        },
        "waldo": (192 - x) // wrap in parens to splice ToJson expressions directly
    })).unwrap());
}
```

[`serde_json`]: <https://github.com/serde-rs/json>
[`rustc-serialize`]: <https://doc.rust-lang.org/rustc-serialize/rustc_serialize/index.html>
[rust-nightly]: <http://doc.rust-lang.org/book/nightly-rust.html>