lookbook 1.2.1 → 1.4.5

data/lib/lookbook/entities/preview_group.rb

@@ -0,0 +1,48 @@
+module Lookbook
+  class PreviewGroup < Entity
+    include Navigable
+
+    attr_reader :examples, :preview
+
+    def initialize(name, examples, preview)
+      @name = Utils.name(name)
+      @examples = PreviewExampleCollection.new(examples)
+      @preview = preview
+      @lookup_path = "#{parent.lookup_path}/#{@name}"
+    end
+
+    def display_options
+      merged = {}
+      examples.to_a.reverse.map do |example|
+        merged.merge!(example.display_options)
+      end
+      merged
+    end
+
+    def components
+      @_components ||= ComponentCollection.new(examples.flat_map(&:components).uniq(&:path))
+    end
+
+    def search_terms
+      [parent.label, label]
+    end
+
+    def tags(tag_name = nil)
+      examples.flat_map { |example| example.tags(tag_name) }
+    end
+
+    def tag(tag_name = nil)
+      tags(tag_name).first
+    end
+
+    def url_path
+      lookbook_inspect_path(path)
+    end
+
+    def type
+      :group
+    end
+
+    alias_method :parent, :preview
+  end
+end

data/lib/lookbook/file_watcher.rb

@@ -0,0 +1,47 @@
+module Lookbook
+  class FileWatcher
+    attr_reader :listeners, :force_polling
+
+    def initialize(force_polling: false)
+      @force_polling = force_polling
+      @listeners = []
+    end
+
+    def watch(paths, extensions = ".*", opts = nil, &block)
+      paths = PathUtils.normalize_paths(paths)
+
+      if paths.any?
+        opts = opts.to_h
+        opts[:only] = /\.(#{Array(extensions).join("|")})$/
+
+        listeners << init_listener(paths, opts, &block)
+      end
+    end
+
+    def start
+      if listeners.any?
+        Lookbook.logger.debug "Starting listeners"
+        listeners.each { |l| l.start }
+      end
+    end
+
+    def stop
+      if listeners.any?
+        Lookbook.logger.debug "Stopping listeners"
+        listeners.each { |l| l.stop }
+      end
+    end
+
+    protected
+
+    def init_listener(paths, opts, &block)
+      Listen.to(
+        *paths,
+        **opts,
+        force_polling: force_polling
+      ) do |modified, added, removed|
+        block.call({modified: modified, added: added, removed: removed})
+      end
+    end
+  end
+end

data/lib/lookbook/lang.rb

@@ -1,46 +1,23 @@
 module Lookbook
   module Lang
     class << self
-      LANGUAGES = [
-        {
-          name: "ruby",
-          ext: ".rb",
-          label: "Ruby",
-          comment: "# %s"
-        },
-        {
-          name: "html",
-          ext: ".html",
-          label: "HTML",
-          comment: "<!-- %s -->"
-        },
-        {
-          name: "erb",
-          ext: ".erb",
-          label: "ERB",
-          comment: "<%%# %s %%>"
-        },
-        {
-          name: "haml",
-          ext: ".haml",
-          label: "Haml",
-          comment: "<!-- %s -->"
-        },
-        {
-          name: "slim",
-          ext: ".slim",
-          label: "Slim",
-          comment: "<!-- %s -->"
-        }
-      ]
+      CONFIG_FILE = "config/languages.yml"
+      LANGUAGES = [] # retained for backwards compatability
 
       def find(name)
-        LANGUAGES.find { |l| l[:name] == name.to_s }
+        languages.find { |l| l[:name] == name.to_s }
       end
 
-      def guess(path)
+      def guess(path, fallback_name = nil)
         ext = File.extname(path)
-        LANGUAGES.find { |l| l[:ext] == ext }
+        lang = languages.find { |l| l[:ext] == ext }
+        lang || (find(fallback_name) if fallback_name)
+      end
+
+      protected
+
+      def languages
+        @_languages ||= [*ConfigLoader.call(CONFIG_FILE).definitions, *LANGUAGES]
       end
     end
   end

data/lib/lookbook/param.rb

@@ -0,0 +1,99 @@
+module Lookbook
+  class Param
+    attr_reader :name, :options, :value_default, :description
+
+    def initialize(name:, input: nil, description: nil, value_type: nil, value_default: nil, value: nil, options: {})
+      @name = name
+      @input = input
+      @description = description
+      @value_type = value_type
+      @value_default = value_default
+      @value = value
+      @options = options
+    end
+
+    def label
+      options.label || name.titleize
+    end
+
+    def hint
+      options.hint
+    end
+
+    def input
+      @input || guess_input
+    end
+
+    def value
+      @value || value_default
+    end
+
+    def value_type
+      @value_type || guess_value_type
+    end
+
+    def input_options
+      return @_input_options if @_input_options
+
+      runtime_options = options.except([*methods, :name, :value_default, :description])
+      @_input_options ||= Store.new(input_config.options.merge(runtime_options))
+    end
+
+    def input_partial
+      input_config.partial
+    end
+
+    def cast_value
+      raise ArgumentError.new("Cannot cast param '#{name}' without a value set") if value.nil?
+
+      StringValueCaster.call(value, value_type)
+    end
+
+    def self.from_tag(tag, value: nil)
+      new(
+        name: tag.name,
+        input: tag.input || tag.options.input,
+        description: tag.description || tag.options.description,
+        value_type: tag.value_type || tag.options.value_type,
+        value_default: tag.value_default,
+        options: tag.options,
+        value: value
+      )
+    end
+
+    protected
+
+    def input_config
+      config = Lookbook::Engine.inputs.get_input(input)
+      config || raise(LookbookError.new("Unknown input type '#{input}'"))
+    end
+
+    def guess_input
+      if @value_type == "boolean" || (@value_type.blank? && boolean?(value_default))
+        "toggle"
+      else
+        "text"
+      end
+    end
+
+    def guess_value_type
+      if input == "toggle"
+        "boolean"
+      elsif input == "number"
+        "integer"
+      elsif boolean?(value_default)
+        "boolean"
+      elsif value_default.is_a?(Symbol)
+        "symbol"
+      elsif ["date", "datetime-local"].include?(input) || value_default.is_a?(DateTime)
+        "datetime"
+      else
+        "string"
+      end
+    end
+
+    def boolean?(value)
+      value == true || value == false
+    end
+  end
+end

data/lib/lookbook/{preview_controller.rb → preview_actions.rb}

@@ -1,5 +1,9 @@
 module Lookbook
-  module PreviewController
+  module PreviewActions
+    def self.included(klass)
+      klass.helper Lookbook::PreviewHelper
+    end
+
     def render_example_to_string(preview, example_name)
       prepend_application_view_paths
       prepend_preview_examples_view_path
@@ -12,7 +16,7 @@ module Lookbook
       opts[:layout] = nil
       opts[:locals] = locals if locals.present?
 
-      Utils.with_optional_action_view_annotations do
+      with_optional_action_view_annotations do
         render html: render_to_string(template, **opts)
       end
     end
@@ -20,7 +24,7 @@ module Lookbook
     def render_in_layout_to_string(template, locals, opts = {})
       append_view_path Lookbook::Engine.root.join("app/views")
 
-      Utils.with_optional_action_view_annotations do
+      with_optional_action_view_annotations do
         html = render_to_string(template, locals: locals, **determine_layout(opts[:layout]))
         if opts[:append_html].present?
           html += opts[:append_html]
@@ -28,5 +32,12 @@ module Lookbook
         render html: html
       end
     end
+
+    protected
+
+    def with_optional_action_view_annotations(&block)
+      disable = Lookbook.config.preview_disable_action_view_annotations
+      ActionViewAnnotationsHandler.call(disable_annotations: disable, &block)
+    end
   end
 end

data/lib/lookbook/preview_parser.rb

@@ -0,0 +1,53 @@
+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(&block)
+      unless @parsing
+        @parsing = true
+        @after_parse_once_callbacks << block if block
+        YARD::Registry.clear
+        YARD.parse(paths)
+      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/process.rb

@@ -0,0 +1,21 @@
+module Lookbook
+  class Process
+    attr_reader :env
+
+    def initialize(env: Rails.env)
+      @env = env
+    end
+
+    def supports_listening?
+      !rake_task? && !Rails.const_defined?(:Console)
+    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/rendered_example.rb

@@ -0,0 +1,37 @@
+module Lookbook
+  class RenderedExample
+    delegate_missing_to :example
+
+    attr_reader :output, :example
+
+    def initialize(example, output, params)
+      @example = example
+      @params = params
+      @output = output
+    end
+
+    def source
+      has_custom_template? ? template_source(template) : example.source
+    end
+
+    def source_lang
+      has_custom_template? ? template_lang(template) : example.source_lang
+    end
+
+    protected
+
+    attr_reader :params
+
+    def render_args
+      @_render_args ||= preview.render_args(example.name, params: params)
+    end
+
+    def template
+      render_args[:template]
+    end
+
+    def has_custom_template?
+      template != "view_components/preview" && !custom_source?
+    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/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.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
+          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)
+      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