view_component 2.19.1 → 2.23.0

data/lib/view_component/engine.rb

@@ -14,9 +14,12 @@ module ViewComponent
       options.render_monkey_patch_enabled = true if options.render_monkey_patch_enabled.nil?
       options.show_previews = Rails.env.development? if options.show_previews.nil?
       options.preview_route ||= ViewComponent::Base.preview_route
+      options.preview_controller ||= ViewComponent::Base.preview_controller
 
       if options.show_previews
-        options.preview_paths << "#{Rails.root}/test/components/previews" if defined?(Rails.root)
+        options.preview_paths << "#{Rails.root}/test/components/previews" if defined?(Rails.root) && Dir.exist?(
+          "#{Rails.root}/test/components/previews"
+        )
 
         if options.preview_path.present?
           ActiveSupport::Deprecation.warn(
@@ -41,7 +44,7 @@ module ViewComponent
 
     initializer "view_component.eager_load_actions" do
       ActiveSupport.on_load(:after_initialize) do
-        ViewComponent::Base.descendants.each(&:compile)
+        ViewComponent::Base.descendants.each(&:compile) if Rails.application.config.eager_load
       end
     end
 
@@ -87,9 +90,11 @@ module ViewComponent
       options = app.config.view_component
 
       if options.show_previews
-        app.routes.prepend do
-          get options.preview_route, to: "view_components#index", as: :preview_view_components, internal: true
-          get "#{options.preview_route}/*path", to: "view_components#previews", as: :preview_view_component, internal: true
+        app.routes.append do
+          preview_controller = options.preview_controller.sub(/Controller$/, "").underscore
+
+          get options.preview_route, to: "#{preview_controller}#index", as: :preview_view_components, internal: true
+          get "#{options.preview_route}/*path", to: "#{preview_controller}#previews", as: :preview_view_component, internal: true
         end
       end
 

data/lib/view_component/preview.rb

@@ -80,7 +80,10 @@ module ViewComponent # :nodoc:
         end
 
         path = Dir["#{preview_path}/#{preview_name}_preview/#{example}.html.*"].first
-        Pathname.new(path).relative_path_from(Pathname.new(preview_path)).to_s
+        Pathname.new(path)
+                .relative_path_from(Pathname.new(preview_path))
+                .to_s
+                .sub(/\..*$/, "")
       end
 
       private

data/lib/view_component/previewable.rb

@@ -41,6 +41,16 @@ module ViewComponent # :nodoc:
       mattr_accessor :preview_route, instance_writer: false do
         "/rails/view_components"
       end
+
+      # Set the controller to be used for previewing components through app configuration:
+      #
+      #     config.view_component.preview_controller = "MyPreviewController"
+      #
+      # Defaults to the provided +ViewComponentsController+
+      #
+      mattr_accessor :preview_controller, instance_writer: false do
+        "ViewComponentsController"
+      end
     end
   end
 end

data/lib/view_component/slot_v2.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  class SlotV2
+    attr_writer :_component_instance, :_content_block, :_content
+
+    def initialize(parent)
+      @parent = parent
+    end
+
+    # Used to render the slot content in the template
+    #
+    # There's currently 3 different values that may be set, that we can render.
+    #
+    # If the slot renderable is a component, the string class name of a
+    # component, or a function that returns a component, we render that
+    # component instance, returning the string.
+    #
+    # If the slot renderable is a function and returns a string, it is
+    # set as `@_content` and is returned directly.
+    #
+    # If there is no slot renderable, we evaluate the block passed to
+    # the slot and return it.
+    def to_s
+      if defined?(@_component_instance)
+        # render_in is faster than `parent.render`
+        @_component_instance.render_in(
+          @parent.send(:view_context),
+          &@_content_block
+        )
+      elsif defined?(@_content)
+        @_content
+      elsif defined?(@_content_block)
+        @_content_block.call
+      end
+    end
+
+    # Allow access to public component methods via the wrapper
+    #
+    # e.g.
+    #
+    # calling `header.name` (where `header` is a slot) will call `name`
+    # on the `HeaderComponent` instance.
+    #
+    # Where the component may look like:
+    #
+    # class MyComponent < ViewComponent::Base
+    #   has_one :header, HeaderComponent
+    #
+    #   class HeaderComponent < ViewComponent::Base
+    #     def name
+    #       @name
+    #     end
+    #   end
+    # end
+    #
+    def method_missing(symbol, *args, &block)
+      @_component_instance.public_send(symbol, *args, &block)
+    end
+
+    def respond_to_missing?(symbol, include_all = false)
+      @_component_instance.respond_to?(symbol, include_all)
+    end
+  end
+end

data/lib/view_component/slotable.rb

@@ -8,6 +8,12 @@ module ViewComponent
   module Slotable
     extend ActiveSupport::Concern
 
+    included do
+      # Hash of registered Slots
+      class_attribute :slots
+      self.slots = {}
+    end
+
     class_methods do
       # support initializing slots as:
       #
@@ -63,6 +69,14 @@ module ViewComponent
           }
         end
       end
