lookbook 1.5.2 → 2.3.7

data/config/panels.yml

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

data/config/routes.rb

@@ -10,7 +10,13 @@ Lookbook::Engine.routes.draw do
 
   get "/previews", to: "previews#index", as: :lookbook_previews
   get "/preview/*path", to: "previews#show", as: :lookbook_preview
+
   get "/inspect/*path", to: "inspector#show", as: :lookbook_inspect
 
-  get "/*path", to: "inspector#show_legacy", as: :lookbook_inspect_legacy
+  if Lookbook::Engine.preview_embeds_allowed?
+    get "/embed", to: "embeds#lookup", as: :lookbook_embed_lookup
+    get "/embed/*path", to: "embeds#show", as: :lookbook_embed
+  end
+
+  get "/*path", to: "application#not_found", via: :all
 end

data/config/tags.yml

@@ -11,8 +11,8 @@ shared:
     label: Display
     opts: {}
 
-  position:
-    label: Position
+  priority:
+    label: Priority
     opts: {}
 
   id:
@@ -23,6 +23,10 @@ shared:
     label: Component
     opts: {}
 
+  renders:
+    label: Renders
+    opts: {}
+
   param:
     label: Param
     opts: {}
@@ -34,3 +38,7 @@ shared:
   source:
     label: Source file
     opts: {}
+
+  after_render:
+    label: After render
+    opts: {}

data/lib/lookbook/cable/cable.rb

@@ -0,0 +1,53 @@
+require "action_cable/engine"
+require_relative "connection"
+require_relative "reload_channel"
+
+module Lookbook
+  class Cable
+    attr_reader :engine_mount_path, :server, :logger
+
+    def initialize(engine_mount_path, logger: Lookbook.logger)
+      @engine_mount_path = engine_mount_path
+      @logger = logger
+
+      logger.info "Initializing websocket"
+
+      if Gem::Version.new(Rails.version) >= Gem::Version.new(6.0)
+        @server = ActionCable::Server::Base.new config: cable_config
+      else
+        @server = ActionCable::Server::Base.new
+        @server.config = cable_config
+      end
+    end
+
+    def broadcast(message, payload = nil)
+      logger.debug message.to_s
+      server.broadcast(message.to_s, payload.to_h)
+    end
+
+    def mount_path
+      "/cable"
+    end
+
+    def full_mount_path
+      "#{engine_mount_path}/#{mount_path}".gsub("//", "/")
+    end
+
+    def mountable?
+      true
+    end
+
+    alias_method :mounted?, :mountable?
+
+    protected
+
+    def cable_config
+      cable = ActionCable::Server::Configuration.new
+      cable.cable = {adapter: "async"}.with_indifferent_access
+      cable.mount_path = nil
+      cable.connection_class = -> { Lookbook::Connection }
+      cable.logger = logger
+      cable
+    end
+  end
+end

data/lib/lookbook/engine.rb

@@ -1,6 +1,3 @@
-require "view_component"
-require "action_cable/engine"
-require "listen"
 require "yard"
 
 module Lookbook
@@ -9,103 +6,97 @@ module Lookbook
 
     config.autoload_paths << File.expand_path(root.join("app/components"))
 
-    config.before_configuration do
-      config.lookbook = Lookbook.config
-    end
-
-    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
       config.app_middleware.use(
         Rack::Static,
-        urls: ["/lookbook-assets"], root: root.join("public").to_s
+        urls: ["/lookbook-assets"],
+        root: root.join("public").to_s
       )
     end
 
-    initializer "lookbook.file_watcher.paths" do
-      opts.listen_paths += opts.preview_paths
-      opts.listen_paths << opts.components_path
-    end
-
-    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) }
+    initializer "lookbook.set_autoload_paths", before: :set_autoload_paths do |app|
+      if opts.autoload_previews && opts.preview_paths.any?
+        paths_to_add = opts.preview_paths - app.config.autoload_paths
+        filtered_paths = paths_to_add.filter { |p| !Engine.component_paths.include?(p) }
+        app.config.autoload_paths.concat(filtered_paths) if filtered_paths.any?
       end
     end
 
