ruby2html 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ba119a7769924fec25bf5a7b80128f2086dd82fc3c81bd60b0d817e19a8232f
-  data.tar.gz: b4decdfd8c01b34813e0d092de84d90abc64bbf78417ab38f4ff3e44719e3ac5
+  metadata.gz: 7c3bc5f1d40d12683edafbe453a291165275d9dc1b2552007a0d757954793a6a
+  data.tar.gz: 2fd1df901225789e4327576d414dd16be60bea5b9c2f11020c16a6ce0e7ef1cb
 SHA512:
-  metadata.gz: 3e93a318476275d137fab0f8149df9ac26a9bdf78e6ddd23b63b630ee662d1e4f87aaa039b22f7f8dd3ebef1a38c334423714ebc3544e2d8cd02869574da5d69
-  data.tar.gz: 5b57bb1eda59d05452e12c7b43161d3b210fd063c597f7ad42c3ccb1320b48fc5378ea2771ebc9a1185384e4ed29eb97e2e7372c697d235d33cbb1c6e93a979a
+  metadata.gz: bc63552f617578a8d98938490e564a7c483e7f6179faefa5800452b8ad90d6cc1dfa921f0626bfa2c1a4046e79f298facdef9c7fb337a1e3a481f46049c0fd7a
+  data.tar.gz: 2e25baa9f3ecce618f5eac307767e66ee9592216d441444e4fb1da39def3a7a454ac97f6a1b3fc007a3f402ac50eb5e2cdfee42bdb81719b44fe60376205c17c

data/CHANGELOG.md

@@ -6,6 +6,19 @@ Entries before 1.6.6 were reconstructed from `git log` and RubyGems release date
 
 ## [Unreleased]
 
+## [2.1.0] - 2026-10-31
+
+### Added
+
+- JRuby now ships a small Java extension (`Ruby2html::JavaNative`) that accelerates HTML escaping — the renderer's hot path — over the pure-Ruby implementation. About 1.9x faster end-to-end rendering on JRuby; output is byte-identical. Distributed as a `ruby2html-<version>-java` platform gem with the jar prebuilt (no JDK needed to install); everything else stays pure Ruby.
+
+### Changed
+
+- `Ruby2html::Component#render_in` accepts Rails' keyword options (`locals:`), as Rails main (8.2) passes them and deprecates `render_in` without options.
+- TruffleRuby now uses the pure-Ruby implementation instead of the C extension. TruffleRuby runs C extensions through Sulong but JITs pure Ruby with Graal, which here renders ~28x faster; `Ruby2html.native?` is now `false` on TruffleRuby.
+- On CRuby, a C extension that fails to load now prints one warning with the reason (`ruby2html: C extension not loaded (...); using the pure-Ruby renderer`) instead of silently rendering about 3x slower. JRuby/TruffleRuby and `RUBY2HTML_DISABLE_EXT=1` stay silent.
+- Development and single-version CI jobs now run on the latest stable Ruby (4.0). The CRuby test matrix already tracks the official maintained-versions list automatically (currently 3.3, 3.4, 4.0).
+
 ## [2.0.0] - 2026-10-31
 
 A rewrite of the renderer for speed, memory and correctness, plus a new component class, Rails 8.1 / ViewComponent 4 support, JRuby/TruffleRuby support and full CI/release automation. **Contains breaking changes: read "Upgrading to 2.0" below.**
@@ -170,7 +183,8 @@ Published to RubyGems; no separate commits in the repository history.
 ### Added
 - Initial release: `Ruby2html::Render` DSL, `Ruby2html::RailsHelper#html` for ERB.
 
-[Unreleased]: https://github.com/sebyx07/ruby2html/compare/v2.0.0...HEAD
+[Unreleased]: https://github.com/sebyx07/ruby2html/compare/v2.1.0...HEAD
+[2.1.0]: https://github.com/sebyx07/ruby2html/compare/v2.0.0...v2.1.0
 [2.0.0]: https://github.com/sebyx07/ruby2html/releases/tag/v2.0.0
 [1.6.6]: https://rubygems.org/gems/ruby2html/versions/1.6.6
 [1.6.4]: https://rubygems.org/gems/ruby2html/versions/1.6.4

