lookbook 1.2.1 → 1.3.0

data/lib/lookbook/engine.rb

@@ -1,6 +1,7 @@
 require "view_component"
 require "action_cable/engine"
 require "listen"
+require "yard"
 
 module Lookbook
   class Engine < Rails::Engine
@@ -8,18 +9,17 @@ module Lookbook
 
     config.autoload_paths << File.expand_path(root.join("app/components"))
 
-    initializer "lookbook.viewcomponent.config" do
-      Lookbook.config.preview_paths += config.view_component.preview_paths
-      Lookbook.config.preview_controller ||= config.view_component.preview_controller
-
-      Lookbook.config.components_path = config.view_component.view_component_path if config.view_component.view_component_path.present?
-
-      Lookbook.config.listen_paths += Lookbook.config.preview_paths
-      Lookbook.config.listen_paths << Lookbook.config.components_path
+    config.before_configuration do
+      config.lookbook = Lookbook.config
     end
 
-    initializer "lookbook.parser.tags" do
-      Lookbook::Parser.define_tags(Engine.tags)
+    initializer "lookbook.viewcomponent.config_sync" do
+      opts.preview_paths += config.view_component.preview_paths
+      opts.preview_controller ||= config.view_component.preview_controller
+
+      if config.view_component.view_component_path.present?
+        opts.components_path = config.view_component.view_component_path
+      end
     end
 
     initializer "lookbook.assets.serve" do
@@ -29,178 +29,129 @@ module Lookbook
       )
     end
 
-    config.before_configuration do
-      config.lookbook = Lookbook.config
+    initializer "lookbook.file_watcher.paths" do
+      opts.listen_paths += opts.preview_paths
+      opts.listen_paths << opts.components_path
     end
 
-    config.after_initialize do
-      @preview_controller = Lookbook.config.preview_controller.constantize
-      @preview_controller.include(Lookbook::PreviewController)
-
-      parser.after_parse do |registry|
-        Preview.load!(registry.all(:class))
-        reload_ui
-      end
-
-      if Gem::Version.new(Rails.version) >= Gem::Version.new("6.1.3.1")
-        # Rails.application.server is only available for newer Rails versions
-        Rails.application.server do
-          init_listeners
-        end
-      else
-        # Fallback for older Rails versions - don't start listeners if running in a rake task.
-        unless prevent_listening?
-          init_listeners
-        end
-      end
-
-      parser.parse do
-        run_hooks(:after_initialize)
+    initializer "lookbook.file_watcher.previews" do
+      file_watcher.watch(opts.listen_paths, opts.listen_extensions, wait_for_delay: 0.5) do |changes|
+        parser.parse { run_hooks(:after_change, changes) }
       end
     end
 
-    at_exit do
-      if listeners.any?
-        Lookbook.logger.debug "Stopping listeners"
-        stop_listeners
+    initializer "lookbook.file_watcher.pages" do
+      file_watcher.watch(opts.page_paths, opts.page_extensions) do |changes|
+        self.class.websocket.broadcast(:reload)
+        run_hooks(:after_change, changes)
       end
-      run_hooks(:before_exit)
     end
 
