Texas 0.2.1

Crate to generate latex documents
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

# Texas

## Purpose

This crate does not, in any way, even remotely cover the vast variety of things you can do with latex. Instead, it attempts to provide a friendly API
for some of the most basic functions. Furthermore, it does not catch most latex errors.

It's also my first foray into the open-source world, so constructive criticism is welcome and appreciated. https://github.com/Abhay478/Texas/issues



## Basics
- The primary type is `Document`, which you populate per your whims and fancies. This can be written to a file like so: 

```rust
let mut q = File::create("file.tex")?;
// let doc = Document::new(DocumentClass::new("book"));
let doc = document!("book");
write!(q, "{}", doc.to_string())?
```
- The document can be filled with `Component`s, `Package`s and `Command`s. They can be created using both functions and macros.
- `Component` is an enum, with each variant containing a separate struct. If a component `impl`s the `Populate` trait, you can fill it with more `Component`s, then install it in the `Document` like so:

```rust
let mut p1 = Part::new("one");
p1.attach(Component::Chapter(Chapter::new("c1")))?
    .attach(Component::Chapter(Chapter::new("c2")))?;

p1.attach_vec(vec![chapter!("c3"); 2])?;

doc.new_component(Component::Part(p1));
```
- `Command`s can be created and installed like so: 
```rust
doc.new_command(Command::new("brak", 1, "\\ensuremath{\\left(#1\\right)}"));
```
- And commands can be called in-text like so: 
```rust
let mut p1 = section!("one");
p1.attach(Component::Command(
    doc.get_command("brak")?.call(vec!["hello"])?,
))?;
p1.attach(command!(doc, "brak", "there"))?;
```
- Will add ability to generate stuff like `ensuremath` from code eventually.
- Packages can be created and installed like so: 
```rust
// let mut p1 = Package::new("parskip");
// p1.add_option("parfill");
let mut p1 = package!("parskip", "parfill");
doc.new_package(p1);
```
- Also has trait `Opt`, which allows for adding options to a command (like `usepackage` and `documentclass`, for now).

<!-- - As of 0.1.7, re-exported `crate::document`, `crate::component`, `crate::commands`, `crate::errors`  -->
<!-- Commands were seriously buggy, so some breaking changes. -->

## Log 
- ### 0.1.7
  - `package!` macro wasn't working, fixed that.
  - Moved the modules to the front (re-imported them in `lib.rs`) for convenience.
- ### 0.1.8
  - Small whoops. Latex errors due to `Line` code.
- ### 0.1.9
  - Brought structs into scope. 

## Future
- Add subsubsections
- Add new componnt variant for `description` lists
- Maybe some handy mathy shortcuts (like the aforementioned `ensuremath`)