view_component 2.17.0

data/lib/view_component/collection.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  class Collection
+    def render_in(view_context, &block)
+      iterator = ActionView::PartialIteration.new(@collection.size)
+
+      @component.compile(raise_errors: true)
+      @component.validate_collection_parameter!(validate_default: true)
+
+      @collection.map do |item|
+        content = @component.new(**component_options(item, iterator)).render_in(view_context, &block)
+        iterator.iterate!
+        content
+      end.join.html_safe
+    end
+
+    private
+
+    def initialize(component, object, **options)
+      @component = component
+      @collection = collection_variable(object || [])
+      @options = options
+    end
+
+    def collection_variable(object)
+      if object.respond_to?(:to_ary)
+        object.to_ary
+      else
+        raise ArgumentError.new("The value of the argument isn't a valid collection. Make sure it responds to to_ary: #{object.inspect}")
+      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?
+
+      @options.merge(item_options)
+    end
+  end
+end

data/lib/view_component/compile_cache.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  # Keeps track of which templates have already been compiled
+  # This is not part of the public API
+  module CompileCache
+    mattr_accessor :cache, instance_reader: false, instance_accessor: false do
+      Set.new
+    end
+    module_function
+
+    def register(klass)
+      cache << klass
+    end
+
+    def compiled?(klass)
+      cache.include? klass
+    end
+
+    def invalidate!
+      cache.clear
+    end
+  end
+end

data/lib/view_component/engine.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "rails"
+require "view_component"
+
+module ViewComponent
+  class Engine < Rails::Engine # :nodoc:
+    config.view_component = ActiveSupport::OrderedOptions.new
+    config.view_component.preview_paths ||= []
+
+    initializer "view_component.set_configs" do |app|
+      options = app.config.view_component
+
+      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
+
+      if options.show_previews
+        options.preview_paths << "#{Rails.root}/test/components/previews" if defined?(Rails.root)
+
+        if options.preview_path.present?
+          ActiveSupport::Deprecation.warn(
+            "`preview_path` will be removed in v3.0.0. Use `preview_paths` instead."
+          )
+          options.preview_paths << options.preview_path
+        end
+      end
+
+      ActiveSupport.on_load(:view_component) do
+        options.each { |k, v| send("#{k}=", v) }
+      end
+    end
+
+    initializer "view_component.set_autoload_paths" do |app|
+      options = app.config.view_component
+
+      if options.show_previews && options.preview_path
+        ActiveSupport::Dependencies.autoload_paths << options.preview_path
+      end
+    end
+
+    initializer "view_component.eager_load_actions" do
+      ActiveSupport.on_load(:after_initialize) do
+        ViewComponent::Base.descendants.each(&:compile)
+      end
+    end
+
+    initializer "view_component.compile_config_methods" do
+      ActiveSupport.on_load(:view_component) do
+        config.compile_methods! if config.respond_to?(:compile_methods!)
+      end
+    end
+
+    initializer "view_component.monkey_patch_render" do |app|
+      next if Rails.version.to_f >= 6.1 || !app.config.view_component.render_monkey_patch_enabled
+
+      ActiveSupport.on_load(:action_view) do
+        require "view_component/render_monkey_patch"
+        ActionView::Base.prepend ViewComponent::RenderMonkeyPatch
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        require "view_component/rendering_monkey_patch"
+        require "view_component/render_to_string_monkey_patch"
+        ActionController::Base.prepend ViewComponent::RenderingMonkeyPatch
+        ActionController::Base.prepend ViewComponent::RenderToStringMonkeyPatch
+      end
+    end
+
+    initializer "view_component.include_render_component" do |app|
+      next if Rails.version.to_f >= 6.1
+
+      ActiveSupport.on_load(:action_view) do
+        require "view_component/render_component_helper"
+        ActionView::Base.include ViewComponent::RenderComponentHelper
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        require "view_component/rendering_component_helper"
+        require "view_component/render_component_to_string_helper"
+        ActionController::Base.include ViewComponent::RenderingComponentHelper
+        ActionController::Base.include ViewComponent::RenderComponentToStringHelper
+      end
+    end
+
+    config.after_initialize do |app|
+      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
+        end
+      end
+
+      app.executor.to_run :before do
+        CompileCache.invalidate! unless ActionView::Base.cache_template_loading
+      end
+    end
+  end
+end

