lookbook 0.9.8 → 1.0.0.beta.0

data/lib/lookbook/engine.rb

@@ -2,71 +2,53 @@ require "rails"
 require "view_component"
 require "action_cable/engine"
 require "listen"
-require "rake"
 
 module Lookbook
+
+  autoload :Config, "lookbook/config"
+  
   class << self
     def config
-      @config ||= Engine.config.lookbook
+      @config ||= Config.new
     end
 
     def logger
-      @logger ||= Rails.logger
+      @logger ||= Rails.env.development? ? Logger.new($stdout) : Rails.logger
     end
 
     def version
       Lookbook::VERSION
     end
+
+    def debug_data
+      {
+        version: version,
+        env: Rails.env.to_s,
+        config: config
+      }
+    end
+
+    def configure
+      yield(config)
+    end
   end
 
   class Engine < Rails::Engine
     isolate_namespace Lookbook
 
-    config.lookbook = ActiveSupport::OrderedOptions.new
-    config.lookbook.listen_paths ||= []
-    config.lookbook.listen_extensions ||= []
-    config.lookbook.preview_paths ||= []
-    config.lookbook.page_paths ||= ["test/components/docs"]
-
-    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
-
-      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 || {})
+    config.lookbook = Lookbook.config
+    config.autoload_paths << File.expand_path(Lookbook::Engine.root.join("app/components"))
 
-      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
+    initializer "lookbook.viewcomponent.config" do      
+      config.lookbook.preview_paths += config.view_component.preview_paths
+      config.lookbook.preview_controller ||= config.view_component.preview_controller
 
-      options.listen = Rails.env.development? if options.listen.nil?
-      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.select! { |path| Dir.exist? path }
-
-      options.listen_extensions += ["rb", "html.*"]
-      options.listen_extensions.uniq!
-
-      options.cable_mount_path ||= "/lookbook-cable"
-      options.cable_logger ||= Rails.logger
-
-      options.runtime_parsing = !Rails.env.production? if options.runtime_parsing.nil?
-      options.parser_registry_path ||= Rails.root.join("tmp/storage/.yardoc")
+      config.lookbook.listen_paths += config.lookbook.preview_paths
+      config.lookbook.listen_paths << (config.view_component.view_component_path.presence || "app/components")
+    end
 
-      options.experimental_features = false unless options.experimental_features.present?
+    initializer "lookbook.logging.development" do
+      Lookbook.logger.level = Lookbook.config.log_level if Rails.env.development?
     end
 
     initializer "lookbook.parser.tags" do
@@ -84,20 +66,34 @@ module Lookbook
       @preview_controller = Lookbook.config.preview_controller.constantize
       @preview_controller.include(Lookbook::PreviewController)
 
-      if Gem::Version.new(Rails.version) >= Gem::Version.new("6.1.3.1")
-        # Rails.application.server is only available for newer Rails versions
-        Rails.application.server do
-          init_listeners
+      if config.lookbook.listen
+        Listen.logger = Lookbook.logger
+        preview_listener = Listen.to(
+          *config.lookbook.listen_paths,
+          only: /\.(rb|html.*)$/,
+          force_polling: Lookbook.config.listen_use_polling
+        ) do |modified, added, removed|
+          begin
+            parser.parse
+          rescue
+          end
+          Lookbook::Preview.clear_cache
+          Lookbook::Engine.websocket&.broadcast("reload", {})
         end
-      else
-        # Fallback for older Rails versions - don't start listeners if running in a rake task.
-        unless File.basename($0) == "rake" || Rake.application.top_level_tasks.any?
-          init_listeners 
+        Lookbook::Engine.register_listener(preview_listener)
+
+        page_listener = Listen.to(
+          *config.lookbook.page_paths,
+          only: /\.(html.*|md.*)$/,
+          force_polling: Lookbook.config.listen_use_polling
+        ) do |modified, added, removed|
+          Lookbook::Engine.websocket&.broadcast("reload", {})
         end
+        Lookbook::Engine.register_listener(page_listener)
       end
 
       if config.lookbook.runtime_parsing
-        Lookbook::Engine.parser.parse
+        parser.parse
       else
         unless File.exist?(config.lookbook.parser_registry_path)
           Lookbook.logger.warn "
