view_component 3.0.0.rc1 → 3.0.0.rc3

data/lib/view_component/translatable.rb

@@ -21,7 +21,7 @@ module ViewComponent
       end
 
       def build_i18n_backend
-        return if CompileCache.compiled? self
+        return if compiled?
 
         self.i18n_backend = if (translation_files = sidecar_files(%w[yml yaml])).any?
           # Returning nil cleans up if translations file has been removed since the last compilation
@@ -32,6 +32,27 @@ module ViewComponent
           )
         end
       end
+
+      def i18n_key(key, scope = nil)
+        scope = scope.join(".") if scope.is_a? Array
+        key = key&.to_s unless key.is_a?(String)
+        key = "#{scope}.#{key}" if scope
+        key = "#{i18n_scope}#{key}" if key.start_with?(".")
+        key
+      end
+
+      def translate(key = nil, **options)
+        return key.map { |k| translate(k, **options) } if key.is_a?(Array)
+
+        ensure_compiled
+
+        locale = options.delete(:locale) || ::I18n.locale
+        key = i18n_key(key, options.delete(:scope))
+
+        i18n_backend.translate(locale, key, options)
+      end
+
+      alias_method :t, :translate
     end
 
     class I18nBackend < ::I18n::Backend::Simple
@@ -64,15 +85,10 @@ module ViewComponent
       return key.map { |k| translate(k, **options) } if key.is_a?(Array)
 
       locale = options.delete(:locale) || ::I18n.locale
-      scope = options.delete(:scope)
-      scope = scope.join(".") if scope.is_a? Array
-      key = key&.to_s unless key.is_a?(String)
-      key = "#{scope}.#{key}" if scope
-      key = "#{i18n_scope}#{key}" if key.start_with?(".")
-
-      if HTML_SAFE_TRANSLATION_KEY.match?(key)
-        html_escape_translation_options!(options)
-      end
+      key = self.class.i18n_key(key, options.delete(:scope))
+      as_html = HTML_SAFE_TRANSLATION_KEY.match?(key)
+
+      html_escape_translation_options!(options) if as_html
 
       if key.start_with?(i18n_scope + ".")
         translated =
@@ -85,10 +101,7 @@ module ViewComponent
           return super(key, locale: locale, **options)
         end
 
-        if HTML_SAFE_TRANSLATION_KEY.match?(key)
-          translated = html_safe_translation(translated)
-        end
-
+        translated = html_safe_translation(translated) if as_html
         translated
       else
         super(key, locale: locale, **options)
@@ -101,6 +114,8 @@ module ViewComponent
       self.class.i18n_scope
     end
 
+    private
+
     def html_safe_translation(translation)
       if translation.respond_to?(:map)
         translation.map { |element| html_safe_translation(element) }
@@ -112,18 +127,13 @@ module ViewComponent
       end
     end
 
-    private
-
     def html_escape_translation_options!(options)
       options.each do |name, value|
-        unless i18n_option?(name) || (name == :count && value.is_a?(Numeric))
-          options[name] = ERB::Util.html_escape(value.to_s)
-        end
-      end
-    end
+        next if ::I18n.reserved_keys_pattern.match?(name)
+        next if name == :count && value.is_a?(Numeric)
 
-    def i18n_option?(name)
-      (@i18n_option_names ||= I18n::RESERVED_KEYS.to_set).include?(name)
+        options[name] = ERB::Util.html_escape(value.to_s)
+      end
     end
   end
 end

data/lib/view_component/version.rb

@@ -5,7 +5,7 @@ module ViewComponent
     MAJOR = 3
     MINOR = 0
     PATCH = 0
-    PRE = "rc1"
+    PRE = "rc3"
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end

data/lib/view_component.rb

@@ -7,11 +7,13 @@ module ViewComponent
   extend ActiveSupport::Autoload
 
   autoload :Base
+  autoload :CaptureCompatibility
   autoload :Compiler
   autoload :CompileCache
   autoload :ComponentError
   autoload :Config
   autoload :Deprecation
+  autoload :InlineTemplate
   autoload :Instrumentation
   autoload :Preview
   autoload :PreviewTemplateError

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: view_component
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc1
+  version: 3.0.0.rc3
 platform: ruby
 authors:
 - ViewComponent Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-17 00:00:00.000000000 Z
