lookbook 1.2.1 → 1.4.5

data/lib/lookbook/services/entities/entity_tree_builder.rb

@@ -0,0 +1,45 @@
+module Lookbook
+  class EntityTreeBuilder < Service
+    attr_reader :include_hidden
+
+    def initialize(entities, include_hidden: false)
+      @entities = entities.to_a
+      @include_hidden = include_hidden
+    end
+
+    def call
+      root_node = TreeNode.new
+      entities.each do |entity|
+        current_node = root_node
+        path_segments = parse_segments(entity.logical_path)
+        path_segments.each.with_index(1) do |segment, i|
+          name, position_prefix = segment
+          content = entity if entity.depth == i # entities are always on the leaf nodes
+
+          current_node.add_child(name, content, position: position_prefix) unless current_node.has_child?(name)
+          current_node = current_node.get_child(name)
+
+          if content && content.type == :preview
+            content.visible_examples.each do |example|
+              current_node.add_child(example.name, example)
+            end
+          end
+        end
+      end
+      root_node
+    end
+
+    def parse_segments(path)
+      path.split("/").map do |segment|
+        unless segment.start_with?(".")
+          position, name = PositionPrefixParser.call(segment)
+          [name, position || 10000]
+        end
+      end.compact
+    end
+
+    def entities
+      include_hidden ? @entities : @entities.select(&:visible?)
+    end
+  end
+end

data/lib/lookbook/services/markdown_renderer.rb

@@ -0,0 +1,29 @@
+require "redcarpet"
+
+module Lookbook
+  class MarkdownRenderer < Service
+    attr_reader :text, :opts
+
+    def initialize(text, opts = {})
+      @text = text
+      @opts = opts.to_h
+    end
+
+    def call
+      clean_text = ActionViewAnnotationsStripper.call(text)
+      md = Redcarpet::Markdown.new(LookbookMarkdownRenderer, opts)
+      md.render(clean_text).html_safe
+    end
+
+    class LookbookMarkdownRenderer < Redcarpet::Render::HTML
+      def block_code(code, language = "ruby")
+        line_numbers = language.to_s.end_with? "-numbered"
+        ApplicationController.render(Lookbook::Code::Component.new(**{
+          source: code,
+          language: language.to_s.chomp("-numbered"),
+          line_numbers: line_numbers
+        }), layout: nil)
+      end
+    end
+  end
+end

data/lib/lookbook/services/position_prefix_parser.rb

@@ -0,0 +1,16 @@
+module Lookbook
+  class PositionPrefixParser < Service
+    POSITION_PREFIX_REGEX = /^(\d+?)[-_]/
+
+    attr_reader :input
+
+    def initialize(input)
+      @input = String(input)
+    end
+
+    def call
+      matches = input.match(POSITION_PREFIX_REGEX)
+      matches ? [matches[1].to_i, input.gsub(POSITION_PREFIX_REGEX, "")] : [nil, input]
+    end
+  end
+end

data/lib/lookbook/services/string_value_caster.rb

@@ -0,0 +1,60 @@
+require "active_model"
+
+module Lookbook
+  class StringValueCaster < Service
+    def initialize(value, type = "string")
+      @value = value.to_s
+      @type = type.to_s.downcase
+      @cast_method = :"cast_to_#{@type}"
+
+      unless respond_to?(@cast_method)
+        raise ArgumentError.new "'#{@type}' is not a valid value type to cast to."
+      end
+    end
+
+    def call
+      return @nil if @value.empty?
+      public_send(@cast_method)
+    rescue => exception
+      Lookbook.logger.debug "Failed to parse '#{@value}' into a '#{@type}' [#{exception}]"
+      raise exception
+    end
+
+    def cast_to_string
+      @value
+    end
+
+    def cast_to_symbol
+      @value.delete_prefix(":").to_sym if @value.present?
+    end
+
+    def cast_to_hash
+      result = YamlParser.call(@value)
+      unless result.is_a?(Hash)
+        raise ParserError.new "'#{@value}' is not a YAML Hash"
+      end
+      result
+    end
+
+    def cast_to_array
+      result = YamlParser.call(@value)
+      unless result.is_a?(Array)
+        raise ParserError.new "'#{@value}' is not a YAML Array"
+      end
+      result
+    end
+
+    def cast_to_datetime
+      DateTime.parse(@value)
+    end
+
+    def active_model_cast
+      type_class = "ActiveModel::Type::#{@type.camelize}".constantize
+      type_class.new.cast(@value)
+    end
+
+    alias_method :cast_to_boolean, :active_model_cast
+    alias_method :cast_to_integer, :active_model_cast
+    alias_method :cast_to_float, :active_model_cast
+  end
+end

