Struct Compiler

Source

pub struct Compiler { /* private fields */ }

Expand description

Deterministic frontend compiler reusable across data instances.

Implementations§

Source §

impl Compiler

Source

pub fn builder() -> CompilerBuilder

Starts configuration with conservative defaults.

Examples found in repository ?

examples/basic.rs (line 20)

18fn main() -> Result<(), Box<dyn std::error::Error>> {
19    let limits = ResourceLimits::default();
20    let compiler = Compiler::builder().limits(limits.clone()).build()?;
21    let template = compiler.compile_template_yaml(include_bytes!("basic.yml"))?;
22    let data: DataValue = serde_json::from_slice(include_bytes!("basic-data.json"))?;
23    let document = compiler.bind(&template, &data, &[])?;
24    let fonts = example_fonts()?;
25    let scene = LayoutEngine::new(&limits, &fonts, LayoutOptions::default())?.resolve(&document)?;
26    let (output, outcome) = export_bytes(
27        &scene,
28        &ExportRequest {
29            format: ExportFormat::Svg,
30            ..ExportRequest::default()
31        },
32        &ExportContext {
33            limits: &limits,
34            fonts: &fonts,
35            assets: None,
36        },
37    )?;
38    let output_path = output_path("basic.svg")?;
39    std::fs::write(&output_path, output)?;
40    println!(
41        "pages={} svg_bytes={} output={}",
42        scene.pages.len(),
43        outcome.bytes_written,
44        output_path.display()
45    );
46    Ok(())
47}

More examples

Hide additional examples

examples/intermediate.rs (line 25)

23fn main() -> Result<(), Box<dyn std::error::Error>> {
24    let limits = ResourceLimits::default();
25    let compiler = Compiler::builder().limits(limits.clone()).build()?;
26    let template = compiler.compile_template_yaml(include_bytes!("intermediate.yml"))?;
27    let data: DataValue = serde_json::from_slice(include_bytes!("intermediate-data.json"))?;
28    let mut document = compiler.bind(&template, &data, &[])?;
29    let mut log = OperationLog::new_bounded(8, 8 * 1024 * 1024)?;
30    let patch = Patch {
31        sequence: 1,
32        operations: vec![PatchOperation::Move {
33            id: ElementId::new("review-marker")?,
34            x: "185mm".parse()?,
35            y: "112mm".parse()?,
36        }],
37    };
38    log.apply(&mut document, &patch, limits.max_patch_operations)?;
39    let fonts = example_fonts()?;
40    let fingerprint = DocumentFingerprint::compute_with_patches(
41        &template,
42        &data,
43        std::slice::from_ref(&patch),
44        None,
45        &fonts,
46        &limits,
47    )?;
48    let engine = LayoutEngine::new(&limits, &fonts, LayoutOptions::default())?;
49    let mut cache = SceneCache::with_byte_capacity(8, 64 * 1024 * 1024)?;
50    let scene = engine.resolve_cached(&document, fingerprint, &mut cache)?;
51    let cached = engine.resolve_cached(&document, fingerprint, &mut cache)?;
52    if !Arc::ptr_eq(&scene, &cached) || scene.pages.len() != 2 {
53        return Err(std::io::Error::other("expected one cached two-page scene").into());
54    }
55
56    let pdf_request = ExportRequest {
57        format: ExportFormat::Pdf,
58        pdf_mode: PdfMode::Editable,
59        ..ExportRequest::default()
60    };
61    let context = ExportContext {
62        limits: &limits,
63        fonts: &fonts,
64        assets: None,
65    };
66    let report = preflight(
67        &scene,
68        &pdf_request,
69        &context,
70        &PreflightOptions {
71            strict: true,
72            ..PreflightOptions::default()
73        },
74        &OperationControl::default(),
75    )?;
76    report.enforce(true)?;
77    let (pdf, pdf_outcome) = export_bytes(&scene, &pdf_request, &context)?;
78    let (html, html_outcome) = export_bytes(
79        &scene,
80        &ExportRequest {
81            format: ExportFormat::Html,
82            html_mode: HtmlMode::Fixed,
83            ..ExportRequest::default()
84        },
85        &context,
86    )?;
87    let (page_one_svg, page_one_outcome) = export_svg_page(&scene, 0, &context)?;
88    let (page_two_svg, page_two_outcome) = export_svg_page(&scene, 1, &context)?;
89
90    let pdf_path = output_path("intermediate.pdf")?;
91    let html_path = output_path("intermediate.html")?;
92    let page_one_path = output_path("intermediate-page-1.svg")?;
93    let page_two_path = output_path("intermediate-page-2.svg")?;
94    let report_path = output_path("intermediate-preflight.json")?;
95    std::fs::write(&pdf_path, pdf)?;
96    std::fs::write(&html_path, html)?;
97    std::fs::write(&page_one_path, page_one_svg)?;
98    std::fs::write(&page_two_path, page_two_svg)?;
99    std::fs::write(&report_path, serde_json::to_vec_pretty(&report)?)?;
100    let inspector = SceneInspector::new(&scene);
101    println!(
102        "pages={} roles={:?}/{:?} undo={} pdf_bytes={} html_bytes={} svg_bytes={}/{}\npdf={}\nhtml={}\npage_1={}\npage_2={}\npreflight={}",
103        scene.pages.len(),
104        inspector.inspect_page(0)?.role,
105        inspector.inspect_page(1)?.role,
106        log.undo_len(),
107        pdf_outcome.bytes_written,
108        html_outcome.bytes_written,
109        page_one_outcome.bytes_written,
110        page_two_outcome.bytes_written,
111        pdf_path.display(),
112        html_path.display(),
113        page_one_path.display(),
114        page_two_path.display(),
115        report_path.display()
116    );
117    Ok(())
118}

