view_component_storybook 0.8.0 → 0.11.0

data/lib/view_component/storybook/controls/multi_options_config.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module Controls
+      class MultiOptionsConfig < BaseOptionsConfig
+        TYPES = %i[multi-select check inline-check].freeze
+
+        validates :type, inclusion: { in: TYPES }, unless: -> { type.nil? }
+        validate :validate_default_value, unless: -> { options.nil? || default_value.nil? }
+
+        def initialize(type, options, default_value, labels: nil, param: nil, name: nil)
+          super(type, options, Array.wrap(default_value), labels: labels, param: param, name: name)
+        end
+
+        def value_from_params(params)
+          params_value = super(params)
+
+          if params_value.is_a?(String)
+            params_value = params_value.split(',')
+            params_value = params_value.map(&:to_sym) if symbol_values
+          end
+          params_value
+        end
+
+        def to_csf_params
+          super.deep_merge(argTypes: { param => { options: options } })
+        end
+
+        private
+
+        def csf_control_params
+          labels.nil? ? super : super.merge(labels: labels)
+        end
+
+        def symbol_values
+          @symbol_values ||= default_value.first.is_a?(Symbol)
+        end
+
+        def validate_default_value
+          errors.add(:default_value, :inclusion) unless default_value.to_set <= options.to_set
+        end
+      end
+    end
+  end
+end

data/lib/view_component/storybook/controls/number_config.rb

@@ -3,7 +3,7 @@
 module ViewComponent
   module Storybook
     module Controls
-      class NumberConfig < ControlConfig
+      class NumberConfig < SimpleControlConfig
         TYPES = %i[number range].freeze
 
         attr_reader :type, :min, :max, :step
@@ -11,27 +11,27 @@ module ViewComponent
         validates :type, presence: true
         validates :type, inclusion: { in: TYPES }, unless: -> { type.nil? }
 
-        def initialize(type, component, param, value, min: nil, max: nil, step: nil, name: nil)
-          super(component, param, value, name: name)
+        def initialize(type, default_value, min: nil, max: nil, step: nil, param: nil, name: nil)
+          super(default_value, param: param, name: name)
           @type = type
           @min = min
           @max = max
           @step = step
         end
 
-        def value_from_param(param)
-          if param.is_a?(String) && param.present?
-            (param.to_f % 1) > 0 ? param.to_f : param.to_i
+        def value_from_params(params)
+          params_value = super(params)
+          if params_value.is_a?(String) && params_value.present?
+            (params_value.to_f % 1) > 0 ? params_value.to_f : params_value.to_i
           else
-            super(param)
+            params_value
           end
         end
 
         private
 
         def csf_control_params
-          params = super
-          params.merge(min: min, max: max, step: step).compact
+          super.merge(min: min, max: max, step: step).compact
         end
       end
     end

data/lib/view_component/storybook/controls/object_config.rb

@@ -3,16 +3,24 @@
 module ViewComponent
   module Storybook
     module Controls
-      class ObjectConfig < ControlConfig
+      class ObjectConfig < SimpleControlConfig
         def type
           :object
         end
 
-        def value_from_param(param)
-          if param.is_a?(String)
-            JSON.parse(param).deep_symbolize_keys
+        def value_from_params(params)
+          params_value = super(params)
+          if params_value.is_a?(String)
+            parsed_json = JSON.parse(params_value)
+            if parsed_json.is_a?(Array)
+              parsed_json.map do |item|
+                item.is_a?(Hash) ? item.deep_symbolize_keys : item
+              end
+            else
+              parsed_json.deep_symbolize_keys
+            end
           else
-            super(param)
+            params_value
           end
         end
       end

data/lib/view_component/storybook/controls/options_config.rb

@@ -3,46 +3,33 @@
 module ViewComponent
   module Storybook
     module Controls
