lookbook 0.6.1 → 0.7.0

data/lib/lookbook/code_inspector.rb

@@ -0,0 +1,73 @@
+module Lookbook
+  class CodeInspector
+    include Utils
+
+    attr_reader :code_object
+    delegate :groups, :source, to: :@code_object, allow_nil: true
+
+    def initialize(taggable_object_path)
+      @code_object = Lookbook::Engine.parser.get_code_object(taggable_object_path)
+    end
+
+    def hidden?
+      if code_object&.tag(:hidden)
+        code_object.tag(:hidden).text.strip != "false"
+      end
+    end
+
+    def id
+      if code_object&.tag(:id)&.text&.present?
+        generate_id(code_object&.tag(:id)&.text)
+      end
+    end
+
+    def label
+      code_object&.tag(:label)&.text
+    end
+
+    def notes
+      if code_object&.docstring
+        code_object.docstring.to_s.strip
+      end
+    end
+
+    def group
+      code_object&.group
+    end
+
+    def position
+      code_object&.tag(:position)&.text&.to_i || 10000
+    end
+
+    def display_params
+      display_params = {}.with_indifferent_access
+      if code_object&.tags(:display).present?
+        code_object.tags(:display).each do |tag|
+          parts = tag.text.strip.match(/^([^\s]*)\s?(.*)$/)
+          if parts.present?
+            begin
+              display_params[parts[1]] = YAML.safe_load(parts[2] || "~")
+            rescue SyntaxError => err
+              Lookbook.logger.error("\n👀 [Lookbook] Invalid JSON in @display tag.\n👀 [Lookbook] (#{err})\n")
+            end
+          end
+        end
+      end
+      display_params
+    end
+
+    def parameter_defaults
+      code_object&.parameters&.map { |str| Params.parse_method_param_str(str) }&.compact&.to_h
+    end
+
+    def params
+      code_object&.tags("param")&.map do |param|
+        Lookbook::Params.build_param(param, parameter_defaults[param.name])
+      end
+    end
+
+    def methods
+      code_object&.meths
+    end
+  end
+end

data/lib/lookbook/collection.rb

@@ -1,33 +1,56 @@
 module Lookbook
   class Collection
+    include Utils
+    include Enumerable
+
     attr_reader :path
+    delegate :size, :each, to: :items
 
-    def initialize(path = "")
+    def initialize(path = "", items = [])
+      if path.is_a?(Array)
+        @items = path
+        path = ""
+      else
+        @items = items
+      end
       @path = path.delete_prefix("/").delete_suffix("/")
-      @items = []
     end
 
     def id
-      (@path || "root").underscore.tr("_", "-")
+      generate_id(lookup_path || "root")
     end
 
     def name
-      @path.present? ? @path.split("/").last : "root"
+      @name ||= remove_position_prefix(basename)
     end
 
     def label
       name&.titleize
     end
 
+    def lookup_path
+      @lookup_path ||= to_lookup_path(@path)
+    end
+
+    def position
+      @position ||= parse_position_prefix(basename).first
+    end
+
     def hierarchy_depth
       @path ? @path.split("/").size : 0
     end
 
-    def items(sorted = true)
-      sorted ? @items.sort_by(&:label) : @items
+    def items
+      @items.sort_by { |item| [item.hierarchy_depth, item.position, item.label] }
+    end
+
+    def visible_items
+      reject { |i| i.hidden? }
     end
 
     def add(item)
+      @ordered_entities = nil
+      @tree = nil
       if item.is_a?(String)
         item = Collection.new([@path, item].join("/"))
       end
@@ -37,15 +60,94 @@ module Lookbook
 
     def get(name)
       name = name.underscore
-      @items.find { |item| item.name.underscore == name }
+      items.find { |item| item.name.underscore == name }
     end
 
     def get_or_create(name)