@@ -109,43 +105,17 @@ module Lookbook
       end
     end
 
-    def init_listeners
+    at_exit do
       if config.lookbook.listen
-        @preview_listener = Listen.to(*config.lookbook.listen_paths, only: /\.(#{config.lookbook.listen_extensions.join("|")})$/) do |modified, added, removed|
-          begin
-            Lookbook::Engine.parser.parse
-          rescue
-          end
-          Lookbook::Preview.clear_cache
-          Lookbook::Engine.websocket&.broadcast("reload", {
-            modified: modified,
-            removed: removed,
-            added: added
-          })
-        end
-        @preview_listener.start
-
-        if Lookbook::Features.enabled?(:pages)
-          @page_listener = Listen.to(*config.lookbook.page_paths.select { |dir| Dir.exist? dir }, only: /\.(html.*|md.*)$/) do |modified, added, removed|
-            Lookbook::Engine.websocket&.broadcast("reload", {
-              modified: modified,
-              removed: removed,
-              added: added
-            })
-          end
-          @page_listener.start
+        Lookbook.logger.debug "Stopping listeners"
+        Lookbook::Engine.listeners.each do |listener|
+          listener.stop
         end
       end
     end
 
-    at_exit do
-      @preview_listener&.stop
-      @page_listener&.stop
-    end
-
     class << self
       def websocket
-        return @websocket unless @websocket.nil?
         if config.lookbook.auto_refresh
           cable = ActionCable::Server::Configuration.new
           cable.cable = {adapter: "async"}.with_indifferent_access
@@ -156,9 +126,9 @@ module Lookbook
           @websocket ||= if Rails.version.to_f >= 6.0
             ActionCable::Server::Base.new(config: cable)
           else
-            ws = ActionCable::Server::Base.new
-            ws.config = cable
-            ws
+            websocket ||= ActionCable::Server::Base.new
+            websocket.config = cable
+            websocket
           end
         end
       end
@@ -175,6 +145,23 @@ module Lookbook
         @parser ||= Lookbook::Parser.new(config.lookbook.preview_paths, config.lookbook.parser_registry_path)
       end
 
+      def log_level
+        Lookbook.logger.level
+      end
+
+      def app_name
+        Rails.application.class.module_parent_name.underscore
+      end
+
+      def register_listener(listener)
+        listener.start
+        listeners << listener
+      end
+
+      def listeners
+        @listeners ||= []
+      end
+
       attr_reader :preview_controller
     end
   end

data/lib/lookbook/entity.rb

@@ -0,0 +1,47 @@
+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/error.rb

@@ -34,8 +34,7 @@ module Lookbook
 
           {
             code: relevant_lines.join("\n").lstrip,
-            start_line: start_line - empty_start_lines,
-            end_line: end_line - empty_start_lines,
+            start_line: start_line,
             highlighted_line: highlighted_line - empty_start_lines
           }
         end

data/lib/lookbook/features.rb

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

data/lib/lookbook/markdown.rb

@@ -12,7 +12,6 @@ module Lookbook
     }
 
     def self.render(text)
-      text&.gsub!("<!-- BEGIN inline template -->", "")&.gsub!("<!-- END inline template -->", "")
       markdown = Redcarpet::Markdown.new(Renderer, Lookbook.config.markdown_options)
       markdown.render(text).html_safe
     end
@@ -20,12 +19,11 @@ module Lookbook
     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,
+        ApplicationController.render(Lookbook::Code::Component.new(**{
+          source: code,
           language: language.to_s.chomp("-numbered"),
           line_numbers: line_numbers
-        },
-        layout: nil
+        }), layout: nil)
       end
     end
   end

data/lib/lookbook/page.rb

@@ -1,6 +1,5 @@
 module Lookbook
-  class Page
-    include Utils
+  class Page < Entity
 
     FRONTMATTER_FIELDS = [
       :id,
@@ -16,26 +15,19 @@ module Lookbook
     ]
 
     attr_reader :errors
-    attr_accessor :tabs
 
     def initialize(path, base_path)
       @pathname = Pathname.new path