-      class OptionsConfig < ControlConfig
-        class << self
-          # support the options being a Hash or an Array. Storybook supports either.
-          def inclusion_in(config)
-            case config.options
-            when Hash
-              config.options.values
-            when Array
-              config.options
-            end
-          end
-        end
-
-        TYPES = %i[select multi-select radio inline-radio check inline-check].freeze
+      class OptionsConfig < BaseOptionsConfig
+        TYPES = %i[select radio inline-radio].freeze
 
-        attr_reader :type, :options, :symbol_value
-
-        validates :type, :options, presence: true
         validates :type, inclusion: { in: TYPES }, unless: -> { type.nil? }
-        validates :value, inclusion: { in: method(:inclusion_in) }, unless: -> { options.nil? || value.nil? }
-
-        def initialize(type, component, param, options, default_value, name: nil)
-          super(component, param, default_value, name: name)
-          @type = type
-          @options = options
-          @symbol_value = default_value.is_a?(Symbol)
-        end
+        validates :default_value, inclusion: { in: ->(config) { config.options } }, unless: -> { options.nil? || default_value.nil? }
 
-        def value_from_param(param)
-          if param.is_a?(String) && symbol_value
-            param.to_sym
+        def value_from_params(params)
+          params_value = super(params)
+          if params_value.is_a?(String) && symbol_value
+            params_value.to_sym
           else
-            super(param)
+            params_value
           end
         end
 
+        def to_csf_params
+          super.deep_merge(argTypes: { param => { options: options } })
+        end
+
         private
 
         def csf_control_params
-          super.merge(options: options)
+          labels.nil? ? super : super.merge(labels: labels)
+        end
+
+        def symbol_value
+          @symbol_value ||= default_value.is_a?(Symbol)
         end
       end
     end

data/lib/view_component/storybook/controls/simple_control_config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module Controls
+      ##
+      # A simple Control Config maps to one Storybook Control
+      # It has a value and pulls its value from params by key
+      class SimpleControlConfig < ControlConfig
+        attr_reader :default_value
+
+        def initialize(default_value, param: nil, name: nil)
+          super(param: param, name: name)
+          @default_value = default_value
+        end
+
+        def to_csf_params
+          validate!
+          {
+            args: { param => csf_value },
+            argTypes: { param => { control: csf_control_params, name: name } }
+          }
+        end
+
+        def value_from_params(params)
+          params.key?(param) ? params[param] : default_value
+        end
+
+        private
+
+        # provide extension points for subclasses to vary the value
+        def type
+          # :nocov:
+          raise NotImplementedError
+          # :nocov:
+        end
+
+        def csf_value
+          default_value
+        end
+
+        def csf_control_params
+          { type: type }
+        end
+      end
+    end
+  end
+end

data/lib/view_component/storybook/controls/text_config.rb

@@ -3,7 +3,7 @@
 module ViewComponent
   module Storybook
     module Controls
-      class TextConfig < ControlConfig
+      class TextConfig < SimpleControlConfig
         def type
           :text
         end

data/lib/view_component/storybook/controls.rb

@@ -8,14 +8,18 @@ module ViewComponent
       extend ActiveSupport::Autoload
 
       autoload :ControlConfig
+      autoload :SimpleControlConfig
       autoload :TextConfig
       autoload :BooleanConfig
       autoload :ColorConfig
       autoload :NumberConfig
+      autoload :BaseOptionsConfig
       autoload :OptionsConfig
-      autoload :ArrayConfig
+      autoload :MultiOptionsConfig
       autoload :DateConfig
       autoload :ObjectConfig
+      autoload :CustomConfig
+      autoload :ControlsHelpers
     end
   end
 end

data/lib/view_component/storybook/dsl/{controls_dsl.rb → legacy_controls_dsl.rb}

@@ -3,68 +3,65 @@
 module ViewComponent
   module Storybook
     module Dsl
-      class ControlsDsl
-        attr_reader :component, :controls
-
-        def initialize(component)
-          @component = component
-          @controls = []
+      class LegacyControlsDsl
+        def controls
+          @controls ||= []
         end
 
         def text(param, value, name: nil)