-      get(name).presence || add(name)
+      get(remove_position_prefix(name)).presence || add(name)
+    end
+
+    def find(lookup = nil, &block)
+      if lookup
+        lookup.is_a?(Symbol) ? find_by_id(lookup.to_s.tr("_", "-")) : find_by_path(lookup)
+      elsif block
+        items.find(&block)
+      end
+    end
+
+    def find_by_id(id)
+      items.find { |i| i.id == id }
+    end
+
+    def find_by_path(path)
+      items.find { |i| i.lookup_path == path }
+    end
+
+    def find_parent(child)
+      parent_path = child.lookup_path.split("/").pop.join("/")
+      find_by_path(parent_path)
+    end
+
+    def ordered_entities
+      return @ordered_entities if @ordered_entities.present?
+      entities = []
+      as_tree.items.each do |item|
+        entities.append(item.is_a?(Collection) ? item.ordered_entities : item)
+      end
+      @ordered_entities ||= entities.flatten
+    end
+
+    def find_first
+      ordered_entities.first
+    end
+
+    def find_next(item)
+      index = ordered_entities.find_index { |i| i.lookup_path == item.lookup_path }
+      ordered_entities[index + 1] unless index.nil?
+    end
+
+    def find_previous(item)
+      index = ordered_entities.find_index { |i| i.lookup_path == item.lookup_path }
+      ordered_entities[index - 1] if !index.nil? && index > 0
+    end
+
+    def as_tree(filter_hidden: true)
+      return self if hierarchy_depth > 0
+      return @tree if @tree.present?
+      @tree = self.class.new
+      candidates = filter_hidden ? visible_items : items
+      candidates.each do |item|
+        current = @tree
+        if item.hierarchy_depth == 1
+          current.add(item)
+        else
+          item.parent_collections_names.each.with_index(1) do |name, i|
+            target = current.get_or_create(name)
+            if item.hierarchy_depth == i + 1
+              target.add(item)
+            else
+              current = target
+            end
+          end
+        end
+      end
+      @tree
     end
 
     def type
       :collection
     end
+
+    protected
+
+    def basename
+      @path.present? ? @path.split("/").last : ""
+    end
+
+    class << self
+      def describe_as
+        "items"
+      end
+    end
   end
 end

data/lib/lookbook/engine.rb

@@ -24,11 +24,13 @@ module Lookbook
     config.lookbook = ActiveSupport::OrderedOptions.new
     config.lookbook.listen_paths ||= []
     config.lookbook.preview_paths ||= []
+    config.lookbook.page_paths ||= ["test/components/docs"]
 
-    initializer "view_component.set_configs" do |app|
-      options = app.config.lookbook
-      vc_options = app.config.view_component
+    initializer "view_component.set_configs" do
+      options = config.lookbook
+      vc_options = config.view_component
 
+      options.project_name ||= options.project_name == false ? nil : options.project_name || "Lookbook"
       options.auto_refresh = true if options.auto_refresh.nil?
       options.sort_examples = false if options.sort_examples.nil?
       options.debug = false unless options.debug == true
@@ -36,6 +38,13 @@ module Lookbook
       options.preview_paths = options.preview_paths.map(&:to_s)
       options.preview_paths += vc_options.preview_paths
 
+      options.page_paths = options.page_paths.map(&:to_s)
+      options.page_controller = "Lookbook::PageController" if options.page_controller.nil?
+      options.page_route ||= "pages"
+      options.page_options ||= {}.with_indifferent_access
+
+      options.markdown_options = Markdown::DEFAULT_OPTIONS.merge(options.markdown_options || {})
+
       options.preview_controller = vc_options.preview_controller if options.preview_controller.nil?
       options.preview_srcdoc = false if options.preview_srcdoc.nil?
       options.preview_display_params ||= {}.with_indifferent_access
@@ -43,16 +52,14 @@ module Lookbook
       options.listen_paths = options.listen_paths.map(&:to_s)
       options.listen_paths += options.preview_paths
       options.listen_paths << (vc_options.view_component_path || Rails.root.join("app/components"))
