liquidz 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ef6c9c092df04414bd76a0c58bd8d07817cc9958d764b515e89eacad97061d7c
+  data.tar.gz: 46cc91dd3d1c98e4618898646b9b5849e2cf9da8e7d8be77cd2a74cae2534cc8
+SHA512:
+  metadata.gz: f101cfad36e446339aa15d13360c3ccef43f9ac156fff297f670830ec4ccff17509d7643f9452352f008e91c7933f88c3f4363c66a4674d16c24f2f0718353a4
+  data.tar.gz: c54ba1b2926f797af2bc5f4da43776b44a097173345a213630d7217561f335bea8adb7cc186db23c418f0a0db344c78f7bcccda31404c983230cf7553ac51cd7

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Pedro Piñera Buendía
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# Liquidz Ruby Binding
+
+High-performance Liquid template engine for Ruby, powered by Zig.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'liquidz'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself:
+
+```bash
+gem install liquidz
+```
+
+**Prerequisites:** You need to build the Zig library first:
+
+```bash
+zig build -Doptimize=ReleaseFast
+```
+
+Then build the gem extension:
+
+```bash
+cd ext/liquidz_ext
+ruby extconf.rb
+make
+```
+
+## Usage
+
+```ruby
+require 'liquidz_ext'
+
+# Simple variable substitution
+result = Liquidz.render("Hello, {{ name }}!", { name: "World" })
+# => "Hello, World!"
+
+# With loops
+result = Liquidz.render("{% for item in items %}{{ item }} {% endfor %}", { items: ["a", "b", "c"] })
+# => "a b c "
+
+# With conditionals
+result = Liquidz.render("{% if show %}visible{% endif %}", { show: true })
+# => "visible"
+
+# With filters
+result = Liquidz.render("{{ name | upcase }}", { name: "hello" })
+# => "HELLO"
+
+# Using JSON string directly
+result = Liquidz.render("{{ x }}", '{"x": 42}')
+# => "42"
+```
+
+## Drop-in Replacement for Liquid
+
+Liquidz can act as a drop-in replacement for the standard Liquid gem:
+
+```ruby
+require 'liquidz_ext/liquid_patch'
+
+# Now Liquid::Template.parse uses Liquidz under the hood
+template = Liquid::Template.parse("Hello, {{ name }}!")
+result = template.render({ "name" => "World" })
+# => "Hello, World!"
+```
+
+## API
+
+### `Liquidz.render(template, data = nil)`
+
+Renders a Liquid template with the given data.
+
+- `template` (String): The Liquid template string
+- `data` (Hash, String, nil): The data to render with. Can be a Hash or a JSON string. Defaults to `nil`.
+
+Returns the rendered template as a String.
+
+Raises `RuntimeError` if rendering fails.
+
+### `Liquidz.render_string(template, data = nil)`
+
+Alias for `Liquidz.render`.
+
+## Performance
+
+Liquidz is approximately 3.3x faster than the standard Ruby Liquid gem for typical templates.
+
+## License
+
+MIT

data/ext/liquidz_ext/extconf.rb

@@ -0,0 +1,10 @@
+require "mkmf"
+
+# Find the Zig-built library (bindings/ruby -> zig-out/lib)
+project_root = File.expand_path("../../../..", __dir__)
+lib_dir = File.join(project_root, "zig-out", "lib")
+
+# Link against the static library directly
+$LDFLAGS << " #{File.join(lib_dir, 'libliquidz_ffi.a')}"
+
+create_makefile("liquidz_ext/liquidz_ext")

data/ext/liquidz_ext/liquidz_ext.c

