heroforge-core 0.2.2

Pure Rust core library for reading and writing Fossil SCM repositories
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

//! Example: Read from a Heroforge repository using builder pattern
//!
//! Usage: cargo run --example read_repo -- path/to/repo.forge

use heroforge_core::{Repository, Result};
use std::env;

fn main() -> Result<()> {
    // Get repository path from command line
    let args: Vec<String> = env::args().collect();
    let repo_path = args
        .get(1)
        .map(|s| s.as_str())
        .unwrap_or("../code/heroforge.forge");

    println!("Opening repository: {}", repo_path);
    println!("{}", "=".repeat(60));

    let repo = Repository::open(repo_path)?;

    // Show project info
    let project_code = repo.project_code()?;
    let project_name = repo.project_name()?;
    println!(
        "Project: {}",
        project_name.as_deref().unwrap_or("(unnamed)")
    );
    println!("Code: {}", &project_code[..16]);
    println!();

    // List branches using builder pattern
    println!("Branches:");
    let branches = repo.branches().list()?;
    for branch in branches.iter().take(10) {
        println!("  - {}", branch);
    }
    if branches.len() > 10 {
        println!("  ... and {} more", branches.len() - 10);
    }
    println!();

    // Get trunk tip using history builder
    println!("Latest check-in (trunk):");
    let tip = repo.history().trunk_tip()?;
    println!("  Hash: {}", &tip.hash[..16]);
    println!("  Date: {}", tip.timestamp);
    println!("  User: {}", tip.user);
    println!("  Comment: {}", tip.comment.lines().next().unwrap_or(""));
    println!();

    // List files in the root directory using files builder
    println!("Root directory files:");
    let root_files = repo.files().on_trunk().list()?;
    let root_only: Vec<_> = root_files
        .iter()
        .filter(|f| !f.name.contains('/'))
        .collect();
    for file in root_only.iter().take(15) {
        println!("  {}", file.name);
    }
    if root_only.len() > 15 {
        println!("  ... and {} more files", root_only.len() - 15);
    }
    println!();

    // List subdirectories using files builder
    println!("Root subdirectories:");
    let subdirs = repo.files().on_trunk().subdirs("")?;
    for dir in &subdirs {
        println!("  {}/", dir);
    }
    println!();

    // Find all C source files using files builder
    println!("C source files (src/*.c):");
    let c_files = repo.files().on_trunk().find("src/*.c")?;
    for file in c_files.iter().take(10) {
        println!("  {}", file.name);
    }
    if c_files.len() > 10 {
        println!("  ... and {} more", c_files.len() - 10);
    }
    println!();

    // Read README.md if it exists using files builder
    println!("README.md content (first 500 chars):");
    match repo.files().on_trunk().read_string("README.md") {
        Ok(text) => {
            let preview: String = text.chars().take(500).collect();
            println!("{}", preview);
            if text.len() > 500 {
                println!("...");
            }
        }
        Err(e) => {
            println!("  Could not read README.md: {}", e);
        }
    }
    println!();

    // Show recent check-ins using history builder
    println!("Recent check-ins:");
    let recent = repo.history().recent(5)?;
    for ci in &recent {
        println!(
            "  {} {} - {}",
            &ci.hash[..8],
            ci.user,
            ci.comment.lines().next().unwrap_or("")
        );
    }

    Ok(())
}