lookbook 1.3.4 → 1.4.1

data/lib/lookbook/preview.rb

@@ -1,181 +0,0 @@
-module Lookbook
-  class Preview < Collection
-    include Utils
-
-    delegate :name, :render_args, to: :@preview
-    delegate :position, :group, :notes, :hidden?, :tags, :tag, to: :@preview_inspector
-
-    def initialize(preview, code_object)
-      @preview = preview
-      @preview_inspector = SourceInspector.new(code_object, eval_scope: preview_class.new)
-      preview_path = preview_class_path(name)
-
-      if @preview_inspector.logical_path
-        basename = preview_path.split("/").last
-        preview_path = "#{@preview_inspector.logical_path}/#{basename}"
-      end
-
-      super(preview_path)
-    end
-
-    def id
-      @preview_inspector&.id || generate_id(lookup_path)
-    end
-
-    def preview_class_name
-      @preview.name
-    end
-
-    def preview_class
-      @preview
-    end
-
-    def label
-      @preview_inspector&.label&.presence || lookup_path.split("/").last.titleize
-    end
-
-    def type
-      :preview
-    end
-
-    def example(example_name)
-      examples.find { |m| m.name == example_name.to_s }
-    end
-
-    def examples
-      return @examples if @examples.present?
-      public_methods = @preview.public_instance_methods(false)
-      public_method_objects = @preview_inspector&.methods&.select { |m| public_methods.include?(m.name) }
-      examples = (public_method_objects || []).map { |m| PreviewExample.new(m.name.to_s, self, m) }
-      sorted = Lookbook.config.sort_examples ? examples.sort_by(&:label) : examples
-      @examples = []
-      if @preview_inspector&.groups&.any?
-        sorted.group_by { |m| m.group }.each do |name, examples|
-          if name.nil?
-            @examples += examples
-          else
-            name = label if name.strip == ""
-            @examples << PreviewGroup.new(name.underscore, self, examples)
-          end
-        end
-      else
-        @examples = sorted
-      end
-      @examples = @examples.compact
-    end
-
-    def items
-      examples.reject { |i| i.hidden? }
-    end
-
-    def default_example
-      examples.first
-    end
-
-    def rel_path
-      "#{name.underscore}.rb"
-    end
-
-    def full_path
-      base_path = preview_paths.detect do |preview_path|
-        Dir["#{preview_path}/#{rel_path}"].first
-      end
-      Pathname.new(Dir["#{base_path}/#{rel_path}"].first)
-    end
-
-    def url_path
-      lookbook_inspect_path lookup_path
-    end
-
-    def parent_collections_names
-      File.dirname(path).split("/")
-    end
-
-    def hierarchy_depth
-      path.split("/").size
-    end
-
-    def layout
-      @preview.instance_variable_get(:@layout)
-    end
-
-    def display_options
-      Lookbook.config.preview_display_options.deep_merge(@preview_inspector&.display_options)
-    end
-
-    def collapsible?
-      true
-    end
-
-    def component
-      components.first
-    end
-
-    def components
-      component_classes = @preview_inspector&.components&.any? ? @preview_inspector&.components : [guess_component]
-      component_classes.map do |class_name|
-        Component.new(class_name.to_s)
-      end
-    end
-
-    def preview_paths
-      PathUtils.normalize_all(Lookbook.config.preview_paths)
-    end
-
-    protected
-
-    @preview_objects = nil
-    @previews = nil
-
-    def guess_component
-      name.chomp("Preview").constantize
-    rescue
-      nil
-    end
-
-    class << self
-      def find(path)
-        all.find { |p| p.lookup_path == path }
-      end
-
-      def exists?(path)
-        !!find(path)
-      end
-
-      def any?
-        all.any?
-      end
-
-      def all
-        if @previews.nil? && @preview_objects.present?
-          previews = @preview_objects.map do |code_object|
-            klass = code_object.path.constantize
-            new(klass, code_object) if klass.ancestors.include?(ViewComponent::Preview)
-          rescue => exception
-            Lookbook.logger.error Lookbook::Error.new(exception)
-            nil
-          end.compact
-
-          sorted_previews = previews.compact.sort_by { |preview| [preview.position, preview.label] }
-          @previews = PreviewCollection.new(sorted_previews)
-          @previews
-        elsif !@preview_objects.present?
-          PreviewCollection.new([])
-        else
-          @previews
-        end
-      end
-
-      def errors
-        @errors ||= []
-      end
-
-      def load!(preview_objects)
-        @preview_objects = preview_objects
-        @previews = nil
-      end
-    end
-
-    alias_method :lookup_path, :path
-  end
-end

