lookbook 1.0.8 → 1.1.1

data/lib/lookbook/parser.rb

@@ -39,6 +39,7 @@ module Lookbook
         YARD::Tags::Library.define_tag("Position", :position)
         YARD::Tags::Library.define_tag("ID", :id)
         YARD::Tags::Library.define_tag("Component", :component)
+        YARD::Tags::Library.define_tag("Param", :param, :with_name)
         custom.each do |name, opts|
           YARD::Tags::Library.define_tag(name.to_s.titleize, name)
         end

data/lib/lookbook/preview.rb

@@ -7,7 +7,7 @@ module Lookbook
 
     def initialize(preview, code_object)
       @preview = preview
-      @preview_inspector = SourceInspector.new(code_object)
+      @preview_inspector = SourceInspector.new(code_object, eval_scope: preview_class.new)
       super(preview_class_path(@preview.name))
     end
 
@@ -15,10 +15,14 @@ module Lookbook
       @preview_inspector&.id || generate_id(lookup_path)
     end
 
-    def preview_class
+    def preview_class_name
       @preview.name
     end
 
+    def preview_class
+      @preview
+    end
+
     def label
       @preview_inspector&.label&.presence || lookup_path.split("/").last.titleize
     end
@@ -143,10 +147,12 @@ module Lookbook
 
           sorted_previews = previews.compact.sort_by { |preview| [preview.position, preview.label] }
           @previews = PreviewCollection.new(sorted_previews)
-        else
+          @previews
+        elsif !@preview_objects.present?
           PreviewCollection.new([])
+        else
+          @previews
         end
-        @previews
       end
 
       def errors

data/lib/lookbook/preview_controller.rb

@@ -12,32 +12,20 @@ module Lookbook
       opts[:layout] = nil
       opts[:locals] = locals if locals.present?
 
-      with_optional_annotations do
+      Utils.with_optional_action_view_annotations do
         render html: render_to_string(template, **opts)
       end
     end
 
     def render_in_layout_to_string(template, locals, opts = {})
       append_view_path Lookbook::Engine.root.join("app/views")
-      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
-
-    def with_optional_annotations
-      if ActionView::Base.respond_to?(:annotate_rendered_view_with_filenames) && Lookbook.config.preview_disable_action_view_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
+      Utils.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]
+        end
+        render html: html
       end
     end
   end

data/lib/lookbook/preview_example.rb

@@ -6,7 +6,7 @@ module Lookbook
     def initialize(name, preview, code_object)
       @name = name
       @preview = preview
-      @example_inspector = SourceInspector.new(code_object)
+      @example_inspector = SourceInspector.new(code_object, eval_scope: @preview.preview_class.new)
       super("#{@preview.path}/#{name}")
     end
 

data/lib/lookbook/source_inspector.rb

@@ -5,8 +5,9 @@ module Lookbook
     attr_reader :code_object
     delegate :groups, :source, to: :@code_object, allow_nil: true
 
-    def initialize(code_object)
+    def initialize(code_object, eval_scope: nil)
       @code_object = code_object
+      @eval_scope = eval_scope
     end
 
     def hidden?
@@ -74,8 +75,11 @@ module Lookbook
     end
 
     def params
-      code_object&.tags("param")&.map do |param|
-        Lookbook::Params.build_param(param, default: parameter_defaults[param.name])
+      @params ||= {}
+      @params[:param] ||= code_object&.tags("param")&.map do |param|
+        Lookbook::Params.build_param(param,
+          default: parameter_defaults[param.name],
+          eval_scope: @eval_scope)
       end
     end
 
@@ -85,7 +89,9 @@ module Lookbook
 
     def tags(name = nil)
       tag_objects = code_object&.tags(name).presence || []
-      Lookbook::Tags.process_tags(tag_objects)
+      Lookbook::Tags.process_tags(tag_objects,
+        eval_scope: @eval_scope,
+        file: (code_object.files.first[0] if code_object.files.any?))
     end
 
     def tag(name = nil)

data/lib/lookbook/store.rb

@@ -1,48 +1,34 @@
 module Lookbook
   class Store < ActiveSupport::OrderedOptions
-    def initialize(data = {}, deep = false)
+    def initialize(data = {}, opts = {})
+      @recursive = opts[:recursive] || false
+      data.each { |key, value| self[key] = value }
       super()
-      @deep = deep
-      set(data) if data.present?
-    end
-
-    def [](key)
-      super(normalize_key(key))
     end
 
     def []=(key, value)
