RubyGems - typst - Versions diffs - 0.0.1 → 0.0.3 - Mend

typst 0.0.1 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43d8c84a75186f58f150a1b401f023269a87b65ff4181622d12ee0605e44e12c
-  data.tar.gz: b04f05668004a681b3dbf23cd8c5741e7a5d88418b1b282144b8a855575e9ae1
+  metadata.gz: ea8821be2119d9f300be030629e825d14c8fe380cd2c858a875337eb703e7df1
+  data.tar.gz: e831657b70680e117e16db19750e9c382a3cff766f7dbe990d1b876c7e898772
 SHA512:
-  metadata.gz: 90852c841c355b42fd6f305627d6ce61e3ad2321e56e8a45bab1eff715888f232f76779eb217375e0da4855c24fd139cb14a86dea2a4aa53aeacccc816ece7da
-  data.tar.gz: 2e661ba34cdef35d3e9911b461cbd06815c31a2ac4408fa6be4a3395519f8a159bf3a3e31ae6cc573f78dbbe14a8818f0089dacf59f6ad6d779e80c79d02733d
+  metadata.gz: e14bdb9e0275a8d716e966442d776e1d514ee055cf473f3795e84555a51e09a30afb124aa2e0ed82be1f3ada4aac1b83a48825e346e3b3b08b4eb7134a3a15ff
+  data.tar.gz: 66c4dfa603503ce492690718f4d7aa74f5ba23db0492752f53e0ebe02892ae3bdbe028f694bb363584e387612cb19b4d3d5cab85f49761105975758bb92c29e6

data/README.md CHANGED Viewed

@@ -36,7 +36,7 @@ pages = Typst::Svg.new("readme.typ").pages
 Typst::Html.new("readme.typ", "README").write("readme.html")
 # Or return HTML content
-markup = Typst::Html.new("readme.typ", "README").markup
+markup = Typst::Html.new("readme.typ", title: "README").markup
 # => "\n<!DOCTYPE html>\n<html>\n<head>\n<title>README</title>\n</head>\n<bo..."
 # Compile from a string to PDF
@@ -70,6 +70,13 @@ icon = File.read("icon.svg")
 font_bytes = File.read("Example.ttf")
 t = Typst::Pdf.from_s(main, dependencies: { "template.typ" => template, "icon.svg" => icon }, fonts: { "Example.ttf" => font_bytes })
+# From a zip file that includes a main.typ
+# zip file include flat dependencies included and a fonts directory
+Typst::Pdf::from_zip("working_directory.zip")
+# From a zip with a named main typst file
+Typst::Pdf::from_zip("working_directory.zip", "hello.typ")
 ```
 ## Contributors & Acknowledgements

data/README.typ CHANGED Viewed

@@ -39,7 +39,7 @@ pages = Typst::Svg.new("readme.typ").pages
 Typst::Html.new("readme.typ", "README").write("readme.html")
 # Or return HTML content
-markup = Typst::Html.new("readme.typ", "README").markup
+markup = Typst::Html.new("readme.typ", title: "README").markup
 # => "\n<!DOCTYPE html>\n<html>\n<head>\n<title>README</title>\n</head>\n<bo..."
 # Compile from a string to PDF
@@ -73,6 +73,13 @@ icon = File.read("icon.svg")
 font_bytes = File.read("Example.ttf")
 t = Typst::Pdf.from_s(main, dependencies: { "template.typ" => template, "icon.svg" => icon }, fonts: { "Example.ttf" => font_bytes })
+# From a zip file that includes a main.typ
+# zip file include flat dependencies included and a fonts directory
+Typst::Pdf::from_zip("working_directory.zip")
+# From a zip with a named main typst file
+Typst::Pdf::from_zip("working_directory.zip", "hello.typ")
 ```
 == Contributors & Acknowledgements

data/Rakefile CHANGED Viewed

