altio 0.2.0

Automating command tools by simulating piped io in process.
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

This crate helps to automating command tools by simulating piped io in process.

# Why this crate

Interactive command tools utilize stdin, stdout and stderr for communication.
If you want to use command tools as libraries(no spawning processes) and tool
authors agree, this crate can help to automating input/output, just 3 steps:

1. Define an `Altio` variable e.g. `let io = Altio::default();`.

2. Replace std APIs with altio's equivalents, e.g. replace `println!(...)` with
`writeln!( io.out(), ... )`, replace `std::io::stdin()` with `io.input()`.

3. Keep main.rs as simple as possible, e.g.
`fn main() { the_tool::run( std::env::args_os() )}`.

# Example for tool authors

```toml
[dependencies]
altio = { version = "0.2", no_default_features = true }

[features]
altio = ["altio/altio"]
```

```rust,no_run
// lib.rs
pub struct TheTool {
    // fields omitted
    pub io: Altio,
}

impl_altio_output!( TheTool );
```

When building the tool as an application, the "altio" feature is disabled and
altio falls back to stdio.

When building the tool as a library, the tool users can invoke send/recv methods
to communicate with the tool, e.g. `send_line()`, `try_recv_line()`.

# Example for tool users

```toml
the_tool = { version = "1.0", features = ["altio"] }
```

```rust,no_run
let args = std::env::args_os(); // clap::Parser::parse_from()
let tool = the_tool::new();
let tool_io = tool.io.clone();

// `io.input().read_line()` called occasionally
std::thread::spawn( || tool.run( args ));

loop {
    if let Some( received ) = tool_io.try_recv_line() {
        if received == "Lorum" {
            tool_io.send_line( "Ipsum" );
        }
    }
}
```

# License

Under Apache License 2.0 or MIT License, at your will.