view_component_storybook 0.8.0 → 0.9.0

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,88 @@
+# 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
+      # I addition the args and kwargs can contain Controls the values of which can
+      # be resolved from a params hash
+      class ControlMethodArgs < ValidatableMethodArgs
+        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
+
+        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(args_from_params, kwargs_from_params, block)
+        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.param("#{param_prefix}__#{arg.param}".to_sym) 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
+        end
+
+        def control?(arg)
+          arg.is_a?(ViewComponent::Storybook::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,19 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Storybook
+    module MethodArgs
+      ##
+      # Simple class representing arguments passed to a method
+      class MethodArgs
+        attr_reader :args, :kwargs, :block
+
+        def initialize(args, kwargs, block)
+          @args = args
+          @kwargs = kwargs
+          @block = block
+        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/method_args/validatable_method_args.rb

@@ -0,0 +1,50 @@
+# 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 ValidatableMethodArgs < MethodArgs
+        include ActiveModel::Validations
+
+        attr_reader :target_method_params_names
+
+        validate :validate_args, :validate_kwargs
+
+        def initialize(target_method, *args, **kwargs, &block)
+          @target_method_params_names = MethodParametersNames.new(target_method)
+          super(args, kwargs, block)
+        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/stories.rb

@@ -4,10 +4,13 @@ module ViewComponent
   module Storybook
     class Stories
       extend ActiveSupport::DescendantsTracker
+      include ActiveModel::Validations
 
       class_attribute :story_configs, default: []
       class_attribute :parameters, :title, :stories_layout
 
+      validate :validate_story_configs
+
       class << self
         def story(name, component = default_component, &block)
           story_config = StoryConfig.configure(story_id(name), name, component, layout, &block)
@@ -26,6 +29,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)
@@ -70,6 +74,19 @@ module ViewComponent
           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)
@@ -95,6 +112,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_config.rb

@@ -6,31 +6,42 @@ module ViewComponent
       include ActiveModel::Validations
 
       attr_reader :id, :name, :component
-      attr_accessor :controls, :parameters, :layout, :content_block
+      attr_accessor :parameters, :layout, :content_block
+
+      validate :validate_constructor_args
 
       def initialize(id, name, component, layout)
         @id = id
         @name = name
         @component = component
         @layout = layout
-        @controls = []
+      end
+
+      def constructor_args(*args, **kwargs, &block)
+        if args.empty? && kwargs.empty? && block.nil?
+          @constructor_args ||= ViewComponent::Storybook::MethodArgs::ControlMethodArgs.new(component_constructor)
+        else
+          @constructor_args = ViewComponent::Storybook::MethodArgs::ControlMethodArgs.new(
+            component_constructor,
+            *args,
+            **kwargs,
+            &block
+          )
+        end
       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|
+        constructor_args.controls.each do |control|
           csf_params.deep_merge!(control.to_csf_params)
         end
         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)
@@ -38,6 +49,29 @@ module ViewComponent
         ViewComponent::Storybook::Dsl::StoryDsl.evaluate!(config, &configuration)
         config
       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
+
+      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 component_constructor
+        component.instance_method(:initialize)
+      end
     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