typst-rb 0.15.0.0.3

data/ext/typst/src/compiler.rs

@@ -0,0 +1,257 @@
+use chrono::{Datelike, Timelike};
+use codespan_reporting::diagnostic::{Diagnostic, Label};
+use codespan_reporting::term::{self, termcolor};
+use ecow::{eco_format, EcoString};
+use typst::diag::{At, Severity, SourceDiagnostic, StrResult, Warned};
+use typst::foundations::Datetime;
+use typst_html::HtmlDocument;
+use typst_layout::PagedDocument;
+use typst::syntax::{DiagSpan, FileId, Lines, Span};
+use typst::{World, WorldExt};
+
+use crate::world::SystemWorld;
+
+type CodespanResult<T> = Result<T, CodespanError>;
+type CodespanError = codespan_reporting::files::Error;
+
+impl SystemWorld {
+    pub fn compile(
+        &mut self,
+        format: Option<&str>,
+        ppi: Option<f32>,
+        pdf_standards: &[typst_pdf::PdfStandard],
+    ) -> StrResult<Vec<Vec<u8>>> {
+        // Reset everything and ensure that the main file is present.
+        self.reset();
+        self.source(self.main()).map_err(|err| err.to_string())?;
+
+        match format.unwrap_or_else(|| "pdf").to_ascii_lowercase().as_str() {
+            "html" => {
+                let Warned { output, warnings } = typst::compile::<HtmlDocument>(self);
+                match output {
+                    Ok(document) => {
+                        Ok(vec![export_html(&document, self)?])
+                    }
+                    Err(errors) => Err(format_diagnostics(self, &errors, &warnings).unwrap().into()),
+                }
+            }
+            _ => {
+                let Warned { output, warnings } = typst::compile::<PagedDocument>(self);
+                match output {
+                    // Export the PDF / PNG.
+                    Ok(document) => {
+                        // Assert format is "pdf" or "png" or "svg"
+                        match format.unwrap_or("pdf").to_ascii_lowercase().as_str() {
+                            "pdf" => Ok(vec![export_pdf(
+                                &document,
+                                self,
+                                typst_pdf::PdfStandards::new(pdf_standards)
+                                    .map_err(|e| eco_format!("PDF standards error: {:?}", e))
+                                    .at(Span::detached()).unwrap()
+                            )?]),
+                            "png" => Ok(export_image(&document, ImageExportFormat::Png, ppi)?),
+                            "svg" => Ok(export_image(&document, ImageExportFormat::Svg, ppi)?),
+                            fmt => Err(eco_format!("unknown format: {fmt}")),
+                        }
+                    }
+                    Err(errors) => Err(format_diagnostics(self, &errors, &warnings).unwrap().into()),
+                }
+            }
+        }
+    }
+}
+
+/// Export to a PDF.
+#[inline]
+fn export_html(
+    document: &HtmlDocument,
+    world: &SystemWorld,
+) -> StrResult<Vec<u8>> {
+    let html = typst_html::html(document, &typst_html::HtmlOptions::default())
+    .map_err(|e| match format_diagnostics(world, &e, &[]) {
+        Ok(e) => EcoString::from(e),
+        Err(err) => eco_format!("failed to print diagnostics ({err})"),
+    })?;
+    let buffer = html.as_bytes().to_vec();
+    Ok(buffer)
+}
+
+/// Export to a PDF.
+#[inline]
+fn export_pdf(
+    document: &PagedDocument,
+    world: &SystemWorld,
+    standards: typst_pdf::PdfStandards,
+) -> StrResult<Vec<u8>> {
+    let buffer = typst_pdf::pdf(
+        document,
+        &typst_pdf::PdfOptions {
+            ident: typst::foundations::Smart::Auto,
+            timestamp: now().map(typst_pdf::Timestamp::new_utc),
+            standards,
+            ..Default::default()
+        },
+    )
+    .map_err(|e| match format_diagnostics(world, &e, &[]) {
+        Ok(e) => EcoString::from(e),
+        Err(err) => eco_format!("failed to print diagnostics ({err})"),
+    })?;
+    Ok(buffer.into())
+}
+
+/// Get the current date and time in UTC.
+fn now() -> Option<Datetime> {
+    let now = chrono::Local::now().naive_utc();
+    Datetime::from_ymd_hms(
+        now.year(),
+        now.month().try_into().ok()?,
+        now.day().try_into().ok()?,
+        now.hour().try_into().ok()?,
+        now.minute().try_into().ok()?,
+        now.second().try_into().ok()?,
+    )
+}
+
+/// An image format to export in.
+enum ImageExportFormat {
+    Png,
+    Svg,
+}
+
+/// Export the frames to PNGs or SVGs.
+fn export_image(
+    document: &PagedDocument,
+    fmt: ImageExportFormat,
+    ppi: Option<f32>,
+) -> StrResult<Vec<Vec<u8>>> {
+    let mut buffers = Vec::new();
+    for page in document.pages() {
+        let buffer = match fmt {
+            ImageExportFormat::Png => typst_render::render(
+                page,
+                &typst_render::RenderOptions {
+                    pixel_per_pt: typst::utils::Scalar::new(f64::from(ppi.unwrap_or(144.0) / 72.0)),
+                    render_bleed: false,
+                },
+            )
+            .encode_png()
+            .map_err(|err| eco_format!("failed to write PNG file ({err})"))?,
+            ImageExportFormat::Svg => {
+                let svg = typst_svg::svg(page, &typst_svg::SvgOptions::default());
+                svg.as_bytes().to_vec()
+            }
+        };
+        buffers.push(buffer);
+    }
+    Ok(buffers)
+}
+
+/// Format diagnostic messages.\
+pub fn format_diagnostics(
+    world: &SystemWorld,
+    errors: &[SourceDiagnostic],
+    warnings: &[SourceDiagnostic],
+) -> Result<String, codespan_reporting::files::Error> {
+    let mut w = termcolor::Buffer::no_color();
+
+    let config = term::Config {
+        tab_width: 2,
+        ..Default::default()
+    };
+
+    for diagnostic in warnings.iter().chain(errors.iter()) {
+        let diag = match diagnostic.severity {
+            Severity::Error => Diagnostic::error(),
+            Severity::Warning => Diagnostic::warning(),
+        }
+        .with_message(diagnostic.message.clone())
+        .with_notes(
+            diagnostic
+                .hints
+                .iter()
+                .map(|e| (eco_format!("hint: {}", e.v)).into())
+                .collect(),
+        )
+        .with_labels(label(world, diagnostic.span).into_iter().collect());
+
+        term::emit_to_write_style(&mut w, &config, world, &diag)?;
+
+        // Stacktrace-like helper diagnostics.
+        for point in &diagnostic.trace {
+            let message = point.v.to_string();
+            let help = Diagnostic::help()
+                .with_message(message)
+                .with_labels(label(world, point.span).into_iter().collect());
+
+            term::emit_to_write_style(&mut w, &config, world, &help)?;
+        }
+    }
+
+    let s = String::from_utf8(w.into_inner()).unwrap();
+    Ok(s)
+}
+
+/// Create a label for a span.
+fn label(world: &SystemWorld, span: impl Into<DiagSpan>) -> Option<Label<FileId>> {
+    let span = span.into();
+    Some(Label::primary(span.id()?, world.range(span)?))
+}
+
+impl<'a> codespan_reporting::files::Files<'a> for SystemWorld {
+    type FileId = FileId;
+    type Name = String;
+    type Source = Lines<String>;
+
+    fn name(&'a self, id: FileId) -> CodespanResult<Self::Name> {
+        let vpath = id.vpath();
+        Ok(if let typst::syntax::VirtualRoot::Package(package) = id.root() {
+            format!("{package}{}", vpath.get_with_slash())
+        } else {
+            // Try to express the path relative to the working directory.
+            vpath
+                .realize(self.root())
+                .ok()
+                .and_then(|abs| pathdiff::diff_paths(abs, self.workdir()))
+                .as_deref()
+                .unwrap_or_else(|| std::path::Path::new(vpath.get_without_slash()))
+                .to_string_lossy()
+                .into()
+        })
+    }
+
+    fn source(&'a self, id: FileId) -> CodespanResult<Self::Source> {
+        Ok(self.lookup(id))
+    }
+
+    fn line_index(&'a self, id: FileId, given: usize) -> CodespanResult<usize> {
+        let source = self.lookup(id);
+        source
+            .byte_to_line(given)
+            .ok_or_else(|| CodespanError::IndexTooLarge {
+                given,
+                max: source.len_bytes(),
+            })
+    }
+
+    fn line_range(&'a self, id: FileId, given: usize) -> CodespanResult<std::ops::Range<usize>> {
+        let source = self.lookup(id);
+        source
+            .line_to_range(given)
+            .ok_or_else(|| CodespanError::LineTooLarge {
+                given,
+                max: source.len_lines(),
+            })
+    }
+
+    fn column_number(&'a self, id: FileId, _: usize, given: usize) -> CodespanResult<usize> {
+        let source = self.lookup(id);
+        source.byte_to_column(given).ok_or_else(|| {
+            let max = source.len_bytes();
+            if given <= max {
+                CodespanError::InvalidCharBoundary { given }
+            } else {
+                CodespanError::IndexTooLarge { given, max }
+            }
+        })
+    }
+}