-          controls << Controls::TextConfig.new(component, param, value, name: name)
+          controls << Controls::TextConfig.new(value, param: param, name: name)
         end
 
         def boolean(param, value, name: nil)
-          controls << Controls::BooleanConfig.new(component, param, value, name: name)
+          controls << Controls::BooleanConfig.new(value, param: param, name: name)
         end
 
         def number(param, value, name: nil, min: nil, max: nil, step: nil)
-          controls << Controls::NumberConfig.new(:number, component, param, value, name: name, min: min, max: max, step: step)
+          controls << Controls::NumberConfig.new(:number, value, param: param, name: name, min: min, max: max, step: step)
         end
 
         def range(param, value, name: nil, min: nil, max: nil, step: nil)
-          controls << Controls::NumberConfig.new(:range, component, param, value, name: name, min: min, max: max, step: step)
+          controls << Controls::NumberConfig.new(:range, value, param: param, name: name, min: min, max: max, step: step)
         end
 
         def color(param, value, name: nil, preset_colors: nil)
-          controls << Controls::ColorConfig.new(component, param, value, name: name, preset_colors: preset_colors)
+          controls << Controls::ColorConfig.new(value, param: param, name: name, preset_colors: preset_colors)
         end
 
         def object(param, value, name: nil)
-          controls << Controls::ObjectConfig.new(component, param, value, name: name)
+          controls << Controls::ObjectConfig.new(value, param: param, name: name)
         end
 
         def select(param, options, value, name: nil)
-          controls << Controls::OptionsConfig.new(:select, component, param, options, value, name: name)
+          controls << Controls::OptionsConfig.new(:select, options, value, param: param, name: name)
         end
 
         def multi_select(param, options, value, name: nil)
-          controls << Controls::OptionsConfig.new(:'multi-select', component, param, options, value, name: name)
+          controls << Controls::OptionsConfig.new(:'multi-select', options, value, param: param, name: name)
         end
 
         def radio(param, options, value, name: nil)
-          controls << Controls::OptionsConfig.new(:radio, component, param, options, value, name: name)
+          controls << Controls::OptionsConfig.new(:radio, options, value, param: param, name: name)
         end
 
         def inline_radio(param, options, value, name: nil)
-          controls << Controls::OptionsConfig.new(:'inline-radio', component, param, options, value, name: name)
+          controls << Controls::OptionsConfig.new(:'inline-radio', options, value, param: param, name: name)
         end
 
         def check(param, options, value, name: nil)
-          controls << Controls::OptionsConfig.new(:check, component, param, options, value, name: name)
+          controls << Controls::OptionsConfig.new(:check, options, value, param: param, name: name)
         end
 
         def inline_check(param, options, value, name: nil)
-          controls << Controls::OptionsConfig.new(:'inline-check', component, param, options, value, name: name)
+          controls << Controls::OptionsConfig.new(:'inline-check', options, value, param: param, name: name)
         end
 
-        def array(param, value, separator = ",", name: nil)
-          controls << Controls::ArrayConfig.new(component, param, value, separator, name: name)
+        def array(param, value, _separator = nil, name: nil)
+          controls << Controls::ObjectConfig.new(value, param: param, name: name)
         end
 
         def date(param, value, name: nil)
-          controls << Controls::DateConfig.new(component, param, value, name: name)
+          controls << Controls::DateConfig.new(value, param: param, name: name)
         end
 
         def respond_to_missing?(_method, *)

data/lib/view_component/storybook/dsl.rb

@@ -7,8 +7,7 @@ module ViewComponent
     module Dsl
       extend ActiveSupport::Autoload
 
-      autoload :StoryDsl
-      autoload :ControlsDsl
+      autoload :LegacyControlsDsl
     end
   end
 end

data/lib/view_component/storybook/engine.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "rails"
-require "view_component/storybook"
 
 module ViewComponent
   module Storybook
