lookbook 1.2.1 → 1.4.5

data/lib/lookbook/preview.rb

@@ -1,174 +0,0 @@
-module Lookbook
-  class Preview < Collection
-    include Utils
-
-    delegate :name, :render_args, to: :@preview
-    delegate :position, :group, :notes, :hidden?, :tags, :tag, to: :@preview_inspector
-
-    def initialize(preview, code_object)
-      @preview = preview
-      @preview_inspector = SourceInspector.new(code_object, eval_scope: preview_class.new)
-      super(preview_class_path(@preview.name))
-    end
-
-    def id
-      @preview_inspector&.id || generate_id(lookup_path)
-    end
-
-    def preview_class_name
-      @preview.name
-    end
-
-    def preview_class
-      @preview
-    end
-
-    def label
-      @preview_inspector&.label&.presence || lookup_path.split("/").last.titleize
-    end
-
-    def type
-      :preview
-    end
-
-    def example(example_name)
-      examples.find { |m| m.name == example_name.to_s }
-    end
-
-    def examples
-      return @examples if @examples.present?
-      public_methods = @preview.public_instance_methods(false)
-      public_method_objects = @preview_inspector&.methods&.select { |m| public_methods.include?(m.name) }
-      examples = (public_method_objects || []).map { |m| PreviewExample.new(m.name.to_s, self, m) }
-      sorted = Lookbook.config.sort_examples ? examples.sort_by(&:label) : examples
-      @examples = []
-      if @preview_inspector&.groups&.any?
-        sorted.group_by { |m| m.group }.each do |name, examples|
-          if name.nil?
-            @examples += examples
-          else
-            name = label if name.strip == ""
-            @examples << PreviewGroup.new(name.underscore, self, examples)
-          end
-        end
-      else
-        @examples = sorted
-      end
-      @examples = @examples.compact
-    end
-
-    def items
-      examples.reject { |i| i.hidden? }
-    end
-
-    def default_example
-      examples.first
-    end
-
-    def rel_path
-      "#{name.underscore}.rb"
-    end
-
-    def full_path
-      base_path = preview_paths.detect do |preview_path|
-        Dir["#{preview_path}/#{rel_path}"].first
-      end
-      Pathname.new(Dir["#{base_path}/#{rel_path}"].first)
-    end
-
-    def url_path
-      lookbook_inspect_path lookup_path
-    end
-
-    def parent_collections_names
-      File.dirname(path).split("/")
-    end
-
-    def hierarchy_depth
-      path.split("/").size
-    end
-
-    def layout
-      @preview.instance_variable_get(:@layout)
-    end
-
-    def display_options
-      Lookbook.config.preview_display_options.deep_merge(@preview_inspector&.display_options)
-    end
-
-    def collapsible?
-      true
-    end
-
-    def component
-      components.first
-    end
-
-    def components
-      component_classes = @preview_inspector&.components&.any? ? @preview_inspector&.components : [guess_component]
-      component_classes.map do |class_name|
-        Component.new(class_name.to_s)
-      end
-    end
-
-    def preview_paths
-      PathUtils.normalize_all(Lookbook.config.preview_paths)
-    end
-
-    protected
-
-    @preview_objects = nil
-    @previews = nil
-
-    def guess_component
-      name.chomp("Preview").constantize
-    rescue
-      nil
-    end
-
-    class << self
-      def find(path)
-        all.find { |p| p.lookup_path == path }
-      end
-
-      def exists?(path)
-        !!find(path)
-      end
-
-      def any?
-        all.any?
-      end
-
-      def all
-        if @previews.nil? && @preview_objects.present?
-          previews = @preview_objects.map do |code_object|
-            klass = code_object.path.constantize
-            new(klass, code_object) if klass.ancestors.include?(ViewComponent::Preview)
-          rescue => exception
-            Lookbook.logger.error Lookbook::Error.new(exception)
-            nil
-          end.compact
-
-          sorted_previews = previews.compact.sort_by { |preview| [preview.position, preview.label] }
-          @previews = PreviewCollection.new(sorted_previews)
-          @previews
-        elsif !@preview_objects.present?
-          PreviewCollection.new([])
-        else
-          @previews
-        end
-      end
-
-      def errors
-        @errors ||= []
-      end
-
-      def load!(preview_objects)
-        @preview_objects = preview_objects
-        @previews = nil
-      end
-    end
-
-    alias_method :lookup_path, :path
-  end
-end

data/lib/lookbook/preview_collection.rb

