lookbook 0.6.1 → 0.7.2.beta.0

data/lib/lookbook/page.rb

@@ -0,0 +1,158 @@
+module Lookbook
+  class Page
+    include Utils
+
+    FRONTMATTER_FIELDS = [
+      :id,
+      :label,
+      :title,
+      :hidden,
+      :landing,
+      :position,
+      :markdown,
+      :header,
+      :footer,
+      :data
+    ]
+
+    attr_reader :errors
+
+    def initialize(path, base_path)
+      @pathname = Pathname.new path
+      @base_path = base_path
+      @errors = []
+    end
+
+    def path
+      rel_path = @pathname.relative_path_from(@base_path)
+      (rel_path.dirname.to_s == "." ? name : "#{rel_path.dirname}/#{name}")
+    end
+
+    def lookup_path
+      @lookup_path ||= to_lookup_path(path)
+    end
+
+    def full_path
+      Rails.root.join(@pathname.to_s)
+    end
+
+    def name
+      remove_position_prefix(path_name)
+    end
+
+    def hidden?
+      options[:hidden] == true
+    end
+
+    def markdown?
+      options[:markdown] == true
+    end
+
+    def header?
+      options[:header] == true
+    end
+
+    def footer?
+      options[:footer] == true
+    end
+
+    def get(key)
+      options[key]
+    end
+
+    def content
+      @content ||= strip_frontmatter(file_contents)
+    end
+
+    def matchers
+      normalize_matchers(label)
+    end
+
+    def hierarchy_depth
+      path.split("/").size
+    end
+
+    def parent_collections_names
+      File.dirname(path).split("/")
+    end
+
+    def type
+      :page
+    end
+
+    def method_missing(method_name, *args, &block)
+      if args.none? && !block
+        options[method_name]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      FRONTMATTER_FIELDS.include? method_name
+    end
+
+    protected
+
+    def file_contents
+      File.read(full_path)
+    end
+
+    def options
+      return @options if @options
+      begin
+        frontmatter = (get_frontmatter(file_contents) || {}).deep_symbolize_keys
+      rescue => exception
+        frontmatter = {}
+        @errors.push(Lookbook::Error.new(exception, {
+          title: "YAML frontmatter parsing error",
+          file_name: @pathname.to_s,
+          line_number: nil
+        }))
+      end
+      options = Lookbook.config.page_options.deep_merge(frontmatter).with_indifferent_access
+      options[:id] = options[:id] ? generate_id(options[:id]) : generate_id(lookup_path)
+      options[:label] ||= name.titleize
+      options[:title] ||= options[:label]
+      options[:hidden] ||= false
+      options[:landing] ||= false
+      options[:position] = options[:position] ? options[:position].to_i : get_position_prefix(path_name)
+      options[:markdown] ||= markdown_file?
+      options[:header] = true unless options.key? :header
+      options[:footer] = true unless options.key? :footer
+      @options ||= options
+    end
+
+    def path_name
+      @pathname.basename(@pathname.extname).to_s.gsub(/\.(html|md)$/, "")
+    end
+
+    def markdown_file?
+      @pathname.basename(@pathname.extname).to_s.end_with?(".md")
+    end
+
+    class << self
+      def find(path)
+        all.find { |p| p.lookup_path == path }
+      end
+
+      def exists?(path)
+        !!find(path)
+      end
+
+      def all
+        pages = Array(page_paths).map do |dir|
+          Dir["#{dir}/**/*.html.*", "#{dir}/**/*.md.*"].sort.map do |page|
+            Lookbook::Page.new(page, dir)
+          end
+        end
+        sorted_pages = pages.flatten.uniq { |p| p.path }.sort_by { |page| [page.position, page.label] }
+        PageCollection.new(sorted_pages)
+      end
+
+      def page_paths
+        Lookbook.config.page_paths.filter { |dir| Dir.exist? dir }
+      end
+    end
+  end
+end

data/lib/lookbook/page_collection.rb

@@ -0,0 +1,11 @@
+module Lookbook
+  class PageCollection < Collection
+    def id
+      generate_id("page-collection", lookup_path || "root")
+    end
+
+    def self.describe_as
+      "pages"
+    end
+  end
+end

data/lib/lookbook/parser.rb

@@ -28,6 +28,8 @@ module Lookbook
         YARD::Tags::Library.define_tag("Hidden status", :hidden)
         YARD::Tags::Library.define_tag("Label", :label)
         YARD::Tags::Library.define_tag("Display", :display)
