quercus 0.1.1

Easy to use CLI tree for your branchy info.
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
126
127
128
129
130
131
132
133
134
135
136
137

# quercus

*quercus* is the scientific genus name for oak trees.

This crate was inspired by [ptree](https://crates.io/crates/ptree).

## Main features

This crate allows you to create trees with many roots.

---

This crate does not have a syntax distinction for the first node/branch of a given root.

The crate also does not have a syntax distinction for nodes that do not have branches (leaves) or nodes that do.

This makes it easy to create a tree recursively, as the information is not needed when adding a new node.

---

This crate also provides a (small) variety of branch styles and a versatile indentation option that may be invoked spontaneously during the construction of the tree.

## Usage
The following code
```rust
let mut tree = Tree::new();

tree.node("Root");

tree.begin_branches();
    tree.node("Branch 1");
    tree.node("Branch 2");
tree.end_branches();

tree.prune();

println!("{tree}");
```
results in:
```bash
Root
├── Branch 1
└── Branch 2
```

For a node with many lines use the `node_many_lines()` command.
For example, the code
```rust
    let mut tree = Tree::new().style(PipeStyle::Double).indent(5);

    tree.node("Root");
    tree.begin_branches();
        tree.node_many_lines(&["Branch 1", "Some", "more", "information"]);
        tree.begin_branches();
            tree.node("Autumn leaf");
            tree.node("Spring leaf");
        tree.end_branches();

        tree.indent(0); // Change indentation

        tree.node("Branch 2");
        tree.begin_branches();
            tree.node("Summer leaf");
            tree.node("Winter (no leaf) :(");
        tree.end_branches();
    tree.end_branches();

    tree.prune_and_print();
```
results in:
```bash
Root
╠═════ Branch 1
║      Some
║      more
║      information
║      ╠═════ Autumn leaf
║      ╚═════ Spring leaf
╚ Branch 2
  ╠ Summer leaf
  ╚ Winter (no leaf) :(
```

## Appearance Options

### Indentation
The indentation of the branches can be set through the `indent()` command, which expects a `usize` integer.

This command can be invoked anywhere during the construction of the tree.


### Branch Style
The style of the branches can be set through the `style()` command, which expects a `PipeStyle`  `enum` variant.

Currently, the following variants are available:
* `PipeStyle::Simple` : `│` `─` `├` `└`
* `PipeStyle::Curvy` : `│` `─` `├` `╰`
* `PipeStyle::Double` : `║` `═` `╠` `╚`
* `PipeStyle::Thick` : `┃` `━` `┣` `┗`

This command, however, may only be invoked at the root level of the tree.

## Crate Examples

For an example that builds a tree recursively, run
```bash
$ cargo run --release --example fibonacci
```

This should yield the following output:
```bash
5
├─ 3
│  ├─ 2
│  │  ├─ 1
│  │  │  ├─ 1
│  │  │  ╰─ 0
│  │  ╰─ 1
│  ╰─ 1
│     ├─ 1
│     ╰─ 0
╰─ 2
   ├─ 1
   │  ├─ 1
   │  ╰─ 0
   ╰─ 1
```
---
For an example that uses the [colored](https://crates.io/crates/colored) crate as well as the `node_many_lines()` command, run
```bash
$ cargo run --release --example hierarchy
```

## License
This project is licensed under either
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or https://www.apache.org/licenses/LICENSE-2.0)
* MIT License ([LICENSE-MIT](LICENSE-MIT) or https://opensource.org/licenses/MIT)