data/lib/lookbook/preview_collection.rb

@@ -1,23 +0,0 @@
-module Lookbook
-  class PreviewCollection < Collection
-    def id
-      generate_id("preview-collection", lookup_path || "root")
-    end
-
-    def label
-      "Previews"
-    end
-
-    def find_example(path)
-      Lookbook::PreviewExample.all.find { |e| e.lookup_path == path }
-    end
-
-    def type
-      :preview_collection
-    end
-
-    def self.describe_as
-      "previews"
-    end
-  end
-end

data/lib/lookbook/preview_example.rb

@@ -1,93 +0,0 @@
-module Lookbook
-  class PreviewExample < Entity
-    attr_reader :name, :preview
-    delegate :position, :group, :notes, :hidden?, :source, :tags, :tag, to: :@example_inspector
-
-    def initialize(name, preview, code_object)
-      @name = name
-      @preview = preview
-      @example_inspector = SourceInspector.new(code_object, eval_scope: @preview.preview_class.new)
-      super("#{@preview.path}/#{name}")
-    end
-
-    def id
-      @example_inspector&.id || generate_id(@preview.id, name)
-    end
-
-    def url_path
-      lookbook_inspect_path lookup_path
-    end
-
-    def label
-      @example_inspector.label.presence || name.titleize
-    end
-
-    def display_options
-      @preview.display_options.merge(@example_inspector.display_options)
-    end
-
-    def method_source
-      @example_inspector.source.sub(/^def \w+\s?(\([^)]+\))?/m, "").split("\n")[0..-2].join("\n").strip_heredoc.strip
-    end
-
-    def lang
-      Lookbook::Lang.find(:ruby)
-    end
-
-    def template_source(template_path)
-      source_path = full_template_path(template_path)
-      source_path ? File.read(source_path) : nil
-    end
-
-    def template_lang(template_path)
-      Lookbook::Lang.guess(full_template_path(template_path)) || Lookbook::Lang.find(:html)
-    end
-
-    def type
-      :example
-    end
-
-    def matchers
-      normalize_matchers(@preview.label, label)
-    end
-
-    def hierarchy_depth
-      @preview.hierarchy_depth + 1
-    end
-
-    protected
-
-    def strip_ext(path)
-      path.sub(/\..*$/, "")
-    end
-
-    def full_template_path(template_path)
-      template_path = strip_ext template_path
-      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
-      end
-
-      def find(path)
-        all.find { |p| p.lookup_path == path }
-      end
-
-      def exists?(path)
-        !!find(path)
-      end
-    end
-
-    alias_method :lookup_path, :path
-  end
-end

data/lib/lookbook/preview_group.rb

@@ -1,58 +0,0 @@
-module Lookbook
-  class PreviewGroup < Entity
-    attr_reader :name, :examples, :preview
-
-    def initialize(name, preview, examples)
-      @name = name
-      @preview = preview
-      @examples = examples
-      super("#{@preview.path}/#{name}")
-    end
-
-    def url_path
-      lookbook_inspect_path lookup_path
-    end
-
-    def label
-      name.titleize
-    end
-
-    def type
-      :group
-    end
-
-    def display_options
-      merged = {}
-      examples.reverse.map do |example|
-        merged.merge! example.display_options
-      end
-      merged
-    end
-
-    def hidden?
-      false
-    end
-
-    def position
-      10000
-    end
-
-    def matchers
-      normalize_matchers(@preview.label, label)
-    end
-
-    def hierarchy_depth
-      @preview.hierarchy_depth + 1
-    end
-
-    def tags(name = nil)
-      examples.map { |example| example.tags(name) }.flatten
-    end
-
-    def tag(name = nil)
-      tags(name).first
-    end
-
-    alias_method :lookup_path, :path
-  end
-end

data/lib/lookbook/source_inspector.rb

