vb6parse 1.0.1

vb6parse is a library for parsing and analyzing VB6 code, from projects, to controls, to modules, and forms.
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

//! This module provides standard Rust trait implementations for converting between
//! `PropertyGroup` and other types.
//!
//! Uses `TryFrom` for fallible conversions from `PropertyGroup` and `From` for
//! infallible conversions to `PropertyGroup`.

use crate::files::common::PropertyGroup;
use crate::language::Font;

use std::collections::HashMap;

use either::Either;

/// Fallible conversion from `PropertyGroup` to `Font`
impl TryFrom<&PropertyGroup> for Font {
    type Error = String; // In a real implementation, you would likely want a more specific error type

    fn try_from(group: &PropertyGroup) -> Result<Self, Self::Error> {
        if !group.name.eq_ignore_ascii_case("Font") {
            return Err(format!(
                "Expected PropertyGroup name 'Font', found '{}'",
                group.name
            ));
        }

        let name = group
            .properties
            .get("Name")
            .and_then(|name| name.as_ref().left())
            .ok_or_else(|| "Missing 'Name' property".to_string())?;

        let size = group
            .properties
            .get("Size")
            .and_then(|v| v.as_ref().left())
            .ok_or_else(|| "Missing 'Size' property".to_string())?
            .parse::<f32>()
            .map_err(|_| "Invalid 'Size' property value".to_string())?;

        let charset = group
            .properties
            .get("Charset")
            .and_then(|v| v.as_ref().left())
            .ok_or_else(|| "Missing 'Charset' property".to_string())?
            .parse::<i32>()
            .map_err(|_| "Invalid 'Charset' property value".to_string())?;

        let weight = group
            .properties
            .get("Weight")
            .and_then(|v| v.as_ref().left())
            .ok_or_else(|| "Missing 'Weight' property".to_string())?
            .parse::<i32>()
            .map_err(|_| "Invalid 'Weight' property value".to_string())?;

        let underline = group
            .properties
            .get("Underline")
            .and_then(|v| v.as_ref().left())
            .ok_or_else(|| "Missing 'Underline' property".to_string())?;

        let italic = group
            .properties
            .get("Italic")
            .and_then(|v| v.as_ref().left())
            .ok_or_else(|| "Missing 'Italic' property".to_string())?;

        let strikethrough = group
            .properties
            .get("Strikethrough")
            .and_then(|v| v.as_ref().left())
            .ok_or_else(|| "Missing 'Strikethrough' property".to_string())?;

        Ok(Font {
            name: name.clone(),
            size,
            charset,
            weight,
            underline: parse_vb6_bool(underline),
            italic: parse_vb6_bool(italic),
            strikethrough: parse_vb6_bool(strikethrough),
        })
    }
}

/// Infallible conversion from `Font` to `PropertyGroup`
impl From<&Font> for PropertyGroup {
    fn from(font: &Font) -> Self {
        let mut properties = HashMap::new();

        properties.insert("Name".to_string(), Either::Left(font.name.clone()));
        properties.insert("Size".to_string(), Either::Left(font.size.to_string()));
        properties.insert(
            "Charset".to_string(),
            Either::Left(font.charset.to_string()),
        );
        properties.insert("Weight".to_string(), Either::Left(font.weight.to_string()));
        properties.insert(
            "Underline".to_string(),
            Either::Left(if font.underline { "-1" } else { "0" }.to_string()),
        );
        properties.insert(
            "Italic".to_string(),
            Either::Left(if font.italic { "-1" } else { "0" }.to_string()),
        );
        properties.insert(
            "Strikethrough".to_string(),
            Either::Left(if font.strikethrough { "-1" } else { "0" }.to_string()),
        );

        PropertyGroup {
            name: "Font".to_string(),
            guid: None, // Font can have GUID in VB6, could extract if needed
            properties,
        }
    }
}

// Helper function
fn parse_vb6_bool(s: &str) -> bool {
    matches!(s, "-1" | "True" | "true")
}