@@ -0,0 +1,42 @@
+#include "ruby.h"
+
+int liquidz_render_json(const char *template_ptr, size_t template_len,
+                        const char *json_ptr, size_t json_len,
+                        char **out_ptr, size_t *out_len);
+void liquidz_free(char *ptr, size_t len);
+
+static VALUE rb_liquidz_render(VALUE self, VALUE template_val, VALUE data_val) {
+    VALUE template_str = StringValue(template_val);
+    VALUE json_str = Qnil;
+
+    if (NIL_P(data_val)) {
+        json_str = rb_str_new("", 0);
+    } else if (RB_TYPE_P(data_val, T_STRING)) {
+        json_str = data_val;
+    } else {
+        json_str = rb_funcall(data_val, rb_intern("to_json"), 0);
+    }
+
+    const char *template_ptr = RSTRING_PTR(template_str);
+    size_t template_len = (size_t)RSTRING_LEN(template_str);
+    const char *json_ptr = RSTRING_PTR(json_str);
+    size_t json_len = (size_t)RSTRING_LEN(json_str);
+
+    char *out_ptr = NULL;
+    size_t out_len = 0;
+
+    int rc = liquidz_render_json(template_ptr, template_len, json_ptr, json_len,
+                                 &out_ptr, &out_len);
+    if (rc != 0) {
+        rb_raise(rb_eRuntimeError, "liquidz render failed");
+    }
+
+    VALUE result = rb_str_new(out_ptr, (long)out_len);
+    liquidz_free(out_ptr, out_len);
+    return result;
+}
+
+void Init_liquidz_ext(void) {
+    VALUE mLiquidz = rb_define_module("Liquidz");
+    rb_define_singleton_method(mLiquidz, "render", rb_liquidz_render, 2);
+}

data/lib/liquidz_ext/liquid_patch.rb

@@ -0,0 +1,36 @@
+require "liquid"
+require "liquidz_ext"
+
+module Liquidz
+  class Template
+    def initialize(source)
+      @source = source
+    end
+
+    def render(context = {}, **_opts)
+      Liquidz.render(@source, context)
+    end
+
+    def render!(*args, **kwargs)
+      render(*args, **kwargs)
+    end
+  end
+
+  def self.enable_liquid_patch!
+    return if @liquid_patch_enabled
+
+    Liquid::Template.singleton_class.class_eval do
+      unless method_defined?(:liquidz_orig_parse)
+        alias_method :liquidz_orig_parse, :parse
+      end
+
+      def parse(source, *args, **_kwargs)
+        Liquidz::Template.new(source)
+      end
+    end
+
+    @liquid_patch_enabled = true
+  end
+end
+
+Liquidz.enable_liquid_patch!

data/lib/liquidz_ext.rb

@@ -0,0 +1,46 @@
+require "json"
+require "liquidz_ext/liquidz_ext"
+
+# Liquidz - High-performance Liquid template engine powered by Zig
+#
+# @example Basic usage
+#   Liquidz.render("Hello, {{ name }}!", { name: "World" })
+#   # => "Hello, World!"
+#
+# @example With loops
+#   Liquidz.render("{% for item in items %}{{ item }} {% endfor %}", { items: ["a", "b", "c"] })
+#   # => "a b c "
+#
+# @example With filters
+#   Liquidz.render("{{ name | upcase }}", { name: "hello" })
+#   # => "HELLO"
+#
+module Liquidz
+  class Error < StandardError; end
+  class RenderError < Error; end
+
+  # Renders a Liquid template with the given data.
+  #
+  # @param template [String] The Liquid template string
+  # @param data [Hash, String, nil] The data to render with (Hash or JSON string)
+  # @return [String] The rendered template
+  # @raise [RenderError] If rendering fails
+  #
+  # @example
+  #   Liquidz.render_string("Hello, {{ name }}!", { name: "World" })
+  #   # => "Hello, World!"
+  #
+  def self.render_string(template, data = nil)
+    render(template, data)
+  rescue => e
+    raise RenderError, "Failed to render template: #{e.message}"
+  end
+
+  # Returns the version of the Liquidz library.
+  #
+  # @return [String] The version string
+  #
+  def self.version
+    "0.2.0"
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: liquidz
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Pedro Pinera Buendia
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A fast, drop-in replacement for the Liquid template engine, compiled
+  from Zig to native code for maximum performance.
+email:
+- pedro@ppinera.es
+executables: []
+extensions:
+- ext/liquidz_ext/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- ext/liquidz_ext/extconf.rb
+- ext/liquidz_ext/liquidz_ext.c
+- lib/liquidz_ext.rb
+- lib/liquidz_ext/liquid_patch.rb
+- lib/liquidz_ext/liquidz_ext.bundle
+homepage: https://github.com/pepicrft/liquidz
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/pepicrft/liquidz
+  source_code_uri: https://github.com/pepicrft/liquidz
+  changelog_uri: https://github.com/pepicrft/liquidz/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: High-performance Liquid template engine powered by Zig
+test_files: []