itch 0.2.3

A cli tool for InTerCHanging between different serialized data formats
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

# Itch

> InTerCHanges one data format into another (get it?)

A very simple cli to convert between some of the most common plain-text data formats. It can't perform every conversion that might be theoretically possible, but it tries its best

<!-- vim-markdown-toc GFM -->

* [Installation](#installation)
* [Overview](#overview)
   * [Formats](#formats)
      * [First Class](#first-class)
      * [Second Class](#second-class)
   * [Behaviour](#behaviour)
* [Implementation](#implementation)

<!-- vim-markdown-toc -->

# Installation

`itch` currently does not offer binary downloads, and must instead be built from source. You can use [rustup][rustup] to get the rust toolchain, the run the following command to download and install itch:

```bash
cargo install --force --git https://github.com/FreddieRidell/itch.git
```

# Overview

```
USAGE:
    itch [OPTIONS]

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information

OPTIONS:
    -f, --from <from-type>    Format of the input, will be derived if possible
    -i, --input <input>       Path to the input file, leave empty for stdin
    -o, --output <output>     Path to the output file, leave empty for stdout
    -t, --to <to-type>        Format of the output, will be derived if possible
```

`itch` can take input from a file or std in, and output to a file or std out. If given a file as input or output it will try to detect the format automatically. `itch` doesn't do any manipulation to data to satisfy the different constructs that different formats can express; so there's no guarantee that a conversion will work.

## Formats

### First Class

Can all be pretty reliably used as sources and targets

- json
- toml
- yaml

### Second Class

Somewhat unreliable, but can be used for basic transformations

- url query strings
- xml

## Behaviour

`itch` should always produce the same output when given the same input:

**input**

```shell
echo '<element key="value"><child/></element>'
   | itch -f xml -t json
```

**output**

```json
{ "key": "value", "child": {} }
```

`itch` will not necessarily produce output that can automatically be reversed:

**input**

```shell
echo '<element key="value"><child/></element>'
   | itch -f xml -t json
   | itch -f json -t xml
```

**output**

```xml
<key>value</key><child></child>
```

# Implementation

Uses [serde][serde] and it's own internal data representation format to act as an intermediary between the different data formats:

```rust
enum Itch {
    Obj(IndexMap<String, Itch>),
    Array(Vec<Itch>),
    Bool(bool),
    Int(i64),
    Float(f64),
    Text(String),
}
```

Each deserialization step converts to this type, and each serialisation step converts from it.

[clap]: https://github.com/clap-rs/clap
[crates]: https://crates.io/
[rustup]: https://rustup.rs/
[serde]: https://serde.rs/