lookbook 2.3.1 → 3.0.0.alpha.1

data/lib/lookbook/preview_controller_actions.rb

@@ -1,64 +0,0 @@
-module Lookbook
-  module PreviewControllerActions
-    extend ActiveSupport::Concern
-
-    included do
-      helper PreviewHelper
-      send(:helper, Rails.application.routes.url_helpers) # YARD parsing workaround: https://github.com/lsegal/yard/issues/546
-      prepend_view_path Engine.root.join("app/views")
-
-      def render_scenario_to_string(preview, scenario)
-        prepend_application_view_paths
-        prepend_preview_examples_view_path
-
-        @preview = preview
-        @scenario_name = scenario.name
-        @render_args = @preview.render_args(@scenario_name, params: params.permit!)
-        template = @render_args[:template]
-        locals = @render_args[:locals]
-        opts = {}
-        opts[:layout] = nil
-        opts[:assigns] = @render_args[:assigns] || {}
-        opts[:locals] = locals if locals.present?
-
-        with_action_view_settings do
-          rendered = render_to_string(template, **opts)
-
-          if scenario.after_render_method.present?
-            render_context = Store.new({
-              preview: preview,
-              scenario: scenario,
-              params: user_request_parameters
-            })
-            rendered = @preview.after_render(method: scenario.after_render_method, html: rendered, context: render_context)
-          end
-          render html: rendered
-        end
-      end
-
-      def render_in_layout_to_string(template, locals, opts = {})
-        with_action_view_settings do
-          html = render_to_string(template, locals: locals, **determine_layout(opts[:layout]))
-          if opts[:append_html].present?
-            html += opts[:append_html]
-          end
-          render html: html
-        end
-      end
-
-      protected
-
-      def with_action_view_settings(&block)
-        ActionViewConfigHandler.call(
-          disable_annotations: Lookbook.config.preview_disable_action_view_annotations,
-          disable_partial_prefixes: Lookbook.config.preview_disable_action_view_partial_prefixes,
-          &block
-        )
-      end
-
-      def user_request_parameters
-        request.query_parameters.to_h.filter { |k, v| !k.start_with?("_") }
-      end
-    end
-  end
-end

data/lib/lookbook/preview_parser.rb

@@ -1,55 +0,0 @@
-require "yard"
-
-module Lookbook
-  class PreviewParser
-    def initialize(paths, tags = nil)
-      @paths = paths
-      @after_parse_callbacks = []
-      @after_parse_once_callbacks = []
-      @parsing = false
-
-      define_tags(tags)
-      YARD::Parser::SourceParser.after_parse_list { run_callbacks }
-    end
-
-    def parse(files = nil, &block)
-      unless @parsing
-        @parsing = true
-        @after_parse_once_callbacks << block if block
-        files_list = files ? files.select { |file| file.to_s.end_with?(".rb") } : paths
-
-        YARD::Registry.clear
-        YARD.parse(files_list)
-      end
-    end
-
-    def after_parse(&block)
-      @after_parse_callbacks << block
-    end
-
-    def paths
-      PathUtils.normalize_paths(@paths).map { |path| "#{path}/**/*preview.rb" }
-    end
-
-    protected
-
-    def callbacks
-      [
-        *@after_parse_callbacks,
-        *@after_parse_once_callbacks
-      ]
-    end
-
-    def run_callbacks
-      callbacks.each { |cb| cb.call(YARD::Registry) }
-      @after_parse_once_callbacks = []
-      @parsing = false
-    end
-
-    def define_tags(tags = nil)
-      tags.to_h.each do |name, tag|
-        YARD::Tags::Library.define_tag(tag[:label], name, Lookbook::TagProvider)
-      end
-    end
-  end
-end

data/lib/lookbook/runtime_context.rb

@@ -1,49 +0,0 @@
-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_highlighter.rb

@@ -1,69 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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/markdown_renderer.rb

@@ -1,33 +0,0 @@
-require "redcarpet"
-
-module Lookbook
-  class MarkdownRenderer < Service
-    attr_reader :text, :opts
-
-    def initialize(text, opts = {})
-      @text = text
-      @opts = Lookbook.config.markdown_options.merge(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
-
-      def postprocess(full_document)
-        full_document&.gsub!("<p><lookbook", "<lookbook")
-        full_document&.gsub!("</lookbook-embed></p>", "</lookbook-embed>")
-        full_document
-      end
-    end
-  end
-end

data/lib/lookbook/services/string_value_caster.rb

@@ -1,60 +0,0 @@
-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/key_value_tag_parser.rb

@@ -1,24 +0,0 @@
-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 => exception
-          raise ParserError.new("Invalid YAML in tag text '#{@text}'", scope: "key_value_tag.parser", original: exception)
-        end
-        return [key, value]
-      end
-      raise ParserError.new("Could not parse key:value pair from '#{@text}'", scope: "key_value_tag.parser")
-    end
-  end
-end