typst 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43d8c84a75186f58f150a1b401f023269a87b65ff4181622d12ee0605e44e12c
-  data.tar.gz: b04f05668004a681b3dbf23cd8c5741e7a5d88418b1b282144b8a855575e9ae1
+  metadata.gz: 85a0ad3847a1a278f6f47ab94fc447860fb583736774ab4c7c81e5fc871d8d7f
+  data.tar.gz: e9a4f127a9f9b2780a2b58efc413f3cbef4f62b0fbae1d2649e670ef552a87da
 SHA512:
-  metadata.gz: 90852c841c355b42fd6f305627d6ce61e3ad2321e56e8a45bab1eff715888f232f76779eb217375e0da4855c24fd139cb14a86dea2a4aa53aeacccc816ece7da
-  data.tar.gz: 2e661ba34cdef35d3e9911b461cbd06815c31a2ac4408fa6be4a3395519f8a159bf3a3e31ae6cc573f78dbbe14a8818f0089dacf59f6ad6d779e80c79d02733d
+  metadata.gz: b75ae52ebb916a9a9fd34b7a77816ddf86f38aaeb3878a1135e135bbb468f712751b2bcd288dc947d884b8cdca64a3fd267b38f405dc8f12976dda9d8e66d059
+  data.tar.gz: bccf2c3206193e12ae7ec4805b61c1d953abda079866eca4063d221973d6491cee3d8c959fb66cfc3b4b5994cd915f85d19e748617f998c4c816ddd67dac3205

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

@@ -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(())
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Flinn
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-26 00:00:00.000000000 Z
+date: 2023-11-27 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,14 +72,14 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Ruby binding to typst, a new markup-based typesetting system that is powerful