lookbook 1.5.2 → 2.3.7

data/lib/lookbook/file_watcher.rb

@@ -1,46 +1,24 @@
 module Lookbook
   class FileWatcher
-    attr_reader :listeners, :force_polling
-
-    def initialize(force_polling: false)
-      @force_polling = force_polling
-      @listeners = []
-    end
-
-    def watch(paths, extensions = ".*", opts = nil, &block)
-      paths = PathUtils.normalize_paths(paths)
-
-      if paths.any?
-        opts = opts.to_h
-        opts[:only] = /\.(#{Array(extensions).join("|")})$/
-
-        listeners << init_listener(paths, opts, &block)
+    class << self
+      def new(...)
+        file_watcher.new(...)
       end
-    end
 
-    def start
-      if listeners.any?
-        Lookbook.logger.debug "Starting listeners"
-        listeners.each { |l| l.start }
+      def evented?
+        !(file_watcher <= ActiveSupport::FileUpdateChecker)
       end
-    end
 
-    def stop
-      if listeners.any?
-        Lookbook.logger.debug "Stopping listeners"
-        listeners.each { |l| l.stop }
-      end
-    end
+      protected
 
-    protected
+      def file_watcher
+        @_file_watcher ||= begin
+          require_relative "support/evented_file_update_checker"
 
-    def init_listener(paths, opts, &block)
-      Listen.to(
-        *paths,
-        **opts,
-        force_polling: force_polling
-      ) do |modified, added, removed|
-        block.call({modified: modified, added: added, removed: removed})
+          EventedFileUpdateChecker
+        rescue LoadError
+          ActiveSupport::FileUpdateChecker
+        end
       end
     end
   end

data/lib/lookbook/helpers/class_names_helper.rb

@@ -0,0 +1,28 @@
+module Lookbook
+  module ClassNamesHelper
+    def build_tag_values(*args)
+      tag_values = []
+
+      args.each do |tag_value|
+        case tag_value
+        when Hash
+          tag_value.each do |key, val|
+            tag_values << key.to_s if val && key.present?
+          end
+        when Array
+          tag_values.concat build_tag_values(*tag_value)
+        else
+          tag_values << tag_value.to_s if tag_value.present?
+        end
+      end
+
+      tag_values
+    end
+
+    def class_names(*args)
+      tokens = build_tag_values(*args).flat_map { |value| value.to_s.split(/\s+/) }.uniq
+
+      safe_join(tokens, " ")
+    end
+  end
+end

data/lib/lookbook/helpers/page_helper.rb

@@ -0,0 +1,43 @@
+module Lookbook
+  # Helpers for documentation page templates
+  #
+  # @api public
+  module PageHelper
+    # Returns the URL path to a page.
+    #
+    # @api private
+    # @param id [String, PageEntity] The id or PageEntity instance to generate a URL path for
+    def page_path(id)
+      page = id.is_a?(PageEntity) ? id : Engine.pages.find_by_id(id)
+      if page.present?
+        page.docs_path
+      else
+        Lookbook.logger.warn "Could not find page with id ':#{id}'"
+      end
+    end
+
+    # Render a 'live' embed of a component preview.
+    #
+    # If no scenario name is provided then the default (first) preview
+    # scenario will be rendered in the embed.
+    #
+    # @param preview [String] Name of the preview class to embed
+    # @param scenario [String] Example method name
+    # @param opts [Hash] Options hash
+    def embed(preview, scenario = nil, **opts)
+      preview_entity = if preview.is_a?(Symbol)
+        Engine.previews.find_by_path(preview)
+      else
+        Engine.previews.find_by_preview_class(preview)
+      end
+      scenario_entity = scenario ? preview_entity&.scenario(scenario) : preview_entity&.default_scenario
+      opts[:actions] ||= ["inspect", "open"]
+
+      lookbook_render Embed::Component.new(
+        scenario: scenario_entity,
+        params: opts.fetch(:params, {}),
+        options: opts.except(:params)
+      )
+    end
+  end
+end

data/{app/helpers/lookbook → lib/lookbook/helpers}/preview_helper.rb

@@ -1,4 +1,7 @@
 module Lookbook
+  # Set of helpers for preview layouts
+  #
+  # @api public
   module PreviewHelper
     def lookbook_display(key, fallback = nil)
       params.dig(:lookbook, :display, key.to_sym) || fallback

data/lib/lookbook/helpers/ui_elements_helper.rb

@@ -0,0 +1,91 @@
+module Lookbook
+  # Helpers for rendering UI elements.
+  #
+  # These are available for use in documentation page templates
+  # and custom preview inspector panel templates.
+  #
+  # @api public
+  module UiElementsHelper
+    # Render an icon.
+    #
+    # Lookbook uses icons from the [Lucide Icons](https://lucide.dev/) set and
+    # a full list of available icon names can be found on that site.
+    #
+    # @example
+    #   <%= icon :trash %>
+    #   <%= icon :camera, size: 6, style: "color: red;" %>
+    #
+    # @param name [Symbol, String] Name of the icon
+    # @param opts [Hash] Options hash
+    def icon(name, **opts)
+      lookbook_render(:icon, name: name, **opts)
+    end
+
+    # Display a syntax-highlighted block of code.
+    #
+    # An alternative to using markdown code blocks for templates that have
+    # markdown parsing disabled, or for when more control is required.
+    #
+    # @param language [Symbol] Which language the code is written in
+    # @param opts [Hash] Options hash
+    # @param block [Proc] Code block
+    def code(language = :html, **opts, &block)
+      opts[:language] ||= language
+      lookbook_render :code, **opts, &block
+    end
+
+    # @api private
+    def prose(**opts, &block)
+      lookbook_render(:prose, **opts, &block)
+    end
+
+    # @api private
+    def lookbook_tag(tag = :div, **attrs, &block)
+      lookbook_render(:tag, tag: tag, **attrs, &block)
+    end
+
+    # @api private
+    def lookbook_render(ref, **attrs, &block)
+      comp = if ref.is_a? ViewComponent::Base
+        ref
+      else
+        klass = component_class(ref)
+        attrs.key?(:content) ? klass.new(**attrs.except(:content)).with_content(attrs[:content]) : klass.new(**attrs)
+      end
+      if block && !attrs.key?(:content)
+        public_send render_method_name, comp, &block
+      else
+        public_send render_method_name, comp
+      end
+    end
+
+    private
+
+    COMPONENT_CLASSES = {} # cache for constantized references
+
+    # @api private
+    def render_method_name
+      if Rails.application.config.view_component.render_monkey_patch_enabled || Rails.version.to_f >= 6.1
+        :render
+      else
+        :render_component
+      end
+    end
+
+    # @api private
+    def component_class(ref)
+      klass = COMPONENT_CLASSES[ref]
+      if klass.nil?
+        ref = ref.to_s.tr("-", "_")
+        class_namespace = ref.camelize
+        begin
+          klass = "Lookbook::#{class_namespace}::Component".constantize
+        rescue
+          klass = "Lookbook::#{class_namespace}Component".constantize
+        end
+        COMPONENT_CLASSES[ref] = klass
+      end
+      klass
+    end
+  end
+end

data/lib/lookbook/param.rb

@@ -25,7 +25,13 @@ module Lookbook
     end
 
     def value
-      @value || value_default
+      val = @value || value_default
+      if value_type == "datetime"
+        formatter = (input == "datetime-local") ? "%Y-%m-%dT%T" : "%Y-%m-%d"
+        StringValueCaster.call(val, "datetime")&.strftime(formatter)
+      else
+        val
+      end
     end
 
     def value_type
@@ -65,7 +71,7 @@ module Lookbook
 
     def input_config
       config = Lookbook::Engine.inputs.get_input(input)
-      config || raise(LookbookError.new("Unknown input type '#{input}'"))
+      config || raise(Lookbook::Error.new("Unknown input type '#{input}'"))
     end
 
     def guess_input

data/lib/lookbook/preview.rb

@@ -0,0 +1,85 @@
+module Lookbook
+  class Preview
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::AssetTagHelper
+    extend PreviewAfterRender
+
+    def render(component = nil, **args, &block)
+      if component.nil?
+        {
+          type: :view,
+          template: args[:template] || Lookbook.config.preview_template,
+          args: args,
+          locals: args[:locals] || {},
+          assigns: args[:assigns] || {},
+          block: block
+        }
+      else
+        {
+          type: component.is_a?(String) ? :view : :component,
+          args: args,
+          block: block,
+          component: component,
+          locals: {},
+          template: Lookbook.config.preview_template
+        }
+      end
+    end
+
+    def render_with_template(template: nil, locals: nil)
+      {
+        type: :template,
+        template: template,
+        locals: locals.to_h
+      }
+    end
+
+    alias_method :render_component, :render
+
+    class << self
+      def preview_name
+        name.chomp("Preview").underscore
+      end
+
+      # Returns the arguments for rendering of the component in its layout
+      def render_args(scenario, params: {})
+        scenario_params_names = instance_method(scenario).parameters.map(&:last)
+        provided_params = params.slice(*scenario_params_names).to_h.symbolize_keys
+        result = provided_params.empty? ? new.public_send(scenario) : new.public_send(scenario, **provided_params)
+        result ||= {}
+        result[:template] = scenario_template_path(scenario) if result[:template].nil?
+        @layout = nil unless defined?(@layout)
+        result.merge(layout: @layout)
+      end
+
+      # rubocop:disable Style/TrivialAccessors
+      def layout(layout_name)
+        @layout = layout_name
+      end
+      # rubocop:enable Style/TrivialAccessors
+
+      # Returns the relative path (from preview_path) to the scenario template if the template exists
+      def scenario_template_path(scenario)
+        preview_name = name.chomp("Preview").underscore
+        preview_path =
+          Engine.preview_paths.detect do |path|
+            Dir["#{path}/#{preview_name}_preview/#{scenario}.html.*"].first
+          end
+
+        if preview_path.nil?
+          raise(
+            PreviewTemplateError,
+            "A preview template for scenario #{scenario} doesn't exist.\n\n" \
+            "To fix this issue, create a template for the scenario."
+          )
+        end
+
+        path = Dir["#{preview_path}/#{preview_name}_preview/#{scenario}.html.*"].first
+        Pathname.new(path)
+          .relative_path_from(Pathname.new(preview_path))
+          .to_s
+          .sub(/\..*$/, "")
+      end
+    end
+  end
+end

data/lib/lookbook/preview_after_render.rb

@@ -0,0 +1,13 @@
+module Lookbook
+  # Shared module that both Lookbook::Preview and ViewComponent::Preview are extended with
+  module PreviewAfterRender
+    def after_render(method:, html:, context:)
+      instance = new
+      if instance.method(method).arity > 1
+        instance.send(method, html, context)
+      else
+        instance.send(method, html)
+      end.html_safe
+    end
+  end
+end

data/lib/lookbook/preview_controller_actions.rb

@@ -0,0 +1,64 @@
+module Lookbook
+  module PreviewControllerActions
+    extend ActiveSupport::Concern
+
+    included do
+      helper PreviewHelper
+      send(:helper, Rails.application.routes.url_helpers) # YARD parsing workaround: https://github.com/lsegal/yard/issues/546
+      prepend_view_path Engine.root.join("app/views")
+
+      def render_scenario_to_string(preview, scenario)
+        prepend_application_view_paths
+        prepend_preview_examples_view_path
+
+        @preview = preview
+        @scenario_name = scenario.name
+        @render_args = @preview.render_args(@scenario_name, params: params.permit!)
+        template = @render_args[:template]
+        locals = @render_args[:locals]
+        opts = {}
+        opts[:layout] = nil
+        opts[:assigns] = @render_args[:assigns] || {}
+        opts[:locals] = locals if locals.present?
+
+        with_action_view_settings do
+          rendered = render_to_string(template, **opts)
+
+          if scenario.after_render_method.present?
+            render_context = Store.new({
+              preview: preview,
+              scenario: scenario,
+              params: user_request_parameters
+            })
+            rendered = @preview.after_render(method: scenario.after_render_method, html: rendered, context: render_context)
+          end
+          render html: rendered
+        end
+      end
+
+      def render_in_layout_to_string(template, locals, opts = {})
+        with_action_view_settings do
+          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
+
+      protected
+
+      def with_action_view_settings(&block)
+        ActionViewConfigHandler.call(
+          disable_annotations: Lookbook.config.preview_disable_action_view_annotations,
+          disable_partial_prefixes: Lookbook.config.preview_disable_action_view_partial_prefixes,
+          &block
+        )
+      end
+
+      def user_request_parameters
+        request.query_parameters.to_h.filter { |k, v| !k.start_with?("_") }
+      end
+    end
+  end
+end

data/lib/lookbook/preview_parser.rb

@@ -12,12 +12,14 @@ module Lookbook
       YARD::Parser::SourceParser.after_parse_list { run_callbacks }
     end
 
-    def parse(&block)
+    def parse(files = nil, &block)
       unless @parsing
         @parsing = true
         @after_parse_once_callbacks << block if block
+        files_list = files ? files.select { |file| file.to_s.end_with?(".rb") } : paths
+
         YARD::Registry.clear
-        YARD.parse(paths)
+        YARD.parse(files_list)
       end
     end
 

data/lib/lookbook/reloaders.rb

@@ -0,0 +1,75 @@
+require "active_support"
+
+module Lookbook
+  class Reloaders
+    attr_reader :reloaders
+
+    def initialize
+      @reloaders = []
+    end
+
+    def add(name, directories, extensions, &callback)
+      reloader = Reloader.new(name, directories, extensions, &callback)
+      reloaders.push(reloader)
+
+      if Engine.reloading?
+        Rails.application.reloaders << reloader
+        Rails.application.reloader.to_run { reloader.execute_if_updated }
+      end
+
+      reloader
+    end
+
+    def execute(name = nil)
+      reloaders.each do |reloader|
+        reloader.execute if name.nil? || name == reloader.name
+      end
+    end
+
+    def register_changes(changes)
+      reloader = reloaders.find { |reloader| reloader.watching?(changes) }
+      reloader.last_changes = changes if reloader
+    end
+
+    class Reloader
+      delegate :execute, :execute_if_updated, :updated?, to: :file_watcher
+
+      attr_reader :name, :directories, :extensions, :callback
+      attr_accessor :last_changes
+
+      def initialize(name, directories, extensions, &callback)
+        @name = name.to_sym
+        @directories = directories
+        @extensions = extensions
+        @callback = callback
+        @last_changes = nil
+      end
+
+      def watching?(changes)
+        file_paths = changes.to_h.values.flatten
+        !!file_paths.find do |file_path|
+          file_path = Pathname(file_path).expand_path
+          directories.find do |dir_path|
+            matcher = File.expand_path(File.join(dir_path, "**"))
+            file_path.fnmatch?(matcher)
+          end
+        end
+      end
+
+      protected
+
+      def file_watcher
+        return @_file_watcher if @_file_watcher
+
+        to_watch = directories.each_with_object({}) do |directory, result|
+          result[directory] = extensions
+        end
+
+        @_file_watcher ||= FileWatcher.new([], to_watch) do
+          callback.call(@last_changes)
+          @last_changes = nil
+        end
+      end
+    end
+  end
+end

data/lib/lookbook/runtime_context.rb

@@ -0,0 +1,49 @@
+module Lookbook
+  class RuntimeContext
+    attr_reader :env
+
+    def initialize(env: Rails.env)
+      @env = env
+    end
+
+    def app_name
+      return @_app_name if @_app_name
+
+      app_class = Rails.application.class
+      name = app_class.respond_to?(:module_parent_name) ? app_class.module_parent_name : app_class.parent_name
+      @_app_name ||= name.underscore
+    end
+
+    def rails_older_than?(version)
+      Gem::Version.new(Rails.version) < Gem::Version.new(version)
+    end
+
+    def rails_newer_than?(version)
+      Gem::Version.new(Rails.version) >= Gem::Version.new(version)
+    end
+
+    def actioncable_installed?
+      gem_installed?("actioncable")
+    end
+
+    def listen_installed?
+      gem_installed?("listen")
+    end
+
+    def gem_installed?(name)
+      Gem.loaded_specs.has_key?(name)
+    end
+
+    def web?
+      !rake_task? && !Rails.const_defined?(:Console, false)
+    end
+
+    def rake_task?
+      if defined?(Rake) && Rake.respond_to?(:application)
+        File.basename($0) == "rake" || Rake.application.top_level_tasks.any?
+      else
+        false
+      end
+    end
+  end
+end

data/lib/lookbook/services/data/resolvers/data_resolver.rb

@@ -5,10 +5,9 @@ module Lookbook
 
     attr_reader :eval_context, :base_dir, :file, :fallback
 
-    def initialize(input, eval_context: nil, permit_eval: false, fail_silently: false, base_dir: Rails.root, file: nil, fallback: nil)
+    def initialize(input, eval_context: nil, fail_silently: false, base_dir: Rails.root, file: nil, fallback: nil)
       @input = input.to_s
       @eval_context = eval_context
-      @permit_eval = permit_eval
       @fail_silently = fail_silently
       @fallback = fallback
       @base_dir = base_dir.to_s
@@ -44,9 +43,11 @@ module Lookbook
     def evaluate(input, fallback = @fallback)
       if evaluatable?
         begin
-          eval_context.instance_eval(input.to_s)
+          proc {
+            eval_context.instance_eval(input.to_s)
+          }.call
         rescue => exception
-          raise_error "Could not evaluate statetment (#{exception.message})", exception
+          raise_error "Could not evaluate statement (#{exception.message})", exception
         end
       else
         Lookbook.logger.debug "Data cannot be evaluated (Input: '#{input}')"
@@ -61,9 +62,6 @@ module Lookbook
     private
 
     def evaluatable?
-      if !@permit_eval
-        raise_error "Runtime evaluation is not permitted"
-      end
       eval_context.present?
     end
   end

data/lib/lookbook/services/entities/page_tree_builder.rb

@@ -0,0 +1,40 @@
+module Lookbook
+  class PageTreeBuilder < Service
+    attr_reader :include_hidden
+
+    def initialize(pages, include_hidden: false)
+      @pages = pages.to_a
+      @include_hidden = include_hidden
+    end
+
+    def call
+      root_node = TreeNode.new
+      pages.each do |page|
+        current_node = root_node
+
+        path_segments = parse_segments(page.relative_file_path)
+        path_segments.each.with_index(1) do |segment, i|
+          name, priority_prefix = segment
+          content = page if page.depth == i # pages are always on the leaf nodes
+
+          current_node.add_child(name, content, priority: priority_prefix) unless current_node.has_child?(name)
+          current_node = current_node.get_child(name)
+        end
+      end
+      root_node
+    end
+
+    def parse_segments(path)
+      path.to_s.split("/").map do |segment|
+        unless segment.start_with?(".")
+          priority, name = PriorityPrefixParser.call(segment)
+          [name, priority || 10000]
+        end
+      end.compact
+    end
+
+    def pages
+      include_hidden ? @pages : @pages.select(&:visible?)
+    end
+  end
+end

data/lib/lookbook/services/entities/preview_tree_builder.rb

@@ -0,0 +1,34 @@
+module Lookbook
+  class PreviewTreeBuilder < Service
+    attr_reader :include_hidden
+
+    def initialize(previews, include_hidden: false)
+      @previews = previews.to_a
+      @include_hidden = include_hidden
+    end
+
+    def call
+      root_node = TreeNode.new
+      previews.each do |preview|
+        current_node = root_node
+
+        path_segments = preview.logical_path.split("/")
+        path_segments.each.with_index(1) do |name, i|
+          content = preview if preview.depth == i # entities are always on the leaf nodes
+
+          current_node.add_child(name, content) unless current_node.has_child?(name)
+          current_node = current_node.get_child(name)
+
+          content&.visible_scenarios&.each do |scenario|
+            current_node.add_child(scenario.name, scenario)
+          end
+        end
+      end
+      root_node
+    end
+
+    def previews
+      include_hidden ? @previews : @previews.select(&:visible?)
+    end
+  end
+end