data/lib/view_component/preview.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "active_support/descendants_tracker"
+
+module ViewComponent # :nodoc:
+  class Preview
+    include ActionView::Helpers::TagHelper
+    extend ActiveSupport::DescendantsTracker
+
+    def render(component, **args, &block)
+      {
+        args: args,
+        block: block,
+        component: component,
+        locals: {},
+        template: "view_components/preview",
+      }
+    end
+
+    def render_with_template(template: nil, locals: {})
+      {
+        template: template,
+        locals: locals
+      }
+    end
+
+    class << self
+      # Returns all component preview classes.
+      def all
+        load_previews if descendants.empty?
+        descendants
+      end
+
+      # Returns the arguments for rendering of the component in its layout
+      def render_args(example, params: {})
+        example_params_names = instance_method(example).parameters.map(&:last)
+        provided_params = params.slice(*example_params_names).to_h.symbolize_keys
+        result = provided_params.empty? ? new.public_send(example) : new.public_send(example, **provided_params)
+        result ||= {}
+        result[:template] = preview_example_template_path(example) if result[:template].nil?
+        @layout = nil unless defined?(@layout)
+        result.merge(layout: @layout)
+      end
+
+      # Returns the component object class associated to the preview.
+      def component
+        name.chomp("Preview").constantize
+      end
+
+      # Returns all of the available examples for the component preview.
+      def examples
+        public_instance_methods(false).map(&:to_s).sort
+      end
+
+      # Returns +true+ if the example of the component preview exists.
+      def example_exists?(example)
+        examples.include?(example)
+      end
+
+      # Returns +true+ if the preview exists.
+      def exists?(preview)
+        all.any? { |p| p.preview_name == preview }
+      end
+
+      # Find a component preview by its underscored class name.
+      def find(preview)
+        all.find { |p| p.preview_name == preview }
+      end
+
+      # Returns the underscored name of the component preview without the suffix.
+      def preview_name
+        name.chomp("Preview").underscore
+      end
+
+      # Setter for layout name.
+      def layout(layout_name)
+        @layout = layout_name
+      end
+
+      # Returns the relative path (from preview_path) to the preview example template if the template exists
+      def preview_example_template_path(example)
+        preview_path = Array(preview_paths).detect do |preview_path|
+          Dir["#{preview_path}/#{preview_name}_preview/#{example}.html.*"].first
+        end
+
+        if preview_path.nil?
+          raise PreviewTemplateError, "preview template for example #{example} does not exist"
+        end
+
+        path = Dir["#{preview_path}/#{preview_name}_preview/#{example}.html.*"].first
+        Pathname.new(path).relative_path_from(Pathname.new(preview_path)).to_s
+      end
+
+      private
+
+      def load_previews
+        Array(preview_paths).each do |preview_path|
+          Dir["#{preview_path}/**/*_preview.rb"].sort.each { |file| require_dependency file }
+        end
+      end
+
+      def preview_paths
+        Base.preview_paths
+      end
+
+      def show_previews
+        Base.show_previews
+      end
+    end
+  end
+end

data/lib/view_component/preview_template_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  class PreviewTemplateError < StandardError
+  end
+end

data/lib/view_component/previewable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module ViewComponent # :nodoc:
+  module Previewable
+    extend ActiveSupport::Concern
+
+    included do
+      # Set the location of component previews through app configuration:
+      #
+      #     config.view_component.preview_paths << "#{Rails.root}/lib/component_previews"
+      #
+      mattr_accessor :preview_paths, instance_writer: false
+
+      # TODO: deprecated, remove in v3.0.0
+      mattr_accessor :preview_path, instance_writer: false
+
+      # Enable or disable component previews through app configuration:
+      #
+      #     config.view_component.show_previews = true
+      #
+      # Defaults to +true+ for development environment
+      #
+      mattr_accessor :show_previews, instance_writer: false
+
+      # Set the entry route for component previews through app configuration:
+      #
+      #     config.view_component.preview_route = "/previews"
+      #
+      # Defaults to +/rails/view_components+ when `show_previews' is enabled
+      #
+      mattr_accessor :preview_route, instance_writer: false do
+        "/rails/view_components"
+      end
+    end
+  end
+end

data/lib/view_component/render_component_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module RenderComponentHelper # :nodoc:
+    def render_component(component, &block)
+      component.render_in(self, &block)
+    end
+  end
+end

data/lib/view_component/render_component_to_string_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module RenderComponentToStringHelper # :nodoc:
+    def render_component_to_string(component)
+      component.render_in(self.view_context)
+    end
+  end
+end

