view_component_storybook 0.5.0 → 0.10.0

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

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

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/dsl/{controls_dsl.rb → legacy_controls_dsl.rb}

@@ -3,71 +3,68 @@
 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)
+        def respond_to_missing?(_method, *)
           true
         end
 

data/lib/view_component/storybook/engine.rb

@@ -12,6 +12,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 +34,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

data/lib/view_component/storybook/method_args.rb

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

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.to_set
+        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/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/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,44 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module Slots
+      class SlotConfig
+        include ContentConcern
+
+        attr_reader :slot_name, :slot_method_args, :param, :content_block
+
+        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)
+          slot_method_args =
+            MethodArgs::ControlMethodArgs
+            .new(component_class.instance_method(slot_name), *args, **kwargs)
+            .with_param_prefix(param)
+          new(slot_name, slot_method_args, 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
+      end
+    end
+  end
+end