@@ -1,76 +0,0 @@
-module Lookbook
-  class SourceInspector
-    include Utils
-
-    attr_reader :code_object
-    delegate :groups, :source, to: :@code_object, allow_nil: true
-
-    def initialize(code_object, eval_scope: nil)
-      @code_object = code_object
-      @eval_scope = eval_scope
-    end
-
-    def hidden?
-      @hidden ||= tag_value(:hidden) || false
-    end
-
-    def id
-      @id ||= tag_value(:id)
-    end
-
-    def label
-      @label ||= tag_value(:label)
-    end
-
-    def notes
-      @notes ||= code_object.docstring&.to_s&.strip
-    end
-
-    def group
-      @group ||= code_object.group
-    end
-
-    def position
-      @position ||= tag_value(:position) || 10000
-    end
-
-    def components
-      @components ||= Array(code_object.tags(:component)).map(&:value)
-    end
-
-    def logical_path
-      path = tag_value(:logical_path)
-      path&.delete_prefix("/")&.delete_suffix("/")
-    end
-
-    def display_options
-      return @display_options unless @display_options.nil?
-
-      # Dynamic params set at the entity level are
-      # not (yet?) supported so filter them out.
-      display_tags = Array(code_object.tags(:display)).select do |tag|
-        !(tag.value.is_a?(Array) || tag.value.is_a?(Hash))
-      end
-
-      display_tags.map { |tag| [tag.key.to_sym, tag.value] }.to_h
-    end
-
-    def methods
-      @methods ||= code_object.meths
-    end
-
-    def tags(name = nil)
-      code_object.tags(name)
-    end
-
-    def tag(name = nil)
-      tags(name).first
-    end
-
-    protected
-
-    def tag_value(tag_name)
-      code_object.tag(tag_name).value if code_object.has_tag?(tag_name)
-    end
-  end
-end

data/lib/lookbook/support/utils/attribute_utils.rb

@@ -1,14 +0,0 @@
-module Lookbook
-  module AttributeUtils
-    class << self
-      def dom_id(*args)
-        entity_id(["lookbook", *args])
-      end
-
-      def entity_id(*args)
-        parts = args.map { |arg| arg.to_s.force_encoding("UTF-8").parameterize.dasherize }
-        parts.join("-").tr("/_", "-").delete_prefix("-").delete_suffix("-").gsub("--", "-")
-      end
-    end
-  end
-end

data/lib/lookbook/utils.rb

@@ -1,65 +0,0 @@
-module Lookbook
-  module Utils
-    include Lookbook::Engine.routes.url_helpers
-
-    POSITION_PREFIX_REGEX = /^(\d+?)[-_]/
-    FRONTMATTER_REGEX = /\A---(.|\n)*?---/
-
-    protected
-
-    def generate_id(*args)
-      parts = args.map { |arg| arg.to_s.force_encoding("UTF-8").parameterize.underscore }
-      parts.join("-").tr("/_", "-").delete_prefix("-").delete_suffix("-").gsub("--", "-")
-    end
-
-    def preview_class_basename(klass)
-      class_name(klass).to_s.chomp("ComponentPreview").chomp("Component::Preview").chomp("::Preview").chomp("Component").chomp("Preview").chomp("::")
-    end
-
-    def preview_class_path(klass)
-      preview_class_basename(klass).underscore
-    end
-
-    def class_name(klass)
-      klass.is_a?(Class) ? klass.name : klass
-    end
-
-    def normalize_matchers(*matchers)
-      matchers.flatten.map { |m| m.gsub(/\s/, "").downcase }
-    end
-
-    def get_position_prefix(str)
-      parse_position_prefix(str).first
-    end
-
-    def remove_position_prefix(str)
-      parse_position_prefix(str).last
-    end
-
-    def to_lookup_path(path)
-      path.split("/").map { |segment| remove_position_prefix(segment) }.join("/")
-    end
-
-    def to_preview_path(*args)
-      args.flatten.map { |arg| preview_class_path(arg) }.join("/")
-    end
-
-    protected
-
-    def default_url_options
-      {}
-    end
-
-    private
-
-    def parse_position_prefix(str)
-      pos = str.match(POSITION_PREFIX_REGEX)
-      if pos.nil?
-        [10000, str]
-      else
-        cleaned_str = str.gsub(POSITION_PREFIX_REGEX, "")
-        [pos[1].to_i, cleaned_str]
-      end
-    end
-  end
-end