hson

JSON like format for HTML.
The parser can be used for other purposes, but its main goal is to represent a HTML structure in a JSON style.

Main differences with standard json

Usage

Parsing
Stringifying
Querying
Searching
Inserting
Removing
Iterating
Debugging
Events listening
Nodes manipulation

Parsing

```rust use hson::{ Hson, Debug };

...

let data = r#"{ "div": { "attrs": { "class": [""], "onClick": "doSomething" }, "div": { "p": { "attrs": {}, "span": { "text": "Hello" } }, "p": {} }, "div": { "component": "test", "attrs": {}, "onClick": "componentDoSomething" } } }"#;

let mut hson = Hson::new(); hson.parse(&data).unwrap(); hson.print_nodes(true); ```

Stringifying

```rust ...

let s = hson.stringify(); println!("{}", &s); ```

Querying

Find matching nodes

Querying works as the javascript querySelectorAll method but without the 'CSS' features.
(Queries improvement is planned). ```rust use hson::{ Hson, Query };

...

// Get node's identifiers for easier processing let results = hson.query("div p").unwrap(); println!("\n{:?}\n", results);

// Get node's reference let results = hson.query_nodes("div p").unwrap(); println!("\n{:?}\n", results);

// Recursive search in a node let results = hson.query_on(&uid, "div p", true).unwrap(); println!("\n{:?}\n", results);

// Non recursive search in a node let results = hson.query_on(&uid, "attrs", false).unwrap(); println!("\n{:?}\n", results);

// Recursive search in a node and get node's reference let results = hson.queryonnodes(&node, "div p", true).unwrap(); println!("\n{:?}\n", results);

// Non recursive search in a node and get node's reference let results = hson.queryonnodes(&node, "attrs", false).unwrap(); println!("\n{:?}\n", results);

// Get node key let key = hson.getnodekey(&node);

// Get node value let value = hson.getnodevalue(&node); ```

Searching

Search allow easier querying. ```rust use hson::{ Hson, Query, Search };

...

// Standard recursive search let results = hson.search("div p").unwrap(); println!("\n{:?}\n", results);

// Look for immediate childs, no recursive search let results = hson.search("div>p").unwrap(); println!("\n{:?}\n", results);

// Look for multiple childs (OR search) let results = hson.search("attrs id|rate|trusted").unwrap(); println!("\n{:?}\n", results);

// Look for a node with a specific value let results = hson.search("attrs id='12'").unwrap(); println!("\n{:?}\n", results);

// All those features can be combined let results = hson.search("div>p attrs id='12'|rate='3'|trusted").unwrap(); println!("\n{:?}\n", results); ```

Inserting

```rust use hson::{ Hson, Query, Ops, Debug };

...

let results = hson.query("div p").unwrap(); let child = r#"{ "i": { "class": [], "text": "World" }, "ul": { "class": ["active","test"] } }"#;

hson.insert(&results[0], 1, child).unwrap(); hson.print_data(true); ```

Removing

```rust use hson::{ Hson, Query, Ops, Debug };

...

let results = hson.query("p").unwrap();

hson.remove(&results[0]).unwrap(); hson.print_data(true); ```

Iterating

Iterate over the nodes identifiers ```rust ...

for id in hson { println!("{}", id); }

// OR loop { let id = match hson.next() { Some(s) => s, None => break };

match &hson.nodes.get(&id) {
    Some(node) => {
        println ! ("{} : {}", node.instance, node.id);
    }
    None => {
        break
    }
}

} ```

Debugging

```rust use hson::{ Hson, Debug };

...

hson.printprocesstime(); hson.printnodes(true); // true for sorted printing hson.printdata(true); // true for pretty printing ```

Events

Current supported events are Parse, Insert, Remove. ```rust use hson::{ Hson, Ops, Event };

...

fn on_event (evt: Event, uid: String) { println!("\nEVENT : {:?} on {}\n", evt, uid); }

let mut hson = Hson::new(); hson.subscribe(on_event);

... ```

Manipulation

Nodes values can be casted to primitive types using Vertex, a Node clone with more attributes.
Note : Vertex are Nodes clones and not references to the underlying Nodes. Manipulating Vertex's values will not be reflected on their matching Nodes. ```rust use hson::{ Hson, Query, Search, Cast };

...

let results = hson.search("div attrs class").unwrap(); let vertex = hson.get_vertex(&results[0]).unwrap();

// Get vertex value as u64 println!("{}", vertex.valueasf64());

// Get vertex value as a vector of String println!("{:?}", vertex.valueasarray());

// Cast a string value to a different type let s = "0.456"; println!("{}", vertex.as_f64(s)); ```

Vertex methods