lookbook 1.1.0 → 1.2.0

data/config/panels.yml

@@ -0,0 +1,30 @@
+shared:
+  main:
+    - name: preview
+      partial: lookbook/previews/panels/preview
+      label: Preview
+      hotkey: v
+
+    - name: output
+      partial: lookbook/previews/panels/output
+      label: HTML
+      hotkey: h
+
+  drawer:
+    - name: source
+      partial: lookbook/previews/panels/source
+      label: Source
+      hotkey: s
+      copy: "->(data) { data.examples.map { |e| e.source }.join(\n) }"
+
+    - name: notes
+      partial: lookbook/previews/panels/notes
+      label: Notes
+      hotkey: n
+      disabled: ->(data) { data.examples.select { |e| e.notes.present? }.none? }
+
+    - name: params
+      partial: lookbook/previews/panels/params
+      label: Params
+      hotkey: p
+      disabled: ->(data) { data.preview.params.none? }

data/config/routes.rb

@@ -1,6 +1,6 @@
 Lookbook::Engine.routes.draw do
   if Lookbook::Engine.websocket?
-    mount Lookbook::Engine.websocket => Lookbook.config.cable_mount_path, :as => :cable
+    mount Lookbook::Engine.websocket => "/cable", :as => :cable
   end
 
   root to: "application#index", as: :lookbook_home

data/config/tags.yml

@@ -0,0 +1,29 @@
+shared:
+  hidden:
+    label: Hidden status
+    opts: {}
+
+  label:
+    label: Label
+    opts: {}
+
+  display:
+    label: Display
+    opts: {}
+
+  position:
+    label: Position
+    opts: {}
+
+  id:
+    label: Id
+    opts: {}
+
+  component:
+    label: Component
+    opts: {}
+
+  param:
+    label: Param
+    yard_parser: with_name
+    opts: {}

data/lib/lookbook/engine.rb

@@ -3,99 +3,36 @@ require "action_cable/engine"
 require "listen"
 
 module Lookbook
-  autoload :Config, "lookbook/config"
-  autoload :Data, "lookbook/data"
-  autoload :Hooks, "lookbook/hooks"
-  autoload :Panels, "lookbook/panels"
-  autoload :Tags, "lookbook/tags"
-
-  class << self
-    include Lookbook::Data
-    include Lookbook::Hooks
-    include Lookbook::Panels
-    include Lookbook::Tags
-
-    def version
-      Lookbook::VERSION
-    end
-
-    def config
-      @config ||= Config.new
-    end
-
-    def configure
-      yield(config)
-    end
-
-    def logger
-      @logger ||= if Rails.logger.present? && config.log_use_rails_logger
-        Rails.logger
-      else
-        logger = Logger.new($stdout)
-        logger.level = config.log_level
-        logger
-      end
-    end
-
-    def debug_data
-      {
-        version: version,
-        env: Rails.env.to_s,
-        config: config.to_h
-      }
-    end
-
-    def previews
-      Preview.all
-    end
-
-    def pages
-      Page.all
-    end
-
-    def broadcast(event_name, data = {})
-      Engine.websocket&.broadcast(event_name.to_s, data)
-    end
-
-    def theme
-      @theme ||= Lookbook::Theme.new(config.ui_theme, config.ui_theme_overrides)
-    end
-
-    def define_param_input(input, partial, input_options = nil)
-      config.preview_param_inputs[input.to_sym] = {
-        partial: partial,
-        input_options: input_options || {}
-      }
-    end
-  end
-
   class Engine < Rails::Engine
     isolate_namespace Lookbook
 
-    config.lookbook = Lookbook.config
-    config.autoload_paths << File.expand_path(Lookbook::Engine.root.join("app/components"))
+    config.autoload_paths << File.expand_path(root.join("app/components"))
 
     initializer "lookbook.viewcomponent.config" do