-    class << self
-      def init_listeners
-        config = Lookbook.config
-        return unless config.listen == true
-
-        listen_paths = PathUtils.normalize_all(config.listen_paths)
-        if listen_paths.any?
-          preview_listener = Listen.to(*listen_paths,
-            only: /\.(#{config.listen_extensions.join("|")})$/,
-            wait_for_delay: 0.5,
-            force_polling: config.listen_use_polling) do |modified, added, removed|
-            parser.parse do
-              run_hooks(:after_change, {modified: modified, added: added, removed: removed})
-            end
-          end
-          register_listener(preview_listener)
-        end
-
-        page_paths = PathUtils.normalize_all(config.page_paths)
-        if page_paths.any?
-          page_listener = Listen.to(*page_paths,
-            only: /\.(html.*|md.*)$/,
-            force_polling: config.listen_use_polling) do |modified, added, removed|
-            changes = {modified: modified, added: added, removed: removed}
-            reload_ui
-            run_hooks(:after_change, changes)
-          end
-          register_listener(page_listener)
-        end
+    initializer "lookbook.parser.preview_load_callback" do
+      parser.after_parse do |registry|
+        Preview.load!(registry.all(:class))
+        self.class.websocket.broadcast(:reload)
       end
+    end
 
-      def websocket
-        config = Lookbook.config
-        return @websocket unless @websocket.nil?
-        return unless config.auto_refresh == true && config.listen == true && !Rails.env.test?
-        Lookbook.logger.info "Initializing websocket"
-
-        cable = ActionCable::Server::Configuration.new
-        cable.cable = {adapter: "async"}.with_indifferent_access
-        cable.mount_path = nil
-        cable.connection_class = -> { Lookbook::Connection }
-        cable.logger = Lookbook.logger
-
-        @websocket ||= if Gem::Version.new(Rails.version) >= Gem::Version.new(6.0)
-          ActionCable::Server::Base.new(config: cable)
-        else
-          ws = ActionCable::Server::Base.new
-          ws.config = cable
-          ws
-        end
-      end
+    # The preview controller handles the rendering of individual previews.
+    #
+    # Lookbook injects some actions into whichever controller has been
+    # specified by the user in order to render previews within the context of
+    # the particular controller class instance so that any before_action/after_action
+    # callbacks will be correctly processed.
+    config.after_initialize do
+      @preview_controller = opts.preview_controller.constantize
+      @preview_controller.class_eval { include Lookbook::PreviewActions }
+    end
 
-      def websocket_mount_path
-        "#{mounted_path}/cable".gsub("//", "/") if websocket?
+    config.after_initialize do
+      if Rails.application.respond_to?(:server)
+        Rails.application.server { file_watcher.start if listen? }
+      elsif process.supports_listening?
+        file_watcher.start if listen?
       end
+    end
 
-      def websocket?
-        websocket.present?
-      end
+    config.after_initialize do
+      parser.parse { run_hooks(:after_initialize) }
+    end
 
-      def mounted_path
-        routes.find_script_name({})
-      end
+    def opts
+      Lookbook.config
+    end
 
-      def parser
-        preview_paths = PathUtils.normalize_all(Lookbook.config.preview_paths)
-        @parser ||= Lookbook::Parser.new(preview_paths)
+    def run_hooks(event_name, *args)
+      self.class.hooks.for_event(event_name).each do |hook|
+        hook.call(Lookbook, *args)
       end
+    end
 
-      def log_level
-        Lookbook.logger.level
-      end
+    def parser
+      @parser ||= PreviewParser.new(opts.preview_paths, Engine.tags)
+    end
 
-      def app_name
-        name = if Gem::Version.new(Rails.version) >= Gem::Version.new("6.1")
-          Rails.application.class.module_parent_name
-        else
-          Rails.application.class.parent_name
-        end
-        name.underscore
-      end
+    def file_watcher
+      @file_watcher ||= FileWatcher.new(force_polling: opts.listen_use_polling)
+    end
 
-      def register_listener(listener)
-        listener.start
-        listeners << listener
-      end
+    def process
+      @process ||= Process.new(env: Rails.env)
+    end
 
-      def listeners
-        @listeners ||= []
-      end
+    def listen?
+      opts.listen && process.supports_listening?
+    end
 
-      def stop_listeners
-        listeners.each { |listener| listener.stop }
-      end
+    def self.mount_path
+      routes.find_script_name({})
+    end
 
-      def run_hooks(event_name, *args)
-        hooks.for_event(event_name).each do |hook|
-          hook.call(Lookbook, *args)
-        end
-      end
+    def self.mounted?
+      mount_path.present?
+    end
 
-      def reload_ui
-        websocket&.broadcast("reload", {})
+    def self.app_name
+      name = if Rails.application.class.respond_to?(:module_parent_name)
+        Rails.application.class.module_parent_name
+      else
+        Rails.application.class.parent_name
       end
+      name.underscore
+    end
 
-      def prevent_listening?
-        Rails.env.test? || running_in_rake_task?
+    def self.websocket
+      if mounted?
+        use_websocket = opts.auto_refresh && opts.listen && process.supports_listening?
+        @websocket ||= use_websocket ? Websocket.new(mount_path, logger: Lookbook.logger) : Websocket.noop
+      else
+        Websocket.noop
       end
+    end
 
-      def running_in_rake_task?
-        if defined?(Rake) && Rake.respond_to?(:application)
-          File.basename($0) == "rake" || Rake.application.top_level_tasks.any?
-        else
-          false
-        end
-      end
+    def self.panels
+      @panels ||= PanelStore.init_from_config
+    end
 
-      def panels
-        @panels ||= PanelStore.init_from_config
-      end
+    def self.inputs
+      @inputs ||= InputStore.init_from_config
+    end
 
-      def inputs
-        @inputs ||= InputStore.init_from_config
-      end
+    def self.tags
+      @tags ||= TagStore.init_from_config
+    end
 
-      def tags
-        @tags ||= TagStore.init_from_config
-      end
+    def self.hooks
+      @hooks ||= HookStore.init_from_config
+    end
 
-      def hooks
-        @hooks ||= HookStore.init_from_config
-      end
+    def self.preview_controller
+      @preview_controller
+    end
 
-      attr_reader :preview_controller
+    at_exit do
+      file_watcher.stop
+      run_hooks(:before_exit)
     end
   end
 end

data/lib/lookbook/file_watcher.rb

@@ -0,0 +1,47 @@
+module Lookbook
+  class FileWatcher
+    attr_reader :listeners, :force_polling
+
+    def initialize(force_polling: false)
+      @force_polling = force_polling
+      @listeners = []
+    end
+
+    def watch(paths, extensions = ".*", opts = nil, &block)
+      paths = PathUtils.normalize_all(paths)
+
+      if paths.any?
+        opts = opts.to_h
+        opts[:only] = /\.(#{Array(extensions).join("|")})$/
+
+        listeners << init_listener(paths, opts, &block)
+      end
+    end
+
+    def start
+      if listeners.any?
+        Lookbook.logger.debug "Starting listeners"
+        listeners.each { |l| l.start }
+      end
+    end
+
+    def stop
+      if listeners.any?
+        Lookbook.logger.debug "Stopping listeners"
+        listeners.each { |l| l.stop }
+      end
+    end
+
+    protected
+
+    def init_listener(paths, opts, &block)
+      Listen.to(
+        *paths,
+        **opts,
+        force_polling: force_polling
+      ) do |modified, added, removed|
+        block.call({modified: modified, added: added, removed: removed})
+      end
+    end
+  end
+end

data/lib/lookbook/page.rb

@@ -13,7 +13,7 @@ module Lookbook
       :data
     ]
 
-    attr_reader :errors, :rel_path
+    attr_reader :errors, :rel_path, :content, :frontmatter
     attr_accessor :sections
 
     def initialize(path, base_path)
@@ -22,9 +22,12 @@ module Lookbook
       @options = nil
       @errors = []
       @sections = []
+      @frontmatter = {}
+      @content = ""
       @page_name = remove_position_prefix(path_name)
       @rel_path = @pathname.relative_path_from(@base_path)
       page_path = @rel_path.dirname.to_s == "." ? @page_name : "#{@rel_path.dirname}/#{@page_name}"
+      extract_frontmatter(file_contents)
       super(page_path)
     end
 
@@ -60,10 +63,6 @@ module Lookbook
       options[key]
     end
 
-    def content
-      @content ||= strip_frontmatter(file_contents).strip
-    end
-
     def matchers
       normalize_matchers(label)
     end
@@ -112,17 +111,6 @@ module Lookbook
 
     def options
       return @options if @options
-      begin
-        frontmatter = (get_frontmatter(file_contents) || {}).deep_symbolize_keys
-      rescue => exception
-        frontmatter = {}
-        line_number_match = exception.message.match(/.*line\s(\d+)/)
-        @errors.push(Lookbook::Error.new(exception, **{
-          title: "YAML frontmatter parsing error",
-          file_path: @pathname.to_s,
-          line_number: line_number_match ? line_number_match[1] : false
-        }))
-      end
       @options = Lookbook.config.page_options.deep_merge(frontmatter).with_indifferent_access
       @options[:id] = generate_id(@options[:id] || lookup_path)
       @options[:label] ||= name.titleize
@@ -136,6 +124,17 @@ module Lookbook
       @options
     end
 
+    def extract_frontmatter(content)
+      @frontmatter, @content = FrontmatterExtractor.call(content)
+    rescue => exception
+      line_number_match = exception.message.match(/.*line\s(\d+)/)
+      @errors.push(Lookbook::Error.new(exception, **{
+        title: "YAML frontmatter parsing error",
+        file_path: @pathname.to_s,
+        line_number: line_number_match ? line_number_match[1] : false
+      }))
+    end
+
     def path_name
       @pathname.basename(@pathname.extname).to_s.gsub(/\.(html|md)$/, "")
     end

data/lib/lookbook/param.rb

@@ -0,0 +1,99 @@
+module Lookbook
+  class Param
+    attr_reader :name, :options, :value_default, :description
+
+    def initialize(name:, input: nil, description: nil, value_type: nil, value_default: nil, value: nil, options: {})
+      @name = name
+      @input = input
+      @description = description
+      @value_type = value_type
+      @value_default = value_default
+      @value = value
+      @options = options
+    end
+
+    def label
+      options.label || name.titleize
+    end
+
+    def hint
+      options.hint
+    end
+
+    def input
+      @input || guess_input
+    end
+
+    def value
+      @value || value_default
+    end
+
+    def value_type
+      @value_type || guess_value_type
+    end
+
+    def input_options
+      return @input_options if @input_options
+
+      runtime_options = options.except([*methods, :name, :value_default, :description])
+      @input_options ||= Store.new(input_config.options.merge(runtime_options))
+    end
+
+    def input_partial
+      input_config.partial
+    end
+
+    def cast_value
+      raise ArgumentError.new("Cannot cast param '#{name}' without a value set") if value.nil?
+
+      StringValueCaster.call(value, value_type)
+    end
+
+    def self.from_tag(tag, value: nil)
+      new(
+        name: tag.name,
+        input: tag.input || tag.options.input,
+        description: tag.description || tag.options.description,
+        value_type: tag.value_type || tag.options.value_type,
+        value_default: tag.value_default,
+        options: tag.options,
+        value: value
+      )
+    end
+
+    protected
+
+    def input_config
+      config = Lookbook::Engine.inputs.get_input(input)
+      config || raise(LookbookError.new("Unknown input type '#{input}'"))
+    end
+
+    def guess_input
+      if @value_type == "boolean" || (@value_type.blank? && boolean?(value_default))
+        "toggle"
+      else
+        "text"
+      end
+    end
+
+    def guess_value_type
+      if input == "toggle"
+        "boolean"
+      elsif input == "number"
+        "integer"
+      elsif boolean?(value_default)
+        "boolean"
+      elsif value_default.is_a?(Symbol)
+        "symbol"
+      elsif ["date", "datetime-local"].include?(input) || value_default.is_a?(DateTime)
+        "datetime"
+      else
+        "string"
+      end
+    end
+
+    def boolean?(value)
+      value == true || value == false
+    end
+  end
+end

data/lib/lookbook/preview.rb

@@ -8,7 +8,14 @@ module Lookbook
     def initialize(preview, code_object)
       @preview = preview
       @preview_inspector = SourceInspector.new(code_object, eval_scope: preview_class.new)
-      super(preview_class_path(@preview.name))
+      preview_path = preview_class_path(name)
+
+      if @preview_inspector.logical_path
+        basename = preview_path.split("/").last
+        preview_path = "#{@preview_inspector.logical_path}/#{basename}"
+      end
+
+      super(preview_path)
     end
 
     def id

data/lib/lookbook/{preview_controller.rb → preview_actions.rb}

@@ -1,5 +1,9 @@
 module Lookbook
-  module PreviewController
+  module PreviewActions
+    def self.included(klass)
+      klass.helper Lookbook::PreviewHelper
+    end
+
     def render_example_to_string(preview, example_name)
       prepend_application_view_paths
       prepend_preview_examples_view_path
@@ -12,7 +16,7 @@ module Lookbook
       opts[:layout] = nil
       opts[:locals] = locals if locals.present?
 
-      Utils.with_optional_action_view_annotations do
+      with_optional_action_view_annotations do
         render html: render_to_string(template, **opts)
       end
     end
@@ -20,7 +24,7 @@ module Lookbook
     def render_in_layout_to_string(template, locals, opts = {})
       append_view_path Lookbook::Engine.root.join("app/views")
 
-      Utils.with_optional_action_view_annotations do
+      with_optional_action_view_annotations do
         html = render_to_string(template, locals: locals, **determine_layout(opts[:layout]))
         if opts[:append_html].present?
           html += opts[:append_html]
@@ -28,5 +32,12 @@ module Lookbook
         render html: html
       end
     end
+
+    protected
+
+    def with_optional_action_view_annotations(&block)
+      disable = Lookbook.config.preview_disable_action_view_annotations
+      ActionViewAnnotationsHandler.call(disable_annotations: disable, &block)
+    end
   end
 end

data/lib/lookbook/preview_example.rb

@@ -1,7 +1,7 @@
 module Lookbook
   class PreviewExample < Entity
     attr_reader :name, :preview
-    delegate :params, :position, :group, :notes, :hidden?, :source, :tags, :tag, to: :@example_inspector
+    delegate :position, :group, :notes, :hidden?, :source, :tags, :tag, to: :@example_inspector
 
     def initialize(name, preview, code_object)
       @name = name

data/lib/lookbook/preview_group.rb

@@ -21,10 +21,6 @@ module Lookbook
       :group
     end
 
-    def params
-      examples.map(&:params).flatten.uniq { |param| param[:name] }
-    end
-
     def display_options
       merged = {}
       examples.reverse.map do |example|

data/lib/lookbook/preview_parser.rb

@@ -0,0 +1,53 @@
+require "yard"
+
+module Lookbook
+  class PreviewParser
+    def initialize(paths, tags = nil)
+      @paths = paths
+      @after_parse_callbacks = []
+      @after_parse_once_callbacks = []
+      @parsing = false
+
+      define_tags(tags)
+      YARD::Parser::SourceParser.after_parse_list { run_callbacks }
+    end
+
+    def parse(&block)
+      unless @parsing
+        @parsing = true
+        @after_parse_once_callbacks << block if block
+        YARD::Registry.clear
+        YARD.parse(paths)
+      end
+    end
+
+    def after_parse(&block)
+      @after_parse_callbacks << block
+    end
+
+    def paths
+      PathUtils.normalize_all(@paths).map { |path| "#{path}/**/*preview.rb" }
+    end
+
+    protected
+
+    def callbacks
+      [
+        *@after_parse_callbacks,
+        *@after_parse_once_callbacks
+      ]
+    end
+
+    def run_callbacks
+      callbacks.each { |cb| cb.call(YARD::Registry) }
+      @after_parse_once_callbacks = []
+      @parsing = false
+    end
+
+    def define_tags(tags = nil)
+      tags.to_h.each do |name, tag|
+        YARD::Tags::Library.define_tag(tag[:label], name, Lookbook::TagProvider)
+      end
+    end
+  end
+end

data/lib/lookbook/process.rb

@@ -0,0 +1,21 @@
+module Lookbook
+  class Process
+    attr_reader :env
+
+    def initialize(env: Rails.env)
+      @env = env
+    end
+
+    def supports_listening?
+      !rake_task? && !Rails.const_defined?(:Console)
+    end
+
+    def rake_task?
+      if defined?(Rake) && Rake.respond_to?(:application)
+        File.basename($0) == "rake" || Rake.application.top_level_tasks.any?
+      else
+        false
+      end
+    end
+  end
+end