@@ -1,5 +1,6 @@
 require "bundler/gem_tasks"
 require "rake/extensiontask"
+require "rake/testtask"
 require "rubygems/package_task"
 require "bundler"
@@ -22,3 +23,9 @@ Rake::ExtensionTask.new("typst", spec) do |ext|
   ext.cross_compile = true
   ext.cross_platform = CROSS_PLATFORMS
 end
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end

data/ext/typst/src/lib.wip.rs ADDED Viewed

@@ -0,0 +1,203 @@
+use std::path::PathBuf;
+use std::env;
+use std::{
+    cell::RefCell,
+    fmt,
+    hash::{Hash, Hasher},
+};
+use magnus::r_string::IntoRString;
+//use magnus::{function, exception, Error, IntoValue};
+use magnus::{
+    class, define_class, exception, method, module, function,
+    prelude::*,
+    scan_args::{get_kwargs, scan_args},
+    typed_data, error::Error, Value, IntoValue, Symbol
+};
+use world::SystemWorld;
+mod compiler;
+mod download;
+mod fonts;
+mod package;
+mod world;
+fn compile(
+    input: PathBuf,
+    output: Option<PathBuf>,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+) -> Result<magnus::Value, Error> {
+    let input = input.canonicalize()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+    let root = if let Some(root) = root {
+        root.canonicalize()
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+    } else if let Some(dir) = input.parent() {
+        dir.into()
+    } else {
+        PathBuf::new()
+    };
+    let resource_path = env::current_dir()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+    let mut default_fonts = Vec::new();
+    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
+        let path = entry
+            .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+            .into_path();
+        let Some(extension) = path.extension() else {
+            continue;
+        };
+        if extension == "ttf" || extension == "otf" {
+            default_fonts.push(path);
+        }
+    }
+    let mut world = SystemWorld::builder(root, input)
+        .font_paths(font_paths)
+        .font_files(default_fonts)
+        .build()
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+    let pdf_bytes = world
+        .compile()
+        .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+    if let Some(output) = output {
+        std::fs::write(output, pdf_bytes)
+            .map_err(|_| magnus::Error::new(exception::arg_error(), "error"))?;
+        let value = true.into_value();
+        Ok(value)
+    } else {
+        let value = pdf_bytes.into_value();
+        Ok(value)
+    }
+}
+#[magnus::wrap(class = "Typst", free_immediately, size)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd)]
+struct Typst {
+    input: PathBuf,
+    output: Option<PathBuf>,
+    root: PathBuf,
+    font_paths: Vec<PathBuf>,
+}
+// can't derive this due to needing to use RefCell to get mutability
+impl Hash for Typst {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.input.hash(state)
+    }
+}
+//#[magnus::wrap(class = "Typst")]
+impl Typst {
+    fn initialize(rb_self: typed_data::Obj<Self>, args: &[Value]) -> Result<Value, Error> {
+        let args = scan_args::<_, _, (), (), _, ()>(args)?;
+        let (input,): (PathBuf,) = args.required;
+        let (output,): (
+            Option<PathBuf>,
+        ) = args.optional;
+        let kw = get_kwargs::<_, (), (Option<PathBuf>, Option<Vec<PathBuf>>), ()>(args.keywords, &[], &["root", "font_paths"])?;
+        let (root, font_paths) = kw.optional;
+        //*rb_self.input.borrow_mut() = input;
+        //*rb_self.output.borrow_mut() = output;
+        rb_self.input = input;
+        rb_self.output = output;
+        rb_self.root = if let Some(root) = root {
+            root
+        } else {
+            PathBuf::new()
+        };
+        rb_self.font_paths = if let Some(font_paths) = font_paths {
+            font_paths
+        } else {
+            let font_paths:Vec<PathBuf> = Vec::new();
+            font_paths
+        };
+        Ok(rb_self.into_value())
+    }
+    fn compile(rb_self: typed_data::Obj<Self>, args: &[Value]) -> Result<Value, Error> {
+        let resource_path = env::current_dir()
+        .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?;
+        let mut default_fonts = Vec::new();
+        for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
+            let path = entry
+                .map_err(|err| magnus::Error::new(exception::arg_error(), err.to_string()))?
+                .into_path();
+            let Some(extension) = path.extension() else {
+                continue;
+            };
+            if extension == "ttf" || extension == "otf" {
+                default_fonts.push(path);
+            }
+        }
+        //let input = PathBuf::from(*rb_self.input.borrow());
+        //let root = PathBuf::from(*rb_self.root.borrow());
+        let input = PathBuf::from(&rb_self.input);
+        let root = PathBuf::from(&rb_self.root);
+        let font_paths: Vec<PathBuf> = Vec::new();
+        let mut world = SystemWorld::builder(root, input)
+            .font_paths(font_paths)
+            .font_files(default_fonts)
+            .build()
+            .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+        let pdf_bytes = world
+            .compile()
+            .map_err(|msg| magnus::Error::new(exception::arg_error(), msg.to_string()))?;
+        //let op: Option<PathBuf> = *rb_self.output.borrow();
+        //if let Some(output) = op {
+        //    std::fs::write(output, pdf_bytes)
+        //        .map_err(|_| magnus::Error::new(exception::arg_error(), "error"))?;
+        //    let value = true.into_value();
+        //    Ok(value)
+        //} else {
+            let value = pdf_bytes.into_value();
+            Ok(value)
+        //}
+    }
+}
+impl fmt::Display for Typst {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.input.display())
+    }
+}
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let class = define_class("Typst", class::object())?;
+    // Define alloc func based on the Default impl, plus an initialize method,
+    // rather than overwriting `new`, to allow class to be subclassed from Ruby
+    class.define_alloc_func::<Typst>();
+    class.define_method("initialize", method!(Typst::initialize, -1))?;
+    //class.define_singleton_method("foo", function!(foo, -1))?;
+    class.define_method("inspect",method!(<Typst as typed_data::Inspect>::inspect, 0))?;
+    class.define_method("to_s", method!(Typst::to_string, 0))?;
+ //   class.define_method("barf", method!(Typst::barf, 0))?;
+    //let module = magnus::define_module("Typst").unwrap();
+    //module.define_module_function("compile", function!(compile, 4)).unwrap();
+    Ok(())
+}

