ruby2html 2.1.0-java

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Ruby2html
+  module RailsComponents
+    # Compile-time rewrite of a .html.rb template.
+    #
+    # Instead of instance_exec'ing the template on a Render (which forces the
+    # renderer to copy every view instance variable on each render and to
+    # route every helper call through method_missing), the template runs
+    # directly in the view/component. Prism finds the receiverless calls that
+    # belong to Ruby2html and gives them an explicit receiver:
+    #
+    #   div class: 'x' do       =>  __r2h_renderer.div class: 'x' do
+    #   link_to 'Home', '/'     =>  __r2h_helpers.link_to 'Home', '/'
+    #   render partial: 'nav'   =>  __r2h_helpers.render partial: 'nav'
+    #
+    # Only text is inserted, never newlines, so line numbers are unchanged.
+    class TemplateCompiler
+      RENDERER = '__r2h_renderer'
+      HELPERS = '__r2h_helpers'
+      RENDERER_PREFIX = "#{RENDERER}."
+      HELPERS_PREFIX = "#{HELPERS}."
+
+      def self.helper_methods
+        @helper_methods ||= TemplateHelpers.public_instance_methods(false).to_set.freeze
+      end
+
+      Result = Struct.new(:source, :uses_helpers)
+
+      class << self
+        # Prism is only loaded when the first template is compiled. Without it
+        # (Ruby < 3.3 and no prism gem) TemplateHandler falls back to the
+        # closure strategy (template block instance_exec'd on the renderer).
+        def available?
+          return @available if defined?(@available)
+
+          @available = begin
+            require 'prism'
+            require_relative 'template_collector'
+            true
+          rescue LoadError
+            false
+          end
+        end
+
+        # Returns a Result, or nil when the source can't be parsed (the caller
+        # then compiles it unchanged so Ruby reports the syntax error).
+        # +locals+: the template's local names (partial locals, `locals:`).
+        # Prism must know them, or `h2 title` would parse `title` as a call
+        # and be rewritten into a <title> tag.
+        def compile(source, locals = [])
+          return unless available?
+
+          parsed = locals.empty? ? Prism.parse(source) : Prism.parse(source, scopes: [locals.map(&:to_sym)])
+          return unless parsed.success?
+
+          collector = Collector.new(renderer_methods)
+          parsed.value.accept(collector)
+          Result.new(apply(source, collector.edits), collector.uses_helpers)
+        end
+
+        # Ruby2html methods a template may call without a receiver: every
+        # tag method plus plain/component. Resolved lazily (and memoized) so
+        # it reflects Render after it has been fully loaded.
+        def renderer_methods
+          @renderer_methods ||= begin
+            tags = Ruby2html::Render::HTML5_TAGS.map { |tag| tag.tr('-', '_').to_sym }
+            (tags + %i[plain component]).select { |name| Ruby2html::Render.public_method_defined?(name) }.to_set.freeze
+          end
+        end
+
+        private
+          # Edits are [byte_offset, text] insertions; Prism offsets are bytes.
+          def apply(source, edits)
+            return source if edits.empty?
+
+            bytes = source.b
+            out = String.new(capacity: bytes.bytesize + (edits.size * 16), encoding: Encoding::BINARY)
+            cursor = 0
+            edits.sort_by!.with_index { |(offset, _), index| [offset, index] }.each do |offset, text|
+              out << bytes.byteslice(cursor, offset - cursor) << text
+              cursor = offset
+            end
+            out << bytes.byteslice(cursor, bytes.bytesize - cursor)
+            out.force_encoding(source.encoding)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'output_capture'
+require_relative 'base_component'
+require_relative 'link_to'
+require_relative 'button_to'
+require_relative 'image_tag'
+require_relative 'form_with'
+
+module Ruby2html
+  module RailsComponents
+    # Receiver for the Rails helper calls of a compiled .html.rb template
+    # (see TemplateCompiler). Routes each helper through its RailsComponents
+    # wrapper so the helper's markup lands in the Ruby2html buffer.
+    class TemplateHelpers
+      include OutputCapture
+
+      COMPONENTS = {
+        link_to: LinkTo,
+        button_to: ButtonTo,
+        image_tag: ImageTag,
+        form_with: FormWith
+      }.freeze
+
+      def initialize(render, context)
+        @render = render
+        @context = context
+      end
+
+      COMPONENTS.each do |name, component|
+        define_method(name) do |*args, **options, &block|
+          component.new(@render, @context, name, *args, **options).render(&block)
+        end
+      end
+
+      # Ruby2html::Component instances write straight into the template's
+      # buffer; anything else (partials, ViewComponents, ...) goes through the
+      # view's render and is appended. A block is captured from the Ruby2html
+      # buffer so its tags end up inside the rendered output.
+      def render(*args, **options, &block)
+        first = args.first
+        if args.size == 1 && options.empty? && first.is_a?(Ruby2html::Component)
+          first.render_into(@render.current_output, @context, block)
+        else
+          @render.plain(@context.render(*args, **options, &capturing(block)))
+        end
+        nil
+      end
+
+      # ActionView's capture only sees the view's output buffer, so a block of
+      # Ruby2html tags would be written to the page and capture nothing.
+      # Redirect the renderer's buffer instead (same return rule as Rails).
+      def capture(*args, &block)
+        return @context.capture(*args) unless block
+
+        value = capture_output(*args, &block)
+        value.is_a?(String) ? ERB::Util.html_escape(value) : nil
+      end
+
+      def content_for(name, content = nil, **options, &block)
+        content = capture(&block) if block
+        @context.content_for(name, content, **options)
+      end
+
+      def provide(name, content = nil, &block)
+        content = capture(&block) if block
+        @context.provide(name, content)
+      end
+
+      # Kept for templates written against the old instance_exec evaluation,
+      # where Render's private escape_html was callable. Returns a plain String.
+      def escape_html(text)
+        ERB::Util.unwrapped_html_escape(text.to_s)
+      end
+    end
+  end
+end