data/ext/typst/src/download.rs

@@ -0,0 +1,7 @@
+use typst_kit::downloader::{Downloader, SystemDownloader};
+
+/// Returns a new downloader.
+pub fn downloader() -> impl Downloader {
+    let user_agent = concat!("typst-rb/", env!("CARGO_PKG_VERSION"));
+    SystemDownloader::new(user_agent)
+}

data/ext/typst/src/lib.rs

@@ -0,0 +1,296 @@
+use std::path::PathBuf;
+
+use magnus::{function, prelude::*, Error, Ruby};
+
+use std::collections::HashMap;
+use query::{query as typst_query, QueryCommand, SerializationFormat};
+use typst::foundations::{Dict, Value};
+use typst_library::Feature;
+use typst_pdf::PdfStandard;
+use world::SystemWorld;
+
+mod compiler;
+mod download;
+mod query;
+mod world;
+
+fn to_html(
+    ruby: &Ruby,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<Vec<Vec<u8>>, Error> {
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let mut features = Vec::new();
+    features.push(Feature::Html);
+
+    let feat = features.iter()
+    .map(|&feature|
+        match feature {
+            Feature::Html => typst::Feature::Html,
+            _ => typst::Feature::Html // TODO: fix this hack
+        }
+    )
+    .collect();
+
+    let mut world = SystemWorld::builder(root, input)
+        .inputs(Dict::from_iter(
+            sys_inputs
+                .into_iter()
+                .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+        ))
+        .features(feat)
+        .font_paths(font_paths)
+        .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
+        .build()
+        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+
+    let bytes = world
+        .compile(Some("html"), None, &Vec::new())
+        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+
+    Ok(bytes)
+}
+
+fn to_svg(
+    ruby: &Ruby,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<Vec<Vec<u8>>, Error> {
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let mut world = SystemWorld::builder(root, input)
+        .inputs(Dict::from_iter(
+            sys_inputs
+                .into_iter()
+                .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+        ))
+        .font_paths(font_paths)
+        .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
+        .build()
+        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+
+    let svg_bytes = world
+        .compile(Some("svg"), None, &Vec::new())
+        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+
+    Ok(svg_bytes)
+}
+
+fn to_png(
+    ruby: &Ruby,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+    ppi: Option<f32>,
+) -> Result<Vec<Vec<u8>>, Error> {
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let mut world = SystemWorld::builder(root, input)
+        .inputs(Dict::from_iter(
+            sys_inputs
+                .into_iter()
+                .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+        ))
+        .font_paths(font_paths)
+        .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
+        .build()
+        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+
+    let bytes = world
+        .compile(Some("png"), ppi, &Vec::new())
+        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+
+    Ok(bytes)
+}
+
+fn to_pdf(
+    ruby: &Ruby,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+    pdf_standards: Vec<String>,
+) -> Result<Vec<Vec<u8>>, Error> {
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let mut world = SystemWorld::builder(root, input)
+        .inputs(Dict::from_iter(
+            sys_inputs
+                .into_iter()
+                .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+        ))
+        .font_paths(font_paths)
+        .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
+        .build()
+        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+
+    let pdf_standards_lookup: HashMap::<&str, PdfStandard> = HashMap::from([
+        ("1.4", PdfStandard::V_1_4),
+        ("1.5", PdfStandard::V_1_5),
+        ("1.6", PdfStandard::V_1_6),
+        ("1.7", PdfStandard::V_1_7),
+        ("2.0", PdfStandard::V_2_0),
+        ("a-1a", PdfStandard::A_1a),
+        ("a-1b", PdfStandard::A_1b),
+        ("a-2a", PdfStandard::A_2a),
+        ("a-2b", PdfStandard::A_2b),
+        ("a-2u", PdfStandard::A_2u),
+        ("a-3a", PdfStandard::A_3a),
+        ("a-3b", PdfStandard::A_3b),
+        ("a-3u", PdfStandard::A_3u),
+        ("a-4", PdfStandard::A_4),
+        ("a-4e", PdfStandard::A_4e),
+        ("a-4f", PdfStandard::A_4f),
+        ("ua-1", PdfStandard::Ua_1),
+    ]);
+
+    let mut pdf_standards_vec = Vec::<PdfStandard>::new();
+    for pdf_standard in pdf_standards.iter() {
+        let result = pdf_standards_lookup.get(pdf_standard.as_str());
+        match result {
+            Some(value) => pdf_standards_vec.push(*value),
+            _ => return Err(magnus::Error::new(ruby.exception_arg_error(), "Unknown PdfStandard")),
+        }
+    }
+
+    let pdf_bytes = world
+        .compile(Some("pdf"), None, &pdf_standards_vec)
+        .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+
+    Ok(pdf_bytes)
+}
+
+fn query(
+    ruby: &Ruby,
+    selector: String,
+    field: Option<String>,
+    one: bool,
+    format: Option<String>,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<String, Error> {
+    let format = match format.unwrap().to_ascii_lowercase().as_str() {
+        "json" => SerializationFormat::Json,
+        "yaml" => SerializationFormat::Yaml,
+        _ => return Err(magnus::Error::new(ruby.exception_arg_error(), "unsupported serialization format"))?,
+    };
+
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+
+    let mut world = SystemWorld::builder(root, input)
+    .inputs(Dict::from_iter(
+        sys_inputs
+            .into_iter()
+            .map(|(k, v)| (k.into(), Value::Str(v.into()))),
+    ))
+    .font_paths(font_paths)
+    .ignore_system_fonts(ignore_system_fonts)
+    .ignore_embedded_fonts(ignore_embedded_fonts)
+    .build()
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
+
+    let result = typst_query(
+        &mut world,
+        &QueryCommand {
+            selector: selector.into(),
+            field: field.map(Into::into),
+            one,
+            format,
+        },
+    );
+
+    match result {
+        Ok(data) => Ok(data),
+        Err(msg) => Err(magnus::Error::new(ruby.exception_arg_error(), msg.to_string())),
+    }
+}
+
+fn clear_cache(_ruby: &Ruby, max_age: usize) {
+    comemo::evict(max_age);
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    env_logger::init();
+
+    let module = ruby.define_module("Typst")?;
+    module.define_singleton_method("_to_pdf", function!(to_pdf, 7))?;
+    module.define_singleton_method("_to_svg", function!(to_svg, 6))?;
+    module.define_singleton_method("_to_png", function!(to_png, 7))?;
+    module.define_singleton_method("_to_html", function!(to_html, 6))?;
+    module.define_singleton_method("_query", function!(query, 10))?;
+    module.define_singleton_method("_clear_cache", function!(clear_cache, 1))?;
+    Ok(())
+}

data/ext/typst/src/package.rs

@@ -0,0 +1,64 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use ecow::eco_format;
+use typst::diag::{PackageError, PackageResult};
+use typst::syntax::PackageSpec;
+
+use crate::download::download;
+
+/// Make a package available in the on-disk cache.
+pub fn prepare_package(spec: &PackageSpec) -> PackageResult<PathBuf> {
+    let subdir = format!(
+        "typst/packages/{}/{}/{}",
+        spec.namespace, spec.name, spec.version
+    );
+
+    if let Some(data_dir) = dirs::data_dir() {
+        let dir = data_dir.join(&subdir);
+        if dir.exists() {
+            return Ok(dir);
+        }
+    }
+
+    if let Some(cache_dir) = dirs::cache_dir() {
+        let dir = cache_dir.join(&subdir);
+
+        // Download from network if it doesn't exist yet.
+        if spec.namespace == "preview" && !dir.exists() {
+            download_package(spec, &dir)?;
+        }
+
+        if dir.exists() {
+            return Ok(dir);
+        }
+    }
+
+    Err(PackageError::NotFound(spec.clone()))
+}
+
+/// Download a package over the network.
+fn download_package(spec: &PackageSpec, package_dir: &Path) -> PackageResult<()> {
+    // The `@preview` namespace is the only namespace that supports on-demand
+    // fetching.
+    assert_eq!(spec.namespace, "preview");
+
+    let url = format!(
+        "https://packages.typst.org/preview/{}-{}.tar.gz",
+        spec.name, spec.version
+    );
+
+    let data = match download(&url) {
+        Ok(data) => data,
+        Err(ureq::Error::Status(404, _)) => return Err(PackageError::NotFound(spec.clone())),
+        Err(err) => return Err(PackageError::NetworkFailed(Some(eco_format!("{err}")))),
+    };
+
+    let decompressed = flate2::read::GzDecoder::new(data.as_slice());
+    tar::Archive::new(decompressed)
+        .unpack(package_dir)
+        .map_err(|err| {
+            fs::remove_dir_all(package_dir).ok();
+            PackageError::MalformedArchive(Some(eco_format!("{err}")))
+        })
+}