lookbook 2.3.1 → 3.0.0.alpha.2

data/lib/lookbook/entities/scenario_entity.rb

@@ -1,182 +0,0 @@
-module Lookbook
-  # Represents a preview scenario method within a preview class
-  #
-  # @api public
-  class ScenarioEntity < Entity
-    include InspectableEntity
-    include AnnotatableEntity
-    include NavigableEntity
-
-    delegate :group, to: :code_object
-
-    # The preview that this scenario belongs to.
-    #
-    # @return [PreviewEntity] The parent preview entity
-    attr_reader :preview
-
-    # @api private
-    alias_method :parent, :preview
-
-    # @api private
-    def initialize(code_object, preview, priority: nil)
-      @code_object = code_object
-      @preview = preview
-      @default_priority = priority
-      @lookup_path = "#{parent.lookup_path}/#{name}"
-    end
-
-    # @!group Identity
-
-    # Human-readable unique scenario ID
-    #
-    # @return [String] The ID
-    def id
-      @_id ||= Utils.id(fetch_config(:id) { "#{parent.id}-#{code_object.name}" })
-    end
-
-    # Parameter-safe scenario name.
-    #
-    # @return [String] The name
-    def name
-      @_name ||= Utils.name(code_object.name)
-    end
-
-    # Entity type identifier.
-    # Returns `:scenario` for scenarios.
-    #
-    # @return [Symbol] The entity type
-    def type
-      :scenario
-    end
-
-    # @!endgroup
-
-    # @!group Display options
-
-    # Display options hash.
-    #
-    # Contains all display options defined via the `@display` tag
-    # merged with any globally-defined options.
-    #
-    # @return [Hash] The resolved display options
-    def display_options
-      parent.display_options.merge(fetch_config(:display_options, {}))
-    end
-
-    # @!endgroup
-
-    # @!group Render Targets
-
-    # @api private
-    def render_targets
-      @_render_targets ||= RenderTargetCollection.new(load_render_targets)
-    end
-
-    # @api private
-    alias_method :components, :render_targets
-
-    # The item (component or partial) that the scenario renders.
-    #
-    # The render target is guessed where possible (based on the preview class name)
-    # but can also be manually specified using the `@renders` tag.
-    #
-    # @example :ruby
-    #  "This scenario renders: #{scenario.render_target.label}"
-    #
-    # @return [RenderableEntity] The render target
-    def render_target
-      render_targets.first
-    end
-
-    alias_method :component, :render_target
-
-    # @!endgroup
-
-    # @!group URLs
-
-    # The inspector URL path for this preview
-    #
-    # @return [String] URL path
-    def inspect_path
-      lookbook_inspect_path(lookup_path)
-    end
-
-    # The standalone preview URL path for this preview
-    #
-    # @return [String] URL path
-    def preview_path
-      lookbook_preview_path(lookup_path)
-    end
-
-    # @!endgroup
-
-    # @api private
-    def after_render_method
-      fetch_config(:after_render) || parent.after_render_method
-    end
-
-    # @api private
-    def scenarios
-      [self]
-    end
-
-    # @api private
-    def template_source(template_path)
-      source_path = template_file_path(template_path)
-      source_path ? File.read(source_path) : nil
-    end
-
-    # @api private
-    def template_lang(template_path)
-      path = template_file_path(template_path)
-      Lookbook::Lang.guess(path) || Lookbook::Lang.find(:html)
-    end
-
-    # @api private
-    def search_terms
-      [parent.search_terms, parent.label, label]
-    end
-
-    alias_method :lang, :source_lang
-    alias_method :examples, :scenarios
-    alias_method :url_path, :inspect_path
-
-    deprecate lang: :source_lang, deprecator: Deprecation
-    deprecate examples: :scenarios, deprecator: Deprecation
-
-    protected
-
-    def sort_handler(other_entity)
-      if Lookbook.config.preview_sort_scenarios
-        label <=> other_entity.label
-      else
-        [priority, label] <=> [other_entity.priority, other_entity.label]
-      end
-    end
-
-    def format_source(source)
-      source.sub(/^def \w+\s?(\([^)]+\))?/m, "").split("\n")[0..-2].join("\n")
-    end
-
-    def template_file_path(template_path)
-      return full_template_path(template_path) if respond_to?(:full_template_path, true)
-
-      search_dirs = [*Engine.preview_paths, *Engine.view_paths]
-      template_path = "#{template_path.to_s.sub(/\..*$/, "")}.html.*"
-      PathUtils.determine_full_path(template_path, search_dirs)
-    end
-
-    def load_render_targets
-      render_target_identifiers = [*fetch_config(:renders, []), *preview.send(:fetch_config, :renders, [])]
-      render_target_identifiers = preview.guess_render_targets if render_target_identifiers.empty?
-
-      render_targets = render_target_identifiers.map do |render_target|
-        RenderableEntity.new(render_target)
-      rescue Lookbook::Error, NameError
-        Lookbook.logger.warn "#{render_target} was not found"
-        nil
-      end
-      render_targets.compact.uniq(&:lookup_path)
-    end
-  end
-end