-      config.lookbook.preview_paths += config.view_component.preview_paths
-      config.lookbook.preview_controller ||= config.view_component.preview_controller
+      Lookbook.config.preview_paths += config.view_component.preview_paths
+      Lookbook.config.preview_controller ||= config.view_component.preview_controller
 
-      config.lookbook.components_path = config.view_component.view_component_path if config.view_component.view_component_path.present?
+      Lookbook.config.components_path = config.view_component.view_component_path if config.view_component.view_component_path.present?
 
-      config.lookbook.listen_paths += config.lookbook.preview_paths
-      config.lookbook.listen_paths << config.lookbook.components_path
+      Lookbook.config.listen_paths += Lookbook.config.preview_paths
+      Lookbook.config.listen_paths << Lookbook.config.components_path
     end
 
     initializer "lookbook.parser.tags" do
-      Lookbook::Parser.define_tags(Lookbook.config.preview_tags)
+      Lookbook::Parser.define_tags(Engine.tags)
     end
 
     initializer "lookbook.assets.serve" do
       config.app_middleware.use(
         Rack::Static,
-        urls: ["/lookbook-assets"], root: Lookbook::Engine.root.join("public").to_s
+        urls: ["/lookbook-assets"], root: root.join("public").to_s
       )
     end
 
+    config.before_configuration do
+      config.lookbook = Lookbook.config
+    end
+
     config.after_initialize do
       @preview_controller = Lookbook.config.preview_controller.constantize
       @preview_controller.include(Lookbook::PreviewController)
@@ -112,31 +49,30 @@ module Lookbook
         end
       else
         # Fallback for older Rails versions - don't start listeners if running in a rake task.
-        unless Lookbook::Engine.prevent_listening?
+        unless prevent_listening?
           init_listeners
         end
       end
 
       parser.parse do
-        Lookbook::Engine.run_hooks(:after_initialize)
+        run_hooks(:after_initialize)
       end
     end
 
     at_exit do
-      if Lookbook::Engine.listeners.any?
+      if listeners.any?
         Lookbook.logger.debug "Stopping listeners"
-        Lookbook::Engine.stop_listeners
+        stop_listeners
       end
-      Lookbook::Engine.run_hooks(:before_exit)
+      run_hooks(:before_exit)
     end
 
     class << self
       def init_listeners
         config = Lookbook.config
         return unless config.listen == true
-        Listen.logger = Lookbook.logger
 
