Use a global output buffer

.github/workflows/ci.yml

@@ -29,6 +29,7 @@ jobs:
       matrix:
         rails_version: ['5.2.6', '6.0.4.4', '6.1.4.4', '7.0.1', 'main']
         ruby_version: ['2.5', '2.6', '2.7', '3.0', '3.1']
+        output_buffer: ['global_buffer', 'local_buffer']
         exclude:
           - rails_version: '5.2.6'
             ruby_version: '3.0'
@@ -64,6 +65,7 @@ jobs:
       env:
         MEASURE_COVERAGE: true
         RAILS_VERSION: ${{ matrix.rails_version }}
+        VIEW_COMPONENT_USE_GLOBAL_OUTPUT_BUFFER: ${{ matrix.output_buffer == 'global_buffer' && 'true' || 'false' }}
     - name: Upload coverage results
       uses: actions/upload-artifact@master
       if: always()

docs/CHANGELOG.md

@@ -29,6 +29,10 @@ title: Changelog
 
     *Cameron Dutro*
 
+* Add the option to use a "global" output buffer so `form_for` and friends can be used with view components.
+
+    *Cameron Dutro*, *Blake Williams*
+
 ## 2.50.0
 
 * Add tests for `layout` usage when rendering via controller.

docs/known_issues.md

@@ -7,7 +7,23 @@ title: Known issues
 
 ## form_for compatibility
 
