lookbook 1.5.5 → 2.0.0.beta.0

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,33 @@ module Lookbook
   class PageCollection < EntityCollection
     include HierarchicalCollection
 
-    def load(page_paths)
-      @entities = []
-      clear_cache
+    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
 
-      file_paths = page_paths.flat_map do |dir|
-        PathUtils.normalize_paths(Dir["#{dir}/**/*.html.*", "#{dir}/**/*.md.*"].sort)
-      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 +39,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.*"].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

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

@@ -2,40 +2,65 @@ module Lookbook
   class PreviewCollection < EntityCollection
     include HierarchicalCollection
 
-    def find_example_by_path(lookup_path)
-      examples.find_by_path(lookup_path)
+    def find_scenario_by_path(lookup_path)
+      scenarios.find_by_path(lookup_path)
     end
 
     def find_by_preview_class(klass)
       find { |preview| preview.preview_class.name == klass.to_s }
     end
 
-    def load(code_objects)
-      @entities = []
-      clear_cache
+    def load(code_objects, changes = nil)
+      changes.present? ? reload_changed(code_objects, changes) : reload_all(code_objects)
+    end
 
-      previews = Array(code_objects).map { |obj| PreviewCollection.preview_from_code_object(obj) }.compact
+    def reload_all(code_objects)
+      clear_all
+      previews = code_objects.map { |obj| PreviewCollection.preview_from_code_object(obj) }.compact
       add(previews)
     end
 
-    def self.preview_from_code_object(code_object)
-      klass = code_object.path.constantize
-      Preview.new(code_object) if preview_class?(klass)
-    rescue => exception
-      Lookbook.logger.error exception.to_s
-      nil
+    def reload_changed(code_objects, changes)
+      modified = Array(changes[:modified])
+      removed = Array(changes[:removed]) + modified
+      added = Array(changes[:added]) + modified
+
+      remove_by_file_path(removed)
+
+      previews = added.map do |path|
+        code_object = code_objects.find { |obj| obj if obj&.file.to_s == path.to_s }
+        PreviewCollection.preview_from_code_object(code_object) if code_object
+      end.compact
+
+      add(previews)
     end
 
-    def self.preview_class?(klass)
-      if klass.ancestors.include?(ViewComponent::Preview)
-        !klass.respond_to?(:abstract_class) || klass.abstract_class != true
+    def remove_by_file_path(paths)
+      paths = Array(paths).map(&:to_s)
+      @entities.reject! { |preview| preview.file_path.to_s.in?(paths) }
+      clear_cache
+    end
+
+    class << self
+      def preview_from_code_object(code_object)
+        klass = code_object.path.constantize
+        PreviewEntity.new(code_object) if preview_class?(klass)
+      rescue => exception
+        Lookbook.logger.error exception.to_s
+        nil
+      end
+
+      def preview_class?(klass)
+        if (defined?(ViewComponent) && klass.ancestors.include?(ViewComponent::Preview)) || klass.ancestors.include?(Lookbook::Preview)
+          !klass.respond_to?(:abstract_class) || klass.abstract_class != true
+        end
       end
     end
 
     protected
 
-    def examples
-      @_cache[:examples] ||= PreviewExampleCollection.new(flat_map(&:examples))
+    def scenarios
+      @_cache[:scenarios] ||= ScenarioCollection.new(flat_map(&:scenarios))
     end
   end
 end

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

@@ -0,0 +1,4 @@
+module Lookbook
+  class RenderTargetCollection < EntityCollection
+  end
+end

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

@@ -0,0 +1,4 @@
+module Lookbook
+  class ScenarioCollection < EntityCollection
+  end
+end

data/lib/lookbook/entities/concerns/{annotatable.rb → annotatable_entity.rb}

@@ -1,5 +1,6 @@
 module Lookbook
-  module Annotatable
+  # @api private
+  module AnnotatableEntity
     extend ActiveSupport::Concern
 
     included do
@@ -23,8 +24,8 @@ module Lookbook
 
       def fetch_config(key, fallback = nil, &block)
         value = case key.to_sym
-        when :components
-          components_config
+        when :renders
+          renders_config
         when :display_options
           display_options_config
         else
@@ -36,10 +37,10 @@ module Lookbook
 
       private
 
-      def components_config
-        return unless has_tag?(:component)
+      def renders_config
+        return unless has_tag?(:component) || has_tag?(:renders)
 
-        Array(tags(:component)).map(&:value).compact
+        [*tags(:component), *tags(:renders)].map(&:value).compact
       end
 
       def display_options_config

data/lib/lookbook/entities/concerns/{inspectable.rb → inspectable_entity.rb}

@@ -1,5 +1,6 @@
 module Lookbook
-  module Inspectable
+  # @api private
+  module InspectableEntity
     extend ActiveSupport::Concern
 
     included do

data/lib/lookbook/entities/concerns/{locatable.rb → locatable_entity.rb}

@@ -1,5 +1,6 @@
 module Lookbook
-  module Locatable
+  # @api private
+  module LocatableEntity
     extend ActiveSupport::Concern
 
     included do
