Decoupled function parser 🔗 [WIP]

1 files changed, 36 insertions, 23 deletions

diff --git a/tests/src/layouter.rs b/tests/src/layouter.rs
index eeca1a1b..95eea204 100644
--- a/tests/src/layouter.rs
+++ b/tests/src/layouter.rs
@@ -10,8 +10,8 @@ use futures_executor::block_on;
 
 use typstc::Typesetter;
 use typstc::layout::{MultiLayout, Serialize};
-use typstc::size::{Size, Size2D};
-use typstc::style::PageStyle;
+use typstc::size::{Size, Size2D, ValueBox};
+use typstc::style::{PageStyle, PaperClass};
 use typstc::toddle::query::FileSystemFontProvider;
 use typstc::export::pdf::PdfExporter;
 
@@ -62,14 +62,15 @@ fn main() -> DynResult<()> {
     Ok(())
 }
 
-/// Create a _PDF_ with a name from the source code.
+/// Create a _PDF_ and render with a name from the source code.
 fn test(name: &str, src: &str) -> DynResult<()> {
     println!("Testing: {}.", name);
 
     let mut typesetter = Typesetter::new();
     typesetter.set_page_style(PageStyle {
+        class: PaperClass::Custom,
         dimensions: Size2D::with_all(Size::pt(250.0)),
-        .. PageStyle::default()
+        margins: ValueBox::with_all(None),
     });
 
     let provider = FileSystemFontProvider::from_index("../fonts/index.json")?;
@@ -120,31 +121,43 @@ fn test(name: &str, src: &str) -> DynResult<()> {
 
 /// Compile the source code with the typesetter.
 fn compile(typesetter: &Typesetter, src: &str) -> MultiLayout {
-    #[cfg(not(debug_assertions))] {
-        use std::time::Instant;
+    #![allow(unused_variables)]
+    use std::time::Instant;
 
-        // Warmup.
+    // Warmup.
+    #[cfg(not(debug_assertions))]
+    let warmup = {
         let warmup_start = Instant::now();
         block_on(typesetter.typeset(&src));
-        let warmup_end = Instant::now();
-
-        let start = Instant::now();
-        let tree = typesetter.parse(&src).output;
-        let mid = Instant::now();
-        let layouts = block_on(typesetter.layout(&tree)).output;
-        let end = Instant::now();
-
-        println!(" - cold start:  {:?}", warmup_end - warmup_start);
-        println!(" - warmed up:   {:?}", end - start);
-        println!("   - parsing:   {:?}", mid - start);
-        println!("   - layouting: {:?}", end - mid);
-        println!();
+        Instant::now() - warmup_start
+    };
+
+    let start = Instant::now();
+    let parsed = typesetter.parse(&src);
+    let parse = Instant::now() - start;
+
+    if !parsed.errors.is_empty() {
+        println!("parse errors: {:#?}", parsed.errors);
+    }
 
-        layouts
+    let start_layout = Instant::now();
+    let layouted = block_on(typesetter.layout(&parsed.output));
+    let layout = Instant::now() - start_layout;
+    let total = Instant::now() - start;
+
+    if !layouted.errors.is_empty() {
+        println!("layout errors: {:#?}", layouted.errors);
+    }
+
+    #[cfg(not(debug_assertions))] {
+        println!(" - cold start:  {:?}", warmup);
+        println!(" - warmed up:   {:?}", total);
+        println!("   - parsing:   {:?}", parse);
+        println!("   - layouting: {:?}", layout);
+        println!();
     }
 
-    #[cfg(debug_assertions)]
-    block_on(typesetter.typeset(&src))
+    layouted.output
 }
 
 /// Command line options.