lookbook 0.6.1 → 0.7.2.beta.0

data/app/views/lookbook/{panels → previews/panels}/_notes.html.erb

@@ -7,14 +7,14 @@
           <h6 class="text-[11px] text-gray-500 italic inline-block uppercase tracking-wide mb-4">
             <%= item[:label] %>
           </h6>
-          <div class="prose prose-sm">
+          <div class="prose prose-sm prose-a:text-indigo-900">
             <%= markdown(item[:notes]) %>
           </div>
         </div>
       <% end %>
     </div>
   <% else %>
-    <div class="p-4 prose prose-sm">
+    <div class="p-4 prose prose-sm prose-a:text-indigo-900">
       <% if items.any? %>
         <%= markdown(items.first[:notes]) %>
       <% else %>

data/config/routes.rb

@@ -1,10 +1,15 @@
 Lookbook::Engine.routes.draw do
   if Lookbook.config.auto_refresh
-    mount Lookbook::Engine.websocket => Lookbook::Engine.cable.mount_path
+    mount Lookbook::Engine.websocket => Lookbook.config.cable.mount_path
   end
 
-  root to: "app#index", as: :home
+  root to: "application#index", as: :home
 
-  get "/preview/*path", to: "app#preview", as: :preview
-  get "/*path", to: "app#show", as: :show
+  if Lookbook::Features.enabled?(:pages)
+    get "/#{Lookbook.config.page_route}", to: "pages#index", as: :page_index
+    get "/#{Lookbook.config.page_route}/*path", to: "pages#show", as: :page
+  end
+
+  get "/preview/*path", to: "previews#preview", as: :preview
+  get "/*path", to: "previews#show", as: :show
 end

data/lib/lookbook/code_formatter.rb

@@ -1,5 +1,26 @@
+require "rouge"
+require "htmlbeautifier"
+
 module Lookbook
-  class CodeFormatter < Rouge::Formatters::HTML
+  module CodeFormatter
+    class << self
+      def highlight(source, language, opts = {})
+        source&.gsub!("&gt;", "<")&.gsub!("&lt;", ">")
+        language ||= "ruby"
+        formatter = Formatter.new(opts)
+        lexer = Rouge::Lexer.find(language.to_s) || Rouge::Lexer.find("plaintext")
+        formatter.format(lexer.lex(source)).html_safe
+      end
+
+      def beautify(source, language = "html")
+        source = source.strip
+        result = language.downcase == "html" ? HtmlBeautifier.beautify(source) : source
+        result.strip.html_safe
+      end
+    end
+  end
+
+  class Formatter < Rouge::Formatters::HTML
     def initialize(opts = {})
       @opts = opts
     end

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,57 +75,76 @@ 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
-    end
-
-    config.after_initialize do |app|
-      @listener = Listen.to(*app.config.lookbook.listen_paths, only: /\.(rb|html.*)$/) do |modified, added, removed|
-        parser.parse
-        if app.config.lookbook.auto_refresh
-          if (modified.any? || removed.any?) && added.none?
+    config.after_initialize do
+      @preview_listener = Listen.to(*config.lookbook.listen_paths, only: /\.(rb|html.*)$/) do |modified, added, removed|
+        if Lookbook::Preview.errors.any?
+          Lookbook::Preview.reload
+        end
+        begin
+          parser.parse
+        rescue
+        end
+        if Lookbook::Engine.websocket
+          if modified.any? || removed.any? || added.none?
             Lookbook::Engine.websocket.broadcast("reload", {
               modified: modified,
-              removed: removed
+              removed: removed,
+              added: added
             })
           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/error.rb

@@ -0,0 +1,52 @@
+module Lookbook
+  class Error < StandardError
+    delegate :full_message, :backtrace, :to_s, to: :target
+
+    def initialize(original = nil, title: nil, message: nil, file_name: false, line_number: false)
+      @original = original
+      @title = title
+      @message = message
+      @file_name = file_name
+      @line_number = line_number
+      super()
+    end
+
+    def title
+      @title || target.class.to_s
+    end
+
+    def message
+      (@message || target.message).gsub("(<unknown>):", "").strip.upcase_first
+    end
+
+    def file_name
+      path = if @file_name == false
+        parsed_backtrace[0][0] if parsed_backtrace.any?
+      else
+        @file_name
+      end
+      path.delete_prefix("#{Rails.root}/")
+    end
+
+    def line_number
+      if @line_number == false
+        parsed_backtrace[0][1] if parsed_backtrace.any?
+      else
+        @line_number
+      end
+    end
+
+    def parsed_backtrace
+      backtrace.map do |x|
+        x =~ /^(.+?):(\d+)(|:in `(.+)')$/
+        [$1, $2, $4]
+      end
+    end
+
+    protected
+
+    def target
+      @original.presence || self
+    end
+  end
+end

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