lookbook 0.9.0 → 1.0.0.beta.2

data/lib/lookbook/config.rb

@@ -0,0 +1,180 @@
+require "lookbook/markdown"
+require "lookbook/theme"
+require "lookbook/store"
+
+module Lookbook
+  class Config
+    def initialize
+      @options = Store.new
+      foobar = "bax"
+      @options.set({
+        project_name: "Lookbook",
+        log_level: 2,
+        auto_refresh: true,
+        
+        page_controller: "Lookbook::PageController",
+        page_route: "pages",
+        page_paths: ["test/components/docs"],
+        page_options: {},
+        markdown_options: Markdown::DEFAULT_OPTIONS,
+
+        preview_paths: [],
+        preview_display_params: {},
+        preview_options: {},
+        preview_srcdoc: false,
+        sort_examples: true,
+
+        listen: Rails.env.development?,
+        listen_paths: [],
+        listen_use_polling: false,
+
+        cable_mount_path: "/lookbook-cable",
+        cable_logger: Lookbook.logger,
+
+        runtime_parsing: !Rails.env.production?,
+        parser_registry_path: "tmp/storage/.yardoc",
+
+        ui_theme: "indigo",
+        ui_theme_overrides: {},
+
+        inspector_panels: {
+          preview: {
+            pane: :main,
+            position: 1,
+            partial: "lookbook/previews/panels/preview",
+            hotkey: "v",
+            panel_classes: "overflow-hidden"
+          },
+          output: {
+            pane: :main,
+            position: 2,
+            partial: "lookbook/previews/panels/output",
+            label: "HTML",
+            hotkey: "h",
+          },
+          source: {
+            pane: :drawer,
+            position: 1,
+            partial: "lookbook/previews/panels/source",
+            label: "Source",
+            hotkey: "s",
+            copy: ->(data) { data.examples.map { |e| e[:source] }.join("\n") }
+          },
+          notes: {
+            pane: :drawer,
+            position: 2,
+            partial: "lookbook/previews/panels/notes",
+            label: "Notes",
+            hotkey: "n",
+            disabled: ->(data) { data.examples.filter { |e| e.notes.present? }.none? }
+          },
+          params: {
+            pane: :drawer,
+            position: 3,
+            partial: "lookbook/previews/panels/params",
+            label: "Params",
+            hotkey: "p",
+            disabled: ->(data) { data.preview.params.none? }
+          }
+        },
+
+        inspector_panel_defaults: {
+          id: ->(data) { "inspector-panel-#{data.name}" },
+          partial: "lookbook/previews/panels/content",
+          content: nil,
+          label: ->(data) { data.name.titleize },
+          pane: :drawer,
+          position: ->(data) { data.index_position },
+          hotkey: nil,
+          disabled: false,
+          show: true,
+          copy: nil,
+          panel_classes: nil,
+          locals: {}
+        },
+
+        experimental_features: false,
+      })
+    end
+
+    def inspector_panels(&block)
+      if block_given?
+        yield get(:inspector_panels)
+      else
+        get(:inspector_panels)
+      end
+    end
+
+    def ui_theme=(name)
+      name = name.to_s
+      if Theme.valid_theme?(name)
+        @options[:ui_theme] = name
+      else
+        Lookbook.logger.warn "'#{name}' is not a valid Lookbook theme. Theme setting not changed."
+      end
+    end
+
+    def ui_theme_overrides(&block)
+      if block_given?
+        yield get(:ui_theme_overrides)
+      else
+        get(:ui_theme_overrides)
+      end
+    end
+
+    def [](key)
+      get(key.to_sym)
+    end
+
+    def []=(key, value)
+      @options[key.to_sym] = value
+    end
+
+    def to_h
+      @options.to_h
+    end
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+    
+    protected
+
+    def get_inspector_panels(panels)
+      panels.filter! { |key, panel| panel }
+      panels
+    end
+
+    def get_project_name(name)
+      name == false ? nil : name
+    end
+
+    def normalize_paths(paths)
+      paths.map! { |path| absolute_path(path) }
+      paths.filter! { |path| Dir.exist?(path) }
+      paths
+    end
+
+    def absolute_path(path)
+      File.absolute_path(path.to_s, Rails.root)
+    end
+
+    alias_method :get_page_paths, :normalize_paths
+    alias_method :get_preview_paths, :normalize_paths
+    alias_method :get_listen_paths, :normalize_paths
+    alias_method :get_parser_registry_path, :absolute_path
+
+    def get(name)
+      getter_name = "get_#{name}".to_sym
+      respond_to?(getter_name, true) ? send(getter_name, @options[name]) : @options[name]
+    end
+
+    def set(name, *args)
+      @options.send(name, *args)
+    end
+
+    def method_missing(name, *args)
+      args.any? ? set(name, *args) : get(name)
+    end
+  end
+end