Source

pub fn compile_template_yaml(&self, bytes: &[u8]) -> Result<TemplateIr>

Parses, expands includes/components/styles, and returns reusable IR.

Examples found in repository ?

examples/basic.rs (line 21)

18fn main() -> Result<(), Box<dyn std::error::Error>> {
19    let limits = ResourceLimits::default();
20    let compiler = Compiler::builder().limits(limits.clone()).build()?;
21    let template = compiler.compile_template_yaml(include_bytes!("basic.yml"))?;
22    let data: DataValue = serde_json::from_slice(include_bytes!("basic-data.json"))?;
23    let document = compiler.bind(&template, &data, &[])?;
24    let fonts = example_fonts()?;
25    let scene = LayoutEngine::new(&limits, &fonts, LayoutOptions::default())?.resolve(&document)?;
26    let (output, outcome) = export_bytes(
27        &scene,
28        &ExportRequest {
29            format: ExportFormat::Svg,
30            ..ExportRequest::default()
31        },
32        &ExportContext {
33            limits: &limits,
34            fonts: &fonts,
35            assets: None,
36        },
37    )?;
38    let output_path = output_path("basic.svg")?;
39    std::fs::write(&output_path, output)?;
40    println!(
41        "pages={} svg_bytes={} output={}",
42        scene.pages.len(),
43        outcome.bytes_written,
44        output_path.display()
45    );
46    Ok(())
47}

More examples

Hide additional examples

examples/intermediate.rs (line 26)