+
+      def inherited(child)
+        # Clone slot configuration into child class
+        # see #test_slots_pollution
+        child.slots = self.slots.clone
+
+        super
+      end
     end
 
     # Build a Slot instance on a component,

data/lib/view_component/slotable_v2.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+require "view_component/slot_v2"
+
+module ViewComponent
+  module SlotableV2
+    extend ActiveSupport::Concern
+
+    # Setup component slot state
+    included do
+      # Hash of registered Slots
+      class_attribute :registered_slots
+      self.registered_slots = {}
+    end
+
+    class_methods do
+      ##
+      # Registers a sub-component
+      #
+      # = Example
+      #
+      #   renders_one :header -> (classes:) do
+      #     HeaderComponent.new(classes: classes)
+      #   end
+      #
+      #   # OR
+      #
+      #   renders_one :header, HeaderComponent
+      #
+      #   where `HeaderComponent` is defined as:
+      #
+      #   class HeaderComponent < ViewComponent::Base
+      #     def initialize(classes:)
+      #       @classes = classes
+      #     end
+      #   end
+      #
+      #   and has the following template:
+      #
+      #   <header class="<%= @classes %>">
+      #     <%= content %>
+      #   </header>
+      #
+      # = Rendering sub-component content
+      #
+      # The component's sidecar template can access the sub-component by calling a
+      # helper method with the same name as the sub-component.
+      #
+      #   <h1>
+      #     <%= header do %>
+      #       My header title
+      #     <% end %>
+      #   </h1>
+      #
+      # = Setting sub-component content
+      #
+      # Consumers of the component can render a sub-component by calling a
+      # helper method with the same name as the slot.
+      #
+      #   <%= render_inline(MyComponent.new) do |component| %>
+      #     <%= component.header(classes: "Foo") do %>
+      #       <p>Bar</p>
+      #     <% end %>
+      #   <% end %>
+      def renders_one(slot_name, callable = nil)
+        validate_slot_name(slot_name)
+
+        define_method slot_name do |*args, **kwargs, &block|
+          if args.empty? && kwargs.empty? && block.nil?
+            get_slot(slot_name)
+          else
+            set_slot(slot_name, *args, **kwargs, &block)
+          end
+        end
+
+        register_slot(slot_name, collection: false, callable: callable)
+      end
+
+      ##
+      # Registers a collection sub-component
+      #
+      # = Example
+      #
+      #   render_many :items, -> (name:) { ItemComponent.new(name: name }
+      #
+      #   # OR
+      #
+      #   render_many :items, ItemComponent
+      #
+      # = Rendering sub-components
+      #
+      # The component's sidecar template can access the slot by calling a
+      # helper method with the same name as the slot.
+      #
+      #   <h1>
+      #     <%= items.each do |item| %>
+      #       <%= item %>
+      #     <% end %>
+      #   </h1>
+      #
+      # = Setting sub-component content
+      #
+      # Consumers of the component can set the content of a slot by calling a
+      # helper method with the same name as the slot. The method can be
+      # called multiple times to append to the slot.
+      #
+      #   <%= render_inline(MyComponent.new) do |component| %>
+      #     <%= component.item(name: "Foo") do %>
+      #       <p>One</p>
+      #     <% end %>
+      #
+      #     <%= component.item(name: "Bar") do %>
+      #       <p>two</p>
+      #     <% end %>
+      #   <% end %>
+      def renders_many(slot_name, callable = nil)
+        validate_slot_name(slot_name)
+
+        singular_name = ActiveSupport::Inflector.singularize(slot_name)
+
+        # Define setter for singular names
+        # e.g. `renders_many :items` allows fetching all tabs with
+        # `component.tabs` and setting a tab with `component.tab`
+        define_method singular_name do |*args, **kwargs, &block|
+          set_slot(slot_name, *args, **kwargs, &block)
+        end
+
+        # Instantiates and and adds multiple slots forwarding the first
+        # argument to each slot constructor
+        define_method slot_name do |collection_args = nil, &block|
+          if collection_args.nil? && block.nil?
+            get_slot(slot_name)
+          else
+            collection_args.each do |args|
+              set_slot(slot_name, **args, &block)
+            end
+          end
+        end
+
+        register_slot(slot_name, collection: true, callable: callable)
+      end
+
+      # Clone slot configuration into child class
+      # see #test_slots_pollution
+      def inherited(child)
+        child.registered_slots = self.registered_slots.clone
+        super
+      end
+
+      private
+
+      def register_slot(slot_name, collection:, callable:)
+        # Setup basic slot data
+        slot = {
+          collection: collection,
+        }
+        # If callable responds to `render_in`, we set it on the slot as a renderable
+        if callable && callable.respond_to?(:method_defined?) && callable.method_defined?(:render_in)
+          slot[:renderable] = callable
+        elsif callable.is_a?(String)
+          # If callable is a string, we assume it's referencing an internal class
+          slot[:renderable_class_name] = callable
+        elsif callable
+          # If slot does not respond to `render_in`, we assume it's a proc,
+          # define a method, and save a reference to it to call when setting
+          method_name = :"_call_#{slot_name}"
+          define_method method_name, &callable
+          slot[:renderable_function] = instance_method(method_name)
+        end
+
+        # Register the slot on the component
+        self.registered_slots[slot_name] = slot
+      end
+
+      def validate_slot_name(slot_name)
+        if self.registered_slots.key?(slot_name)
+          # TODO remove? This breaks overriding slots when slots are inherited
+          raise ArgumentError.new("#{slot_name} slot declared multiple times")
+        end
+      end
+    end
+
+    def get_slot(slot_name)
+      slot = self.class.registered_slots[slot_name]
+      @_set_slots ||= {}
+
+      if @_set_slots[slot_name]
+        return @_set_slots[slot_name]
+      end
+
+      if slot[:collection]
+        []
+      else
+        nil
+      end
+    end
+
+    def set_slot(slot_name, *args, **kwargs, &block)
+      slot_definition = self.class.registered_slots[slot_name]
+
+      slot = SlotV2.new(self)
+
+      # Passing the block to the sub-component wrapper like this has two
+      # benefits:
+      #
+      # 1. If this is a `content_area` style sub-component, we will render the
+      # block via the `slot`
+      #
+      # 2. Since we have to pass block content to components when calling
+      # `render`, evaluating the block here would require us to call
+      # `view_context.capture` twice, which is slower
+      slot._content_block = block if block_given?
+
+      # If class
+      if slot_definition[:renderable]
+        slot._component_instance = slot_definition[:renderable].new(*args, **kwargs)
+      # If class name as a string
+      elsif slot_definition[:renderable_class_name]
+        slot._component_instance = self.class.const_get(slot_definition[:renderable_class_name]).new(*args, **kwargs)
+      # If passed a lambda
+      elsif slot_definition[:renderable_function]
+        # Use `bind(self)` to ensure lambda is executed in the context of the
+        # current component. This is necessary to allow the lambda to access helper
+        # methods like `content_tag` as well as parent component state.
+        renderable_value = slot_definition[:renderable_function].bind(self).call(*args, **kwargs, &block)
+
+        # Function calls can return components, so if it's a component handle it specially
+        if renderable_value.respond_to?(:render_in)
+          slot._component_instance = renderable_value
+        else
+          slot._content = renderable_value
+        end
+      end
+
+      @_set_slots ||= {}
+
+      if slot_definition[:collection]
+        @_set_slots[slot_name] ||= []
+        @_set_slots[slot_name].push(slot)
+      else
+        @_set_slots[slot_name] = slot
+      end
+
+      nil
+    end
+  end
+end

