lookbook 2.3.1 → 3.0.0.alpha.2

data/lib/lookbook/directory_entity.rb

@@ -0,0 +1,72 @@
+module Lookbook
+  class DirectoryEntity < Entity
+    include EntityTreeNode
+
+    CONFIG_FILE_NAME = "_config.yml"
+
+    attr_reader :lookup_path
+
+    def initialize(lookup_path, path: nil)
+      @lookup_path = lookup_path
+      @path = path
+      @type = :directory
+    end
+
+    def id
+      @id ||= Utils.id(lookup_path)
+    end
+
+    def name
+      @name ||= lookup_path.split("/").pop
+    end
+
+    def label
+      config.fetch(:label, super)
+    end
+
+    def hidden?
+      config.fetch(:hidden, false) || children.select(&:visible?).none?
+    end
+
+    def path
+      Pathname(@path) if @path
+    end
+
+    def exists?
+      path ? File.exist?(path) : false
+    end
+
+    def children
+      raise Lookbook::Error, "DirectoryEntity subclasses must define a #children method"
+    end
+
+    def parent
+      raise Lookbook::Error, "DirectoryEntity subclasses must define a #parent method"
+    end
+
+    def to_h
+      {
+        entity: "directory",
+        name: name,
+        label: label,
+        lookup_path: lookup_path,
+        path: path.to_s,
+        children: children.map(&:to_h)
+      }
+    end
+
+    protected
+
+    def config
+      @config ||= begin
+        opts = if exists?
+          config_file_path = File.join(path, CONFIG_FILE_NAME)
+          if File.exist?(config_file_path)
+            YAML.safe_load_file(config_file_path)
+          end
+        end
+        DataObject.new(opts || {})
+      end
+    end
+  end
+end

data/lib/lookbook/engine.rb

@@ -1,245 +1,100 @@
-require "yard"
-
 module Lookbook
   class Engine < Rails::Engine
-    isolate_namespace Lookbook
-
-    config.autoload_paths << File.expand_path(root.join("app/components"))
+    include Loggable
 
-    initializer "lookbook.assets.serve" do
-      config.app_middleware.use(
-        Rack::Static,
-        urls: ["/lookbook-assets"],
-        root: root.join("public").to_s
-      )
-    end
+    isolate_namespace Lookbook
 
-    initializer "lookbook.set_autoload_paths" do
-      if opts.autoload_previews && opts.preview_paths.any?
-        paths_to_add = opts.preview_paths - ActiveSupport::Dependencies.autoload_paths
-        filtered_paths = paths_to_add.filter { |p| !Engine.component_paths.include?(p) }
-        ActiveSupport::Dependencies.autoload_paths.concat(filtered_paths) if filtered_paths.any?
-      end
+    config.before_configuration do |app|
+      app.config.lookbook = Lookbook::Config.current
     end
 
-    config.before_configuration do
-      config.lookbook = Lookbook.config
-
-      if defined?(ViewComponent)
-        config.lookbook.using_view_component ||= true
-      else
-        require "view_component"
-        config.lookbook.using_view_component ||= false
-      end
+    config.before_initialize do |app|
+      YARD::Parser::Ruby::RipperParser.prepend YardParserPatch
     end
 
-    config.after_initialize do
-      if opts.using_view_component
-        vc_config = Engine.host_config.view_component
-
-        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
+    config.to_prepare do
+      ViewComponentConfigSync.call if Utils.gem_installed?("view_component")
 
-      if opts.reload_on_change.nil?
-        opts.reload_on_change = !host_config.cache_classes && host_config.reload_classes_only_on_change
+      preview_controller = Lookbook.config.preview_controller.constantize
+      unless preview_controller.include?(Lookbook::PreviewControllerActions)
+        preview_controller.include(Lookbook::PreviewControllerActions)
       end
     end
 
     config.after_initialize do
-      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
+      if Engine.enabled?
+        start
       else
-        Engine.load_previews
-        Engine.load_pages
+        info("Lookbook is loaded but not enabled in this environment (#{Rails.env}).")
       end
-
-      Engine.run_hooks(:after_initialize)
-    end
-
-    def opts
-      Lookbook.config
-    end
-
-    def parser
-      @_parser ||= PreviewParser.new(opts.preview_paths, Engine.tags)
-    end
-
-    def reloaders
-      @_reloaders ||= Reloaders.new
     end
 
     class << self
-      delegate :app_name, to: :runtime_context
-
-      def mount_path
-        routes.find_script_name({})
-      end
-
-      def mounted?
-        mount_path.present?
-      end
-
-      def reloading?
-        opts.reload_on_change
-      end
-
-      def auto_refresh?
-        opts.live_updates == true &&
-          reloading? &&
-          runtime_context.web? &&
-          FileWatcher.evented?
-      end
+      def start
+        raise "Lookbook is already started!" if @started
 
-      def preview_embeds_allowed?
-        opts.preview_embeds.enabled == true && opts.preview_embeds.policy != "DENY"
-      end
-
-      def websocket
-        @_websocket ||= auto_refresh? ? Websocket.new(mount_path, logger: Lookbook.logger) : NullWebsocket.new
-      end
-
-      def runtime_context
-        @_runtime_context ||= RuntimeContext.new(env: Rails.env)
-      end
+        info("Starting Lookbook in #{Lookbook.env} mode...")
 
