lookbook 1.2.1 → 1.4.5

data/lib/lookbook/component.rb

@@ -1,34 +0,0 @@
-module Lookbook
-  class Component < Entity
-    attr_accessor :name
-
-    def initialize(name)
-      @name = name
-      super(path)
-    end
-
-    def path
-      name.underscore
-    end
-
-    def rel_path
-      Pathname.new("#{path}.rb")
-    end
-
-    def full_path
-      Pathname.new("#{Lookbook.config.components_path}/#{path}.rb")
-    end
-
-    def dir_path
-      full_path.dirname
-    end
-
-    def template_path
-      Dir.glob("#{Lookbook.config.components_path}/#{path}.*.erb").first
-    end
-
-    def inline?
-      template_path.present?
-    end
-  end
-end

data/lib/lookbook/entity.rb

@@ -1,47 +0,0 @@
-module Lookbook
-  class Entity
-    include Utils
-
-    def initialize(reference_path)
-      @refpath = reference_path
-    end
-
-    def id
-      generate_id(lookup_path)
-    end
-
-    def label
-      lookup_path.split("/").last.titleize
-    end
-
-    def type
-      :item
-    end
-
-    def path
-      @refpath
-    end
-
-    def lookup_path
-      @lookup_path ||= to_lookup_path(@refpath)
-    end
-
-    def hierarchy_depth
-      @refpath.present? ? @refpath.split("/").size : 0
-    end
-
-    def position
-      0
-    end
-
-    def hidden?
-      false
-    end
-
-    def matchers
-      nil
-    end
-
-    alias_method :url_path, :lookup_path
-  end
-end

data/lib/lookbook/markdown.rb

@@ -1,22 +0,0 @@
-require "redcarpet"
-
-module Lookbook
-  class Markdown
-    def self.render(text)
-      Utils.strip_action_view_annotations!(text)
-      markdown = Redcarpet::Markdown.new(Renderer, Lookbook.config.markdown_options.to_h)
-      markdown.render(text).html_safe
-    end
-
-    class Renderer < 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/page.rb

@@ -1,195 +0,0 @@
-module Lookbook
-  class Page < Entity
-    FRONTMATTER_FIELDS = [
-      :id,
-      :label,
-      :title,
-      :hidden,
-      :landing,
-      :position,
-      :markdown,
-      :header,
-      :footer,
-      :data
-    ]
-
-    attr_reader :errors, :rel_path
-    attr_accessor :sections
-
-    def initialize(path, base_path)
-      @pathname = Pathname.new path
-      @base_path = Pathname.new base_path
-      @options = nil
-      @errors = []
-      @sections = []
-      @page_name = remove_position_prefix(path_name)
-      @rel_path = @pathname.relative_path_from(@base_path)
-      page_path = @rel_path.dirname.to_s == "." ? @page_name : "#{@rel_path.dirname}/#{@page_name}"
-      super(page_path)
-    end
-
-    def url_path
-      lookbook_page_path lookup_path
-    end
-
-    def full_path
-      Pathname.new Rails.root.join(@pathname.to_s)
-    end
-
-    def name
-      @page_name
-    end
-
-    def hidden?
-      options[:hidden] == true
-    end
-
-    def markdown?
-      options[:markdown] == true
-    end
-
-    def header?
-      options[:header] == true
-    end
-
-    def footer?
-      options[:footer] == true
-    end
-
-    def get(key)
-      options[key]
-    end
-
-    def content
-      @content ||= strip_frontmatter(file_contents).strip
-    end
-
-    def matchers
-      normalize_matchers(label)
-    end
-
-    def parent_collections_names
-      File.dirname(path).split("/")
-    end
-
-    def type
-      :page
-    end
-
-    def id
-      options[:id]
-    end
-
-    def position
-      options[:position]
-    end
-
-    def hidden
-      options[:hidden]
-    end
-
-    def label
-      options[:label]
-    end
-
-    def method_missing(method_name, *args, &block)
-      if args.none? && !block
-        options[method_name]
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      FRONTMATTER_FIELDS.include? method_name
-    end
-
-    protected
-
-    def file_contents
-      File.read(full_path)
-    end
-
-    def options
-      return @options if @options
-      begin
-        frontmatter = (get_frontmatter(file_contents) || {}).deep_symbolize_keys
-      rescue => exception
-        frontmatter = {}
-        line_number_match = exception.message.match(/.*line\s(\d+)/)
-        @errors.push(Lookbook::Error.new(exception, **{
-          title: "YAML frontmatter parsing error",
-          file_path: @pathname.to_s,
-          line_number: line_number_match ? line_number_match[1] : false
-        }))
-      end
-      @options = Lookbook.config.page_options.deep_merge(frontmatter).with_indifferent_access
-      @options[:id] = generate_id(@options[:id] || lookup_path)
-      @options[:label] ||= name.titleize
-      @options[:title] ||= @options[:label]
-      @options[:hidden] ||= false
-      @options[:landing] ||= false
-      @options[:position] = @options[:position] ? @options[:position].to_i : get_position_prefix(path_name)
-      @options[:markdown] ||= markdown_file?
-      @options[:header] = true unless @options.key? :header
-      @options[:footer] = true unless @options.key? :footer
-      @options
-    end
-
-    def path_name
-      @pathname.basename(@pathname.extname).to_s.gsub(/\.(html|md)$/, "")
-    end
-
-    def markdown_file?
-      @pathname.basename(@pathname.extname).to_s.end_with?(".md")
-    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
-        pages, sections =
-          Array(page_paths).flat_map do |dir|
-            Dir["#{dir}/**/*.html.*", "#{dir}/**/*.md.*"].sort.map do |path|
-              create(path, dir)
-            end
-          end.partition { |page| page.type == :page }
-
-        sorted_pages = pages
-          .uniq { |page| page.path }
-          .sort_by { |page| [page.position, page.label] }
-
-        page_dict = sorted_pages.index_by(&:path)
-        sorted_sections = sections.sort_by { |section| [section.position, section.label] }
-
-        sorted_sections.each do |section|
-          page_dict[section.path].sections << section
-        end
-
-        PageCollection.new(sorted_pages)
-      end
-
-      def page_paths
-        PathUtils.normalize_all(Lookbook.config.page_paths)
-      end
-
-      def section_path?(path)
-        !!path.match(%r{\[(.*?\w+)\]})
-      end
-
-      def create(path, base_path)
-        (section_path?(path) ? PageSection : Page).new(path, base_path)
-      end
-    end
-  end
-end

