gitlab-lookbook 2.3.14

data/lib/lookbook/reloaders.rb

@@ -0,0 +1,75 @@
+require "active_support"
+
+module Lookbook
+  class Reloaders
+    attr_reader :reloaders
+
+    def initialize
+      @reloaders = []
+    end
+
+    def add(name, directories, extensions, &callback)
+      reloader = Reloader.new(name, directories, extensions, &callback)
+      reloaders.push(reloader)
+
+      if Engine.reloading?
+        Rails.application.reloaders << reloader
+        Rails.application.reloader.to_run { reloader.execute_if_updated }
+      end
+
+      reloader
+    end
+
+    def execute(name = nil)
+      reloaders.each do |reloader|
+        reloader.execute if name.nil? || name == reloader.name
+      end
+    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
+      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
+      end
+
+      protected
+
+      def file_watcher
+        return @_file_watcher if @_file_watcher
+
+        to_watch = directories.each_with_object({}) do |directory, result|
+          result[directory] = extensions
+        end
+
+        @_file_watcher ||= FileWatcher.new([], to_watch) do
+          callback.call(@last_changes)
+          @last_changes = nil
+        end
+      end
+    end
+  end
+end

data/lib/lookbook/runtime_context.rb

@@ -0,0 +1,49 @@
+module Lookbook
+  class RuntimeContext
+    attr_reader :env
+
+    def initialize(env: Rails.env)
+      @env = env
+    end
+
+    def app_name
+      return @_app_name if @_app_name
+
+      app_class = Rails.application.class
+      name = app_class.respond_to?(:module_parent_name) ? app_class.module_parent_name : app_class.parent_name
+      @_app_name ||= name.underscore
+    end
+
+    def rails_older_than?(version)
+      Gem::Version.new(Rails.version) < Gem::Version.new(version)
+    end
+
+    def rails_newer_than?(version)
+      Gem::Version.new(Rails.version) >= Gem::Version.new(version)
+    end
+
+    def actioncable_installed?
+      gem_installed?("actioncable")
+    end
+
+    def listen_installed?
+      gem_installed?("listen")
+    end
+
+    def gem_installed?(name)
+      Gem.loaded_specs.has_key?(name)
+    end
+
+    def web?
+      !rake_task? && !Rails.const_defined?(:Console, false)
+    end
+
+    def rake_task?
+      if defined?(Rake) && Rake.respond_to?(:application)
+        File.basename($0) == "rake" || Rake.application.top_level_tasks.any?
+      else
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require "htmlbeautifier"
+
+module Lookbook
+  class CodeBeautifier < Service
+    attr_reader :source, :opts
+
+    def initialize(source, opts = {})
+      @source = source.to_s
+      @opts = opts
+    end
+
+    def call
+      language = opts.fetch(:language, "html")
+      stripped_source = source.strip
+      result = (language.downcase == "html") ? HtmlBeautifier.beautify(stripped_source, opts) : stripped_source
+      result.to_s.strip.html_safe
+    rescue
+      source.strip.html_safe
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require "rouge"
+require "htmlentities"
+
+module Lookbook
+  class CodeHighlighter < Service
+    attr_reader :source
+
+    def initialize(source, opts = {})
+      @source = source.to_s
+      @opts = opts
+    end
+
+    def opts
+      (@opts.is_a?(String) || @opts.is_a?(Symbol)) ? {language: @opts} : @opts.to_h
+    end
+
+    def call
+      coder = HTMLEntities.new
+      decoded_source = coder.decode(source)
+      language = opts.fetch(:language, "ruby")
+      formatter = LookbookFormatter.new(language: language, **opts)
+      lexer = Rouge::Lexer.find(language.to_s) || Rouge::Lexer.find("plaintext")
+      formatter.format(lexer.lex(decoded_source)).html_safe
+    end
+
+    class LookbookFormatter < Rouge::Formatters::HTML
+      def initialize(**opts)
+        @opts = opts
+        @highlight_lines = opts[:highlight_lines].to_a || []
+        @start_line = opts[:start_line] || 1
+        @language = opts[:language]
+      end
+
+      def stream(tokens, &block)
+        lines = token_lines(tokens)
+
+        yield "<div class='wrapper'>"
+
+        if @opts[:line_numbers]
+          yield "<div class='line-numbers'>"
+          lines.each.with_index do |line, i|
+            yield "<div class='line #{"highlighted" if highlighted?(i)}'><span class='line-number'>#{line_number(i)}</span></div>"
+          end
+          yield "</div>"
+        end
+
+        yield "<pre class='code highlight' data-lang='#{@language}'><code>"
+        lines.each.with_index do |line_tokens, i|
+          yield "<div class='line#{" highlighted" if highlighted?(i)}'>"
+          line_tokens.each do |token, value|
+            yield span(token, value)
+          end
+          yield "</div>"
+        end
+        yield "</code></pre>"
+
+        yield "</div>"
+      end
+
+      def highlighted?(i)
+        @highlight_lines.include?(i + 1)
+      end
+
+      def line_number(i)
+        @start_line + i
+      end
+    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/config_loader.rb