data/lib/lookbook/services/tags/tag_options_parser.rb

@@ -0,0 +1,62 @@
+module Lookbook
+  class TagOptionsParser < Service
+    RESOLVERS = [
+      FileResolver,
+      MethodResolver,
+      EvalResolver,
+      YamlResolver
+    ]
+
+    def initialize(input, resolver_opts = {})
+      @input = input.to_s.strip
+      @resolver_opts = resolver_opts
+      @fallback = resolver_opts.fetch(:fallback, {})
+    end
+
+    def call
+      options_string, remaining_text = parse_input(@input)
+      resolved_options = resolver(options_string).call(options_string, **@resolver_opts)
+      options = prepare_options(resolved_options)
+      [options, remaining_text]
+    end
+
+    protected
+
+    def resolver(options_string)
+      if options_string.present?
+        handler = RESOLVERS.find { |r| r.resolveable?(options_string) }
+        if handler.nil?
+          Lookbook.logger.error "Invalid tag options string '#{options_string}'"
+          method(:fallback_resolver)
+        else
+          handler
+        end
+      else
+        method(:fallback_resolver)
+      end
+    end
+
+    def fallback_resolver(*args)
+      @fallback
+    end
+
+    def parse_input(input)
+      matchers.each_with_object(["", input]) do |matcher, result|
+        input.match(matcher) do |match_data|
+          result[0] = match_data[1] # options string
+          result[1] = input.gsub(matcher, "").strip # any remaining text
+          return result
+        end
+      end
+    end
+
+    def matchers
+      RESOLVERS.map { |r| r::MATCHER }
+    end
+
+    def prepare_options(options)
+      options = options.is_a?(Array) ? {choices: options} : options
+      options.is_a?(Hash) ? Store.new(options) : options
+    end
+  end
+end

data/lib/lookbook/services/templates/action_view_annotations_handler.rb

@@ -0,0 +1,21 @@
+module Lookbook
+  class ActionViewAnnotationsHandler < Service
+    attr_reader :disable_annotations
+
+    def initialize(disable_annotations: true)
+      @disable_annotations = disable_annotations
+    end
+
+    def call
+      if ActionView::Base.respond_to?(:annotate_rendered_view_with_filenames) && disable_annotations
+        original_value = ActionView::Base.annotate_rendered_view_with_filenames
+        ActionView::Base.annotate_rendered_view_with_filenames = false
+        res = yield
+        ActionView::Base.annotate_rendered_view_with_filenames = original_value
+        res
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/lookbook/services/templates/action_view_annotations_stripper.rb

@@ -0,0 +1,15 @@
+module Lookbook
+  class ActionViewAnnotationsStripper < Service
+    attr_reader :text
+
+    ANNOTATIONS_REGEX = /<!-- (BEGIN|END) (.*) -->/
+
+    def initialize(text)
+      @text = text.to_s
+    end
+
+    def call
+      text.gsub(ANNOTATIONS_REGEX, "")
+    end
+  end
+end

data/lib/lookbook/services/templates/frontmatter_extractor.rb

