ruby2html 2.1.0-java

data/ext/ruby2html/ruby2html.h

@@ -0,0 +1,32 @@
+#ifndef RUBY2HTML_H
+#define RUBY2HTML_H
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+/* Interned at Init so hot paths never call rb_intern. */
+extern ID r2h_id_current_output;
+extern ID r2h_id_html_safe_p;
+
+/* html_escape.c */
+void r2h_init_escape(VALUE native);
+VALUE r2h_utf8_compatible(VALUE str);
+void r2h_append_escaped(VALUE buf, VALUE str);
+void r2h_append_escaped_wrapped(VALUE buf, const char *before, long before_len, VALUE str,
+                                const char *after, long after_len);
+void r2h_append_raw(VALUE buf, VALUE str);
+
+/* attributes.c */
+void r2h_append_attributes(VALUE buf, VALUE attrs);
+
+/* content.c */
+void r2h_init_content(VALUE native);
+VALUE r2h_current_buffer(VALUE self);
+void r2h_append_long(VALUE buf, long value);
+void r2h_append_text(VALUE buf, VALUE obj);
+void r2h_append_block_result(VALUE buf, VALUE result);
+
+/* tag_render.c */
+void r2h_init_tags(VALUE native);
+
+#endif

data/ext/ruby2html/tag_render.c