@@ -1,23 +0,0 @@
-module Lookbook
-  class PreviewCollection < Collection
-    def id
-      generate_id("preview-collection", lookup_path || "root")
-    end
-
-    def label
-      "Previews"
-    end
-
-    def find_example(path)
-      Lookbook::PreviewExample.all.find { |e| e.lookup_path == path }
-    end
-
-    def type
-      :preview_collection
-    end
-
-    def self.describe_as
-      "previews"
-    end
-  end
-end

data/lib/lookbook/preview_example.rb

@@ -1,93 +0,0 @@
-module Lookbook
-  class PreviewExample < Entity
-    attr_reader :name, :preview
-    delegate :params, :position, :group, :notes, :hidden?, :source, :tags, :tag, to: :@example_inspector
-
-    def initialize(name, preview, code_object)
-      @name = name
-      @preview = preview
-      @example_inspector = SourceInspector.new(code_object, eval_scope: @preview.preview_class.new)
-      super("#{@preview.path}/#{name}")
-    end
-
-    def id
-      @example_inspector&.id || generate_id(@preview.id, name)
-    end
-
-    def url_path
-      lookbook_inspect_path lookup_path
-    end
-
-    def label
-      @example_inspector.label.presence || name.titleize
-    end
-
-    def display_options
-      @preview.display_options.merge(@example_inspector.display_options)
-    end
-
-    def method_source
-      @example_inspector.source.sub(/^def \w+\s?(\([^)]+\))?/m, "").split("\n")[0..-2].join("\n").strip_heredoc.strip
-    end
-
-    def lang
-      Lookbook::Lang.find(:ruby)
-    end
-
-    def template_source(template_path)
-      source_path = full_template_path(template_path)
-      source_path ? File.read(source_path) : nil
-    end
-
-    def template_lang(template_path)
-      Lookbook::Lang.guess(full_template_path(template_path)) || Lookbook::Lang.find(:html)
-    end
-
-    def type
-      :example
-    end
-
-    def matchers
-      normalize_matchers(@preview.label, label)
-    end
-
-    def hierarchy_depth
-      @preview.hierarchy_depth + 1
-    end
-
-    protected
-
-    def strip_ext(path)
-      path.sub(/\..*$/, "")
-    end
-
-    def full_template_path(template_path)
-      template_path = strip_ext template_path
-      base_path = preview_paths.detect do |p|
-        Dir["#{p}/#{template_path}.html.*"].first
-      end
-      path = Dir["#{base_path}/#{template_path}.html.*"].first
-      path ? Pathname.new(path) : nil
-    end
-
-    def preview_paths
-      PathUtils.normalize_all(Lookbook.config.preview_paths)
-    end
-
-    class << self
-      def all
-        Preview.all.map { |preview| preview.examples }.flatten
-      end
-
-      def find(path)
-        all.find { |p| p.lookup_path == path }
-      end
-
-      def exists?(path)
-        !!find(path)
-      end
-    end
-
-    alias_method :lookup_path, :path
-  end
-end

data/lib/lookbook/preview_group.rb

@@ -1,62 +0,0 @@
-module Lookbook
-  class PreviewGroup < Entity
-    attr_reader :name, :examples, :preview
-
-    def initialize(name, preview, examples)
-      @name = name
-      @preview = preview
-      @examples = examples
-      super("#{@preview.path}/#{name}")
-    end
-
-    def url_path
-      lookbook_inspect_path lookup_path
-    end
-
-    def label
-      name.titleize
-    end
-
-    def type
-      :group
-    end
-
-    def params
-      examples.map(&:params).flatten.uniq { |param| param[:name] }
-    end
-
-    def display_options
-      merged = {}
-      examples.reverse.map do |example|
-        merged.merge! example.display_options
-      end
-      merged
-    end
-
-    def hidden?
-      false
-    end
-
-    def position
-      10000
-    end
-
-    def matchers
-      normalize_matchers(@preview.label, label)
-    end
-
-    def hierarchy_depth
-      @preview.hierarchy_depth + 1
-    end
-
-    def tags(name = nil)
-      examples.map { |example| example.tags(name) }.flatten
-    end
-
-    def tag(name = nil)
-      tags(name).first
-    end
-
-    alias_method :lookup_path, :path
-  end
-end

data/lib/lookbook/source_inspector.rb