-ViewComponent [isn't currently compatible](https://github.com/github/view_component/issues/241) with `form_for` helpers.
+ViewComponent [isn't compatible](https://github.com/github/view_component/issues/241) with `form_for` helpers by default.
+
+### Using a Global Output Buffer (Experimental)
+
+One possible solution to the form helpers problem is to use a single, global output buffer. For details, please refer to [this pull request](https://github.com/github/view_component/pull/1307).
+
+The global output buffer behavior is opt-in. Prepend the `ViewComponent::GlobalOutputBuffer` module into individual component classes to use it.
+
+For example:
+
+```ruby
+class MyComponent < ViewComponent::Base
+  prepend ViewComponent::GlobalOutputBuffer
+end
+```
+
+It is also possible to enable the global output buffer globally by setting the `config.view_component.use_global_output_buffer` setting to `true` in your Rails config.
 
 ## Inconsistent controller rendering behavior between Rails versions
 

lib/view_component.rb

@@ -11,7 +11,9 @@ module ViewComponent
   autoload :CompileCache
   autoload :ComponentError
   autoload :Deprecation
+  autoload :GlobalOutputBuffer
   autoload :Instrumentation
+  autoload :OutputBufferStack
   autoload :Preview
   autoload :PreviewTemplateError
   autoload :TestHelpers

lib/view_component/base.rb

@@ -69,6 +69,8 @@ def render_in(view_context, &block)
       @view_context = view_context
       self.__vc_original_view_context ||= view_context
 
+      @output_buffer = ActionView::OutputBuffer.new unless @global_buffer_in_use
+
       @lookup_context ||= view_context.lookup_context
 
       # required for path helpers in older Rails versions
@@ -102,14 +104,18 @@ def render_in(view_context, &block)
       before_render
 
       if render?
-        render_template_for(@__vc_variant).to_s + _output_postamble
+        perform_render
       else
         ""
       end
     ensure
       @current_template = old_current_template
     end
 
+    def perform_render
+      render_template_for(@__vc_variant).to_s + _output_postamble
+    end
+
     # :nocov:
     def render_template_for(variant = nil)
       # Force compilation here so the compiler always redefines render_template_for.

lib/view_component/compiler.rb

@@ -68,9 +68,8 @@ def compile(raise_errors: false, force: false)
             component_class.send(:remove_method, method_name.to_sym)
           end
 
-          component_class.class_eval <<-RUBY, template[:path], -1
+          component_class.class_eval <<-RUBY, template[:path], 0
           def #{method_name}
-            @output_buffer = ActionView::OutputBuffer.new
             #{compiled_template(template[:path])}
           end
           RUBY

lib/view_component/engine.rb

@@ -20,6 +20,7 @@ class Engine < Rails::Engine # :nodoc:
       options.instrumentation_enabled = false if options.instrumentation_enabled.nil?
       options.preview_route ||= ViewComponent::Base.preview_route
       options.preview_controller ||= ViewComponent::Base.preview_controller
+      options.use_global_output_buffer = false if options.use_global_output_buffer.nil?
 
       if options.show_previews
         options.preview_paths << "#{Rails.root}/test/components/previews" if defined?(Rails.root) && Dir.exist?(
@@ -57,6 +58,21 @@ class Engine < Rails::Engine # :nodoc:
       end
     end
 
+    initializer "view_component.enable_global_output_buffer" do |app|
+      ActiveSupport.on_load(:view_component) do
+        env_use_gob = ENV.fetch("VIEW_COMPONENT_USE_GLOBAL_OUTPUT_BUFFER", "false") == "true"
+        config_use_gob = app.config.view_component.use_global_output_buffer
+
+        if config_use_gob || env_use_gob
+          # :nocov:
+          app.config.view_component.use_global_output_buffer = true
+          ViewComponent::Base.prepend(ViewComponent::GlobalOutputBuffer)
+          ActionView::Base.prepend(ViewComponent::GlobalOutputBuffer::ActionViewMods)
+          # :nocov:
+        end
+      end
+    end
+
     initializer "view_component.set_autoload_paths" do |app|
       options = app.config.view_component
 

lib/view_component/global_output_buffer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module GlobalOutputBuffer
+    def render_in(view_context, &block)
+      unless view_context.output_buffer.is_a?(OutputBufferStack)
+        # use instance_variable_set here to avoid triggering the code in the #output_buffer= method below
+        view_context.instance_variable_set(:@output_buffer, OutputBufferStack.new(view_context.output_buffer))
+      end
+
+      @output_buffer = view_context.output_buffer
+      @global_buffer_in_use = true
+
+      super(view_context, &block)
+    end
+
+    def perform_render
+      # HAML unhelpfully assigns to @output_buffer directly, so we hold onto a reference to
+      # it and restore @output_buffer when the HAML engine is finished. In non-HAML cases,
+      # @output_buffer and orig_buf will point to the same object, making the reassignment
+      # statements no-ops.
+      orig_buf = @output_buffer
+      @output_buffer.push
+      result = render_template_for(@__vc_variant).to_s + _output_postamble
+      @output_buffer = orig_buf
+      @output_buffer.pop
+      result
+    end
+
+    def output_buffer=(other_buffer)
+      @output_buffer.replace(other_buffer)
+    end
+
+    def with_output_buffer(buf = nil)
+      unless buf
+        buf = ActionView::OutputBuffer.new
+        if output_buffer && output_buffer.respond_to?(:encoding)
+          buf.force_encoding(output_buffer.encoding)
+        end
+      end
+
+      output_buffer.push(buf)
+      result = nil
+
+      begin
+        yield
+      ensure
+        # assign result here to avoid a return statement, which will
+        # immediately return to the caller and swallow any errors
+        result = output_buffer.pop
+      end
+
+      result
+    end
+
+    module ActionViewMods
+      def with_output_buffer(buf = nil)
+        # save a reference to the stack-based buffer
+        orig_buf = output_buffer
+        result = nil
+
+        super do
+          if orig_buf.respond_to?(:push)
+            # super will have set self.output_buffer to the new buffer
+            new_buf = self.output_buffer
+            orig_buf.push(new_buf)
+
+            # set output_buffer back to the original, stack-based buffer we
+            # saved a reference to earlier
+            self.output_buffer = orig_buf
+
+            begin
+              yield
+            ensure
+              result = orig_buf.pop
+            end
+          else
+            # :nocov:
+            yield
+            result = output_buffer
+            # :nocov:
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

lib/view_component/output_buffer_stack.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  class OutputBufferStack
+    delegate_missing_to :@current_buffer
+    delegate :presence, :present?, :html_safe?, to: :@current_buffer
+
+    attr_reader :buffer_stack
+
+    def self.make_frame(*args)
+      ActionView::OutputBuffer.new(*args)
+    end
+
+    def initialize(initial_buffer = nil)
+      if initial_buffer.is_a?(self.class)
+        @current_buffer = self.class.make_frame(initial_buffer.current)
+        @buffer_stack = [*initial_buffer.buffer_stack[0..-2], @current_buffer]
+      else
+        @current_buffer = initial_buffer || self.class.make_frame
+        @buffer_stack = [@current_buffer]
+      end
+    end
+
+    def replace(buffer)
+      return if self == buffer
+
+      @current_buffer = buffer.current
+      @buffer_stack = buffer.buffer_stack
+    end
+
+    def append=(arg)
+      @current_buffer.append = arg
+    end
+
+    def safe_append=(arg)
+      @current_buffer.safe_append = arg
+    end
+
+    def safe_concat(arg)
+      # rubocop:disable Rails/OutputSafety
+      @current_buffer.safe_concat(arg)
+      # rubocop:enable Rails/OutputSafety
+    end
+
+    def length
+      @current_buffer.length
+    end
+
+    def push(buffer = nil)
+      buffer ||= self.class.make_frame
+      @buffer_stack.push(buffer)
+      @current_buffer = buffer
+    end
+
+    def pop
+      @buffer_stack.pop.tap do
+        @current_buffer = @buffer_stack.last
+      end
+    end
+
+    def to_s
+      @current_buffer
+    end
+
+    alias_method :current, :to_s
+  end
+end

lib/view_component/slot_v2.rb

@@ -45,18 +45,12 @@ def to_s
           if defined?(@__vc_content_set_by_with_content)
             @__vc_component_instance.with_content(@__vc_content_set_by_with_content)
 
-            view_context.capture do
-              @__vc_component_instance.render_in(view_context)
-            end
+            @__vc_component_instance.render_in(view_context)
           elsif defined?(@__vc_content_block)
-            view_context.capture do
-              # render_in is faster than `parent.render`
-              @__vc_component_instance.render_in(view_context, &@__vc_content_block)
-            end
+            # render_in is faster than `parent.render`
+            @__vc_component_instance.render_in(view_context, &@__vc_content_block)
           else
-            view_context.capture do
-              @__vc_component_instance.render_in(view_context)
-            end
+            @__vc_component_instance.render_in(view_context)
           end
         elsif defined?(@__vc_content)
           @__vc_content

performance/components/name_component_with_gob.html.erb

@@ -0,0 +1,5 @@
+<h1>hello <%= @name %></h1>
+
+<% 50.times do %>
+  <%= render Performance::NestedNameComponentWithGOB.new(name: @name) %>
+<% end %>

performance/components/name_component_with_gob.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Performance::NameComponentWithGOB < Performance::NameComponent
+  prepend ViewComponent::GlobalOutputBuffer
+end

performance/components/nested_name_component_with_gob.html.erb

@@ -0,0 +1 @@
+<p>nested hello <%= @name %></p>

performance/components/nested_name_component_with_gob.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Performance::NestedNameComponentWithGOB < Performance::NestedNameComponent
+  prepend ViewComponent::GlobalOutputBuffer
+end

performance/global_output_buffer_benchmark.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Run `bundle exec rake benchmark` to execute benchmark.
+# This is very much a work-in-progress. Please feel free to make/suggest improvements!
+
+require "benchmark/ips"
+
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "production"
+require File.expand_path("../test/sandbox/config/environment.rb", __dir__)
+
+module Performance
+  require_relative "components/name_component.rb"
+  require_relative "components/nested_name_component.rb"
+  require_relative "components/name_component_with_gob.rb"
+  require_relative "components/nested_name_component_with_gob.rb"
+end
+
+class BenchmarksController < ActionController::Base
+end
+
+BenchmarksController.view_paths = [File.expand_path("./views", __dir__)]
+controller_view = BenchmarksController.new.view_context
+
+Benchmark.ips do |x|
+  x.time = 10
+  x.warmup = 2
+
+  x.report("component") { controller_view.render(Performance::NameComponent.new(name: "Fox Mulder")) }
+  x.report("component with GOB") { controller_view.render(Performance::NameComponentWithGOB.new(name: "Fox Mulder")) }
+
+  x.compare!
+end

test/sandbox/app/components/content_tag_component.html.erb

@@ -0,0 +1,3 @@
+<%= helpers.my_helper_method({ foo: :bar }) do %>
+  <p>Content inside helper method</p>
+<% end %>

test/sandbox/app/components/content_tag_component.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ContentTagComponent < ViewComponent::Base
+end

test/sandbox/app/components/form_for_component.html.erb

@@ -0,0 +1,3 @@
+<%= form_for Post.new, url: "/" do |form| %>
+  <%= render LabelComponent.new(form: form) %>
+<% end %>

test/sandbox/app/components/form_for_component.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class FormForComponent < ViewComponent::Base
+  def initialize
+  end
+end

test/sandbox/app/components/form_with_component.html.erb

@@ -0,0 +1,3 @@
+<%= form_with model: Post.new, url: "/" do |form| %>
+  <%= render LabelComponent.new(form: form) %>
+<% end %>

test/sandbox/app/components/form_with_component.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class FormWithComponent < ViewComponent::Base
+  def initialize
+  end
+end