storybook_rails 1.0.0

data/lib/action_view/storybook/controls/control_config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Storybook
+    module Controls
+      class ControlConfig
+        include ActiveModel::Validations
+
+        attr_reader :param, :value, :name
+
+        validates :param, presence: true
+
+        def initialize(param, value, name: nil)
+          @param = param
+          @value = value
+          @name = name || param.to_s.humanize.titlecase
+        end
+
+        def to_csf_params
+          {
+            args: { param => csf_value },
+            argTypes: { param => { control: csf_control_params, name: name } }
+          }
+        end
+
+        def value_from_param(param)
+          param
+        end
+
+        private
+
+        # provide extension points for subclasses to vary the value
+        def csf_value
+          value
+        end
+
+        def csf_control_params
+          { type: type }
+        end
+      end
+    end
+  end
+end

data/lib/action_view/storybook/controls/date_config.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Storybook
+    module Controls
+      class DateConfig < ControlConfig
+        def initialize(param, value, name: nil)
+          super(param, value, name: name)
+        end
+
+        def type
+          :date
+        end
+
+        def value_from_param(param)
+          if param.is_a?(String)
+            DateTime.iso8601(param)
+          else
+            super(param)
+          end
+        end
+
+        private
+
+        def csf_value
+          params_value = value
+          params_value = params_value.in_time_zone if params_value.is_a?(Date)
+          params_value = params_value.iso8601 if params_value.is_a?(Time)
+          params_value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Storybook
+    module Controls
+      class NumberConfig < ControlConfig
+        TYPES = %i[number range].freeze
+
+        attr_reader :type, :min, :max, :step
+
+        validates :type, presence: true
+        validates :type, inclusion: { in: TYPES }, unless: -> { type.nil? }
+
+        def initialize(type, param, value, min: nil, max: nil, step: nil, name: nil)
+          super(param, value, 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
+          else
+            super(param)
+          end
+        end
+
+        private
+
+        def csf_control_params
+          params = super
+          params.merge(min: min, max: max, step: step).compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Storybook
+    module Controls
+      class ObjectConfig < ControlConfig
+        def type
+          :object
+        end
+
+        def value_from_param(param)
+          if param.is_a?(String)
+            JSON.parse(param).deep_symbolize_keys
+          else
+            super(param)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActionView
+  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
+
+        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, param, options, default_value, name: nil)
+          super(param, default_value, name: name)
+          @type = type
+          @options = options
+          @symbol_value = default_value.is_a?(Symbol)
+        end
+
+        def value_from_param(param)
+          if param.is_a?(String) && symbol_value
+            param.to_sym
+          else
+            super(param)
+          end
+        end
+
+        private
+
+        def csf_control_params
+          super.merge(options: options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Storybook
+    module Controls
+      class TextConfig < ControlConfig
+        def type
+          :text
+        end
+      end
+    end
+  end
+end

data/lib/action_view/storybook/dsl.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_support/dependencies/autoload"
+
+module ActionView
+  module Storybook
+    module Dsl
+      extend ActiveSupport::Autoload
+
+      autoload :StoryDsl
+      autoload :ControlsDsl
+    end
+  end
+end

data/lib/action_view/storybook/dsl/controls_dsl.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Storybook
+    module Dsl
+      class ControlsDsl
+        attr_reader :controls
+
+        def initialize(story_config)
+          @story_config = story_config
+          @controls = []
+        end
+
+        def text(param, value, name: nil)
+          controls << Controls::TextConfig.new(param, value, name: name)
+        end
+
+        def boolean(param, value, name: nil)
+          controls << Controls::BooleanConfig.new(param, value, name: name)
+        end
+
+        def number(param, value, name: nil, min: nil, max: nil, step: nil)
+          controls << Controls::NumberConfig.new(:number, param, value, 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, param, value, name: name, min: min, max: max, step: step)
+        end
+
+        def color(param, value, name: nil, preset_colors: nil)
+          controls << Controls::ColorConfig.new(param, value, name: name, preset_colors: preset_colors)
+        end
+
+        def object(param, value, name: nil)
+          controls << Controls::ObjectConfig.new(param, value, name: name)
+        end
+
+        def select(param, options, value, name: nil)
+          controls << Controls::OptionsConfig.new(:select, param, options, value, name: name)
+        end
+
+        def multi_select(param, options, value, name: nil)
+          controls << Controls::OptionsConfig.new(:'multi-select', param, options, value, name: name)
+        end
+
+        def radio(param, options, value, name: nil)
+          controls << Controls::OptionsConfig.new(:radio, param, options, value, name: name)
+        end
+
+        def inline_radio(param, options, value, name: nil)
+          controls << Controls::OptionsConfig.new(:'inline-radio', param, options, value, name: name)
+        end
+
+        def check(param, options, value, name: nil)
+          controls << Controls::OptionsConfig.new(:check, param, options, value, name: name)
+        end
+
+        def inline_check(param, options, value, name: nil)
+          controls << Controls::OptionsConfig.new(:'inline-check', param, options, value, name: name)
+        end
+
+        def array(param, value, separator = ",", name: nil)
+          controls << Controls::ArrayConfig.new(param, value, separator, name: name)
+        end
+
+        def date(param, value, name: nil)
+          controls << Controls::DateConfig.new(param, value, name: name)
+        end
+
+        def respond_to_missing?(_method, *)
+          true
+        end
+
+        def method_missing(method, *args)
+          value = args.first
+          control_method = case value
+                           when Date
+                             :date
+                           when Array
+                             :array
+                           when Hash
+                             :object
+                           when Numeric
+                             :number
+                           when TrueClass, FalseClass
+                             :boolean
+                           when String
+                             :text
+                           end
+          if control_method
+            send(control_method, method, *args)
+          else
+            super
+          end
+        end
+
+        Controls = ActionView::Storybook::Controls
+      end
+    end
+  end
+end

data/lib/action_view/storybook/dsl/story_dsl.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Storybook
+    module Dsl
+      class StoryDsl
+        def self.evaluate!(story_config, &block)
+          new(story_config).instance_eval(&block)
+        end
+
+        def parameters(**params)
+          @story_config.parameters = params
+        end
+
+        def controls(&block)
+          controls_dsl = ControlsDsl.new(story_config)
+          controls_dsl.instance_eval(&block)
+          @story_config.controls = controls_dsl.controls
+        end
+
+        def layout(layout)
+          @story_config.layout = layout
+        end
+
+        def content(&block)
+          @story_config.content_block = block
+        end
+
+        private
+
+        attr_reader :story_config
+
+        def initialize(story_config)
+          @story_config = story_config
+        end
+      end
+    end
+  end
+end

data/lib/action_view/storybook/engine.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "rails"
+require "action_view/storybook"
+
+module ActionView
+  module Storybook
+    class Engine < Rails::Engine
+      config.storybook_rails = ActiveSupport::OrderedOptions.new
+
+      initializer "storybook_rails.set_configs" do |app|
+        options = app.config.storybook_rails
+
+        options.show_stories = Rails.env.development? if options.show_stories.nil?
+
+        if options.show_stories
+          options.stories_path ||= defined?(Rails.root) ? Rails.root.join("test/components/stories") : nil
+        end
+
+        ActiveSupport.on_load(:storybook_rails) do
+          options.each { |k, v| send("#{k}=", v) }
+        end
+      end
+
+      initializer "storybook_rails.set_autoload_paths" do |app|
+        options = app.config.storybook_rails
+
+        ActiveSupport::Dependencies.autoload_paths << options.stories_path if options.show_stories && options.stories_path
+      end
+
+      config.after_initialize do |app|
+        options = app.config.storybook_rails
+
+        if options.show_stories
+          app.routes.prepend do
+            get "storybook/*stories/:story" => "action_view/storybook/stories#show"
+          end
+        end
+      end
+
+      rake_tasks do
+        load File.join(__dir__, "tasks/write_stories_json.rake")
+      end
+    end
+  end
+end

data/lib/action_view/storybook/helpers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_support/dependencies/autoload"
+
+module ActionView
+  module Storybook
+    module Helpers
+      extend ActiveSupport::Autoload
+
+      autoload :story_params
+    end
+  end
+end

data/lib/action_view/storybook/helpers/story_params.rb

@@ -0,0 +1,5 @@
+module StoryParamsHelper
+  def story_params
+    params.dig(:story_params)
+  end
+end

data/lib/action_view/storybook/stories.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Storybook
+    class Stories
+      extend ActiveSupport::DescendantsTracker
+      include ActiveModel::Validations
+
+      class_attribute :story_configs, default: []
+      class_attribute :parameters, :title, :stories_layout
+
+      validate :valid_story_configs
+
+      class << self
+        def story(name, template = default_template, &block)
+          story_config = StoryConfig.configure(story_id(name), name, layout, template, &block)
+          story_configs << story_config
+          story_config
+        end
+
+        def parameters(**params)
+          self.parameters = params
+        end
+
+        def layout(layout = nil)
+          # if no argument is passed act like a getter
+          self.stories_layout = layout unless layout.nil?
+          stories_layout
+        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)
+          csf_params
+        end
+
+        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
+          json_path
+        end
+
+        def stories_name
+          name.chomp("Stories").underscore
+        end
+
+        # Returns all component stories classes.
+        def all
+          load_stories if descendants.empty?
+          descendants
+        end
+
+        # Returns +true+ if the stories exist.
+        def stories_exists?(stories_name)
+          all.any? { |stories| stories.stories_name == stories_name }
+        end
+
+        # Find a component stories by its underscored class name.
+        def find_stories(stories_name)
+          all.find { |stories| stories.stories_name == stories_name }
+        end
+
+        # Returns +true+ if the story of the component stories exists.
+        def story_exists?(name)
+          story_configs.map(&:name).include?(name.to_sym)
+        end
+
+        # find the story by name
+        def find_story(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(ActiveModel::ValidationError, @validation_instance)
+        end
+
+        private
+
+        def inherited(other)
+          super(other)
+          # setup class defaults
+          other.title = other.stories_name.humanize.titlecase
+          other.story_configs = []
+        end
+
+        def default_template
+          "#{name.chomp("Stories").underscore}_stories"
+        end
+
+        def load_stories
+          if stories_path
+            Dir["#{stories_path}/**/*_stories.rb"].sort.each do |file|
+              require_dependency file
+            end
+          end
+        end
+
+        def stories_path
+          Storybook.stories_path
+        end
+
+        def story_id(name)
+          "#{stories_name}/#{name.to_s.parameterize}".underscore
+        end
+      end
+
+      protected
+
+      def valid_story_configs
+        story_configs.reject(&:valid?).each do |story_config|
+          errors.add(:story_configs, :invalid, value: story_config)
+        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?
+
+        errors.add(:story_configs, :invalid, message: "Stories #{'names'.pluralize(duplicate_names.count)} #{duplicate_names.to_sentence} are repeated")
+      end
+    end
+  end
+end