-      super(normalize_key(key), normalize_value(value))
-    end
-
-    def set(data)
-      data.keys.each do |key|
-        self[normalize_key(key)] = normalize_value(data[key])
-      end
-      self
+      super(key, normalize_value(value))
     end
 
-    def get(key, fallback = nil)
-      if key?(normalize_key(key))
-        self[normalize_key(key)]
-      else
-        fallback
-      end
+    def fetch(name, *args)
+      super(name.to_sym, *args)
     end
 
     def method_missing(name, *args)
-      super(normalize_key(name), *args.map { |arg| normalize_value(arg) })
+      if name.to_s.end_with?("=")
+        args[0] = normalize_value(args[0])
+      end
+      super(name, *args)
     end
 
-    def respond_to_missing?(name, *)
-      key?(name)
+    def respond_to_missing?(name, include_private)
+      true
     end
 
-    def normalize_key(key)
-      key.to_s.downcase.tr("-", "_").to_sym
-    end
+    private
 
     def normalize_value(value)
-      @deep && !value.is_a?(Store) && value.is_a?(Hash) ? Store.new(value, @deep) : value
+      @recursive && !value.is_a?(Store) && value.is_a?(Hash) ? Store.new(value, recursive: @recursive) : value
     end
   end
 end

data/lib/lookbook/tag.rb

@@ -5,13 +5,15 @@ module Lookbook
     attr_reader :data, :arg_names
     attr_accessor :args, :opts
 
-    def initialize(tag_object, arg_names = nil, parser: nil, **options)
+    def initialize(tag_object, arg_names = nil, parser: nil, eval_scope: nil, file: nil, **options)
       @tag_object = tag_object
       @arg_names = arg_names
       @args = {}
       @opts = {}
       @options = options
       @parser = parser
+      @eval_scope = eval_scope
+      @file = file
       @data = Store.new
       run_parser
     end
@@ -43,8 +45,16 @@ module Lookbook
 
     def parse_opts
       return @opts if @options[:parse_options] == false
-      parsed_opts = parse_yaml(opts_str)
-      @opts = parsed_opts.is_a?(Hash) ? parsed_opts.with_indifferent_access : {}
+      tag_opts = Lookbook::TagOptions.new(opts_str,
+        eval_scope: @eval_scope,
+        base_dir: File.dirname(@file))
+      options = tag_opts.resolve || {}
+      @opts = if options.is_a?(Hash)
+        options.with_indifferent_access
+      else
+        Lookbook.logger.warn "'@#{tag_name}' tag options should resolve to a Hash"
+        options
+      end
     end
 
     def run_parser

data/lib/lookbook/tag_options.rb

@@ -0,0 +1,111 @@
+module Lookbook
+  class TagOptions
+    SYMBOL_MATCH = /(:([a-zA-Z_\d]+))$/
+    EVAL_OPTION_MATCH = /(\{\{\s?(.*)\s?\}\})$/
+    YAML_HASH_MATCH = /(\{(.*?)\})$/m
+    YAML_ARRAY_MATCH = /(\[(.*?)\])$/m
+    FILE_PATH_MATCH = /(\S+\.(json|yml))$/
+
+    MATCHERS = [YAML_ARRAY_MATCH, YAML_HASH_MATCH, SYMBOL_MATCH, EVAL_OPTION_MATCH, FILE_PATH_MATCH]
+
+    def initialize(options_str, eval_scope: nil, base_dir: nil)
+      @options_str = options_str.is_a?(String) ? options_str.strip : ""
+      @eval_scope = eval_scope
+      @base_dir = base_dir
+    end
+
+    def options
+      resolve.is_a?(Hash) ? resolve.symbolize_keys : resolve
+    end
+
+    def resolve
+      @resolved_options ||= begin
+        if @options_str.present?
+          if @options_str.end_with?(".json", ".yml")
+            file_path = resolve_file_path
+            if file_path
+              options_file_content = File.read(file_path)
+            else
+              raise "Tag options data file not found"
+            end
+          end
+          if file_path&.extname == ".json"
+            JSON.parse(options_file_content)
+          elsif file_path&.extname == ".yml"
+            YAML.safe_load(options_file_content)
+          elsif evaluatable?
+            evaluate
+          else
+            YAML.safe_load(@options_str || "{}")
+          end
+        else
+          {}
+        end
+      rescue => exception
+        Lookbook.logger.warn Lookbook::Error.new(exception)
+        {}
+      end
+    end
+
+    def resolve_file_path
+      path = if @options_str.start_with?(".") && @base_dir.present?
+        File.expand_path(@options_str, @base_dir)
+      else
+        Rails.root.join(@options_str)
+      end
+      Pathname.new path
+    end
+
+    def evaluate
+      if Lookbook.config.preview_params_options_eval == true
+        if @eval_scope.nil?
+          raise "Preview params eval must be scoped to an object"
+        else
+          @eval_scope.instance_eval(statement)
+        end
+      else
+        raise "The config option `preview_params_options_eval` must be set to `true` before param options can be evaluated at runtime"
+      end
+    end
+
+    def self.extract_options(str)
+      str ||= ""
+      str.strip!
+      opts_str = ""
+
+      MATCHERS.each do |regexp|
+        match_data = str.match(regexp)
+        unless match_data.nil?
+          str.gsub!(regexp, "").strip!
+          opts_str = match_data[1]
+          break
+        end
+      end
+
+      [str, opts_str]
+    end
+
+    def self.resolveable?(str)
+      return unless str.is_a?(String)
+      str.strip!
+      MATCHERS.each do |regexp|
+        return true if str.match?(regexp)
+      end
+      false
+    end
+
+    private
+
+    def statement
+      evaluatable? ? eval_match_data[2].strip : "{}"
+    end
+
+    def evaluatable?
+      eval_match_data.present?
+    end
+
+    def eval_match_data
+      @eval_match_data ||= @options_str.match(EVAL_OPTION_MATCH) || @options_str.match(SYMBOL_MATCH)
+    end
+  end
+end

