view_component_storybook 0.8.0 → 0.11.0

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module MethodArgs
+      class MethodParametersNames
+        REQ_KWARG_TYPE = :keyreq
+        KWARG_TYPES = [REQ_KWARG_TYPE, :key].freeze
+        REQ_ARG_TYPE = :req
+        ARG_TYPES = [REQ_ARG_TYPE, :opt].freeze
+        KWARG_REST = :keyrest
+        REST = :rest
+
+        attr_reader :target_method
+
+        def initialize(target_method)
+          @target_method = target_method
+        end
+
+        def arg_name(pos)
+          if pos < named_arg_count
+            arg_names[pos]
+          else
+            offset_pos = pos - named_arg_count
+            "#{rest_arg_name}#{offset_pos}".to_sym
+          end
+        end
+
+        def include_kwarg?(kwarg_name)
+          supports_keyrest? || kwarg_names.include?(kwarg_name)
+        end
+
+        def covers_required_kwargs?(names)
+          names.to_set >= req_kwarg_names.to_set
+        end
+
+        def max_arg_count
+          supports_rest? ? Float::INFINITY : named_arg_count
+        end
+
+        def min_arg_count
+          req_arg_count
+        end
+
+        def req_kwarg_names
+          @req_kwarg_names ||= parameters.map do |type, name|
+            name if type == REQ_KWARG_TYPE
+          end.compact
+        end
+
+        private
+
+        def parameters
+          @parameters ||= target_method.parameters
+        end
+
+        def kwarg_names
+          @kwarg_names ||= parameters.map do |type, name|
+            name if KWARG_TYPES.include?(type)
+          end.compact
+        end
+
+        def arg_names
+          @arg_names ||= parameters.map do |type, name|
+            name if ARG_TYPES.include?(type)
+          end.compact
+        end
+
+        def req_arg_names
+          @req_arg_names ||= parameters.map do |type, name|
+            name if type == REQ_ARG_TYPE
+          end.compact
+        end
+
+        def named_arg_count
+          @named_arg_count ||= arg_names.count
+        end
+
+        def req_arg_count
+          @req_arg_count ||= req_arg_names.count
+        end
+
+        def rest_arg_name
+          @rest_arg_name ||= parameters.map { |type, name| name if type == REST }.first
+        end
+
+        def supports_keyrest?
+          @supports_keyrest ||= parameters.map(&:first).include?(KWARG_REST)
+        end
+
+        def supports_rest?
+          @supports_rest ||= parameters.map(&:first).include?(REST)
+        end
+      end
+    end
+  end
+end

data/lib/view_component/storybook/method_args.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "active_support/dependencies/autoload"
+
+module ViewComponent
+  module Storybook
+    module MethodArgs
+      extend ActiveSupport::Autoload
+
+      autoload :MethodArgs
+      autoload :MethodParametersNames
+      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

@@ -4,19 +4,31 @@ module ViewComponent
   module Storybook
     class Stories
       extend ActiveSupport::DescendantsTracker
+      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)
@@ -26,6 +38,7 @@ module ViewComponent
         end
 
         def to_csf_params
+          validate!
           csf_params = { title: title }
           csf_params[:parameters] = parameters if parameters.present?
           csf_params[:stories] = story_configs.map(&:to_csf_params)
@@ -34,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
 
@@ -56,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
 
@@ -66,16 +77,29 @@ 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
 
+        # validation - ActiveModel::Validations like but on the class vs the instance
+        def valid?
+          # use an instance so we can enjoy the benefits of ActiveModel::Validations
+          @validation_instance = new
+          @validation_instance.valid?
+        end
+
+        delegate :errors, to: :@validation_instance
+
+        def validate!
+          valid? || raise(ValidationError, @validation_instance)
+        end
+
         private
 
         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
 
@@ -95,6 +119,32 @@ module ViewComponent
           "#{stories_name}/#{name.to_s.parameterize}".underscore
         end
       end
+
+      protected
+
+      def validate_story_configs
+        story_configs.reject(&:valid?).each do |story_config|
+          story_errors = story_config.errors.full_messages.join(', ')
+          errors.add(:story_configs, :invalid_story, story_name: story_config.name, story_errors: story_errors)
+        end
+
+        story_names = story_configs.map(&:name)
+        duplicate_names = story_names.group_by(&:itself).map { |k, v| k if v.length > 1 }.compact
+        return if duplicate_names.empty?
+
+        duplicate_name_sentence = duplicate_names.map { |name| "'#{name}'" }.to_sentence
+        errors.add(:story_configs, :duplicate_stories, count: duplicate_names.count, duplicate_names: duplicate_name_sentence)
+      end
+
+      class ValidationError < StandardError
+        attr_reader :stories
+
+        def initialize(stories)
+          @stories = stories
+
+          super("#{@stories.class.name} invalid: (#{@stories.errors.full_messages.join(', ')})")
+        end
+      end
     end
   end
 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,19 +4,73 @@ module ViewComponent
   module Storybook
     class StoryConfig
       include ActiveModel::Validations
+      include ContentConcern
+      include Controls::ControlsHelpers
 
-      attr_reader :id, :name, :component
-      attr_accessor :controls, :parameters, :layout, :content_block
+      attr_reader :id, :name, :component_class
 
-      def initialize(id, name, component, layout)
+      validate :validate_constructor_args, :validate_slots_args
+
+      def initialize(id, name, component_class, layout)
         @id = id
         @name = name
-        @component = component
+        @component_class = component_class
         @layout = layout
-        @controls = []
+        @slots ||= {}
+      end
+
+      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
+          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?
         controls.each do |control|
@@ -25,18 +79,92 @@ module ViewComponent
         csf_params
       end
 
-      def values_from_params(params)
-        controls.map do |control|
-          value = control.value_from_param(params[control.param])
-          value = control.value if value.nil? # nil only not falsey
-          [control.param, value]
-        end.to_h
+      def validate!
+        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
+      ##
+      # 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
+
+        story_content_block = resolve_content_block(params)
+
+        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
+        attr_reader :story_config
+
+        def initialize(story_config)
+          @story_config = story_config
+
+          super("'#{@story_config.name}' invalid: (#{@story_config.errors.full_messages.join(', ')})")
+        end
+      end
+
+      private
+
+      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

@@ -4,10 +4,16 @@ namespace :view_component_storybook do
   desc "Write CSF JSON stories for all Stories"
   task write_stories_json: :environment do
     puts "Writing Stories JSON"
+    exceptions = []
     ViewComponent::Storybook::Stories.all.each do |stories|
       json_path = stories.write_csf_json
       puts "#{stories.name} => #{json_path}"
+    rescue StandardError => e
+      exceptions << e
     end
+
+    raise StandardError, exceptions.map(&:message).join(", ") if exceptions.present?
+
     puts "Done"
   end
 end

data/lib/view_component/storybook/version.rb

@@ -2,6 +2,6 @@
 
 module ViewComponent
   module Storybook
-    VERSION = "0.8.0"
+    VERSION = "0.11.0"
   end
 end

data/lib/view_component/storybook.rb

@@ -10,6 +10,10 @@ module ViewComponent
     autoload :Controls
     autoload :Stories
     autoload :StoryConfig
+    autoload :Story
+    autoload :Slots
+    autoload :ContentConcern
+    autoload :MethodArgs
     autoload :Dsl
 
     include ActiveSupport::Configurable
@@ -27,6 +31,27 @@ 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 do
+      "/rails/stories"
+    end
+
+    # :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