data/lib/lookbook/entities/scenario_group_entity.rb

@@ -1,135 +0,0 @@
-module Lookbook
-  # Represents a group of preview scenarios within a preview class
-  #
-  # @api public
-  class ScenarioGroupEntity < Entity
-    include NavigableEntity
-
-    # @!group Scenarios
-
-    # Returns all scenarios within the group.
-    #
-    # @return [Array<ScenarioEntity>] All scenarios
-    attr_reader :scenarios
-
-    # @!endgroup
-
-    # The preview that this scenario belongs to.
-    #
-    # @return [PreviewEntity] The parent preview entity
-    attr_reader :preview
-
-    # @api private
-    alias_method :parent, :preview
-
-    # @api private
-    def initialize(name, scenarios, preview)
-      @name = Utils.name(name)
-      @scenarios = ScenarioCollection.new(scenarios)
-      @preview = preview
-      @lookup_path = "#{parent.lookup_path}/#{@name}"
-    end
-
-    # @!group Display options
-
-    # Display options hash.
-    #
-    # Contains all display options defined via the `@display` tag
-    # for each scenario in the group, merged with any globally-defined options.
-    #
-    # @return [Hash] The resolved display options
-    def display_options
-      merged = {}
-      scenarios.to_a.reverse.map do |scenario|
-        merged.merge!(scenario.display_options)
-      end
-      merged
-    end
-
-    # @!endgroup
-
-    # @!group Render Targets
-
-    # Collection of render targets (components or partials)
-    # from each of the scenarios in the group.
-    #
-    # Render targets are guessed where possible (based on the preview class name)
-    # but can also be manually specified using the `@renders` tag.
-    #
-    # @example :ruby
-    #  "This group renders: #{group.render_targets.map(&:label).join(", ")}"
-    #
-    # @return [Array<RenderableEntity>] Render target entities
-    def render_targets
-      @_render_targets ||= RenderTargetCollection.new(scenarios.flat_map(&:render_targets).uniq(&:lookup_path))
-    end
-
-    alias_method :components, :render_targets
-
-    # @!endgroup
-
-    # @!group Annotations
-
-    # Collection of tags from each of the scenarios in the group.
-    # Can be filtered by tag name by providing the name as an argument.
-    #
-    # @example :ruby
-    #   all_tags = group.tags
-    #   display_tags = group.tags(:display)
-    #
-    # @param tag_name [Symbol] Optional tag type to filter by
-    # @return [Array<YardTag>] Array of tags
-    def tags(tag_name = nil)
-      scenarios.flat_map { |scenario| scenario.tags(tag_name) }
-    end
-
-    # @api private
-    def tag(tag_name = nil)
-      tags(tag_name).first
-    end
-
-    # @!endgroup
-
-    # @!group URLs
-
-    # The inspector URL path for this scenario group
-    #
-    # @return [String] URL path
-    def inspect_path
-      lookbook_inspect_path(lookup_path)
-    end
-
-    # The standalone preview URL path for this scenario group
-    #
-    # @return [String] URL path
-    def preview_path
-      lookbook_preview_path(lookup_path)
-    end
-
-    alias_method :url_path, :inspect_path
-
-    # @!endgroup
-
-    # @!group Identity
-
-    # Entity type identifier.
-    # Returns `:scenario_group` for scenario groups.
-    #
-    # @return [Symbol] The entity type
-    def type
-      :scenario_group
-    end
-
-    # @!endgroup
-
-    # @api private
-    def search_terms
-      [parent.search_terms, parent.label, label]
-    end
-
-    # @api private
-    def add_scenario(scenario)
-      @scenarios.add(scenario)
-    end
-  end
-end