data/lib/gem/ruby2html/rails_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ruby2html
+  # Include in a controller to get +html(self) { ... }+ inside ERB/other views.
+  module RailsHelper
+    def self.included(base)
+      # Only controllers can expose helpers to views; plain modules just get +html+.
+      base.helper_method :html if base.respond_to?(:helper_method)
+    end
+
+    def html(context, &block)
+      output = Ruby2html::Render.new(context, &block).render
+      # Render#render already returns a SafeBuffer under Rails; avoid copying it.
+      output.html_safe? ? output : output.html_safe
+    end
+  end
+end

data/lib/gem/ruby2html/railtie.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# The template handler and Railtie only make sense with ActiveSupport/ActionView.
+return unless defined?(ActiveSupport)
+
+require 'active_support/core_ext/class/attribute'
+require_relative '../ruby2html' unless defined?(Ruby2html::RailsComponents) # autoloads
+
+module Ruby2html
+  # ActionView template handler for +*.html.rb+ views, partials and
+  # ViewComponent sidecar templates.
+  #
+  # Templates are compiled once by ActionView; all decisions that don't depend
+  # on the request (rewriting, annotations, whether helpers are needed) are
+  # made here so the compiled method does as little as possible per render.
+  #
+  # Two strategies:
+  # * compiled (default): TemplateCompiler rewrites the source so it runs in
+  #   the view itself. No instance variable copying, no instance_exec, helper
+  #   calls go straight to the view.
+  # * closure (fallback when Prism is unavailable or the source doesn't
+  #   parse): the source becomes a block instance_exec'd on a Render that
+  #   copies the view's instance variables, as in 1.x.
+  class TemplateHandler
+    # Render#render runs its root block; compiled templates have already
+    # written their output, so they pass this shared no-op.
+    NOOP = proc { }
+
+    # Every generated prologue ends on the template's first line so that
+    # backtrace line numbers point at the right line of the .html.rb file.
+    # Locals are prefixed because the template code shares their scope.
+    #
+    # The renderer is held in a local and published on the view/component as
+    # +@__r2h+ (the slot ComponentHelper#method_missing reads), restoring the
+    # previous value afterwards so nested partials/components on the same
+    # object stay correct. No thread/fiber-global state is involved.
+    SAVE_PREVIOUS = '__r2h_prev = @__r2h; begin; '
+    COMPILED_PROLOGUE = "#{SAVE_PREVIOUS}__r2h_renderer = Ruby2html::Render.new(nil, &Ruby2html::TemplateHandler::NOOP); "
+    HELPERS_PROLOGUE = '__r2h_helpers = Ruby2html::RailsComponents::TemplateHelpers.new(__r2h_renderer, self); '
+    PUSH_RENDERER = '@__r2h = __r2h_renderer'
+    CLOSURE_PROLOGUE = "#{SAVE_PREVIOUS}__r2h_renderer = Ruby2html::Render.new(self) do; "
+    EPILOGUE = "\nensure\n@__r2h = __r2h_prev\nend"
+
+    class_attribute :default_format
+    self.default_format = :html
+
+    class << self
+      def call(template, source)
+        compiled = RailsComponents::TemplateCompiler.compile(source, template_locals(template))
+        compiled ? compiled_code(template, compiled) : closure_code(template, source)
+      end
+
+      # This handler does no encoding work of its own, so let ActionView
+      # transcode the source to Encoding.default_external (honouring an
+      # `# encoding:` magic comment) before it reaches #call.
+      def handles_encoding?
+        false
+      end
+
+      private
+        def template_locals(template)
+          template.respond_to?(:locals) ? Array(template.locals) : []
+        end
+
+        def compiled_code(template, compiled)
+          helpers = compiled.uses_helpers ? HELPERS_PROLOGUE : ''
+          "#{COMPILED_PROLOGUE}#{helpers}#{PUSH_RENDERER}; #{compiled.source}\n" \
+            "#{render_expression(template)}#{EPILOGUE}"
+        end
+
+        def closure_code(template, source)
+          "#{CLOSURE_PROLOGUE}#{source}\nend\n#{PUSH_RENDERER}\n#{render_expression(template)}#{EPILOGUE}"
+        end
+
+        # Mirrors the ERB handler: wrap HTML templates in BEGIN/END comments
+        # when config.action_view.annotate_rendered_view_with_filenames is on.
+        def render_expression(template)
+          return '__r2h_renderer.render' unless annotate?(template)
+
+          path = template.short_identifier
+          "ActiveSupport::SafeBuffer.new(#{"<!-- BEGIN #{path} -->".inspect})" \
+            '.safe_concat(__r2h_renderer.render)' \
+            ".safe_concat(#{"<!-- END #{path} -->".inspect})"
+        end
+
+        def annotate?(template)
+          defined?(ActionView::Base) &&
+            ActionView::Base.annotate_rendered_view_with_filenames &&
+            template.respond_to?(:format) && template.format == :html &&
+            template.respond_to?(:short_identifier)
+        end
+    end
+  end
+
+  if defined?(Rails::Railtie)
+    class Railtie < Rails::Railtie
+      # Lazy by default (dev, tests, plain `require`). When the app eager-loads
+      # (production), load everything up front instead: no first-request
+      # latency, and forking servers share these pages copy-on-write.
+      config.before_eager_load do
+        Ruby2html::RailsComponents::TemplateCompiler.available? # loads Prism
+        Ruby2html::RailsComponents.constants.each { |name| Ruby2html::RailsComponents.const_get(name) }
+        Ruby2html::Component
+        Ruby2html::ComponentHelper
+      end
+
+      initializer 'ruby2html.initializer' do
+        # *.html.rb files are templates, not constants: keep Zeitwerk from
+        # trying to autoload/eager-load them anywhere under app/.
+        Rails.autoloaders.main.ignore(Rails.root.join('app/**/*.html.rb'))
+      end
+    end
+  end
+end
+
+# Register lazily so requiring the gem doesn't force ActionView to load.
+ActiveSupport.on_load(:action_view) do
+  ActionView::Template.register_template_handler :rb, Ruby2html::TemplateHandler
+end

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

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+begin
+  # Only ERB's C escaper (erb >= 4), not the template engine. Absent on
+  # JRuby/TruffleRuby: PureRuby.escape then uses its regex fallback.
+  require 'erb/escape'
+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
+  # RUBY2HTML_DISABLE_EXT=1. The specs render everything with both and
+  # compare. The rules are documented once, in the C sources.
+  #
+  # Written for JITs (YJIT, the JVM): generated tag methods without splats,
+  # everything appended with String#<< to one buffer, and escaping that
+  # returns the string itself when there is nothing to escape.
+  module PureRuby
+    INVALID_ATTRIBUTE_NAME = %r{[\x00-\x20\x7f"'<>/=]}
+    STRING_BOOLEAN = /\A(?:data-|aria-|(?:draggable|spellcheck|contenteditable)\z)/
+    MAX_NESTING = 32 # see R2H_MAX_NESTING in attributes.c
+    ESCAPABLE = /[&<>"']/
+    ESCAPABLE_BYTES = /[&<>"']/n
+    ESCAPES = { '&' => '&amp;', '<' => '&lt;', '>' => '&gt;', '"' => '&quot;', "'" => '&#39;' }.freeze
+
+    class << self
+      # CRuby's ERB::Escape (erb >= 4, in C) is the fastest option and also
+      # returns its argument untouched when it is clean.
+      if RUBY_ENGINE == 'ruby' && defined?(ERB::Escape)
+        # May return str itself: only for appending to the buffer.
+        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)
+          # A UTF-8 regex raises on invalid bytes; Native passes them through.
+          return str.b.gsub(ESCAPABLE_BYTES, ESCAPES).force_encoding(Encoding::UTF_8) unless str.valid_encoding?
+
+          str.match?(ESCAPABLE) ? str.gsub(ESCAPABLE, ESCAPES) : str
+        end
+      end
+
+      # Like Native.escape_html: never hands back the caller's mutable string.
+      def escape_html(obj)
+        str = obj.to_s
+        escaped = escape(str)
+        escaped.equal?(str) && !str.frozen? ? str.dup : escaped
+      end
+
+      # See r2h_utf8_compatible in html_escape.c.
+      def utf8_compatible(str)
+        case str.encoding
+        when Encoding::UTF_8, Encoding::US_ASCII then str
+        when Encoding::BINARY then str.dup.force_encoding(Encoding::UTF_8)
+        else str.ascii_only? ? str : str.encode(Encoding::UTF_8)
+        end
+      end
+
+      def define_tag(method_name, tag, void)
+        source = void ? void_tag_source(method_name, tag) : tag_source(method_name, tag)
+        # The magic comment is per eval: without it every tag literal allocates.
+        module_eval("# frozen_string_literal: true\n#{source}", __FILE__, __LINE__)
+      end
+
+      private
+        def tag_source(method_name, tag)
+          <<~RUBY
+            def #{method_name}(content = nil, **attributes)
+              buffer = @current_output
+              if attributes.empty?
+                buffer << '<#{tag}>'
+              else
+                __r2h_open_tag(buffer, '<#{tag}', attributes)
+                buffer << '>'
+              end
+              if block_given?
+                size = buffer.bytesize
+                result = yield
+                __r2h_block_result(buffer, result) if buffer.bytesize == size
+              elsif content.instance_of?(String)
+                buffer << PureRuby.escape(content)
+              else
+                __r2h_text(buffer, content)
+              end
+              buffer << '</#{tag}>'
+              nil
+            end
+          RUBY
+        end
+
+        def void_tag_source(method_name, tag)
+          <<~RUBY
+            def #{method_name}(_content = nil, **attributes)
+              if attributes.empty?
+                @current_output << '<#{tag} />'
+              else
+                buffer = @current_output
+                __r2h_open_tag(buffer, '<#{tag}', attributes)
+                buffer << ' />'
+              end
+              nil
+            end
+          RUBY
+        end
+    end
+
+    def plain(text)
+      __r2h_text(@current_output, text)
+      nil
+    end
+
+    def component(html)
+      @current_output << PureRuby.utf8_compatible(html.to_s) unless html.nil?
+      nil
+    end
+
+    private
+      def __r2h_text(buffer, obj)
+        case obj
+        when nil then nil
+        when String
+          safe = !obj.instance_of?(String) && __r2h_html_safe?(obj)
+          buffer << (safe ? PureRuby.utf8_compatible(obj) : PureRuby.escape(obj))
+        when Symbol, Integer then buffer << PureRuby.escape(obj.to_s)
+        else
+          buffer << (__r2h_html_safe?(obj) ? PureRuby.utf8_compatible(obj.to_s) : PureRuby.escape(obj.to_s))
+        end
+      end
+
+      def __r2h_block_result(buffer, result)
+        __r2h_text(buffer, result) if result.is_a?(String) || result.is_a?(Symbol) || result.is_a?(Numeric)
+      end
+
+      def __r2h_html_safe?(obj)
+        obj.respond_to?(:html_safe?) && obj.html_safe?
+      end
+
+      # Writes `<tag attr="..."`. If an attribute raises and the caller rescues,
+      # a half-written start tag would turn whatever is appended next into
+      # markup, so the buffer is rolled back to before the tag.
+      def __r2h_open_tag(buffer, open, attributes)
+        mark = buffer.bytesize
+        buffer << open
+        __r2h_attributes(buffer, attributes, nil)
+      rescue Exception # rubocop:disable Lint/RescueException -- re-raised; any exception leaves the tag open
+        buffer.replace(buffer.byteslice(0, mark)) if !buffer.frozen? && buffer.bytesize >= mark
+        raise
+      end
+
+      def __r2h_attributes(buffer, attributes, prefix, depth = 0)
+        raise ArgumentError, "attributes nested more than #{MAX_NESTING} levels deep" if depth > MAX_NESTING
+
+        attributes.each do |key, value|
+          next if value.nil?
+
+          name = key.is_a?(Symbol) ? key.name : key.to_s
+          raise ArgumentError, "attribute name can't be empty" if name.empty?
+
+          name = PureRuby.utf8_compatible(name)
+          name = "#{prefix}-#{__r2h_dasherize(name)}" if prefix
+          # Match bytes when the name isn't valid UTF-8 (a UTF-8 regex would raise).
+          checked = name.valid_encoding? ? name : name.b
+          raise ArgumentError, "invalid attribute name: #{name.inspect}" if INVALID_ATTRIBUTE_NAME.match?(checked)
+
+          case value
+          when String then buffer << ' ' << name << '="' << PureRuby.escape(value) << '"'
+          when true then buffer << ' ' << name << (STRING_BOOLEAN.match?(name) ? '="true"' : '')
+          when false then buffer << ' ' << name << '="false"' if STRING_BOOLEAN.match?(name)
+          when Hash then __r2h_attributes(buffer, value, name, depth + 1)
+          when Array then buffer << ' ' << name << '="' << __r2h_tokens(value) << '"'
+          else buffer << ' ' << name << '="' << PureRuby.escape(value.to_s) << '"'
+          end
+        end
+      end
+
+      def __r2h_dasherize(name)
+        return name.tr('_', '-') if name.valid_encoding?
+
+        name.b.tr('_', '-').force_encoding(Encoding::UTF_8)
+      end
+
+      def __r2h_tokens(tokens)
+        __r2h_collect_tokens(tokens, [], 1).join(' ')
+      end
+
+      def __r2h_collect_tokens(tokens, collected, depth)
+        raise ArgumentError, "attributes nested more than #{MAX_NESTING} levels deep" if depth > MAX_NESTING
+
+        tokens.each do |token|
+          if token.is_a?(Array)
+            __r2h_collect_tokens(token, collected, depth + 1)
+          elsif token
+            collected << PureRuby.escape(token.to_s)
+          end
+        end
+        collected
+      end
+  end
+end

data/lib/gem/ruby2html/render.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative 'render/pure_ruby'
+
+module Ruby2html
+  # Loads the C extension (Ruby2html::Native). Without it (JRuby, a failed
+  # build, or RUBY2HTML_DISABLE_EXT=1) the pure-Ruby twin is used instead.
+  # Installed gems find the extension on the load path; this repo builds it
+  # 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'
+    rescue LoadError
+      require_relative '../../ruby2html/ruby2html'
+    end
+    defined?(Native) ? true : false
+  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
+
+  # The module providing tag methods, #plain and #component: Native or PureRuby.
+  IMPLEMENTATION = load_native_extension ? Native : PureRuby
+
+  def self.native?
+    IMPLEMENTATION != PureRuby
+  end
+
+  def self.escape_html(obj)
+    IMPLEMENTATION.escape_html(obj)
+  end
+
+  class Render
+    HTML5_TAGS = %w[
+      a abbr address area article aside audio b base bdi bdo blockquote body br button canvas caption
+      cite code col colgroup data datalist dd del details dfn dialog div dl dt em embed fieldset
+      figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hr html i iframe img input ins
+      kbd label legend li link main map mark meta meter nav noscript object ol optgroup option
+      output p param picture pre progress q rp rt ruby s samp script section select small source
+      span strong style sub summary sup table tbody td template textarea tfoot th thead time title
+      tr track u ul var video wbr turbo-frame turbo-stream
+    ].freeze
+
+    VOID_ELEMENTS = %w[area base br col embed hr img input link meta param source track wbr].freeze
+    # Rails helpers that write their markup into the ruby2html buffer, mapped
+    # to their RailsComponents wrapper (shared by Render and Component).
+    RAILS_HELPER_COMPONENTS = { link_to: :LinkTo, button_to: :ButtonTo, image_tag: :ImageTag, form_with: :FormWith }.freeze
+    # Context ivars that would clobber the renderer's own state if copied.
+    SKIPPED_IVAR_PREFIXES = %w[@_ @output @current_output @context @root].freeze
+
+    # Both implementations get the tags so specs can compare them in one process.
+    [PureRuby, IMPLEMENTATION].uniq.each do |implementation|
+      HTML5_TAGS.each { |tag| implementation.define_tag(tag.tr('-', '_'), tag, VOID_ELEMENTS.include?(tag)) }
+    end
+
+    include IMPLEMENTATION
+
+    # No `output` reader: it would shadow the <output> tag method.
+    attr_accessor :current_output
+
+    def initialize(context = nil, &root)
+      @context = context
+      @root = root
+      @output = String.new(capacity: 4096, encoding: Encoding::UTF_8)
+      @current_output = @output
+    end
+
+    # Without arguments renders the root block and returns the HTML (a
+    # SafeBuffer under ActiveSupport). With arguments it is the context's
+    # render (partials, components), appended to the output.
+    def render(*args, **options, &block)
+      copy_instance_variables if @context && !@__vars_copied
+
+      return plain @context.render(*args, **options, &block) if !args.empty? || !options.empty? || block
+
+      instance_exec(&@root)
+      defined?(ActiveSupport::SafeBuffer) ? ActiveSupport::SafeBuffer.new(@output) : @output
+    end
+
+    private
+      def method_missing(method_name, ...)
+        if @context.respond_to?(method_name)
+          @context.send(method_name, ...)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @context.respond_to?(method_name) || super
+      end
+
+      # Resolved per call (const_get with a Symbol; autoloaded on first use).
+      RAILS_HELPER_COMPONENTS.each do |method, component_name|
+        define_method(method) do |*args, **options, &block|
+          RailsComponents.const_get(component_name).new(self, @context, method, *args, **options).render(&block)
+        end
+      end if defined?(ActionView)
+
+      def escape_html(text)
+        IMPLEMENTATION.escape_html(text)
+      end
+
+      # Templates read the view's assigns (@users, ...) as their own ivars.
+      def copy_instance_variables
+        @context.instance_variables.each do |name|
+          next if name.start_with?(*SKIPPED_IVAR_PREFIXES)
+
+          instance_variable_set(name, @context.instance_variable_get(name))
+        end
+        @__vars_copied = true
+      end
+  end
+end

data/lib/gem/ruby2html/version.rb

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