lookbook 1.2.1 → 1.3.0

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/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,70 @@
+module Lookbook
+  class DataResolver < Service
+    MATCHER = /(?!.*)/
+    MATCH_INDEX = 1
+
+    attr_reader :eval_context, :base_dir, :file, :fallback
+
+    def initialize(input, eval_context: nil, permit_eval: false, fail_silently: false, base_dir: Rails.root, file: nil, fallback: nil)
+      @input = input.to_s
+      @eval_context = eval_context
+      @permit_eval = permit_eval
+      @fail_silently = fail_silently
+      @fallback = fallback
+      @base_dir = base_dir
+      @file = file
+    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
+          eval_context.instance_eval(input.to_s)
+        rescue => exception
+          raise_error "Could not evaluate statetment (#{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?
+      if !@permit_eval
+        raise_error "Runtime evaluation is not permitted"
+      end
+      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)
+      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 = /(:([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/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/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/source_inspector.rb

@@ -11,85 +11,66 @@ module Lookbook
     end
 
     def hidden?
-      @hidden ||= if code_object&.tag(:hidden)
-        code_object.tag(:hidden).text.strip != "false"
-      else
-        false
-      end
+      @hidden ||= tag_value(:hidden) || false
     end
 
     def id
-      @id ||= if code_object&.tag(:id)&.text&.present?
-        generate_id(code_object&.tag(:id)&.text)
-      end
+      @id ||= tag_value(:id)
     end
 
     def label
-      @label ||= code_object&.tag(:label)&.text
+      @label ||= tag_value(:label)
     end
 
     def notes
-      @notes ||= if code_object&.docstring
-        code_object.docstring.to_s.strip
-      end
+      @notes ||= code_object.docstring&.to_s&.strip
     end
 
     def group
-      @group ||= code_object&.group
+      @group ||= code_object.group
     end
 
     def position
-      @position ||= code_object&.tag(:position)&.text&.to_i || 10000
+      @position ||= tag_value(:position) || 10000
     end
 
     def components
-      @components ||= if code_object&.tags(:component).present?
-        code_object.tags(:component).map do |component|
-          component.text.constantize
-        end
-      else
-        []
-      end
+      @components ||= Array(code_object.tags(:component)).map(&:value)
     end
 
-    def display_options
-      return @display_options unless @display_options.nil?
-      tags = code_object.tags(:display).to_a
-      pairs = tags.map { KeyValueTagParser.call(_1.text) }
-
-      # dynamic params set at the entity level are
-      # not (yet) supported so filter them out.
-      pairs.select! { |pair| !pair[1].is_a?(Array) && !pair[1].is_a?(Hash) }
-
-      pairs.to_h.symbolize_keys
+    def logical_path
+      path = tag_value(:logical_path)
+      path&.delete_prefix("/")&.delete_suffix("/")
     end
 
-    def parameter_defaults
-      @param_defaults ||= code_object&.parameters&.map { |str| Params.parse_method_param_str(str) }&.compact&.to_h
-    end
+    def display_options
+      return @display_options unless @display_options.nil?
 
-    def params
-      @params ||= {}
-      @params[:param] ||= code_object&.tags("param")&.map do |param|
-        Lookbook::Params.build_param(param,
-          default: parameter_defaults[param.name],
-          eval_scope: @eval_scope)
+      # Dynamic params set at the entity level are
+      # not (yet?) supported so filter them out.
+      display_tags = Array(code_object.tags(:display)).select do |tag|
+        !(tag.value.is_a?(Array) || tag.value.is_a?(Hash))
       end
+
+      display_tags.map { |tag| [tag.key.to_sym, tag.value] }.to_h
     end
 
     def methods
-      @methods ||= code_object&.meths
+      @methods ||= code_object.meths
     end
 
     def tags(name = nil)
-      tag_objects = code_object&.tags(name).presence || []
-      Lookbook::Tags.process_tags(tag_objects,
-        eval_scope: @eval_scope,
-        file: (code_object.files.first[0] if code_object.files.any?))
+      code_object.tags(name)
     end
 
     def tag(name = nil)
       tags(name).first
     end
+
+    protected
+
+    def tag_value(tag_name)
+      code_object.tag(tag_name).value if code_object.has_tag?(tag_name)
+    end
   end
 end