@@ -0,0 +1,179 @@
+/*
+ * Tag methods (div, p, img, ...) implemented in C.
+ *
+ * Each tag is a C method, so a call costs no Ruby frame, no *args or **kwargs
+ * allocation when called without keywords, and block content is rendered
+ * straight into the shared buffer (open tag, yield, close tag) instead of
+ * into a nested buffer that is copied afterwards.
+ *
+ * The tag list itself lives in Ruby (Render::HTML5_TAGS). A C method can't
+ * carry data, so define_tag binds each tag to a slot of a fixed pool of
+ * one-line trampolines, each of which passes its slot to render_tag.
+ */
+#include "buffer.h"
+
+#define R2H_MAX_TAGS 200
+#define R2H_MAX_TAG_NAME 32
+
+typedef struct {
+    char open[R2H_MAX_TAG_NAME + 5];  /* "<div>", or "<br />" for void tags, + NUL */
+    char close[R2H_MAX_TAG_NAME + 4]; /* "</div>" + NUL */
+    long open_len;
+    long name_len; /* "<div" is open[0, name_len + 1) */
+    long close_len;
+    int is_void;
+    ID method;
+} r2h_tag;
+
+static r2h_tag tags[R2H_MAX_TAGS];
+static int tag_count;
+
+typedef struct {
+    VALUE buf;
+    VALUE attrs;
+} attrs_args;
+
+static VALUE append_attributes_protected(VALUE data)
+{
+    const attrs_args *args = (const attrs_args *)data;
+    r2h_append_attributes(args->buf, args->attrs);
+    return Qnil;
+}
+
+static void open_tag(VALUE buf, const r2h_tag *tag, VALUE attrs)
+{
+    if (NIL_P(attrs)) {
+        r2h_buf_cat(buf, tag->open, tag->open_len);
+        return;
+    }
+    /*
+     * If an attribute raises (invalid name, a value's to_s raising) and the
+     * caller rescues, a half-written `<div class="x` would turn whatever is
+     * appended next into markup. Roll the buffer back to before the tag.
+     */
+    const long mark = RSTRING_LEN(buf);
+    r2h_buf_cat(buf, tag->open, tag->name_len + 1);
+    attrs_args args = { buf, attrs };
+    int state = 0;
+    rb_protect(append_attributes_protected, (VALUE)&args, &state);
+    if (state) {
+        /*
+         * rb_str_resize (not set_len): the failing to_s may have replaced,
+         * shared or shrunk the buffer. Leave a frozen buffer alone so the
+         * original exception propagates.
+         */
+        if (!OBJ_FROZEN(buf) && RSTRING_LEN(buf) >= mark) rb_str_resize(buf, mark);
+        rb_jump_tag(state);
+    }
+    if (tag->is_void) {
+        R2H_BUF_CAT_LIT(buf, " />");
+    } else {
+        R2H_BUF_CAT_LIT(buf, ">");
+    }
+}
+
+/*
+ * tag(content = nil, **attributes) { ... }
+ *
+ * With a block, the block's output is the content (content is ignored);
+ * void tags ignore content and block.
+ */
+static VALUE render_tag(int argc, VALUE *argv, VALUE self, const r2h_tag *tag)
+{
+    VALUE attrs = Qnil, content = Qnil;
+
+    if (argc > 0 && rb_keyword_given_p()) {
+        attrs = argv[--argc];
+        if (RHASH_EMPTY_P(attrs)) attrs = Qnil;
+    }
+    if (argc > 1) rb_error_arity(argc, 0, 1);
+    if (argc == 1) content = argv[0];
+
+    VALUE buf = r2h_current_buffer(self);
+    const int block_given = rb_block_given_p();
+
+    /* Fast path for the most common shape, `li "text"`: one buffer write. */
+    if (NIL_P(attrs) && !block_given && !tag->is_void && RB_TYPE_P(content, T_STRING) &&
+        RBASIC_CLASS(content) == rb_cString) {
+        r2h_append_escaped_wrapped(buf, tag->open, tag->open_len, content, tag->close, tag->close_len);
+        return Qnil;
+    }
+
+    open_tag(buf, tag, attrs);
+    if (tag->is_void) return Qnil;
+
+    if (block_given) {
+        const long before = RSTRING_LEN(buf);
+        VALUE result = rb_yield_values2(0, NULL);
+        if (RSTRING_LEN(buf) == before) r2h_append_block_result(buf, result);
+    } else {
+        r2h_append_text(buf, content);
+    }
+    r2h_buf_cat(buf, tag->close, tag->close_len);
+    RB_GC_GUARD(buf);
+    return Qnil;
+}
+
+#define R2H_TRAMPOLINE(n) \
+    static VALUE tag_##n(int argc, VALUE *argv, VALUE self) { return render_tag(argc, argv, self, &tags[n]); }
+#define R2H_TRAMPOLINE_REF(n) tag_##n,
+#define R2H_TEN(M, d) M(d##0) M(d##1) M(d##2) M(d##3) M(d##4) M(d##5) M(d##6) M(d##7) M(d##8) M(d##9)
+#define R2H_TWO_HUNDRED(M) \
+    R2H_TEN(M, ) R2H_TEN(M, 1) R2H_TEN(M, 2) R2H_TEN(M, 3) R2H_TEN(M, 4) R2H_TEN(M, 5) R2H_TEN(M, 6) \
+    R2H_TEN(M, 7) R2H_TEN(M, 8) R2H_TEN(M, 9) R2H_TEN(M, 10) R2H_TEN(M, 11) R2H_TEN(M, 12) R2H_TEN(M, 13) \
+    R2H_TEN(M, 14) R2H_TEN(M, 15) R2H_TEN(M, 16) R2H_TEN(M, 17) R2H_TEN(M, 18) R2H_TEN(M, 19)
+
+R2H_TWO_HUNDRED(R2H_TRAMPOLINE)
+
+typedef VALUE (*r2h_tag_fn)(int, VALUE *, VALUE);
+static const r2h_tag_fn trampolines[R2H_MAX_TAGS] = { R2H_TWO_HUNDRED(R2H_TRAMPOLINE_REF) };
+
+/* Tag names are written unescaped, so only allow [a-z0-9-]. */
+static void validate_tag_name(VALUE name)
+{
+    const char *p = RSTRING_PTR(name);
+    const long len = RSTRING_LEN(name);
+
+    if (len == 0 || len > R2H_MAX_TAG_NAME) rb_raise(rb_eArgError, "invalid tag name: %+" PRIsVALUE, name);
+    for (long i = 0; i < len; i++) {
+        const char c = p[i];
+        if (!((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-')) {
+            rb_raise(rb_eArgError, "invalid tag name: %+" PRIsVALUE, name);
+        }
+    }
+}
+
+static r2h_tag *slot_for(ID method)
+{
+    for (int i = 0; i < tag_count; i++) {
+        if (tags[i].method == method) return &tags[i];
+    }
+    if (tag_count == R2H_MAX_TAGS) rb_raise(rb_eRuntimeError, "ruby2html: more than %d tags", R2H_MAX_TAGS);
+    return &tags[tag_count++];
+}
+
+/* Ruby2html::Native.define_tag(method_name, tag_name, void) */
+static VALUE native_define_tag(VALUE native, VALUE method_name, VALUE tag_name, VALUE is_void)
+{
+    const ID method = rb_to_id(method_name);
+    StringValue(tag_name);
+    validate_tag_name(tag_name);
+
+    r2h_tag *tag = slot_for(method);
+    const long len = RSTRING_LEN(tag_name);
+    tag->method = method;
+    tag->is_void = RTEST(is_void);
+    tag->name_len = len;
+    tag->open_len = snprintf(tag->open, sizeof(tag->open), tag->is_void ? "<%.*s />" : "<%.*s>", (int)len,
+                             RSTRING_PTR(tag_name));
+    tag->close_len = snprintf(tag->close, sizeof(tag->close), "</%.*s>", (int)len, RSTRING_PTR(tag_name));
+
+    /* rb_define_method (not _id): TruffleRuby doesn't implement rb_define_method_id. */
+    rb_define_method(native, rb_id2name(method), trampolines[tag - tags], -1);
+    return Qnil;
+}
+
+void r2h_init_tags(VALUE native)
+{
+    rb_define_singleton_method(native, "define_tag", native_define_tag, 3);
+}

data/lib/gem/ruby2html/component.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative 'render'
+
+module Ruby2html
+  # Lightweight component without ViewComponent:
+  #
+  #   class CardComponent < Ruby2html::Component
+  #     def initialize(title:) = @title = title
+  #
+  #     def view_template
+  #       div class: 'card' do
+  #         h2 @title
+  #         content            # block given to render, if any
+  #         link_to 'More', helpers.root_path
+  #       end
+  #     end
+  #   end
+  #
+  #   render CardComponent.new(title: 'Hi')   # ERB, controllers, .html.rb
+  #
+  # Why it is fast: the tag methods are mixed straight into the component and
+  # write into a buffer it is handed, so templates run with +self+ = the
+  # component (own ivars, no copying, no instance_exec, no method_missing).
+  # Nested in another Ruby2html component or .html.rb template it writes into
+  # the parent's buffer directly; only the outermost render allocates one.
+  #
+  # Define +view_template+ (or +call+). +template+ is accepted when a subclass
+  # overrides it, but shadows the <template> tag for that component.
+  class Component
+    include Ruby2html::IMPLEMENTATION
+
+    INITIAL_CAPACITY = 1024
+
+    # Rails helpers whose markup must land in the component's buffer. The
+    # component itself is the RailsComponents "renderer" (it has #plain and
+    # #current_output). Constants are resolved lazily: they need ActionView.
+    Render::RAILS_HELPER_COMPONENTS.each do |name, klass|
+      define_method(name) do |*args, **options, &block|
+        RailsComponents.const_get(klass).new(self, helpers, name, *args, **options).render(&block)
+      end
+    end
+
+    class << self
+      # Entry method, resolved once per class.
+      def __r2h_entry
+        @__r2h_entry ||=
+          if method_defined?(:view_template) then :view_template
+          elsif method_defined?(:call) then :call
+          elsif instance_method(:template).owner != Ruby2html::IMPLEMENTATION then :template
+          else raise NotImplementedError, "#{name} must define #view_template (or #call)"
+          end
+      end
+
+      # Last output size, so the next top-level render pre-sizes its buffer.
+      # A benign race between threads only affects the capacity hint.
+      attr_writer :__r2h_capacity
+
+      def __r2h_capacity
+        @__r2h_capacity || INITIAL_CAPACITY
+      end
+    end
+
+    # The buffer currently written to (RailsComponents swap it to capture blocks).
+    attr_accessor :current_output
+
+    # 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)
+      self.class.__r2h_capacity = buffer.bytesize if buffer.bytesize > self.class.__r2h_capacity
+      defined?(ActiveSupport::SafeBuffer) ? ActiveSupport::SafeBuffer.new(buffer) : buffer
+    end
+
+    # Writes the component into +buffer+ (a parent's output) and returns nil.
+    # +content+ is a callable run by #content. Re-entrant: state is restored.
+    def render_into(buffer, view_context, content = nil)
+      previous_output = @current_output
+      previous_helpers = @__r2h_helpers
+      previous_content = @__r2h_content
+      @current_output = buffer
+      @__r2h_helpers = view_context
+      @__r2h_content = content
+      __send__(self.class.__r2h_entry)
+      nil
+    ensure
+      @current_output = previous_output
+      @__r2h_helpers = previous_helpers
+      @__r2h_content = previous_content
+    end
+
+    # The view context (Rails helpers, routes, request, ...).
+    def helpers
+      return @__r2h_helpers if @__r2h_helpers
+
+      raise Ruby2html::Error, "#{self.class.name}#helpers is only available while rendering"
+    end
+
+    # Emits the block given to render (see #render_in / #render).
+    def content
+      @__r2h_content&.call
+      nil
+    end
+
+    # Renders another component into this buffer, or anything Rails can
+    # render (partials, ViewComponents) via the view context.
+    def render(*args, **options, &block)
+      first = args.first
+      if args.size == 1 && options.empty? && first.is_a?(Component)
+        first.render_into(@current_output, helpers, block)
+      else
+        plain(helpers.render(*args, **options, &block))
+      end
+      nil
+    end
+  end
+end

data/lib/gem/ruby2html/component_helper.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Ruby2html
+  # Mixed into ViewComponents (or any object) to render with Ruby2html.
+  #
+  # The active renderer is stored on the component itself (+@__r2h+), never in
+  # thread/fiber-global state, so interleaved renders (fiber schedulers,
+  # Falcon, async) can't see each other's renderer. Component methods called
+  # while rendering (e.g. a helper that emits +div+) reach it through
+  # method_missing. +.html.rb+ templates set the same ivar on their view or
+  # component (see TemplateHandler).
+  #
+  # Each render saves the previous value and restores it in +ensure+, so
+  # re-entrant +html+ calls and exceptions leave no stale renderer behind.
+  # The ivar starts with '@_' so Render does not copy it into itself.
+  module ComponentHelper
+    def html(&block)
+      previous_renderer = @__r2h
+      renderer = Ruby2html::Render.new(self, &block)
+      @__r2h = renderer
+      output = renderer.render
+      # Render#render already returns a SafeBuffer under Rails; avoid copying it.
+      output.html_safe? ? output : output.html_safe
+    ensure
+      @__r2h = previous_renderer
+    end
+
+    # The renderer currently rendering this object, or nil.
+    def __ruby2html_renderer__
+      @__r2h
+    end
+
+    private
+      def method_missing(name, ...)
+        renderer = @__r2h
+        return super if renderer.nil? || !renderer.respond_to?(name)
+
+        renderer.__send__(name, ...)
+      end
+
+      # Only claims the renderer's own methods (tags, plain, component, ...).
+      # Asking the renderer's respond_to? here could recurse back into this
+      # object, because the renderer delegates respond_to? to its context.
+      def respond_to_missing?(name, include_private = false)
+        (@__r2h && Ruby2html::Render.method_defined?(name)) || super
+      end
+  end
+end

data/lib/gem/ruby2html/html_beautifier_middleware.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Ruby2html
+  # Development/test middleware that re-indents HTML responses with
+  # HtmlBeautifier. Responses are left untouched unless they are buffered,
+  # uncompressed text/html with a body.
+  class HtmlBeautifierMiddleware
+    CONTENT_TYPE = 'content-type'
+    CONTENT_LENGTH = 'content-length'
+    CONTENT_ENCODING = 'content-encoding'
+    TRANSFER_ENCODING = 'transfer-encoding'
+
+    def initialize(app)
+      self.class.load_beautifier
+      @app = app
+    end
+
+    # htmlbeautifier is an optional dependency, only needed by this middleware.
+    def self.load_beautifier
+      require 'htmlbeautifier'
+    rescue LoadError => e
+      raise LoadError, "Ruby2html::HtmlBeautifierMiddleware needs the htmlbeautifier gem. Add `gem 'htmlbeautifier'` " \
+                       "to your Gemfile (e.g. in the :development group) or remove the middleware. (#{e.message})"
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      return [status, headers, body] unless beautify?(status, headers, body)
+
+      html = HtmlBeautifier.beautify(read_body(body))
+      set_header(headers, CONTENT_LENGTH, html.bytesize.to_s)
+      [status, headers, [html]]
+    end
+
+    private
+      def beautify?(status, headers, body)
+        status >= 200 && status != 204 && status != 304 &&
+          header(headers, CONTENT_TYPE)&.include?('text/html') &&
+          header(headers, CONTENT_ENCODING).nil? && # gzip etc.: bytes aren't HTML
+          header(headers, TRANSFER_ENCODING).nil? && # streamed by the app
+          body.respond_to?(:to_ary) # Rack 3: only buffered bodies; never drain a stream
+      end
+
+      # Beautify the document as a whole: chunk boundaries can fall inside tags.
+      # Per Rack spec the original body must be closed once consumed.
+      def read_body(body)
+        chunks = body.to_ary
+        chunks.size == 1 ? chunks.first.to_s : chunks.join
+      ensure
+        body.close if body.respond_to?(:close)
+      end
+
+      # Rack 3 headers are lowercase (and Rails uses case-insensitive
+      # Rack::Headers); fall back to a scan for plain hashes from older apps.
+      def header(headers, name)
+        key = header_key(headers, name)
+        key && headers[key]
+      end
+
+      def set_header(headers, name, value)
+        headers[header_key(headers, name) || name] = value
+      end
+
+      def header_key(headers, name)
+        return name if headers.key?(name)
+
+        headers.each_key.find { |key| key.casecmp?(name) }
+      end
+  end
+end

data/lib/gem/ruby2html/rails_components/base_component.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'output_capture'
+
+module Ruby2html
+  module RailsComponents
+    # Calls the Rails helper named +method+ on the view context and appends its
+    # (html_safe) result to the renderer. A block given to the helper is
+    # captured from the renderer's buffer, so nested Ruby2html tags end up
+    # inside the helper's markup.
+    class BaseComponent
+      include OutputCapture
+
+      def initialize(render, context, method, *args, **options)
+        @render = render
+        @context = context
+        @method = method
+        @args = args
+        @options = options
+      end
+
+      def render(&block)
+        @render.plain(@context.public_send(@method, *@args, **@options, &capturing(block)))
+        nil
+      end
+    end
+  end
+end

data/lib/gem/ruby2html/rails_components/button_to.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+
+module Ruby2html
+  module RailsComponents
+    # Delegates to Rails' +button_to+; see BaseComponent.
+    class ButtonTo < BaseComponent
+    end
+  end
+end

data/lib/gem/ruby2html/rails_components/form_with.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+
+module Ruby2html
+  module RailsComponents
+    # Delegates to Rails' +form_with+ so the form tag, CSRF token, method
+    # spoofing (_method), multipart detection and URL resolution match Rails
+    # exactly. The yielded builder is wrapped in a FormBuilderProxy so that
+    # calls like +f.text_field :name+ write straight into the Ruby2html output.
+    class FormWith < BaseComponent
+      private
+        def block_arg(arg)
+          FormBuilderProxy.wrap(@render, arg)
+        end
+    end
+
+    # Forwards every call to the wrapped ActionView FormBuilder. Markup results
+    # (html_safe strings) are appended to the renderer and +nil+ is returned so
+    # a block's return value can't re-emit them; anything else (f.object,
+    # f.field_id, ...) is returned unchanged. Builder methods that clash with
+    # private Kernel methods (select, format, ...) still reach method_missing.
+    class FormBuilderProxy
+      include OutputCapture
+
+      def self.wrap(render, arg)
+        return arg unless defined?(ActionView::Helpers::FormBuilder) && arg.is_a?(ActionView::Helpers::FormBuilder)
+
+        new(render, arg)
+      end
+
+      def initialize(render, builder)
+        @render = render
+        @builder = builder
+      end
+
+      # The underlying ActionView::Helpers::FormBuilder.
+      def __builder__
+        @builder
+      end
+
+      def method_missing(name, ...)
+        return super unless @builder.respond_to?(name)
+
+        forward(name, ...)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @builder.respond_to?(name, include_private)
+      end
+
+      private
+        def forward(name, *args, **options, &block)
+          result = @builder.public_send(name, *args, **options, &capturing(block))
+          return result unless result.is_a?(String) && result.html_safe?
+
+          @render.plain(result)
+          nil
+        end
+
+        # Nested builders (fields_for / fields) are wrapped as well.
+        def block_arg(arg)
+          FormBuilderProxy.wrap(@render, arg)
+        end
+    end
+  end
+end

data/lib/gem/ruby2html/rails_components/image_tag.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+
+module Ruby2html
+  module RailsComponents
+    # Delegates to Rails' +image_tag+; see BaseComponent.
+    class ImageTag < BaseComponent
+    end
+  end
+end

data/lib/gem/ruby2html/rails_components/link_to.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+
+module Ruby2html
+  module RailsComponents
+    # Delegates to Rails' +link_to+; see BaseComponent.
+    class LinkTo < BaseComponent
+    end
+  end
+end

data/lib/gem/ruby2html/rails_components/output_capture.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Ruby2html
+  module RailsComponents
+    # Bridges Ruby2html blocks and Rails helpers that take a block.
+    #
+    # Rails helpers (link_to, button_to, form_with, FormBuilder#label, ...) run
+    # their block through ActionView's +capture+, which only sees the view's
+    # output buffer. Ruby2html tag methods write into the renderer's buffer
+    # instead, so without this bridge nested tags would leak out *before* the
+    # helper's markup. Including classes must set +@render+.
+    module OutputCapture
+      private
+        # Wraps +block+ in a proc for a Rails helper. The proc redirects the
+        # renderer's output into a scratch buffer while the block runs and
+        # returns that markup as html_safe. +block_arg+ lets subclasses swap
+        # yielded objects (e.g. wrap a FormBuilder) before the user sees them.
+        def capturing(block)
+          return unless block
+
+          proc { |*yielded| capture_output(*yielded.map! { |arg| block_arg(arg) }, &block) }
+        end
+
+        def capture_output(*args)
+          previous = @render.current_output
+          buffer = String.new(capacity: 256)
+          @render.current_output = buffer
+          value = yield(*args)
+          # Same rule as ActionView's capture: markup written to the buffer wins,
+          # otherwise the block's return value is used (Rails escapes it if unsafe).
+          buffer.empty? ? value : buffer.html_safe
+        ensure
+          @render.current_output = previous
+        end
+
+        def block_arg(arg)
+          arg
+        end
+    end
+  end
+end

data/lib/gem/ruby2html/rails_components/template_collector.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Loaded by TemplateCompiler.available? after Prism (Prism::Visitor must exist).
+module Ruby2html
+  module RailsComponents
+    class TemplateCompiler
+      # Walks the AST collecting insertions. Method/class bodies are skipped:
+      # the renderer local isn't visible there.
+      class Collector < Prism::Visitor
+        attr_reader :edits, :uses_helpers
+
+        def initialize(renderer_methods)
+          super()
+          @renderer_methods = renderer_methods
+          @edits = []
+          @uses_helpers = false
+        end
+
+        def visit_call_node(node)
+          rewrite(node) if node.receiver.nil?
+          return super unless own_renderer_block?(node)
+
+          # The block belongs to a fresh renderer (e.g. Ruby2html::Render.new
+          # { p 'x' }) and is instance_exec'd on it, so its receiverless calls
+          # must stay receiverless. Visit everything except the block body.
+          node.receiver&.accept(self)
+          node.arguments&.accept(self)
+        end
+
+        def visit_def_node(_node); end
+        def visit_class_node(_node); end
+        def visit_module_node(_node); end
+        def visit_singleton_class_node(_node); end
+
+        private
+          # `Render.new { ... }` / `Ruby2html::Render.new { ... }`
+          def own_renderer_block?(node)
+            return false unless node.name == :new && node.block.is_a?(Prism::BlockNode)
+
+            receiver = node.receiver
+            case receiver
+            when Prism::ConstantReadNode then receiver.name == :Render
+            when Prism::ConstantPathNode then receiver.name == :Render
+            else false
+            end
+          end
+
+          def rewrite(node)
+            name = node.name
+            return unless node.message_loc
+
+            if @renderer_methods.include?(name)
+              @edits << [node.message_loc.start_offset, TemplateCompiler::RENDERER_PREFIX]
+            elsif TemplateCompiler.helper_methods.include?(name)
+              @edits << [node.message_loc.start_offset, TemplateCompiler::HELPERS_PREFIX]
+              @uses_helpers = true
+            end
+          end
+      end
+    end
+  end
+end