data/lib/lookbook/tags.rb

@@ -11,11 +11,15 @@ module Lookbook
       Lookbook.config.preview_tags[name] = opts
     end
 
-    def self.process_tags(tag_objects)
+    def self.process_tags(tag_objects, file: nil, eval_scope: nil)
       return [] if tag_objects.none?
       tag_objects.map do |tag_object|
         opts = Lookbook.config.preview_tags[tag_object.tag_name] || {}
-        Lookbook::Tag.new(tag_object, opts[:args], **opts.except(:args))
+        Lookbook::Tag.new(tag_object,
+          opts[:args],
+          **opts.except(:args),
+          file: file,
+          eval_scope: eval_scope)
       end.compact
     end
   end

data/lib/lookbook/template_parser.rb

@@ -0,0 +1,72 @@
+require "css_parser"
+
+module Lookbook
+  class TemplateParser
+    STYLE_TAGS_REGEX = /<style(?:\s[^>]*)?>((?:(?!<\/style>).)*)<\/style>/m
+    FRONTMATTER_REGEX = /\A---(.|\n)*?---/
+
+    def initialize(content)
+      @raw_content = content.strip
+      @parsed_content = nil
+      @styles = nil
+      @frontmatter = nil
+    end
+
+    def content
+      parse
+      @parsed_content.strip.html_safe
+    end
+
+    def styles
+      parse
+      @styles
+    end
+
+    def frontmatter
+      parse
+      @frontmatter
+    end
+
+    private
+
+    def parse
+      if @parsed_content.nil?
+        @styles = extract_styles(@raw_content)
+        content = strip_styles(@raw_content)
+
+        @frontmatter = extract_frontmatter(content)
+        content = strip_frontmatter(content)
+
+        @parsed_content = content
+      end
+    end
+
+    def extract_styles(text)
+      styles = []
+      css_parser = ::CssParser::Parser.new
+      text.scan(STYLE_TAGS_REGEX).flatten.map(&:strip).each do |css|
+        css_parser.load_string! css.strip
+      end
+      css_parser.each_selector do |selector, declarations, specificity|
+        styles << "#{selector} { #{declarations} }"
+      end
+      styles
+    end
+
+    def strip_styles(text)
+      text.gsub(STYLE_TAGS_REGEX, "")
+    end
+
+    def extract_frontmatter(text)
+      frontmatter = {}
+      text.match(FRONTMATTER_REGEX) do |m|
+        frontmatter = YAML.safe_load(m[0])
+      end
+      frontmatter.deep_symbolize_keys
+    end
+
+    def strip_frontmatter(text)
+      text.gsub(FRONTMATTER_REGEX, "")
+    end
+  end
+end

data/lib/lookbook/theme.rb

@@ -41,7 +41,7 @@ module Lookbook
       return @css unless @css.nil?
       @css ||= if @overrides.present?
         styles = [":root {"]