+      options.listen_paths.filter! { |path| Dir.exist? path }
 
-      options.experimental_features = false unless options.experimental_features.present?
-    end
+      options.cable = ActionCable::Server::Configuration.new
+      options.cable.cable = {adapter: "async"}.with_indifferent_access
+      options.cable.mount_path ||= "/lookbook-cable"
+      options.cable.connection_class = -> { Lookbook::Connection }
 
-    initializer "lookbook.cable.config" do |app|
-      if app.config.lookbook.auto_refresh
-        Lookbook::Engine.cable.cable = {adapter: "async"}.with_indifferent_access
-        Lookbook::Engine.cable.mount_path = "/cable"
-        Lookbook::Engine.cable.connection_class = -> { Lookbook::Connection }
-      end
+      options.experimental_features = false unless options.experimental_features.present?
     end
 
     initializer "lookbook.parser.tags" do
@@ -68,23 +75,25 @@ module Lookbook
 
     initializer "lookbook.logging" do
       if config.lookbook.debug == true
-        Lookbook::Engine.cable.logger ||= Rails.logger
+        config.lookbook.cable.logger ||= Rails.logger
       else
-        Lookbook::Engine.cable.logger = Lookbook::NullLogger.new
+        config.lookbook.cable.logger = Lookbook::NullLogger.new
         config.action_view.logger = Lookbook::NullLogger.new
       end
     end
 
-    initializer "lookbook.preview.extend" do
-      ActiveSupport.on_load(:view_component) do
-        ViewComponent::Preview.extend Lookbook::Preview
-      end
+    initializer "lookbook.helpers" do
+      config.action_controller.include_all_helpers = false
     end
 
-    config.after_initialize do |app|
-      @listener = Listen.to(*app.config.lookbook.listen_paths, only: /\.(rb|html.*)$/) do |modified, added, removed|
+    config.after_initialize do
+      Array(config.view_component.preview_paths).each do |preview_path|
+        Dir["#{preview_path}/**/*_preview.rb"].sort.each { |file| require_dependency file }
+      end
+
+      @preview_listener = Listen.to(*config.lookbook.listen_paths, only: /\.(rb|html.*)$/) do |modified, added, removed|
         parser.parse