-      @base_path = Pathname.new base_path
+      @base_path = base_path
       @options = nil
       @errors = []
-      @tabs = []
-    end
-
-    def path
       rel_path = @pathname.relative_path_from(@base_path)
-
-      _path = (rel_path.dirname.to_s == "." ? name : "#{rel_path.dirname}/#{name}")
-      _path.gsub!("[#{tab}]", "") if tab?
-      _path
+      page_path = (rel_path.dirname.to_s == "." ? name : "#{rel_path.dirname}/#{name}")
+      super(page_path)
     end
 
-    def lookup_path
-      @lookup_path ||= to_lookup_path(path)
+    def url_path
+      page_path lookup_path
     end
 
     def full_path
@@ -74,25 +66,28 @@ module Lookbook
       normalize_matchers(label)
     end
 
-    def hierarchy_depth
-      path.split("/").size
-    end
-
     def parent_collections_names
       File.dirname(path).split("/")
     end
 
     def type
-      tab? ? :tab : :page
+      :page
     end
 
-    def tab
-      matches = full_path.to_s.match(%r{\[(?<tab>\w+)\]})
-      matches ? remove_position_prefix(matches[:tab]) : nil
+    def id
+      options[:id]
     end
 
-    def tab?
-      tab.present?
+    def position
+      options[:position]
+    end
+
+    def hidden
+      options[:hidden]
+    end
+
+    def label
+      options[:label]
     end
 
     def method_missing(method_name, *args, &block)
@@ -128,7 +123,7 @@ module Lookbook
       end
       @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] ||= (tab? ? tab : name).titleize
+      @options[:label] ||= name.titleize
       @options[:title] ||= @options[:label]
       @options[:hidden] ||= false
       @options[:landing] ||= false
@@ -157,29 +152,17 @@ module Lookbook
       end
 
       def all
-        pages, tabs =
-          Array(page_paths).flat_map do |dir|
-            Dir["#{dir}/**/*.html.*", "#{dir}/**/*.md.*"].sort.map do |page|
-              page = Lookbook::Page.new(page, 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_tabs = tabs.sort_by { |tab| [tab.position, tab.label] }
-
-        sorted_tabs.each do |tab|
-          page_dict[tab.path].tabs << tab
+        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.select { |dir| Dir.exist? dir }
+        Lookbook.config.page_paths.filter { |dir| Dir.exist? dir }
       end
     end
   end

data/lib/lookbook/page_collection.rb

@@ -4,6 +4,14 @@ module Lookbook
       generate_id("page-collection", lookup_path || "root")
     end
 
+    def label
+      "Pages"
+    end
+
+    def type
+      :page_collection
+    end
+
     def self.describe_as
       "pages"
     end

data/lib/lookbook/params.rb

@@ -1,10 +1,21 @@
+require "active_model"
+
 module Lookbook
   module Params
     class << self
-      def build_param(param, default)
+      def build_param(param, default: nil, **opts)
         input, options_str = param.text.present? ? param.text.split(" ", 2) : [nil, ""]
         type = param.types&.first
-        options = YAML.safe_load(options_str || "~")
+        options = if options_str.present? && options_str.end_with?(".json")
+          json_path = if options_str.start_with?(".")
+            File.expand_path(options_str, File.dirname(param.object.files.first[0]))
+          else
+            Rails.root.join(options_str)
+          end
+          JSON.parse(File.read(json_path))
+        else
+          YAML.safe_load(options_str || "~")
+        end
         input ||= guess_input(type, default)
         type ||= guess_type(input, default)
         {
@@ -52,14 +63,6 @@ module Lookbook
             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
@@ -89,8 +92,6 @@ module Lookbook
           "Boolean"
         elsif default.is_a? Symbol
           "Symbol"
-        elsif ["date", "datetime-local"].include?(input&.downcase) || default.is_a?(DateTime)
-          "DateTime"
         else
           "String"
         end
@@ -98,14 +99,12 @@ module Lookbook
 
       def input_text?(input)
         [
-          "date",
-          "datetime-local",
           "email",
           "number",
           "tel",
           "text",
           "url"
-        ].include? input
+        ].include? input.to_s
       end
 
       def safe_parse_yaml(value, fallback)

data/lib/lookbook/parser.rb

@@ -23,6 +23,10 @@ module Lookbook
       registry.get(path)
     end
 
+    # def yardoc_file_path
+    #   Rails&.root ? Rails.root.join(YARDOC_FILE_PATH) : YARDOC_FILE_PATH
+    # end
+
     class << self
       def define_tags
         YARD::Tags::Library.define_tag("Hidden status", :hidden)

data/lib/lookbook/preview.rb

@@ -1,5 +1,5 @@
 module Lookbook
-  class Preview
+  class Preview < Collection
     include Utils
 
     delegate :name, :render_args, to: :@preview
@@ -7,7 +7,8 @@ module Lookbook
 
     def initialize(preview)
       @preview = preview
-      @preview_inspector = CodeInspector.new(@preview.name)
+      @preview_inspector = SourceInspector.new(@preview.name)
+      super(preview_class_name(preview_class_basename(@preview.name)))
     end
 
     def id
@@ -33,7 +34,7 @@ module Lookbook
     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) }