data/lib/lookbook/file_watcher.rb

@@ -1,25 +0,0 @@
-module Lookbook
-  class FileWatcher
-    class << self
-      def new(...)
-        file_watcher.new(...)
-      end
-
-      def evented?
-        !(file_watcher <= ActiveSupport::FileUpdateChecker)
-      end
-
-      protected
-
-      def file_watcher
-        @_file_watcher ||= begin
-          require_relative "support/evented_file_update_checker"
-
-          EventedFileUpdateChecker
-        rescue LoadError
-          ActiveSupport::FileUpdateChecker
-        end
-      end
-    end
-  end
-end

data/lib/lookbook/helpers/class_names_helper.rb

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

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

@@ -1,24 +0,0 @@
-module Lookbook
-  module Lang
-    class << self
-      CONFIG_FILE = "config/languages.yml"
-      LANGUAGES = [] # retained for backwards compatability
-
-      def find(name)
-        languages.find { |l| l[:name] == name.to_s }
-      end
-
-      def guess(path, fallback_name = nil)
-        ext = File.extname(path)
-        lang = languages.find { |l| l[:ext] == ext }
-        lang || (find(fallback_name) if fallback_name)
-      end
-
-      protected
-
-      def languages
-        @_languages ||= [*ConfigLoader.call(CONFIG_FILE).definitions, *LANGUAGES]
-      end
-    end
-  end
-end

data/lib/lookbook/param.rb

@@ -1,105 +0,0 @@
-module Lookbook
-  class Param
-    attr_reader :name, :options, :value_default, :description
-
-    def initialize(name:, input: nil, description: nil, value_type: nil, value_default: nil, value: nil, options: {})
-      @name = name
-      @input = input
-      @description = description
-      @value_type = value_type
-      @value_default = value_default
-      @value = value
-      @options = options
-    end
-
-    def label
-      options.label || name.titleize
-    end
-
-    def hint
-      options.hint
-    end
-
-    def input
-      @input || guess_input
-    end
-
-    def value
-      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
-      @value_type || guess_value_type
-    end
-
-    def input_options
-      return @_input_options if @_input_options
-
-      runtime_options = options.except([*methods, :name, :value_default, :description])
-      @_input_options ||= Store.new(input_config.options.merge(runtime_options))
-    end
-
-    def input_partial
-      input_config.partial
-    end
-
-    def cast_value
-      raise ArgumentError.new("Cannot cast param '#{name}' without a value set") if value.nil?
-
-      StringValueCaster.call(value, value_type)
-    end
-
-    def self.from_tag(tag, value: nil)
-      new(
-        name: tag.name,
-        input: tag.input || tag.options.input,
-        description: tag.description || tag.options.description,
-        value_type: tag.value_type || tag.options.value_type,
-        value_default: tag.value_default,
-        options: tag.options,
-        value: value
-      )
-    end
-
-    protected
-
-    def input_config
-      config = Lookbook::Engine.inputs.get_input(input)
-      config || raise(Lookbook::Error.new("Unknown input type '#{input}'"))
-    end
-
-    def guess_input
-      if @value_type == "boolean" || (@value_type.blank? && boolean?(value_default))
-        "toggle"
-      else
-        "text"
-      end
-    end
-
-    def guess_value_type
-      if input == "toggle"
-        "boolean"
-      elsif input == "number"
-        "integer"
-      elsif boolean?(value_default)
-        "boolean"
-      elsif value_default.is_a?(Symbol)
-        "symbol"
-      elsif ["date", "datetime-local"].include?(input) || value_default.is_a?(DateTime)
-        "datetime"
-      else
-        "string"
-      end
-    end
-
-    def boolean?(value)
-      value == true || value == false
-    end
-  end
-end

data/lib/lookbook/preview.rb

@@ -1,85 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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