view_component-fragment_caching 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc762ffb0feb715f3c3bf3d621c783871453926765109c40d4cd827f50494580
+  data.tar.gz: 717f0a81506a140d71d0b717149662fe073eb006bdfd0cbeae59f2419bf9a6a3
+SHA512:
+  metadata.gz: 642b6eef5c8669122224a26b1090f3bb1ce242c1b322126c967effc4361048014de35486007aeb8d7f7a9f3dff7b60ce8c4e7fa100cc9391de787112944c30ae
+  data.tar.gz: a523f790eaf7747ab425a5d5279294fa5f96bfcf3d958fe50f1472ecc3c5083cf13e882e0ccebee5ea7ff4b2620a4b7062751ed88680b060a8c7609688080617

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 Patrick Arnett
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# ViewComponent::FragmentCaching
+With fragment caching in Rails, updates to a partial's source code will automatically bust
+appropriate caches in which the partial is detectable as a dependency.
+
+This gem augments ActionView's fragment caching strategy to detect and parse view components. In addition to digesting a
+component's view file (if present), it will also digest the component's ruby file and those of any superclasses
+descended from `ViewComponent::Base`. 
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "view_component-fragment_caching"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install view_component-fragment_caching
+```
+
+## Configuration
+By default, view components will be detected in `ViewComponent::Base.view_component_path` (`app/components` typically).
+This can be configured in an initializer:
+
+```ruby
+ViewComponent::FragmentCaching.configure do |c|
+  c.view_component_paths = %w(
+    app/components
+    app/additional_components
+  )
+end
+```
+
+## Use
+It is important that naming conventions are followed. The tracker will ignore components whose class names do not end with "Component".
+
+#### Render dependencies
+```erb
+<%= render Users::AuthorComponent.new(...) %>
+<%= render Users::AuthorComponent.with_collection(...) %>
+```
+
+#### Explicit dependencies
+```erb
+<%# View Component Dependency: Users::AuthorComponent %>
+<%= render @author %>  
+```
+
+## Contributing
+Please follow conventions and write tests.
+```bash
+$ bundle exec rspec
+$ bundle exec rubocop
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+
+APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/config/initializers/view_component/fragment_caching.rb

@@ -0,0 +1,19 @@
+ActiveSupport.on_load :action_controller do
+  next unless self == ActionController::Base
+
+  ViewComponent::FragmentCaching.initialize! context: self
+end
+
+Rails.application.reloader.to_prepare do
+  ActiveSupport.on_load :action_view do
+    ActiveSupport.on_load :after_initialize do
+      ActionView::DependencyTracker::ERBTracker.prepend ViewComponent::FragmentCaching::Trackers::ViewComponentTracking
+      ActionView::Digestor::Node.prepend ViewComponent::FragmentCaching::Digestors::WithViewComponentRb
+
+      ViewComponent::FragmentCaching::Resolvers::ViewComponentResolver::VIEW_COMPONENT_RUBY_HANDLER.tap do |vc_rb|
+        ActionView::Template.register_template_handler vc_rb, ActionView::Template::Handlers::ERB.new
+        ActionView::DependencyTracker.register_tracker vc_rb, ActionView::DependencyTracker::ERBTracker
+      end
+    end
+  end
+end

data/lib/view_component/fragment_caching/configuration.rb

@@ -0,0 +1,18 @@
+require 'view_component'
+
+module ViewComponent
+  module FragmentCaching
+    class Configuration
+      attr_reader :view_component_paths
+
+      def initialize
+        self.view_component_path = ::ViewComponent::Base.view_component_path
+      end
+
+      def view_component_paths=(path_or_paths)
+        @view_component_paths = Array(path_or_paths)
+      end
+      alias view_component_path= view_component_paths=
+    end
+  end
+end

data/lib/view_component/fragment_caching/digestors/with_view_component_rb.rb

