view_component_storybook 0.9.0 → 0.11.1

data/lib/view_component/storybook/method_args/control_method_args.rb

@@ -6,9 +6,9 @@ module ViewComponent
       ##
       # Class representing arguments passed to a method which can be validated
       # against the args of the target method
-      # I addition the args and kwargs can contain Controls the values of which can
+      # In addition the args and kwargs can contain Controls the values of which can
       # be resolved from a params hash
-      class ControlMethodArgs < ValidatableMethodArgs
+      class ControlMethodArgs < MethodArgs
         include ActiveModel::Validations::Callbacks
 
         attr_reader :param_prefix
@@ -21,6 +21,15 @@ module ViewComponent
           self
         end
 
+        ##
+        # resolve the controls values from the params
+        # call the target method or block with those values
+        def call(params, &target_block)
+          method_args = resolve_method_args(params)
+
+          (target_block || target_method).call(*method_args.args, **method_args.kwargs)
+        end
+
         def resolve_method_args(params)
           assign_control_params
 
@@ -31,7 +40,7 @@ module ViewComponent
             value_from_params(arg, params)
           end
 
-          MethodArgs.new(args_from_params, kwargs_from_params, block)
+          MethodArgs.new(target_method, *args_from_params, **kwargs_from_params)
         end
 
         def controls
@@ -59,21 +68,15 @@ module ViewComponent
 
           arg.param(param) if arg.param.nil? # don't overrite if set
           # Always add prefix
-          arg.param("#{param_prefix}__#{arg.param}".to_sym) if param_prefix.present?
+          arg.prefix_param(param_prefix) if param_prefix.present?
         end
 
         def value_from_params(arg, params)
-          if control?(arg)
-            value = arg.value_from_params(params)
-            value = arg.default_value if value.nil? # nil only not falsey
-            value
-          else
-            arg
-          end
+          control?(arg) ? arg.value_from_params(params) : arg
         end
 
         def control?(arg)
-          arg.is_a?(ViewComponent::Storybook::Controls::ControlConfig)
+          arg.is_a?(Controls::ControlConfig)
         end
 
         def validate_controls

data/lib/view_component/storybook/method_args/dry_initializer_component_constructor_args.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module MethodArgs
+      ##
+      # Class representing the constructor args for a Component the extends dry-initializer
+      class DryInitializerComponentConstructorArgs < ControlMethodArgs
+        INITIALIZE_METHOD = :__dry_initializer_initialize__
+
+        ##
+        # Method Parameters names that are dry-initialize aware
+        # THe main difference is that Dry Initializer keyword args cannot be deduced from the constructor initialize params
+        # Instead we have to introspect the dry_initializer config for the option definitions
+        class DryConstructorParametersNames < MethodParametersNames
+          attr_reader :dry_initializer
+
+          def initialize(component_class)
+            super(component_class.instance_method(INITIALIZE_METHOD))
+            @dry_initializer = component_class.dry_initializer
+          end
+
+          # Required keywords are the only thing we need.
+          # We could define kwarg_names similarly but wihout the `optional` check. However, dry-initializer
+          # always ends has supports_keyrest? == true so kwarg_names isn't needed
+          def req_kwarg_names
+            @req_kwarg_names ||= dry_initializer.definitions.map do |name, definition|
+              name if definition.option && !definition.optional
+            end.compact
+          end
+        end
+
+        def self.dry_initialize?(component_class)
+          component_class.private_method_defined?(INITIALIZE_METHOD)
+        end
+
+        def initialize(component_class, *args, **kwargs)
+          super(component_class.instance_method(INITIALIZE_METHOD), *args, **kwargs)
+
+          @target_method_params_names = DryConstructorParametersNames.new(component_class)
+        end
+      end
+    end
+  end
+end

data/lib/view_component/storybook/method_args/method_args.rb

@@ -4,14 +4,47 @@ module ViewComponent
   module Storybook
     module MethodArgs
       ##
-      # Simple class representing arguments passed to a method
+      # Class representing arguments passed to a method which can be validated
+      # against the args of the target method
       class MethodArgs
