lookbook 2.3.1 → 3.0.0.alpha.1

data/lib/lookbook/previews/tags/param_tag.rb

@@ -0,0 +1,85 @@
+require "strscan"
+
+module Lookbook
+  class ParamTag < YardTag
+    TAG_NAME = "param"
+
+    def param_name
+      parts[:param_name].to_sym
+    end
+
+    def value_type
+      if parts[:value_types].any?
+        parts[:value_types].first.strip.downcase.to_sym
+      end
+    end
+
+    def input_type
+      parts[:input_type]&.to_sym
+    end
+
+    def description
+      parts[:description]
+    end
+
+    def options_str
+      parts[:options] || super
+    end
+
+    def parts
+      @parts ||= scan_text
+    end
+
+    def value
+      raise "@param tags do not have a value"
+    end
+
+    private
+
+    def scan_text
+      parts = {}
+      scanner = StringScanner.new(@text.strip)
+
+      # Name
+      scanner.scan(/^([\d\w]+)\s?|$?/)
+      if scanner.matched?
+        parts[:param_name] = scanner.captures.first.strip
+        last_pos = scanner.pos
+      else
+        raise ArgumentError, "No name found for @param tag"
+      end
+
+      # Data types
+      scanner.scan(/\[([a-zA-Z]+)\]/)
+      if scanner.matched?
+        parts[:value_types] = scanner.captures.first.split(",")
+        last_pos = scanner.pos
+      else
+        parts[:value_types] = []
+        scanner.pos = last_pos
+      end
+
+      # Input type
+      scanner.scan(/\s?(\w+)\s?/)
+      if scanner.matched?
+        parts[:input_type] = scanner.captures.first
+        last_pos = scanner.pos
+      else
+        scanner.pos = last_pos
+      end
+
+      # Description
+      scanner.scan(/\s?(?:'(?<single>[^'\\]*(?:\\.[^'\\]*)*)'|"(?<double>[^"\\]*(?:\\.[^"\\]*)*)")\s?/i)
+      if scanner.matched?
+        parts[:description] = scanner.captures.first.presence || scanner.captures.last
+      else
+        scanner.pos = last_pos
+      end
+
+      # Options
+      parts[:options] = scanner.rest.strip
+
+      parts
+    end
+  end
+end

data/lib/lookbook/previews/tags/priority_tag.rb

@@ -0,0 +1,11 @@
+module Lookbook
+  class PriorityTag < YardTag
+    TAG_NAME = "priority"
+
+    def value
+      if @text.present?
+        text.to_i
+      end
+    end
+  end
+end

data/lib/lookbook/previews/tags/status_tag.rb

@@ -0,0 +1,5 @@
+module Lookbook
+  class StatusTag < YardTag
+    TAG_NAME = "status"
+  end
+end

data/lib/lookbook/previews/tags/yard_tag.rb

@@ -0,0 +1,22 @@
+module Lookbook
+  class YardTag < YARD::Tags::Tag
+    def value = @text
+
+    def options_str
+      @options || ""
+    end
+
+    class << self
+      def name
+        raise "No TAG_NAME constant defined" unless defined?(self::TAG_NAME)
+        self::TAG_NAME
+      end
+
+      def label = name.titleize
+
+      def aliases
+        defined?(self::TAG_ALIASES) ? self::TAG_ALIASES : []
+      end
+    end
+  end
+end

data/lib/lookbook/project.rb

@@ -0,0 +1,13 @@
+module Lookbook
+  module Project
+    class << self
+      def name
+        Lookbook.config.project_name
+      end
+
+      def links
+        Lookbook.config.project_links.map { DataObject.new(_1) }
+      end
+    end
+  end
+end

data/lib/lookbook/reloader.rb

@@ -0,0 +1,70 @@
+module Lookbook
+  class Reloader
+    include Loggable
+
+    delegate :execute, :execute_if_updated, :updated?, to: :file_watcher
+
+    attr_reader :name
+
+    def initialize(name, directories, extensions, &callback)
+      @name = name.to_sym
+      @directories = directories
+      @extensions = extensions
+      @last_changeset = nil
+      @callback = callback
+    end
+
+    def watching?(paths)
+      !!paths.find do |file_path|
+        file_path = Pathname(file_path).expand_path
+        @directories.find do |dir_path|
+          matcher = File.expand_path(File.join(dir_path, "**"))
+          file_path.fnmatch?(matcher)
+        end
+      end
+    end
+
+    protected
+
+    def watch_dirs
+      @directories.each_with_object({}) do |directory, result|
+        result[directory.to_s] = @extensions
+      end
+    end
+
+    def file_watcher
+      @_file_watcher ||= begin
+        file_watcher = file_watcher_class.new([], watch_dirs) do
+          @callback.call(@last_changeset)
+          @last_changeset = nil
+        end
+
+        if evented?
+          file_watcher.on_change do |changeset|
+            if watching?(changeset.all)
+              debug("#{name}: file changes detected")
+              @last_changeset = changeset
+              Engine.files_updated!
+            end
+          end
+        end
+
+        file_watcher
+      end
+    end
+
+    def file_watcher_class
+      if evented?
+        require_relative "evented_file_update_checker"
+
+        Lookbook::EventedFileUpdateChecker
+      else
+        ActiveSupport::FileUpdateChecker
+      end
+    end
+
+    def evented?
+      Gem.loaded_specs.has_key?("listen")
+    end
+  end
+end

data/lib/lookbook/reloaders.rb

@@ -1,70 +1,29 @@
 require "active_support"
 
 module Lookbook
-  class Reloaders
-    attr_reader :reloaders
+  module Reloaders
+    class << self
+      include Loggable
 
-    def initialize
-      @reloaders = []
-    end
+      def register(reloader)
+        raise ArgumentError, "Reloader '#{reloader.name}' is already registered" if reloader.in?(reloaders)
 
-    def add(name, directories, extensions, &callback)
-      reloader = Reloader.new(name, directories, extensions, &callback)
-      reloaders.push(reloader)
+        reloaders.push(reloader)
 
-      if Engine.reloading?
         Rails.application.reloaders << reloader
         Rails.application.reloader.to_run { reloader.execute_if_updated }
-      end
-    end
 
-    def execute
-      reloaders.each { |reloader| reloader.execute }
-    end
-
-    def register_changes(changes)
-      reloader = reloaders.find { |reloader| reloader.watching?(changes) }
-      reloader.last_changes = changes if reloader
-    end
-
-    class Reloader
-      delegate :execute, :execute_if_updated, :updated?, to: :file_watcher
-
-      attr_reader :name, :directories, :extensions, :callback
-      attr_accessor :last_changes
-
-      def initialize(name, directories, extensions, &callback)
-        @name = name.to_sym
-        @directories = directories
-        @extensions = extensions
-        @callback = callback
-        @last_changes = nil
+        debug("#{reloader.name}: reloader registered")
       end
 
-      def watching?(changes)
-        file_paths = changes.to_h.values.flatten
-        !!file_paths.find do |file_path|
-          file_path = Pathname(file_path).expand_path
-          directories.find do |dir_path|
-            matcher = File.expand_path(File.join(dir_path, "**"))
-            file_path.fnmatch?(matcher)
-          end
-        end
+      def execute
+        reloaders.each { _1.execute }
       end
 
-      protected
-
-      def file_watcher
-        return @_file_watcher if @_file_watcher
-
-        to_watch = directories.each_with_object({}) do |directory, result|
-          result[directory] = extensions
-        end
+      private
 
-        @_file_watcher ||= FileWatcher.new([], to_watch) do
-          callback.call(@last_changes)
-          @last_changes = nil
-        end
+      def reloaders
+        @reloaders ||= []
       end
     end
   end

data/lib/lookbook/services/action_view_config_handler.rb

@@ -0,0 +1,32 @@
+module Lookbook
+  class ActionViewConfigHandler < Service
+    attr_reader :disable_annotations
+
+    def initialize(disable_annotations: true)
+      @disable_annotations = disable_annotations
+    end
+
+    def call
+      handle_annotations
+      yield
+    ensure
+      restore_annotations
+    end
+
+    private
+
+    def handle_annotations
+      return unless disable_annotations && ActionView::Base.respond_to?(:annotate_rendered_view_with_filenames)
+
+      @original_annotations_value = ActionView::Base.annotate_rendered_view_with_filenames
+      ActionView::Base.annotate_rendered_view_with_filenames = false
+    end
+
+    def restore_annotations
+      return if @original_annotations_value.nil?
+
+      ActionView::Base.annotate_rendered_view_with_filenames = @original_annotations_value
+      @original_annotations_value = nil
+    end
+  end
+end

data/lib/lookbook/services/frontmatter_extractor.rb

@@ -0,0 +1,29 @@
+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)
+      data = matches ? YAML.safe_load(matches[0]).deep_symbolize_keys : {}
+      DataObject.new(data)
+    end
+
+    def strip_frontmatter(text)
+      text.gsub(FRONTMATTER_REGEX, "").strip
+    end
+  end
+end

data/lib/lookbook/services/key_value_tag_parser.rb

@@ -0,0 +1,24 @@
+module Lookbook
+  class KeyValueTagParser < Service
+    KEY_VALUE_REGEX = /^([^\s]+)\s+(.+)$/
+
+    attr_reader :text
+
+    def initialize(text)
+      @text = text.to_s
+    end
+
+    def call
+      text.strip.match(KEY_VALUE_REGEX) do |matches|
+        key = matches[1]
+        value = begin
+          YAML.safe_load(matches[2] || "~")
+        rescue ::Psych::SyntaxError
+          raise ArgumentError, "Invalid YAML in tag text '#{@text}'"
+        end
+        return [key, value]
+      end
+      raise ArgumentError, "Could not parse key:value pair from '#{@text}'"
+    end
+  end
+end

data/lib/lookbook/services/list_resolver.rb

@@ -3,13 +3,13 @@ module Lookbook
     attr_reader :item_set
 
     def initialize(to_include = nil, item_set = nil)
-      @to_include = to_include
+      @to_include = to_include.is_a?(String) ? to_include.split(",").map(&:strip) : to_include
       @item_set = Array(item_set).compact.uniq.map(&:to_s)
     end
 
     def call(&resolver)
       included = to_include.inject([]) do |result, name|
-        if name == "*"
+        if name.to_s == "*"
           result += item_set.select { |item| !result.include?(item) }
         elsif item_set.include?(name)
           result << name
@@ -18,7 +18,7 @@ module Lookbook
       end
 
       resolved = resolver ? included.map { |item| resolver.call(item) } : included
-      resolved.compact
+      resolved.compact.uniq
     end
 
     def to_include

data/lib/lookbook/services/param_value_parser.rb

@@ -0,0 +1,57 @@
+require "active_model"
+
+module Lookbook
+  class ParamValueParser < 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, "'#{@type}' is not a valid value type to cast to."
+      end
+    end
+
+    def call
+      return @nil if @value.empty?
+      public_send(@cast_method)
+    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 = YAML.safe_load(@value)
+      unless result.is_a?(Hash)
+        raise "'#{@value}' is not a YAML Hash"
+      end
+      result
+    end
+
+    def cast_to_array
+      result = YAML.safe_load(@value)
+      unless result.is_a?(Array)
+        raise "'#{@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/param_value_stringifier.rb

@@ -0,0 +1,25 @@
+require "active_model"
+
+module Lookbook
+  class ParamValueStringifier < Service
+    def initialize(value)
+      @value = value
+    end
+
+    def call
+      if @value == true
+        "true"
+      elsif @value == false
+        "false"
+      elsif @value.is_a?(DateTime)
+        @value.strftime("%Y-%m-%dT%H:%M")
+      elsif @value.is_a?(Date)
+        @value.strftime("%Y-%m-%d")
+      elsif @value.is_a?(Hash) || @value.is_a?(Array)
+        @value.to_yaml
+      else
+        @value.to_s
+      end
+    end
+  end
+end

data/lib/lookbook/services/path_priority_prefixes_stripper.rb

@@ -0,0 +1,23 @@
+module Lookbook
+  class PathPriorityPrefixesStripper < Service
+    def initialize(path)
+      @path = path
+    end
+
+    def call
+      path = @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
+      segments.map! do |segment|
+        PriorityPrefixParser.call(segment).last.tr("-", "_")
+      end
+
+      Utils.to_path(segments)
+    end
+  end
+end

data/lib/lookbook/services/search_param_parser.rb

@@ -0,0 +1,16 @@
+require "cgi"
+
+module Lookbook
+  class SearchParamParser < Service
+    attr_reader :str
+
+    def initialize(str)
+      @str = str.to_s.strip
+    end
+
+    def call
+      json = CGI.unescape(str)
+      JSON.parse(json).symbolize_keys
+    end
+  end
+end

data/lib/lookbook/services/styles_extractor.rb

@@ -0,0 +1,43 @@
+require "css_parser"
+
+module Lookbook
+  class StylesExtractor < Service
+    IFRAME_REGEX = /(<iframe(?:\s[^>]*)?>((?:(?!<\/iframe>).)*)<\/iframe>)/m
+    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.gsub(IFRAME_REGEX, "").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)
+      iframes = text.scan(IFRAME_REGEX).flatten
+      iframes.each.with_index(1) { text.gsub!(_1, "IFRAME_#{_2}") }
+      text = text.gsub(STYLE_TAGS_REGEX, "").strip
+      iframes.each.with_index(1) { text.gsub!("IFRAME_#{_2}", _1) }
+      text
+    end
+  end
+end