@@ -0,0 +1,80 @@
+module ViewComponent
+  module FragmentCaching
+    module Digestors
+      module WithViewComponentRb
+        class << self
+          def prepended(mod)
+            mod.singleton_class.prepend ClassMethods
+          end
+        end
+
+        module ClassMethods
+          def create(name, logical_name, template, partial)
+            klass = partial ? ActionView::Digestor::Partial : ActionView::Digestor::Node
+            children = ruby_nodes name, template, klass
+            klass.new name, logical_name, template, children
+          end
+
+          private
+
+          def ruby_nodes(name, template, klass)
+            identifier = template.identifier
+            if identifier.end_with?('.rb') || !identifier.match?(view_component_path_regex) ||
+               (component_class = name.classify.safe_constantize).nil?
+
+              return []
+            end
+
+            view_component_ancestors(component_class).map do |ancestor|
+              anc_identifier = ancestor.source_location
+              anc_logical_name = ancestor.name.underscore
+              view_component_ruby_node anc_identifier, anc_logical_name, template, klass
+            end
+          end
+
+          def view_component_path_regex
+            @view_component_path_regex ||=
+              begin
+                paths =
+                  ViewComponent::FragmentCaching.view_component_paths.map do |path|
+                    "/#{path}/".gsub Regexp.new('/{2,}'), '/'
+                  end
+                Regexp.new paths.join '|'
+              end
+          end
+
+          def view_component_ancestors(component_class)
+            ancestors = component_class.ancestors
+            return [] unless ancestors.include? ViewComponent::Base
+
+            ancestors.each_with_object [] do |ancestor, memo|
+              return memo if ancestor == ViewComponent::Base
+
+              memo << ancestor if ancestor.is_a? Class
+            end
+          end
+
+          def view_component_ruby_node(identifier, logical_name, template, klass)
+            "#{identifier.split('.').first}.rb".then do |rb_identifier|
+              next unless File.exist? rb_identifier
+
+              rb_source = File.read rb_identifier
+              rb_template = new_ruby_template rb_source, rb_identifier, template, logical_name
+              klass.new logical_name, logical_name, rb_template, []
+            end
+          end
+
+          def new_ruby_template(rb_source, rb_identifier, template, virtual_path)
+            ActionView::Template.new rb_source,
+                                     rb_identifier,
+                                     template.handler,
+                                     locals: template.locals,
+                                     format: template.format,
+                                     variant: template.variant,
+                                     virtual_path: virtual_path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/view_component/fragment_caching/engine.rb

@@ -0,0 +1,7 @@
+module ViewComponent
+  module FragmentCaching
+    class Engine < ::Rails::Engine
+      isolate_namespace ViewComponent::FragmentCaching
+    end
+  end
+end

data/lib/view_component/fragment_caching/resolvers/view_component_resolver.rb

