textlane 0.0.0

Rust-native text processing pipeline — a unified replacement with native and JavaScript plugins
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

# Textlane

Textlane is a Rust-native text processing pipeline: a replacement for unified whose plugins
run natively, while existing JavaScript plugins can still join the same pipeline. One Rust
crate ships to crates.io, npm and PyPI at one version.

## Installation

```bash
cargo add textlane
```

## Usage

A processor chains plugins with `use`, as unified does, then parses, transforms and serializes
text with `process`. Each language reaches the same crate; plugins are grouped by domain (`md`,
`html`, `mdx`, `nl`) and named as the pipeline names them.

Rust:

```rust
use textlane::{Processor, html, md};

let processor = Processor::new()
    .with(md::Parse::default())
    .with(md::Gfm::default())
    .with(md::ToHtml::default())
    .with(html::Stringify::default())
    .freeze()?;
assert_eq!(processor.process("# hi")?.value, "<h1>hi</h1>");
```

Node.js:

```js
import { textlane } from "textlane"
import * as html from "textlane/html"
import * as md from "textlane/md"

const file = await textlane()
  .use(md.parse())
  .use(md.gfm())
  .use(md.toHtml({ allowDangerousHtml: true }))
  .use(html.stringify())
  .process("# hi")
file.value // "<h1>hi</h1>"
```

Python:

```python
from textlane import html, md, textlane

file = (
    textlane()
    .use(md.parse())
    .use(md.gfm())
    .use(md.to_html({"allowDangerousHtml": True}))
    .use(html.stringify())
    .process("# hi")
)
file["value"]  # "<h1>hi</h1>"
```

Node.js and Python also offer `parse`, `run`, `stringify`, `data` and `freeze`, with
Node.js's `process`/`run` returning a Promise beside `processSync`/`runSync`, and Python's
returning the result beside the coroutines `aprocess`/`arun`.
Errors carry the crate's `code`, such as `unknown-plugin`. A JavaScript or Python function
joins a pipeline as a unified attacher returning a transformer; it cannot add syntax, a parser
or a compiler.

## Documentation

Read the docs at [textlane.dev](https://textlane.dev).

## License

MIT.