ruby2html 1.6.6 → 2.0.0

data/ext/ruby2html/ruby2html.c

@@ -1,108 +1,16 @@
-// ext/ruby2html/ruby2html.c
-#include <ruby.h>
-#include <ruby/encoding.h>
-#include <ctype.h>
-
-static VALUE rb_mRuby2html;
-static VALUE rb_cRenderer;
-
-// Fast HTML escaping
-static VALUE fast_escape_html(VALUE self, VALUE str) {
-    if (NIL_P(str)) return Qnil;
-
-    str = rb_String(str);
-    long len = RSTRING_LEN(str);
-    const char *ptr = RSTRING_PTR(str);
-
-    // First pass: calculate required buffer size
-    long new_len = len;
-    for (long i = 0; i < len; i++) {
-        switch (ptr[i]) {
-            case '&': new_len += 4; break; // &amp;
-            case '<': new_len += 3; break; // &lt;
-            case '>': new_len += 3; break; // &gt;
-            case '"': new_len += 5; break; // &quot;
-            case '\'': new_len += 5; break; // &#39;
-        }
-    }
-
-    if (new_len == len) return str;
-
-    VALUE result = rb_str_new(NULL, new_len);
-    char *out = RSTRING_PTR(result);
-    long pos = 0;
-
-    // Second pass: actual escaping
-    for (long i = 0; i < len; i++) {
-        switch (ptr[i]) {
-            case '&':
-                memcpy(out + pos, "&amp;", 5);
-                pos += 5;
-                break;
-            case '<':
-                memcpy(out + pos, "&lt;", 4);
-                pos += 4;
-                break;
-            case '>':
-                memcpy(out + pos, "&gt;", 4);
-                pos += 4;
-                break;
-            case '"':
-                memcpy(out + pos, "&quot;", 6);
-                pos += 6;
-                break;
-            case '\'':
-                memcpy(out + pos, "&#39;", 5);
-                pos += 5;
-                break;
-            default:
-                out[pos++] = ptr[i];
-        }
-    }
-
-    rb_str_set_len(result, pos);
-    rb_enc_associate(result, rb_enc_get(str));
-    return result;
+/*
+ * Native renderer core. Defines Ruby2html::Native, a module of instance
+ * methods (tag methods, plain, component) that Ruby2html::Render includes.
+ * Ruby2html::PureRuby (lib/gem/ruby2html/render/pure_ruby.rb) mirrors it.
+ */
+#include "ruby2html.h"
+
+RUBY_FUNC_EXPORTED void Init_ruby2html(void)
+{
+    VALUE ruby2html = rb_define_module("Ruby2html");
+    VALUE native = rb_define_module_under(ruby2html, "Native");
+
+    r2h_init_escape(native);
+    r2h_init_content(native);
+    r2h_init_tags(native);
 }
-
-// Fast attribute string builder
-static VALUE fast_attributes_to_s(VALUE self, VALUE hash) {
-    if (NIL_P(hash) || RHASH_EMPTY_P(hash)) return rb_str_new2("");
-
-    VALUE result = rb_str_buf_new(64); // Pre-allocate with reasonable size
-    VALUE keys = rb_funcall(hash, rb_intern("keys"), 0);
-    long len = RARRAY_LEN(keys);
-
-    for (long i = 0; i < len; i++) {
-        VALUE key = rb_ary_entry(keys, i);
-        VALUE value = rb_hash_aref(hash, key);
-
-        if (!NIL_P(value)) {
-            rb_str_cat2(result, " ");
-            rb_str_append(result, rb_String(key));
-            rb_str_cat2(result, "=\"");
-            rb_str_append(result, fast_escape_html(self, rb_String(value)));
-            rb_str_cat2(result, "\"");
-        }
-    }
-
-    return result;
-}
-
-// Fast string buffer concatenation
-static VALUE fast_buffer_append(VALUE self, VALUE buffer, VALUE str) {
-    if (!NIL_P(str)) {
-        rb_funcall(buffer, rb_intern("<<"), 1, rb_String(str));
-    }
-    return Qnil;
-}
-
-void Init_ruby2html(void) {
-    rb_mRuby2html = rb_define_module("Ruby2html");
-
-    rb_cRenderer = rb_define_class_under(rb_mRuby2html, "Render", rb_cObject);
-
-    rb_define_method(rb_cRenderer, "fast_escape_html", fast_escape_html, 1);
-    rb_define_method(rb_cRenderer, "fast_attributes_to_s", fast_attributes_to_s, 1);
-    rb_define_method(rb_cRenderer, "fast_buffer_append", fast_buffer_append, 2);
-}

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,118 @@
+# 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.
+    def render_in(view_context, &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

@@ -1,27 +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 = __ruby2html_renderer__
-      Ruby2html::Render.new(self, &block).yield_self do |component_renderer|
-        Thread.current[:__ruby2html_renderer__] = component_renderer
-        component_renderer.render.html_safe
-      end
+      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
-      Thread.current[:__ruby2html_renderer__] = previous_renderer
-    end
-
-    def method_missing(method, *args, **options, &block)
-      if __ruby2html_renderer__.respond_to?(method)
-        __ruby2html_renderer__.send(method, *args, **options, &block)
-      else
-        super
-      end
+      @__r2h = previous_renderer
     end
 
+    # The renderer currently rendering this object, or nil.
     def __ruby2html_renderer__
-      Thread.current[:__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

@@ -1,24 +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)
 
-      if headers['Content-Type']&.include?('text/html')
-        new_body = []
-        body.each do |chunk|
-          new_body << HtmlBeautifier.beautify(chunk)
-        end
-        headers['Content-Length'] = new_body.map(&:bytesize).sum.to_s
-        body = new_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
 
-      [status, headers, body]
-    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

@@ -1,8 +1,16 @@
 # 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
@@ -12,7 +20,8 @@ module Ruby2html
       end
 
       def render(&block)
-        raise NotImplementedError
+        @render.plain(@context.public_send(@method, *@args, **@options, &capturing(block)))
+        nil
       end
     end
   end

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

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