rustybars 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 496b13a766702b1f13c09d30feb704fd38561a5f8cf74ea5f5cade07cd5f3680
-  data.tar.gz: c1c89890e98584ea42059f2323ce7010ab52264bb29f88019b2441d3043044f3
+  metadata.gz: 63b3077155604ec100bf23a804db7cc05c58a2c638bf353069b54c033943e953
+  data.tar.gz: 10051bbaa90b5f132ab8790f443f77911f1677bef26dca75adf6cbdb9703ff1e
 SHA512:
-  metadata.gz: 2c1ba377df721ed92e79bac27914f5616bb3f3018206358dd8d8c95b078d8d8d503ebb4c5183b397a9435b54cea186e49da4318891f38eb9740ca309276e0d13
-  data.tar.gz: dad473debdeeb4f61b2f574a004c53068e76ef441fb236347bae29dc350ecf3e12ecdbf8306bc55019c984e8ad82e8f0a4ab3d4eda15eaf252c743c85dcd570f
+  metadata.gz: 437f489e8405d717bbeb5670a8a1acd318d5920385d85b239390f3b27586cb6534757f0d9d0b63573863ba6b0fb6650cdb2846f862fecff567b1e145aabfb5b1
+  data.tar.gz: e2cb1d4542158d1301c6287d961126f9ebc6ae4b578da45bfd8d36d853976090c81a74e425c269e9e7cc4757c8fc9b147fece6dac8038cb5b587a99674a7b8ee

data/ext/rustybars/src/engine.rs

@@ -0,0 +1,63 @@
+use std::fmt::{self, Debug, Formatter};
+
+use handlebars::Handlebars;
+use magnus::{function, method, prelude::*, scan_args::{get_kwargs, scan_args}, Error, Object, RHash, Ruby, Value};
+
+use crate::{namespace::RUSTYBARS_MODULE, template::CompiledTemplate};
+
+#[magnus::wrap(class = "Rustybars::Engine")]
+pub struct Engine {
+    pub registry: Handlebars<'static>
+}
+
+impl Debug for Engine {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+        f.debug_struct("Engine")
+            .field("strict_mode", &self.registry.strict_mode())
+            .field("dev_mode", &self.registry.dev_mode())
+            .field("prevent_indent", &self.registry.prevent_indent())
+            .finish()
+    }
+}
+
+impl Engine {
+    fn new(args: &[Value]) -> Result<Self, Error> {
+        let args = scan_args::<(), (), (), (), RHash, ()>(args)?;
+        let args = get_kwargs(
+            args.keywords,
+            &[],
+            &["strict_mode", "dev_mode", "prevent_indent"]
+        )?;
+        let _: () = args.required;
+        let (strict_mode, dev_mode, prevent_indent): (Option<bool>, Option<bool>, Option<bool>,) = args.optional;
+        let _: () = args.splat;
+
+        let mut hbs = Handlebars::new();
+        hbs.set_strict_mode(strict_mode.unwrap_or(false));
+        hbs.set_dev_mode(dev_mode.unwrap_or(false));
+        hbs.set_prevent_indent(prevent_indent.unwrap_or(false));
+        Ok(Self { registry: hbs })
+    }
+
+    fn render(ruby: &Ruby, rb_self: &'static Self, source: String, data: String) -> Result<String, Error> {
+        let template = Self::compile(ruby, rb_self, source)?;
+        CompiledTemplate::render(ruby, &template, data)
+    }
+
+    fn compile(ruby: &Ruby, rb_self: &'static Self, source: String) -> Result<CompiledTemplate, Error> {
+        CompiledTemplate::compile(ruby, &rb_self.registry, source)
+    }
+
+    fn inspect(&self) -> Result<String, Error> {
+        Ok(format!("<Rustybars::{:?}>", self))
+    }
+}
+
+pub fn init(ruby: &Ruby) -> Result<(), Error> {
+    let class = ruby.get_inner(&RUSTYBARS_MODULE).define_class("Engine", ruby.class_object())?;
+    class.define_singleton_method("new", function!(Engine::new, -1))?;
+    class.define_method("compile", method!(Engine::compile, 1))?;
+    class.define_method("render", method!(Engine::render, 2))?;
+    class.define_method("inspect", method!(Engine::inspect, 0))?;
+    Ok(())
+}

