minus 1.0.2

An asynchronous paging library for Rust
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

# minus
A fast, asynchronous terminal paging library for Rust. Minus provides a high level functions to easily write a pager for any terminal application
Due to the asynchronous nature, data to the pager can be **updated**. It supports both tokio as well as async-std runtimes.
Plus if you only to use minus for serving static output, you can simply opt out of
these dynamic features

Minus was started by me as my work on pijul. I had dissatisfaction with all existing options like *pager* and *moins*

* Pager:-
    * Only provides functions to join the standard output of the current program to the standard input of external pager like `more` or `less`
    * Due to this, for functioning in Windows, the external pagers need to be packaged along with the executable

* Moins
    * The output could only be defined once and for all. It is not asynchronous and does not support updating

## Usage
* If you use `tokio` for your application, use the `tokio_lib` feature
* If you use `async_std` for your application, use the `async_std_lib` feature
* If you only want too show static information, use `static_output` feature

In your `Cargo.toml` file
```toml
[dependencies.minus]
version = "^1.0" 
# For tokio
features = ["tokio_lib"]

# For async_std
features = ["async_std_lib"]

# For static output
features = ["static_output"]
```

## Example
Using tokio

``` rust
use tokio::main;
use futures::join;
use std::sync::{Arc, Mutex};

#[main]
async fn main() {
    let output = Arc::new(Mutex::new(String::new()));
    // Asynchronously push numbers to a string
    let increment = async {
        for i in 0..100 {
            let guard = output.lock().unwrap();
            // Always use writeln to add a \n after the line
            let _ = writeln!(output, "{}", guard);
            // Drop here explicitly, if you have further asynchronous blocking code
            drop(guard);
            // Some asynchronous blocking code
            tokio::task::sleep(std::Duration::new(1,0)).await;
        }
    }
    join!(minus::tokio_updating(output.clone()), increment);
}
```

Using async_std

```rust
use async_std::main;
use futures::join;
use std::sync::{Arc, Mutex};
use std::fmt::Write;

#[main]
async fn main() {
    let output = Arc::new(Mutex::new(String::new()));
    // Asynchronously push numbers to a string
    let increment = async {
        for i in 0..100 {
            let guard = output.lock().unwrap();
            // Always use writeln to add a \n after the line
            let _ = writeln!(output, "{}", guard);
            // Drop here explicitly, if you have further asynchronous blocking code
            drop(guard);
            // Some asynchronous blocking code
            async_std::task::sleep(std::Duration::new(1,0)).await;
        }
    }
    join!(minus::async_std_updating(output.clone()), increment);
}
```

Some static output
``` rust
use std::fmt::Write;

fn main() {
    let mut output = String::new();
    for i in 1..=100 {
        let _ = writeln!(output, "{}", i);
    }
    minus::page_all(output);
}
```

If there are more rows in the terminal than the number of lines in the given data. Minus will simply print the
data and quit. This only works in static paging only

## Contributing
Issues, pull requests are more than welcome
Unless explicitly stated otherwise, all works to minus are dual licensed under the MIT and Apache License 2.0

See [CONTRIBUTING.md](CONTRIBUTING.md) on how to contribute to minus

See the licenses in their respective files