-      def theme
-        @_theme ||= Lookbook::Theme.new(opts.ui_theme, opts.ui_theme_overrides)
-      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.new
-      end
-
-      def run_hooks(event_name, *args)
-        hooks.for_event(event_name).each do |hook|
-          hook.call(Lookbook, *args)
+        if watch_files?
+          Reloaders.register(Previews.reloader)
+          Reloaders.register(Pages.reloader)
+          Reloaders.execute
+        else
+          Previews.load
+          Pages.load
         end
-      end
 
-      def host_app_path
-        Rails.application.root.join("app")
+        @started = true
+
+        info("Lookbook started#{" - watching filesystem for changes" if watch_files?}")
       end
 
-      def host_config
-        Rails.application.config
+      def mount_path
+        config.lookbook.mount_path || Lookbook::Config.defaults.mount_path
       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)
+        @view_paths ||= begin
+          # 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
+          Utils.normalize_paths(paths.map(&:to_s))
         end
-        paths.map { |path| Pathname(path.to_s) }
       end
 
       def component_paths
-        @_component_paths ||= begin
-          paths = [*opts.component_paths, *view_paths, host_app_path]
-          PathUtils.normalize_paths(paths)
+        @component_paths ||= begin
+          paths = [*config.lookbook.component_paths, *view_paths, host_app_path]
+          Utils.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
+      def host_app_path
+        Rails.application.root.join("app")
       end
 
-      def previews
-        @_previews ||= PreviewCollection.new
+      def notifications
+        @notifications ||= Notifications.new
       end
 
-      def preview_controller
-        @_preview_controller = opts.preview_controller.constantize
-        @_preview_controller.include PreviewControllerActions
+      def watch_files?
+        config.lookbook.reload_on_change
       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
+      def files_updated!
+        @updated_at = DateTime.now
       end
 
-      def load_pages(changes = nil)
-        pages.load(Engine.page_paths, changes)
-      rescue => e
-        Lookbook.logger.error(e)
-        raise e
+      def updated_at
+        @updated_at ||= DateTime.now
       end
 
-      def notify_clients(changes = nil)
-        return unless changes.present?
-
-        websocket.broadcast(:reload)
-        run_hooks(:after_change, changes.to_h)
+      def enabled?
+        config.lookbook.enabled
       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
-      Engine.run_hooks(:before_exit)
     end
   end
 end

data/lib/lookbook/entity.rb

@@ -0,0 +1,74 @@
+module Lookbook
+  class Entity
+    DEFAULT_PRIORITY = 1
+
+    send(:include, Lookbook::Engine.routes.url_helpers) # YARD parsing workaround: https://github.com/lsegal/yard/issues/546
+
+    def id
+      raise Lookbook::Error, "Entity subclasses must define an #id method"
+    end
+
+    def uuid
+      @uuid ||= Utils.hash("#{type}#{id}")
+    end
+
+    def name = nil
+
+    def label
+      Utils.label(name) if name
+    end
+
+    def title
+      label
+    end
+
+    def visible?
+      !hidden?
+    end
+
+    def hidden?
+      false
+    end
+
+    def priority
+      default_priority || DEFAULT_PRIORITY
+    end
+
+    attr_reader :default_priority
+
+    def type
+      @type ||= self.class.name.demodulize.underscore.delete_suffix("_entity").to_sym
+    end
+
+    def <=>(other)
+      [priority || DEFAULT_PRIORITY, label.downcase] <=> [other.priority || DEFAULT_PRIORITY, other.label.downcase]
+    end
+
+    def parent_lookup_path = nil
+
+    def url_path = nil
+
+    def to_param = url_param
+
+    def to_key = [uuid]
+
+    def model_name
+      OpenStruct.new param_key: type
+    end
+
+    def to_h
+      {
+        type: type,
+        id: id,
+        uuid: uuid,
+        name: name,
+        label: label,
+        hidden: hidden?
+      }
+    end
+
+    def to_json
+      Utils.deep_camelize_keys(to_h)
+    end
+  end
+end

data/lib/lookbook/entity_store.rb

@@ -0,0 +1,50 @@
+module Lookbook
+  class EntityStore
+    include Enumerable
+
+    delegate :each, :clear, to: :@entities
+
+    def initialize
+      @entities = []
+    end
+
+    def add(*entities)
+      entities.each { @entities.push(_1) }
+    end
+
+    def replace(*entities)
+      entities.each do |entity|
+        i = index(entity)
+        @entities[i] = entity unless i.nil?
+      end
+    end
+
+    def remove(*entities)
+      entities.each do |entity|
+        i = index(entity)
+        @entities.delete_at(i) unless i.nil?
+      end
+    end
+
+    def replace_all(entities)
+      clear
+      add(*entities)
+    end
+
+    def include?(entity)
+      !index(entity).nil?
+    end
+
+    def index(entity)
+      @entities.index { _1.id == entity.id }
+    end
+
+    def all = @entities
+
+    alias_method :to_a, :all
+
+    def to_data
+      @entities.map(&:to_h)
+    end
+  end
+end