23fn main() -> Result<(), Box<dyn std::error::Error>> {
24    let limits = ResourceLimits::default();
25    let compiler = Compiler::builder().limits(limits.clone()).build()?;
26    let template = compiler.compile_template_yaml(include_bytes!("intermediate.yml"))?;
27    let data: DataValue = serde_json::from_slice(include_bytes!("intermediate-data.json"))?;
28    let mut document = compiler.bind(&template, &data, &[])?;
29    let mut log = OperationLog::new_bounded(8, 8 * 1024 * 1024)?;
30    let patch = Patch {
31        sequence: 1,
32        operations: vec![PatchOperation::Move {
33            id: ElementId::new("review-marker")?,
34            x: "185mm".parse()?,
35            y: "112mm".parse()?,
36        }],
37    };
38    log.apply(&mut document, &patch, limits.max_patch_operations)?;
39    let fonts = example_fonts()?;
40    let fingerprint = DocumentFingerprint::compute_with_patches(
41        &template,
42        &data,
43        std::slice::from_ref(&patch),
44        None,
45        &fonts,
46        &limits,
47    )?;
48    let engine = LayoutEngine::new(&limits, &fonts, LayoutOptions::default())?;
49    let mut cache = SceneCache::with_byte_capacity(8, 64 * 1024 * 1024)?;
50    let scene = engine.resolve_cached(&document, fingerprint, &mut cache)?;
51    let cached = engine.resolve_cached(&document, fingerprint, &mut cache)?;
52    if !Arc::ptr_eq(&scene, &cached) || scene.pages.len() != 2 {
53        return Err(std::io::Error::other("expected one cached two-page scene").into());
54    }
55
56    let pdf_request = ExportRequest {
57        format: ExportFormat::Pdf,
58        pdf_mode: PdfMode::Editable,
59        ..ExportRequest::default()
60    };
61    let context = ExportContext {
62        limits: &limits,
63        fonts: &fonts,
64        assets: None,
65    };
66    let report = preflight(
67        &scene,
68        &pdf_request,
69        &context,
70        &PreflightOptions {
71            strict: true,
72            ..PreflightOptions::default()
73        },
74        &OperationControl::default(),
75    )?;
76    report.enforce(true)?;
77    let (pdf, pdf_outcome) = export_bytes(&scene, &pdf_request, &context)?;
78    let (html, html_outcome) = export_bytes(
79        &scene,
80        &ExportRequest {
81            format: ExportFormat::Html,
82            html_mode: HtmlMode::Fixed,
83            ..ExportRequest::default()
84        },
85        &context,
86    )?;
87    let (page_one_svg, page_one_outcome) = export_svg_page(&scene, 0, &context)?;
88    let (page_two_svg, page_two_outcome) = export_svg_page(&scene, 1, &context)?;
89
90    let pdf_path = output_path("intermediate.pdf")?;
91    let html_path = output_path("intermediate.html")?;
92    let page_one_path = output_path("intermediate-page-1.svg")?;
93    let page_two_path = output_path("intermediate-page-2.svg")?;
94    let report_path = output_path("intermediate-preflight.json")?;
95    std::fs::write(&pdf_path, pdf)?;
96    std::fs::write(&html_path, html)?;
97    std::fs::write(&page_one_path, page_one_svg)?;
98    std::fs::write(&page_two_path, page_two_svg)?;
99    std::fs::write(&report_path, serde_json::to_vec_pretty(&report)?)?;
100    let inspector = SceneInspector::new(&scene);
101    println!(
102        "pages={} roles={:?}/{:?} undo={} pdf_bytes={} html_bytes={} svg_bytes={}/{}\npdf={}\nhtml={}\npage_1={}\npage_2={}\npreflight={}",
103        scene.pages.len(),
104        inspector.inspect_page(0)?.role,
105        inspector.inspect_page(1)?.role,
106        log.undo_len(),
107        pdf_outcome.bytes_written,
108        html_outcome.bytes_written,
109        page_one_outcome.bytes_written,
110        page_two_outcome.bytes_written,
111        pdf_path.display(),
112        html_path.display(),
113        page_one_path.display(),
114        page_two_path.display(),
115        report_path.display()
116    );
117    Ok(())
118}

Source

pub fn bind( &self, template: &TemplateIr, data: &DataValue, patches: &[Patch], ) -> Result<DocumentIr>

Binds one data instance and applies ordered patch transactions.

Examples found in repository ?

examples/basic.rs (line 23)

18fn main() -> Result<(), Box<dyn std::error::Error>> {
19    let limits = ResourceLimits::default();
20    let compiler = Compiler::builder().limits(limits.clone()).build()?;
21    let template = compiler.compile_template_yaml(include_bytes!("basic.yml"))?;
22    let data: DataValue = serde_json::from_slice(include_bytes!("basic-data.json"))?;
23    let document = compiler.bind(&template, &data, &[])?;
24    let fonts = example_fonts()?;
25    let scene = LayoutEngine::new(&limits, &fonts, LayoutOptions::default())?.resolve(&document)?;
26    let (output, outcome) = export_bytes(
27        &scene,
28        &ExportRequest {
29            format: ExportFormat::Svg,
30            ..ExportRequest::default()
31        },
32        &ExportContext {
33            limits: &limits,
34            fonts: &fonts,
35            assets: None,
36        },
37    )?;
38    let output_path = output_path("basic.svg")?;
39    std::fs::write(&output_path, output)?;
40    println!(
41        "pages={} svg_bytes={} output={}",
42        scene.pages.len(),
43        outcome.bytes_written,
44        output_path.display()
45    );
46    Ok(())
47}