@@ -0,0 +1,129 @@
+require 'action_view'
+
+module ViewComponent
+  module FragmentCaching
+    module Resolvers
+      class ViewComponentResolver < ActionView::FileSystemResolver
+        VIEW_COMPONENT_RUBY_HANDLER = :vc_rb
+        public_constant :VIEW_COMPONENT_RUBY_HANDLER
+
+        class PathParser < ActionView::Resolver::PathParser
+          class MatchedAttributes
+            FORMATS = (ActionView::Template::Types.symbols | %i(rb)).map(&Regexp.method(:escape)).join('|').freeze
+            private_constant :FORMATS
+
+            HANDLERS = ActionView::Template::Handlers.extensions.map(&Regexp.method(:escape)).join('|').freeze
+            private_constant :HANDLERS
+
+            LOCALES = '(?!rb)[a-z]{2}(?:-[A-Z]{2})?'.freeze
+            private_constant :LOCALES
+
+            VARIANTS = '[^.]*'.freeze
+            private_constant :VARIANTS
+
+            MATCH_NAMES = %i(prefix partial action locale format variant handler).freeze
+            private_constant :MATCH_NAMES
+
+            REGEX = %r{
+              \A
+              (?:(?<prefix>.*)/)?
+              (?<partial>_)?
+              (?<action>.*?)
+              (?:\.(?<locale>#{LOCALES}))??
+              (?:\.(?<format>#{FORMATS}))??
+              (?:\+(?<variant>#{VARIANTS}))??
+              (?:\.(?<handler>#{HANDLERS}))?
+              \z
+            }x.freeze
+            private_constant :REGEX
+
+            delegate :[], to: :match
+
+            def initialize(path)
+              @match = REGEX.match path
+            end
+
+            def format
+              matched_sym :format
+            end
+
+            def handler
+              matched_sym(:handler) || (VIEW_COMPONENT_RUBY_HANDLER if format == :rb)
+            end
+
+            def locale
+              matched_sym :locale
+            end
+
+            def variant
+              matched_sym :variant
+            end
+
+            def method_missing(method_name, *)
+              match[method_name] if MATCH_NAMES.include? method_name
+            end
+
+            def respond_to_missing?(method_name)
+              MATCH_NAMES.include? method_name
+            end
+
+            private
+
+            attr_reader :match
+
+            def matched_sym(key)
+              match[key]&.to_sym
+            end
+          end
+          private_constant :MatchedAttributes
+
+          def parse(path)
+            match = MatchedAttributes.new path
+            template_path = ActionView::TemplatePath.build match.action, match.prefix || '', !match.partial.nil?
+            details = ActionView::TemplateDetails.new match.locale, match.handler, match.format, match.variant
+            ParsedPath.new template_path, details
+          end
+        end
+        private_constant :PathParser
+
+        def initialize(path)
+          super
+          override_path_parser
+        end
+
+        def clear_cache
+          super
+          override_path_parser
+        end
+
+        # def find_all(name, prefix = nil, partial = false, details = {}, key = nil, locals = [])
+        def find_all(*args)
+          name      = args.fetch 0
+          prefix    = args.fetch 1, nil
+          partial   = false
+          details   = args.fetch 3, {}
+          given_key = args.fetch 4, nil
+          locals    = args.fetch 5, []
+
+          key = build_key given_key, details
+          super name, prefix, partial, details, key, locals
+        end
+
+        private
+
+        def override_path_parser
+          @path_parser = PathParser.new
+        end
+
+        def build_key(key, details)
+          (key || ActionView::TemplateDetails::Requested.new(**details)).then do |k|
+            ActionView::TemplateDetails::Requested.new formats: k.formats | %i(rb),
+                                                       handlers: k.handlers,
+                                                       locale: k.locale,
+                                                       variants: k.variants
+          end
+        end
+      end
+    end
+  end
+end

data/lib/view_component/fragment_caching/trackers/view_component_tracking.rb

@@ -0,0 +1,96 @@
+module ViewComponent
+  module FragmentCaching
+    module Trackers
+      module ViewComponentTracking
+        EXPLICIT_VIEW_COMPONENT_DEPENDENCY = /# View Component Dependency: (\S+)/.freeze
+        private_constant :EXPLICIT_VIEW_COMPONENT_DEPENDENCY
+
+        CAMEL_PHRASE = /(?:([A-Z]+[a-z]*[0-9]*)+)/.freeze
+        private_constant :CAMEL_PHRASE
+
+        MODULE_NAME = /(?:((::)?#{CAMEL_PHRASE}+)+)/.freeze
+        private_constant :MODULE_NAME
+
+        VIEW_COMPONENT_NAME = /(?:#{MODULE_NAME}Component)/.freeze
+        private_constant :VIEW_COMPONENT_NAME
+
+        MODULE_NAME_END = /(?:\b[^:])/.freeze
+        private_constant :MODULE_NAME_END
+
+        INVOKE_METHOD = /(?:\s*\.\s*(((public_)?send?(\s*\(?\s*):)?))/.freeze
+        private_constant :INVOKE_METHOD
+
+        INITIALIZE_METHOD_NAME = /(?:\b(new|with_collection)\b)/.freeze
+        private_constant :INITIALIZE_METHOD_NAME
+
+        VIEW_COMPONENT_RENDER_ARGUMENTS = /
+          \A
+          (?:\s*\(?\s*)
+          (?<view_component>#{VIEW_COMPONENT_NAME})
+          (?:#{INVOKE_METHOD})
+          (?:#{INITIALIZE_METHOD_NAME})
+        /xm.freeze
+        private_constant :VIEW_COMPONENT_RENDER_ARGUMENTS
+
+        CLASS_INHERITANCE = /(?:\s*\bclass\s+#{MODULE_NAME}\s*<\s*)/.freeze
+        private_constant :CLASS_INHERITANCE
+
+        VIEW_COMPONENT_INHERITANCE_DEPENDENCY = /
+          (?:#{CLASS_INHERITANCE})
+          (?<view_component>#{VIEW_COMPONENT_NAME})
+          (?:#{MODULE_NAME_END})
+        /xm.freeze
+        private_constant :VIEW_COMPONENT_INHERITANCE_DEPENDENCY
+
+        def dependencies
+          render_dependencies |
+            explicit_dependencies |
+            view_component_inheritance_dependencies |
+            explicit_view_component_dependencies
+        end
+
+        private
+
+        def render_dependencies
+          [].tap do |render_dependencies|
+            render_calls = source.split(/\brender\b/).drop(1)
+
+            render_calls.each do |arguments|
+              add_dependencies render_dependencies, arguments, self.class::LAYOUT_DEPENDENCY
+              add_dependencies render_dependencies, arguments, self.class::RENDER_ARGUMENTS
+              add_dependencies render_dependencies, arguments, VIEW_COMPONENT_RENDER_ARGUMENTS
+            end
+          end
+        end
+
+        def add_dependencies(render_dependencies, arguments, pattern)
+          arguments.scan pattern do
+            match = Regexp.last_match.named_captures.symbolize_keys
+            add_dynamic_dependency render_dependencies, match[:dynamic]
+            add_static_dependency render_dependencies, match[:static], match[:quote]
+            add_view_component_dependency render_dependencies, match[:view_component]
+          end
+        end
+
+        def add_view_component_dependency(dependencies, dependency)
+          return if dependency.blank?
+
+          path = dependency.underscore
+          dependencies << path unless dependencies.include? path
+        end
+
+        def view_component_inheritance_dependencies
+          scan_source VIEW_COMPONENT_INHERITANCE_DEPENDENCY
+        end
+
+        def explicit_view_component_dependencies
+          scan_source EXPLICIT_VIEW_COMPONENT_DEPENDENCY
+        end
+
+        def scan_source(pattern)
+          source.scan(pattern).flatten.uniq.map(&:underscore)
+        end
+      end
+    end
+  end
+end

data/lib/view_component/fragment_caching/version.rb

@@ -0,0 +1,6 @@
+module ViewComponent
+  module FragmentCaching
+    VERSION = '0.2.1'.freeze
+    public_constant :VERSION
+  end
+end

data/lib/view_component/fragment_caching.rb

@@ -0,0 +1,32 @@
+require 'action_view/dependency_tracker/erb_tracker'
+Dir[File.expand_path './fragment_caching/**/*.rb', __dir__].sort.each(&method(:require))
+
+module ViewComponent
+  module FragmentCaching
+    class << self
+      delegate :view_component_paths, to: :configuration
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+      end
+
+      def initialize!(context:)
+        prepend_view_component_paths context
+      end
+
+      private
+
+      def prepend_view_component_paths(context)
+        full_paths = view_component_paths.map(&Rails.root.method(:join))
+        Dir[*full_paths].each do |dir|
+          resolver = Resolvers::ViewComponentResolver.new dir
+          context.prepend_view_path resolver
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: view_component-fragment_caching
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Patrick Arnett
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: view_component
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.43'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.43'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.36'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.36'
+- !ruby/object:Gem::Dependency
+  name: pry-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.26'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+description: Monkey patch ActionView to track and digest view components within cached
+  fragments.
+email:
+- patrick.a.arnett@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- config/initializers/view_component/fragment_caching.rb
+- lib/view_component/fragment_caching.rb
+- lib/view_component/fragment_caching/configuration.rb
+- lib/view_component/fragment_caching/digestors/with_view_component_rb.rb
+- lib/view_component/fragment_caching/engine.rb
+- lib/view_component/fragment_caching/resolvers/view_component_resolver.rb
+- lib/view_component/fragment_caching/trackers/view_component_tracking.rb
+- lib/view_component/fragment_caching/version.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://www.github.com/patrickarnett/view_component-fragment_caching
+  changelog_uri: https://www.github.com/patrickarnett/view_component-fragment_caching/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Bust fragment caches when view components update
+test_files: []