ruby2html 1.6.6 → 2.0.0

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

@@ -1,93 +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
-      include ActionView::Helpers::FormHelper
-      def render(&block)
-        model = @options[:model]
-        scope = @options[:scope]
-        url = @options[:url]
-        method = @options[:method]
-        local = @options[:local]
+      private
+        def block_arg(arg)
+          FormBuilderProxy.wrap(@render, arg)
+        end
+    end
 
-        form_options = @options.except(:model, :scope, :url, :method, :local)
-        form_options[:action] = determine_url(model, url)
-        form_options[:method] = determine_method(model, method)
-        form_options['data-remote'] = 'true' unless local
-        @model = model
-        @scope = determine_scope(model, scope)
+    # 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
 
-        @render.form(**form_options) do
-          authenticity_token_tag
-          utf8_enforcer_tag
-          block.call(self)
-        end
-      end
+      def self.wrap(render, arg)
+        return arg unless defined?(ActionView::Helpers::FormBuilder) && arg.is_a?(ActionView::Helpers::FormBuilder)
 
-      def label(method, text = nil, options = {})
-        @render.label(**options.merge(for: field_id(method))) do
-          text || method.to_s.humanize
-        end
+        new(render, arg)
       end
 
-      def text_field(method, options = {})
-        @render.input(**options.merge(type: 'text', name: field_name(method), id: field_id(method), value: object_value_for(method)))
+      def initialize(render, builder)
+        @render = render
+        @builder = builder
       end
 
-      def hidden_field(method, options = {})
-        @render.input(**options.merge(type: 'hidden', name: field_name(method), id: field_id(method), value: object_value_for(method)))
+      # The underlying ActionView::Helpers::FormBuilder.
+      def __builder__
+        @builder
       end
 
-      def password_field(method, options = {})
-        @render.input(**options.merge(type: 'password', name: field_name(method), id: field_id(method)))
-      end
+      def method_missing(name, ...)
+        return super unless @builder.respond_to?(name)
 
-      def file_field(method, options = {})
-        @render.input(**options.merge(type: 'file', name: field_name(method), id: field_id(method)))
+        forward(name, ...)
       end
 
-      def submit(value = nil, options = {})
-        @render.input(**options.merge(type: 'submit', value: value || submit_default_value))
+      def respond_to_missing?(name, include_private = false)
+        @builder.respond_to?(name, include_private)
       end
 
       private
-        def determine_url(model, url)
-          return url if url
-          return polymorphic_path(model) if model && model.respond_to?(:persisted?)
-          nil
-        end
+        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?
 
-        def determine_method(model, method)
-          return method if method
-          return 'post' unless model
-          model.respond_to?(:persisted?) && model.persisted? ? 'patch' : 'post'
-        end
-
-        def determine_scope(model, scope)
-          return scope if scope
-          model.model_name.param_key if model.respond_to?(:model_name)
-        end
-
-        def authenticity_token_tag
-          @render.input(type: 'hidden', name: 'authenticity_token', value: @context.form_authenticity_token)
-        end
-
-        def utf8_enforcer_tag
-          @render.input(type: 'hidden', name: 'utf8', value: '✓')
-        end
-
-        def field_name(method)
-          @scope ? "#{@scope}[#{method}]" : method.to_s
-        end
-
-        def field_id(method)
-          @scope ? "#{@scope}_#{method}" : method.to_s
+          @render.plain(result)
+          nil
         end
 
-        def object_value_for(method)
-          @model&.public_send(method) if @model
+        # Nested builders (fields_for / fields) are wrapped as well.
+        def block_arg(arg)
+          FormBuilderProxy.wrap(@render, arg)
         end
     end
   end
-end if defined?(ActionView::Helpers::FormHelper)
+end

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'base_component'
+
 module Ruby2html
   module RailsComponents
+    # Delegates to Rails' +image_tag+; see BaseComponent.
     class ImageTag < BaseComponent
-      def render(&block)
-        @render.plain(@context.image_tag(*@args, **@options, &block))
-      end
     end
   end
 end

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'base_component'
+
 module Ruby2html
   module RailsComponents
+    # Delegates to Rails' +link_to+; see BaseComponent.
     class LinkTo < BaseComponent
-      def render(&block)
-        @render.plain(@context.button_to(*@args, **@options, &block))
-      end
     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

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

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
 module Ruby2html
+  # Include in a controller to get +html(self) { ... }+ inside ERB/other views.
   module RailsHelper
-    def html(context, &block)
-      Ruby2html::Render.new(context, &block).render.html_safe
+    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 self.included(base)
-      base.helper_method :html
+    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

@@ -1,40 +1,119 @@
 # frozen_string_literal: true
 
-if defined?(Rails)
-  module Ruby2html
-    class TemplateHandler
-      class_attribute :default_format
-      self.default_format = :html
-
-      def self.call(template, source)
-        <<-RUBY
-begin
-previous_renderer = Thread.current[:__ruby2html_renderer__]
-renderer = Ruby2html::Render.new(self) do
-#{source}
-end
-Thread.current[:__ruby2html_renderer__] = renderer
-renderer.__render_from_rails(#{template.identifier.inspect})
-ensure
-Thread.current[:__ruby2html_renderer__] = previous_renderer
-end
-        RUBY
+# 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
 
-      def self.handles_encoding?
-        true
+      # 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
-        Rails.autoloaders.main.ignore(
-          Rails.root.join('app/views/**/*.html.rb'),
-          Rails.root.join('app/components/**/*.html.rb')
-        )
+        # *.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