rsword_chirho 0.3.0

Core SWORD module library in pure Rust
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

// Test module for checking verse indices

#[test]
fn check_indices_chirho() {
    use crate::versification_chirho::{kjv_chirho, TestamentChirho};

    let kjv_chirho = kjv_chirho();

    // Genesis 1:1
    let idx_chirho = kjv_chirho.calculate_index_chirho(TestamentChirho::OldChirho, 0, 1, 1).unwrap();
    println!("Genesis 1:1 index: {}", idx_chirho);

    // Genesis 1:2
    let idx_chirho = kjv_chirho.calculate_index_chirho(TestamentChirho::OldChirho, 0, 1, 2).unwrap();
    println!("Genesis 1:2 index: {}", idx_chirho);

    // John 3:16 (John is book index 3 in NT)
    let idx_chirho = kjv_chirho.calculate_index_chirho(TestamentChirho::NewChirho, 3, 3, 16).unwrap();
    println!("John 3:16 index: {}", idx_chirho);

    // Check totals
    println!("OT total: {}", kjv_chirho.testament_size_chirho(TestamentChirho::OldChirho));
    println!("NT total: {}", kjv_chirho.testament_size_chirho(TestamentChirho::NewChirho));
}

#[test]
fn debug_gbtspa_ot_chirho() {
    use std::path::Path;
    use crate::compression_chirho::create_compressor_chirho;
    use crate::storage_chirho::z_verse_chirho::ZVerseChirho;
    use crate::CompressionTypeChirho;

    let path_chirho = Path::new("/Users/hallelujah/.sword/modules/texts/ztext/gbtspa");

    if !path_chirho.exists() {
        println!("GBTSPA module not found, skipping test");
        return;
    }

    let comp_type_chirho = CompressionTypeChirho::ZipChirho;
    let compressor_chirho = create_compressor_chirho(comp_type_chirho);

    let mut storage_chirho = ZVerseChirho::open_with_comp_type_chirho(
        path_chirho,
        compressor_chirho,
        comp_type_chirho,
    ).expect("Failed to open storage");

    // Try to read OT verse at index 3 (Genesis 1:1)
    println!("Reading OT index 3 (Genesis 1:1)...");
    let verse_idx_chirho = storage_chirho.find_verse_index_chirho(1, 3);
    println!("Verse index result: {:?}", verse_idx_chirho);

    if let Ok(idx_chirho) = verse_idx_chirho {
        println!("  block_num: {}", idx_chirho.block_num_chirho);
        println!("  offset: {}", idx_chirho.offset_in_block_chirho);
        println!("  size: {}", idx_chirho.size_chirho);

        if !idx_chirho.is_empty_chirho() {
            // Try to read the block
            let block_result_chirho = storage_chirho.read_block_chirho(1, idx_chirho.block_num_chirho);
            println!("Block read result: {:?}", block_result_chirho.as_ref().map(|v| v.len()));

            if let Ok(block_chirho) = &block_result_chirho {
                let start_chirho = idx_chirho.offset_in_block_chirho as usize;
                let end_chirho = start_chirho + idx_chirho.size_chirho as usize;
                if end_chirho <= block_chirho.len() {
                    let text_chirho = String::from_utf8_lossy(&block_chirho[start_chirho..end_chirho]);
                    println!("  Text: {}", text_chirho);
                } else {
                    println!("  ERROR: end {} > block len {}", end_chirho, block_chirho.len());
                }
            }
        }
    }

    // Check indices 0-10 to understand the pattern
    println!("\nChecking indices 0-10:");
    for i_chirho in 0..10u32 {
        if let Ok(idx_chirho) = storage_chirho.find_verse_index_chirho(1, i_chirho) {
            if idx_chirho.size_chirho > 0 {
                if let Ok(block_chirho) = storage_chirho.read_block_chirho(1, idx_chirho.block_num_chirho) {
                    let start_chirho = idx_chirho.offset_in_block_chirho as usize;
                    let end_chirho = (start_chirho + idx_chirho.size_chirho as usize).min(start_chirho + 60);
                    let end_chirho = end_chirho.min(block_chirho.len());
                    let text_chirho = String::from_utf8_lossy(&block_chirho[start_chirho..end_chirho]);
                    // Safely truncate at char boundary
                    let display_text_chirho: String = text_chirho.chars().take(50).collect();
                    println!("Index {}: block={}, offset={}, size={} => {:?}...",
                        i_chirho, idx_chirho.block_num_chirho, idx_chirho.offset_in_block_chirho,
                        idx_chirho.size_chirho, display_text_chirho);
                }
            } else {
                println!("Index {}: empty", i_chirho);
            }
        }
    }

    // Also try NT for comparison
    println!("\nReading NT index 3067 (John 3:16)...");
    let verse_idx_chirho = storage_chirho.find_verse_index_chirho(2, 3067);
    println!("Verse index result: {:?}", verse_idx_chirho);

    if let Ok(idx_chirho) = verse_idx_chirho {
        println!("  block_num: {}", idx_chirho.block_num_chirho);
        println!("  offset: {}", idx_chirho.offset_in_block_chirho);
        println!("  size: {}", idx_chirho.size_chirho);
        if !idx_chirho.is_empty_chirho() {
            if let Ok(block_chirho) = storage_chirho.read_block_chirho(2, idx_chirho.block_num_chirho) {
                let start_chirho = idx_chirho.offset_in_block_chirho as usize;
                let end_chirho = start_chirho + idx_chirho.size_chirho as usize;
                if end_chirho <= block_chirho.len() {
                    let text_chirho = String::from_utf8_lossy(&block_chirho[start_chirho..end_chirho]);
                    println!("  Text: {}", text_chirho);
                }
            }
        }
    }
}