-        if app.config.lookbook.auto_refresh
+        if Lookbook::Engine.websocket
           if (modified.any? || removed.any?) && added.none?
             Lookbook::Engine.websocket.broadcast("reload", {
               modified: modified,
@@ -93,32 +102,50 @@ module Lookbook
           end
         end
       end
-      @listener.start
+      @preview_listener.start
+
+      if Lookbook::Features.enabled?(:pages)
+        @page_listener = Listen.to(*config.lookbook.page_paths.filter { |dir| Dir.exist? dir }, only: /\.(html.*|md.*)$/) do |modified, added, removed|
+          if Lookbook::Engine.websocket
+            if modified.any? || removed.any? || added.any?
+              Lookbook::Engine.websocket.broadcast("reload", {
+                modified: modified,
+                removed: removed,
+                added: added
+              })
+            end
+          end
+        end
+        @page_listener.start
+      end
+
       parser.parse
     end
 
     at_exit do
-      @listener&.stop
+      @preview_listener&.stop
+      @page_listener&.stop
     end
 
     class << self
       def websocket
-        if Rails.version.to_f >= 6.0
-          @websocket ||= ActionCable::Server::Base.new(config: Lookbook::Engine.cable)
-        else
-          @websocket = ActionCable::Server::Base.new
-          @websocket.config = Lookbook::Engine.cable
-
-          @websocket
+        if config.lookbook.auto_refresh
+          @websocket ||= if Rails.version.to_f >= 6.0
+            ActionCable::Server::Base.new(config: config.lookbook.cable)
+          else
+            websocket ||= ActionCable::Server::Base.new
+            websocket.config = config.lookbook.cable
+            websocket
+          end
         end
       end
 
       def websocket_mount_path
-        "#{Lookbook::Engine.routes.find_script_name({})}#{cable.mount_path}"
+        "#{mounted_path}#{config.lookbook.cable.mount_path}" if websocket
       end
 
-      def cable
-        @cable ||= ActionCable::Server::Configuration.new
+      def mounted_path
+        Lookbook::Engine.routes.find_script_name({})
       end
 
       def parser

data/lib/lookbook/features.rb

@@ -1,6 +1,6 @@
 module Lookbook
   module Features
-    EXPERIMENTAL_FEATURES = []
+    EXPERIMENTAL_FEATURES = [:pages]
 
     def self.experimental_feature?(name)
       EXPERIMENTAL_FEATURES.include?(name.to_sym)

data/lib/lookbook/markdown.rb

@@ -0,0 +1,31 @@
+require "redcarpet"
+
+module Lookbook
+  class Markdown
+    DEFAULT_OPTIONS = {
+      tables: true,
+      fenced_code_blocks: true,
+      disable_indented_code_blocks: true,
+      strikethrough: true,
+      highlight: true,
+      with_toc_data: true
+    }
+
+    def self.render(text)
+      markdown = Redcarpet::Markdown.new(Renderer, Lookbook.config.markdown_options)
+      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/components/_code", locals: {
+          code: code,
+          language: language.to_s.chomp("-numbered"),
+          line_numbers: line_numbers
+        },
+        layout: nil
+      end
+    end
+  end
+end

data/lib/lookbook/page.rb

@@ -0,0 +1,146 @@
+module Lookbook
+  class Page
+    include Utils
+
+    FRONTMATTER_FIELDS = [
+      :id,
+      :label,
+      :title,
+      :hidden,
+      :landing,
+      :position,
+      :markdown,
+      :header,
+      :footer,
+      :data
+    ]
+
+    def initialize(path, base_path)
+      @pathname = Pathname.new path
+      @base_path = base_path
+    end
+
+    def path
+      rel_path = @pathname.relative_path_from(@base_path)
+      (rel_path.dirname.to_s == "." ? name : "#{rel_path.dirname}/#{name}")
+    end
+
+    def lookup_path
+      @lookup_path ||= to_lookup_path(path)
+    end
+
+    def full_path
+      Rails.root.join(@pathname.to_s)
+    end
+
+    def name
+      remove_position_prefix(path_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)
+    end
+
+    def matchers
+      normalize_matchers(label)
+    end
+
+    def hierarchy_depth
+      path.split("/").size
+    end
+
+    def parent_collections_names
+      File.dirname(path).split("/")
+    end
+
+    def type
+      :page
+    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
+      frontmatter = (get_frontmatter(file_contents) || {}).deep_symbolize_keys
+      options = Lookbook.config.page_options.deep_merge(frontmatter).with_indifferent_access
+      options[:id] = options[:id] ? generate_id(options[:id]) : generate_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 ||= 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 all
+        pages = Array(page_paths).map do |dir|
+          Dir["#{dir}/**/*.html.*", "#{dir}/**/*.md.*"].sort.map do |page|
+            Lookbook::Page.new(page, dir)
+          end
+        end
+        sorted_pages = pages.flatten.uniq { |p| p.path }.sort_by { |page| [page.position, page.label] }
+        PageCollection.new(sorted_pages)
+      end
+
+      def page_paths
+        Lookbook.config.page_paths.filter { |dir| Dir.exist? dir }
+      end
+    end
+  end
+end

data/lib/lookbook/page_collection.rb

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

data/lib/lookbook/parser.rb

@@ -28,6 +28,8 @@ module Lookbook
         YARD::Tags::Library.define_tag("Hidden status", :hidden)
         YARD::Tags::Library.define_tag("Label", :label)
         YARD::Tags::Library.define_tag("Display", :display)
+        YARD::Tags::Library.define_tag("Position", :position)
+        YARD::Tags::Library.define_tag("ID", :id)
       end
     end
   end