@@ -41,20 +42,13 @@ module Lookbook
         @_logical_path ||= PathUtils.to_path(directory, file_name_base)
       end
 
-      def full_path
-        Lookbook.logger.warn "The `full_path` method has been deprecated - use `file_path` instead. `full_path` will be removed in v2.0"
-        file_path
-      end
-
-      def rel_path
-        Lookbook.logger.warn "The `rel_path` method has been deprecated - use `relative_file_path` instead. `rel_path` will be removed in v2.0"
-        relative_file_path
-      end
+      alias_method :full_path, :file_path
+      alias_method :rel_path, :relative_file_path
+      alias_method :dir_path, :directory_path
 
-      def dir_path
-        Lookbook.logger.warn "The `dir_path` method has been deprecated - use `directory_path` instead. `dir_path` will be removed in v2.0"
-        directory_path
-      end
+      deprecate full_path: :file_path, deprecator: Deprecation
+      deprecate rel_path: :relative_file_path, deprecator: Deprecation
+      deprecate dir_path: :directory_path, deprecator: Deprecation
 
       protected
 

data/lib/lookbook/entities/concerns/navigable_entity.rb

@@ -0,0 +1,44 @@
+module Lookbook
+  # @api private
+  module NavigableEntity
+    extend ActiveSupport::Concern
+
+    included do
+      def hidden?
+        fetch_config(:hidden, false)
+      end
+
+      def visible?
+        !hidden?
+      end
+
+      def priority
+        return @_priority if @_priority
+
+        pos = if @priority_prefixes && respond_to?(:file_name)
+          PriorityPrefixParser.call(file_name).first || fetch_config(:priority, default_priority)
+        else
+          fetch_config(:priority, default_priority)
+        end
+
+        @_priority ||= pos.to_i
+      end
+
+      def depth
+        lookup_path.split("/").size
+      end
+
+      def default_priority
+        @default_priority || 10000
+      end
+
+      def <=>(other)
+        if respond_to?(:sort_handler, true)
+          sort_handler(other)
+        else
+          [priority, label] <=> [other.priority, other.label]
+        end
+      end
+    end
+  end
+end

data/lib/lookbook/entities/entity.rb

@@ -1,7 +1,10 @@
 module Lookbook
+  # Base entity class
+  #
+  # @api private
   class Entity
     include Comparable
-    include Lookbook::Engine.routes.url_helpers
+    send(:include, Lookbook::Engine.routes.url_helpers) # YARD parsing workaround: https://github.com/lsegal/yard/issues/546
 
     def initialize(lookup_path = nil)
       @lookup_path = lookup_path
@@ -34,7 +37,7 @@ module Lookbook
     end
 
     def type
-      @_type ||= self.class.name.demodulize.underscore.downcase.to_sym
+      @_type ||= self.class.name.gsub("Entity", "").demodulize.underscore.downcase.to_sym
     end
 
     def <=>(other)
@@ -44,6 +47,8 @@ module Lookbook
     alias_method :path, :lookup_path
     alias_method :logical_path, :lookup_path
 
+    deprecate path: :lookup_path, deprecator: Deprecation
+
     protected
 
     def fetch_config(key, fallback = nil, &block)

data/lib/lookbook/entities/{page.rb → page_entity.rb}

@@ -1,7 +1,11 @@
 module Lookbook
-  class Page < Entity
-    include Locatable
-    include Navigable
+  # Represents a documentation page
+  #
+  # @ignore methods
+  # @api public
+  class PageEntity < Entity
+    include LocatableEntity
+    include NavigableEntity
 
     attr_reader :content, :sections
 
@@ -10,7 +14,7 @@ module Lookbook
       @base_directories = Engine.page_paths
       @lookup_path = PathUtils.to_lookup_path(relative_file_path)
       @frontmatter, @content = FrontmatterExtractor.call(file_contents)
-      @position_prefixes = true
+      @priority_prefixes = true
       @sections = []
     end
 
@@ -46,12 +50,12 @@ module Lookbook
     end
 
     def url_path
-      lookbook_page_path(path)
+      lookbook_page_path(lookup_path)
     end
 
     def add_section(section)
       @sections << section
-      @sections.sort_by! { |section| [section.position, section.label] }
+      @sections.sort_by! { |section| [section.priority, section.label] }
     end
 
     def method_missing(method_name, *args, &block)

data/lib/lookbook/entities/{page_section.rb → page_section_entity.rb}

@@ -1,5 +1,5 @@
 module Lookbook
-  class PageSection < Page
+  class PageSectionEntity < PageEntity
     attr_accessor :parent
 
     def initialize(file_path)

data/lib/lookbook/entities/preview_entity.rb

