strict-yaml-rust 0.2.0

A StrictYAML parser obtained by savagely chopping up the original yaml-rust crate.
Documentation 
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

strict-yaml-rust
-----
A [StrictYAML](http://hitchdev.com/strictyaml/) implementation for Rust 
obtained by savagely chopping off code from [yaml-rust](https://crates.io/crates/yaml-rust).

Now with built-in `serde` support as an optional feature! (@puetzp)

[![license](https://img.shields.io/crates/l/strict-yaml-rust.svg)](https://crates.io/crates/strict-yaml-rust/)
[![version](https://img.shields.io/crates/v/strict-yaml-rust.svg)](https://crates.io/crates/strict-yaml-rust/)

## What is StrictYAML?

StrictYAML is a subset of the YAML format, removing troublesome parts of the specification:

 - No typing. StrictYAML only knows Strings, Arrays and Dicts (Maps)  
 - No duplicate keys
 - No tags
 - No anchors or refs
 - No "flow" style (embedded JSON)
 
In short, keeping only the parts of YAML that we all know and love.

For more details, see the original documentation and implementation:

 - http://hitchdev.com/strictyaml/
 - https://github.com/crdoconnor/strictyaml
 
## Caveats

Missing from this implementation is a 
[programmatic schema](https://hitchdev.com/strictyaml/using/alpha/howto/either-or-validation/), 
which would enable document validation and typed value parsing. 
Seems that you'll still have to parse integers and dates from strings, 
or [send a PR](https://github.com/fralalonde/strict-yaml-rust/pulls)!

## Quick Start

Add the following to the Cargo.toml of your project:

```toml
[dependencies]
strict-yaml-rust = "0.1"
```

or

```toml
[dependencies.yaml-rust]
git = "https://github.com/fralalonde/strict-yaml-rust.git"
```

Use `StrictYamlLoader` to load the YAML documents, access it as Vec/HashMap and finally print it to `stdout` via `StrictYamlEmitter`:

```rust
use strict_yaml_rust::{StrictYamlEmitter, StrictYamlLoader};

fn main() {
    let s = "
foo:
    - list1
    - list2
bar:
    - 1
    - 2.0
";
    let docs = StrictYamlLoader::load_from_str(s).unwrap();

    // Multi document support, doc is a yaml::Yaml
    let doc = &docs[0];

    // Debug support
    println!("{:?}", doc);

    // Index access for map & array
    assert_eq!(doc["foo"][0].as_str().unwrap(), "list1");
    assert_eq!(doc["bar"][1].as_str().unwrap(), "2.0");

    // Chained key/array access is checked and won't panic,
    // return BadValue if a key does not exist.
    assert!(doc["INVALID_KEY"][100].is_badvalue());

    // Dump the YAML object
    let mut out_str = String::new();

    {
        let mut emitter = StrictYamlEmitter::new(&mut out_str);
        emitter.dump(doc).unwrap(); // dump the YAML object to a String
    }

    println!("{}", out_str);
}
```

Note that `strict_yaml_rust::StrictYaml` implements `Index<&'a str>` AND `Index<usize>`:

* `Index<usize>` assumes the container is an Array
* `Index<&'a str>` assumes the container is a string to value Map
* otherwise, `Yaml::BadValue` is returned

## Features

* Pure Rust
* Ruby-like Array/Hash access API
* Low-level StrictYAML events emission

## Specification Compliance

This implementation aims to provide StrictYAML parser fully compatible with the StrictYAML specification. 

## License

Licensed under either of

 * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
 * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

at your option.

## Contribution

Fork & PR on Github.

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
additional terms or conditions.