-        attr_reader :args, :kwargs, :block
+        include ActiveModel::Validations
 
-        def initialize(args, kwargs, block)
+        attr_reader :args, :kwargs, :target_method, :target_method_params_names
+
+        validate :validate_args, :validate_kwargs
+
+        def initialize(target_method, *args, **kwargs)
+          @target_method = target_method
           @args = args
           @kwargs = kwargs
-          @block = block
+          @target_method_params_names = MethodParametersNames.new(target_method)
+        end
+
+        private
+
+        def validate_args
+          arg_count = args.count
+
+          if arg_count > target_method_params_names.max_arg_count
+            errors.add(:args, :too_many, max: target_method_params_names.max_arg_count, count: arg_count)
+          elsif arg_count < target_method_params_names.min_arg_count
+            errors.add(:args, :too_few, min: target_method_params_names.min_arg_count, count: arg_count)
+          end
+        end
+
+        def validate_kwargs
+          kwargs.each_key do |kwarg|
+            unless target_method_params_names.include_kwarg?(kwarg)
+              errors.add(:kwargs, :invalid_arg, kwarg: kwarg)
+            end
+          end
+
+          return if target_method_params_names.covers_required_kwargs?(kwargs.keys)
+
+          expected_keys = target_method_params_names.req_kwarg_names.join(', ')
+          actual_keys = kwargs.keys.join(', ')
+
+          errors.add(:kwargs, :invalid, expected_keys: expected_keys, actual_keys: actual_keys)
         end
       end
     end

data/lib/view_component/storybook/method_args/method_parameters_names.rb

@@ -57,7 +57,7 @@ module ViewComponent
         def kwarg_names
           @kwarg_names ||= parameters.map do |type, name|
             name if KWARG_TYPES.include?(type)
-          end.compact.to_set
+          end.compact
         end
 
         def arg_names

data/lib/view_component/storybook/method_args.rb

@@ -9,8 +9,9 @@ module ViewComponent
 
       autoload :MethodArgs
       autoload :MethodParametersNames
-      autoload :ValidatableMethodArgs
       autoload :ControlMethodArgs
+      autoload :ComponentConstructorArgs
+      autoload :DryInitializerComponentConstructorArgs
     end
   end
 end

