lookbook 1.2.1 → 1.4.5

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

@@ -0,0 +1,41 @@
+module Lookbook
+  class PreviewCollection < EntityCollection
+    include HierarchicalCollection
+
+    def find_example_by_path(lookup_path)
+      examples.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
+
+      previews = Array(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
+    end
+
+    def self.preview_class?(klass)
+      if klass.ancestors.include?(ViewComponent::Preview)
+        !klass.respond_to?(:abstract_class) || klass.abstract_class != true
+      end
+    end
+
+    protected
+
+    def examples
+      @_cache[:examples] ||= PreviewExampleCollection.new(flat_map(&:examples))
+    end
+  end
+end

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

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

data/lib/lookbook/entities/component.rb

@@ -0,0 +1,31 @@
+module Lookbook
+  class Component < Entity
+    include Locatable
+
+    attr_reader :component_class
+
+    def initialize(component_class)
+      @component_class = component_class
+      @file_path = "#{Engine.component_paths.first}/#{name.underscore}.rb"
+      @base_directories = Engine.component_paths
+      @lookup_path = PathUtils.to_lookup_path(relative_file_path)
+    end
+
+    def name
+      component_class.name
+    end
+
+    def template_file_path
+      Dir.glob("#{directory_path}/#{file_name(true)}.*.erb").first
+    end
+
+    def inline?
+      template_file_path.present?
+    end
+
+    def template_path
+      Lookbook.logger.warn "The `template_path` method has been deprecated - use `template_file_path` instead. `template_file_path` will be removed in v2.0"
+      template_file_path
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Lookbook
+  module Annotatable
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :has_tag?, to: :code_object
+
+      def notes
+        code_object.docstring.to_s.strip
+      end
+
+      def tags(name = nil)
+        code_object.tags(name)
+      end
+
+      def tag(name = nil)
+        tags(name).first
+      end
+
+      protected
+
+      attr_reader :code_object
+
+      def fetch_config(key, fallback = nil, &block)
+        value = case key.to_sym
+        when :components
+          components_config
+        when :display_options
+          display_options_config
+        else
+          tag(key).value if has_tag?(key)
+        end
+
+        Utils.value_or_fallback(value, fallback, &block)
+      end
+
+      private
+
+      def components_config
+        return unless has_tag?(:component)
+
+        Array(tags(:component)).map(&:value).compact
+      end
+
+      def display_options_config
+        return unless has_tag?(:display)
+
+        # Dynamic params set at the entity level are
+        # not (yet?) supported so filter them out.
+        display_tags = tags(:display).select do |tag|
+          !tag.value.is_a?(Hash) && !tag.value.is_a?(Array)
+        end
+
+        display_tags.map { |tag| [tag.key.to_sym, tag.value] }.to_h
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Lookbook
+  module Inspectable
+    extend ActiveSupport::Concern
+
+    included do
+      def source
+        source_code = if custom_source?
+          File.read(source_file_path)
+        else
+          src = CodeIndenter.call(code_object.source)
+          begin
+            send(:format_source, src)
+          rescue NoMethodError
+            src
+          end
+        end
+
+        source_code.strip_heredoc.strip
+      end
+
+      def source_lang
+        custom_source? ? Lang.guess(source_file_path, :ruby) : Lang.find(:ruby)
+      end
+
+      def custom_source?
+        source_file_path.present?
+      end
+
+      protected
+
+      attr_reader :code_object
+
+      def source_file_path
+        @_source_path ||= if code_object.has_tag?(:source)
+          source_path = code_object.tag(:source).value
+          unless source_path.present? && File.exist?(source_path)
+            raise LookbookError, "Could not find source file '#{source_path}'"
+          end
+          source_path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Lookbook
+  module Locatable
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :file_path, :base_directories
+
+      def file_name(strip_ext = false)
+        basename = file_pathname.basename
+        (strip_ext ? basename.to_s.split(".").first : basename).to_s
+      end
+
+      def file_name_base
+        @_file_name_slug ||= file_name(true).gsub(/(_component_preview|component_preview|preview)$/, "")
+      end
+
+      def file_extension
+        @_file_extension ||= file_pathname.extname
+      end
+
+      def directory_path
+        @_directory_path ||= Pathname(file_pathname.dirname)
+      end
+
+      def relative_file_path
+        @_relative_file_path ||= file_pathname.relative_path_from(base_directory)
+      end
+
+      def relative_directory_path
+        @_relative_directory_path ||= directory_path.relative_path_from(base_directory)
+      end
+
+      def last_modified
+        @_last_modified ||= File.mtime(file_path)
+      end
+
+      def logical_path
+        return @_logical_path if @_logical_path
+
+        directory = fetch_config(:logical_path) { relative_directory_path.to_s }
+        @_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
+
+      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
+
+      protected
+
+      def file_pathname
+        Pathname(file_path)
+      end
+
+      def base_directory
+        return @_base_directory if @_base_directory
+
+        directories = Array(base_directories).map(&:to_s).sort_by { |path| path.split("/").size }.reverse
+        @_base_directory ||= directories.find { |dir| file_path.to_s.start_with?(dir) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Lookbook
+  module Navigable
+    extend ActiveSupport::Concern
+
+    included do
+      def hidden?
+        fetch_config(:hidden, false)
+      end
+
+      def visible?
+        !hidden?
+      end
+
+      def position
+        return @_position if @_position
+
+        pos = if @position_prefixes && respond_to?(:file_name)
+          PositionPrefixParser.call(file_name).first || default_position
+        else
+          fetch_config(:position, default_position)
+        end
+
+        @_position ||= pos.to_i
+      end
+
+      def depth
+        path.split("/").size
+      end
+
+      def default_position
+        @default_position || 10000
+      end
+
+      def <=>(other)
+        if respond_to?(:sort_handler, true)
+          sort_handler(other)
+        else
+          [position, label] <=> [other.position, other.label]
+        end
+      end
+    end
+  end
+end

data/lib/lookbook/entities/entity.rb

@@ -0,0 +1,53 @@
+module Lookbook
+  class Entity
+    include Comparable
+    include Lookbook::Engine.routes.url_helpers
+
+    def initialize(lookup_path = nil)
+      @lookup_path = lookup_path
+    end
+
+    def id
+      Utils.id(fetch_config(:id) { lookup_path.tr("/", "-") })
+    end
+
+    def name
+      @_name ||= Utils.name(File.basename(@lookup_path))
+    end
+
+    def label
+      @_label ||= fetch_config(:label) { name.titleize }
+    end
+
+    def lookup_path
+      return @_lookup_path if @_lookup_path
+
+      directory = fetch_config(:logical_path) do
+        dir = File.dirname(@lookup_path)
+        dir if !dir.start_with?(".")
+      end
+      @_lookup_path ||= PathUtils.strip_slashes(PathUtils.to_path(directory, name))
+    end
+
+    def url_path
+      nil
+    end
+
+    def type
+      @_type ||= self.class.name.demodulize.underscore.downcase.to_sym
+    end
+
+    def <=>(other)
+      label <=> other.label
+    end
+
+    alias_method :path, :lookup_path
+    alias_method :logical_path, :lookup_path
+
+    protected
+
+    def fetch_config(key, fallback = nil, &block)
+      Utils.value_or_fallback(nil, fallback, &block)
+    end
+  end
+end

data/lib/lookbook/entities/page.rb

@@ -0,0 +1,80 @@
+module Lookbook
+  class Page < Entity
+    include Locatable
+    include Navigable
+
+    attr_reader :content, :sections
+
+    def initialize(file_path)
+      @file_path = Pathname(file_path)
+      @base_directories = Engine.page_paths
+      @lookup_path = PathUtils.to_lookup_path(relative_file_path)
+      @frontmatter, @content = FrontmatterExtractor.call(file_contents)
+      @position_prefixes = true
+      @sections = []
+    end
+
+    def title
+      @_title ||= fetch_config(:title, label)
+    end
+
+    def landing?
+      @_landing ||= fetch_config(:landing, false)
+    end
+
+    def markdown?
+      @_markdown ||= fetch_config(:markdown) { file_path.to_s.match?(/(.*)\.md\.(.*)$/) }
+    end
+
+    def header?
+      @_header ||= fetch_config(:header, true)
+    end
+
+    def footer?
+      @_footer ||= fetch_config(:footer, true)
+    end
+
+    def data
+      return @_data if @_data
+
+      config_data = fetch_config(:data, {})
+      @_data ||= config_data.is_a?(Hash) ? Store.new(config_data) : config_data
+    end
+
+    def search_terms
+      label
+    end
+
+    def url_path
+      lookbook_page_path(path)
+    end
+
+    def add_section(section)
+      @sections << section
+      @sections.sort_by! { |section| [section.position, section.label] }
+    end
+
+    def method_missing(method_name, *args, &block)
+      method_name.to_s.end_with?("=") ? super : frontmatter.fetch(method_name, nil)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      frontmatter.key?(method_name) || super
+    end
+
+    protected
+
+    def fetch_config(key, fallback = nil, &block)
+      value = frontmatter[key]
+      Utils.value_or_fallback(value, fallback, &block)
+    end
+
+    def file_contents
+      @_file_contents ||= File.read(file_path)
+    end
+
+    def frontmatter
+      @_merged_frontmatter ||= Lookbook.config.page_options.deep_merge(@frontmatter.to_h).deep_symbolize_keys
+    end
+  end
+end

data/lib/lookbook/entities/page_section.rb

@@ -0,0 +1,43 @@
+module Lookbook
+  class PageSection < Page
+    attr_accessor :parent
+
+    def initialize(file_path)
+      @file_path = Pathname(file_path)
+      @parent = nil
+      super
+    end
+
+    def name
+      Utils.name(name_parts[:name])
+    end
+
+    def lookup_path
+      directory = if relative_directory_path.present? && !relative_directory_path.to_s.start_with?(".")
+        relative_directory_path
+      end
+
+      path = PathUtils.to_path(directory, name_parts[:parent_name])
+      PathUtils.to_lookup_path(path)
+    end
+
+    def landing?
+      false
+    end
+
+    def url_path
+      nil
+    end
+
+    alias_method :page, :parent
+
+    protected
+
+    def name_parts
+      return @_name_parts if @_name_parts
+
+      matches = file_name(true).match(/(?<parent_name>.*)\[(?<name>.*)\]/)
+      @_name_parts ||= {name: matches[:name], parent_name: matches[:parent_name]}
+    end
+  end
+end

data/lib/lookbook/entities/preview.rb

@@ -0,0 +1,87 @@
+module Lookbook
+  class Preview < Entity
+    include Annotatable
+    include Locatable
+    include Navigable
+
+    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 examples
+      @_examples ||= PreviewExampleCollection.new(load_examples)
+    end
+
+    def example(example_name)
+      examples.find { |m| m.name == example_name.to_s }
+    end
+
+    def visible_examples
+      @_visible_examples ||= PreviewExampleCollection.new(examples.select(&:visible?))
+    end
+
+    def default_example
+      visible_examples.first
+    end
+
+    def components
+      @_components ||= ComponentCollection.new(examples.flat_map(&:components).uniq(&:path))
+    end
+
+    def component
+      components.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(path)
+    end
+
+    def preview_class_name
+      preview_class.name
+    end
+
+    def guess_components
+      [preview_class.name.chomp("Preview").constantize]
+    rescue
+      []
+    end
+
+    protected
+
+    def load_examples
+      return example_entities unless code_object.groups.any?
+
+      example_entities.group_by(&:group).flat_map do |group_name, grouped_examples|
+        group_name.nil? ? grouped_examples : PreviewGroup.new(group_name.presence || label.pluralize, grouped_examples, self)
+      end
+    end
+
+    def example_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| PreviewExample.new(code_object, self, position: i) }
+    end
+  end
+end

data/lib/lookbook/entities/preview_example.rb

@@ -0,0 +1,100 @@
+module Lookbook
+  class PreviewExample < Entity
+    include Inspectable
+    include Annotatable
+    include Navigable
+
+    delegate :group, to: :code_object
+
+    attr_reader :preview
+
+    def initialize(code_object, preview, position: nil)
+      @code_object = code_object
+      @preview = preview
+      @default_position = position
+      @lookup_path = "#{parent.lookup_path}/#{name}"
+    end
+
+    def id
+      @_id ||= Utils.id(fetch_config(:id) { "#{parent.id}-#{code_object.name}" })
+    end
+
+    def name
+      @_name ||= Utils.name(code_object.name)
+    end
+
+    def display_options
+      parent.display_options.merge(fetch_config(:display_options, {}))
+    end
+
+    def components
+      @_components ||= ComponentCollection.new(load_components)
+    end
+
+    def component
+      components.first
+    end
+
+    def examples
+      [self]
+    end
+
+    def template_source(template_path)
+      source_path = template_file_path(template_path)
+      source_path ? File.read(source_path) : nil
+    end
+
+    def template_lang(template_path)
+      path = template_file_path(template_path)
+      Lookbook::Lang.guess(path) || Lookbook::Lang.find(:html)
+    end
+
+    def search_terms
+      [parent.label, label]
+    end
+
+    def url_path
+      lookbook_inspect_path(path)
+    end
+
+    def type
+      :example
+    end
+
+    alias_method :parent, :preview
+    alias_method :lang, :source_lang
+
+    protected
+
+    def sort_handler(other_entity)
+      if Lookbook.config.sort_examples
+        label <=> other_entity.label
+      else
+        [position, label] <=> [other_entity.position, other_entity.label]
+      end
+    end
+
+    def format_source(source)
+      source.sub(/^def \w+\s?(\([^)]+\))?/m, "").split("\n")[0..-2].join("\n")
+    end
+
+    def template_file_path(template_path)
+      return full_template_path(template_path) if respond_to?(:full_template_path, true)
+
+      template_path = template_path.to_s.sub(/\..*$/, "")
+      base_path = Engine.preview_paths.detect do |p|
+        Dir["#{p}/#{template_path}.html.*"].first
+      end
+      path = Dir["#{base_path}/#{template_path}.html.*"].first
+      Pathname(path) if path
+    end
+
+    def load_components
+      component_classes = [*fetch_config(:components, []), *preview.send(:fetch_config, :components, [])]
+      component_classes = preview.guess_components if component_classes.empty?
+
+      components = component_classes.map { |klass| Component.new(klass) }
+      components.uniq(&:path)
+    end
+  end
+end