@@ -1,95 +0,0 @@
-module Lookbook
-  class SourceInspector
-    include Utils
-
-    attr_reader :code_object
-    delegate :groups, :source, to: :@code_object, allow_nil: true
-
-    def initialize(code_object, eval_scope: nil)
-      @code_object = code_object
-      @eval_scope = eval_scope
-    end
-
-    def hidden?
-      @hidden ||= if code_object&.tag(:hidden)
-        code_object.tag(:hidden).text.strip != "false"
-      else
-        false
-      end
-    end
-
-    def id
-      @id ||= if code_object&.tag(:id)&.text&.present?
-        generate_id(code_object&.tag(:id)&.text)
-      end
-    end
-
-    def label
-      @label ||= code_object&.tag(:label)&.text
-    end
-
-    def notes
-      @notes ||= if code_object&.docstring
-        code_object.docstring.to_s.strip
-      end
-    end
-
-    def group
-      @group ||= code_object&.group
-    end
-
-    def position
-      @position ||= code_object&.tag(:position)&.text&.to_i || 10000
-    end
-
-    def components
-      @components ||= if code_object&.tags(:component).present?
-        code_object.tags(:component).map do |component|
-          component.text.constantize
-        end
-      else
-        []
-      end
-    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
-    end
-
-    def parameter_defaults
-      @param_defaults ||= code_object&.parameters&.map { |str| Params.parse_method_param_str(str) }&.compact&.to_h
-    end
-
-    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)
-      end
-    end
-
-    def methods
-      @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?))
-    end
-
-    def tag(name = nil)
-      tags(name).first
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-module Lookbook
-  module AttributeUtils
-    class << self
-      def dom_id(*args)
-        ["lookbook", *args].join("-").parameterize.dasherize
-      end
-    end
-  end
-end

data/lib/lookbook/tag.rb

@@ -1,122 +0,0 @@
-require "shellwords"
-
-module Lookbook
-  class Tag
-    attr_reader :data, :arg_names
-    attr_accessor :args, :opts
-
-    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
-
-    def tag_name
-      @name ||= @tag_object.tag_name.to_sym
-    end
-
-    def tag_body
-      @tag_object.text
-    end
-
-    def get_opt(key, fallback = nil)
-      opts[key] || fallback
-    end
-
-    def opts_str
-      @opts_str ||= text_tokens.size > args_count ? text_tokens.slice(args_count, text_tokens.size).join(" ") : ""
-    end
-
-    protected
-
-    def parse_args
-      unless arg_names.nil?
-        values = text_tokens.slice(0, args_count)
-        @args = build_args(values)
-      end
-    end
-
-    def parse_opts
-      return @opts if @options[:parse_options] == false
-      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
-      parse_args
-      parse_opts
-      @parser.call(self) if @parser.respond_to?(:call)
-    end
-
-    def arg_options
-      return [] if arg_names.nil?
-      @arg_options ||= arg_names.map do |arg|
-        unless arg.is_a? Hash
-          name = arg
-          arg = {
-            name: name.to_sym
-          }
-        end
-        arg[:parse] = false unless arg.key? :parse
-        arg
-      end
-    end
-
-    def validate_arg_names
-      if arg_names.present?
-        arg_names.each do |name|
-          if methods.include? name.to_sym
-            raise ArgumentError, "'#{name}' is a reserved word and cannot be used as an argument name."
-          end
-        end
-      end
-    end
-
-    def args_count
-      arg_options.size
-    end
-
-    def parse_yaml(str, fallback = "~")
-      YAML.safe_load(str || fallback)
-    end
-
-    def text_tokens
-      @tokens ||= Shellwords.split(@tag_object.text)
-    end
-
-    def build_args(values)
-      arg_options.map.with_index do |arg, i|
-        value = values[i]
-        value = parse_arg(value) if arg[:parse] == true && value.present?
-        [arg[:name].to_sym, value]
-      end.to_h
-    end
-
-    def method_missing(name, *method_args)
-      if name.end_with? "="
-        data[name.to_s.chomp("=").to_sym] = method_args.first
-      else
-        data[name] || args[name]
-      end
-    end
-
-    def respond_to_missing?(name, *)
-      data.key?(name) || args.key?(name)
-    end
-  end
-end

data/lib/lookbook/tag_options.rb

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

@@ -1,17 +0,0 @@
-module Lookbook
-  module Tags
-    def self.process_tags(tag_objects, file: nil, eval_scope: nil)
-      return [] if tag_objects.none?
-      tag_objects.map do |tag_object|
-        tag_config = Engine.tags.get_tag(tag_object.tag_name).to_h
-        tag_opts = tag_config[:opts].to_h
-        Lookbook::Tag.new(tag_object,
-          tag_opts[:named_args],
-          parser: tag_opts[:args_parser],
-          **tag_opts.except(:named_args, :args_parser),
-          file: file,
-          eval_scope: eval_scope)
-      end.compact
-    end
-  end
-end