data/lib/view_component/version.rb

@@ -3,8 +3,8 @@
 module ViewComponent
   module VERSION
     MAJOR = 2
-    MINOR = 19
-    PATCH = 1
+    MINOR = 23
+    PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].join(".")
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: view_component
 version: !ruby/object:Gem::Version
-  version: 2.19.1
+  version: 2.23.0
 platform: ruby
 authors:
 - GitHub Open Source
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-21 00:00:00.000000000 Z
+date: 2020-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -184,6 +184,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.7.2
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
 description:
 email:
 - opensource+view_component@github.com
@@ -215,6 +229,7 @@ files:
 - lib/view_component/base.rb
 - lib/view_component/collection.rb
 - lib/view_component/compile_cache.rb
+- lib/view_component/compiler.rb
 - lib/view_component/engine.rb
 - lib/view_component/preview.rb
 - lib/view_component/preview_template_error.rb
@@ -226,7 +241,9 @@ files:
 - lib/view_component/rendering_component_helper.rb
 - lib/view_component/rendering_monkey_patch.rb
 - lib/view_component/slot.rb
+- lib/view_component/slot_v2.rb
 - lib/view_component/slotable.rb
+- lib/view_component/slotable_v2.rb
 - lib/view_component/template_error.rb
 - lib/view_component/test_case.rb
 - lib/view_component/test_helpers.rb