ruby2html 2.1.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 678f6ff9d5e9fe3533aa2cb06c1534ae03dbbe59ef05e7d8ea5b30b6d289ea4c
+  data.tar.gz: 5010cb4cf951235866dacf21613f745315ae084c198476c050bab6616899c10e
+SHA512:
+  metadata.gz: d71d3a65e68d5bb6771c5d988290641969c0580f589b95b25a64926c898753403b685ef452bbb5b18db818fd33bf75015fcbfacd7fa849540184f0ac8f46f68d
+  data.tar.gz: 9bb3546ffe322f98f374ae3fb01622d45485266d2269e74a786957883683a1145a0923cfe1ddaac2e4197a2277d54698c5d827b0cdb1e64ce7db8fc044be7516

data/CHANGELOG.md

@@ -0,0 +1,211 @@
+# Changelog
+
+All notable changes to this project are documented here.
+Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning: [SemVer](https://semver.org/spec/v2.0.0.html).
+Entries before 1.6.6 were reconstructed from `git log` and RubyGems release dates (the repo has no git tags for them); they are best-effort summaries.
+
+## [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.**
+
+### Performance
+
+Measured on Ruby 3.4.7 x86_64 (`bench/render_bench.rb`, a 100-item page with attributes and escaped text):
+
+- About 4.7x faster than 1.6.6 (≈620 → ≈2,950 renders/s) with about 8x fewer allocations per render (3,531 → 419).
+- Faster than Erubi (Rails' ERB engine) and Phlex on the same page; see the README snapshot and the CI benchmark workflow for current numbers.
+- HTML escaping uses SSE2 (x86_64) / NEON (arm64): up to 5.9x faster on large clean text, about 2x on typical strings.
+- `require 'ruby2html'` costs about 0.4 MB and 19 ms (was about 9.5 MB and 116 ms): Prism, the Rails glue and htmlbeautifier load only when used; in eager-loading (production) Rails apps they load at boot instead.
+
+### Added
+
+- `Ruby2html::Component`: a lightweight component base class (no ViewComponent needed) with `view_template`/`call`, `render_in`, `helpers` and `content`; nested components write straight into the parent's buffer.
+- Pure-Ruby implementation with byte-identical output (`Ruby2html::PureRuby`), used on JRuby, when the extension can't be built, or with `RUBY2HTML_DISABLE_EXT=1`. `Ruby2html.native?` and `Ruby2html::IMPLEMENTATION` tell which one is loaded.
+- `Ruby2html.escape_html(obj)`.
+- Attributes: `true` renders a bare attribute, `false` omits it; nested `data:`/`aria:` Hashes expand to `data-user-id="1"`; Arrays render as space-separated tokens (`class: ['btn', active && 'on']`).
+- `.html.rb` templates are compiled with Prism to run directly in the view/component (no instance-variable copying, no `method_missing`).
+- `capture`, `content_for` and `provide` with blocks of ruby2html tags work in `.html.rb` templates.
+- Support for Rails 8.1, ViewComponent 4, JRuby and TruffleRuby; fiber-safe rendering (no thread/fiber-global state).
+- `llms.txt`: complete reference for AI coding tools; `AGENTS.md` (with `CLAUDE.md` symlinked to it) and Claude Code skills/agents for maintainers.
+- CI: generated CRuby matrix (all maintained versions), Rails matrix, Linux x86_64/arm64 and macOS builds, `-Werror` gcc/clang builds, sanitizers, JRuby/TruffleRuby, gem install smoke test, benchmarks in every PR; Dependabot; releases published automatically when a version bump merges (RubyGems trusted publishing).
+- Maintained by [developerz.ai](https://developerz.ai): its maintainer agent triages issues, reviews PRs, merges on green, runs daily health and release checkups, and opens release PRs (`.dz/`).
+
+### Fixed
+
+- Attribute cache keyed by `Object#hash`: a hash collision could render another element's attributes; the cache also grew without bound. Removed.
+- `link_to` rendered a `button_to` form.
+- `form_with` emitted its fields as escaped text, ignored `patch`/`delete` (`_method`), crashed on `submit` without a label, and ignored Rails' CSRF/`data-remote` settings. It now delegates to Rails' own `form_with` and `FormBuilder`.
+- Tags inside `link_to`/`button_to` blocks were emitted before the link instead of inside it.
+- `html_safe` content was escaped twice; non-String content (`p 42`) was silently dropped.
+- A block's String return value replaced markup the block had already written.
+- The `<output>` tag was unusable (shadowed by `Render#output`).
+- Template backtraces were off by 3 lines; the renderer wasn't restored when a template raised; template locals could clash with internal variables or be rewritten into tag calls (`h2 title` in a partial with a `title` local).
+- A rescued exception while writing attributes left a half-written start tag in the output.
+- `HtmlBeautifierMiddleware` beautified each streamed chunk separately, didn't close the body, and touched gzip/204/304 responses.
+- The packaged gem shipped a locally compiled `.so`; `rake build` didn't build a gem.
+
+### Upgrading to 2.0
+
+Templates and components:
+1. `self` in `.html.rb` templates is now the view (or component), not a `Ruby2html::Render`. Replace `self.div` / `self.plain` with `div` / `plain`. Without Prism (Ruby < 3.3 and no `prism` gem) templates still use the 1.x path.
+2. `Thread.current[:__ruby2html_renderer__]` is gone. The active renderer lives on the component/view; use `component.__ruby2html_renderer__`.
+3. `form_with` output now matches Rails (`_method`, `accept-charset`, no forced `data-remote`, no `utf8` field); its builder is a proxy around Rails' `FormBuilder`.
+4. `Ruby2html::ComponentHelper#method_missing` is now private.
+
+HTML output:
+5. Non-String content renders: `p 42` → `<p>42</p>` (1.x: `<p></p>`); `nil` renders nothing.
+6. `html_safe` strings passed as content or returned from a block are inserted raw (1.x escaped them).
+7. A block's return value is used only if the block wrote nothing, and only for String/Symbol/Numeric (1.x: a returned String replaced everything the block wrote).
+8. Attributes: `true` → bare attribute and `false` omitted (except `data-*`, `aria-*`, `draggable`, `spellcheck`, `contenteditable`, which keep `"true"`/`"false"`); Hash values expand; Arrays join with spaces; invalid attribute names raise `ArgumentError`; Hashes/Arrays nested deeper than 32 levels raise `ArgumentError`.
+9. Tag methods accept at most one positional argument (extra arguments raise `ArgumentError`).
+10. The output buffer is UTF-8; strings in other encodings are transcoded (raising `EncodingError` if impossible).
+
+Removed / packaging:
+11. `Ruby2html::ATTRIBUTE_CACHE`, `Render::METHOD_DEFINITIONS`, `Render#output` and the `Render#fast_escape_html` / `#fast_attributes_to_s` / `#fast_buffer_append` / `#fast_render_tag` methods are removed. Use `Ruby2html.escape_html`, the value returned by `render`, or `current_output`.
+12. Ruby >= 3.1 and (for Rails integration) Rails >= 7.2 are required.
+13. `htmlbeautifier` is no longer a dependency: add `gem 'htmlbeautifier'` if you use `Ruby2html::HtmlBeautifierMiddleware`.
+14. The gem's require path is `lib/gem` only.
+
+## [1.6.6] - 2025-02-10
+
+### Fixed
+- Stop shipping a prebuilt `lib/ruby2html/ruby2html.so`; the extension is compiled on install (`*.so` gitignored).
+
+## [1.6.4] - 2025-02-09
+
+### Fixed
+- Renderer fixes following the C extension introduction.
+
+## [1.6.3] - 2025-02-09
+
+### Fixed
+- Template handler, `form_with` and gemspec fixes for the C extension build.
+
+## [1.6.2] - 2025-02-09
+## [1.6.1] - 2025-02-09
+
+Published to RubyGems; no separate commits in the repository history.
+
+## [1.6.0] - 2025-02-09
+
+### Added
+- C extension (`ext/ruby2html`) for HTML escaping, attribute serialization and buffer appends; `rake compile` via rake-compiler.
+
+## [1.5.8] - 2024-11-01
+## [1.5.7] - 2024-11-01
+
+### Changed
+- Load `htmlbeautifier` from the main entry file; renderer cleanup. Dependency updates.
+
+## [1.5.6] - 2024-08-17
+## [1.5.5] - 2024-08-17
+
+### Changed
+- Template handler declares `handles_encoding?`; Railtie cleanup.
+
+## [1.5.4] - 2024-08-12
+
+### Changed
+- Gemspec cleanup.
+
+## [1.5.3] - 2024-08-12
+
+### Added
+- `turbo_stream` tag (`<turbo-stream>`).
+
+## [1.5.2] - 2024-08-12
+
+### Added
+- `turbo_frame` tag (`<turbo-frame>`).
+
+## [1.5.1] - 2024-08-12
+
+### Fixed
+- `link_to` wrapper simplified.
+
+## [1.5.0] - 2024-08-12
+
+### Added
+- Rails helper wrappers: `form_with` (with `label`, `text_field`, `hidden_field`, `password_field`, `file_field`, `submit`), `button_to`, `link_to`, `image_tag`.
+
+## [1.4.0] - 2024-08-10
+
+### Added
+- `Ruby2html::HtmlBeautifierMiddleware`; runtime dependency on `htmlbeautifier`.
+
+## [1.3.3] - 2024-08-10
+
+### Added
+- Support for `config.action_view.annotate_rendered_view_with_filenames`.
+
+## [1.3.2] - 2024-08-09
+
+### Fixed
+- Keyword option handling in tag methods.
+
+## [1.3.1] - 2024-08-09
+
+### Fixed
+- `ComponentHelper` renderer bug.
+
+## [1.3.0] - 2024-08-09
+
+### Added
+- Calling component methods from component templates; nested renderer tracking.
+
+## [1.2.0] - 2024-08-09
+
+### Added
+- ViewComponent support: `.html.rb` component templates, `Ruby2html::ComponentHelper`.
+
+## [1.1.0] - 2024-08-08
+
+### Added
+- `.rb` ActionView template handler (`*.html.rb` views and partials).
+
+## [1.0.0] - 2024-08-08
+
+### Added
+- Initial release: `Ruby2html::Render` DSL, `Ruby2html::RailsHelper#html` for ERB.
+
+[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
+[1.6.3]: https://rubygems.org/gems/ruby2html/versions/1.6.3
+[1.6.2]: https://rubygems.org/gems/ruby2html/versions/1.6.2
+[1.6.1]: https://rubygems.org/gems/ruby2html/versions/1.6.1
+[1.6.0]: https://rubygems.org/gems/ruby2html/versions/1.6.0
+[1.5.8]: https://rubygems.org/gems/ruby2html/versions/1.5.8
+[1.5.7]: https://rubygems.org/gems/ruby2html/versions/1.5.7
+[1.5.6]: https://rubygems.org/gems/ruby2html/versions/1.5.6
+[1.5.5]: https://rubygems.org/gems/ruby2html/versions/1.5.5
+[1.5.4]: https://rubygems.org/gems/ruby2html/versions/1.5.4
+[1.5.3]: https://rubygems.org/gems/ruby2html/versions/1.5.3
+[1.5.2]: https://rubygems.org/gems/ruby2html/versions/1.5.2
+[1.5.1]: https://rubygems.org/gems/ruby2html/versions/1.5.1
+[1.5.0]: https://rubygems.org/gems/ruby2html/versions/1.5.0
+[1.4.0]: https://rubygems.org/gems/ruby2html/versions/1.4.0
+[1.3.3]: https://rubygems.org/gems/ruby2html/versions/1.3.3
+[1.3.2]: https://rubygems.org/gems/ruby2html/versions/1.3.2
+[1.3.1]: https://rubygems.org/gems/ruby2html/versions/1.3.1
+[1.3.0]: https://rubygems.org/gems/ruby2html/versions/1.3.0
+[1.2.0]: https://rubygems.org/gems/ruby2html/versions/1.2.0
+[1.1.0]: https://rubygems.org/gems/ruby2html/versions/1.1.0
+[1.0.0]: https://rubygems.org/gems/ruby2html/versions/1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 sebi
+
+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,263 @@
+# Ruby2html
+
+[![CI](https://github.com/sebyx07/ruby2html/actions/workflows/ci.yml/badge.svg)](https://github.com/sebyx07/ruby2html/actions/workflows/ci.yml)
+[![Gem Version](https://img.shields.io/gem/v/ruby2html)](https://rubygems.org/gems/ruby2html)
+[![Maintained by developerz.ai](https://img.shields.io/badge/maintained%20by-developerz.ai-6f42c1)](https://developerz.ai)
+
+Write views in pure Ruby; get escaped, compact HTML. A C extension handles escaping, attribute serialization and tag rendering. Works standalone, as Rails `.html.rb` templates, inside ERB, and in ViewComponent.
+
+```ruby
+div class: 'card', 'data-controller': 'card' do
+  h2 @product.title
+  p @product.description
+  a 'Details', href: product_path(@product), class: 'btn'
+end
+```
+
+```html
+<div class="card" data-controller="card"><h2>Lamp</h2><p>Warm &amp; bright</p><a href="/products/1" class="btn">Details</a></div>
+```
+
+## Why ruby2html
+
+- **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), 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; 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
+gem 'ruby2html'
+```
+
+```bash
+bundle install   # compiles the native extension (needs a C compiler); pure-Ruby fallback otherwise
+```
+
+## AI agents
+
+**This project is maintained by [developerz.ai](https://developerz.ai).** Its maintainer agent triages issues, reviews every pull request, merges every pull request once its author marks it ready and CI passes, watches project health daily, and opens release PRs. The policy is in [`.dz/maintainer/maintainer.yml`](.dz/maintainer/maintainer.yml). Breaking changes and major releases stay with the owner.
+
+- **Using ruby2html in your app?** Point your agent at [`llms.txt`](llms.txt), the complete reference in one file (DSL rules, escaping, Rails, components, forms, pitfalls). Paste this into your app's `CLAUDE.md` / `AGENTS.md`:
+  ```markdown
+  ## ruby2html views
+  `*.html.rb` templates and `html do ... end` blocks use the ruby2html gem. Before editing them read
+  https://github.com/sebyx07/ruby2html/blob/main/llms.txt
+  ```
+- **Working on this repo?** [`AGENTS.md`](AGENTS.md) is the only agent-instructions file (`CLAUDE.md` is a symlink to it): commands, code map, invariants, how to verify a change, CI/release automation.
+- **Claude Code**: project skills in `.claude/skills/` (`release`, `benchmark`, `add-html-tag`, `review`, `debug-render`, `upgrade-deps`), read-only reviewer subagents in `.claude/agents/` (`perf-reviewer`, `xss-auditor`), and `.claude/settings.json` with a safe permission allowlist and a non-blocking recompile-reminder hook.
+
+## Usage
+
+### DSL basics
+
+- Every HTML5 tag is a method (`div`, `p`, `ul`, `li`, `img`, `input`, ...), plus `turbo_frame` / `turbo_stream`.
+- `tag content, **attrs` or `tag(**attrs) { nested tags }`. Text and attribute values are HTML-escaped; numbers and symbols are converted (`td 42`).
+- Raw HTML only from `html_safe` strings (Rails helpers, `'<hr>'.html_safe`), as content or via `plain`. `plain 'text'` escapes.
+- Attributes: `'data-id': 1` or `data: { id: 1 }`, `class: ['btn', active && 'on']`, `disabled: true` → bare `disabled`, `nil`/`false` omitted.
+
+Full rules and pitfalls: [`llms.txt`](llms.txt).
+
+### Rails views (`.html.rb`)
+
+File: `app/views/products/index.html.rb`
+
+```ruby
+div class: 'container' do
+  h1 'Products', class: 'main-title'
+  link_to 'Home', root_path, class: 'btn btn-primary', 'data-turbo': false
+
+  @products.each do |product|
+    h2 product.title, class: 'item-title', id: "product-#{product.id}"
+    p product.description, class: 'item-description'
+  end
+end
+
+plain '<div>Inline html</div>'.html_safe
+render partial: 'shared/navbar'
+```
+
+Controller instance variables are available. Partials can be `.html.rb` too. `link_to`, `image_tag`, `button_to`, `form_with` and `render` write their output directly; other helpers return a value you must output (`h1 t('.title')`, `plain some_safe_html_helper`).
+
+### Inside ERB
+
+```ruby
+class ApplicationController < ActionController::Base
+  include Ruby2html::RailsHelper # exposes the html(context) helper to views
+end
+```
+
+```erb
+<h1>Legacy ERB header</h1>
+<%= html(self) do
+  div class: 'ruby2html-section' do
+    h2 'This section is powered by Ruby2html'
+    @items.each { |item| p item[:title] }
+  end
+end %>
+```
+
+ERB, Slim and Ruby2html views, partials and components can be mixed freely, so adoption can be gradual.
+
+### ViewComponent
+
+```ruby
+class ApplicationComponent < ViewComponent::Base
+  include Ruby2html::ComponentHelper
+end
+```
+
+Inline `call`:
+
+```ruby
+class GreetingComponent < ApplicationComponent
+  def initialize(name)
+    @name = name
+  end
+
+  def call
+    html do
+      h1 "Hello, #{@name}!", class: 'greeting', 'data-user': @name
+      p 'Welcome to Ruby2html!', class: 'welcome-message'
+    end
+  end
+end
+```
+
+Or a sidecar template, `app/components/farewell_component.html.rb`:
+
+```ruby
+div class: 'farewell' do
+  h1 "Goodbye, #{@name}!", class: 'farewell-message'
+end
+```
+
+Public component methods can be called from the template and may emit tags themselves (see `app/components/first_component.rb`).
+
+### `Ruby2html::Component` (no ViewComponent required)
+
+```ruby
+class CardComponent < Ruby2html::Component
+  def initialize(title:)
+    @title = title
+  end
+
+  def view_template
+    div class: 'card' do
+      h2 @title
+      content                              # block passed to render
+      link_to 'More', helpers.root_path
+    end
+  end
+end
+
+# any view or controller
+render CardComponent.new(title: 'Hi')
+```
+
+Tag methods run on the component itself (no instance-variable copying); nested ruby2html components write into the parent's buffer.
+
+### Forms
+
+```ruby
+form_with model: @user do |f|
+  f.label :email
+  f.text_field :email
+  f.submit 'Save'
+end
+```
+
+### Without Rails
+
+```ruby
+require 'ruby2html'
+
+Ruby2html::Render.new do # optional context object: its public methods and ivars become available
+  html do
+    head { title 'Ruby2html Example' }
+    body { h1 'Hello, World!' }
+  end
+end.render
+# => "<html><head><title>Ruby2html Example</title></head><body><h1>Hello, World!</h1></body></html>"
+```
+
+### Pretty HTML in development
+
+```ruby
+# Gemfile (development group): gem 'htmlbeautifier'
+# config/environments/development.rb
+config.middleware.use Ruby2html::HtmlBeautifierMiddleware
+```
+
+## Performance
+
+Benchmarks run in CI on every push to `main` and every pull request ([`.github/workflows/benchmark.yml`](.github/workflows/benchmark.yml)): the latest run's summary page has the current table, and PRs get a sticky comment with the delta against `main`. Run them locally with `bundle exec rake bench` (standalone scripts in `bench/`) or `bundle exec rspec spec/benchmarks/` (request-level through the demo app, vs ERB, Slim, Phlex and ViewComponent).
+
+### Snapshot at 2.0.0 release (2026-10-31)
+
+This is a dated snapshot. CI has the live numbers. Measured on Ruby 3.4.7 x86_64 on a busy machine (load average about 7), so read the ratios rather than the absolute figures.
+
+**Page render** (`bench/render_bench.rb`, no Rails): a header with nav, 100 list items with links, images, attributes and escaped text, about 34 KB of HTML.
+
+| Engine | Renders/s | Time per render | Allocations per render |
+|---|---|---|---|
+| **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, 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 |
+
+¹ Phlex 2's default attribute cache (2 KB, FIFO) misses on per-row values such as ids and hrefs. `Phlex::ATTRIBUTE_CACHE.expand(1_000_000)` is its best case. Phlex 2 also checks URLs for `javascript:`; ruby2html leaves URL validation to you.
+
+**Full Rails request** (`spec/benchmarks/requests_spec.rb`; Rails 8.1, a 7 ms request where most of the time is Rails itself; differences are within ±15% error):
+
+| Engine | Requests/s |
+|---|---|
+| **`Ruby2html::Component`** | **144.5** |
+| **ViewComponent 4 + ruby2html** | **142.2** |
+| **`.html.rb` template** | **139.6** |
+| Slim | 128.3 |
+| ERB | 122.6 |
+| Phlex 2.4 | 116.6 |
+
+**HTML escaping** (SIMD vs scalar): up to 5.9x faster on 10 KB clean text, about 2x on 200-byte strings; short strings take the scalar path.
+
+**Footprint:**
+
+| | Ruby/C lines | Runtime dependencies | `require` cost |
+|---|---|---|---|
+| **ruby2html** | 1.1k Ruby + 0.8k C | none | ~0.4 MB, ~19 ms |
+| phlex + phlex-rails | 6.2k | refract, zeitwerk, railties | ~1.4 MB, ~30 ms (phlex alone) |
+| view_component | 5.3k | actionview, activesupport, prism | |
+| slim | 7.3k | temple, tilt | |
+
+How it is fast:
+
+- **Tag methods in C**: each tag writes open tag, content/block output and close tag straight into one shared buffer (no nested buffers, no `*args`/`**kwargs` allocation without keywords).
+- **HTML escaping**: 16-byte SSE2/NEON scan for `& < > " '`; clean strings are one `memcpy`, dirty strings get their exact size computed once.
+- **Attributes**: written directly into the buffer, no intermediate strings, no cache to thrash or leak.
+- **Lazy loading**: `require 'ruby2html'` loads only the renderer. Production Rails apps load everything at boot, so forked workers share it copy-on-write.
+- **Templates and components**: `.html.rb` templates are rewritten at compile time (Prism) to run in the view itself; `Ruby2html::Component` runs tag methods on the component. No instance-variable copying or `method_missing` per render.
+- A pure-Ruby implementation with identical output is used when the extension is unavailable.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake compile   # build the C extension
+CI=1 bundle exec rspec     # specs (CI=1 skips the slow benchmark spec)
+bundle exec rubocop
+bin/rails server           # demo app
+```
+
+The repository is both the gem (`lib/gem/`, `ext/ruby2html/`) and a Rails demo app (`app/`, `config/`). See [CONTRIBUTING.md](CONTRIBUTING.md), [docs/architecture.md](docs/architecture.md), [docs/release.md](docs/release.md) and [CHANGELOG.md](CHANGELOG.md).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

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);
+        }
+    }
+}