data/lib/lookbook/page_collection.rb

@@ -1,19 +0,0 @@
-module Lookbook
-  class PageCollection < Collection
-    def id
-      generate_id("page-collection", lookup_path || "root")
-    end
-
-    def label
-      "Pages"
-    end
-
-    def type
-      :page_collection
-    end
-
-    def self.describe_as
-      "pages"
-    end
-  end
-end

data/lib/lookbook/page_section.rb

@@ -1,29 +0,0 @@
-module Lookbook
-  class PageSection < Page
-    def name
-      return @name if @name.present?
-      matches = full_path.to_s.match(%r{\[(?<name>\w+)\]})
-      @name ||= matches[:name]
-    end
-
-    def id
-      "#{super}-#{name}"
-    end
-
-    def url_path
-      nil
-    end
-
-    def path
-      super.gsub("[#{name}]", "")
-    end
-
-    def type
-      :page_section
-    end
-
-    def lookup_path
-      "#{super}/#{name}"
-    end
-  end
-end

data/lib/lookbook/params.rb

@@ -1,157 +0,0 @@
-require "active_model"
-
-module Lookbook
-  module Params
-    VALUE_TYPE_MATCH_REGEXP = /^(\[\s?([A-Z]{1}\w+)\s?\])/
-    DESCRIPTION_MATCH_REGEXP = /"(.*[^\\])"$/
-
-    PARAM_OPTION_KEYS = %i[name input label hint description value_type value_default].freeze
-
-    class << self
-      def build_param(param, default: nil, eval_scope: nil)
-        input, value_type, options_str, description = parse_param_tag_text(param.text)
-
-        tag_options = Lookbook::TagOptions.new(options_str,
-          base_dir: (File.dirname(param.object.files.first[0]) if param.object.files.any?),
-          eval_scope: eval_scope).options
-
-        if tag_options.is_a? Array
-          # handle special case legacy situation for selects where
-          # options are an array of choices rather than a Hash
-          tag_options = {choices: tag_options}
-        end
-
-        param_options = tag_options.select { |key| PARAM_OPTION_KEYS.include? key }
-        input_options = tag_options.except(*PARAM_OPTION_KEYS)
-
-        value_type ||= param_options[:value_type]
-        input ||= param_options[:input] || guess_input(value_type, default)
-        name = param.name.to_s
-
-        {
-          name: name,
-          label: param_options[:label] || name.titleize,
-          hint: param_options[:hint],
-          description: description || param_options[:description],
-          input: input.to_s.tr("_", "-"),
-          input_options: input_options,
-          value: nil,
-          value_type: value_type || guess_value_type(input, default),
-          value_default: default
-        }
-      end
-
-      # Parses param tag strings with the format: `[<value_type>] <input> <description?> <opts?>`
-      def parse_param_tag_text(text)
-        text = (text.presence || "").strip
-
-        value_type = nil
-        text.match(VALUE_TYPE_MATCH_REGEXP) do |m|
-          value_type = m[2]
-          text.gsub!(VALUE_TYPE_MATCH_REGEXP, "").strip!
-        end
-
-        text, options_str = Lookbook::TagOptions.extract_options(text)
-
-        description = nil
-        text.match(DESCRIPTION_MATCH_REGEXP) do |m|
-          description = m[1]
-          text.gsub!(DESCRIPTION_MATCH_REGEXP, "").strip!
-        end
-
-        input, rest = text.split(" ", 2)
-
-        [input, value_type, options_str, description, rest]
-      end
-
-      def parse_method_param_str(param_str)
-        return nil if param_str[0].nil? || param_str[1].nil?
-        name = param_str[0].chomp(":")
-        value = param_str[1]&.strip
-        value = case value
-        when "nil"
-          nil
-        else
-          if value&.first == ":"
-            value.delete_prefix(":").to_sym
-          else
-            YAML.safe_load(value)
-          end
-        end
-        [name, value]
-      end
-
-      def cast(value, type = "String")
-        case type.downcase
-        when "symbol"
-          value.presence&.delete_prefix(":")&.to_sym
-        when "hash"
-          result = safe_parse_yaml(value, {})
-          unless result.is_a? Hash
-            Lookbook.logger.debug "Failed to parse '#{value}' into a Hash"
-            result = {}
-          end
-          result
-        when "array"
-          result = safe_parse_yaml(value, [])
-          unless result.is_a? Array
-            Lookbook.logger.debug "Failed to parse '#{value}' into an Array"
-            result = []
-          end
-          result
-        when "datetime"
-          begin
-            result = DateTime.parse(value)
-          rescue Date::Error
-            Lookbook.logger.debug "Failed to parse '#{value}' into a DateTime"
-            result = DateTime.now
-          end
-          result
-        else
-          begin
-            type_class = "ActiveModel::Type::#{type}".constantize
-            type_class.new.cast(value)
-          rescue NameError
-            raise ArgumentError, "'#{type}' is not a valid param type to cast to."
-          end
-        end
-      end
-
-      private
-
-      def guess_input(value_type, default)
-        if value_type&.downcase == "boolean" || (value_type.blank? && boolean?(default))
-          "toggle"
-        else
-          "text"
-        end
-      end
-
-      def guess_value_type(input, default)
-        if input&.downcase == "toggle"
-          "Boolean"
-        elsif input&.downcase == "number"
-          "Integer"
-        elsif boolean?(default)
-          "Boolean"
-        elsif default.is_a? Symbol
-          "Symbol"
-        elsif ["date", "datetime-local"].include?(input&.downcase) || default.is_a?(DateTime)
-          "DateTime"
-        else
-          "String"
-        end
-      end
-
-      def safe_parse_yaml(value, fallback)
-        value.present? ? YAML.safe_load(value) : fallback
-      rescue Psych::SyntaxError
-        fallback
-      end
-
-      def boolean?(value)
-        value == true || value == false
-      end
-    end
-  end
-end

data/lib/lookbook/parser.rb

@@ -1,42 +0,0 @@
-require "yard"
-
-module Lookbook
-  class Parser
-    attr_reader :registry_path
-    def initialize(paths)
-      @paths = paths.map { |p| "#{p}/**/*preview.rb" }
-      @after_parse_callbacks = []
-      @after_parse_once_callbacks = []
-      @parsing = false
-
-      YARD::Parser::SourceParser.after_parse_list do
-        [*@after_parse_callbacks, *@after_parse_once_callbacks].each do |callback|
-          callback.call(YARD::Registry)
-        end
-        @after_parse_once_callbacks = []
-        @parsing = false
-      end
-    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
-
-    class << self
-      def define_tags(tags = nil)
-        tags.to_h.each do |name, tag|
-          YARD::Tags::Library.define_tag(tag[:label], name, tag[:yard_parser])
-        end
-      end
-    end
-  end
-end