-        styles << @overrides.select { |key| !key.start_with?("favicon") }.map do |key, value|
+        styles << @overrides.reject { |key| key.to_s.start_with?("favicon") }.map do |key, value|
           "  --lookbook-#{key.to_s.underscore.tr("_", "-")}: #{value};"
         end
         styles.push "}"

data/lib/lookbook/utils.rb

@@ -4,6 +4,29 @@ module Lookbook
 
     POSITION_PREFIX_REGEX = /^(\d+?)[-_]/
     FRONTMATTER_REGEX = /\A---(.|\n)*?---/
+    ACTION_VIEW_ANNOTATIONS_REGEX = /<!-- (BEGIN|END) (.*) -->/
+
+    def self.strip_action_view_annotations!(text)
+      text&.gsub!(ACTION_VIEW_ANNOTATIONS_REGEX, "")
+    end
+
+    def self.without_action_view_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
+    end
+
+    def self.with_optional_action_view_annotations
+      if ActionView::Base.respond_to?(:annotate_rendered_view_with_filenames) && Lookbook.config.preview_disable_action_view_annotations
+        without_action_view_annotations do
+          yield
+        end
+      else
+        yield
+      end
+    end
 
     protected
 

data/lib/lookbook/version.rb

@@ -1,3 +1,3 @@
 module Lookbook
-  VERSION = "1.0.8"
+  VERSION = "1.1.1"
 end

data/lib/lookbook.rb

@@ -1,32 +1,79 @@
-require "active_support/dependencies/autoload"
-require "lookbook/engine"
+require "zeitwerk"
+require "ostruct"
 require "lookbook/version"
-require "view_component/engine"
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/lookbook.rb")
+loader.push_dir("#{__dir__}/lookbook", namespace: Lookbook)
+loader.setup
 
 module Lookbook
-  extend ActiveSupport::Autoload
-
-  autoload :Error, "lookbook/error"
-  autoload :Utils, "lookbook/utils"
-  autoload :Lang, "lookbook/lang"
-  autoload :Params, "lookbook/params"
-  autoload :Page, "lookbook/page"
-  autoload :Tag, "lookbook/tag"
-  autoload :PageSection, "lookbook/page_section"
-  autoload :PageCollection, "lookbook/page_collection"
-  autoload :Features, "lookbook/features"
-  autoload :Collection, "lookbook/collection"
-  autoload :Entity, "lookbook/entity"
-  autoload :Parser, "lookbook/parser"
-  autoload :Preview, "lookbook/preview"
-  autoload :PreviewCollection, "lookbook/preview_collection"
-  autoload :PreviewController, "lookbook/preview_controller"
-  autoload :PreviewExample, "lookbook/preview_example"
-  autoload :PreviewGroup, "lookbook/preview_group"
-  autoload :SourceInspector, "lookbook/source_inspector"
-  autoload :CodeFormatter, "lookbook/code_formatter"
-  autoload :Markdown, "lookbook/markdown"
-  autoload :Theme, "lookbook/theme"
-  autoload :Store, "lookbook/store"
-  autoload :Component, "lookbook/component"
+  class << self
+    include Lookbook::Hooks
+    include Lookbook::Panels
+    include Lookbook::Tags
+
+    def version
+      Lookbook::VERSION
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def configure
+      yield(config)
+    end
+
+    def data
+      @data ||= Store.new
+    end
+
+    def data=(new_data)
+      @data = Store.new(new_data)
+    end
+
+    def logger
+      @logger ||= if Rails.logger.present? && config.log_use_rails_logger
+        Rails.logger
+      else
+        logger = Logger.new($stdout)
+        logger.level = config.log_level
+        logger
+      end
+    end
+
+    def debug_data
+      {
+        version: version,
+        env: Rails.env.to_s,
+        config: config.to_h
+      }
+    end
+
+    def previews
+      Preview.all
+    end
+
+    def pages
+      Page.all
+    end
+
+    def broadcast(event_name, data = {})
+      Engine.websocket&.broadcast(event_name.to_s, data)
+    end
+
+    def theme
+      @theme ||= Lookbook::Theme.new(config.ui_theme, config.ui_theme_overrides)
+    end
+
+    def define_param_input(input, partial, input_options = nil)
+      config.preview_param_inputs[input.to_sym] = {
+        partial: partial,
+        input_options: input_options || {}
+      }
+    end
+  end
 end
+
+require "lookbook/engine"