data/lib/lookbook/services/view_component_config_sync.rb

@@ -0,0 +1,25 @@
+module Lookbook
+  class ViewComponentConfigSync < Service
+    def call
+      vc_config = Rails.application.config.view_component
+
+      Lookbook.config.preview_paths += vc_config.preview_paths
+
+      if vc_config.preview_controller != ViewComponent::Config.defaults.preview_controller && Lookbook.config.preview_controller == Lookbook::Config.defaults.preview_controller
+        Lookbook.config.preview_controller = vc_config.preview_controller
+      elsif Lookbook.config.preview_controller != Lookbook::Config.defaults.preview_controller
+        vc_config.preview_controller = Lookbook.config.preview_controller
+      end
+
+      if Lookbook.config.preview_layout.nil? || vc_config.default_preview_layout.present?
+        Lookbook.config.preview_layout = vc_config.default_preview_layout
+      else
+        vc_config.default_preview_layout = Lookbook.config.preview_layout
+      end
+
+      if vc_config.view_component_path.present?
+        Lookbook.config.component_paths << vc_config.view_component_path
+      end
+    end
+  end
+end

data/lib/lookbook/services/whitespace_stripper.rb

@@ -0,0 +1,14 @@
+module Lookbook
+  class WhitespaceStripper < 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}}/, "").strip_heredoc.strip.html_safe
+    end
+  end
+end