@@ -0,0 +1,99 @@
+module Lookbook
+  # Represents a preview class
+  #
+  # @ignore methods
+  # @api public
+  class PreviewEntity < Entity
+    include AnnotatableEntity
+    include LocatableEntity
+    include NavigableEntity
+
+    delegate :render_args, to: :preview_class
+
+    attr_reader :preview_class
+
+    def initialize(code_object)
+      @code_object = code_object
+      @preview_class = code_object.path.constantize
+      @file_path = Pathname(code_object.file)
+      @base_directories = Engine.preview_paths
+
+      cleaned_path = relative_file_path.to_s
+        .gsub(/\/(component_preview|preview)(\..*)$/, "")
+        .gsub(/(_component_preview|_preview)(\..*)$/, "")
+
+      @lookup_path = PathUtils.to_lookup_path(cleaned_path)
+    end
+
+    def scenarios
+      @_scenarios ||= ScenarioCollection.new(load_scenarios)
+    end
+
+    def scenario(scenario_name)
+      scenarios.find { |m| m.name == scenario_name.to_s }
+    end
+
+    def visible_scenarios
+      @_visible_scenarios ||= ScenarioCollection.new(scenarios.select(&:visible?))
+    end
+
+    def default_scenario
+      visible_scenarios.first
+    end
+
+    def render_targets
+      @_render_targets ||= RenderTargetCollection.new(scenarios.flat_map(&:render_targets).uniq(&:lookup_path))
+    end
+
+    def render_target
+      render_targets.first
+    end
+
+    def display_options
+      global_options = Lookbook.config.preview_display_options
+      global_options.deep_merge(fetch_config(:display_options, {}))
+    end
+
+    def layout
+      preview_class.instance_variable_get(:@layout)
+    end
+
+    def url_path
+      lookbook_inspect_path(lookup_path)
+    end
+
+    def preview_class_name
+      preview_class.name
+    end
+
+    def guess_render_targets
+      [preview_class.name.chomp("Preview").constantize&.name]
+    rescue
+      []
+    end
+
+    alias_method :components, :render_targets
+    alias_method :component, :render_target
+    alias_method :examples, :scenarios
+    alias_method :example, :scenario
+
+    deprecate examples: :scenarios, deprecator: Deprecation
+    deprecate example: :scenario, deprecator: Deprecation
+
+    protected
+
+    def load_scenarios
+      return scenario_entities unless code_object.groups.any?
+
+      scenario_entities.group_by(&:group).flat_map do |group_name, grouped_scenarios|
+        group_name.nil? ? grouped_scenarios : ScenarioGroupEntity.new(group_name.presence || label.pluralize, grouped_scenarios, self)
+      end
+    end
+
+    def scenario_entities
+      public_methods = preview_class.public_instance_methods(false)
+      method_objects = code_object.meths.select { |m| public_methods.include?(m.name) }
+      method_objects.map.with_index { |code_object, i| ScenarioEntity.new(code_object, self, priority: i) }
+    end
+  end
+end

data/lib/lookbook/entities/renderable_entity.rb

@@ -0,0 +1,50 @@
+module Lookbook
+  # Represents the component or view template partial
+  # that is being rendered in a preview.
+  #
+  # @ignore methods
+  # @api public
+  class RenderableEntity < Entity
+    include LocatableEntity
+
+    def initialize(identifier)
+      @identifier = identifier
+      @base_directories = Engine.component_paths
+      @file_path = PathUtils.determine_full_path(component? ? "#{name}.rb" : identifier, @base_directories)
+      unless @file_path && File.exist?(@file_path)
+        raise LookbookError, "The render target #{@identifier} was not found."
+      end
+      @lookup_path = PathUtils.to_lookup_path(relative_file_path)
+    end
+
+    def component_class
+      @identifier.constantize if component?
+    end
+
+    def name
+      component? ? component_class.name.underscore : @identifier
+    end
+
+    def template_file_path
+      component? ? Dir.glob("#{directory_path}/#{file_name(true)}.*.erb").first : file_path
+    end
+
+    def inline?
+      component? ? template_file_path.present? : false
+    end
+
+    def component?
+      @identifier.first.upcase == @identifier.first &&
+        !@identifier.include?(".") &&
+        !@identifier.include?("/")
+    end
+
+    def template?
+      !component?
+    end
+
+    def type
+      component? ? :component : :template
+    end
+  end
+end

data/lib/lookbook/entities/rendered_scenario_entity.rb

@@ -0,0 +1,53 @@
+module Lookbook
+  # Represents a **rendered** preview scenario
+  #
+  # @ignore methods
+  # @api public
+  class RenderedScenarioEntity
+    delegate_missing_to :scenario
+
+    attr_reader :scenario
+
+    def initialize(scenario, output, params)
+      @scenario = scenario
+      @params = params
+      @output = output
+    end
+
+    def source
+      has_custom_template? ? template_source(template) : scenario.source
+    end
+
+    def source_lang
+      has_custom_template? ? template_lang(template) : scenario.source_lang
+    end
+
+    def output
+      @_output ||= CodeBeautifier.call(@output)
+    end
+
+    protected
+
+    attr_reader :params
+
+    def render_args
+      @_render_args ||= preview.render_args(scenario.name, params: params)
+    end
+
+    def template
+      render_args[:template]
+    end
+
+    def view?
+      render_args[:type] == :view
+    end
+
+    def has_custom_template?
+      !template.in?(system_templates) && !custom_source? && !view?
+    end
+
+    def system_templates
+      ["view_components/preview", Lookbook.config.preview_template]
+    end
+  end
+end