view_component 1.16.0

data/lib/railties/lib/rails/templates/rails/components/index.html.erb

@@ -0,0 +1,8 @@
+<% @previews.each do |preview| %>
+  <h3><%= link_to preview.preview_name.titleize, "/rails/components/#{preview.preview_name}" %></h3>
+  <ul>
+    <% preview.examples.each do |preview_example| %>
+      <li><%= link_to preview_example, "/rails/components/#{preview.preview_name}/#{preview_example}" %></li>
+    <% end %>
+  </ul>
+<% end %>

data/lib/railties/lib/rails/templates/rails/components/preview.html.erb

@@ -0,0 +1 @@
+<%= render(@render_args[:component], **@render_args[:args], &@render_args[:block])%>

data/lib/railties/lib/rails/templates/rails/components/previews.html.erb

@@ -0,0 +1,6 @@
+<h3><%= @preview.preview_name.titleize %></h3>
+<ul>
+  <% @preview.examples.each do |example| %>
+    <li><%= link_to example, "/rails/components/#{@preview.preview_name}/#{example}" %></li>
+  <% end %>
+</ul>

data/lib/view_component.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require "action_view"
+require "active_support/dependencies/autoload"
+
+module ViewComponent
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :Conversion
+  autoload :Preview
+  autoload :Previewable
+  autoload :TestHelpers
+  autoload :TestCase
+  autoload :RenderMonkeyPatch
+  autoload :RenderingMonkeyPatch
+  autoload :TemplateError
+end
+
+module ActionView
+  module Component
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :Preview
+    autoload :TestCase
+    autoload :TestHelpers
+  end
+end
+
+ActiveModel::Conversion.include ViewComponent::Conversion

data/lib/view_component/base.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require "action_view"
+require "active_support/configurable"
+require "view_component/previewable"
+
+module ViewComponent
+  class Base < ActionView::Base
+    include ActiveSupport::Configurable
+    include ViewComponent::Previewable
+
+    delegate :form_authenticity_token, :protect_against_forgery?, to: :helpers
+
+    class_attribute :content_areas, default: []
+    self.content_areas = [] # default doesn't work until Rails 5.2
+
+    # Entrypoint for rendering components.
+    #
+    # view_context: ActionView context from calling view
+    # block: optional block to be captured within the view context
+    #
+    # returns HTML that has been escaped by the respective template handler
+    #
+    # Example subclass:
+    #
+    # app/components/my_component.rb:
+    # class MyComponent < ViewComponent::Base
+    #   def initialize(title:)
+    #     @title = title
+    #   end
+    # end
+    #
+    # app/components/my_component.html.erb
+    # <span title="<%= @title %>">Hello, <%= content %>!</span>
+    #
+    # In use:
+    # <%= render MyComponent.new(title: "greeting") do %>world<% end %>
+    # returns:
+    # <span title="greeting">Hello, world!</span>
+    #
+    def render_in(view_context, &block)
+      self.class.compile!
+      @view_context = view_context
+      @view_renderer ||= view_context.view_renderer
+      @lookup_context ||= view_context.lookup_context
+      @view_flow ||= view_context.view_flow
+      @virtual_path ||= virtual_path
+      @variant = @lookup_context.variants.first
+
+      old_current_template = @current_template
+      @current_template = self
+
+      @content = view_context.capture(self, &block) if block_given?
+
+      before_render_check
+
+      if render?
+        send(self.class.call_method_name(@variant))
+      else
+        ""
+      end
+    ensure
+      @current_template = old_current_template
+    end
+
+    def before_render_check
+      # noop
+    end
+
+    def render?
+      true
+    end
+
+    def initialize(*); end
+
+    def render(options = {}, args = {}, &block)
+      if options.is_a?(String) || (options.is_a?(Hash) && options.has_key?(:partial))
+        view_context.render(options, args, &block)
+      else
+        super
+      end
+    end
+
+    def controller
+      @controller ||= view_context.controller
+    end
+
+    # Provides a proxy to access helper methods through
+    def helpers
+      @helpers ||= view_context
+    end
+
+    # Removes the first part of the path and the extension.
+    def virtual_path
+      self.class.source_location.gsub(%r{(.*app/components)|(\.rb)}, "")
+    end
+
+    def view_cache_dependencies
+      []
+    end
+
+    def format # :nodoc:
+      @variant
+    end
+
+    def with(area, content = nil, &block)
+      unless content_areas.include?(area)
+        raise ArgumentError.new "Unknown content_area '#{area}' - expected one of '#{content_areas}'"
+      end
+
+      if block_given?
+        content = view_context.capture(&block)
+      end
+
+      instance_variable_set("@#{area}".to_sym, content)
+      nil
+    end
+
+    private
+
+    def request
+      @request ||= controller.request
+    end
+
+    attr_reader :content, :view_context
+
+    # The controller used for testing components.
+    # Defaults to ApplicationController. This should be set early
+    # in the initialization process and should be set to a string.
+    mattr_accessor :test_controller
+    @@test_controller = "ApplicationController"
+
+    class << self
+      def inherited(child)
+        if defined?(Rails)
+          child.include Rails.application.routes.url_helpers unless child < Rails.application.routes.url_helpers
+        end
+
+        super
+      end
+
+      def call_method_name(variant)
+        if variant.present? && variants.include?(variant)
+          "call_#{variant}"
+        else
+          "call"
+        end
+      end
+
+      def source_location
+        @source_location ||=
+          begin
+            # Require `#initialize` to be defined so that we can use `method#source_location`
+            # to look up the filename of the component.
+            initialize_method = instance_method(:initialize)
+            initialize_method.source_location[0] if initialize_method.owner == self
+          end
+      end
+
+      def compiled?
+        @compiled && ActionView::Base.cache_template_loading
+      end
+
+      def inlined?
+        instance_methods(false).grep(/^call/).present? && templates.empty?
+      end
+
+      def compile!
+        compile(raise_template_errors: true)
+      end
+
+      # Compile templates to instance methods, assuming they haven't been compiled already.
+      # We could in theory do this on app boot, at least in production environments.
+      # Right now this just compiles the first time the component is rendered.
+      def compile(raise_template_errors: false)
+        return if compiled? || inlined?
+
+        if template_errors.present?
+          raise ViewComponent::TemplateError.new(template_errors) if raise_template_errors
+          return false
+        end
+
+        templates.each do |template|
+          class_eval <<-RUBY, template[:path], -1
+            def #{call_method_name(template[:variant])}
+              @output_buffer = ActionView::OutputBuffer.new
+              #{compiled_template(template[:path])}
+            end
+          RUBY
+        end
+
+        @compiled = true
+      end
+
+      def variants
+        templates.map { |template| template[:variant] }
+      end
+
+      # we'll eventually want to update this to support other types
+      def type
+        "text/html"
+      end
+
+      def identifier
+        source_location
+      end
+
+      def with_content_areas(*areas)
+        if areas.include?(:content)
+          raise ArgumentError.new ":content is a reserved content area name. Please use another name, such as ':body'"
+        end
+        attr_reader *areas
+        self.content_areas = areas
+      end
+
+      private
+
+      def matching_views_in_source_location
+        return [] unless source_location
+        (Dir["#{source_location.chomp(File.extname(source_location))}.*{#{ActionView::Template.template_handler_extensions.join(',')}}"] - [source_location])
+      end
+
+      def templates
+        @templates ||=
+          matching_views_in_source_location.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
+      end
+
+      def template_errors
+        @template_errors ||=
+          begin
+            errors = []
+            if source_location.nil?
+              # Require `#initialize` to be defined so that we can use `method#source_location`
+              # to look up the filename of the component.
+              errors << "#{self} must implement #initialize."
+            end
+
+            errors << "Could not find a template file for #{self}." if templates.empty?
+
+            if templates.count { |template| template[:variant].nil? } > 1
+              errors << "More than one template found for #{self}. 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 #{self}. There can only be one template file per variant."
+            end
+            errors
+          end
+      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(self, template)
+        else # remove before upstreaming into Rails
+          handler.call(OpenStruct.new(source: template, identifier: identifier, type: type))
+        end
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:action_view_component, self)
+  end
+end