data/lib/lookbook/entity_tree.rb

@@ -0,0 +1,80 @@
+module Lookbook
+  class EntityTree
+    include EntityTreeNode
+
+    attr_reader :lookup_path
+
+    def initialize(leaf_nodes = [], config_path: nil)
+      @leaf_nodes = leaf_nodes
+      @config_path = config_path
+      @lookup_path = ""
+    end
+
+    def children
+      @children ||= begin
+        child_nodes = nodes.select { _1.depth == 1 }.sort
+        ListResolver.call(config.fetch(:children, "*"), child_nodes.map(&:name)) do |name|
+          child_nodes.find { _1.name == name }
+        end
+      end
+    end
+
+    def children_of(parent)
+      nodes.select do |node|
+        node.depth == parent.depth + 1 &&
+          node.lookup_path.start_with?("#{parent.lookup_path}/")
+      end
+    end
+
+    def next(node)
+      nodes = navigable_nodes.filter(&:visible?)
+      index = nodes.index(node)
+      nodes[index + 1] unless node == nodes.last
+    end
+
+    def previous(node)
+      nodes = navigable_nodes.filter(&:visible?)
+      index = nodes.index(node)
+      nodes[index - 1] unless node == nodes.first
+    end
+
+    def root? = true
+
+    def to_data
+      children.map(&:to_h)
+    end
+
+    protected
+
+    def navigable_nodes
+      ordered_nodes.select(&:navigable?)
+    end
+
+    def ordered_nodes
+      @ordered_nodes ||= collect_ordered_entities(self).flatten
+    end
+
+    def nodes
+      @nodes ||= begin
+        node_entities = [@leaf_nodes, *@leaf_nodes.map(&:ancestors)].flatten.uniq
+        node_entities.sort_by { _1.lookup_path }
+      end
+    end
+
+    def collect_ordered_entities(start_node)
+      start_node.children.flat_map do |node|
+        child_nodes = collect_ordered_entities(node)
+        [node, child_nodes]
+      end
+    end
+
+    def config
+      @config ||= begin
+        opts = if @config_path && File.exist?(@config_path)
+          YAML.safe_load_file(@config_path)
+        end
+        DataObject.new(opts || {})
+      end
+    end
+  end
+end

data/lib/lookbook/errors/error.rb

@@ -0,0 +1,4 @@
+module Lookbook
+  class Error < StandardError
+  end
+end

data/lib/lookbook/errors/parser_error.rb

@@ -0,0 +1,4 @@
+module Lookbook
+  class ParserError < Error
+  end
+end

data/lib/lookbook/evented_file_update_checker.rb

@@ -0,0 +1,56 @@
+require "active_support/evented_file_update_checker"
+
+module Lookbook
+  class EventedFileUpdateChecker < ActiveSupport::EventedFileUpdateChecker
+    attr_reader :change_callbacks
+
+    def initialize(files, dirs = {}, &block)
+      unless block
+        raise ArgumentError, "A block is required to initialize an EventedFileUpdateChecker"
+      end
+
+      @block = block
+      @change_callbacks = []
+      @core = Core.new(files, dirs, self)
+      ObjectSpace.define_finalizer(self, @core.finalizer)
+    end
+
+    def on_change(&block)
+      change_callbacks << block if block
+    end
+
+    class Core < ActiveSupport::EventedFileUpdateChecker::Core
+      def initialize(files, dirs, checker)
+        @checker = checker
+        super(files, dirs)
+      end
+
+      def changed(modified, added, removed)
+        super
+        if @updated&.true?
+          changeset = FilesChangeset.new(modified: modified, added: added, removed: removed)
+          @checker.change_callbacks.each { _1.call(changeset) }
+        end
+      end
+
+      # Patched to handle regex-style
+      # extension matchers like `.html.*`
+      def watching?(file)
+        return true if super
+
+        file = Pathname(file)
+        name_parts = file.basename.to_s.split(".")
+        ext = "." + name_parts.drop(1).join(".").to_s
+
+        file.dirname.ascend do |dir|
+          matching = @dirs.fetch(dir, []).map { |m| Regexp.new(m) }
+          if matching.empty? || matching.find { |m| m.match?(ext) }
+            break true
+          elsif dir == @common_path || dir.root?
+            break false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lookbook/files_changeset.rb

@@ -0,0 +1,29 @@
+module Lookbook
+  class FilesChangeset
+    attr_reader :added, :modified, :removed
+
+    def initialize(added: nil, modified: nil, removed: nil)
+      @added = added.to_a
+      @modified = modified.to_a
+      @removed = removed.to_a
+    end
+
+    def touched
+      [added, modified].flatten.uniq
+    end
+
+    def all
+      [added, modified, removed].flatten
+    end
+
+    def any? = all.any?
+
+    def to_h
+      {
+        added: added,
+        removed: removed,
+        modified: modified
+      }
+    end
+  end
+end