data/lib/typst.rb CHANGED Viewed

@@ -2,10 +2,27 @@ require_relative "typst/typst"
 require "cgi"
 require "pathname"
 require "tmpdir"
+require "zip/filesystem"
 module Typst
   class Base
+    attr_accessor :input
+    attr_accessor :root
+    attr_accessor :font_paths
+    def initialize(input, root: ".", font_paths: [])
+      self.input = input
+      self.root = Pathname.new(root).expand_path.to_s
+      self.font_paths = font_paths.collect{ |fp| Pathname.new(fp).expand_path.to_s }
+    end
+    def write(output)
+      File.open(output, "w"){ |f| f.write(document) }
+    end
     def self.from_s(main_source, dependencies: {}, fonts: {})
+      dependencies = {} if dependencies.nil?
+      fonts = {} if fonts.nil?
       Dir.mktmpdir do |tmp_dir|
         tmp_main_file = Pathname.new(tmp_dir).join("main.typ")
         File.write(tmp_main_file, main_source)
@@ -16,7 +33,6 @@ module Typst
         end
         relative_font_path = Pathname.new(tmp_dir).join("fonts")
-        puts fonts
         fonts.each do |font_name, font_bytes|
           Pathname.new(relative_font_path).mkpath
           tmp_font_file = relative_font_path.join(font_name)
@@ -26,43 +42,56 @@ module Typst
         new(tmp_main_file, root: tmp_dir, font_paths: [relative_font_path])
       end
     end