@@ -0,0 +1,20 @@
+module Lookbook
+  class ConfigLoader < Service
+    attr_reader :file, :env
+
+    def initialize(path, env: Rails.env)
+      @file = Engine.root.join(path)
+      @env = env.to_sym
+    end
+
+    def call
+      if file.exist?
+        config = YAML.load_file(file).deep_symbolize_keys
+        env_config = config[:shared].to_h.deep_merge(config[env].to_h)
+        Store.new(env_config)
+      else
+        raise ConfigError.new("Could not load configuration. No such file - #{file}")
+      end
+    end
+  end
+end

data/lib/lookbook/services/data/parsers/data_parser.rb

@@ -0,0 +1,22 @@
+module Lookbook
+  class DataParser < Service
+    def initialize(input, fail_silently: false, fallback: nil)
+      @input = input
+      @fail_silently = fail_silently
+      @fallback = fallback
+    end
+
+    def call
+      result = @input.present? ? parse(@input) : @fallback
+      result.is_a?(Hash) ? result.deep_symbolize_keys : result
+    rescue => exception
+      @fail_silently ? @fallback : raise(exception)
+    end
+
+    protected
+
+    def parse(input)
+      raise ParserError.new "DataParser must be subclassed with a :parse method defined"
+    end
+  end
+end

data/lib/lookbook/services/data/parsers/json_parser.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class JsonParser < DataParser
+    def parse(input)
+      JSON.parse(input.to_s)
+    end
+  end
+end

data/lib/lookbook/services/data/parsers/yaml_parser.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class YamlParser < DataParser
+    def parse(input)
+      YAML.safe_load(input.to_s)
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Lookbook
+  class DataResolver < Service
+    MATCHER = /(?!.*)/
+    MATCH_INDEX = 1
+
+    attr_reader :eval_context, :base_dir, :file, :fallback
+
+    def initialize(input, eval_context: nil, fail_silently: false, base_dir: Rails.root, file: nil, fallback: nil)
+      @input = input.to_s
+      @eval_context = eval_context
+      @fail_silently = fail_silently
+      @fallback = fallback
+      @base_dir = base_dir.to_s
+      @file = file.to_s
+    end
+
+    def call
+      resolve extract(@input)
+    rescue => exception
+      Lookbook.logger.debug "Data resolution failed. (Input: '#{@input}')"
+      @fail_silently ? fallback : raise(exception)
+    end
+
+    def self.resolveable?(input)
+      input.to_s.match?(self::MATCHER)
+    end
+
+    protected
+
+    def extract(input)
+      match_data = input.match(self.class::MATCHER)
+      if match_data.nil?
+        raise_error "Invalid data '#{input}'"
+      else
+        match_data[self.class::MATCH_INDEX]
+      end
+    end
+
+    def resolve(input)
+      raise ParserError.new "OptionsResolver must be subclassed with a :resolve method defined"
+    end
+
+    def evaluate(input, fallback = @fallback)
+      if evaluatable?
+        begin
+          proc {
+            eval_context.instance_eval(input.to_s)
+          }.call
+        rescue => exception
+          raise_error "Could not evaluate statement (#{exception.message})", exception
+        end
+      else
+        Lookbook.logger.debug "Data cannot be evaluated (Input: '#{input}')"
+        fallback
+      end
+    end
+
+    def raise_error(message, original_exception = nil)
+      raise ParserError.new message, original: original_exception, scope: "resolvers"
+    end
+
+    private
+
+    def evaluatable?
+      eval_context.present?
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Lookbook
+  class EvalResolver < DataResolver
+    MATCHER = /(\{\{\s?(.*)\s?\}\})$/
+    MATCH_INDEX = 2
+
+    def resolve(input)
+      evaluate(input)
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Lookbook
+  class FileResolver < DataResolver
+    MATCHER = /(\S+\.(json|yml))$/
+    MATCH_INDEX = 1
+
+    protected
+
+    def resolve(input)
+      path = resolve_path(input, base_dir)
+      content = read_file(path)
+
+      case path.extname
+      when ".json"
+        JsonParser.call(content)
+      when ".yml"
+        YamlParser.call(content)
+      end
+    end
+
+    def read_file(path)
+      File.exist?(path.to_s) ? File.read(path) : raise_error("The data file at '#{path}' could not be found")
+    end
+
+    def resolve_path(path, base_dir)
+      Pathname(path.start_with?(".") ? File.expand_path(path, base_dir) : Rails.root.join(path))
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Lookbook
+  class MethodResolver < DataResolver
+    MATCHER = /(:{1}([a-zA-Z_\d]+))$/
+    MATCH_INDEX = 2
+
+    def resolve(input)
+      evaluate(input)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Lookbook
+  class YamlResolver < DataResolver
+    MATCHER = /((?:\{|\[)(.*?)(?:\]|\}))$/m
+    MATCH_INDEX = 1
+
+    def self.resolveable?(input)
+      input.to_s.match?(MATCHER) && YamlParser.call(input, fail_silently: true)
+    end
+
+    protected
+
+    def resolve(input)
+      YamlParser.call(input)
+    rescue Psych::SyntaxError => exception
+      raise_error "YAML parse error (#{exception}) in '#{file}'", exception
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Lookbook
+  class PageTreeBuilder < Service
+    attr_reader :include_hidden
+
+    def initialize(pages, include_hidden: false)
+      @pages = pages.to_a
+      @include_hidden = include_hidden
+    end
+
+    def call
+      root_node = TreeNode.new
+      pages.each do |page|
+        current_node = root_node
+
+        path_segments = parse_segments(page.relative_file_path)
+        path_segments.each.with_index(1) do |segment, i|
+          name, priority_prefix = segment
+          content = page if page.depth == i # pages are always on the leaf nodes
+
+          current_node.add_child(name, content, priority: priority_prefix) unless current_node.has_child?(name)
+          current_node = current_node.get_child(name)
+        end
+      end
+      root_node
+    end
+
+    def parse_segments(path)
+      path.to_s.split("/").map do |segment|
+        unless segment.start_with?(".")
+          priority, name = PriorityPrefixParser.call(segment)
+          [name, priority || 10000]
+        end
+      end.compact
+    end
+
+    def pages
+      include_hidden ? @pages : @pages.select(&:visible?)
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Lookbook
+  class PreviewTreeBuilder < Service
+    attr_reader :include_hidden
+
+    def initialize(previews, include_hidden: false)
+      @previews = previews.to_a
+      @include_hidden = include_hidden
+    end
+
+    def call
+      root_node = TreeNode.new
+      previews.each do |preview|
+        current_node = root_node
+
+        path_segments = preview.logical_path.split("/")
+        path_segments.each.with_index(1) do |name, i|
+          content = preview if preview.depth == i # entities are always on the leaf nodes
+
+          current_node.add_child(name, content) unless current_node.has_child?(name)
+          current_node = current_node.get_child(name)
+
+          content&.visible_scenarios&.each do |scenario|
+            current_node.add_child(scenario.name, scenario)
+          end
+        end
+      end
+      root_node
+    end
+
+    def previews
+      include_hidden ? @previews : @previews.select(&:visible?)
+    end
+  end
+end