-    initializer "lookbook.file_watcher.pages" do
-      file_watcher.watch(opts.page_paths, opts.page_extensions) do |changes|
-        Engine.pages.load(Engine.page_paths)
-        Engine.websocket.broadcast(:reload)
-        run_hooks(:after_change, changes)
-      end
-    end
+    config.before_configuration do
+      config.lookbook = Lookbook.config
 
-    initializer "lookbook.parser.previews_load_callback" do
-      parser.after_parse do |code_objects|
-        Engine.previews.load(code_objects.all(:class))
-        Engine.websocket.broadcast(:reload)
+      if defined?(ViewComponent)
+        config.lookbook.using_view_component ||= true
+      else
+        require "view_component"
+        config.lookbook.using_view_component ||= false
       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
+      if opts.using_view_component
+        vc_config = Engine.host_config.view_component
 
-    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?
+        opts.preview_paths += vc_config.preview_paths
+
+        # sync preview controller and layout setting between Lookbook and ViewComponent
+        if opts.preview_controller == "Lookbook::PreviewController" ||
+            vc_config.preview_controller != ViewComponent::Config.defaults.preview_controller
+          opts.preview_controller = vc_config.preview_controller
+        else
+          vc_config.preview_controller = opts.preview_controller
+        end
+
+        if opts.preview_layout.nil? || vc_config.default_preview_layout.present?
+          opts.preview_layout = vc_config.default_preview_layout
+        else
+          vc_config.default_preview_layout = opts.preview_layout
+        end
+
+        vc_config.show_previews = true
+
+        if vc_config.view_component_path.present?
+          opts.component_paths << vc_config.view_component_path
+        end
+
+        ViewComponent::Preview.extend(Lookbook::PreviewAfterRender)
+      end
+
+      if opts.reload_on_change.nil?
+        opts.reload_on_change = !host_config.cache_classes && host_config.reload_classes_only_on_change
       end
     end
 
     config.after_initialize do
-      Engine.pages.load(Engine.page_paths)
-      parser.parse { run_hooks(:after_initialize) }
+      if Engine.reloading?
+        reloaders.add(:previews, Engine.preview_watch_paths, opts.listen_extensions, &Engine.method(:load_previews))
+        reloaders.add(:pages, Engine.page_watch_paths, opts.page_extensions, &Engine.method(:load_pages))
+        reloaders.execute unless opts.lazy_load_previews_and_pages
+      else
+        unless opts.lazy_load_previews_and_pages
+          Engine.load_previews
+          Engine.load_pages
+        end
+      end
+
+      Engine.run_hooks(:after_initialize)
     end
 
     def opts
       Lookbook.config
     end
 
-    def run_hooks(event_name, *args)
-      Engine.hooks.for_event(event_name).each do |hook|
-        hook.call(Lookbook, *args)
-      end
-    end
-
     def parser
       @_parser ||= PreviewParser.new(opts.preview_paths, Engine.tags)
     end
 
-    def file_watcher
-      @_file_watcher ||= FileWatcher.new(force_polling: opts.listen_use_polling)
-    end
-
-    def process
-      @_process ||= Process.new(env: Rails.env)
-    end
-
-    def listen?
-      opts.listen && process.supports_listening?
+    def reloaders
+      @_reloaders ||= Reloaders.new
     end
 
     class << self
+      delegate :app_name, to: :runtime_context
+
       def mount_path
         routes.find_script_name({})
       end
@@ -114,22 +105,31 @@ module Lookbook
         mount_path.present?
       end
 
-      def 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
+      def reloading?
+        opts.reload_on_change
+      end
+
+      def auto_refresh?
+        opts.live_updates == true &&
+          reloading? &&
+          runtime_context.web? &&
+          FileWatcher.evented?
+      end
+
+      def preview_embeds_allowed?
+        opts.preview_embeds.enabled == true && opts.preview_embeds.policy != "DENY"
       end
 
       def 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
+        @_websocket ||= auto_refresh? ? Websocket.new(mount_path, logger: Lookbook.logger) : NullWebsocket.new
+      end
+
+      def runtime_context
+        @_runtime_context ||= RuntimeContext.new(env: Rails.env)
+      end
+
+      def theme
+        @_theme ||= Lookbook::Theme.new(opts.ui_theme, opts.ui_theme_overrides)
       end
 
       def panels
@@ -145,35 +145,127 @@ module Lookbook
       end
 
       def hooks