data/lib/lookbook/source_parser.rb

@@ -0,0 +1,25 @@
+module Lookbook
+  class SourceParser
+    def initialize(log_level: YARD::Logger::ERROR, tags: [])
+      @log_level = log_level
+
+      tags.to_a.each do |tag_class|
+        tag_class = tag_class.constantize if tag_class.is_a?(String)
+
+        YARD::Tags::Library.define_tag(tag_class.label, tag_class.name, tag_class)
+        tag_class.aliases.each do |name|
+          YARD::Tags::Library.define_tag(tag_class.label, name, tag_class)
+        end
+      end
+    end
+
+    def parse(paths)
+      YARD::Logger.instance.enter_level(@log_level) do
+        YARD::Registry.clear
+        YARD.parse(paths)
+      end
+
+      yield YARD::Registry.all(:class)
+    end
+  end
+end

data/lib/lookbook/status.rb

@@ -0,0 +1,22 @@
+module Lookbook
+  class Status
+    attr_reader :color, :description
+
+    def initialize(name, label: nil, color: :gray, description: nil)
+      @name = name
+      @label = label
+      @color = color
+      @description = description
+    end
+
+    def name
+      Utils.name(@name, true)
+    end
+
+    def label
+      @label || Utils.label(@name)
+    end
+
+    def to_s = label
+  end
+end