data/lib/view_component/storybook/slots/slot.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module Slots
+      class Slot
+        attr_reader :component, :slot_name, :slot_method_args, :content_block
+
+        # delegate :args, :kwargs, :controls, to: :slot_method_args
+
+        def initialize(component, slot_name, slot_method_args, content_block)
+          @component = component
+          @slot_name = slot_name
+          @slot_method_args = slot_method_args
+          @content_block = content_block
+        end
+
+        def call(&block)
+          component.send(slot_name, *slot_method_args.args, **slot_method_args.kwargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/view_component/storybook/slots/slot_config.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module Slots
+      class SlotConfig
+        include ActiveModel::Validations
+        include ContentConcern
+
+        attr_reader :slot_name, :slot_method_args, :param, :content_block
+
+        validate :validate_slot_method_args
+
+        def initialize(slot_name, slot_method_args, param, content_block)
+          @slot_name = slot_name
+          @slot_method_args = slot_method_args
+          @param = param
+          @content_block = content_block
+        end
+
+        def self.from_component(component_class, slot_name, param, *args, **kwargs, &block)
+          new(
+            slot_name,
+            slot_method_args(component_class, slot_name, *args, **kwargs).with_param_prefix(param),
+            param,
+            block
+          )
+        end
+
+        def slot(componeont, params)
+          resolved_method_args = slot_method_args.resolve_method_args(params)
+          story_content_block = resolve_content_block(params)
+          Slot.new(componeont, slot_name, resolved_method_args, story_content_block)
+        end
+
+        def controls
+          list = slot_method_args.controls.dup
+          list << content_control if content_control
+          list
+        end
+
+        def content_param
+          "#{param}__content".to_sym
+        end
+
+        private
+
+        def validate_slot_method_args
+          return if slot_method_args.valid?
+
+          slot_method_args_errors = slot_method_args.errors.full_messages.join(', ')
+          errors.add(:slot_method_args, :invalid, errors: slot_method_args_errors)
+        end
+
+        def self.slot_method_args(component_class, slot_name, *args, **kwargs)
+          # Reverse engineer the signature of the slot so that we can validate control args to the slot
+          # The slot methods themselves just have rest params so we can't introspect them. Instead we
+          # look for 'renderable' details of the registered slot
+          # This approach is tightly coupled to internal ViewCopmonent apis and might prove to be brittle
+          registred_slot_name = component_class.slot_type(slot_name) == :collection_item ? ActiveSupport::Inflector.pluralize(slot_name).to_sym : slot_name
+
+          registered_slot = component_class.registered_slots[registred_slot_name]
+
+          if registered_slot[:renderable] || registered_slot[:renderable_class_name]
+            # The slot is a component - either a class or a string representing the class
+            component_class = registered_slot[:renderable] || component_class.const_get(registered_slot[:renderable_class_name])
+            MethodArgs::ComponentConstructorArgs.from_component_class(component_class, *args, **kwargs)
+          else
+            # the slot is a lamba or a simple content slot
+            slot_lamba = registered_slot[:renderable_function] || proc {}
+            MethodArgs::ControlMethodArgs.new(slot_lamba, *args, **kwargs)
+          end
+        end
+
+        private_class_method :slot_method_args
+      end
+    end
+  end
+end

data/lib/view_component/storybook/slots.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_support/dependencies/autoload"
+
+module ViewComponent
+  module Storybook
+    module Slots
+      extend ActiveSupport::Autoload
+
+      autoload :SlotConfig
+      autoload :Slot
+    end
+  end
+end

data/lib/view_component/storybook/stories.rb

@@ -7,19 +7,28 @@ module ViewComponent
       include ActiveModel::Validations
 
       class_attribute :story_configs, default: []
-      class_attribute :parameters, :title, :stories_layout
+      class_attribute :stories_parameters, :stories_title, :stories_layout
 
       validate :validate_story_configs
 
       class << self
+        def title(title = nil)
+          # if no argument is passed act like a getter
+          self.stories_title = title unless title.nil?
+          stories_title
+        end
+
         def story(name, component = default_component, &block)
-          story_config = StoryConfig.configure(story_id(name), name, component, layout, &block)
+          story_config = StoryConfig.new(story_id(name), name, component, layout, &block)
+          story_config.instance_eval(&block)
           story_configs << story_config
           story_config
         end
 
-        def parameters(**params)
-          self.parameters = params
+        def parameters(params = nil)
+          # if no argument is passed act like a getter
+          self.stories_parameters = params unless params.nil?
+          stories_parameters
         end
 
         def layout(layout = nil)
@@ -38,9 +47,7 @@ module ViewComponent
 
         def write_csf_json
           json_path = File.join(stories_path, "#{stories_name}.stories.json")
-          File.open(json_path, "w") do |f|
-            f.write(JSON.pretty_generate(to_csf_params))
-          end
+          File.write(json_path, JSON.pretty_generate(to_csf_params))
           json_path
         end
 
@@ -60,7 +67,7 @@ module ViewComponent
         end
 
         # Find a component stories by its underscored class name.
-        def find_stories(stories_name)
+        def find_story_configs(stories_name)
           all.find { |stories| stories.stories_name == stories_name }
         end
 
@@ -70,7 +77,7 @@ module ViewComponent
         end
 
         # find the story by name
-        def find_story(name)
+        def find_story_config(name)
           story_configs.find { |config| config.name == name.to_sym }
         end
 
@@ -92,7 +99,7 @@ module ViewComponent
         def inherited(other)
           super(other)
           # setup class defaults
-          other.title = other.stories_name.humanize.titlecase
+          other.stories_title = other.stories_name.humanize.titlecase
           other.story_configs = []
         end
 

data/lib/view_component/storybook/story.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    class Story
+      include ActiveModel::Validations
+
+      attr_reader :component, :content_block, :slots, :layout
+
+      def initialize(component, content_block, slots, layout)
+        @component = component
+        @content_block = content_block
+        @slots = slots
+        @layout = layout
+      end
+    end
+  end
+end

data/lib/view_component/storybook/story_config.rb

@@ -4,37 +4,76 @@ module ViewComponent
   module Storybook
     class StoryConfig
       include ActiveModel::Validations
+      include ContentConcern
+      include Controls::ControlsHelpers
 
-      attr_reader :id, :name, :component
-      attr_accessor :parameters, :layout, :content_block
+      attr_reader :id, :name, :component_class
 
-      validate :validate_constructor_args
+      validate :validate_constructor_args, :validate_slots_args
 
-      def initialize(id, name, component, layout)
+      def initialize(id, name, component_class, layout)
         @id = id
         @name = name
-        @component = component
+        @component_class = component_class
         @layout = layout
+        @slots ||= {}
       end
 
-      def constructor_args(*args, **kwargs, &block)
-        if args.empty? && kwargs.empty? && block.nil?
-          @constructor_args ||= ViewComponent::Storybook::MethodArgs::ControlMethodArgs.new(component_constructor)
+      def constructor(*args, **kwargs, &block)
+        @constructor_args = MethodArgs::ComponentConstructorArgs.from_component_class(
+          component_class,
+          *args,
+          **kwargs
+        )
+        content(nil, &block)
+
+        self
+      end
+
+      # Once deprecated block version is removed make this a private getter
+      def controls(&block)
+        if block_given?
+          ActiveSupport::Deprecation.warn("`controls` will be removed in v1.0.0. Use `#constructor` instead.")
+          controls_dsl = Dsl::LegacyControlsDsl.new
+          controls_dsl.instance_eval(&block)
+
+          controls_hash = controls_dsl.controls.index_by(&:param)
+          constructor(**controls_hash)
         else
-          @constructor_args = ViewComponent::Storybook::MethodArgs::ControlMethodArgs.new(
-            component_constructor,
-            *args,
-            **kwargs,
-            &block
-          )
+          list = constructor_args.controls.dup
+          list << content_control if content_control
+          list += slots.flat_map(&:controls) if slots
+          list
         end
       end
 
+      def layout(layout = nil)
+        @layout = layout unless layout.nil?
+        @layout
+      end
+
+      def parameters(parameters = nil)
+        @parameters = parameters unless parameters.nil?
+        @parameters
+      end
+
+      def method_missing(method_name, *args, **kwargs, &block)
+        if component_class.slot_type(method_name)
+          slot(method_name, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, _include_private = false)
+        component_class.slot_type(method_name).present?
+      end
+
       def to_csf_params
         validate!
         csf_params = { name: name, parameters: { server: { id: id } } }
         csf_params.deep_merge!(parameters: parameters) if parameters.present?
-        constructor_args.controls.each do |control|
+        controls.each do |control|
           csf_params.deep_merge!(control.to_csf_params)
         end
         csf_params
@@ -44,17 +83,25 @@ module ViewComponent
         valid? || raise(ValidationError, self)
       end
 
-      def self.configure(id, name, component, layout, &configuration)
-        config = new(id, name, component, layout)
-        ViewComponent::Storybook::Dsl::StoryDsl.evaluate!(config, &configuration)
-        config
-      end
+      ##
+      # Build a Story from this config
+      # * Resolves the values of the constructor args from the params
+      # * constructs the component
+      # * resolve the content_control and content_block to a single block
+      # * builds a list of Slots by resolving their args from the params
+      def story(params)
+        # constructor_args.target_method is UnboundMethod so can't call it directly
+        component = constructor_args.call(params) do |*args, **kwargs|
+          component_class.new(*args, **kwargs)
+        end
 
-      def validate_constructor_args
-        return if constructor_args.valid?
+        story_content_block = resolve_content_block(params)
 
-        constructor_args_errors = constructor_args.errors.full_messages.join(', ')
-        errors.add(:constructor_args, :invalid, errors: constructor_args_errors)
+        story_slots = slots.map do |slot_config|
+          slot_config.slot(component, params)
+        end
+
+        Storybook::Story.new(component, story_content_block, story_slots, layout)
       end
 
       class ValidationError < StandardError
@@ -69,8 +116,55 @@ module ViewComponent
 
       private
 
-      def component_constructor
-        component.instance_method(:initialize)
+      def constructor_args
+        @constructor_args ||= MethodArgs::ComponentConstructorArgs.from_component_class(component_class)
+      end
+
+      def slots
+        @slots.values.flatten
+      end
+
+      def validate_constructor_args
+        return if constructor_args.valid?
+
+        constructor_args_errors = constructor_args.errors.full_messages.join(', ')
+        errors.add(:constructor_args, :invalid, errors: constructor_args_errors)
+      end
+
+      def validate_slots_args
+        slots.reject(&:valid?).each do |slot_config|
+          slot_errors = slot_config.errors.full_messages.join(', ')
+          errors.add(:slots, :invalid, errors: slot_errors)
+        end
+      end
+
+      def slot(slot_name, *args, **kwargs, &block)
+        # if the name is a slot then build a SlotConfig with slot_name and param the same
+        if component_class.slot_type(slot_name) == :collection_item
+          # generate a unique param generated by the count of slots with this name already added
+          @slots[slot_name] ||= []
+          slot_index = @slots[slot_name].count + 1
+          slot_config = Slots::SlotConfig.from_component(
+            component_class,
+            slot_name,
+            "#{slot_name}#{slot_index}".to_sym,
+            *args,
+            **kwargs,
+            &block
+          )
+          @slots[slot_name] << slot_config
+        else
+          slot_config = Slots::SlotConfig.from_component(
+            component_class,
+            slot_name,
+            slot_name,
+            *args,
+            **kwargs,
+            &block
+          )
+          @slots[slot_name] = slot_config
+        end
+        slot_config
       end
     end
   end

data/lib/view_component/storybook/tasks/write_stories_json.rake

@@ -12,7 +12,7 @@ namespace :view_component_storybook do
       exceptions << e
     end
 
-    raise StandardError, exceptions.map(:message).join(", ") if exceptions.present?
+    raise StandardError, exceptions.map(&:message).join(", ") if exceptions.present?
 
     puts "Done"
   end

data/lib/view_component/storybook/version.rb

@@ -2,6 +2,6 @@
 
 module ViewComponent
   module Storybook
-    VERSION = "0.9.0"
+    VERSION = "0.11.1"
   end
 end

data/lib/view_component/storybook.rb

@@ -10,9 +10,11 @@ module ViewComponent
     autoload :Controls
     autoload :Stories
     autoload :StoryConfig
-    autoload :ControlMethodArgs
-    autoload :Dsl
+    autoload :Story
+    autoload :Slots
+    autoload :ContentConcern
     autoload :MethodArgs
+    autoload :Dsl
 
     include ActiveSupport::Configurable
     # Set the location of component previews through app configuration:
@@ -29,6 +31,25 @@ module ViewComponent
     #
     mattr_accessor :show_stories, instance_writer: false
 
+    # Set the entry route for component stories:
+    #
+    #     config.view_component_storybook.stories_route = "/stories"
+    #
+    # Defaults to `/rails/stories` when `show_stories` is enabled.
+    #
+    mattr_accessor :stories_route, instance_writer: false
+
+    # :nocov:
+    if defined?(ViewComponent::Storybook::Engine)
+      ActiveSupport::Deprecation.warn(
+        "This manually engine loading is deprecated and will be removed in v1.0.0. " \
+        "Remove `require \"view_component/storybook/engine\"`."
+      )
+    elsif defined?(Rails::Engine)
+      require "view_component/storybook/engine"
+    end
+    # :nocov:
+
     ActiveSupport.run_load_hooks(:view_component_storybook, self)
   end
 end