phprs 0.1.8

A PHP interpreter with build/package manager written in 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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! PHP INI configuration
//!
//! Migrated from main/php_ini.h and main/php_ini.c

#[cfg(test)]
mod tests;

use std::collections::HashMap;
use std::fs;
use std::sync::Mutex;

thread_local! {
    static GLOBAL_INI: Mutex<HashMap<String, String>> = Mutex::new(HashMap::new());
}

/// INI entry with name, value, and optional section
#[derive(Debug, Clone)]
pub struct IniEntry {
    pub name: String,
    pub value: String,
    pub section: Option<String>,
}

/// INI configuration parser
pub struct IniParser {
    entries: HashMap<String, IniEntry>,
    current_section: Option<String>,
}

impl IniParser {
    pub fn new() -> Self {
        Self {
            entries: HashMap::new(),
            current_section: None,
        }
    }

    /// Parse INI file
    pub fn parse_file(&mut self, filename: &str) -> Result<(), String> {
        let content =
            fs::read_to_string(filename).map_err(|e| format!("Failed to read INI file: {e}"))?;
        self.parse_string(&content)
    }

    /// Parse INI string
    pub fn parse_string(&mut self, content: &str) -> Result<(), String> {
        for (line_num, line) in content.lines().enumerate() {
            let line = line.trim();

            // Skip empty lines and comments
            if line.is_empty() || line.starts_with(';') || line.starts_with('#') {
                continue;
            }

            // Parse section [section_name]
            if line.starts_with('[') && line.ends_with(']') {
                let section = &line[1..line.len() - 1];
                self.current_section = Some(section.to_string());
                continue;
            }

            // Parse key=value
            if let Some(equal_pos) = line.find('=') {
                let key = line[..equal_pos].trim().to_string();
                let value = line[equal_pos + 1..].trim().to_string();

                // Remove quotes if present
                let value = value.trim_matches(|c| c == '"' || c == '\'');

                let entry = IniEntry {
                    name: key.clone(),
                    value: value.to_string(),
                    section: self.current_section.clone(),
                };

                // Use full key (section.key) as map key
                let map_key = if let Some(ref section) = self.current_section {
                    format!("{section}.{key}")
                } else {
                    key
                };

                self.entries.insert(map_key, entry);
            } else {
                return Err(format!("Invalid INI syntax at line {line_num}: {line}"));
            }
        }

        Ok(())
    }

    /// Get INI entry by name
    pub fn get(&self, name: &str) -> Option<&IniEntry> {
        self.entries.get(name)
    }

    /// Get all entries
    pub fn get_all(&self) -> Vec<&IniEntry> {
        self.entries.values().collect()
    }

    /// Get entries for a specific section
    pub fn get_section(&self, section: &str) -> Vec<&IniEntry> {
        self.entries
            .values()
            .filter(|e| e.section.as_ref().map(|s| s == section).unwrap_or(false))
            .collect()
    }
}

impl Default for IniParser {
    fn default() -> Self {
        Self::new()
    }
}

/// Parse INI file and return entries
pub fn php_ini_parse_file(filename: &str) -> Result<Vec<IniEntry>, String> {
    let mut parser = IniParser::new();
    parser.parse_file(filename)?;
    Ok(parser.get_all().into_iter().cloned().collect())
}

/// Get INI value by name
pub fn php_ini_get(name: &str) -> Option<String> {
    GLOBAL_INI.with(|ini| {
        let ini = ini.lock().unwrap();
        ini.get(name).cloned()
    })
}

/// Set INI value
pub fn php_ini_set(name: &str, value: &str) -> Result<(), String> {
    GLOBAL_INI.with(|ini| {
        let mut ini = ini.lock().unwrap();
        ini.insert(name.to_string(), value.to_string());
        Ok(())
    })
}