lookbook 1.3.4 → 1.4.1

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 = [Rails.root, *Array(base_directories)].map(&:to_s).sort_by(&:length).reverse
+        @_base_directory ||= directories.first { |dir| file_path.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(\..*)$/, "")
+
+      @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

data/lib/lookbook/entities/preview_group.rb

@@ -0,0 +1,48 @@
+module Lookbook
+  class PreviewGroup < Entity
+    include Navigable
+
+    attr_reader :examples, :preview
+
+    def initialize(name, examples, preview)
+      @name = Utils.name(name)
+      @examples = PreviewExampleCollection.new(examples)
+      @preview = preview
+      @lookup_path = "#{parent.lookup_path}/#{@name}"
+    end
+
+    def display_options
+      merged = {}
+      examples.to_a.reverse.map do |example|
+        merged.merge!(example.display_options)
+      end
+      merged
+    end
+
+    def components
+      @_components ||= ComponentCollection.new(examples.flat_map(&:components).uniq(&:path))
+    end
+
+    def search_terms
+      [parent.label, label]
+    end
+
+    def tags(tag_name = nil)
+      examples.flat_map { |example| example.tags(tag_name) }
+    end
+
+    def tag(tag_name = nil)
+      tags(tag_name).first
+    end
+
+    def url_path
+      lookbook_inspect_path(path)
+    end
+
+    def type
+      :group
+    end
+
+    alias_method :parent, :preview
+  end
+end

data/lib/lookbook/file_watcher.rb

@@ -8,7 +8,7 @@ module Lookbook
     end
 
     def watch(paths, extensions = ".*", opts = nil, &block)
-      paths = PathUtils.normalize_all(paths)
+      paths = PathUtils.normalize_paths(paths)
 
       if paths.any?
         opts = opts.to_h

data/lib/lookbook/lang.rb

@@ -1,46 +1,23 @@
 module Lookbook
   module Lang
     class << self
-      LANGUAGES = [
-        {
-          name: "ruby",
-          ext: ".rb",
-          label: "Ruby",
-          comment: "# %s"
-        },
-        {
-          name: "html",
-          ext: ".html",
-          label: "HTML",
-          comment: "<!-- %s -->"
-        },
-        {
-          name: "erb",
-          ext: ".erb",
-          label: "ERB",
-          comment: "<%%# %s %%>"
-        },
-        {
-          name: "haml",
-          ext: ".haml",
-          label: "Haml",
-          comment: "<!-- %s -->"
-        },
-        {
-          name: "slim",
-          ext: ".slim",
-          label: "Slim",
-          comment: "<!-- %s -->"
-        }
-      ]
+      CONFIG_FILE = "config/languages.yml"
+      LANGUAGES = [] # retained for backwards compatability
 
       def find(name)
-        LANGUAGES.find { |l| l[:name] == name.to_s }
+        languages.find { |l| l[:name] == name.to_s }
       end
 
-      def guess(path)
+      def guess(path, fallback_name = nil)
         ext = File.extname(path)
-        LANGUAGES.find { |l| l[:ext] == ext }
+        lang = languages.find { |l| l[:ext] == ext }
+        lang || (find(fallback_name) if fallback_name)
+      end
+
+      protected
+
+      def languages
+        @_languages ||= [*ConfigLoader.call(CONFIG_FILE).definitions, *LANGUAGES]
       end
     end
   end

data/lib/lookbook/param.rb

@@ -33,10 +33,10 @@ module Lookbook
     end
 
     def input_options
-      return @input_options if @input_options
+      return @_input_options if @_input_options
 
       runtime_options = options.except([*methods, :name, :value_default, :description])
-      @input_options ||= Store.new(input_config.options.merge(runtime_options))
+      @_input_options ||= Store.new(input_config.options.merge(runtime_options))
     end
 
     def input_partial

data/lib/lookbook/preview_parser.rb

@@ -26,7 +26,7 @@ module Lookbook
     end
 
     def paths
-      PathUtils.normalize_all(@paths).map { |path| "#{path}/**/*preview.rb" }
+      PathUtils.normalize_paths(@paths).map { |path| "#{path}/**/*preview.rb" }
     end
 
     protected

data/lib/lookbook/rendered_example.rb

@@ -0,0 +1,37 @@
+module Lookbook
+  class RenderedExample
+    delegate_missing_to :example
+
+    attr_reader :output, :example
+
+    def initialize(example, output, params)
+      @example = example
+      @params = params
+      @output = output
+    end
+
+    def source
+      has_custom_template? ? template_source(template) : example.source
+    end
+
+    def source_lang
+      has_custom_template? ? template_lang(template) : example.source_lang
+    end
+
+    protected
+
+    attr_reader :params
+
+    def render_args
+      @_render_args ||= preview.render_args(example.name, params: params)
+    end
+
+    def template
+      render_args[:template]
+    end
+
+    def has_custom_template?
+      template != "view_components/preview" && !custom_source?
+    end
+  end
+end

data/lib/lookbook/services/code/code_indenter.rb

@@ -0,0 +1,14 @@
+module Lookbook
+  class CodeIndenter < Service
+    def initialize(source)
+      @source = source.to_s
+    end
+
+    def call
+      source = @source.chomp
+      last = source.split(/\r?\n/).last
+      indent = last ? last[/^([ \t]*)/, 1].length : 0
+      source.gsub(/^[ \t]{#{indent}}/, "")
+    end
+  end
+end

data/lib/lookbook/services/data/resolvers/data_resolver.rb

@@ -11,8 +11,8 @@ module Lookbook
       @permit_eval = permit_eval
       @fail_silently = fail_silently
       @fallback = fallback
-      @base_dir = base_dir
-      @file = file
+      @base_dir = base_dir.to_s
+      @file = file.to_s
     end
 
     def call

data/lib/lookbook/services/data/resolvers/file_resolver.rb

@@ -22,7 +22,7 @@ module Lookbook
     end
 
     def resolve_path(path, base_dir)
-      path.start_with?(".") ? File.expand_path(path, base_dir) : Rails.root.join(path)
+      Pathname(path.start_with?(".") ? File.expand_path(path, base_dir) : Rails.root.join(path))
     end
   end
 end