+date: 2023-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -353,6 +353,7 @@ files:
 - lib/rails/generators/test_unit/templates/component_test.rb.tt
 - lib/view_component.rb
 - lib/view_component/base.rb
+- lib/view_component/capture_compatibility.rb
 - lib/view_component/collection.rb
 - lib/view_component/compile_cache.rb
 - lib/view_component/compiler.rb
@@ -362,8 +363,8 @@ files:
 - lib/view_component/docs_builder_component.html.erb
 - lib/view_component/docs_builder_component.rb
 - lib/view_component/engine.rb
+- lib/view_component/inline_template.rb
 - lib/view_component/instrumentation.rb
-- lib/view_component/polymorphic_slots.rb
 - lib/view_component/preview.rb
 - lib/view_component/preview_template_error.rb
 - lib/view_component/rails/tasks/view_component.rake
@@ -373,9 +374,8 @@ files:
 - lib/view_component/render_to_string_monkey_patch.rb
 - lib/view_component/rendering_component_helper.rb
 - lib/view_component/rendering_monkey_patch.rb
-- lib/view_component/slot_v2.rb
+- lib/view_component/slot.rb
 - lib/view_component/slotable.rb
-- lib/view_component/slotable_v2.rb
 - lib/view_component/system_test_case.rb
 - lib/view_component/system_test_helpers.rb
 - lib/view_component/template_error.rb

data/lib/view_component/polymorphic_slots.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module ViewComponent
-  module PolymorphicSlots
-    # In older rails versions, using a concern isn't a good idea here because they appear to not work with
-    # Module#prepend and class methods.
-    def self.included(base)
-      if base != ViewComponent::Base
-        # :nocov:
-        location = Kernel.caller_locations(1, 1)[0]
-
-        warn(
-          "warning: ViewComponent::PolymorphicSlots is now included in ViewComponent::Base by default " \
-          "and can be removed from #{location.path}:#{location.lineno}"
-        )
-        # :nocov:
-      end
-
-      base.singleton_class.prepend(ClassMethods)
-      base.include(InstanceMethods)
-    end
-
-    module ClassMethods
-      def renders_one(slot_name, callable = nil)
-        return super unless callable.is_a?(Hash) && callable.key?(:types)
-
-        validate_singular_slot_name(slot_name)
-        register_polymorphic_slot(slot_name, callable[:types], collection: false)
-      end
-
-      def renders_many(slot_name, callable = nil)
-        return super unless callable.is_a?(Hash) && callable.key?(:types)
-
-        validate_plural_slot_name(slot_name)
-        register_polymorphic_slot(slot_name, callable[:types], collection: true)
-      end
-
-      def register_polymorphic_slot(slot_name, types, collection:)
-        unless types.empty?
-          getter_name = slot_name
-
-          define_method(getter_name) do
-            get_slot(slot_name)
-          end
-
-          define_method("#{getter_name}?") do
-            get_slot(slot_name).present?
-          end
-        end
-
-        renderable_hash = types.each_with_object({}) do |(poly_type, poly_callable), memo|
-          memo[poly_type] = define_slot(
-            "#{slot_name}_#{poly_type}", collection: collection, callable: poly_callable
-          )
-
-          setter_name =
-            if collection
-              "#{ActiveSupport::Inflector.singularize(slot_name)}_#{poly_type}"
-            else
-              "#{slot_name}_#{poly_type}"
-            end
-
-          define_method("with_#{setter_name}") do |*args, &block|
-            set_polymorphic_slot(slot_name, poly_type, *args, &block)
-          end
-          ruby2_keywords(:"with_#{setter_name}") if respond_to?(:ruby2_keywords, true)
-        end
-
-        registered_slots[slot_name] = {
-          collection: collection,
-          renderable_hash: renderable_hash
-        }
-      end
-    end
-
-    module InstanceMethods
-      def set_polymorphic_slot(slot_name, poly_type = nil, *args, &block)
-        slot_definition = self.class.registered_slots[slot_name]
-
-        if !slot_definition[:collection] && (defined?(@__vc_set_slots) && @__vc_set_slots[slot_name])
-          raise ArgumentError, "content for slot '#{slot_name}' has already been provided"
-        end
-
-        poly_def = slot_definition[:renderable_hash][poly_type]
-
-        set_slot(slot_name, poly_def, *args, &block)
-      end
-      ruby2_keywords(:set_polymorphic_slot) if respond_to?(:ruby2_keywords, true)
-    end
-  end
-end

