term_tools 0.1.0

Colorize Your Terminal with Term-Tools: A Rust-powered Formatting Tool
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

# **term_tools: Rich API for Colorizing Terminal**

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/dynamic/toml?url=https%3A%2F%2Fraw.githubusercontent.com%2FSyaw0%2Fterm_tools%2Frefs%2Fheads%2Fdevelop%2FCargo.toml&query=package.version&label=Version&color=red)](https://crates.io/term_tools)

## **Overview**

term_tools is a Rust library that provides a rich API for colorizing terminal output. It allows you to create styled text strings with various colors, effects, and formatters.

## **Features**

- **Colors**: Supports 16 basic colors, 256 palette colors, and RGB colors.
- **Effects**: Supports slow blink and rapid blink.
- **Formatters**: Supports reset, bold, faint, italic, underline, and overline formatters.
- **Easy to use**: Simple and intuitive API for creating styled text strings.

## **Usage**

To use term_tools, simply add the following line to your `Cargo.toml` file:

```toml
[dependencies]
term_tools = "0.1.0"
```

Then, import the library in your Rust code:

```rust
use term_tools::styled;
```

Create a styled text string using the `styled` function:

```rust
let styled_text = styled("Hello, World!")
    .red()
    .bold()
    .underline()
    .paint();
println!("{}", styled_text);
```

## **Sequence of Styles**

The sequence of styles is important when using the `fg` and `bg` methods. These methods set the foreground and background colors, respectively, for all subsequent styles.

When you call `fg` or `bg`, all styles that come before it will be applied to the foreground or background, respectively.

Here's an example:

```rust
let styled_text = styled("Hello, World!")
    .red() // applies to foreground
    .fg() // sets foreground color to red
    .blue() // applies to background
    .bg() // sets background color to blue
    .paint();
```

In this example, the `red` style is applied to the foreground, and the `blue` style is applied to the background.

if there is only one call of `fg` or `bg` whole colors applied that `PaintType` for example:

```rust
let styled_text = styled("Hello, World!")
    .red() // red color
    .blue() // blue color
    .bg() // apply background color
    .magenta() // magenta color
    .paint();
```

in this example `paint` method will apply the background color of all colors.

if there is not any `fg` or `bg` call , the default paint type assume as `Foreground` for example:

```rust
let styled_text = styled("Hello, World!")
    .red() // red color
    .blue() // blue color
    .paint();
```

in this example the `paint` method will use foreground color of the colors.

## **Examples**

Here are some examples of using term_tools:

- **Basic colors**:

```rust
let styled_text = styled("Hello, World!")
    .red()
    .paint();
println!("{}", styled_text);
```

- **RGB colors**:

```rust
let styled_text = styled("Hello, World!")
    .rgb(255, 0, 0)
    .paint();
println!("{}", styled_text);
```

- **Effects**:

```rust
let styled_text = styled("Hello, World!")
    .bold()
    .underline()
    .paint();
println!("{}", styled_text);
```

- **Formatters**:

```rust
let styled_text = styled("Hello, World!")
    .reset()
    .bold()
    .paint();
println!("{}", styled_text);
```

## **License**

term_tools is licensed under the MIT License.

## **Contributing**

Contributions are welcome If you'd like to contribute to term_tools, please fork the repository and submit a pull request.

I hope this helps Let me know if you'd like me to make any changes.