strune 0.1.0

A simple, directional knowledge structure library for building linked references and word books
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

# Strune

A simple, directional knowledge structure library for building linked references and word books.

more about: https://project-starlivia.github.io/Strune/

## Features

- **Core Data Structure**: Generic `Node<T>` with label, description, dependencies, and customizable options
- **Markdown & JSON Loaders**: Parse knowledge nodes from Markdown or JSON files
- **Graph Operations**: Calculate reverse dependencies (dependents) and slug mappings
- **Static Site Generation**: Render knowledge graphs to HTML using Tera templates
- **Type-Safe**: Leverages Rust's type system with generic options support

## Installation

Add Strune to your `Cargo.toml`:

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

## Quick Start

Loading Nodes from Markdown
```rust
// define custom options
#[derive(Clone, Debug, Serialize, Deserialize, Default)]
pub struct MyOpts<T>
{
    #[serde(flatten)]
    pub base: T,
    #[serde(default)]
    pub slug: Option<String>,
    #[serde(default)]
    pub dependents: Option<Vec<String>>,
}

impl_maybe_slug!(MyOpts);
impl_maybe_dependents!(MyOpts);

fn main() -> Result<()> {
    // Load nodes from Markdown file
    let base_path = Path::new(env!("CARGO_MANIFEST_DIR"));
    let nodes: Vec<Node<MyOpts<Value>>> = load_nodes_from_markdown(base_path.join("content/sample.md"))?;

    // Calculate dependents
    let nodes = fill_dependents(nodes);

    println!("nodes: {}", nodes.len());

    // Clear dist directory
    let dist_path = base_path.join("dist");
    if dist_path.exists() {
        fs::remove_dir_all(&dist_path)?;
    }
    fs::create_dir_all(&dist_path)?;

    // Render static site
    render(
        "strune/templates/**/*.html",
        &dist_path,
        "/projects/Strune/sample/dist/",
        nodes.as_slice(),
    )
    .map_err(|e| {
        eprintln!("render error: {:?}", e);
        e
    })?;

    // Copy public directory to dist/public
    let public_path = base_path.join("public");
    if public_path.exists() {
        let dist_public = dist_path.join("public");
        copy_dir_all(public_path, &dist_public)?;
        println!("Copied public directory to dist/public");
    }

    Ok(())
}
```

## Markdown Syntax

Strune uses an extended Markdown syntax for defining knowledge nodes:

```markdown
# NodeLabel
## description
A short explanation of this concept.

## dependencies
- ParentConcept1
- ParentConcept2

## options
Additional metadata as needed
```

All fields except the label (h1) are optional.

## Core Concepts

### Node Structure

```rust
pub struct Node<T = Value> {
    pub label: String,           // Node identifier
    pub description: String,     // Explanation text
    pub dependencies: Vec<String>, // Parent concepts
    pub options: T,              // Custom metadata
}
```

### Dependencies

Dependencies represent directional relationships. A node's dependencies are concepts that compose or contain it:

- `Unity` → depends on `GameEngine`
- `Blender` ↔ `FBX` (mutual dependencies)

## Sample

See the [sample directory](https://github.com/your-username/Strune/tree/main/sample) for complete usage examples.

https://project-starlivia.github.io/Strune/

## License

MIT License - see [LICENSE](../LICENSE) for details.