gitlab-lookbook 2.3.14

data/lib/lookbook/support/errors/error.rb

@@ -0,0 +1,64 @@
+module Lookbook
+  class Error < StandardError
+    attr_reader :scope, :original, :status, :detail, :source
+
+    def initialize(message = nil,
+      scope: nil, original: nil, status: nil, detail: nil,
+      file_path: nil, source: nil, line_number: nil, **kwargs)
+      @scope = scope
+      @original = original
+      @message = message
+      @status = status
+      @detail = detail
+      @file_path = file_path
+      @source = source
+      @line_number = line_number
+      super(message)
+    end
+
+    def message
+      @message || original&.message
+    end
+
+    def backtrace
+      original&.backtrace || super
+    end
+
+    def type
+      (original.presence || self).class.to_s
+    end
+
+    def file_path
+      return @file_path.to_s if @file_path.present?
+
+      parsed_backtrace[0][0] if parsed_backtrace.any?
+    end
+
+    def relative_file_path
+      file_path&.delete_prefix("#{Rails.root}/")
+    end
+
+    def line_number
+      return @line_number.to_i if @line_number.present?
+
+      if parsed_backtrace.any?
+        number = parsed_backtrace[0][1]
+        number.to_i if number.present?
+      end
+    end
+
+    def backtrace_lines
+      root = Rails.root.to_s
+      backtrace.map { |line| line.gsub(root, "") }
+    end
+
+    protected
+
+    def parsed_backtrace
+      backtrace.map do |line|
+        line =~ /^(.+?):(\d+)(|:in `(.+)')$/
+        [$1, $2, $4]
+      end
+    end
+  end
+end

data/lib/lookbook/support/errors/parser_error.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class ParserError < Error
+    def initialize(msg = nil, scope: "parser", **kwargs)
+      super
+    end
+  end
+end

data/lib/lookbook/support/errors/preview_template_error.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class PreviewTemplateError < Error
+    def initialize(msg = nil, scope: "preview", **kwargs)
+      super
+    end
+  end
+end

data/lib/lookbook/support/errors/routing_error.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class RoutingError < Error
+    def initialize(msg = nil, scope: "request", **kwargs)
+      super(msg, scope: scope, status: :not_found, **kwargs)
+    end
+  end
+end

data/lib/lookbook/support/errors/template_error.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class TemplateError < Error
+    def initialize(msg = nil, scope: "template", **kwargs)
+      super
+    end
+  end
+end

data/lib/lookbook/support/evented_file_update_checker.rb

@@ -0,0 +1,69 @@
+require "active_support/evented_file_update_checker"
+
+module Lookbook
+  require "listen" unless Engine.runtime_context.rails_newer_than?("6.1.0")
+
+  class EventedFileUpdateChecker < ActiveSupport::EventedFileUpdateChecker
+    if Engine.runtime_context.rails_newer_than?("6.1.0")
+
+      def initialize(files, dirs = {}, &block)
+        super
+        @core = Core.new(files, dirs)
+      end
+
+      class Core < ActiveSupport::EventedFileUpdateChecker::Core
+        def changed(modified, added, removed)
+          super
+          Engine.files_changed(modified, added, removed) if @updated
+        end
+
+        # Patched to handle regex-style
+        # extension matchers like `.html.*`
+        def watching?(file)
+          return true if super
+
+          file = Pathname(file)
+          name_parts = file.basename.to_s.split(".")
+          ext = "." + name_parts.drop(1).join(".").to_s
+
+          file.dirname.ascend do |dir|
+            matching = @dirs.fetch(dir, []).map { |m| Regexp.new(m) }
+            if matching.empty? || matching.find { |m| m.match?(ext) }
+              break true
+            elsif dir == @common_path || dir.root?
+              break false
+            end
+          end
+        end
+      end
+
+    else
+
+      # Patched to handle regex-style
+      # extension matchers like `.html.*`
+      def watching?(file)
+        return true if super
+
+        file = Pathname(file)
+        name_parts = file.basename.to_s.split(".")
+        ext = "." + name_parts.drop(1).join(".").to_s
+
+        file.dirname.ascend do |dir|
+          matching = @dirs.fetch(dir, []).map { |m| Regexp.new(m) }
+          if matching.empty? || matching.find { |m| m.match?(ext) }
+            break true
+          elsif dir == @lcsp || dir.root?
+            break false
+          end
+        end
+      end
+
+      private
+
+      def changed(modified, added, removed)
+        super
+        Engine.files_changed(modified, added, removed) if updated?
+      end
+    end
+  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/null_websocket.rb

@@ -0,0 +1,9 @@
+module Lookbook
+  class NullWebsocket < NullObject
+    def mountable?
+      false
+    end
+
+    alias_method :mounted?, :mountable?
+  end
+end

data/lib/lookbook/support/service.rb

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

data/lib/lookbook/support/store.rb

@@ -0,0 +1,53 @@
+module Lookbook
+  # Generic hash-like key/value store.
+  #
+  # Properties can be get/set using hash access syntax (`data[:key]`)
+  # or dot-notation syntax (`data.key`).
+  #
+  # Based on [ActiveSupport::OrderedOptions](https://api.rubyonrails.org/classes/ActiveSupport/OrderedOptions.html)
+  #
+  # @ignore methods
+  # @api public
+  class Store < ActiveSupport::OrderedOptions
+    def initialize(initial_data = nil, opts = {})
+      @recursive = opts[:recursive] || false
+      super()
+      initial_data.to_h.each { |k, v| self[k] = v }
+    end
+
+    def []=(key, value)
+      super(key, normalize_value(value))
+    end
+
+    def fetch(name, *args)
+      super(name.to_sym, *args)
+    end
+
+    def method_missing(name, *args)
+      if name.to_s.end_with?("=")
+        args[0] = normalize_value(args[0])
+      end
+      super
+    end
+
+    def respond_to_missing?(name, include_private)
+      true
+    end
+
+    def to_h
+      transform_values do |value|
+        value.is_a?(Store) ? value.to_h : value
+      end
+    end
+
+    def to_hash
+      to_h
+    end
+
+    protected
+
+    def normalize_value(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, priority: 10000)
+      @path = path.to_s
+      @content = content
+      @priority = priority
+      @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 priority
+      content_value(:priority, @priority)
+    end
+
+    def type
+      content_value(:type, :directory)
+    end
+
+    def depth
+      path.split("/").size
+    end
+
+    def add_child(name, content = nil, priority: 10000)
+      children << TreeNode.new("#{path}/#{name}", content, priority: priority)
+    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
+        [priority, label] <=> [other.priority, 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

@@ -0,0 +1,52 @@
+module Lookbook
+  module PathUtils
+    class << self
+      def to_absolute(path)
+        File.absolute_path(path.to_s, Rails.root)
+      end
+
+      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
+        segments.map! do |segment|
+          PriorityPrefixParser.call(segment).last.tr("-", "_")
+        end
+
+        to_path(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 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
+
+      def determine_full_path(rel_path, search_dirs = [])
+        base_path = search_dirs.detect { |p| Dir["#{p}/#{rel_path}"].first }
+        path = Dir["#{base_path}/#{rel_path}"].first
+        Pathname(path) if path
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Lookbook
+  module Utils
+    class << self
+      def id(*args)
+        parts = args.map { |arg| arg.to_s }
+        id_str = parts.join("-").force_encoding("UTF-8").parameterize.dasherize
+        PathUtils.strip_slashes(id_str).tr("/", "-").gsub("--", "-")
+      end
+
+      def temp_id(prefix: nil)
+        [prefix, (Time.now.to_f * 1000).to_i + rand(0..100)].compact.join("-")
+      end
+
+      def name(str)
+        str.to_s.dup.force_encoding("UTF-8").parameterize.tr("-", "_")
+      end
+
+      def symbolize_name(str)
+        name(str).to_sym
+      end
+
+      def value_or_fallback(value, fallback = nil, &block)
+        if value.nil?
+          fallback_block = block || proc { fallback }
+          fallback_block.call
+        else
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Lookbook
+  module Where
+    class << self
+      attr_accessor :editor
+
+      def is_proc(proc)
+        source_location(proc)
+      end
+
+      def is_method(klass, method_name)
+        source_location(klass.method(method_name))
+      end
+
+      def is_instance_method(klass, method_name)
+        source_location(klass.instance_method(method_name))
+      end
+
+      def is_class(klass)
+        methods = defined_methods(klass)
+        file_groups = methods.group_by { |sl| sl[0] }
+        file_counts = file_groups.map do |file, sls|
+          lines = sls.map { |sl| sl[1] }
+          count = lines.size
+          line = lines.min
+          {file: file, count: count, line: line}
+        end
+        file_counts.sort_by! { |fc| fc[:count] }
+        file_counts.map { |fc| [fc[:file], fc[:line]] }
+      end
+
+      private
+
+      def source_location(method)
+        method.source_location || (
+          method.to_s =~ /: (.*)>/
+          $1
+        )
+      end
+
+      def defined_methods(klass)
+        methods = klass.methods(false).map { |m| klass.method(m) } +
+          klass.instance_methods(false).map { |m| klass.instance_method(m) }
+        methods.map!(&:source_location)
+        methods.compact!
+        methods
+      end
+    end
+  end
+end

data/lib/lookbook/tags/after_render_tag.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class AfterRenderTag < YardTag
+    def value
+      text.sub(/\A:/, "")
+    end
+  end
+end

data/lib/lookbook/tags/custom_tag.rb

@@ -0,0 +1,61 @@
+module Lookbook
+  class CustomTag < YardTag
+    supports_options
+
+    attr_reader :arg_names, :tag_args
+
+    def initialize(tag_name, text = nil, *args)
+      tag_definition = Engine.tags.get_tag(tag_name)
+      unless tag_definition
+        raise ParserError.new "Unknown custom tag type '#{tag_name}'"
+      end
+
+      super(tag_name, text.to_s, *args)
+
+      @custom_attributes = Store.new
+      @arg_names = tag_definition.options.fetch(:named_args, [])
+      @after_parse = tag_definition.options.fetch(:after_parse, nil)
+
+      validate_arg_names
+
+      @tag_args = parse_tag
+      @after_parse.call(self) if @after_parse.respond_to?(:call)
+    end
+
+    # Method aliases to keep compatability with
+    # the original custom tag implementation
+    alias_method :tag_body, :text
+    alias_method :opts, :options
+
+    protected
+
+    def parse_tag
+      text_tokens = Shellwords.split(text)
+      values = text_tokens.slice(0, arg_names.size)
+
+      arg_names.map.with_index do |name, i|
+        [name.to_sym, values[i]]
+      end.to_h
+    end
+
+    def validate_arg_names
+      arg_names.each do |name|
+        if methods.include? name.to_sym
+          raise ParserError.new "'#{name}' is a reserved word and cannot be used as an argument name."
+        end
+      end
+    end
+
+    def method_missing(name, *args)
+      if name.end_with? "="
+        @custom_attributes[name.to_s.chomp("=")] = args.first
+      else
+        @custom_attributes.public_send(name, *args) || tag_args[name]
+      end
+    end
+
+    def respond_to_missing?(name, include_private)
+      @custom_attributes.key?(name) || tag_args.key?(name) || super
+    end
+  end
+end

data/lib/lookbook/tags/display_tag.rb

@@ -0,0 +1,15 @@
+module Lookbook
+  class DisplayTag < YardTag
+    def key
+      parts.first
+    end
+
+    def value
+      parts.second
+    end
+
+    def parts
+      @parts ||= KeyValueTagParser.call(text)
+    end
+  end
+end

data/lib/lookbook/tags/hidden_tag.rb

@@ -0,0 +1,13 @@
+module Lookbook
+  class HiddenTag < YardTag
+    def value
+      text != "false"
+    end
+
+    def to_s
+      value ? "true" : "false"
+    end
+
+    alias_method :to_bool, :value
+  end
+end

data/lib/lookbook/tags/id_tag.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class IdTag < YardTag
+    def value
+      Utils.id(text) if text.present?
+    end
+  end
+end

data/lib/lookbook/tags/label_tag.rb

@@ -0,0 +1,4 @@
+module Lookbook
+  class LabelTag < YardTag
+  end
+end

data/lib/lookbook/tags/logical_path_tag.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class LogicalPathTag < YardTag
+    def value
+      PathUtils.strip_slashes(super)
+    end
+  end
+end

data/lib/lookbook/tags/param_tag.rb

@@ -0,0 +1,76 @@
+module Lookbook
+  class ParamTag < YardTag
+    VALUE_TYPE_MATCHER = /^(\[\s?([A-Z]{1}\w+)\s?\])/
+    DESCRIPTION_MATCHER = /(?<=\s|^)"(.*?[^\\])"(?:\s|$)/
+
+    supports_options
+
+    attr_reader :tag_args
+
+    def initialize(text)
+      @name, text_without_name = extract_name(text)
+      @tag_args = parse_tag_body(text_without_name)
+      super("param", tag_args[:rest], nil, @name)
+    end
+
+    def input
+      tag_args[:input]&.downcase&.tr("_", "-")
+    end
+
+    def description
+      tag_args[:description]
+    end
+
+    def value_type
+      tag_args[:value_type]&.downcase
+    end
+
+    def value_default
+      default_value_parts = object.parameters.find { |parts| parts[0].chomp(":") == name }
+      if default_value_parts
+        # fix issue with YARD argument parser not splitting args correctly (leaving a trailing comma or bracket)
+        # when one or more of the argument values is a negative number.
+        cleaned_value = default_value_parts[1].start_with?("-") ? default_value_parts[1].sub(/[,\)]$/, "") : default_value_parts[1]
+        host_class_instance.instance_eval(cleaned_value)
+      else
+        raise ParserError.new "Unknown method parameter '#{name}'"
+      end
+    end
+
+    protected
+
+    def extract_name(text)
+      parts = text.to_s.split(" ")
+      [parts.shift, parts.join(" ")]
+    end
+
+    def parse_tag_body(text)
+      value_type = nil
+      description = nil
+
+      # Parse out YARD-style value type definition - i.e. [Boolean]
+      text.match(VALUE_TYPE_MATCHER) do |match_data|
+        value_type = match_data[2]
+        text.gsub!(VALUE_TYPE_MATCHER, "").strip!
+      end
+
+      # Parse and remove any options from string
+      options_str, text = parse_options(text, resolve: false)
+
+      # Parse description, if provided
+      text.match(DESCRIPTION_MATCHER) do |match_data|
+        description = match_data[1]
+        text.sub!(DESCRIPTION_MATCHER, "").strip!
+      end
+
+      input, rest = text.split(" ", 2)
+
+      {
+        input: input,
+        value_type: value_type,
+        description: description,
+        rest: [rest, options_str].compact.join(" ")
+      }
+    end
+  end
+end

data/lib/lookbook/tags/priority_tag.rb

@@ -0,0 +1,16 @@
+module Lookbook
+  class PriorityTag < YardTag
+    DEFAULT_PRIORITY = 100000
+
+    def value
+      if text.present?
+        int = text.to_i
+        (int == 0) ? DEFAULT_PRIORITY : int
+      else
+        DEFAULT_PRIORITY
+      end
+    end
+
+    alias_method :to_i, :value
+  end
+end