lookbook 1.2.1 → 1.4.5

data/lib/lookbook/support/utils/utils.rb

@@ -0,0 +1,24 @@
+module Lookbook
+  module Utils
+    class << self
+      def id(*args)
+        parts = args.map { |arg| arg.to_s }
+        id_str = parts.join("-").force_encoding("UTF-8").parameterize.dasherize
+        PathUtils.strip_slashes(id_str).tr("/", "-").gsub("--", "-")
+      end
+
+      def name(str)
+        str.to_s.parameterize.tr("-", "_")
+      end
+
+      def value_or_fallback(value, fallback = nil, &block)
+        if value.nil?
+          fallback_block = block || proc { fallback }
+          fallback_block.call
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/lookbook/tags/component_tag.rb

@@ -0,0 +1,13 @@
+module Lookbook
+  class ComponentTag < YardTag
+    def value
+      text.constantize if text.present?
+    rescue
+      nil
+    end
+
+    def tag_body
+      text
+    end
+  end
+end

data/lib/lookbook/tags/custom_tag.rb

@@ -0,0 +1,61 @@
+module Lookbook
+  class CustomTag < YardTag
+    supports_options
+
+    attr_reader :arg_names, :tag_args
+
+    def initialize(tag_name, text = nil, *args)
+      tag_definition = Engine.tags.get_tag(tag_name)
+      unless tag_definition
+        raise ParserError.new "Unknown custom tag type '#{tag_name}'"
+      end
+
+      super(tag_name, text.to_s, *args)
+
+      @custom_attributes = Store.new
+      @arg_names = tag_definition.options.fetch(:named_args, [])
+      @after_parse = tag_definition.options.fetch(:after_parse, nil)
+
+      validate_arg_names
+
+      @tag_args = parse_tag
+      @after_parse.call(self) if @after_parse.respond_to?(:call)
+    end
+
+    # Method aliases to keep compatability with
+    # the original custom tag implementation
+    alias_method :tag_body, :text
+    alias_method :opts, :options
+
+    protected
+
+    def parse_tag
+      text_tokens = Shellwords.split(text)
+      values = text_tokens.slice(0, arg_names.size)
+
+      arg_names.map.with_index do |name, i|
+        [name.to_sym, values[i]]
+      end.to_h
+    end
+
+    def validate_arg_names
+      arg_names.each do |name|
+        if methods.include? name.to_sym
+          raise ParserError.new "'#{name}' is a reserved word and cannot be used as an argument name."
+        end
+      end
+    end
+
+    def method_missing(name, *args)
+      if name.end_with? "="
+        @custom_attributes[name.to_s.chomp("=")] = args.first
+      else
+        @custom_attributes.public_send(name, *args) || tag_args[name]
+      end
+    end
+
+    def respond_to_missing?(name, include_private)
+      @custom_attributes.key?(name) || tag_args.key?(name) || super
+    end
+  end
+end

data/lib/lookbook/tags/display_tag.rb

@@ -0,0 +1,15 @@
+module Lookbook
+  class DisplayTag < YardTag
+    def key
+      parts.first
+    end
+
+    def value
+      parts.second
+    end
+
+    def parts
+      @parts ||= KeyValueTagParser.call(text)
+    end
+  end
+end

data/lib/lookbook/tags/hidden_tag.rb

@@ -0,0 +1,13 @@
+module Lookbook
+  class HiddenTag < YardTag
+    def value
+      text != "false"
+    end
+
+    def to_s
+      value ? "true" : "false"
+    end
+
+    alias_method :to_bool, :value
+  end
+end

data/lib/lookbook/tags/id_tag.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class IdTag < YardTag
+    def value
+      Utils.id(text) if text.present?
+    end
+  end
+end

data/lib/lookbook/tags/label_tag.rb

@@ -0,0 +1,4 @@
+module Lookbook
+  class LabelTag < YardTag
+  end
+end

data/lib/lookbook/tags/logical_path_tag.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class LogicalPathTag < YardTag
+    def value
+      PathUtils.strip_slashes(super)
+    end
+  end
+end

data/lib/lookbook/tags/param_tag.rb