-        listen_paths = config.listen_paths.uniq
+        listen_paths = PathUtils.normalize_all(config.listen_paths)
         if listen_paths.any?
           preview_listener = Listen.to(*listen_paths,
             only: /\.(#{config.listen_extensions.join("|")})$/,
@@ -149,7 +85,7 @@ module Lookbook
           register_listener(preview_listener)
         end
 
-        page_paths = config.page_paths.uniq
+        page_paths = PathUtils.normalize_all(config.page_paths)
         if page_paths.any?
           page_listener = Listen.to(*page_paths,
             only: /\.(html.*|md.*)$/,
@@ -184,7 +120,7 @@ module Lookbook
       end
 
       def websocket_mount_path
-        "#{mounted_path}#{config.lookbook.cable_mount_path}".gsub("//", "/") if websocket?
+        "#{mounted_path}/cable".gsub("//", "/") if websocket?
       end
 
       def websocket?
@@ -192,11 +128,12 @@ module Lookbook
       end
 
       def mounted_path
-        Lookbook::Engine.routes.find_script_name({})
+        routes.find_script_name({})
       end
 
       def parser
-        @parser ||= Lookbook::Parser.new(config.lookbook.preview_paths)
+        preview_paths = PathUtils.normalize_all(Lookbook.config.preview_paths)
+        @parser ||= Lookbook::Parser.new(preview_paths)
       end
 
       def log_level
@@ -226,7 +163,7 @@ module Lookbook
       end
 
       def run_hooks(event_name, *args)
-        config.lookbook.hooks[event_name].each do |hook|
+        hooks.for_event(event_name).each do |hook|
           hook.call(Lookbook, *args)
         end
       end
@@ -247,6 +184,22 @@ module Lookbook
         end
       end
 
+      def panels
+        @panels ||= PanelStore.init_from_config
+      end
+
+      def inputs
+        @inputs ||= InputStore.init_from_config
+      end
+
+      def tags
+        @tags ||= TagStore.init_from_config
+      end
+
+      def hooks
+        @hooks ||= HookStore.init_from_config
+      end
+
       attr_reader :preview_controller
     end
   end

data/lib/lookbook/markdown.rb

@@ -2,19 +2,9 @@ require "redcarpet"
 
 module Lookbook
   class Markdown
-    DEFAULT_OPTIONS = {
-      tables: true,
-      fenced_code_blocks: true,
-      disable_indented_code_blocks: true,
-      strikethrough: true,
-      highlight: true,
-      with_toc_data: true,
-      lax_spacing: true
-    }
-
     def self.render(text)
       Utils.strip_action_view_annotations!(text)
-      markdown = Redcarpet::Markdown.new(Renderer, Lookbook.config.markdown_options)
+      markdown = Redcarpet::Markdown.new(Renderer, Lookbook.config.markdown_options.to_h)
       markdown.render(text).html_safe
     end
 

data/lib/lookbook/page.rb

@@ -180,7 +180,7 @@ module Lookbook
       end
 
       def page_paths
-        Lookbook.config.page_paths.select { |dir| Dir.exist? dir }
+        PathUtils.normalize_all(Lookbook.config.page_paths)
       end
 
       def section_path?(path)

data/lib/lookbook/params.rb

@@ -117,13 +117,6 @@ module Lookbook
         end
       end
 
-      def inputs
-        @inputs ||= Lookbook.config.preview_param_inputs.map do |name, config|
-          config = {partial: config} if config.is_a?(String)
-          [name, {input_options: {}}.merge(config)]
-        end.to_h
-      end
-
       private
 
       def guess_input(value_type, default)

data/lib/lookbook/parser.rb

@@ -32,16 +32,9 @@ module Lookbook
     end
 
     class << self
-      def define_tags(custom = {})
-        YARD::Tags::Library.define_tag("Hidden status", :hidden)
-        YARD::Tags::Library.define_tag("Label", :label)
-        YARD::Tags::Library.define_tag("Display", :display)
-        YARD::Tags::Library.define_tag("Position", :position)
-        YARD::Tags::Library.define_tag("ID", :id)
-        YARD::Tags::Library.define_tag("Component", :component)
-        YARD::Tags::Library.define_tag("Param", :param, :with_name)
-        custom.each do |name, opts|
-          YARD::Tags::Library.define_tag(name.to_s.titleize, name)
+      def define_tags(tags = nil)
+        tags.to_h.each do |name, tag|
+          YARD::Tags::Library.define_tag(tag[:label], name, tag[:yard_parser])
         end
       end
     end

data/lib/lookbook/preview.rb

@@ -70,7 +70,7 @@ module Lookbook
     end
 
     def full_path
-      base_path = Array(Lookbook.config.preview_paths).detect do |preview_path|
+      base_path = preview_paths.detect do |preview_path|
         Dir["#{preview_path}/#{rel_path}"].first
       end
       Pathname.new(Dir["#{base_path}/#{rel_path}"].first)
@@ -92,8 +92,8 @@ module Lookbook
       @preview.instance_variable_get(:@layout)
     end
 
-    def display_params
-      Lookbook.config.preview_display_params.deep_merge(@preview_inspector&.display_params)
+    def display_options
+      Lookbook.config.preview_display_options.deep_merge(@preview_inspector&.display_options)
     end
 
     def collapsible?
@@ -111,6 +111,10 @@ module Lookbook
       end
     end
 
+    def preview_paths
+      PathUtils.normalize_all(Lookbook.config.preview_paths)
+    end
+
     protected
 
     @preview_objects = nil

data/lib/lookbook/preview_example.rb

@@ -22,8 +22,8 @@ module Lookbook
       @example_inspector.label.presence || name.titleize
     end
 
-    def display_params
-      @preview.display_params.merge(@example_inspector.display_params)
+    def display_options
+      @preview.display_options.merge(@example_inspector.display_options)
     end
 
     def method_source
@@ -63,13 +63,17 @@ module Lookbook
 
     def full_template_path(template_path)
       template_path = strip_ext template_path
-      base_path = Array(Lookbook.config.preview_paths).detect do |p|
+      base_path = preview_paths.detect do |p|
         Dir["#{p}/#{template_path}.html.*"].first
       end
       path = Dir["#{base_path}/#{template_path}.html.*"].first
       path ? Pathname.new(path) : nil
     end
 
+    def preview_paths
+      PathUtils.normalize_all(Lookbook.config.preview_paths)
+    end
+
     class << self
       def all
         Preview.all.map { |preview| preview.examples }.flatten

data/lib/lookbook/preview_group.rb

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

data/lib/lookbook/services/config_loader.rb

@@ -0,0 +1,20 @@
+module Lookbook
+  class ConfigLoader < Service
+    attr_reader :file, :env
+
+    def initialize(path, env: Rails.env)
+      @file = Engine.root.join(path)
+      @env = env.to_sym
+    end
+
+    def call
+      if file.exist?
+        config = YAML.load_file(file).deep_symbolize_keys
+        env_config = config[:shared].to_h.deep_merge(config[env].to_h)
+        Store.new(env_config)
+      else
+        raise ConfigError.new("Could not load configuration. No such file - #{file}")
+      end
+    end
+  end
+end

data/lib/lookbook/services/search_param_builder.rb

@@ -0,0 +1,13 @@
+module Lookbook
+  class SearchParamBuilder < Service
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+    end
+
+    def call
+      data.map { "#{_1}:#{_2}" }.join("|")
+    end
+  end
+end

data/lib/lookbook/services/search_param_parser.rb

@@ -0,0 +1,15 @@
+module Lookbook
+  class SearchParamParser < Service
+    attr_reader :param_value
+
+    def initialize(param_value)
+      @param_value = param_value.strip
+    end
+
+    def call
+      pairs_str = param_value.split("|")
+      pairs = pairs_str.map { [*_1.split(":").map(&:strip)] }
+      pairs.to_h.symbolize_keys
+    end
+  end
+end

data/lib/lookbook/services/tags/key_value_tag_parser.rb

@@ -0,0 +1,24 @@
+module Lookbook
+  class KeyValueTagParser < Service
+    KEY_VALUE_REGEX = /^([^\s]+)\s+(.+)$/
+
+    attr_reader :text
+
+    def initialize(text)
+      @text = text.to_s
+    end
+
+    def call
+      text.strip.match(KEY_VALUE_REGEX) do |matches|
+        key = matches[1]
+        value = begin
+          YAML.safe_load(matches[2] || "~")
+        rescue ::Psych::SyntaxError => exception
+          raise ParserError.new("Invalid YAML in tag text '#{@text}'", scope: "key_value_tag.parser", original: exception)
+        end
+        return [key, value]
+      end
+      raise ParserError.new("Could not parse key:value pair from '#{@text}'", scope: "key_value_tag.parser")
+    end
+  end
+end

data/lib/lookbook/source_inspector.rb

@@ -52,22 +52,16 @@ module Lookbook
       end
     end
 
-    def display_params
-      return @display_params unless @display_params.nil?
-      @display_params = {}.with_indifferent_access
-      if code_object&.tags(:display).present?
-        code_object.tags(:display).each do |tag|
-          parts = tag.text.strip.match(/^([^\s]*)\s?(.*)$/)
-          if parts.present?
-            begin
-              display_params[parts[1]] = YAML.safe_load(parts[2] || "~")
-            rescue SyntaxError => err
-              Lookbook.logger.error("\n👀 [Lookbook] Invalid JSON in @display tag.\n👀 [Lookbook] (#{err})\n")
-            end
-          end
-        end
-      end
-      @display_params
+    def display_options
+      return @display_options unless @display_options.nil?
+      tags = code_object.tags(:display).to_a
+      pairs = tags.map { KeyValueTagParser.call(_1.text) }
+
+      # dynamic params set at the entity level are
+      # not (yet) supported so filter them out.
+      pairs.select! { |pair| !pair[1].is_a?(Array) && !pair[1].is_a?(Hash) }
+
+      pairs.to_h.symbolize_keys
     end
 
     def parameter_defaults

data/lib/lookbook/stores/config_store.rb

@@ -0,0 +1,80 @@
+module Lookbook
+  class ConfigStore
+    CONFIG_FILE = "config/app.yml"
+
+    delegate_missing_to :store
+    attr_reader :store
+
+    def initialize(config = nil)
+      @store = Store.new(config, recursive: true)
+    end
+
+    def project_name=(name)
+      store[:project_name] = name == false ? nil : name
+    end
+
+    def page_paths=(paths = nil)
+      store[:page_paths] ||= []
+      store[:page_paths] += paths.to_a
+    end
+
+    def preview_paths=(paths = nil)
+      store[:preview_paths] ||= []
+      store[:preview_paths] += paths.to_a
+    end
+
+    def preview_display_params
+      Lookbook.logger.warn "The `preview_display_params` config option has been renamed to `preview_display_options` and will be removed in v2.0"
+      store[:preview_display_options]
+    end
+
+    def preview_display_params=(options)
+      Lookbook.logger.warn "The `preview_display_params` config option has been renamed to `preview_display_options` and will be removed in v2.0"
+      store[:preview_display_options] = options.to_h
+    end
+
+    def listen_extensions=(extensions = nil)
+      store[:listen_extensions] ||= []
+      store[:listen_extensions] += extensions.to_a
+      store[:listen_extensions].uniq!
+    end
+
+    def markdown_options=(options = nil)
+      store[:markdown_options] ||= {}
+      store[:markdown_options].merge!(options.to_h)
+    end
+
+    def ui_theme=(name)
+      name = name.to_s
+      if Theme.valid_theme?(name)
+        store[:ui_theme] = name
+      else
+        raise ConfigError.new("'#{name}' is not a valid Lookbook theme. ", scope: "app.config")
+      end
+    end
+
+    def ui_theme_overrides(&block)
+      if block
+        yield store[:ui_theme_overrides]
+      else
+        store[:ui_theme_overrides]
+      end
+    end
+
+    def runtime_parsing=(value)
+      Lookbook.logger.warn "The `runtime_parsing` config option has been deprecated and will be removed in v2.0"
+    end
+
+    def preview_srcdoc=(enable)
+      Lookbook.logger.warn "The `preview_srcdoc` config option is deprecated and will be removed in v2.0"
+    end
+
+    def self.init_from_config(env: Rails.env)
+      new(default_config(env: env))
+    end
+
+    def self.default_config(env: Rails.env)
+      ConfigLoader.call(CONFIG_FILE, env: env)
+    end
+  end
+end

data/lib/lookbook/stores/hook_store.rb

@@ -0,0 +1,28 @@
+module Lookbook
+  class HookStore
+    CONFIG_FILE = "config/hooks.yml"
+
+    attr_reader :store
+    delegate :to_h, to: :store
+
+    def initialize(config = nil)
+      @store = {}
+    end
+
+    def add_hook(event_name, callback)
+      for_event(event_name) << callback
+    end
+
+    def for_event(event_name)
+      store[event_name.to_sym] ||= []
+    end
+
+    def self.init_from_config
+      new(default_config)
+    end
+
+    def self.default_config
+      ConfigLoader.call(CONFIG_FILE)
+    end
+  end
+end