@@ -0,0 +1,28 @@
+module Lookbook
+  class FrontmatterExtractor < Service
+    FRONTMATTER_REGEX = /\A---(.|\n)*?---/
+
+    attr_reader :content
+
+    def initialize(content)
+      @content = content.to_s
+    end
+
+    def call
+      frontmatter = extract_frontmatter(content)
+      rest = strip_frontmatter(content)
+      [frontmatter, rest]
+    end
+
+    protected
+
+    def extract_frontmatter(text)
+      matches = text.match(FRONTMATTER_REGEX)
+      matches ? YAML.safe_load(matches[0]).deep_symbolize_keys : {}
+    end
+
+    def strip_frontmatter(text)
+      text.gsub(FRONTMATTER_REGEX, "").strip
+    end
+  end
+end

data/lib/lookbook/services/templates/styles_extractor.rb

@@ -0,0 +1,38 @@
+require "css_parser"
+
+module Lookbook
+  class StylesExtractor < Service
+    STYLE_TAGS_REGEX = /<style(?:\s[^>]*)?>((?:(?!<\/style>).)*)<\/style>/m
+
+    attr_reader :content
+
+    def initialize(content)
+      @content = content.to_s
+    end
+
+    def call
+      styles = extract_styles(content)
+      rest = strip_styles(content)
+      [styles, rest]
+    end
+
+    protected
+
+    def extract_styles(text)
+      css_parser = ::CssParser::Parser.new
+      text.scan(STYLE_TAGS_REGEX).flatten.map(&:strip).each do |css|
+        css_parser.load_string!(css.strip)
+      end
+
+      styles = []
+      css_parser.each_selector do |selector, declarations, specificity|
+        styles << "#{selector} { #{declarations} }"
+      end
+      styles
+    end
+
+    def strip_styles(text)
+      text.gsub(STYLE_TAGS_REGEX, "").strip
+    end
+  end
+end

data/lib/lookbook/services/{search_param_builder.rb → urls/search_param_builder.rb}

@@ -7,7 +7,7 @@ module Lookbook
     end
 
     def call
-      data.map { "#{_1}:#{_2}" }.join("|")
+      data.map { |k, v| "#{k}:#{v}" }.join("|")
     end
   end
 end

data/lib/lookbook/services/{search_param_parser.rb → urls/search_param_parser.rb}

@@ -8,7 +8,7 @@ module Lookbook
 
     def call
       pairs_str = param_value.split("|")
-      pairs = pairs_str.map { [*_1.split(":").map(&:strip)] }
+      pairs = pairs_str.map { |pair| [*pair.split(":").map(&:strip)] }
       pairs.to_h.symbolize_keys
     end
   end

data/lib/lookbook/stores/config_store.rb

@@ -10,17 +10,19 @@ module Lookbook
     end
 
     def project_name=(name)
-      store[:project_name] = name == false ? nil : name
+      store[:project_name] = (name == false) ? nil : name
     end
 
     def page_paths=(paths = nil)
-      store[:page_paths] ||= []
-      store[:page_paths] += paths.to_a
+      store[:page_paths].push(*paths.to_a)
+    end
+
+    def page_extensions=(extensions = nil)
+      store[:page_extensions].push(*extensions.to_a).uniq!
     end
 
     def preview_paths=(paths = nil)
-      store[:preview_paths] ||= []
-      store[:preview_paths] += paths.to_a
+      store[:preview_paths].push(*paths.to_a)
     end
 
     def preview_display_params
@@ -34,16 +36,17 @@ module Lookbook
     end
 
     def listen_extensions=(extensions = nil)
-      store[:listen_extensions] ||= []
-      store[:listen_extensions] += extensions.to_a
-      store[:listen_extensions].uniq!
+      store[:listen_extensions].push(*extensions.to_a).uniq!
     end
 
     def markdown_options=(options = nil)
-      store[:markdown_options] ||= {}
       store[:markdown_options].merge!(options.to_h)
     end
 
+    def highlighter_options=(options = nil)
+      store[:highlighter_options].merge!(options.to_h)
+    end
+
     def ui_theme=(name)
       name = name.to_s
       if Theme.valid_theme?(name)

data/lib/lookbook/stores/input_store.rb

