view_component 4.15.0 → 4.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9da4df780e2f53937b1593ef29fbbf9ce09662b48de7bc56ceae812c43880d2f
-  data.tar.gz: 94c6f23684dc139431a5c912a9e7fab5f70e2e794ba6bb72f5b66211c97f0e8c
+  metadata.gz: 6b893658a7831510ca06effa1b9abb1d50669a6910c31049f4225a164987e858
+  data.tar.gz: c4e55c9e7f4e49117c8abbaeaafb077c535be72d3b78775283e8599110cd47aa
 SHA512:
-  metadata.gz: 50b36d70558457271f43deb0b67473209af190979ca48c68ce1b3116b27abf06255b0d9312c53382600be23d75aa2304b58926d9e52f314923c4968182b10e53
-  data.tar.gz: c687e6eec0d97bd5ea53b3f5b51012e94ca75bd3d659bd1ac2ea03d3343e4d88e695aa5b822d5fe8f55a4a239163cd3df7048a33195b95132ac95e186a491b7b
+  metadata.gz: f4d1ad504f345a9eff5088d22f34955d9a0d95f6990d16923e373f264c189ed8871a8551ec039985650251e330f22c752d7cb04a8bc1e0ddfc40dfde42148947
+  data.tar.gz: 05a6b4ace5d3bbb6fede8ea9f8d93a1291d1222f998d8cce3158133167430c06d5371cc2fdf7794dc2e432bde2ec650a0edeccea0465eabfb2dad6589289acd2

data/docs/CHANGELOG.md

@@ -10,6 +10,46 @@ nav_order: 6
 
 ## main
 
