typst 0.14.2.3 → 0.15.1.0

data/ext/typst/src/query.rs

@@ -3,8 +3,10 @@ use ecow::{eco_format, EcoString};
 use serde::Serialize;
 use typst::diag::{bail, StrResult, Warned};
 use typst::engine::Sink;
-use typst::foundations::{Content, IntoValue, LocatableSelector, Scope};
-use typst::layout::PagedDocument;
+use typst::foundations::{Content, Context, IntoValue, LocatableSelector, Scope};
+use typst::introspection::{EmptyIntrospector, Introspector};
+use typst::routines::SpanMode;
+use typst_layout::PagedDocument;
 use typst::syntax::Span;
 use typst::syntax::SyntaxMode;
 use typst::World;
@@ -73,13 +75,15 @@ fn retrieve(
     document: &PagedDocument,
 ) -> StrResult<Vec<Content>> {
     let selector = eval_string(
-        &typst::ROUTINES,
         world.track(),
+        world.library(),
         Sink::new().track_mut(),
+        EmptyIntrospector.track(),
+        Context::none().track(),
         &command.selector,
-        Span::detached(),
+        SpanMode::Uniform(Span::detached()),
         SyntaxMode::Code,
-        Scope::default(),
+        Scope::default()
     )
     .map_err(|errors| {
         let mut message = EcoString::from("failed to evaluate selector");
@@ -93,7 +97,7 @@ fn retrieve(
     .map_err(|e| e.message().clone())?;
 
     Ok(document
-        .introspector
+        .introspector()
         .query(&selector.0)
         .into_iter()
         .collect::<Vec<_>>())

data/ext/typst/src/world.rs

@@ -1,44 +1,34 @@
 use std::fs;
 use std::path::{Path, PathBuf};
-use std::sync::{Mutex, OnceLock};
+use std::sync::{Arc, Mutex, OnceLock};
+use std::collections::HashMap;
 
-use chrono::{DateTime, Datelike, Local};
-use ecow::eco_format;
+use chrono::{DateTime, Datelike, FixedOffset, Local};
 use typst::diag::{FileError, FileResult, StrResult};
-use typst::foundations::{Bytes, Datetime, Dict};
-use typst::syntax::{FileId, Lines, Source, VirtualPath};
+use typst::foundations::{Bytes, Datetime, Dict, Duration};
+use typst::syntax::{FileId, Lines, Source, VirtualPath, VirtualRoot, RootedPath};
 use typst::text::{Font, FontBook};
 use typst::utils::LazyHash;
 use typst::{Features, Library, LibraryExt, World};
-use typst_kit::{
-    fonts::{FontSearcher, FontSlot},
-    package::PackageStorage,
-};
-
-use std::collections::HashMap;
-
-use crate::download::SlientDownload;
+use typst_kit::fonts::{self, FontStore};
+use typst_kit::packages::{FsPackages, SystemPackages, UniversePackages};
 
 /// A world that provides access to the operating system.
 pub struct SystemWorld {
     /// The working directory.
     workdir: Option<PathBuf>,
-    /// The canonical path to the input file.
-    input: PathBuf,
     /// The root relative to which absolute paths are resolved.
     root: PathBuf,
     /// The input path.
     main: FileId,
     /// Typst's standard library.
     library: LazyHash<Library>,
-    /// Metadata about discovered fonts.
-    book: LazyHash<FontBook>,
     /// Locations of and storage for lazily loaded fonts.
-    fonts: Vec<FontSlot>,
+    fonts: Arc<FontStore>,
     /// Maps file ids to source files and buffers.
     slots: Mutex<HashMap<FileId, FileSlot>>,
     /// Holds information about where packages are stored.
-    package_storage: PackageStorage,
+    package_storage: SystemPackages,
     /// The current datetime if requested. This is stored here to ensure it is
     /// always the same within one compilation. Reset between compilations.
     now: OnceLock<DateTime<Local>>,
@@ -50,7 +40,7 @@ impl World for SystemWorld {
     }
 
     fn book(&self) -> &LazyHash<FontBook> {
-        &self.book
+        &self.fonts.book()
     }
 
     fn main(&self) -> FileId {
@@ -66,21 +56,30 @@ impl World for SystemWorld {
     }
 
     fn font(&self, index: usize) -> Option<Font> {
-        self.fonts[index].get()
+        self.fonts.font(index)
     }
 
-    fn today(&self, offset: Option<i64>) -> Option<Datetime> {
+    fn today(&self, offset: Option<Duration>) -> Option<Datetime> {
         let now = self.now.get_or_init(chrono::Local::now);
 
-        let naive = match offset {
-            None => now.naive_local(),
-            Some(o) => now.naive_utc() + chrono::Duration::hours(o),
+        let now = match offset {
+            None => now.fixed_offset(),
+            Some(offset) => {
+                let seconds = offset.seconds().trunc();
+                if !seconds.is_finite()
+                    || seconds < f64::from(i32::MIN)
+                    || seconds > f64::from(i32::MAX)
+                {
+                    return None;
+                }
+                now.with_timezone(&FixedOffset::east_opt(seconds as i32)?)
+            }
         };
 
         Datetime::from_ymd(
-            naive.year(),
-            naive.month().try_into().ok()?,
-            naive.day().try_into().ok()?,
+            now.year(),
+            now.month().try_into().ok()?,
+            now.day().try_into().ok()?,
         )
     }
 }
@@ -122,23 +121,20 @@ impl SystemWorld {
         self.now.take();
     }
 
-    /// Return the canonical path to the input file.
-    pub fn input(&self) -> &PathBuf {
-        &self.input
-    }
-
     /// Lookup a source file by id.
     #[track_caller]
     pub fn lookup(&self, id: FileId) -> Lines<String> {
-//        self.source(id)
-//            .expect("file id does not point to any source file")
         self.slot(id, |slot| {
             if let Some(source) = slot.source.get() {
                 let source = source.as_ref().expect("file is not valid");
                 source.lines().clone()
             } else if let Some(bytes) = slot.file.get() {
                 let bytes = bytes.as_ref().expect("file is not valid");
-                Lines::try_from(bytes).expect("file is not valid utf-8")
+                Lines::new(
+                    decode_utf8(bytes.as_slice())
+                        .expect("file is not valid utf-8")
+                        .to_string(),
+                )
             } else {
                 panic!("file id does not point to any source file");
             }
@@ -151,8 +147,11 @@ pub struct SystemWorldBuilder {
     main: PathBuf,
     font_paths: Vec<PathBuf>,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     inputs: Dict,
     features: Features,
+    package_path: Option<PathBuf>,
+    package_cache_path: Option<PathBuf>,
 }
 
 impl SystemWorldBuilder {
@@ -162,8 +161,11 @@ impl SystemWorldBuilder {
             main,
             font_paths: Vec::new(),
             ignore_system_fonts: false,
+            ignore_embedded_fonts: false,
             inputs: Dict::default(),
             features: Features::default(),
+            package_path: None,
+            package_cache_path: None,
         }
     }
 
@@ -177,6 +179,11 @@ impl SystemWorldBuilder {
         self
     }
 
+    pub fn ignore_embedded_fonts(mut self, ignore: bool) -> Self {
+        self.ignore_embedded_fonts = ignore;
+        self
+    }
+
     pub fn inputs(mut self, inputs: Dict) -> Self {
         self.inputs = inputs;
         self
@@ -188,33 +195,57 @@ impl SystemWorldBuilder {
     }
 
     pub fn build(self) -> StrResult<SystemWorld> {
-        let fonts = FontSearcher::new()
-            .include_system_fonts(!self.ignore_system_fonts)
-            .search_with(&self.font_paths);
+        let fonts = Arc::new(build_font_store(self.ignore_system_fonts, self.ignore_embedded_fonts, self.font_paths));
+
+        let package_storage = system_packages(self.package_path, self.package_cache_path);
 
-        let input = self.main.canonicalize().map_err(|_| {
-            eco_format!("input file not found (searched at {})", self.main.display())
-        })?;
         // Resolve the virtual path of the main file within the project root.
-        let main_path = VirtualPath::within_root(&self.main, &self.root)
-            .ok_or("input file must be contained in project root")?;
+        let main_path = VirtualPath::virtualize(&self.root, &self.main)
+            .map_err(|_| "input file must be contained in project root")?;
 
         let world = SystemWorld {
             workdir: std::env::current_dir().ok(),
-            input,
             root: self.root,
-            main: FileId::new(None, main_path),
+            main: RootedPath::new(VirtualRoot::Project, main_path).intern(),
             library: LazyHash::new(Library::builder().with_inputs(self.inputs).with_features(self.features).build()),
-            book: LazyHash::new(fonts.book),
-            fonts: fonts.fonts,
+            fonts,
             slots: Mutex::default(),
-            package_storage: PackageStorage::new(None, None, crate::download::downloader()),
+            package_storage,
             now: OnceLock::new(),
         };
         Ok(world)
     }
 }
 
+fn build_font_store(ignore_system_fonts: bool, ignore_embedded_fonts: bool, font_paths: Vec<PathBuf>) -> FontStore {
+    let mut fonts = FontStore::new();
+    if !ignore_system_fonts {
+        fonts.extend(fonts::system());
+    }
+    if !ignore_embedded_fonts {
+        fonts.extend(fonts::embedded());
+    }
+    for path in font_paths {
+        fonts.extend(fonts::scan(&path));
+    }
+    fonts
+}
+
+fn system_packages(
+    package_path: Option<PathBuf>,
+    package_cache_path: Option<PathBuf>,
+) -> SystemPackages {
+    SystemPackages::from_parts(
+        package_path
+            .map(FsPackages::new)
+            .or_else(FsPackages::system_data),
+        package_cache_path
+            .map(FsPackages::new)
+            .or_else(FsPackages::system_cache),
+        UniversePackages::new(crate::download::downloader()),
+    )
+}
+
 /// Holds canonical data for all paths pointing to the same entity.
 ///
 /// Both fields can be populated if the file is both imported and read().
@@ -244,7 +275,7 @@ impl FileSlot {
         self.file.reset();
     }
 
-    fn source(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Source> {
+    fn source(&mut self, root: &Path, package_storage: &SystemPackages) -> FileResult<Source> {
         let id = self.id;
         self.source.get_or_init(
             || system_path(root, id, package_storage),
@@ -260,7 +291,7 @@ impl FileSlot {
         )
     }
 
-    fn file(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Bytes> {
+    fn file(&mut self, root: &Path, package_storage: &SystemPackages) -> FileResult<Bytes> {
         let id = self.id;
         self.file.get_or_init(
             || system_path(root, id, package_storage),
@@ -270,19 +301,21 @@ impl FileSlot {
 }
 
 /// The path of the slot on the system.
-fn system_path(root: &Path, id: FileId, package_storage: &PackageStorage) -> FileResult<PathBuf> {
+fn system_path(root: &Path, id: FileId, package_storage: &SystemPackages) -> FileResult<PathBuf> {
     // Determine the root path relative to which the file path
     // will be resolved.
-    let buf;
-    let mut root = root;
-    if let Some(spec) = id.package() {
-        buf = package_storage.prepare_package(spec, &mut SlientDownload(&spec))?;
-        root = &buf;
-    }
+    let package_root;
+    let root = match id.root() {
+        VirtualRoot::Project => root,
+        VirtualRoot::Package(spec) => {
+            package_root = package_storage.obtain(spec)?;
+            package_root.path()
+        }
+    };
 
     // Join the path to the root. If it tries to escape, deny
     // access. Note: It can still escape via symlinks.
-    id.vpath().resolve(root).ok_or(FileError::AccessDenied)
+    id.vpath().realize(root).map_err(Into::into)
 }
 
 /// Lazily processes data for a file.

data/lib/base.rb

@@ -34,19 +34,28 @@ module Typst
       options[:dependencies] ||= {}
       options[:fonts] ||= {}
       options[:sys_inputs] ||= {}
-      options[:resource_path] ||= File.dirname(__FILE__)
       options[:ignore_system_fonts] ||= false
+      options[:ignore_embedded_fonts] ||= false
+      options[:pretty] ||= false
     
       self.options = options
     end
 
+    def typst_options
+      [:file, :root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts]
+    end
+
     def typst_args
-      [options[:file], options[:root], options[:font_paths], options[:resource_path], options[:ignore_system_fonts], options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h]
+      options.values_at(*typst_options).append(options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h)
+    end
+
+    def typst_pretty_args
+      options.values_at(*typst_options, :pretty).append(options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h)
     end
 
     def typst_pdf_args
       options[:pdf_standards] ||= []
-      [*typst_args, options[:pdf_standards]]
+      [*typst_pretty_args, options[:pdf_standards]]
     end
 
     def typst_png_args
@@ -100,6 +109,16 @@ module Typst
       self
     end
 
+    def pretty(pretty = true)
+      self.options[:pretty] = pretty
+      self
+    end
+
+    def ugly(pretty = false)
+      self.pretty(pretty)
+      self
+    end
+
     def compile(format, **options)
       raise "Invalid format" if Typst::formats[format].nil?
 
@@ -125,14 +144,14 @@ module Typst
       query_options = { field: field, one: one, format: format }
 
       if self.options.has_key?(:file)
-        Typst::Query.new(selector, self.options[:file], **query_options.merge(self.options.slice(:root, :font_paths, :resource_path, :ignore_system_fonts, :sys_inputs)))
+        Typst::Query.new(selector, self.options[:file], **query_options.merge(self.options.slice(:root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :sys_inputs)))
       elsif self.options.has_key?(:body)
         Typst::build_world_from_s(self.options[:body], **self.options) do |opts|
-          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :resource_path, :ignore_system_fonts, :sys_inputs)))
+          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :sys_inputs)))
         end
       elsif self.options.has_key?(:zip)
         Typst::build_world_from_zip(self.options[:zip], **self.options) do |opts|
-          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :resource_path, :ignore_system_fonts, :sys_inputs)))
+          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :sys_inputs)))
         end
       else
         raise "No input given"

data/lib/formats/html_experimental.rb

@@ -2,7 +2,7 @@ module Typst
   class HtmlExperimental < Base
     def initialize(*options)
       super(*options)
-      @compiled = HtmlExperimentalDocument.new(Typst::_to_html(*self.typst_args))
+      @compiled = HtmlExperimentalDocument.new(Typst::_to_html(*self.typst_pretty_args))
     end
   end
   class HtmlExperimentalDocument < Document

data/lib/formats/svg.rb

@@ -2,7 +2,7 @@ module Typst
   class Svg < Base
     def initialize(*options)
       super(*options)
-      @compiled = SvgDocument.new(Typst::_to_svg(*self.typst_args))
+      @compiled = SvgDocument.new(Typst::_to_svg(*self.typst_pretty_args))
     end
   end
   class SvgDocument < Document

data/lib/query.rb

@@ -2,9 +2,9 @@ module Typst
   class Query < Base
     attr_accessor :format
 
-    def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], resource_path: ".", ignore_system_fonts: false, sys_inputs: {})
+    def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], ignore_system_fonts: false, ignore_embedded_fonts: false, sys_inputs: {})
       self.format = format
-      @result = Typst::_query(selector, field, one, format, input, root, font_paths, resource_path, ignore_system_fonts, sys_inputs)
+      @result = Typst::_query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, sys_inputs)
     end
 
     def result(raw: false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.14.2.3
+  version: 0.15.1.0
 platform: ruby
 authors:
 - Flinn
@@ -18,7 +18,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.124
+        version: 0.9.128
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,7 +28,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.124
+        version: 0.9.128
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -71,41 +71,15 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.6'
-- !ruby/object:Gem::Dependency
-  name: os
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-- !ruby/object:Gem::Dependency
-  name: pngcheck
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
 email: flinn@actsasflinn.com
 executables: []
 extensions:
 - ext/typst/extconf.rb
 extra_rdoc_files: []
 files:
+- Cargo.lock
 - Cargo.toml
+- LICENSE
 - README.md
 - README.typ
 - Rakefile
@@ -113,27 +87,12 @@ files:
 - ext/typst/extconf.rb
 - ext/typst/src/compiler.rs
 - ext/typst/src/download.rs
-- ext/typst/src/fonts.rs
 - ext/typst/src/lib.rs
 - ext/typst/src/package.rs
 - ext/typst/src/query.rs
 - ext/typst/src/world.rs
 - lib/base.rb
 - lib/document.rb
-- lib/fonts/DejaVuSansMono-Bold.ttf
-- lib/fonts/DejaVuSansMono-BoldOblique.ttf
-- lib/fonts/DejaVuSansMono-Oblique.ttf
-- lib/fonts/DejaVuSansMono.ttf
-- lib/fonts/LinLibertine_R.ttf
-- lib/fonts/LinLibertine_RB.ttf
-- lib/fonts/LinLibertine_RBI.ttf
-- lib/fonts/LinLibertine_RI.ttf
-- lib/fonts/NewCM10-Bold.otf
-- lib/fonts/NewCM10-BoldItalic.otf
-- lib/fonts/NewCM10-Italic.otf
-- lib/fonts/NewCM10-Regular.otf
-- lib/fonts/NewCMMath-Book.otf
-- lib/fonts/NewCMMath-Regular.otf
 - lib/formats/html_experimental.rb
 - lib/formats/pdf.rb
 - lib/formats/png.rb
@@ -158,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.4
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Ruby binding to typst, a new markup-based typesetting system that is powerful
   and easy to learn.

data/ext/typst/src/fonts.rs

@@ -1,86 +0,0 @@
-use std::cell::OnceCell;
-use std::fs::{self};
-use std::path::PathBuf;
-
-use fontdb::{Database, Source};
-use typst::font::{Font, FontBook, FontInfo};
-
-/// Searches for fonts.
-pub struct FontSearcher {
-    // Metadata about all discovered fonts.
-    pub book: FontBook,
-    /// Slots that the fonts are loaded into.
-    pub fonts: Vec<FontSlot>,
-}
-
-/// Holds details about the location of a font and lazily the font itself.
-pub struct FontSlot {
-    /// The path at which the font can be found on the system.
-    path: PathBuf,
-    /// The index of the font in its collection. Zero if the path does not point
-    /// to a collection.
-    index: u32,
-    /// The lazily loaded font.
-    font: OnceCell<Option<Font>>,
-}
-
-impl FontSlot {
-    /// Get the font for this slot.
-    pub fn get(&self) -> Option<Font> {
-        self.font
-            .get_or_init(|| {
-                let data = fs::read(&self.path).ok()?.into();
-                Font::new(data, self.index)
-            })
-            .clone()
-    }
-}
-
-impl FontSearcher {
-    /// Create a new, empty system searcher.
-    pub fn new() -> Self {
-        Self {
-            book: FontBook::new(),
-            fonts: vec![],
-        }
-    }
-
-    /// Search everything that is available.
-    pub fn search(&mut self, font_dirs: &[PathBuf], font_files: &[PathBuf]) {
-        let mut db = Database::new();
-
-        // Font paths have highest priority.
-        for path in font_dirs {
-            db.load_fonts_dir(path);
-        }
-
-        // System fonts have second priority.
-        db.load_system_fonts();
-
-        for path in font_files {
-            let _ret = db.load_font_file(path).ok();
-        }
-
-        for face in db.faces() {
-            let path = match &face.source {
-                Source::File(path) | Source::SharedFile(path, _) => path,
-                // We never add binary sources to the database, so there
-                // shouln't be any.
-                Source::Binary(_) => continue,
-            };
-
-            let info = db
-                .with_face_data(face.id, FontInfo::new)
-                .expect("database must contain this font");
-
-            if let Some(info) = info {
-                self.book.push(info);
-                self.fonts.push(FontSlot {
-                    path: path.clone(),
-                    index: face.index,
-                    font: OnceCell::new(),
-                });
-            }
-        }
-    }
-}