actionview-component 1.7.0 → 1.17.0

data/lib/action_view/component/preview.rb

@@ -1,87 +1,8 @@
 # frozen_string_literal: true
 
-require "active_support/descendants_tracker"
-
 module ActionView
   module Component # :nodoc:
-    class Preview
-      extend ActiveSupport::DescendantsTracker
-      include ActionView::Component::TestHelpers
-
-      def render(component, *locals, &block)
-        render_inline(component, *locals, &block)
-      end
-
-      class << self
-        # Returns all component preview classes.
-        def all
-          load_previews if descendants.empty?
-          descendants
-        end
-
-        # Returns the html of the component in its layout
-        def call(example, layout: nil)
-          example_html = new.public_send(example)
-          if layout.nil?
-            layout = @layout.nil? ? "layouts/application" : @layout
-          end
-
-          Rails::ComponentExamplesController.render(template: "examples/show",
-                                                    layout: layout,
-                                                    assigns: { example: example_html })
-        end
-
-        # Returns the component object class associated to the preview.
-        def component
-          self.name.sub(%r{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.sub(/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
+    class Preview < ViewComponent::Preview
     end
   end
 end

data/lib/action_view/component/railtie.rb

@@ -1,66 +1,3 @@
 # frozen_string_literal: true
 
-require "rails"
-require "action_view/component"
-
-module ActionView
-  module Component
-    class Railtie < Rails::Railtie # :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|
-        require "railties/lib/rails/components_controller"
-        require "railties/lib/rails/component_examples_controller"
-
-        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
-          ActionView::Component::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 ActionView::Component::RenderMonkeyPatch
-        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
-end
+require "view_component/engine"

data/lib/action_view/component/test_case.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "active_support/test_case"
-
 module ActionView
   module Component
-    class TestCase < ActiveSupport::TestCase
+    class TestCase
       include ActionView::Component::TestHelpers
     end
   end

data/lib/action_view/component/test_helpers.rb

@@ -3,17 +3,7 @@
 module ActionView
   module Component
     module TestHelpers
-      def render_inline(component, **args, &block)
-        Nokogiri::HTML.fragment(controller.view_context.render(component, args, &block))
-      end
-
-      def controller
-        @controller ||= ApplicationController.new.tap { |c| c.request = request }
-      end
-
-      def request
-        @request ||= ActionDispatch::TestRequest.create
-      end
+      include ViewComponent::TestHelpers
 
       def render_component(component, **args, &block)
         ActiveSupport::Deprecation.warn(
@@ -22,14 +12,6 @@ module ActionView
 
         render_inline(component, args, &block)
       end
-
-      def with_variant(variant)
-        old_variants = controller.view_context.lookup_context.variants
-
-        controller.view_context.lookup_context.variants = variant
-        yield
-        controller.view_context.lookup_context.variants = old_variants
-      end
     end
   end
 end

data/lib/rails/generators/component/component_generator.rb

@@ -6,15 +6,16 @@ module Rails
       source_root File.expand_path("templates", __dir__)
 
       argument :attributes, type: :array, default: [], banner: "attribute"
-      hook_for :test_framework
       check_class_collision suffix: "Component"
 
       def create_component_file
-        template "component.rb", File.join("app/components",  "#{file_name}_component.rb")
+        template "component.rb", File.join("app/components", class_path, "#{file_name}_component.rb")
       end
 
-      def create_template_file
-        template "component.html.erb", File.join("app/components",  "#{file_name}_component.html.erb")
+      hook_for :test_framework
+
+      hook_for :template_engine do |instance, template_engine|
+        instance.invoke template_engine, [instance.name]
       end
 
       private
@@ -23,15 +24,8 @@ module Rails
         @_file_name ||= super.sub(/_component\z/i, "")
       end
 
-      def requires_content?
-        return @requires_content if @asked
-
-        @asked = true
-        @requires_content = ask("Would you like #{class_name} to require content? (Y/n)").downcase == "y"
-      end
-
       def parent_class
-        defined?(ApplicationComponent) ? "ApplicationComponent" : "ActionView::Component::Base"
+        defined?(ApplicationComponent) ? "ApplicationComponent" : "ViewComponent::Base"
       end
 
       def initialize_signature

data/lib/rails/generators/component/templates/component.rb.tt

@@ -1,8 +1,4 @@
 class <%= class_name %>Component < <%= parent_class %>
-  <%- if requires_content? -%>
-  validates :content, presence: true
-  <%- end -%>
-
   def initialize(<%= initialize_signature %>)
     <%= initialize_body %>
   end

data/lib/rails/generators/erb/component_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails/generators/erb"
+
+module Erb
+  module Generators
+    class ComponentGenerator < Base
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_view_file
+        template "component.html.erb", File.join("app/components", class_path, "#{file_name}_component.html.erb")
+      end
+
+      private
+
+      def file_name
+        @_file_name ||= super.sub(/_component\z/i, "")
+      end
+    end
+  end
+end

data/lib/rails/generators/erb/templates/component.html.erb.tt

@@ -0,0 +1 @@
+<div>Add <%= class_name %> template here</div>

data/lib/rails/generators/haml/component_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails/generators/erb/component_generator"
+
+module Haml
+  module Generators
+    class ComponentGenerator < Erb::Generators::ComponentGenerator
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_view_file
+        template "component.html.haml", File.join("app/components", class_path, "#{file_name}_component.html.haml")
+      end
+
+      private
+
+      def file_name
+        @_file_name ||= super.sub(/_component\z/i, "")
+      end
+    end
+  end
+end

data/lib/rails/generators/haml/templates/component.html.haml.tt

@@ -0,0 +1 @@
+%div Add <%= class_name %> template here

data/lib/rails/generators/rspec/component_generator.rb

@@ -6,7 +6,7 @@ module Rspec
       source_root File.expand_path("templates", __dir__)
 
       def create_test_file
-        template "component_spec.rb", File.join("spec/components", "#{file_name}_component_spec.rb")
+        template "component_spec.rb", File.join("spec/components", class_path, "#{file_name}_component_spec.rb")
       end
 
       private

data/lib/rails/generators/rspec/templates/component_spec.rb.tt

@@ -5,7 +5,7 @@ RSpec.describe <%= class_name %>Component, type: :component do
 
   # it "renders something useful" do
   #   expect(
-  #     render_inline(described_class, attr: "value") { "Hello, components!" }.css("p").to_html
+  #     render_inline(described_class.new(attr: "value")) { "Hello, components!" }.css("p").to_html
   #   ).to include(
   #     "Hello, components!"
   #   )

data/lib/rails/generators/slim/component_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails/generators/erb/component_generator"
+
+module Slim
+  module Generators
+    class ComponentGenerator < Erb::Generators::ComponentGenerator
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_view_file
+        template "component.html.slim", File.join("app/components", class_path, "#{file_name}_component.html.slim")
+      end
+
+      private
+
+      def file_name
+        @_file_name ||= super.sub(/_component\z/i, "")
+      end
+    end
+  end
+end

data/lib/rails/generators/slim/templates/component.html.slim.tt

@@ -0,0 +1 @@
+div Add <%= class_name %> template here

data/lib/rails/generators/test_unit/component_generator.rb

@@ -7,7 +7,7 @@ module TestUnit
       check_class_collision suffix: "ComponentTest"
 
       def create_test_file
-        template "component_test.rb", File.join("test/components", "#{file_name}_component_test.rb")
+        template "component_test.rb", File.join("test/components", class_path, "#{file_name}_component_test.rb")
       end
 
       private

data/lib/rails/generators/test_unit/templates/component_test.rb.tt

@@ -1,10 +1,10 @@
 require "test_helper"
 
-class <%= class_name %>ComponentTest < ActionView::Component::TestCase
+class <%= class_name %>ComponentTest < ViewComponent::TestCase
   test "component renders something useful" do
     # assert_equal(
-    #   %(<span title="my title">Hello, components!</span>),
-    #   render_inline(<%= class_name %>Component, attr: "value") { "Hello, components!" }.css("span").to_html
+    #   %(<span>Hello, components!</span>),
+    #   render_inline(<%= class_name %>Component.new(message: "Hello, components!")).css("span").to_html
     # )
   end
 end

data/lib/railties/lib/rails.rb

@@ -2,5 +2,4 @@
 
 module Rails
   autoload :ComponentsController
-  autoload :ComponentExamplesController
 end

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

@@ -1 +1 @@
-<%= raw @preview.call(@example_name) %>
+<%= render(@render_args[:component], **@render_args[:args], &@render_args[:block])%>

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