data/lib/lookbook/engine.rb

@@ -4,64 +4,51 @@ require "action_cable/engine"
 require "listen"
 
 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.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
+    config.lookbook = Lookbook.config
+    config.autoload_paths << File.expand_path(Lookbook::Engine.root.join("app/components"))
 
-      options.preview_paths = options.preview_paths.map(&:to_s)
-      options.preview_paths += vc_options.preview_paths
+    initializer "lookbook.viewcomponent.config" do      
+      config.lookbook.preview_paths += config.view_component.preview_paths
+      config.lookbook.preview_controller ||= config.view_component.preview_controller
 
-      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
-
-      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.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
@@ -80,30 +67,29 @@ module Lookbook
       @preview_controller.include(Lookbook::PreviewController)
 
       if config.lookbook.listen
-        @preview_listener = Listen.to(*config.lookbook.listen_paths, only: /\.(rb|html.*)$/) do |modified, added, removed|
+        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", {
-            modified: modified,
-            removed: removed,
-            added: added
-          })
+          Lookbook::Engine.websocket&.broadcast("reload", {})
         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::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
@@ -120,8 +106,12 @@ module Lookbook
     end
 
     at_exit do
-      @preview_listener&.stop
-      @page_listener&.stop
+      if config.lookbook.listen
+        Lookbook.logger.debug "Stopping listeners"
+        Lookbook::Engine.listeners.each do |listener|
+          listener.stop
+        end
+      end
     end
 
     class << self
@@ -155,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

@@ -19,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,22 @@ module Lookbook
     ]
 
     attr_reader :errors
-    attr_accessor :tabs
+    attr_accessor :sections
 
     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
+      @sections = []
+      @page_name = remove_position_prefix(path_name)
       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 == "." ? @page_name : "#{rel_path.dirname}/#{@page_name}"
+      super(page_path)
     end
 
-    def lookup_path
-      @lookup_path ||= to_lookup_path(path)
+    def url_path
+      lookbook_page_path lookup_path
     end
 
     def full_path
@@ -43,7 +38,7 @@ module Lookbook
     end
 
     def name
-      remove_position_prefix(path_name)
+      @page_name
     end
 
     def hidden?
@@ -74,25 +69,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 id
+      options[:id]
     end
 
-    def tab
-      matches = full_path.to_s.match(%r{\[(?<tab>\w+)\]})
-      matches ? remove_position_prefix(matches[:tab]) : nil
+    def position
+      options[:position]
     end
 
-    def tab?
-      tab.present?
+    def hidden
+      options[:hidden]
+    end
+
+    def label
+      options[:label]
     end
 
     def method_missing(method_name, *args, &block)
@@ -128,7 +126,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,10 +155,10 @@ module Lookbook
       end
 
       def all
-        pages, tabs =
+         pages, sections =
           Array(page_paths).flat_map do |dir|
-            Dir["#{dir}/**/*.html.*", "#{dir}/**/*.md.*"].sort.map do |page|
-              page = Lookbook::Page.new(page, dir)
+            Dir["#{dir}/**/*.html.*", "#{dir}/**/*.md.*"].sort.map do |path|
+              create(path, dir)
             end
           end.partition { |page| page.type == :page }
 
@@ -169,17 +167,25 @@ module Lookbook
           .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
+        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
-        Lookbook.config.page_paths.select { |dir| Dir.exist? dir }
+        Lookbook.config.page_paths.filter { |dir| Dir.exist? dir }
+      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

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/page_section.rb

@@ -0,0 +1,31 @@
+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,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)
         {
@@ -93,7 +104,7 @@ module Lookbook
           "tel",
           "text",
           "url"
-        ].include? input
+        ].include? input.to_s
       end
 
       def safe_parse_yaml(value, fallback)