More examples

Hide additional examples

examples/intermediate.rs (line 28)

23fn main() -> Result<(), Box<dyn std::error::Error>> {
24    let limits = ResourceLimits::default();
25    let compiler = Compiler::builder().limits(limits.clone()).build()?;
26    let template = compiler.compile_template_yaml(include_bytes!("intermediate.yml"))?;
27    let data: DataValue = serde_json::from_slice(include_bytes!("intermediate-data.json"))?;
28    let mut document = compiler.bind(&template, &data, &[])?;
29    let mut log = OperationLog::new_bounded(8, 8 * 1024 * 1024)?;
30    let patch = Patch {
31        sequence: 1,
32        operations: vec![PatchOperation::Move {
33            id: ElementId::new("review-marker")?,
34            x: "185mm".parse()?,
35            y: "112mm".parse()?,
36        }],
37    };
38    log.apply(&mut document, &patch, limits.max_patch_operations)?;
39    let fonts = example_fonts()?;
40    let fingerprint = DocumentFingerprint::compute_with_patches(
41        &template,
42        &data,
43        std::slice::from_ref(&patch),
44        None,
45        &fonts,
46        &limits,
47    )?;
48    let engine = LayoutEngine::new(&limits, &fonts, LayoutOptions::default())?;
49    let mut cache = SceneCache::with_byte_capacity(8, 64 * 1024 * 1024)?;
50    let scene = engine.resolve_cached(&document, fingerprint, &mut cache)?;
51    let cached = engine.resolve_cached(&document, fingerprint, &mut cache)?;
52    if !Arc::ptr_eq(&scene, &cached) || scene.pages.len() != 2 {
53        return Err(std::io::Error::other("expected one cached two-page scene").into());
54    }
55
56    let pdf_request = ExportRequest {
57        format: ExportFormat::Pdf,
58        pdf_mode: PdfMode::Editable,
59        ..ExportRequest::default()
60    };
61    let context = ExportContext {
62        limits: &limits,
63        fonts: &fonts,
64        assets: None,
65    };
66    let report = preflight(
67        &scene,
68        &pdf_request,
69        &context,
70        &PreflightOptions {
71            strict: true,
72            ..PreflightOptions::default()
73        },
74        &OperationControl::default(),
75    )?;
76    report.enforce(true)?;
77    let (pdf, pdf_outcome) = export_bytes(&scene, &pdf_request, &context)?;
78    let (html, html_outcome) = export_bytes(
79        &scene,
80        &ExportRequest {
81            format: ExportFormat::Html,
82            html_mode: HtmlMode::Fixed,
83            ..ExportRequest::default()
84        },
85        &context,
86    )?;
87    let (page_one_svg, page_one_outcome) = export_svg_page(&scene, 0, &context)?;
88    let (page_two_svg, page_two_outcome) = export_svg_page(&scene, 1, &context)?;
89
90    let pdf_path = output_path("intermediate.pdf")?;
91    let html_path = output_path("intermediate.html")?;
92    let page_one_path = output_path("intermediate-page-1.svg")?;
93    let page_two_path = output_path("intermediate-page-2.svg")?;
94    let report_path = output_path("intermediate-preflight.json")?;
95    std::fs::write(&pdf_path, pdf)?;
96    std::fs::write(&html_path, html)?;
97    std::fs::write(&page_one_path, page_one_svg)?;
98    std::fs::write(&page_two_path, page_two_svg)?;
99    std::fs::write(&report_path, serde_json::to_vec_pretty(&report)?)?;
100    let inspector = SceneInspector::new(&scene);
101    println!(
102        "pages={} roles={:?}/{:?} undo={} pdf_bytes={} html_bytes={} svg_bytes={}/{}\npdf={}\nhtml={}\npage_1={}\npage_2={}\npreflight={}",
103        scene.pages.len(),
104        inspector.inspect_page(0)?.role,
105        inspector.inspect_page(1)?.role,
106        log.undo_len(),
107        pdf_outcome.bytes_written,
108        html_outcome.bytes_written,
109        page_one_outcome.bytes_written,
110        page_two_outcome.bytes_written,
111        pdf_path.display(),
112        html_path.display(),
113        page_one_path.display(),
114        page_two_path.display(),
115        report_path.display()
116    );
117    Ok(())
118}