data/lib/lookbook/services/list_resolver.rb

@@ -0,0 +1,35 @@
+module Lookbook
+  class ListResolver < Service
+    attr_reader :item_set
+
+    def initialize(to_include = nil, item_set = nil)
+      @to_include = 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 == "*"
+          result += item_set.select { |item| !result.include?(item) }
+        elsif item_set.include?(name)
+          result << name
+        end
+        result
+      end
+
+      resolved = resolver ? included.map { |item| resolver.call(item) } : included
+      resolved.compact
+    end
+
+    def to_include
+      case @to_include
+      when true
+        ["*"]
+      when false
+        []
+      else
+        Array(@to_include).compact.uniq.map(&:to_s)
+      end
+    end
+  end
+end

data/lib/lookbook/services/markdown_renderer.rb

@@ -0,0 +1,41 @@
+require "redcarpet"
+
+module Lookbook
+  class MarkdownRenderer < Service
+    attr_reader :text, :extensions, :options
+
+    # In Lookbook config, `markdown_options` are actually Redcarpet `extensions` so we store them as `@extensions`
+    def initialize(text, extensions = {}, options = {})
+      @text = text
+      @extensions = Lookbook.config.markdown_options.merge(extensions.to_h)
+      @options = default_options.merge(options.to_h)
+    end
+
+    def call
+      clean_text = ActionViewAnnotationsStripper.call(text)
+      md = Redcarpet::Markdown.new(LookbookMarkdownRenderer.new(default_options), extensions)
+      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
+
+      def postprocess(full_document)
+        full_document&.gsub!("<p><lookbook", "<lookbook")
+        full_document&.gsub!("</lookbook-embed></p>", "</lookbook-embed>")
+        full_document
+      end
+    end
+
+    def default_options
+      {
+        with_toc_data: true
+      }
+    end
+  end
+end

data/lib/lookbook/services/priority_prefix_parser.rb

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

data/lib/lookbook/services/string_value_caster.rb

@@ -0,0 +1,64 @@
+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_date
+      Date.parse(@value)
+    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