data/README.md

@@ -23,12 +23,12 @@ end
 - **Fastest Ruby HTML renderer we've measured.** The page benchmark renders 1.35x faster than Erubi (Rails' ERB engine) and 2.4–16x faster than Phlex 2, with 40–90% fewer allocations; in a full Rails request it leads ERB, Slim and Phlex ([numbers](#performance)).
 - **Light.** No runtime dependencies, a 32 KB gem, and `require 'ruby2html'` costs about 0.4 MB and 19 ms. Prism, the Rails glue and the optional beautifier load only when used, or at boot in eager-loading production apps.
 - **Plain Ruby views.** `.html.rb` templates, ERB interop, ViewComponent, or the built-in `Ruby2html::Component`. Escaped by default.
-- **Runs everywhere.** CRuby ≥ 3.1 with a C extension (SIMD escaping on x86_64 and arm64), and JRuby/TruffleRuby through a byte-identical pure-Ruby implementation. Rails 7.2+.
+- **Runs everywhere.** CRuby ≥ 3.1 with a C extension (SIMD escaping on x86_64 and arm64), JRuby with a Java escaper over the pure-Ruby implementation, and TruffleRuby on pure Ruby (faster there than the C extension) — all byte-identical. Rails 7.2+.
 - **AI-ready.** One-file reference for coding agents: [`llms.txt`](llms.txt).
 
 ## Installation
 
-Supports all maintained CRuby versions (>= 3.1), JRuby (via the pure-Ruby implementation), TruffleRuby, and Rails 7.2+; the CI matrix is generated automatically.
+Supports all maintained CRuby versions (>= 3.1; CI currently covers 3.3, 3.4 and 4.0), JRuby (pure Ruby plus a Java escaper), TruffleRuby (pure Ruby), and Rails 7.2+; the CI matrix is generated automatically, so new Ruby releases are picked up without edits.
 
 ```ruby
 # Gemfile
@@ -208,7 +208,7 @@ This is a dated snapshot. CI has the live numbers. Measured on Ruby 3.4.7 x86_64
 |---|---|---|---|
 | **ruby2html 2.0 (C extension)** | **2,676** | **0.37 ms** | **419** |
 | Erubi 1.x (Rails' ERB engine) | 1,988 (1.35x slower) | 0.50 ms | 713 |
-| ruby2html 2.0 (pure Ruby: JRuby, no compiler) | ~820 | ~1.2 ms | 1,029 |
+| ruby2html 2.0 (pure Ruby, no C extension; CRuby) | ~820 | ~1.2 ms | 1,029 |
 | Phlex 2.4, enlarged attribute cache¹ | ~1,250 (≈2.4x slower) | ~0.8 ms | 831 |
 | Phlex 2.4, defaults | 164 (16x slower) | 6.1 ms | 6,410 |
 | ruby2html 1.6.6 | ~620 | ~1.6 ms | 3,531 |

data/ext/java/Ruby2htmlJrubyService.java

@@ -0,0 +1,95 @@
+// JRuby's only native code: a byte-level HTML escaper, the renderer's hottest
+// primitive. Everything else (tag methods, attributes, content rules) stays in
+// the pure-Ruby twin (lib/gem/ruby2html/render/pure_ruby.rb), which JRuby's JIT
+// optimizes well; on TruffleRuby even the C extension loses to pure Ruby, so
+// only JRuby gets this. The C extension (ext/ruby2html/html_escape.c) is the
+// reference; this must stay byte-identical with it and with PureRuby.escape.
+//
+// require 'ruby2html/ruby2html_jruby' loads this: JRuby maps the base name
+// ruby2html_jruby to the class Ruby2htmlJrubyService (CamelCase + "Service") in
+// the default package, so the name and package here are load-bearing.
+//
+// Built by rake-compiler's Rake::JavaExtensionTask (see Rakefile) into
+// lib/gem/ruby2html/ruby2html_jruby.jar and shipped in the -java platform gem.
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+import org.jruby.util.ByteList;
+
+public class Ruby2htmlJrubyService implements BasicLibraryService {
+    // getOrCreateModule/defineModuleUnder/defineAnnotatedMethods are marked
+    // deprecated on JRuby 10 but remain the load-service API and still work; the
+    // context-taking replacements are not available on the JRuby versions in CI.
+    @SuppressWarnings("deprecation")
+    public boolean basicLoad(final Ruby runtime) {
+        final RubyModule javaNative =
+            runtime.getOrCreateModule("Ruby2html").defineModuleUnder("JavaNative");
+        javaNative.defineAnnotatedMethods(Escaper.class);
+        return true;
+    }
+
+    public static final class Escaper {
+        private static final byte AMP = '&', LT = '<', GT = '>', QUOT = '"', APOS = '\'';
+        private static final byte[] E_AMP = bytes("&amp;");
+        private static final byte[] E_LT = bytes("&lt;");
+        private static final byte[] E_GT = bytes("&gt;");
+        private static final byte[] E_QUOT = bytes("&quot;");
+        private static final byte[] E_APOS = bytes("&#39;");
+
+        private static byte[] bytes(final String s) {
+            final byte[] b = new byte[s.length()];
+            for (int i = 0; i < s.length(); i++) b[i] = (byte) s.charAt(i);
+            return b;
+        }
+
+        private static boolean escapable(final byte b) {
+            return b == AMP || b == LT || b == GT || b == QUOT || b == APOS;
+        }
+
+        // Ruby2html::JavaNative.escape(str) -> String
+        //
+        // str has already been run through PureRuby.utf8_compatible, so its
+        // encoding is UTF-8, US-ASCII or BINARY. All five escapable characters
+        // are ASCII, so escaping byte by byte is identical across those
+        // encodings and for bytes that are invalid UTF-8 (the C extension and
+        // PureRuby both pass such bytes through). The result keeps the input's
+        // encoding. A clean string is returned unchanged (same object), which
+        // PureRuby.escape_html relies on to avoid a copy.
+        @JRubyMethod(name = "escape", module = true)
+        public static IRubyObject escape(final ThreadContext ctx, final IRubyObject self,
+                                         final IRubyObject arg) {
+            final RubyString str = (RubyString) arg;
+            final ByteList in = str.getByteList();
+            final byte[] src = in.getUnsafeBytes();
+            final int begin = in.getBegin();
+            final int len = in.getRealSize();
+
+            int first = -1;
+            for (int i = 0; i < len; i++) {
+                if (escapable(src[begin + i])) { first = i; break; }
+            }
+            if (first < 0) return str; // nothing to escape: hand back the same string
+
+            final ByteList out = new ByteList(len + 16);
+            out.setEncoding(in.getEncoding());
+            out.append(src, begin, first);
+            for (int i = first; i < len; i++) {
+                final byte b = src[begin + i];
+                switch (b) {
+                    case AMP:  out.append(E_AMP);  break;
+                    case LT:   out.append(E_LT);   break;
+                    case GT:   out.append(E_GT);   break;
+                    case QUOT: out.append(E_QUOT); break;
+                    case APOS: out.append(E_APOS); break;
+                    default:   out.append(b);
+                }
+            }
+            return RubyString.newString(ctx.runtime, out);
+        }
+    }
+}

data/ext/ruby2html/extconf.rb

@@ -12,6 +12,10 @@ end
 
 skip_native_extension('RUBY2HTML_DISABLE_EXT=1') if ENV['RUBY2HTML_DISABLE_EXT'] == '1'
 skip_native_extension('JRuby does not load C extensions') if RUBY_ENGINE == 'jruby'
+# TruffleRuby runs C extensions through Sulong (an LLVM interpreter) but gives
+# pure Ruby the full Graal JIT, which here renders ~28x faster than the
+# extension. Building it would only slow TruffleRuby down, so don't.
+skip_native_extension('TruffleRuby is faster on the pure-Ruby renderer') if RUBY_ENGINE == 'truffleruby'
 
 require 'mkmf'
 

data/lib/gem/ruby2html/component.rb

@@ -64,8 +64,10 @@ module Ruby2html
     # The buffer currently written to (RailsComponents swap it to capture blocks).
     attr_accessor :current_output
 
-    # Rails' entry point: `render component` in views and controllers.
-    def render_in(view_context, &block)
+    # Rails' entry point: `render component` in views and controllers. Rails 8.2+ passes
+    # `locals:` (render_in without options is deprecated there); a component takes its data
+    # through #initialize, so options are accepted and ignored.
+    def render_in(view_context, **_options, &block)
       buffer = String.new(capacity: self.class.__r2h_capacity, encoding: Encoding::UTF_8)
       content = block && -> { plain(view_context.capture(self, &block)) }
       render_into(buffer, view_context, content)

data/lib/gem/ruby2html/render/pure_ruby.rb

@@ -8,6 +8,16 @@ rescue LoadError
   nil
 end
 
+if RUBY_ENGINE == 'jruby' && ENV['RUBY2HTML_DISABLE_EXT'] != '1'
+  begin
+    # Defines Ruby2html::JavaNative (a byte-level HTML escaper, ext/java).
+    # JRuby's only native code; PureRuby.escape uses it when present.
+    require 'ruby2html/ruby2html_jruby'
+  rescue LoadError
+    nil
+  end
+end
+
 module Ruby2html
   # Pure-Ruby twin of the C extension's Ruby2html::Native (ext/ruby2html),
   # used on JRuby, when the extension isn't built, or with
@@ -33,6 +43,13 @@ module Ruby2html
         def escape(str)
           ERB::Escape.html_escape(utf8_compatible(str))
         end
+      elsif defined?(Ruby2html::JavaNative)
+        # JRuby: the Java escaper (ext/java). Byte-identical with the regex
+        # branch below (and with the C extension); also returns str itself
+        # when clean. utf8_compatible first, so it sees UTF-8/US-ASCII/BINARY.
+        def escape(str)
+          Ruby2html::JavaNative.escape(utf8_compatible(str))
+        end
       else
         def escape(str)
           str = utf8_compatible(str)

data/lib/gem/ruby2html/render.rb

@@ -9,6 +9,10 @@ module Ruby2html
   # into lib/ruby2html.
   def self.load_native_extension
     return false if ENV['RUBY2HTML_DISABLE_EXT'] == '1'
+    # JRuby has no C extension (it uses a Java escaper over the pure-Ruby twin,
+    # see load_java_escaper). TruffleRuby *can* load it via Sulong, but renders
+    # ~28x slower that way than on pure Ruby under the Graal JIT, so never do.
+    return false if RUBY_ENGINE == 'jruby' || RUBY_ENGINE == 'truffleruby'
 
     begin
       require 'ruby2html/ruby2html'
@@ -16,7 +20,10 @@ module Ruby2html
       require_relative '../../ruby2html/ruby2html'
     end
     defined?(Native) ? true : false
-  rescue LoadError
+  rescue LoadError => e
+    # On CRuby a missing extension means a broken build: say so instead of
+    # silently rendering about 3x slower.
+    warn "ruby2html: C extension not loaded (#{e.message}); using the pure-Ruby renderer"
     false
   end
   private_class_method :load_native_extension

data/lib/gem/ruby2html/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruby2html
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby2html
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - sebi
@@ -24,6 +24,7 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- ext/java/Ruby2htmlJrubyService.java
 - ext/ruby2html/attributes.c
 - ext/ruby2html/buffer.h
 - ext/ruby2html/content.c
@@ -73,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Transform Ruby code into beautiful, structured HTML with C-optimized performance
 test_files: []