+    def self.from_zip(zip_file_path, main_file = nil)
+      dependencies = {}
+      fonts = {}
+      Zip::File.open(zip_file_path) do |zipfile|
+        file_names = zipfile.dir.glob("*").collect{ |f| f.name }
+        case
+          when file_names.include?(main_file) then tmp_main_file = main_file
+          when file_names.include?("main.typ") then tmp_main_file = "main.typ"
+          when file_names.size == 1 then tmp_main_file = file_names.first
+          else raise "no main file found"
+        end
+        main_source = zipfile.file.read(tmp_main_file)
+        file_names.delete(tmp_main_file)
+        file_names.delete("fonts/")
+        file_names.each do |dep_name|
+          dependencies[dep_name] = zipfile.file.read(dep_name)
+        end
+        font_file_names = zipfile.dir.glob("fonts/*").collect{ |f| f.name }
+        font_file_names.each do |font_name|
+          fonts[Pathname.new(font_name).basename.to_s] = zipfile.file.read(font_name)
+        end
+        from_s(tmp_main_file, dependencies: dependencies, fonts: fonts)
+      end
+    end
   end
   class Pdf < Base
-    attr_accessor :input
-    attr_accessor :root
-    attr_accessor :font_paths
     attr_accessor :bytes
-    def initialize(input, root: ".", font_paths: ["fonts"])
-      self.input = input
-      self.root = root
-      self.font_paths = font_paths
-      @bytes = Typst::_to_pdf(input, root, font_paths, File.dirname(__FILE__))
+    def initialize(input, root: ".", font_paths: [])
+      super(input, root: root, font_paths: font_paths)
+      @bytes = Typst::_to_pdf(self.input, self.root, self.font_paths, File.dirname(__FILE__))
     end
     def document
       bytes.pack("C*").to_s
     end
-    def write(output)
-      File.open(output, "w"){ |f| f.write(document) }
-    end
   end
   class Svg < Base
-    attr_accessor :input
-    attr_accessor :root
-    attr_accessor :font_paths
     attr_accessor :pages
-    def initialize(input, root: ".", font_paths: ["fonts"])
-      self.input = input
-      self.root = root
-      self.font_paths = font_paths
-      @pages = Typst::_to_svg(input, root, font_paths, File.dirname(__FILE__))
+    def initialize(input, root: ".", font_paths: [])
+      super(input, root: root, font_paths: font_paths)
+      @pages = Typst::_to_svg(self.input, self.root, self.font_paths, File.dirname(__FILE__))
     end
     def write(output)
@@ -88,12 +117,13 @@ module Typst
     attr_accessor :svg
     attr_accessor :html
-    def initialize(input, title = nil, root: ".", font_paths: ["fonts"])
+    def initialize(input, title: nil, root: ".", font_paths: [])
+      super(input, root: root, font_paths: font_paths)
       title = title || File.basename(input, File.extname(input))
-      @title = CGI::escapeHTML(title)
-      @svg = Svg.new(input, root: root, font_paths: font_paths)
+      self.title = CGI::escapeHTML(title)
+      self.svg = Svg.new(self.input, root: self.root, font_paths: self.font_paths)
     end
     def markup
       %{
 <!DOCTYPE html>
@@ -107,9 +137,6 @@ module Typst
 </html>
       }
     end
-    def write(output)
-      File.open(output, "w"){ |f| f.write(markup) }
-    end
+    alias_method :document, :markup
   end
 end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Flinn
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-26 00:00:00.000000000 Z
+date: 2023-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -42,6 +42,7 @@ files:
 - ext/typst/src/download.rs
 - ext/typst/src/fonts.rs
 - ext/typst/src/lib.rs
+- ext/typst/src/lib.wip.rs
 - ext/typst/src/package.rs
 - ext/typst/src/world.rs
 - lib/fonts/DejaVuSansMono-Bold.ttf
@@ -71,7 +72,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.2
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="