+        YARD::Tags::Library.define_tag("Position", :position)
+        YARD::Tags::Library.define_tag("ID", :id)
       end
     end
   end

data/lib/lookbook/preview.rb

@@ -1,113 +1,167 @@
 module Lookbook
-  module Preview
-    include Taggable
+  class Preview
+    include Utils
+
+    delegate :name, :render_args, to: :@preview
+    delegate :position, :group, :notes, :hidden?, to: :@preview_inspector
+
+    def initialize(preview)
+      @preview = preview
+      @preview_inspector = CodeInspector.new(@preview.name)
+    end
 
     def id
-      lookbook_path.tr("/", "-").tr("_", "-")
+      @preview_inspector&.id || generate_id(lookup_path)
+    end
+
+    def preview_class
+      @preview.name
     end
 
-    # Examples::FooBarComponent::Preview -> "Foo Bar"
-    def lookbook_label
-      super.presence || lookbook_path.split("/").last.titleize
+    def label
+      @preview_inspector&.label&.presence || lookup_path.split("/").last.titleize
     end
 
-    def lookbook_type
+    def type
       :preview
     end
 
-    def lookbook_example(example_name)
-      lookbook_examples.find { |m| m.name == example_name }
+    def example(example_name)
+      examples.find { |m| m.name == example_name.to_s }
     end
 
-    def lookbook_examples
-      return @lookbook_examples if @lookbook_examples.present?
-      public_methods = public_instance_methods(false)
-      public_method_objects = code_object.meths.filter { |m| public_methods.include?(m.name) }
-      examples = public_method_objects.map { |m| PreviewExample.new(m.name.to_s, self) }
+    def examples
+      return @examples if @examples.present?
+      public_methods = @preview.public_instance_methods(false)
+      public_method_objects = @preview_inspector&.methods&.filter { |m| public_methods.include?(m.name) }
+      examples = (public_method_objects || []).map { |m| PreviewExample.new(m.name.to_s, self) }
       sorted = Lookbook.config.sort_examples ? examples.sort_by(&:label) : examples
-      @lookbook_examples = []
-      if code_object.groups.any?
+      @examples = []
+      if @preview_inspector&.groups&.any?
         sorted.group_by { |m| m.group }.each do |name, examples|
           if name.nil?
-            @lookbook_examples += examples
+            @examples += examples
           else
-            name = lookbook_label if name.strip == ""
-            @lookbook_examples << PreviewGroup.new(name.underscore, self, examples)
+            name = label if name.strip == ""
+            @examples << PreviewGroup.new(name.underscore, self, examples)
           end
         end
       else
-        @lookbook_examples = sorted
+        @examples = sorted
       end
-      @lookbook_examples
+      @examples = @examples.compact
     end
 
-    # Examples::FooBarComponentPreview -> "Examples::FooBar"
-    # Examples::FooBarComponent::Preview -> "Examples::FooBar"
-    def lookbook_name
-      name.chomp("ComponentPreview").chomp("Component::Preview").chomp("::Preview").chomp("::")
+    def default_example
+      examples.first
     end
 
-    # Examples::FooBarComponentPreview -> "examples/foo_bar"
-    # Examples::FooBarComponent::Preview -> "examples/foo_bar"
-    def lookbook_path
-      lookbook_name.underscore
+    def path
+      preview_class_name(preview_class_basename(name))
     end
 
-    # Examples::FooBarComponentPreview -> "/Users/myname/myapp/test/components/previews/examples/foo_bar_component_preview.rb"
-    # Examples::FooBarComponent::Preview -> "/Users/myname/myapp/test/components/previews/examples/foo_bar/component_preview.rb"
-    def lookbook_full_path
+    def full_path
       base_path = Array(preview_paths).detect do |preview_path|
         Dir["#{preview_path}/#{name.underscore}.rb"].first
       end
       Pathname.new(Dir["#{base_path}/#{name.underscore}.rb"].first)
     end
 
-    def lookbook_parent_collections
-      File.dirname(lookbook_path).split("/")
+    def preview_paths
+      ViewComponent::Preview.preview_paths
     end
 
-    def lookbook_hierarchy_depth
-      lookbook_path.split("/").size
+    def parent_collections_names
+      File.dirname(path).split("/")
     end
 
-    def lookbook_id
-      lookbook_path.tr("/", "-").tr("_", "-")
+    def hierarchy_depth
+      path.split("/").size
     end
 
-    def lookbook_layout
-      defined?(@layout) ? @layout : nil
+    def layout
+      @preview.instance_variable_get(:@layout)
     end
 
     def display_params