data/ext/rustybars/src/errors.rs

@@ -0,0 +1,39 @@
+use magnus::{exception::ExceptionClass, value::Lazy, Error, Module, Ruby};
+
+use super::namespace::RUSTYBARS_MODULE;
+
+pub static RUSTYBARS_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    ruby
+        .get_inner(&RUSTYBARS_MODULE)
+        .define_error("Error", ruby.exception_standard_error())
+        .unwrap()
+});
+
+pub static RUSTYBARS_JSON_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    ruby
+        .get_inner(&RUSTYBARS_MODULE)
+        .define_error("JsonError", ruby.get_inner(&RUSTYBARS_ERROR))
+        .unwrap()
+});
+
+pub static RUSTYBARS_COMPILE_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    ruby
+        .get_inner(&RUSTYBARS_MODULE)
+        .define_error("CompileError", ruby.get_inner(&RUSTYBARS_ERROR))
+        .unwrap()
+});
+
+pub static RUSTYBARS_RENDER_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    ruby
+        .get_inner(&RUSTYBARS_MODULE)
+        .define_error("RenderError", ruby.get_inner(&RUSTYBARS_ERROR))
+        .unwrap()
+});
+
+pub fn init(ruby: &Ruby) -> Result<(), Error> {
+    Lazy::force(&RUSTYBARS_ERROR, ruby);
+    Lazy::force(&RUSTYBARS_JSON_ERROR, ruby);
+    Lazy::force(&RUSTYBARS_COMPILE_ERROR, ruby);
+    Lazy::force(&RUSTYBARS_RENDER_ERROR, ruby);
+    Ok(())
+}

data/ext/rustybars/src/lib.rs

@@ -1,61 +1,14 @@
-use magnus::{function, exception, prelude::*, value::Lazy, Error, Ruby, RModule};
-use handlebars::Handlebars;
-use serde_json;
-
-
-static RUSTYBARS: Lazy<RModule> = Lazy::new(|ruby| {
-    ruby
-        .define_module("Rustybars")
-        .unwrap()
-});
-
-static RUSTYBARS_ERROR: Lazy<exception::ExceptionClass> = Lazy::new(|ruby| {
-    ruby
-        .get_inner(&RUSTYBARS)
-        .define_error("Error", ruby.exception_standard_error())
-        .unwrap()
-});
-
-static RUSTYBARS_DATA_ERROR: Lazy<exception::ExceptionClass> = Lazy::new(|ruby| {
-    ruby
-        .get_inner(&RUSTYBARS)
-        .define_error("DataError", ruby.get_inner(&RUSTYBARS_ERROR))
-        .unwrap()
-});
-
-static RUSTYBARS_TEMPLATE_ERROR: Lazy<exception::ExceptionClass> = Lazy::new(|ruby| {
-    ruby
-        .get_inner(&RUSTYBARS)
-        .define_error("TemplateError", ruby.get_inner(&RUSTYBARS_ERROR))
-        .unwrap()
-});
-
-
-fn render(ruby: &Ruby, template: String, data: String) -> Result<String, Error> {
-    let variables: serde_json::Value = serde_json::from_str(&data).map_err(|e| {
-        Error::new(
-            ruby.get_inner(&RUSTYBARS_DATA_ERROR),
-            e.to_string(),
-        )
-    })?;
-
-    let hbs = Handlebars::new();
-    hbs.render_template(&template, &variables).map_err(|e| {
-        Error::new(
-            ruby.get_inner(&RUSTYBARS_TEMPLATE_ERROR),
-            e.to_string()
-        )
-    })
-}
+mod namespace;
+mod errors;
+mod engine;
+mod template;
 
 #[magnus::init]