+## 4.16.0
+
+* Fix subclasses defined after their parent renders a collection using the parent's default collection parameter name instead of their own. Fix recompiling a component not refreshing its collection parameter, counter, and iteration detection. Compute that detection when a component compiles, and store the results frozen so they're shareable across Ractors.
+
+    *Ben Sheldon*
+
+* Fix collection counter and iteration detection, and collection and reserved parameter validation, when `initialize` arguments are forwarded through anonymous arguments (`...` or `**`), such as by prepended modules and subclasses calling `super`.
+
+    *Ben Sheldon*
+
+* Update development and documentation dependencies, baseline existing Audition findings, and accommodate updated lint rules.
+
+    *Joel Hawksley*
+
+* Invalidate Action View's memoized template digests when a component registers with `ViewComponent::CacheDigest`, so a digest computed before the component loaded isn't served for the rest of the process.
+
+    *Erik Axel Nielsen*
+
+* Raise errors encountered while computing a component's cache digest instead of degrading to an untracked component that can serve stale fragments.
+
+    *Erik Axel Nielsen*
+
+* Give `<% cache %>` blocks inside a component's own template a digest, for components that `include ViewComponent::ExperimentallyCacheable`.
+
+    Rails digests the virtual path of whichever template is rendering. Inside a component that path resolves to no template, because component templates aren't in the view paths, so the Digestor returned an empty digest and the fragment was never invalidated. The only signal was a `Couldn't find template for digesting` line in the log. 4.15.0 fixed the case where the `cache` block wraps the component in a view. This fixes the case where the block sits in the component's template.
+
+    *Erik Axel Nielsen*
+
+* Fix line numbers and, under coverage, missing output for ERB templates that Rails doesn't annotate.
+
+    On Rails 8.1+, ViewComponent compensated for the newline Rails adds to compiled ERB output ([rails/rails#53731](https://github.com/rails/rails/pull/53731)) for every ERB template, whether from a file or from `erb_template`. That newline lives inside the `<!-- BEGIN ... -->` annotation, which Rails only emits when `annotate_rendered_view_with_filenames` is enabled *and* the template's format is HTML. Compensating unconditionally shifted backtraces for non-HTML templates (`.text.erb`, `.css.erb`) and for every ERB template when annotations are disabled, such as in production, by one line. When coverage was running, the same mismatch made the annotation-stripping workaround remove real template source, so non-HTML templates rendered empty.
+
+    Inline templates now decide the compensation when they compile rather than when the component class is defined, matching file templates.
+
+    *Ryutaro Mizokami*
+
+* Reduce per-render allocations. Inline renders drop 2 to 3 allocations and collection renders drop 4 to 8 depending on Rails/Ruby version by caching the instrumentation-enabled flag at the module level, memoizing the empty-details `Requested` per `LookupContext`, hoisting per-item metadata lookups out of the collection render loop, and dropping a few gratuitous `**` splats on the `Collection` API boundary.
+
+    *Joel Hawksley*
+
 ## 4.15.0
 
 * Add experimental caching support, opt-in per component via `include ViewComponent::ExperimentallyCacheable`.

data/lib/view_component/base.rb

@@ -631,7 +631,7 @@ module ViewComponent
       # @param spacer_component [ViewComponent::Base] Component instance to be rendered between items.
       # @param args [Arguments] Arguments to pass to the ViewComponent every time.
       def with_collection(collection, spacer_component: nil, **args)
-        Collection.new(self, collection, spacer_component, **args)
+        Collection.new(self, collection, spacer_component, args)
       end
 
       # @private
@@ -716,7 +716,7 @@ module ViewComponent
       # @param parameter [Symbol] The parameter name used when rendering elements of a collection.
       def with_collection_parameter(parameter)
         @__vc_provided_collection_parameter = parameter
-        @__vc_initialize_parameters = nil
+        @__vc_collection_arguments = nil
       end
 
       # Strips trailing whitespace from templates before compiling them.
@@ -746,10 +746,14 @@ module ViewComponent
       # rendering is optional.
       # @private
       def __vc_validate_collection_parameter!(validate_default: false)
-        parameter = validate_default ? __vc_collection_parameter : __vc_provided_collection_parameter
+        if validate_default
+          return if __vc_collection_arguments[:parameter_accepted]
 
-        return unless parameter
-        return if __vc_initialize_parameter_names.include?(parameter) || __vc_splatted_keyword_argument_present?
+          raise MissingCollectionArgumentError.new(name, __vc_collection_parameter)
+        end
+
+        parameter = __vc_provided_collection_parameter
+        return if __vc_collection_parameter_accepted?(parameter)
 
         raise MissingCollectionArgumentError.new(name, parameter)
       end
@@ -766,51 +770,91 @@ module ViewComponent
 
       # @private
       def __vc_collection_parameter
-        @__vc_provided_collection_parameter ||= name && name.demodulize.underscore.chomp("_component").to_sym
+        __vc_collection_arguments[:parameter]
       end
 
       # @private
       def __vc_collection_counter_parameter
-        @__vc_collection_counter_parameter ||= :"#{__vc_collection_parameter}_counter"
+        __vc_collection_arguments[:counter_parameter]
       end
 
       # @private
       def __vc_counter_argument_present?
-        __vc_initialize_parameter_names.include?(__vc_collection_counter_parameter)
+        __vc_collection_arguments[:counter]
       end
 
       # @private
       def __vc_collection_iteration_parameter
-        @__vc_collection_iteration_parameter ||= :"#{__vc_collection_parameter}_iteration"
+        __vc_collection_arguments[:iteration_parameter]
       end
 
       # @private
       def __vc_iteration_argument_present?
-        __vc_initialize_parameter_names.include?(__vc_collection_iteration_parameter)
+        __vc_collection_arguments[:iteration]
+      end
+
+      # @private
+      def __vc_build_collection_arguments
+        names =
+          if respond_to?(:attribute_names)
+            attribute_names.map(&:to_sym)
+          else
+            __vc_initialize_signatures.flat_map { |_owner, parameters| parameters.map(&:last) }
+          end
+        parameter = __vc_provided_collection_parameter || (name && name.demodulize.underscore.chomp("_component").to_sym)
+        counter_parameter = :"#{parameter}_counter"
+        iteration_parameter = :"#{parameter}_iteration"
+
+        @__vc_collection_arguments = Ractor.make_shareable(
+          {
+            initialize_parameter_names: names,
+            parameter: parameter,
+            parameter_accepted: parameter.nil? || names.include?(parameter) || __vc_splatted_keyword_argument_present?,
+            counter_parameter: counter_parameter,
+            counter: names.include?(counter_parameter),
+            iteration_parameter: iteration_parameter,
+            iteration: names.include?(iteration_parameter)
+          }
+        )
       end
 
       private
 
-      def __vc_splatted_keyword_argument_present?
-        __vc_initialize_parameters.flatten.include?(:keyrest)
+      def __vc_collection_arguments
+        @__vc_collection_arguments || __vc_build_collection_arguments
       end
 
-      def __vc_initialize_parameter_names
-        @__vc_initialize_parameter_names ||=
-          if respond_to?(:attribute_names)
-            attribute_names.map(&:to_sym)
-          else
-            __vc_initialize_parameters.map(&:last)
+      def __vc_collection_parameter_accepted?(parameter)
+        parameter.nil? || __vc_initialize_parameter_names.include?(parameter) || __vc_splatted_keyword_argument_present?
+      end
+
+      def __vc_splatted_keyword_argument_present?
+        prepended_modules = ancestors.grep(Class).flat_map { |klass| klass.ancestors.take_while { |mod| mod != klass } }
+
+        __vc_initialize_signatures.any? do |owner, parameters|
+          parameters.any? do |type, name|
+            type == :keyrest && (name != :** || !prepended_modules.include?(owner))
           end
+        end
       end
 
-      def __vc_initialize_parameters
-        @__vc_initialize_parameters ||= instance_method(:initialize).parameters
+      def __vc_initialize_parameter_names
+        __vc_collection_arguments[:initialize_parameter_names]
       end
 
-      def __vc_provided_collection_parameter
-        @__vc_provided_collection_parameter ||= nil
+      def __vc_initialize_signatures
+        signatures = []
+        method = instance_method(:initialize)
+        while method
+          signatures << [method.owner, method.parameters]
+          break unless method.parameters.any? { |type, _| type == :keyrest }
+
+          method = method.super_method
+        end
+        signatures
       end
+
+      attr_reader :__vc_provided_collection_parameter
     end
 
     ActiveSupport.run_load_hooks(:view_component, self)

data/lib/view_component/cache_digest/dependency_tracking.rb

@@ -27,11 +27,6 @@ module ViewComponent
         end
 
         dependencies + CacheDigest.dependencies_in(template)
-      rescue
-        # A broken digest is preferable to a broken render. Falling back to the
-        # dependencies Rails found on its own means the component simply isn't
-        # tracked, which is the pre-existing behavior.
-        super
       end
 
       # @private

data/lib/view_component/cache_digest/resolver.rb

@@ -30,11 +30,6 @@ module ViewComponent
         return [] unless component
 
         [build_template(component, virtual_path, details)]
-      rescue
-        # Never let digest resolution break rendering. Returning no template
-        # makes the Digestor treat this as a missing node, which degrades to
-        # the behavior components have without this feature.
-        []
       end
 
       def to_s

data/lib/view_component/cache_digest.rb

@@ -75,8 +75,16 @@ module ViewComponent
       # @private
       def register(component)
         return unless component.virtual_path && component.name
+        return if registry[component.virtual_path] == component.name
 
         registry[component.virtual_path] = component.name
+
+        # Components register as they load, and under lazy loading that happens
+        # after Action View has already digested and memoized some templates.
+        # Those digests were computed without this component's dependencies and
+        # would otherwise be served for the rest of the process, making the
+        # digest a function of load order rather than of source.
+        expire_digests
       end
 
       # The synthetic virtual path a component is digested under.
@@ -146,9 +154,6 @@ module ViewComponent
         RENDER_PARSER.new(name, source).render_calls.uniq.select do |path|
           source.include?(path) || source.include?(path.sub(%r{(\A|/)_}, '\1'))
         end
-      rescue
-        # Never let digest computation break rendering.
-        []
       end
 
       # Action View has shipped its render parser as a class (Rails 7.1, and
@@ -223,6 +228,13 @@ module ViewComponent
 
       private
 
+      # Drop Action View's memoized template digests, leaving its resolver
+      # caches alone: no template changed, only the set of dependencies the
+      # Digestor can see.
+      def expire_digests
+        ActionView::LookupContext::DetailsKey.digest_caches.each(&:clear)
+      end
+
       # Resolve a constant name to a component that opted into caching.
       #
       # Returns nil for anything else, including constants that don't exist.
@@ -234,9 +246,6 @@ module ViewComponent
         return unless component.respond_to?(:__vc_cacheable?) && component.__vc_cacheable?
 
         component
-      rescue
-        # Never let digest computation break rendering.
-        nil
       end
     end
 

data/lib/view_component/collection.rb

@@ -12,6 +12,9 @@ module ViewComponent
 
     delegate :size, to: :@collection
 
+    EMPTY_SPACER = "".html_safe.freeze
+    private_constant :EMPTY_SPACER
+
     def render_in(view_context, **_, &block)
       rendered = components.map! do |component|
         component.render_in(view_context, &block)
@@ -36,18 +39,27 @@ module ViewComponent
     # Always rebuild child component instances per render to avoid leaking
     # request-scoped state from a previous render into a later one (GHSA).
     def components
-      iterator = ActionView::PartialIteration.new(@collection.size)
-
       component.__vc_validate_collection_parameter!(validate_default: true)
 
+      iterator = ActionView::PartialIteration.new(@collection.size)
+      collection_param = component.__vc_collection_parameter
+      counter_present = component.__vc_counter_argument_present?
+      counter_param = component.__vc_collection_counter_parameter if counter_present
+      iteration_present = component.__vc_iteration_argument_present?
+      iteration_param = component.__vc_collection_iteration_parameter if iteration_present
+      item_options = @options.dup
+
       @collection.map do |item|
-        component.new(**component_options(item, iterator)).tap do |_|
-          iterator.iterate!
-        end
+        item_options[collection_param] = item
+        item_options[counter_param] = iterator.index if counter_present
+        item_options[iteration_param] = iterator.dup if iteration_present
+        instance = component.new(**item_options)
+        iterator.iterate!
+        instance
       end
     end
 
-    def initialize(component, object, spacer_component, **options)
+    def initialize(component, object, spacer_component, options = {})
       @component = component
       @collection = collection_variable(object || [])
       @spacer_component = spacer_component
@@ -62,20 +74,11 @@ module ViewComponent
       end
     end
 
-    def component_options(item, iterator)
-      item_options = @options.dup
-      item_options[component.__vc_collection_parameter] = item
-      item_options[component.__vc_collection_counter_parameter] = iterator.index if component.__vc_counter_argument_present?
-      item_options[component.__vc_collection_iteration_parameter] = iterator.dup if component.__vc_iteration_argument_present?
-
-      item_options
-    end
-
     # Render the spacer through a fresh `dup` so a collection rendered multiple
     # times does not reuse (and trip the single-render guard on) the spacer
     # instance passed by the caller.
     def rendered_spacer(view_context)
-      return "" unless @spacer_component
+      return EMPTY_SPACER unless @spacer_component
 
       spacer = @spacer_component.dup
       if spacer.instance_variable_defined?(:@__vc_rendered)

data/lib/view_component/compiler.rb

@@ -41,6 +41,8 @@ module ViewComponent
           return false
         end
 
+        @component.__vc_build_collection_arguments
+
         if raise_errors
           @component.__vc_validate_initialization_parameters!
           @component.__vc_validate_collection_parameter!

data/lib/view_component/engine.rb

@@ -28,6 +28,7 @@ module ViewComponent
     initializer "view_component.enable_instrumentation" do |app|
       ActiveSupport.on_load(:view_component) do
         if app.config.view_component.instrumentation_enabled.present?
+          ViewComponent::Instrumentation.enabled = true
           ViewComponent::Base.prepend(ViewComponent::Instrumentation)
         end
       end

data/lib/view_component/experimentally_cacheable.rb

@@ -12,9 +12,10 @@ module ViewComponent
   # Including this module does two things:
   #
   # 1. Registers the component with Rails' template digest tree, so a
-  #    `<% cache %>` block wrapping the component in a view is invalidated when
-  #    the component's template, Ruby class, sidecar files, or child components
-  #    change.
+  #    `<% cache %>` block is invalidated when the component's template, Ruby
+  #    class, sidecar files, or child components change. This covers blocks
+  #    wrapping the component in a view and blocks inside the component's own
+  #    template.
   # 2. Enables the `cache_on` macro, which caches the component's own rendered
   #    output.
   #
@@ -185,7 +186,7 @@ module ViewComponent
       if (cached = store.read(key))
         # Safe to mark as HTML-safe: the cached string was produced by this same
         # rendering pipeline, which escapes output before it's written.
-        return cached.html_safe # rubocop:disable Rails/OutputSafety
+        return cached.html_safe
       end
 
       super.tap do |output|
@@ -225,6 +226,33 @@ module ViewComponent
       )
     end
 
+    # The digest Rails mixes into the key of a `<% cache %>` block.
+    #
+    # `ActionView::Helpers::CacheHelper` digests the virtual path of whichever
+    # template is rendering. Inside a component that path is the component's
+    # own, which resolves to nothing: component templates aren't in the view
+    # paths. The Digestor returns an empty digest, `CacheHelper` falls back to
+    # the bare virtual path, and the fragment never invalidates.
+    #
+    # Substituting the digest the component already computes makes a `cache`
+    # block in a component template behave like one in a view. Everything else
+    # the component renders — a partial, say — keeps Rails' behavior.
+    #
+    # @private
+    def digest_path_from_template(template)
+      component_path = self.class.virtual_path
+      return super unless component_path && template.virtual_path == component_path
+
+      digest = self.class.cache_digest(
+        finder: lookup_context,
+        format: template.format || __vc_cache_format(lookup_context)
+      )
+
+      # An empty digest means the component couldn't be resolved. Falling back
+      # to the bare virtual path matches what `CacheHelper` does with one.
+      digest.present? ? "#{component_path}:#{digest}" : component_path
+    end
+
     private
 
     # Slots set by the caller via `with_*`. Checked before rendering, so slots

data/lib/view_component/instrumentation.rb

@@ -8,8 +8,12 @@ module ViewComponent # :nodoc:
       mod.prepend(self) unless self <= ViewComponent::Instrumentation
     end
 
+    class << self
+      attr_accessor :enabled
+    end
+
     def render_in(...)
-      return super if !Rails.application.config.view_component.instrumentation_enabled.present?
+      return super unless Instrumentation.enabled
 
       payload = {
         name: self.class.name,

data/lib/view_component/request_details.rb

@@ -24,8 +24,21 @@ module ViewComponent
         # The hash `user_details` would normally be the standard arguments that
         # `render` accepts, but there's currently no mechanism for users to
         # provide these when calling render on a ViewComponent.
-        details, cached = detail_args_for(user_details)
-        cached || ActionView::TemplateDetails::Requested.new(**details)
+        if user_details.equal?(EMPTY_DETAILS)
+          # Fast path: memoize the empty-details Requested per LookupContext.
+          # Rendered many times with the same context, the tuple/Requested
+          # allocations from ActionView are then paid at most once.
+          cached = instance_variable_defined?(:@__vc_requested_details_cache) &&
+            @__vc_requested_details_cache
+          return cached if cached
+
+          details, from_cache = detail_args_for(EMPTY_DETAILS)
+          @__vc_requested_details_cache =
+            from_cache || ActionView::TemplateDetails::Requested.new(**details)
+        else
+          details, from_cache = detail_args_for(user_details)
+          from_cache || ActionView::TemplateDetails::Requested.new(**details)
+        end
       end
     end
   end

data/lib/view_component/template.rb

@@ -60,13 +60,7 @@ module ViewComponent
       # Strip the annotation line to maintain correct line numbers when coverage
       # is running (avoids segfault from negative lineno)
       def strip_annotation_line?
-        erb_newline_compensation_needed? &&
-          coverage_running? &&
-          ActionView::Base.annotate_rendered_view_with_filenames
-      end
-
-      def erb_newline_compensation_needed?
-        Rails::VERSION::MAJOR >= 8 && Rails::VERSION::MINOR > 0 && details.handler == :erb
+        erb_newline_compensation_needed? && coverage_running?
       end
 
       def compiled_source
@@ -82,22 +76,11 @@ module ViewComponent
       def initialize(component:, inline_template:)
         details = ActionView::TemplateDetails.new(nil, inline_template.language.to_sym, nil, nil)
 
-        # Rails 8.1 added a newline to compiled ERB output (rails/rails#53731).
-        # Subtract 1 to compensate for correct line numbers in stack traces.
-        # Inline templates start at line 2+ (defined inside a class), so this
-        # won't result in negative line numbers that cause segfaults with coverage.
-        lineno =
-          if Rails::VERSION::MAJOR >= 8 && Rails::VERSION::MINOR > 0 && details.handler == :erb
-            inline_template.lineno - 1
-          else
-            inline_template.lineno
-          end
-
         super(
           component: component,
           details: details,
           path: inline_template.path,
-          lineno: lineno,
+          lineno: inline_template.lineno,
         )
 
         @source = inline_template.source.dup
@@ -106,6 +89,19 @@ module ViewComponent
       def type
         :inline
       end
+
+      private
+
+      # Rails 8.1 added a newline to compiled ERB output (rails/rails#53731).
+      # Subtract 1 to compensate for correct line numbers in stack traces.
+      # Inline templates start at line 2+ (defined inside a class), so this
+      # won't result in negative line numbers that cause segfaults with coverage.
+      #
+      # Computed at compile time rather than at initialization because the
+      # annotation setting can change between the two.
+      def lineno
+        erb_newline_compensation_needed? ? super - 1 : super
+      end
     end
 
     class InlineCall < Template
@@ -196,6 +192,20 @@ module ViewComponent
 
     attr_reader :lineno
 
+    def erb_newline_compensation_needed?
+      Rails::VERSION::MAJOR >= 8 && Rails::VERSION::MINOR > 0 &&
+        details.handler == :erb &&
+        annotated?
+    end
+
+    # The newline compensated for lives inside the `<!-- BEGIN ... -->`
+    # annotation, which Rails only prepends to HTML templates, and only when
+    # annotations are enabled. Compensating outside those conditions shifts
+    # backtraces by a line and, under coverage, strips real template source.
+    def annotated?
+      ActionView::Base.annotate_rendered_view_with_filenames && html?
+    end
+
     def compiled_source
       handler = details.handler_class
       this_source = source

data/lib/view_component/version.rb

@@ -3,7 +3,7 @@
 module ViewComponent
   module VERSION
     MAJOR = 4
-    MINOR = 15
+    MINOR = 16
     PATCH = 0
     PRE = nil
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: view_component
 version: !ruby/object:Gem::Version
-  version: 4.15.0
+  version: 4.16.0
 platform: ruby
 authors:
 - ViewComponent Team
@@ -142,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A framework for building reusable, testable & encapsulated view components
   in Ruby on Rails.