-        @_hooks ||= HookStore.init_from_config
+        @_hooks ||= HookStore.new
+      end
+
+      def run_hooks(event_name, *args)
+        hooks.for_event(event_name).each do |hook|
+          hook.call(Lookbook, *args)
+        end
+      end
+
+      def host_app_path
+        Rails.application.root.join("app")
+      end
+
+      def host_config
+        Rails.application.config
+      end
+
+      def view_paths
+        # handle view path registry changes in Rails 7.1
+        paths = if defined?(ActionView::PathRegistry)
+          ActionView::PathRegistry.all_file_system_resolvers.map(&:path)
+        else
+          ActionView::ViewPaths.all_view_paths.flat_map(&paths)
+        end
+        paths.map { |path| Pathname(path.to_s) }
       end
 
       def component_paths
-        @_component_paths ||= Array(PathUtils.to_absolute(opts.components_path))
+        @_component_paths ||= begin
+          paths = [*opts.component_paths, *view_paths, host_app_path]
+          PathUtils.normalize_paths(paths)
+        end
       end
 
       def page_paths
         @_page_paths ||= PathUtils.normalize_paths(opts.page_paths)
       end
 
+      alias_method :page_watch_paths, :page_paths
+
       def preview_paths
         @_preview_paths ||= PathUtils.normalize_paths(opts.preview_paths)
       end
 
+      def preview_watch_paths
+        @_preview_watch_paths ||= begin
+          paths = [*opts.preview_paths, *opts.component_paths, *opts.listen_paths, *view_paths].uniq
+          PathUtils.normalize_paths(paths)
+        end
+      end
+
       def pages
         @_pages ||= PageCollection.new
+
+        if opts.lazy_load_previews_and_pages && !@_loaded_pages
+          @_loaded_pages = true
+
+          if reloading?
+            reloaders.execute(:pages)
+          else
+            load_pages
+          end
+        end
+
+        @_pages
       end
 
       def previews
         @_previews ||= PreviewCollection.new
+
+        if opts.lazy_load_previews_and_pages && !@_loaded_previews
+          @_loaded_previews = true
+
+          if reloading?
+            reloaders.execute(:previews)
+          else
+            load_previews
+          end
+        end
+
+        @_previews
       end
 
-      attr_reader :preview_controller
+      def preview_controller
+        @_preview_controller = opts.preview_controller.constantize
+        @_preview_controller.include PreviewControllerActions
+      end
+
+      def load_previews(changes = nil)
+        changed_files = [*changes[:added], *changes[:modified]] if changes
+        parser.parse(changed_files) do |code_objects|
+          previews.load(code_objects.all(:class), changes)
+        end
+      rescue => e
+        Lookbook.logger.error(e)
+        raise e
+      end
+
+      def load_pages(changes = nil)
+        pages.load(Engine.page_paths, changes)
+      rescue => e
+        Lookbook.logger.error(e)
+        raise e
+      end
+
+      def notify_clients(changes = nil)
+        return unless changes.present?
+
+        websocket.broadcast(:reload)
+        run_hooks(:after_change, changes.to_h)
+      end
+
+      def files_changed(modified, added, removed)
+        changes = {modified: modified, added: added, removed: removed}
+        reloaders.register_changes(changes)
+        notify_clients(changes)
+      end
     end
 
     at_exit do
-      file_watcher.stop
-      run_hooks(:before_exit)
+      Engine.run_hooks(:before_exit)
     end
   end
 end

data/lib/lookbook/entities/collections/concerns/hierarchical_collection.rb

@@ -2,21 +2,26 @@ module Lookbook
   module HierarchicalCollection
     extend ActiveSupport::Concern
 
+    TREE_BUILDER = nil
+
     included do
       def entities
         @_cache[:entities] ||= collect_ordered_entities(to_tree(include_hidden: true))
       end
 
       def to_tree(include_hidden: false)
-        @_cache[include_hidden ? :tree_with_hidden : :tree] ||= EntityTreeBuilder.call(@entities, include_hidden: include_hidden)
+        cache_key = include_hidden ? :tree_with_hidden : :tree
+        @_cache[cache_key] ||= self.class::TREE_BUILDER.call(@entities, include_hidden: include_hidden)
       end
 
       protected
 
       def collect_ordered_entities(start_node)