@@ -18,11 +18,11 @@ module Lookbook
     end
 
     def add_input(input, *args)
-      store[input.to_sym] = build_config(input, *args)
+      store[normalize_name(input)] = build_config(input, *args)
     end
 
     def get_input(input)
-      store[input.to_sym]
+      store[normalize_name(input)]
     end
 
     def self.init_from_config
@@ -35,6 +35,10 @@ module Lookbook
 
     protected
 
+    def normalize_name(name)
+      name.to_s.tr("-", "_").to_sym
+    end
+
     def build_config(name, *args)
       partial = nil
       opts = nil
@@ -48,7 +52,7 @@ module Lookbook
         Store.new({
           name: name.to_sym,
           partial: partial,
-          opts: DEFAULTS.merge(opts.to_h)
+          options: DEFAULTS.merge(opts.to_h)
         })
       else
         raise ConfigError.new("inputs must define a partial path", scope: "inputs.config")

data/lib/lookbook/stores/panel_store.rb

@@ -96,7 +96,7 @@ module Lookbook
       config.each do |group, panels|
         panels.map! do |opts|
           opts.transform_values! do |value|
-            value.is_a?(String) && value.start_with?("->") ? eval(value) : value # standard:disable Security/Eval
+            (value.is_a?(String) && value.start_with?("->")) ? eval(value) : value # standard:disable Security/Eval
           end
         end
       end
@@ -111,7 +111,7 @@ module Lookbook
     end
 
     def insert_index(position, items_count)
-      index = position == 0 ? 1 : (position || 0).to_int
+      index = (position == 0) ? 1 : (position || 0).to_int
       last_position = items_count + 1
       index = last_position if index > last_position
       index - 1

data/lib/lookbook/stores/tag_store.rb

@@ -7,7 +7,7 @@ module Lookbook
 
     def initialize(config = nil)
       @store = {}
-      config.to_h.each { add_tag(_1, _2) }
+      config.to_h.each { |k, v| add_tag(k, v) }
     end
 
     def add_tag(name, opts = nil)
@@ -34,12 +34,10 @@ module Lookbook
     protected
 
     def build_config(name, opts = nil)
-      opts = opts.to_h
       Store.new({
         name: name.to_sym,
-        label: opts[:label] || name.to_s.titleize,
-        yard_parser: opts[:yard_parser]&.to_sym,
-        opts: opts[:opts].to_h
+        label: name.to_s.titleize,
+        options: opts.to_h
       })
     end
   end

data/lib/lookbook/support/null_object.rb

@@ -0,0 +1,10 @@
+module Lookbook
+  class NullObject < BasicObject
+    def method_missing(*)
+    end
+
+    def respond_to_missing?(name)
+      true
+    end
+  end
+end

data/lib/lookbook/support/service.rb

@@ -1,7 +1,7 @@
 module Lookbook
   class Service
-    def self.call(*args, **kwargs)
-      new(*args, **kwargs).call
+    def self.call(*args, **kwargs, &block)
+      new(*args, **kwargs).call(&block)
     end
   end
 end

data/lib/lookbook/support/store.rb

@@ -3,7 +3,7 @@ module Lookbook
     def initialize(initial_data = nil, opts = {})
       @recursive = opts[:recursive] || false
       super()
-      initial_data.to_h.each { self[_1] = _2 }
+      initial_data.to_h.each { |k, v| self[k] = v }
     end
 
     def []=(key, value)
@@ -25,39 +25,6 @@ module Lookbook
       true
     end
 