@@ -0,0 +1,63 @@
+module Lookbook
+  class ParamTag < YardTag
+    VALUE_TYPE_MATCHER = /^(\[\s?([A-Z]{1}\w+)\s?\])/
+    DESCRIPTION_MATCHER = /(?<=\s|^)"(.*[^\\])"(?:\s|$)/
+
+    supports_options
+
+    attr_reader :tag_args
+
+    def initialize(text)
+      @name, text_without_name = extract_name(text)
+      @tag_args = parse_tag_body(text_without_name)
+      super("param", tag_args[:rest], nil, @name)
+    end
+
+    def input
+      tag_args[:input]&.downcase&.tr("_", "-")
+    end
+
+    def description
+      tag_args[:description]
+    end
+
+    def value_type
+      tag_args[:value_type]&.downcase
+    end
+
+    def value_default
+      default_value_parts = object.parameters.find { |parts| parts[0].chomp(":") == name }
+      if default_value_parts
+        object.instance_eval(default_value_parts[1])
+      else
+        raise ParserError.new "Unknown method parameter '#{name}'"
+      end
+    end
+
+    protected
+
+    def extract_name(text)
+      parts = text.to_s.split(" ")
+      [parts.shift, parts.join(" ")]
+    end
+
+    def parse_tag_body(text)
+      value_type = nil
+      description = nil
+
+      text.match(VALUE_TYPE_MATCHER) do |match_data|
+        value_type = match_data[2]
+        text.gsub!(VALUE_TYPE_MATCHER, "").strip!
+      end
+
+      text.match(DESCRIPTION_MATCHER) do |match_data|
+        description = match_data[1]
+        text.gsub!(DESCRIPTION_MATCHER, "").strip!
+      end
+
+      input, rest = text.split(" ", 2)
+
+      {input: input, value_type: value_type, description: description, rest: rest}
+    end
+  end
+end

data/lib/lookbook/tags/position_tag.rb

@@ -0,0 +1,16 @@
+module Lookbook
+  class PositionTag < YardTag
+    DEFAULT_POSITION = 100000
+
+    def value
+      if text.present?
+        int = text.to_i
+        (int == 0) ? DEFAULT_POSITION : int
+      else
+        DEFAULT_POSITION
+      end
+    end
+
+    alias_method :to_i, :value
+  end
+end

data/lib/lookbook/tags/source_tag.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class SourceTag < YardTag
+    def value
+      resolve_path(text.strip) if text.present?
+    end
+  end
+end

data/lib/lookbook/tags/tag_provider.rb

@@ -0,0 +1,18 @@
+module Lookbook
+  class TagProvider < ::YARD::Tags::Tag
+    def self.new(tag_name, text, types = nil, name = nil)
+      tag_name = tag_name.to_s
+
+      if tag_name == "custom"
+        raise NameError.new "'custom' is a reserved tag name and cannot be used"
+      end
+
+      begin
+        tag_class = "Lookbook::#{tag_name.camelize}Tag".constantize
+        tag_class.new(text)
+      rescue NameError
+        CustomTag.new(tag_name, text)
+      end
+    end
+  end
+end

data/lib/lookbook/tags/yard_tag.rb

@@ -0,0 +1,90 @@
+module Lookbook
+  class YardTag < ::YARD::Tags::Tag
+    def initialize(*args)
+      if args.size < 2
+        tag_name = self.class.name.demodulize.underscore.chomp("_tag")
+        super(tag_name, args.first, nil, @name)
+      else
+        super(*args)
+      end
+    end
+
+    def text
+      tag_parts[:text]
+    end
+
+    def options
+      tag_parts[:options]
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    # The `value` attribute should be overriden in child classes
+    # to return the resolved value of the tag, where appropriate.
+    # i.e. for the @hidden tag this would return boolean true/false.
+    alias_method :value, :text
+
+    def self.supports_options(value = true)
+      @supports_options = !!value
+    end
+
+    def self.supports_options?
+      @supports_options.nil? ? false : @supports_options
+    end
+
+    supports_options
+
+    protected
+
+    def tag_parts
+      if @tag_parts.nil?
+        options, text = if self.class.supports_options?
+          TagOptionsParser.call(@text, {
+            file: host_file,
+            base_dir: host_file&.dirname,
+            eval_context: host_class_instance,
+            permit_eval: Lookbook.config.preview_params_options_eval
+          })
+        else
+          [{}, @text]
+        end
+      end
+      @tag_parts ||= {options: options, text: text}
+    end
+
+    def resolve_path(path)
+      return unless host_file
+
+      dir = path.start_with?(".") ? host_file.dirname : host_file_base_directory
+      Pathname(File.expand_path(path, dir))
+    end
+
+    def host_file
+      location = object&.files&.first # [file, line_number]
+      Pathname(location.first) if location
+    end
+
+    def host_file_base_directory
+      return unless host_file
+
+      directories = Engine.preview_paths.map(&:to_s).sort_by(&:length).reverse
+      directories.first { |dir| host_file.to_s.start_with?(dir) }
+    end
+
+    def host_class_instance
+      host_class = lookup_host_class
+      host_class&.new
+    end
+
+    def lookup_host_class
+      host_code_object = if object.is_a?(YARD::CodeObjects::MethodObject)
+        object.parent
+      elsif object.is_a?(YARD::CodeObjects::ClassObject)
+        object
+      end
+      host_code_object&.path&.constantize
+    end
+  end
+end

