ryo-source 0.1.0

High-speed Rust AST manipulation engine
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

//! Source code generation from Pure AST.
//!
//! This module provides generators that convert Pure AST structures into
//! Rust source code. Different generators support different output strategies:
//!
//! - `SingleFileGenerator`: Generates a single lib.rs/main.rs with nested `mod {}` blocks
//! - `MultiFileGenerator`: Generates multiple files following Rust module conventions
//!
//! # Architecture
//!
//! ```text
//! ModuleTree ──► SingleFileGenerator ──► PureFile ──► String (source code)
//!      │
//!      ├── Hierarchical module structure with items
//!      │
//!      └─► MultiFileGenerator ──► GeneratedFiles (PathBuf → GeneratedSource)
//! ```
//!
//! # Example
//!
//! ```ignore
//! use ryo_source::generator::{ModuleTree, SingleFileGenerator, MultiFileGenerator};
//!
//! let tree = ModuleTree::new("crate")
//!     .with_item(PureItem::Struct(my_struct))
//!     .with_child(ModuleTree::new("utils")
//!         .with_item(PureItem::Fn(helper_fn)));
//!
//! // Single file output
//! let generator = SingleFileGenerator::new();
//! let source = generator.generate(&tree);
//!
//! // Multi-file output
//! let generator = MultiFileGenerator::new();
//! let files = generator.generate(&tree);
//! // files.get("lib.rs"), files.get("utils.rs"), etc.
//! ```

mod multi;
mod single;
mod tree;

pub use multi::{GeneratedFiles, MultiFileGenerator};
pub use single::SingleFileGenerator;
pub use tree::ModuleTree;

use crate::pure::PureFile;

/// Result of source generation.
#[derive(Debug, Clone)]
pub struct GeneratedSource {
    /// The generated source code.
    pub source: String,
    /// The PureFile representation (for further manipulation if needed).
    pub pure_file: PureFile,
}

/// Trait for source code generators.
///
/// Generators transform a `ModuleTree` into source code, supporting
/// different output strategies (single file, multi-file, etc.).
pub trait SourceGenerator {
    /// Generate source code from a module tree.
    fn generate(&self, tree: &ModuleTree) -> Result<GeneratedSource, crate::pure::ToSynError>;
}