-fn init(ruby: &Ruby) -> Result<(), Error> {
-    Lazy::force(&RUSTYBARS_DATA_ERROR, ruby);
-    Lazy::force(&RUSTYBARS_TEMPLATE_ERROR, ruby);
-
-    ruby
-        .get_inner(&RUSTYBARS)
-        .define_singleton_method("render", function!(render, 2))?;
-
+fn init(ruby: &magnus::Ruby) -> Result<(), magnus::Error> {
+    namespace::init(ruby)?;
+    errors::init(ruby)?;
+    engine::init(ruby)?;
+    template::init(ruby)?;
     Ok(())
 }
+

data/ext/rustybars/src/namespace.rs

@@ -0,0 +1,12 @@
+use magnus::{value::Lazy, Error, RModule, Ruby};
+
+pub static RUSTYBARS_MODULE: Lazy<RModule> = Lazy::new(|ruby| {
+    ruby
+        .define_module("Rustybars")
+        .unwrap()
+});
+
+pub fn init(ruby: &Ruby) -> Result<(), Error> {
+    Lazy::force(&RUSTYBARS_MODULE, ruby);
+    Ok(())
+}

data/ext/rustybars/src/template.rs

@@ -0,0 +1,54 @@
+use handlebars::{Context, Handlebars, RenderContext, Renderable, Template};
+use magnus::{method, prelude::*, Class, Error, Ruby};
+
+use crate::{errors::{RUSTYBARS_COMPILE_ERROR, RUSTYBARS_JSON_ERROR, RUSTYBARS_RENDER_ERROR}, namespace::RUSTYBARS_MODULE};
+
+#[magnus::wrap(class = "Rustybars::CompiledTemplate")]
+pub struct CompiledTemplate {
+    pub handlebars: &'static Handlebars<'static>,
+    pub template: Template
+}
+
+impl CompiledTemplate {
+    pub fn compile(ruby: &Ruby, handlebars: &'static Handlebars, source: String) -> Result<Self, Error> {
+        let template = Template::compile(&source).map_err(|e| {
+            Error::new(
+                ruby.get_inner(&RUSTYBARS_COMPILE_ERROR),
+                e.to_string()
+                )
+        })?;
+        Ok(Self{
+            handlebars,
+            template
+        })
+    }
+
+    pub fn render(ruby: &Ruby, rb_self: &Self, data: String) -> Result<String, Error> {
+        let hbs = &rb_self.handlebars;
+
+        let data: serde_json::Value = serde_json::from_str(&data).map_err(|e| {
+            Error::new(
+                ruby.get_inner(&RUSTYBARS_JSON_ERROR),
+                e.to_string(),
+            )
+        })?;
+
+        let ctx = Context::from(data);
+
+        let mut render_context = RenderContext::new(None);
+
+        rb_self.template.renders(&hbs, &ctx, &mut render_context).map_err(|e| {
+            Error::new(
+                ruby.get_inner(&RUSTYBARS_RENDER_ERROR),
+                e.to_string()
+            )
+        })
+    }
+}
+
+pub fn init(ruby: &Ruby) -> Result<(), Error> {
+    let class = ruby.get_inner(&RUSTYBARS_MODULE).define_class("CompiledTemplate", ruby.class_object())?;
+    class.undef_default_alloc_func();
+    class.define_method("render", method!(CompiledTemplate::render, 1))?;
+    Ok(())
+}

data/lib/rustybars/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rustybars
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rustybars
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Andriy Yanko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-19 00:00:00.000000000 Z
+date: 2024-01-29 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -20,7 +20,11 @@ extra_rdoc_files: []
 files:
 - ext/rustybars/Cargo.toml
 - ext/rustybars/extconf.rb
+- ext/rustybars/src/engine.rs
+- ext/rustybars/src/errors.rs
 - ext/rustybars/src/lib.rs
+- ext/rustybars/src/namespace.rs
+- ext/rustybars/src/template.rs
 - lib/rustybars.rb
 - lib/rustybars/version.rb
 homepage: https://github.com/ayanko/rustybars