+      public_method_objects = @preview_inspector&.methods&.filter { |m| public_methods.include?(m.name) }
       examples = (public_method_objects || []).map { |m| PreviewExample.new(m.name.to_s, self) }
       sorted = Lookbook.config.sort_examples ? examples.sort_by(&:label) : examples
       @examples = []
@@ -52,12 +53,12 @@ module Lookbook
       @examples = @examples.compact
     end
 
-    def default_example
-      examples.first
+    def items
+      examples.reject { |i| i.hidden? }
     end
 
-    def path
-      preview_class_name(preview_class_basename(name))
+    def default_example
+      examples.first
     end
 
     def full_path
@@ -67,6 +68,10 @@ module Lookbook
       Pathname.new(Dir["#{base_path}/#{name.underscore}.rb"].first)
     end
 
+    def url_path
+      inspect_path lookup_path
+    end
+
     def preview_paths
       ViewComponent::Base.preview_paths
     end
@@ -87,6 +92,10 @@ module Lookbook
       Lookbook.config.preview_display_params.deep_merge(@preview_inspector&.display_params)
     end
 
+    def collapsible?
+      true
+    end
+
     class << self
       def find(path)
         all.find { |p| p.lookup_path == path }

data/lib/lookbook/preview_collection.rb

@@ -4,10 +4,18 @@ module Lookbook
       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

data/lib/lookbook/preview_controller.rb

@@ -14,9 +14,13 @@ module Lookbook
       render html: render_to_string(template, **opts)
     end
 
-    def render_in_layout_to_string(template, locals, layout = nil)
+    def render_in_layout_to_string(template, locals, **opts)
       append_view_path Lookbook::Engine.root.join("app/views")
-      render html: render_to_string(template, locals: locals, **determine_layout(layout))
+      html = render_to_string(template, locals: locals, **determine_layout(opts[:layout]))
+      if opts[:append_html].present?
+        html += opts[:append_html]
+      end
+      render html: html
     end
   end
 end

data/lib/lookbook/preview_example.rb

@@ -1,22 +1,21 @@
 module Lookbook
-  class PreviewExample
-    include Utils
-
+  class PreviewExample < Entity
     attr_reader :name, :preview
     delegate :params, :position, :group, :notes, :hidden?, :source, to: :@example_inspector
 
     def initialize(name, preview)
       @name = name
       @preview = preview
-      @example_inspector = CodeInspector.new("#{@preview.name}##{name}")
+      @example_inspector = SourceInspector.new("#{@preview.name}##{name}")
+      super("#{@preview.path}/#{name}")
     end
 
     def id
       generate_id(@preview.id, name)
     end
 
-    def path
-      "#{@preview.path}/#{name}"
+    def url_path
+      inspect_path lookup_path
     end
 
     def label

data/lib/lookbook/preview_group.rb

@@ -1,21 +1,16 @@
 module Lookbook
-  class PreviewGroup
-    include Utils
-
+  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 id
-      generate_id(lookup_path)
-    end
-
-    def path
-      "#{@preview.path}/#{name}"
+    def url_path
+      inspect_path lookup_path
     end
 
     def label