i-ching 1.0.0

I Ching divination readings for CLI and Goose extension
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::env;
use std::fs;
use std::path::PathBuf;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Trigram {
    pub name: String,
    pub chinese: String,
    pub unicode: String,
    pub symbolic: String,
    pub element: String,
    pub attribute: String,
    pub lines: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HexagramJudgment {
    pub text: String,
    pub commentary: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HexagramImage {
    pub text: String,
    pub commentary: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LineInterpretation {
    pub text: String,
    pub comments: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Hexagram {
    pub number: u8,
    pub name: String,
    pub chinese: String,
    pub pinyin: String,
    pub unicode: String,
    pub binary: String,
    pub opposite: String,
    pub upper_trigram: String,
    pub lower_trigram: String,
    pub description: String,
    pub judgment: HexagramJudgment,
    pub image: HexagramImage,
    pub lines: HashMap<String, LineInterpretation>,
}

pub struct IChingData {
    pub trigrams: HashMap<String, Trigram>,
    pub hexagrams: HashMap<String, Hexagram>,
}

impl IChingData {
    pub fn load() -> Result<Self, Box<dyn std::error::Error>> {
        // Try to load from embedded data first, then fall back to files
        Self::load_embedded().or_else(|_| Self::load_from_files())
    }

    /// Load data embedded in the binary at compile time
    fn load_embedded() -> Result<Self, Box<dyn std::error::Error>> {
        // Embed the JSON files at compile time
        let trigrams_content = include_str!("../../data/trigrams.json");
        let hexagrams_content = include_str!("../../data/hexagrams.json");

        let trigrams: HashMap<String, Trigram> = serde_json::from_str(trigrams_content)?;
        let hexagrams: HashMap<String, Hexagram> = serde_json::from_str(hexagrams_content)?;

        Ok(IChingData {
            trigrams,
            hexagrams,
        })
    }

    /// Load data from external files (fallback for development)
    fn load_from_files() -> Result<Self, Box<dyn std::error::Error>> {
        let data_dir = Self::find_data_directory()?;

        // Load trigrams
        let trigrams_path = data_dir.join("trigrams.json");
        let trigrams_content = fs::read_to_string(&trigrams_path).map_err(|e| {
            format!(
                "Failed to read trigrams.json from {}: {}",
                trigrams_path.display(),
                e
            )
        })?;
        let trigrams: HashMap<String, Trigram> = serde_json::from_str(&trigrams_content)?;

        // Load hexagrams
        let hexagrams_path = data_dir.join("hexagrams.json");
        let hexagrams_content = fs::read_to_string(&hexagrams_path).map_err(|e| {
            format!(
                "Failed to read hexagrams.json from {}: {}",
                hexagrams_path.display(),
                e
            )
        })?;
        let hexagrams: HashMap<String, Hexagram> = serde_json::from_str(&hexagrams_content)?;

        Ok(IChingData {
            trigrams,
            hexagrams,
        })
    }

    fn find_data_directory() -> Result<PathBuf, Box<dyn std::error::Error>> {
        // Try multiple locations in order of preference
        let candidates = vec![
            // 1. Current working directory
            PathBuf::from("data"),
            // 2. Relative to the executable
            env::current_exe()?.parent().unwrap().join("data"),
            // 3. Relative to the executable's parent (for development)
            env::current_exe()?
                .parent()
                .unwrap()
                .parent()
                .unwrap()
                .join("data"),
            // 4. In the same directory as the executable
            env::current_exe()?.parent().unwrap().to_path_buf(),
        ];

        for candidate in candidates {
            if candidate.join("trigrams.json").exists() && candidate.join("hexagrams.json").exists()
            {
                return Ok(candidate);
            }
        }

        Err("Could not find data directory with trigrams.json and hexagrams.json. Please ensure the data files are in one of these locations: ./data/, next to the executable, or in the parent directory.".into())
    }

    pub fn get_hexagram(&self, number: u8) -> Option<&Hexagram> {
        self.hexagrams.get(&number.to_string())
    }

    pub fn get_trigram(&self, name: &str) -> Option<&Trigram> {
        self.trigrams.get(name)
    }

    pub fn get_line_interpretation(
        &self,
        hexagram_number: u8,
        line_position: u8,
    ) -> Option<&LineInterpretation> {
        self.get_hexagram(hexagram_number)?
            .lines
            .get(&line_position.to_string())
    }
}