-      Lookbook.config.preview_display_params.deep_merge(lookbook_display_params)
+      Lookbook.config.preview_display_params.deep_merge(@preview_inspector&.display_params)
     end
 
     class << self
-      def all
-        ViewComponent::Preview.all.sort_by(&:label)
-      end
-
       def find(path)
-        all.find { |p| p.lookbook_path == path }
+        all.find { |p| p.lookup_path == path }
       end
 
       def exists?(path)
         !!find(path)
       end
-    end
 
-    private
+      def all
+        previews = load_previews.map do |p|
+          new(p)
+        rescue
+          Rails.logger.error "[lookbook] error instantiating preview\n#{exception.full_message}"
+        end
+
+        sorted_previews = previews.compact.sort_by { |preview| [preview.position, preview.label] }
+        PreviewCollection.new(sorted_previews)
+      end
+
+      def errors
+        @errors || []
+      end
 
-    def taggable_object_path
-      name
+      def reload
+        load_previews
+      end
+
+      protected
+
+      def reset_files_data
+        @loaded_files = []
+        @errors = []
+      end
+
+      def load_previews
+        reset_files_data if @loaded_files.nil?
+        require_preview_files if @errors.any?
+
+        preview_classes = ViewComponent::Preview.descendants
+        if preview_files.size > preview_classes.size
+          require_preview_files
+        end
+
+        ViewComponent::Preview.descendants.filter { |klass| @loaded_files.include? "#{klass.name.underscore}.rb" }
+      end
+
+      def require_preview_files
+        reset_files_data
+        preview_files.each do |file|
+          require_dependency(file[:path])
+          @loaded_files.push(file[:rel_path])
+        rescue => exception
+          Rails.logger.error "[lookbook] preview error\n#{exception.full_message}\n"
+          @errors.push(Lookbook::Error.new(exception, {
+            title: "Preview #{exception.class}",
+            file_name: file[:rel_path]
+          }))
+        end
+      end
+
+      def preview_files
+        files = Array(Lookbook.config.preview_paths).map do |preview_path|
+          Dir["#{preview_path}/**/*_preview.rb"].map do |path|
+            {
+              path: path,
+              base_path: preview_path,
+              rel_path: Pathname(path).relative_path_from(preview_path).to_s
+            }
+          end
+        end
+        files.flatten
+      end
     end
 
-    alias_method :label, :lookbook_label
-    alias_method :notes, :lookbook_notes
-    alias_method :hidden?, :lookbook_hidden?
-    alias_method :type, :lookbook_type
-    alias_method :example, :lookbook_example
-    alias_method :get_examples, :lookbook_examples
-    alias_method :hierarchy_depth, :lookbook_hierarchy_depth
+    alias_method :lookup_path, :path
   end
 end

data/lib/lookbook/preview_collection.rb

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

data/lib/lookbook/preview_example.rb

@@ -1,38 +1,34 @@
 module Lookbook
   class PreviewExample
-    include Taggable
+    include Utils
 
-    attr_reader :name
+    attr_reader :name, :preview
+    delegate :params, :position, :group, :notes, :hidden?, to: :@example_inspector
 
     def initialize(name, preview)
       @name = name
       @preview = preview
+      @example_inspector = CodeInspector.new("#{@preview.name}##{name}")
     end
 
     def id
-      path.underscore.tr("/", "-").tr("_", "-")
+      generate_id(@preview.id, name)
     end
 
     def path
-      "#{@preview.lookbook_path}/#{name}"
+      "#{@preview.path}/#{name}"
     end
 
     def label
-      lookbook_label.presence || name.titleize
+      @example_inspector.label.presence || name.titleize
     end
 
     def display_params
-      @preview.display_params.merge(lookbook_display_params)
-    end
-
-    def params
-      @params || code_object&.tags("param")&.map do |param|
-        Lookbook::Params.build_param(param, parameter_defaults[param.name])
-      end
+      @preview.display_params.merge(@example_inspector.display_params)
     end
 
     def method_source
-      code_object.source.split("\n")[1..-2].join("\n").strip_heredoc
+      @example_inspector.source.split("\n")[1..-2].join("\n").strip_heredoc
     end
 
     def source_lang
@@ -52,24 +48,14 @@ module Lookbook
     end
 
     def matchers
-      [@preview.label, label].map { |m| m.gsub(/\s/, "").downcase }
+      normalize_matchers(@preview.label, label)
     end
 
     def hierarchy_depth
