ucp-translator-html 0.1.18

HTML to UCM document translator
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

//! HTML to UCM document translator.
//!
//! This crate provides translation from HTML documents to UCM's block-based
//! document model. It extracts semantic structure from HTML elements and
//! creates appropriate blocks with proper hierarchy.
//!
//! # Example
//!
//! ```
//! use ucp_translator_html::{HtmlParser, HtmlParserConfig};
//!
//! let html = r#"<html><body>
//!     <h1>Title</h1>
//!     <p>Some content here.</p>
//! </body></html>"#;
//!
//! let parser = HtmlParser::new();
//! let doc = parser.parse(html).unwrap();
//! ```

mod error;
mod parser;

pub use error::{HtmlError, Result};
pub use parser::{HeadingStrategy, HtmlParser, HtmlParserConfig};

/// Parse HTML string into a UCM Document.
///
/// This is a convenience function that uses default configuration.
pub fn parse_html(html: &str) -> Result<ucm_core::Document> {
    HtmlParser::new().parse(html)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_simple_html() {
        let html = r#"<html><body>
            <h1>Hello World</h1>
            <p>This is a paragraph.</p>
        </body></html>"#;

        let doc = parse_html(html).unwrap();
        assert!(doc.block_count() > 1);
    }

    #[test]
    fn test_parse_nested_structure() {
        let html = r#"<html><body>
            <h1>Main Title</h1>
            <p>Intro paragraph</p>
            <h2>Section 1</h2>
            <p>Section 1 content</p>
            <h2>Section 2</h2>
            <p>Section 2 content</p>
        </body></html>"#;

        let doc = parse_html(html).unwrap();

        // Should have root + h1 + h2 + h2 + paragraphs
        assert!(doc.block_count() >= 5);
    }

    #[test]
    fn test_parse_with_links() {
        let html = r#"<html><body>
            <p>Check out <a href="https://example.com">this link</a>!</p>
        </body></html>"#;

        let doc = parse_html(html).unwrap();
        assert!(doc.block_count() >= 2);
    }

    #[test]
    fn test_parse_with_images() {
        let html = r#"<html><body>
            <h1>Gallery</h1>
            <img src="https://example.com/image.jpg" alt="Test image">
        </body></html>"#;

        let config = HtmlParserConfig {
            extract_images: true,
            ..Default::default()
        };
        let parser = HtmlParser::with_config(config);
        let doc = parser.parse(html).unwrap();

        assert!(doc.block_count() >= 2);
    }

    #[test]
    fn test_parse_code_blocks() {
        let html = r#"<html><body>
            <pre><code class="language-rust">fn main() {
    println!("Hello");
}</code></pre>
        </body></html>"#;

        let doc = parse_html(html).unwrap();
        assert!(doc.block_count() >= 2);
    }

    #[test]
    fn test_parse_lists() {
        let html = r#"<html><body>
            <ul>
                <li>Item 1</li>
                <li>Item 2</li>
                <li>Item 3</li>
            </ul>
        </body></html>"#;

        let doc = parse_html(html).unwrap();
        assert!(doc.block_count() >= 2);
    }

    #[test]
    fn test_parse_tables() {
        let html = r#"<html><body>
            <table>
                <tr><th>Name</th><th>Age</th></tr>
                <tr><td>Alice</td><td>30</td></tr>
                <tr><td>Bob</td><td>25</td></tr>
            </table>
        </body></html>"#;

        let doc = parse_html(html).unwrap();
        assert!(doc.block_count() >= 2);
    }

    #[test]
    fn test_empty_html() {
        let html = "<html><body></body></html>";
        let doc = parse_html(html).unwrap();
        assert_eq!(doc.block_count(), 1); // Just root
    }

    #[test]
    fn test_malformed_html() {
        // Should handle malformed HTML gracefully
        let html = "<p>Unclosed paragraph <b>bold";
        let result = parse_html(html);
        // Should not panic, may succeed with partial parsing
        assert!(result.is_ok());
    }
}