@@ -12,6 +11,7 @@ module ViewComponent
         options = app.config.view_component_storybook
 
         options.show_stories = Rails.env.development? if options.show_stories.nil?
+        options.stories_route ||= ViewComponent::Storybook.stories_route
 
         if options.show_stories
           options.stories_path ||= defined?(Rails.root) ? Rails.root.join("test/components/stories") : nil
@@ -33,7 +33,7 @@ module ViewComponent
 
         if options.show_stories
           app.routes.prepend do
-            get "/rails/stories/*stories/:story" => "view_component/storybook/stories#show", :internal => true
+            get "#{options.stories_route}/*stories/:story" => "view_component/storybook/stories#show", :internal => true
           end
         end
       end
@@ -44,3 +44,14 @@ module ViewComponent
     end
   end
 end
+
+# :nocov:
+unless defined?(ViewComponent::Storybook)
+  ActiveSupport::Deprecation.warn(
+    "This manually engine loading is deprecated and will be removed in v1.0.0. " \
+    "Remove `require \"view_component/storybook/engine\"`."
+  )
+
+  require "view_component/storybook"
+end
+# :nocov:

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module MethodArgs
+      ##
+      # Class representing the constructor args for a Component
+      class ComponentConstructorArgs < ControlMethodArgs
+        def self.from_component_class(component_class, *args, **kwargs)
+          if DryInitializerComponentConstructorArgs.dry_initialize?(component_class)
+            DryInitializerComponentConstructorArgs.new(component_class, *args, **kwargs)
+          else
+            new(component_class, *args, **kwargs)
+          end
+        end
+
+        def initialize(component_class, *args, **kwargs)
+          super(component_class.instance_method(:initialize), *args, **kwargs)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module MethodArgs
+      ##
+      # Class representing arguments passed to a method which can be validated
+      # against the args of the target method
+      # In addition the args and kwargs can contain Controls the values of which can
+      # be resolved from a params hash
+      class ControlMethodArgs < MethodArgs
+        include ActiveModel::Validations::Callbacks
+
+        attr_reader :param_prefix
+
+        validate :validate_controls
+        before_validation :assign_control_params
+
+        def with_param_prefix(prefix)
+          @param_prefix = prefix
+          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
+
+          args_from_params = args.map do |arg|
+            value_from_params(arg, params)
+          end
+          kwargs_from_params = kwargs.transform_values do |arg|
+            value_from_params(arg, params)
+          end
+
+          MethodArgs.new(target_method, *args_from_params, **kwargs_from_params)
+        end
+
+        def controls
+          @controls ||= (args + kwargs.values).select(&method(:control?))
+        end
+
+        private
+
+        def assign_control_params
+          return if @assigned_control_params
+
+          args.each_with_index do |arg, index|
+            add_param_if_control(arg, target_method_params_names.arg_name(index))
+          end
+
+          kwargs.each do |key, arg|
+            add_param_if_control(arg, key)
+          end
+
+          @assigned_control_params = true
+        end
+
+        def add_param_if_control(arg, param)
+          return unless control?(arg)
+
+          arg.param(param) if arg.param.nil? # don't overrite if set
+          # Always add prefix
+          arg.prefix_param(param_prefix) if param_prefix.present?
+        end
+
+        def value_from_params(arg, params)
+          control?(arg) ? arg.value_from_params(params) : arg
+        end
+
+        def control?(arg)
+          arg.is_a?(Controls::ControlConfig)
+        end
+
+        def validate_controls
+          controls.reject(&:valid?).each do |control|
+            control_errors = control.errors.full_messages.join(', ')
+            errors.add(:controls, :invalid_control, control_name: control.name, control_errors: control_errors)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module MethodArgs
+      ##
+      # Class representing arguments passed to a method which can be validated
+      # against the args of the target method
+      class MethodArgs
+        include ActiveModel::Validations
+
+        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
+          @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
+  end
+end