-        start_node.inject([]) do |entities, node|
-          entities.append(node.content? ? node.content : collect_ordered_entities(node))
-        end.flatten
+        start_node.flat_map do |node|
+          node_entity = node.content? ? [node.content] : []
+          child_entities = collect_ordered_entities(node)
+          [*node_entity, *child_entities]
+        end
       end
     end
   end

data/lib/lookbook/entities/collections/entity_collection.rb

@@ -14,7 +14,7 @@ module Lookbook
 
     def add(to_add = nil)
       Array(to_add).each do |entity|
-        unless find_by_path(entity.path)
+        unless find_by_path(entity.lookup_path)
           @entities.push(entity)
         end
       end
@@ -23,20 +23,20 @@ module Lookbook
 
     def find_by_id(id)
       id = Utils.id(id)
-      entities.find { |entity| entity.id == id }
+      @entities.find { |entity| entity.id == id }
     end
 
     def find_by_path(path)
-      entities.find { |entity| entity.path.to_s == path.to_s }
+      @entities.find { |entity| entity.lookup_path.to_s == path.to_s }
     end
 
     def next(entity)
-      index = entities.find_index { |i| i.path == entity.path }
+      index = entities.find_index { |i| i.lookup_path == entity.lookup_path }
       entities[index + 1] unless index.nil?
     end
 
     def previous(entity)
-      index = entities.find_index { |i| i.path == entity.path }
+      index = entities.find_index { |i| i.lookup_path == entity.lookup_path }
       entities[index - 1] if !index.nil? && index > 0
     end
 
@@ -49,7 +49,12 @@ module Lookbook
     end
 
     def flat_map(...)
-      entities.map(...).map(&:to_a).flatten
+      entities.map(...).map { |e| e.respond_to?(:to_a) ? e.to_a : e }.flatten
+    end
+
+    def clear_all
+      @entities = []
+      clear_cache
     end
 
     protected

data/lib/lookbook/entities/collections/page_collection.rb

@@ -2,14 +2,35 @@ module Lookbook
   class PageCollection < EntityCollection
     include HierarchicalCollection
 
-    def load(page_paths)
-      @entities = []
-      clear_cache
+    TREE_BUILDER = PageTreeBuilder
 
-      file_paths = page_paths.flat_map do |dir|
-        PathUtils.normalize_paths(Dir["#{dir}/**/*.html.*", "#{dir}/**/*.md.*"].sort)
-      end
+    def load(page_paths, changes = nil)
+      file_paths = PageCollection.file_paths(page_paths)
+      reload_all(file_paths) # TODO: Fix incremental reloading
+      # changes.present? ? reload_changed(file_paths, changes) : reload_all(file_paths)
+    end
+
+    def reload_all(file_paths)
+      clear_all
+      add(pages_from_paths(file_paths))
+    end
+
+    def reload_changed(file_paths, changes)
+      modified = Array(changes[:modified])
+      removed = Array(changes[:removed]) + modified
+      added = Array(changes[:added]) + modified
+
+      remove_by_file_path(removed)
+      add(pages_from_paths(added))
+    end
+
+    def remove_by_file_path(paths)
+      paths = Array(paths).map(&:to_s)
+      @entities.reject! { |page| page.file_path.to_s.in?(paths) }
+      clear_cache
+    end
 
+    def pages_from_paths(file_paths)
       entities = file_paths.map { |path| PageCollection.entity(path) }
       pages, sections = entities.partition { |page| page.type == :page }
 
@@ -20,11 +41,17 @@ module Lookbook
         parent.add_section(section)
       end
 
-      add(pages)
+      pages
+    end
+
+    def self.file_paths(directories)
+      directories.flat_map do |dir|
+        PathUtils.normalize_paths(Dir["#{dir}/**/*.html.*", "#{dir}/**/*.md.*", "#{dir}/**/*.md"].sort)
+      end
     end
 
     def self.entity(file_path)
-      File.basename(file_path).match?(%r{\[(.*?\w+)\]}) ? PageSection.new(file_path) : Page.new(file_path)
+      File.basename(file_path).match?(%r{\[(.*?\w+)\]}) ? PageSectionEntity.new(file_path) : PageEntity.new(file_path)
     end
   end
 end