data/lib/view_component/conversion.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ViewComponent # :nodoc:
+  module Conversion
+    def to_component_class
+      "#{self.class.name}Component".safe_constantize
+    end
+  end
+end

data/lib/view_component/engine.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "rails"
+require "view_component"
+
+module ViewComponent
+  class Engine < Rails::Engine # :nodoc:
+    config.action_view_component = ActiveSupport::OrderedOptions.new
+
+    initializer "action_view_component.set_configs" do |app|
+      options = app.config.action_view_component
+
+      options.show_previews = Rails.env.development? if options.show_previews.nil?
+
+      if options.show_previews
+        options.preview_path ||= defined?(Rails.root) ? "#{Rails.root}/test/components/previews" : nil
+      end
+
+      ActiveSupport.on_load(:action_view_component) do
+        options.each { |k, v| send("#{k}=", v) }
+      end
+    end
+
+    initializer "action_view_component.set_autoload_paths" do |app|
+      options = app.config.action_view_component
+
+      if options.show_previews && options.preview_path
+        ActiveSupport::Dependencies.autoload_paths << options.preview_path
+      end
+    end
+
+    initializer "action_view_component.eager_load_actions" do
+      ActiveSupport.on_load(:after_initialize) do
+        ViewComponent::Base.descendants.each(&:compile)
+      end
+    end
+
+    initializer "action_view_component.compile_config_methods" do
+      ActiveSupport.on_load(:action_view_component) do
+        config.compile_methods! if config.respond_to?(:compile_methods!)
+      end
+    end
+
+    initializer "action_view_component.monkey_patch_render" do
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Base.prepend ViewComponent::RenderMonkeyPatch
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.prepend ViewComponent::RenderingMonkeyPatch
+      end
+    end
+
+    config.after_initialize do |app|
+      options = app.config.action_view_component
+
+      if options.show_previews
+        app.routes.prepend do
+          get "/rails/components"       => "rails/components#index", :internal => true
+          get "/rails/components/*path" => "rails/components#previews", :internal => true
+        end
+      end
+    end
+  end
+end

data/lib/view_component/preview.rb

@@ -0,0 +1,78 @@
+# 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)
+      { component: component, args: args, block: block }
+    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)
+        new.public_send(example).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
+
+      private
+
+      def load_previews
+        if preview_path
+          Dir["#{preview_path}/**/*_preview.rb"].sort.each { |file| require_dependency file }
+        end
+      end
+
+      def preview_path
+        Base.preview_path
+      end
+
+      def show_previews
+        Base.show_previews
+      end
+    end
+  end
+end