-    # def [](key)
-    #   key = key.to_sym
-    #   if respond_to? key
-    #     public_send(key)
-    #   else
-    #     self[key]
-    #   end
-    # end
-
-    # def []=(key, value)
-    #   setter_key = "#{key}=".to_sym
-    #   if respond_to? setter_key
-    #     public_send(setter_key, value)
-    #   else
-    #     _set(key.to_sym, normalize_value(value))
-    #   end
-    # end
-
-    # def method_missing(key, *args)
-    #   if key.to_s.end_with?("=")
-    #     args[0] = normalize_value(args[0])
-    #   end
-    #   public_send(key.to_sym, *args)
-    # end
-
-    # def respond_to_missing?(key, *args)
-    #   key?(key.to_sym)
-    # end
-
-    # def fetch(key, *args)
-    #   super.fetch(key.to_sym, *args)
-    # end
-
     def to_h
       transform_values do |value|
         value.is_a?(Store) ? value.to_h : value
@@ -71,7 +38,7 @@ module Lookbook
     protected
 
     def normalize_value(value)
-      @recursive && !value.is_a?(Store) && value.is_a?(Hash) ? Store.new(value, recursive: @recursive) : value
+      (@recursive && !value.is_a?(Store) && value.is_a?(Hash)) ? Store.new(value, recursive: @recursive) : value
     end
   end
 end

data/lib/lookbook/support/tree_node.rb

@@ -0,0 +1,87 @@
+module Lookbook
+  class TreeNode
+    include Enumerable
+    include Comparable
+
+    delegate_missing_to :content
+
+    attr_accessor :path, :content
+    attr_reader :children
+
+    def initialize(path = nil, content = nil, position: 10000)
+      @path = path.to_s
+      @content = content
+      @position = position
+      @children = []
+    end
+
+    def id
+      Utils.id(content_value(:id, path))
+    end
+
+    def name
+      segments.last
+    end
+
+    def label
+      content_value(:label, name.titleize)
+    end
+
+    def position
+      content_value(:position, @position)
+    end
+
+    def type
+      content_value(:type, :directory)
+    end
+
+    def depth
+      path.split("/").size
+    end
+
+    def add_child(name, content = nil, position: 10000)
+      children << TreeNode.new("#{path}/#{name}", content, position: position)
+    end
+
+    def has_child?(name)
+      !!get_child(name)
+    end
+
+    def get_child(name)
+      children.find { |child| child.name == name }
+    end
+
+    def content?
+      content.present?
+    end
+
+    def each(&block)
+      if block
+        children.sort.each do |child|
+          yield child
+        end
+      else
+        to_enum(:each)
+      end
+    end
+
+    def <=>(other)
+      if content?
+        content <=> (other.content? ? other.content : other)
+      else
+        [position, label] <=> [other.position, other.label]
+      end
+    end
+
+    protected
+
+    def content_value(method_name, fallback = nil)
+      value = content.send(method_name) if content
+      value || fallback
+    end
+
+    def segments
+      path.split("/")
+    end
+  end
+end

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

@@ -5,15 +5,42 @@ module Lookbook
         File.absolute_path(path.to_s, Rails.root)
       end
 
-      def normalize_all(paths, allow_root: false)
-        root = Rails.application.root.to_s
-        paths.map do |path|
+      def to_lookup_path(file_path)
+        path = file_path.to_s.downcase
+
+        directory_path = File.dirname(path)
+        directory_path = nil if directory_path.start_with?(".")
+
+        file_name = File.basename(path).split(".").first
+
+        segments = [*directory_path&.split("/"), file_name].compact
+        stripped_segments = segments.map! do |segment|
+          PositionPrefixParser.call(segment).last.tr("-", "_")
+        end
+
+        to_path(stripped_segments)
+      end
+
+      def to_path(*args)
+        args.flatten.compact.map(&:to_s).join("/")
+      end
+
+      def normalize_paths(paths, allow_root: false)
+        Array(paths).map do |path|
           full_path = to_absolute(path)
-          if Dir.exist?(full_path)
-            full_path if allow_root || full_path.to_s != root
+          if File.exist?(full_path)
+            full_path if allow_root || !root_path?(full_path)
           end
         end.compact.uniq
       end
+
+      def root_path?(path)
+        Rails.application.root.to_s == path.to_s
+      end
+
+      def strip_slashes(path)
+        path.to_s.gsub(/\A\/|\/\z/, "")
+      end
     end
   end
 end