view_component 2.49.1 → 3.23.2

data/lib/view_component/capture_compatibility.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  # CaptureCompatibility is a module that patches #capture to fix issues
+  # related to ViewComponent and functionality that relies on `capture`
+  # like forms, capture itself, turbo frames, etc.
+  #
+  # This underlying incompatibility with ViewComponent and capture is
+  # that several features like forms keep a reference to the primary
+  # `ActionView::Base` instance which has its own @output_buffer. When
+  # `#capture` is called on the original `ActionView::Base` instance while
+  # evaluating a block from a ViewComponent the @output_buffer is overridden
+  # in the ActionView::Base instance, and *not* the component. This results
+  # in a double render due to `#capture` implementation details.
+  #
+  # To resolve the issue, we override `#capture` so that we can delegate
+  # the `capture` logic to the ViewComponent that created the block.
+  module CaptureCompatibility
+    def self.included(base)
+      return if base < InstanceMethods
+
+      base.class_eval do
+        alias_method :original_capture, :capture
+      end
+
+      base.prepend(InstanceMethods)
+    end
+
+    module InstanceMethods
+      def capture(*args, &block)
+        # Handle blocks that originate from C code and raise, such as `&:method`
+        return original_capture(*args, &block) if block.source_location.nil?
+
+        block_context = block.binding.receiver
+
+        if block_context != self && block_context.class < ActionView::Base
+          block_context.original_capture(*args, &block)
+        else
+          original_capture(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/view_component/collection.rb

@@ -7,13 +7,19 @@ module ViewComponent
     include Enumerable
     attr_reader :component
 
-    delegate :format, to: :component
     delegate :size, to: :@collection
 
+    attr_accessor :__vc_original_view_context
+
+    def set_original_view_context(view_context)
+      self.__vc_original_view_context = view_context
+    end
+
     def render_in(view_context, &block)
       components.map do |component|
+        component.set_original_view_context(__vc_original_view_context)
         component.render_in(view_context, &block)
-      end.join.html_safe # rubocop:disable Rails/OutputSafety
+      end.join(rendered_spacer(view_context)).html_safe
     end
 
     def components
@@ -34,11 +40,18 @@ module ViewComponent
       components.each(&block)
     end
 
+    # Rails expects us to define `format` on all renderables,
+    # but we do not know the `format` of a ViewComponent until runtime.
+    def format
+      nil
+    end
+
     private
 
-    def initialize(component, object, **options)
+    def initialize(component, object, spacer_component, **options)
       @component = component
       @collection = collection_variable(object || [])
+      @spacer_component = spacer_component
       @options = options
     end
 
@@ -46,19 +59,25 @@ module ViewComponent
       if object.respond_to?(:to_ary)
         object.to_ary
       else
-        raise ArgumentError.new(
-          "The value of the first argument passed to `with_collection` isn't a valid collection. " \
-          "Make sure it responds to `to_ary`."
-        )
+        raise InvalidCollectionArgumentError
       end
     end
 
     def component_options(item, iterator)
-      item_options = { component.collection_parameter => item }
-      item_options[component.collection_counter_parameter] = iterator.index + 1 if component.counter_argument_present?
+      item_options = {component.collection_parameter => item}
+      item_options[component.collection_counter_parameter] = iterator.index if component.counter_argument_present?
       item_options[component.collection_iteration_parameter] = iterator.dup if component.iteration_argument_present?
 
       @options.merge(item_options)
     end
+
+    def rendered_spacer(view_context)
+      if @spacer_component
+        @spacer_component.set_original_view_context(__vc_original_view_context)
+        @spacer_component.render_in(view_context)
+      else
+        ""
+      end
+    end
   end
 end

data/lib/view_component/compiler.rb

@@ -1,260 +1,229 @@
 # frozen_string_literal: true
 
+require "concurrent-ruby"
+
 module ViewComponent
   class Compiler
-    # Lock required to be obtained before compiling the component
-    attr_reader :__vc_compiler_lock
-
-    # Compiler mode. Can be either:
-    # * development (a blocking mode which ensures thread safety when redefining the `call` method for components,
+    # Compiler development mode. Can be either:
+    # * true (a blocking mode which ensures thread safety when redefining the `call` method for components,
     #                default in Rails development and test mode)
-    # * production (a non-blocking mode, default in Rails production mode)
-    DEVELOPMENT_MODE = :development
-    PRODUCTION_MODE = :production
+    # * false(a non-blocking mode, default in Rails production mode)
+    class_attribute :development_mode, default: false
 
-    class_attribute :mode, default: PRODUCTION_MODE
-
-    def initialize(component_class)
-      @component_class = component_class
-      @__vc_compiler_lock = Monitor.new
+    def initialize(component)
+      @component = component
+      @lock = Mutex.new
     end
 
     def compiled?
-      CompileCache.compiled?(component_class)
+      CompileCache.compiled?(@component)
     end
 
-    def development?
-      self.class.mode == DEVELOPMENT_MODE
-    end
+    def compile(raise_errors: false, force: false)
+      return if compiled? && !force
+      return if @component == ViewComponent::Base
 
-    def compile(raise_errors: false)
-      return if compiled?
+      @lock.synchronize do
+        # this check is duplicated so that concurrent compile calls can still
+        # early exit
+        return if compiled? && !force
 
-      with_lock do
-        CompileCache.invalidate_class!(component_class)
+        gather_templates
 
-        subclass_instance_methods = component_class.instance_methods(false)
-
-        if subclass_instance_methods.include?(:with_content) && raise_errors
-          raise ViewComponent::ComponentError.new(
-            "#{component_class} implements a reserved method, `#with_content`.\n\n" \
-            "To fix this issue, change the name of the method."
-          )
+        if self.class.development_mode && @templates.any?(&:requires_compiled_superclass?)
+          @component.superclass.compile(raise_errors: raise_errors)
         end
 
         if template_errors.present?
-          raise ViewComponent::TemplateError.new(template_errors) if raise_errors
+          raise TemplateError.new(template_errors) if raise_errors
 
+          # this return is load bearing, and prevents the component from being considered "compiled?"
           return false
         end
 
-        if subclass_instance_methods.include?(:before_render_check)
-          ActiveSupport::Deprecation.warn(
-            "`#before_render_check` will be removed in v3.0.0.\n\n" \
-            "To fix this issue, use `#before_render` instead."
-          )
-        end
-
         if raise_errors
-          component_class.validate_initialization_parameters!
-          component_class.validate_collection_parameter!
-        end
-
-        templates.each do |template|
-          # Remove existing compiled template methods,
-          # as Ruby warns when redefining a method.
-          method_name = call_method_name(template[:variant])
-
-          if component_class.instance_methods.include?(method_name.to_sym)
-            component_class.send(:undef_method, method_name.to_sym)
-          end
-
-          component_class.class_eval <<-RUBY, template[:path], -1
-          def #{method_name}
-            @output_buffer = ActionView::OutputBuffer.new
-            #{compiled_template(template[:path])}
-          end
-          RUBY
+          @component.validate_initialization_parameters!
+          @component.validate_collection_parameter!
         end
 
         define_render_template_for
 
-        component_class._after_compile
-
-        CompileCache.register(component_class)
-      end
-    end
+        @component.register_default_slots
+        @component.build_i18n_backend
 
-    def with_lock(&block)
-      if development?
-        __vc_compiler_lock.synchronize(&block)
-      else
-        block.call
+        CompileCache.register(@component)
       end
     end
 
     private
 
-    attr_reader :component_class
+    attr_reader :templates
 
     def define_render_template_for
-      if component_class.instance_methods.include?(:render_template_for)
-        component_class.send(:undef_method, :render_template_for)
+      @templates.each do |template|
+        template.compile_to_component
       end
 
-      variant_elsifs = variants.compact.uniq.map do |variant|
-        "elsif variant.to_sym == :#{variant}\n    #{call_method_name(variant)}"
-      end.join("\n")
-
-      body = <<-RUBY
-        if variant.nil?
-          call
-        #{variant_elsifs}
+      method_body =
+        if @templates.one?
+          @templates.first.safe_method_name_call
+        elsif (template = @templates.find(&:inline?))
+          template.safe_method_name_call
         else
-          call
-        end
-      RUBY
+          branches = []
+
+          @templates.each do |template|
+            conditional =
+              if template.inline_call?
+                "variant&.to_sym == #{template.variant.inspect}"
+              else
+                [
+                  template.default_format? ? "(format == #{ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT.inspect} || format.nil?)" : "format == #{template.format.inspect}",
+                  template.variant.nil? ? "variant.nil?" : "variant&.to_sym == #{template.variant.inspect}"
+                ].join(" && ")
+              end
+
+            branches << [conditional, template.safe_method_name_call]
+          end
 
-      if development?
-        component_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def render_template_for(variant = nil)
-          self.class.compiler.with_lock do
-            #{body}
+          out = branches.each_with_object(+"") do |(conditional, branch_body), memo|
+            memo << "#{(!memo.present?) ? "if" : "elsif"} #{conditional}\n  #{branch_body}\n"
           end
+          out << "else\n  #{templates.find { _1.variant.nil? && _1.default_format? }.safe_method_name_call}\nend"
         end
-        RUBY
-      else
-        component_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def render_template_for(variant = nil)
-          #{body}
-        end
-        RUBY
+
+      @component.silence_redefinition_of_method(:render_template_for)
+      @component.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def render_template_for(variant = nil, format = nil)
+        #{method_body}
       end
+      RUBY
     end
 
     def template_errors
-      @__vc_template_errors ||=
-        begin
-          errors = []
+      @_template_errors ||= begin
+        errors = []
 
-          if (templates + inline_calls).empty?
-            errors << "Couldn't find a template file or inline render method for #{component_class}."
-          end
+        errors << "Couldn't find a template file or inline render method for #{@component}." if @templates.empty?
 
-          if templates.count { |template| template[:variant].nil? } > 1
-            errors <<
-              "More than one template found for #{component_class}. " \
-              "There can only be one default template file per component."
-          end
-
-          invalid_variants =
-            templates.
-            group_by { |template| template[:variant] }.
-            map { |variant, grouped| variant if grouped.length > 1 }.
-            compact.
-            sort
-
-          unless invalid_variants.empty?
-            errors <<
-              "More than one template found for #{'variant'.pluralize(invalid_variants.count)} " \
-              "#{invalid_variants.map { |v| "'#{v}'" }.to_sentence} in #{component_class}. " \
-              "There can only be one template file per variant."
-          end
+        # We currently allow components to have both an inline call method and a template for a variant, with the
+        # inline call method overriding the template. We should aim to change this in v4 to instead
+        # raise an error.
+        @templates.reject(&:inline_call?)
+          .map { |template| [template.variant, template.format] }
+          .tally
+          .select { |_, count| count > 1 }
+          .each do |tally|
+          variant, this_format = tally.first
 
-          if templates.find { |template| template[:variant].nil? } && inline_calls_defined_on_self.include?(:call)
-            errors <<
-              "Template file and inline render method found for #{component_class}. " \
-              "There can only be a template file or inline render method per component."
-          end
+          variant_string = " for variant `#{variant}`" if variant.present?
 
-          duplicate_template_file_and_inline_variant_calls =
-            templates.pluck(:variant) & variants_from_inline_calls(inline_calls_defined_on_self)
+          errors << "More than one #{this_format.upcase} template found#{variant_string} for #{@component}. "
+        end
 
-          unless duplicate_template_file_and_inline_variant_calls.empty?
-            count = duplicate_template_file_and_inline_variant_calls.count
+        default_template_types = @templates.each_with_object(Set.new) do |template, memo|
+          next if template.variant
 
-            errors <<
-              "Template #{'file'.pluralize(count)} and inline render #{'method'.pluralize(count)} " \
-              "found for #{'variant'.pluralize(count)} " \
-              "#{duplicate_template_file_and_inline_variant_calls.map { |v| "'#{v}'" }.to_sentence} " \
-              "in #{component_class}. " \
-              "There can only be a template file or inline render method per variant."
-          end
+          memo << :template_file if !template.inline_call?
+          memo << :inline_render if template.inline_call? && template.defined_on_self?
 
-          errors
+          memo
         end
-    end
 
-    def templates
-      @templates ||=
-        begin
-          extensions = ActionView::Template.template_handler_extensions
+        if default_template_types.length > 1
+          errors <<
+            "Template file and inline render method found for #{@component}. " \
+            "There can only be a template file or inline render method per component."
+        end
 
-          component_class._sidecar_files(extensions).each_with_object([]) do |path, memo|
-            pieces = File.basename(path).split(".")
-            memo << {
-              path: path,
-              variant: pieces.second.split("+").second&.to_sym,
-              handler: pieces.last
-            }
-          end
+        # If a template has inline calls, they can conflict with template files the component may use
+        # to render. This attempts to catch and raise that issue before run time. For example,
+        # `def render_mobile` would conflict with a sidecar template of `component.html+mobile.erb`
+        duplicate_template_file_and_inline_call_variants =
+          @templates.reject(&:inline_call?).map(&:variant) &
+          @templates.select { _1.inline_call? && _1.defined_on_self? }.map(&:variant)
+
+        unless duplicate_template_file_and_inline_call_variants.empty?
+          count = duplicate_template_file_and_inline_call_variants.count
+
+          errors <<
+            "Template #{"file".pluralize(count)} and inline render #{"method".pluralize(count)} " \
+            "found for #{"variant".pluralize(count)} " \
+            "#{duplicate_template_file_and_inline_call_variants.map { |v| "'#{v}'" }.to_sentence} " \
+            "in #{@component}. There can only be a template file or inline render method per variant."
         end
-    end
 
-    def inline_calls
-      @inline_calls ||=
-        begin
-          # Fetch only ViewComponent ancestor classes to limit the scope of
-          # finding inline calls
-          view_component_ancestors =
-            (
-              component_class.ancestors.take_while { |ancestor| ancestor != ViewComponent::Base } -
-              component_class.included_modules
-            )
+        @templates.select(&:variant).each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |template, memo|
+          memo[template.normalized_variant_name] << template.variant
+          memo
+        end.each do |_, variant_names|
+          next unless variant_names.length > 1
 
-          view_component_ancestors.flat_map { |ancestor| ancestor.instance_methods(false).grep(/^call/) }.uniq
+          errors << "Colliding templates #{variant_names.sort.map { |v| "'#{v}'" }.to_sentence} found in #{@component}."
         end
-    end
 
-    def inline_calls_defined_on_self
-      @inline_calls_defined_on_self ||= component_class.instance_methods(false).grep(/^call/)
+        errors
+      end
     end
 
-    def variants
-      @__vc_variants = (
-        templates.map { |template| template[:variant] } + variants_from_inline_calls(inline_calls)
-      ).compact.uniq
-    end
+    def gather_templates
+      @templates ||=
+        begin
+          templates = @component.sidecar_files(
+            ActionView::Template.template_handler_extensions
+          ).map do |path|
+            # Extract format and variant from template filename
+            this_format, variant =
+              File
+                .basename(path)     # "variants_component.html+mini.watch.erb"
+                .split(".")[1..-2]  # ["html+mini", "watch"]
+                .join(".")          # "html+mini.watch"
+                .split("+")         # ["html", "mini.watch"]
+                .map(&:to_sym)      # [:html, :"mini.watch"]
+
+            out = Template.new(
+              component: @component,
+              type: :file,
+              path: path,
+              lineno: 0,
+              extension: path.split(".").last,
+              this_format: this_format.to_s.split(".").last&.to_sym, # strip locale from this_format, see #2113
+              variant: variant
+            )
 
-    def variants_from_inline_calls(calls)
-      calls.reject { |call| call == :call }.map do |variant_call|
-        variant_call.to_s.sub("call_", "").to_sym
-      end
-    end
+            out
+          end
 
-    def compiled_template(file_path)
-      handler = ActionView::Template.handler_for_extension(File.extname(file_path).gsub(".", ""))
-      template = File.read(file_path)
-
-      if handler.method(:call).parameters.length > 1
-        handler.call(component_class, template)
-      else
-        handler.call(
-          OpenStruct.new(
-            source: template,
-            identifier: component_class.identifier,
-            type: component_class.type
-          )
-        )
-      end
-    end
+          component_instance_methods_on_self = @component.instance_methods(false)
+
+          (
+            @component.ancestors.take_while { |ancestor| ancestor != ViewComponent::Base } - @component.included_modules
+          ).flat_map { |ancestor| ancestor.instance_methods(false).grep(/^call(_|$)/) }
+            .uniq
+            .each do |method_name|
+              templates << Template.new(
+                component: @component,
+                type: :inline_call,
+                this_format: ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT,
+                variant: method_name.to_s.include?("call_") ? method_name.to_s.sub("call_", "").to_sym : nil,
+                method_name: method_name,
+                defined_on_self: component_instance_methods_on_self.include?(method_name)
+              )
+            end
+
+          if @component.inline_template.present?
+            templates << Template.new(
+              component: @component,
+              type: :inline,
+              path: @component.inline_template.path,
+              lineno: @component.inline_template.lineno,
+              source: @component.inline_template.source.dup,
+              extension: @component.inline_template.language
+            )
+          end
 
-    def call_method_name(variant)
-      if variant.present? && variants.include?(variant)
-        "call_#{variant}"
-      else
-        "call"
-      end
+          templates
+        end
     end
   end
 end