data/lib/lookbook/theme.rb

@@ -12,6 +12,14 @@ module Lookbook
       blue: {
         favicon_light_mode: "#2563EB",
         favicon_dark_mode: "#60A5FA"
+      },
+      green: {
+        favicon_light_mode: "#16a34a",
+        favicon_dark_mode: "#66E093"
+      },
+      rose: {
+        favicon_light_mode: "#E11D48",
+        favicon_dark_mode: "#FFA0B5"
       }
     }
 

data/lib/lookbook/version.rb

@@ -1,3 +1,3 @@
 module Lookbook
-  VERSION = "1.2.1"
+  VERSION = "1.4.5"
 end

data/lib/lookbook/websocket.rb

@@ -0,0 +1,60 @@
+module Lookbook
+  class Websocket
+    attr_reader :engine_mount_path, :server, :logger
+
+    def initialize(engine_mount_path, logger: Lookbook.logger)
+      @engine_mount_path = engine_mount_path
+      @logger = logger
+
+      logger.info "Initializing websocket"
+
+      if Gem::Version.new(Rails.version) >= Gem::Version.new(6.0)
+        @server = ActionCable::Server::Base.new config: cable_config
+      else
+        @server = ActionCable::Server::Base.new
+        @server.config = cable_config
+      end
+    end
+
+    def broadcast(message, payload = nil)
+      logger.debug message.to_s
+      server.broadcast(message.to_s, payload.to_h)
+    end
+
+    def mount_path
+      "/cable"
+    end
+
+    def full_mount_path
+      "#{engine_mount_path}/#{mount_path}".gsub("//", "/")
+    end
+
+    def mountable?
+      true
+    end
+
+    alias_method :mounted?, :mountable?
+
+    def self.noop
+      NullWebsocket.new
+    end
+
+    protected
+
+    def cable_config
+      cable = ActionCable::Server::Configuration.new
+      cable.cable = {adapter: "async"}.with_indifferent_access
+      cable.mount_path = nil
+      cable.connection_class = -> { Lookbook::Connection }
+      cable.logger = logger
+      cable
+    end
+  end
+
+  class NullWebsocket < NullObject
+    def mountable?
+      false
+    end
+    alias_method :mounted?, :mountable?
+  end
+end

data/lib/lookbook.rb

@@ -6,6 +6,7 @@ loader.ignore("#{__dir__}/lookbook.rb")
 loader.push_dir("#{__dir__}/lookbook", namespace: Lookbook)
 loader.collapse("#{__dir__}/lookbook/*")
 loader.collapse("#{__dir__}/lookbook/*/*")
+loader.collapse("#{__dir__}/lookbook/*/*/*")
 loader.setup
 
 module Lookbook
@@ -15,23 +16,27 @@ module Lookbook
     end
 
     def config
-      @config ||= ConfigStore.init_from_config
+      @_config ||= ConfigStore.init_from_config
     end
 
     def configure
       yield(config)
     end
 
+    def engine
+      Engine
+    end
+
     def data
-      @data ||= Store.new
+      @_data ||= Store.new
     end
 
     def data=(new_data)
-      @data = Store.new(new_data)
+      @_data = Store.new(new_data)
     end
 
     def logger
-      @logger ||= if Rails.logger.present? && config.log_use_rails_logger
+      @_logger ||= if Rails.logger.present? && config.log_use_rails_logger
         Rails.logger
       else
         logger = Logger.new($stdout)
@@ -54,11 +59,11 @@ module Lookbook
     end
 
     def previews
-      Preview.all
+      Engine.previews
     end
 
     def pages
-      Page.all
+      Engine.pages
     end
 
     def broadcast(event_name, data = {})
@@ -66,7 +71,7 @@ module Lookbook
     end
 
     def theme
-      @theme ||= Lookbook::Theme.new(config.ui_theme, config.ui_theme_overrides)
+      @_theme ||= Lookbook::Theme.new(config.ui_theme, config.ui_theme_overrides)
     end
 
     def define_param_input(*args)
@@ -88,7 +93,7 @@ module Lookbook
     def define_tag(name, args = nil, &block)
       Engine.tags.add_tag(name, {
         named_args: args.to_a,
-        args_parser: block
+        after_parse: block
       })
     end