-      @preview.lookbook_hierarchy_depth + 1
+      @preview.hierarchy_depth + 1
     end
 
-    private
-
-    def parameter_defaults
-      @parameter_defaults || code_object&.parameters&.map do |param_str|
-        Lookbook::Params.parse_method_param_str(param_str)
-      end&.compact&.to_h
-    end
-
-    def taggable_object_path
-      "#{@preview.name}##{name}"
-    end
+    protected
 
     def full_template_path(template_path)
       base_path = Array(Lookbook.config.preview_paths).detect do |p|
@@ -78,8 +64,20 @@ module Lookbook
       Pathname.new(Dir["#{base_path}/#{template_path}.html.*"].first)
     end
 
-    alias_method :group, :lookbook_group
-    alias_method :notes, :lookbook_notes
-    alias_method :hidden?, :lookbook_hidden?
+    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,8 +1,8 @@
 module Lookbook
   class PreviewGroup
-    include Taggable
+    include Utils
 
-    attr_reader :name, :examples
+    attr_reader :name, :examples, :preview
 
     def initialize(name, preview, examples)
       @name = name
@@ -11,11 +11,11 @@ module Lookbook
     end
 
     def id
-      path.underscore.tr("/", "-").tr("_", "-")
+      generate_id(lookup_path)
     end
 
     def path
-      "#{@preview.lookbook_path}/#{name}"
+      "#{@preview.path}/#{name}"
     end
 
     def label
@@ -38,12 +38,18 @@ module Lookbook
       false
     end
 
+    def position
+      10000
+    end
+
     def matchers
-      [@preview.label, label].map { |m| m.gsub(/\s/, "").downcase }
+      normalize_matchers(@preview.label, label)
     end
 
     def hierarchy_depth
-      @preview.lookbook_hierarchy_depth + 1
+      @preview.hierarchy_depth + 1
     end
+
+    alias_method :lookup_path, :path
   end
 end

data/lib/lookbook/utils.rb

@@ -0,0 +1,74 @@
+module Lookbook
+  module Utils
+    POSITION_PREFIX_REGEX = /^(\d+?)[-_]/
+    FRONTMATTER_REGEX = /\A---(.|\n)*?---/
+
+    protected
+
+    def generate_id(*args)
+      parts = args.map { |arg| arg.to_s.parameterize.underscore }
+      parts.join("-").tr("/", "-").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("::")
+    end
+
+    def preview_class_name(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 get_frontmatter(str)
+      parse_frontmatter(str).first
+    end
+
+    def strip_frontmatter(str)
+      parse_frontmatter(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_name(arg) }.join("/")
+    end
+
+    private
+
+    def parse_frontmatter(content)
+      frontmatter = content.match(FRONTMATTER_REGEX)
+      if frontmatter.nil?
+        [{}, content]
+      else
+        [YAML.safe_load(frontmatter[0]), content.gsub(FRONTMATTER_REGEX, "")]
+      end
+    end
+
+    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

data/lib/lookbook/version.rb

@@ -1,3 +1,3 @@
 module Lookbook
-  VERSION = "0.6.1"
+  VERSION = "0.7.2.beta.0"
 end

data/lib/lookbook.rb

@@ -5,16 +5,34 @@ require "lookbook/version"
 module Lookbook
   extend ActiveSupport::Autoload
 
+  autoload :Error, "lookbook/error"
+  autoload :Utils, "lookbook/utils"
   autoload :Lang, "lookbook/lang"
   autoload :Params, "lookbook/params"
+  autoload :Page, "lookbook/page"
+  autoload :PageCollection, "lookbook/page_collection"
   autoload :Features, "lookbook/features"
   autoload :Collection, "lookbook/collection"
   autoload :Parser, "lookbook/parser"
   autoload :Preview, "lookbook/preview"
+  autoload :PreviewCollection, "lookbook/preview_collection"
   autoload :PreviewController, "lookbook/preview_controller"
   autoload :PreviewExample, "lookbook/preview_example"
   autoload :PreviewGroup, "lookbook/preview_group"
-  autoload :Taggable, "lookbook/taggable"
+  autoload :CodeInspector, "lookbook/code_inspector"
   autoload :NullLogger, "lookbook/null_logger"
   autoload :CodeFormatter, "lookbook/code_formatter"
+  autoload :Markdown, "lookbook/markdown"
+
+  class << self
+    include Utils
+
+    def previews
+      Preview.all
+    end
+
+    def pages
+      Page.all
+    end
+  end
 end