data/lib/view_component/render_monkey_patch.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module RenderMonkeyPatch # :nodoc:
+    def render(options = {}, args = {}, &block)
+      if options.respond_to?(:render_in)
+        options.render_in(self, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/view_component/render_to_string_monkey_patch.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module RenderToStringMonkeyPatch # :nodoc:
+    def render_to_string(options = {}, args = {})
+      if options.respond_to?(:render_in)
+        options.render_in(self.view_context)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/view_component/rendering_component_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module RenderingComponentHelper # :nodoc:
+    def render_component(component)
+      self.response_body = component.render_in(self.view_context)
+    end
+  end
+end

data/lib/view_component/rendering_monkey_patch.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module RenderingMonkeyPatch # :nodoc:
+    def render(options = {}, args = {})
+      if options.respond_to?(:render_in)
+        self.response_body = options.render_in(self.view_context)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/view_component/slot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  class Slot
+    attr_accessor :content
+  end
+end

data/lib/view_component/slotable.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+require "view_component/slot"
+
+module ViewComponent
+  module Slotable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # support initializing slots as:
+      #
+      # with_slot(
+      #   :header,
+      #   collection: true|false,
+      #   class_name: "Header" # class name string, used to instantiate Slot
+      # )
+      def with_slot(*slot_names, collection: false, class_name: nil)
+        slot_names.each do |slot_name|
+          # Ensure slot_name is not already declared
+          if self.slots.key?(slot_name)
+            raise ArgumentError.new("#{slot_name} slot declared multiple times")
+          end
+
+          # Ensure slot name is not :content
+          if slot_name == :content
+            raise ArgumentError.new ":content is a reserved slot name. Please use another name, such as ':body'"
+          end
+
+          # Set the name of the method used to access the Slot(s)
+          accessor_name =
+            if collection
+              # If Slot is a collection, set the accessor
+              # name to the pluralized form of the slot name
+              # For example: :tab => :tabs
+              ActiveSupport::Inflector.pluralize(slot_name)
+            else
+              slot_name
+            end
+
+          instance_variable_name = "@#{accessor_name}"
+
+          # If the slot is a collection, define an accesor that defaults to an empty array
+          if collection
+            class_eval <<-RUBY
+              def #{accessor_name}
+                #{instance_variable_name} ||= []
+              end
+            RUBY
+          else
+            attr_reader accessor_name
+          end
+
+          # Default class_name to ViewComponent::Slot
+          class_name = "ViewComponent::Slot" unless class_name.present?
+
+          # Register the slot on the component
+          self.slots[slot_name] = {
+            class_name: class_name,
+            instance_variable_name: instance_variable_name,
+            collection: collection
+          }
+        end
+      end
+    end
+
+    # Build a Slot instance on a component,
+    # exposing it for use inside the
+    # component template.
+    #
+    # slot: Name of Slot, in symbol form
+    # **args: Arguments to be passed to Slot initializer
+    #
+    # For example:
+    # <%= render(SlotsComponent.new) do |component| %>
+    #   <% component.slot(:footer, class_names: "footer-class") do %>
+    #     <p>This is my footer!</p>
+    #   <% end %>
+    # <% end %>
+    #
+    def slot(slot_name, **args, &block)
+      # Raise ArgumentError if `slot` does not exist
+      unless slots.keys.include?(slot_name)
+        raise ArgumentError.new "Unknown slot '#{slot_name}' - expected one of '#{slots.keys}'"
+      end
+
+      slot = slots[slot_name]
+
+      # The class name of the Slot, such as Header
+      slot_class = self.class.const_get(slot[:class_name])
+
+      unless slot_class <= ViewComponent::Slot
+        raise ArgumentError.new "#{slot[:class_name]} must inherit from ViewComponent::Slot"
+      end
+
+      # Instantiate Slot class, accommodating Slots that don't accept arguments
+      slot_instance = args.present? ? slot_class.new(**args) : slot_class.new
+
+      # Capture block and assign to slot_instance#content
+      slot_instance.content = view_context.capture(&block).strip.html_safe if block_given?
+
+      if slot[:collection]
+        # Initialize instance variable as an empty array
+        # if slot is a collection and has yet to be initialized
+        unless instance_variable_defined?(slot[:instance_variable_name])
+          instance_variable_set(slot[:instance_variable_name], [])
+        end
+
+        # Append Slot instance to collection accessor Array
+        instance_variable_get(slot[:instance_variable_name]) << slot_instance
+      else
+         # Assign the Slot instance to the slot accessor
+        instance_variable_set(slot[:instance_variable_name], slot_instance)
+      end
+
+      # Return nil, as this method should not output anything to the view itself.
+      nil
+    end
+  end
+end