data/lib/view_component/slotable_v2.rb

@@ -1,336 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "view_component/slot_v2"
-
-module ViewComponent
-  module SlotableV2
-    extend ActiveSupport::Concern
-
-    RESERVED_NAMES = {
-      singular: %i[content render].freeze,
-      plural: %i[contents renders].freeze
-    }.freeze
-
-    # 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 prefixed with `with_`.
-      #
-      #   <%= render_inline(MyComponent.new) do |component| %>
-      #     <% component.with_header(classes: "Foo") do %>
-      #       <p>Bar</p>
-      #     <% end %>
-      #   <% end %>
-      def renders_one(slot_name, callable = nil)
-        validate_singular_slot_name(slot_name)
-        validate_plural_slot_name(ActiveSupport::Inflector.pluralize(slot_name).to_sym)
-
-        define_method :"with_#{slot_name}" do |*args, &block|
-          set_slot(slot_name, nil, *args, &block)
-        end
-        ruby2_keywords(:"with_#{slot_name}") if respond_to?(:ruby2_keywords, true)
-
-        define_method slot_name do |*args, &block|
-          get_slot(slot_name)
-        end
-        ruby2_keywords(slot_name.to_sym) if respond_to?(:ruby2_keywords, true)
-
-        define_method "#{slot_name}?" do
-          get_slot(slot_name).present?
-        end
-
-        register_slot(slot_name, collection: false, callable: callable)
-      end
-
-      ##
-      # Registers a collection sub-component
-      #
-      # = Example
-      #
-      #   renders_many :items, -> (name:) { ItemComponent.new(name: name }
-      #
-      #   # OR
-      #
-      #   renders_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 prefixed with `with_`. The
-      # method can be called multiple times to append to the slot.
-      #
-      #   <%= render_inline(MyComponent.new) do |component| %>
-      #     <% component.with_item(name: "Foo") do %>
-      #       <p>One</p>
-      #     <% end %>
-      #
-      #     <% component.with_item(name: "Bar") do %>
-      #       <p>two</p>
-      #     <% end %>
-      #   <% end %>
-      def renders_many(slot_name, callable = nil)
-        singular_name = ActiveSupport::Inflector.singularize(slot_name)
-        validate_plural_slot_name(slot_name)
-        validate_singular_slot_name(ActiveSupport::Inflector.singularize(slot_name).to_sym)
-
-        define_method :"with_#{singular_name}" do |*args, &block|
-          set_slot(slot_name, nil, *args, &block)
-        end
-        ruby2_keywords(:"with_#{singular_name}") if respond_to?(:ruby2_keywords, true)
-
-        define_method :"with_#{slot_name}" do |collection_args = nil, &block|
-          collection_args.map do |args|
-            set_slot(slot_name, nil, **args, &block)
-          end
-        end
-
-        define_method slot_name do |collection_args = nil, &block|
-          get_slot(slot_name)
-        end
-
-        define_method "#{slot_name}?" do
-          get_slot(slot_name).present?
-        end
-
-        register_slot(slot_name, collection: true, callable: callable)
-      end
-
-      def slot_type(slot_name)
-        registered_slot = registered_slots[slot_name]
-        if registered_slot
-          registered_slot[:collection] ? :collection : :single
-        else
-          plural_slot_name = ActiveSupport::Inflector.pluralize(slot_name).to_sym
-          plural_registered_slot = registered_slots[plural_slot_name]
-          plural_registered_slot&.fetch(:collection) ? :collection_item : nil
-        end
-      end
-
-      # Clone slot configuration into child class
-      # see #test_slots_pollution
-      def inherited(child)
-        child.registered_slots = registered_slots.clone
-        super
-      end
-
-      private
-
-      def register_slot(slot_name, **kwargs)
-        registered_slots[slot_name] = define_slot(slot_name, **kwargs)
-      end
-
-      def define_slot(slot_name, collection:, callable:)
-        # Setup basic slot data
-        slot = {
-          collection: collection
-        }
-        return slot unless callable
-
-        # If callable responds to `render_in`, we set it on the slot as a renderable
-        if 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.respond_to?(:call)
-          # If slot doesn't 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)
-        else
-          raise(
-            ArgumentError,
-            "invalid slot definition. Please pass a class, string, or callable (i.e. proc, lambda, etc)"
-          )
-        end
-
-        slot
-      end
-
-      def validate_plural_slot_name(slot_name)
-        if RESERVED_NAMES[:plural].include?(slot_name.to_sym)
-          raise ArgumentError.new(
-            "#{self} declares a slot named #{slot_name}, which is a reserved word in the ViewComponent framework.\n\n" \
-            "To fix this issue, choose a different name."
-          )
-        end
-
-        raise_if_slot_ends_with_question_mark(slot_name)
-        raise_if_slot_registered(slot_name)
-      end
-
-      def validate_singular_slot_name(slot_name)
-        if slot_name.to_sym == :content
-          raise ArgumentError.new(
-            "#{self} declares a slot named content, which is a reserved word in ViewComponent.\n\n" \
-            "Content passed to a ViewComponent as a block is captured and assigned to the `content` accessor without having to create an explicit slot.\n\n" \
-            "To fix this issue, either use the `content` accessor directly or choose a different slot name."
-          )
-        end
-
-        if RESERVED_NAMES[:singular].include?(slot_name.to_sym)
-          raise ArgumentError.new(
-            "#{self} declares a slot named #{slot_name}, which is a reserved word in the ViewComponent framework.\n\n" \
-            "To fix this issue, choose a different name."
-          )
-        end
-
-        raise_if_slot_ends_with_question_mark(slot_name)
-        raise_if_slot_registered(slot_name)
-      end
-
-      def raise_if_slot_registered(slot_name)
-        if registered_slots.key?(slot_name)
-          # TODO remove? This breaks overriding slots when slots are inherited
-          raise ArgumentError.new(
-            "#{self} declares the #{slot_name} slot multiple times.\n\n" \
-            "To fix this issue, choose a different slot name."
-          )
-        end
-      end
-
-      def raise_if_slot_ends_with_question_mark(slot_name)
-        if slot_name.to_s.ends_with?("?")
-          raise ArgumentError.new(
-            "#{self} declares a slot named #{slot_name}, which ends with a question mark.\n\n" \
-            "This is not allowed because the ViewComponent framework already provides predicate " \
-            "methods ending in `?`.\n\n" \
-            "To fix this issue, choose a different name."
-          )
-        end
-      end
-    end
-
-    def get_slot(slot_name)
-      content unless content_evaluated? # ensure content is loaded so slots will be defined
-
-      slot = self.class.registered_slots[slot_name]
-      @__vc_set_slots ||= {}
-
-      if @__vc_set_slots[slot_name]
-        return @__vc_set_slots[slot_name]
-      end
-
-      if slot[:collection]
-        []
-      end
-    end
-
-    def set_slot(slot_name, slot_definition = nil, *args, &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've 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.__vc_content_block = block if block
-
-      # If class
-      if slot_definition[:renderable]
-        slot.__vc_component_instance = slot_definition[:renderable].new(*args)
-      # If class name as a string
-      elsif slot_definition[:renderable_class_name]
-        slot.__vc_component_instance =
-          self.class.const_get(slot_definition[:renderable_class_name]).new(*args)
-      # 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_function = slot_definition[:renderable_function].bind(self)
-        renderable_value =
-          if block
-            renderable_function.call(*args) do |*rargs|
-              view_context.capture(*rargs, &block)
-            end
-          else
-            renderable_function.call(*args)
-          end
-
-        # Function calls can return components, so if it's a component handle it specially
-        if renderable_value.respond_to?(:render_in)
-          slot.__vc_component_instance = renderable_value
-        else
-          slot.__vc_content = renderable_value
-        end
-      end
-
-      @__vc_set_slots ||= {}
-
-      if slot_definition[:collection]
-        @__vc_set_slots[slot_name] ||= []
-        @__vc_set_slots[slot_name].push(slot)
-      else
-        @__vc_set_slots[slot_name] = slot
-      end
-
-      slot
-    end
-    ruby2_keywords(:set_slot) if respond_to?(:ruby2_keywords, true)
-  end
-end