lightning_ui_kit 0.3.3 → 0.3.5

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/errors.rb

@@ -0,0 +1,222 @@
+module ViewComponent
+  class BaseError < StandardError
+    def initialize
+      super(self.class::MESSAGE)
+    end
+  end
+
+  class DuplicateSlotContentError < StandardError
+    MESSAGE =
+      "It looks like a block was provided after calling `with_content` on COMPONENT, " \
+      "which means that ViewComponent doesn't know which content to use.\n\n" \
+      "To fix this issue, use either `with_content` or a block."
+
+    def initialize(klass_name)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s))
+    end
+  end
+
+  class TemplateError < StandardError
+    def initialize(errors, templates = nil)
+      message = errors.join("\n")
+
+      super(message)
+    end
+  end
+
+  class MultipleInlineTemplatesError < BaseError
+    MESSAGE = "Inline templates can only be defined once per-component."
+  end
+
+  class MissingPreviewTemplateError < StandardError
+    MESSAGE =
+      "A preview template for example EXAMPLE doesn't exist.\n\n" \
+      "To fix this issue, create a template for the example."
+
+    def initialize(example)
+      super(MESSAGE.gsub("EXAMPLE", example))
+    end
+  end
+
+  class MissingTemplateError < StandardError
+    MESSAGE =
+      "No templates for COMPONENT match the request DETAIL.\n\n" \
+      "To fix this issue, provide a suitable template."
+
+    def initialize(component, request_detail)
+      detail = {
+        locale: request_detail.locale,
+        formats: request_detail.formats,
+        variants: request_detail.variants,
+        handlers: request_detail.handlers
+      }
+      super(MESSAGE.gsub("COMPONENT", component).gsub("DETAIL", detail.inspect))
+    end
+  end
+
+  class DuplicateContentError < StandardError
+    MESSAGE =
+      "It looks like a block was provided after calling `with_content` on COMPONENT, " \
+      "which means that ViewComponent doesn't know which content to use.\n\n" \
+      "To fix this issue, use either `with_content` or a block."
+
+    def initialize(klass_name)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s))
+    end
+  end
+
+  class MissingCollectionArgumentError < StandardError
+    MESSAGE =
+      "The initializer for COMPONENT doesn't accept the parameter `PARAMETER`, " \
+      "which is required to render it as a collection.\n\n" \
+      "To fix this issue, update the initializer to accept `PARAMETER`.\n\n" \
+      "See [the collections docs](https://viewcomponent.org/guide/collections.html) for more information on rendering collections."
+
+    def initialize(klass_name, parameter)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s).gsub("PARAMETER", parameter.to_s))
+    end
+  end
+
+  class ReservedParameterError < StandardError
+    MESSAGE =
+      "COMPONENT initializer can't accept the parameter `PARAMETER`, as it will override a " \
+      "public ViewComponent method. To fix this issue, rename the parameter."
+
+    def initialize(klass_name, parameter)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s).gsub("PARAMETER", parameter.to_s))
+    end
+  end
+
+  class InvalidCollectionArgumentError < BaseError
+    MESSAGE =
+      "The value of the first argument passed to `with_collection` isn't a valid collection. " \
+      "Make sure it responds to `to_ary`."
+  end
+
+  class ContentSlotNameError < StandardError
+    MESSAGE =
+      "COMPONENT declares a slot named content, which is a reserved word in ViewComponent.\n\n" \
+      "Content passed to a ViewComponent as a block is captured and assigned to the `content` accessor without having to create an explicit slot.\n\n" \
+      "To fix this issue, either use the `content` accessor directly or choose a different slot name."
+
+    def initialize(klass_name)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s))
+    end
+  end
+
+  class InvalidSlotDefinitionError < BaseError
+    MESSAGE =
+      "Invalid slot definition. Please pass a class, " \
+      "string, or callable (that is proc, lambda, etc)"
+  end
+
+  class InvalidSlotNameError < StandardError
+  end
+
+  class SlotPredicateNameError < InvalidSlotNameError
+    MESSAGE =
+      "COMPONENT declares a slot named SLOT_NAME, which ends with a question mark.\n\n" \
+      "This isn't allowed because the ViewComponent framework already provides predicate " \
+      "methods ending in `?`.\n\n" \
+      "To fix this issue, choose a different name."
+
+    def initialize(klass_name, slot_name)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s).gsub("SLOT_NAME", slot_name.to_s))
+    end
+  end
+
+  class RedefinedSlotError < StandardError
+    MESSAGE =
+      "COMPONENT declares the SLOT_NAME slot multiple times.\n\n" \
+      "To fix this issue, choose a different slot name."
+
+    def initialize(klass_name, slot_name)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s).gsub("SLOT_NAME", slot_name.to_s))
+    end
+  end
+
+  class ReservedSingularSlotNameError < InvalidSlotNameError
+    MESSAGE =
+      "COMPONENT declares a slot named SLOT_NAME, which is a reserved word in the ViewComponent framework.\n\n" \
+      "To fix this issue, choose a different name."
+
+    def initialize(klass_name, slot_name)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s).gsub("SLOT_NAME", slot_name.to_s))
+    end
+  end
+
+  class ReservedPluralSlotNameError < InvalidSlotNameError
+    MESSAGE =
+      "COMPONENT declares a slot named SLOT_NAME, which is a reserved word in the ViewComponent framework.\n\n" \
+      "To fix this issue, choose a different name."
+
+    def initialize(klass_name, slot_name)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s).gsub("SLOT_NAME", slot_name.to_s))
+    end
+  end
+
+  class UncountableSlotNameError < InvalidSlotNameError
+    MESSAGE =
+      "COMPONENT declares a slot named SLOT_NAME, which is an uncountable word\n\n" \
+      "To fix this issue, choose a different name."
+
+    def initialize(klass_name, slot_name)
+      super(MESSAGE.gsub("COMPONENT", klass_name.to_s).gsub("SLOT_NAME", slot_name.to_s))
+    end
+  end
+
+  class ContentAlreadySetForPolymorphicSlotError < StandardError
+    MESSAGE = "Content for slot SLOT_NAME has already been provided."
+
+    def initialize(slot_name)
+      super(MESSAGE.gsub("SLOT_NAME", slot_name.to_s))
+    end
+  end
+
+  class NilWithContentError < BaseError
+    MESSAGE =
+      "No content provided to `#with_content` for #{self}.\n\n" \
+      "To fix this issue, pass a value."
+  end
+
+  class TranslateCalledBeforeRenderError < BaseError
+    MESSAGE =
+      "`#translate` can't be used before rendering as it depends " \
+      "on the view context that only exists once a ViewComponent is passed to " \
+      "the Rails render pipeline.\n\n" \
+      "It's sometimes possible to fix this issue by moving code dependent on " \
+      "`#translate` to a [`#before_render` method](https://viewcomponent.org/api.html#before_render--void)."
+  end
+
+  class HelpersCalledBeforeRenderError < BaseError
+    MESSAGE =
+      "`#helpers` can't be used before rendering as it depends " \
+      "on the view context that only exists once a ViewComponent is passed to " \
+      "the Rails render pipeline.\n\n" \
+      "It's sometimes possible to fix this issue by moving code dependent on " \
+      "`#helpers` to a [`#before_render` method](https://viewcomponent.org/api.html#before_render--void)."
+  end
+
+  class ControllerCalledBeforeRenderError < BaseError
+    MESSAGE =
+      "`#controller` can't be used before rendering, as it depends " \
+      "on the view context that only exists once a ViewComponent is passed to " \
+      "the Rails render pipeline.\n\n" \
+      "It's sometimes possible to fix this issue by moving code dependent on " \
+      "`#controller` to a [`#before_render` method](https://viewcomponent.org/api.html#before_render--void)."
+  end
+
+  class SystemTestControllerNefariousPathError < BaseError
+    MESSAGE = "ViewComponent SystemTest controller attempted to load a file outside of the expected directory."
+  end
+
+  class AlreadyDefinedPolymorphicSlotSetterError < StandardError
+    MESSAGE =
+      "A method called 'SETTER_METHOD_NAME' already exists and would be overwritten by the 'SETTER_NAME' polymorphic " \
+      "slot setter.\n\nPlease choose a different setter name."
+
+    def initialize(setter_method_name, setter_name)
+      super(MESSAGE.gsub("SETTER_METHOD_NAME", setter_method_name.to_s).gsub("SETTER_NAME", setter_name.to_s))
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/inline_template.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ViewComponent # :nodoc:
+  module InlineTemplate
+    extend ActiveSupport::Concern
+
+    Template = Struct.new(:source, :language, :path, :lineno)
+
+    class_methods do
+      def method_missing(method, *args)
+        return super if !method.end_with?("_template")
+
+        if defined?(@__vc_inline_template_defined) && @__vc_inline_template_defined
+          raise MultipleInlineTemplatesError
+        end
+
+        if args.size != 1
+          raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 1)"
+        end
+
+        ext = method.to_s.gsub("_template", "")
+        template = args.first
+
+        @__vc_inline_template_language = ext
+
+        caller = caller_locations(1..1)[0]
+        @__vc_inline_template = Template.new(
+          template,
+          ext,
+          caller.absolute_path || caller.path,
+          caller.lineno
+        )
+
+        @__vc_inline_template_defined = true
+      end
+
+      def respond_to_missing?(method, include_all = false)
+        method.end_with?("_template") || super
+      end
+
+      def __vc_inline_template
+        @__vc_inline_template if defined?(@__vc_inline_template)
+      end
+
+      def __vc_inline_template_language
+        @__vc_inline_template_language if defined?(@__vc_inline_template_language)
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@__vc_inline_template_language, __vc_inline_template_language)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/instrumentation.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module ViewComponent # :nodoc:
+  module Instrumentation
+    def self.included(mod)
+      mod.prepend(self) unless self <= ViewComponent::Instrumentation
+    end
+
+    def render_in(view_context, &block)
+      return super if !Rails.application.config.view_component.instrumentation_enabled.present?
+
+      payload = {
+        name: self.class.name,
+        identifier: self.class.identifier,
+        view_identifier: nil
+      }
+
+      ActiveSupport::Notifications.instrument(
+        "render.view_component",
+        payload
+      ) do
+        result = super
+        payload[:view_identifier] = @__vc_instrumentation_view_identifier
+        result
+      end
+    ensure
+      @__vc_instrumentation_view_identifier = nil
+    end
+
+    def around_render
+      result = super
+      @__vc_instrumentation_view_identifier = current_template&.path
+      result
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/preview.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "active_support/descendants_tracker"
+
+module ViewComponent # :nodoc:
+  class Preview
+    if defined?(Rails.application.routes.url_helpers)
+      # Workaround from https://stackoverflow.com/questions/20853526/make-yard-ignore-certain-class-extensions to appease YARD
+      send(:include, Rails.application.routes.url_helpers)
+    end
+
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::AssetTagHelper
+    extend ActiveSupport::DescendantsTracker
+
+    def render(component, **args, &block)
+      {
+        args: args,
+        block: block,
+        component: component,
+        locals: {},
+        template: "view_components/preview"
+      }
+    end
+
+    def render_with_template(template: nil, locals: {})
+      {
+        template: template,
+        locals: locals
+      }
+    end
+
+    class << self
+      # Returns all component preview classes.
+      def all
+        __vc_load_previews
+
+        descendants
+      end
+
+      # Returns the arguments for rendering of the component in its layout
+      def render_args(example, params: {})
+        example_params_names = instance_method(example).parameters.map(&:last)
+        provided_params = params.slice(*example_params_names).to_h.symbolize_keys
+        result = provided_params.empty? ? new.public_send(example) : new.public_send(example, **provided_params)
+        result ||= {}
+        result[:template] = preview_example_template_path(example) if result[:template].nil?
+        @layout = nil unless defined?(@layout)
+        result.merge(layout: @layout)
+      end
+
+      # Returns all of the available examples for the component preview.
+      def examples
+        public_instance_methods(false).map(&:to_s).sort
+      end
+
+      # Returns +true+ if the preview exists.
+      def exists?(preview)
+        all.any? { |p| p.preview_name == preview }
+      end
+
+      # Find a component preview by its underscored class name.
+      def find(preview)
+        all.find { |p| p.preview_name == preview }
+      end
+
+      # Returns the underscored name of the component preview without the suffix.
+      def preview_name
+        name.chomp("Preview").underscore
+      end
+
+      # rubocop:disable Style/TrivialAccessors
+      # Setter for layout name.
+      def layout(layout_name)
+        @layout = layout_name
+      end
+      # rubocop:enable Style/TrivialAccessors
+
+      # Returns the relative path (from preview_path) to the preview example template if the template exists
+      def preview_example_template_path(example)
+        preview_path =
+          Array(preview_paths).detect do |path|
+            Dir["#{path}/#{preview_name}_preview/#{example}.html.*"].first
+          end
+
+        raise MissingPreviewTemplateError.new(example) if preview_path.nil?
+
+        path = Dir["#{preview_path}/#{preview_name}_preview/#{example}.html.*"].first
+        Pathname.new(path)
+          .relative_path_from(Pathname.new(preview_path))
+          .to_s
+          .sub(/\..*$/, "")
+      end
+
+      # @private
+      def __vc_load_previews
+        Array(preview_paths).each do |preview_path|
+          Dir["#{preview_path}/**/*preview.rb"].sort.each { |file| require file }
+        end
+      end
+
+      private
+
+      def preview_paths
+        Base.previews.paths
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/request_details.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  # LookupContext computes and encapsulates @details for each request
+  # so that it doesn't need to be recomputed on each partial render.
+  # This data is wrapped in ActionView::TemplateDetails::Requested and
+  # used by instances of ActionView::Resolver to choose which template
+  # best matches the request.
+  #
+  # ActionView considers this logic internal to template/partial resolution.
+  # We're exposing it to the compiler via `refine` so that ViewComponent
+  # can match Rails' template picking logic.
+  module RequestDetails
+    refine ActionView::LookupContext do
+      # Return an abstraction for matching and sorting available templates
+      # based on the current lookup context details.
+      #
+      # @return ActionView::TemplateDetails::Requested
+      # @see ActionView::LookupContext#detail_args_for
+      # @see ActionView::FileSystemResolver#_find_all
+      def vc_requested_details(user_details = {})
+        # The hash `user_details` would normally be the standard arguments that
+        # `render` accepts, but there's currently no mechanism for users to
+        # provide these when calling render on a ViewComponent.
+        details, cached = detail_args_for(user_details)
+        cached || ActionView::TemplateDetails::Requested.new(**details)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/view_component-4.8.0/lib/view_component/slot.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "view_component/with_content_helper"
+
+module ViewComponent
+  class Slot
+    include ViewComponent::WithContentHelper
+
+    attr_writer :__vc_component_instance, :__vc_content_block, :__vc_content, :__vc_content_block_virtual_path
+
+    def initialize(parent)
+      @parent = parent
+    end
+
+    def content?
+      return true if defined?(@__vc_content) && @__vc_content.present?
+      return true if defined?(@__vc_content_set_by_with_content) && @__vc_content_set_by_with_content.present?
+      return true if defined?(@__vc_content_block) && @__vc_content_block.present?
+      return false if !__vc_component_instance?
+
+      @__vc_component_instance.content?
+    end
+
+    def with_content(args)
+      if __vc_component_instance?
+        @__vc_component_instance.with_content(args)
+      else
+        super
+      end
+    end
+
+    # Used to render the slot content in the template
+    #
+    # There's currently 3 different values that may be set, that we can render.
+    #
+    # If the slot renderable is a component, the string class name of a
+    # component, or a function that returns a component, we render that
+    # component instance, returning the string.
+    #
+    # If the slot renderable is a function and returns a string, it's
+    # set as `@__vc_content` and is returned directly.
+    #
+    # If there is no slot renderable, we evaluate the block passed to
+    # the slot and return it.
+    def to_s
+      return @content if defined?(@content)
+
+      view_context = @parent.send(:view_context)
+
+      if defined?(@__vc_content_block) && defined?(@__vc_content_set_by_with_content)
+        raise DuplicateSlotContentError.new(self.class.name)
+      end
+
+      @content =
+        if __vc_component_instance?
+          @__vc_component_instance.__vc_original_view_context = @parent.__vc_original_view_context
+
+          if defined?(@__vc_content_block)
+            # render_in is faster than `parent.render`
+            @__vc_component_instance.render_in(view_context) do |*args|
+              @parent.with_captured_virtual_path(@__vc_content_block_virtual_path) do
+                @__vc_content_block.call(*args)
+              end
+            end
+          else
+            @__vc_component_instance.render_in(view_context)
+          end
+        elsif defined?(@__vc_content)
+          @__vc_content
+        elsif defined?(@__vc_content_block)
+          @parent.with_captured_virtual_path(@__vc_content_block_virtual_path) do
+            view_context.capture(&@__vc_content_block)
+          end
+        elsif defined?(@__vc_content_set_by_with_content)
+          @__vc_content_set_by_with_content
+        end
+
+      @content = @content.to_s
+    end
+
+    # Allow access to public component methods via the wrapper
+    #
+    # for example
+    #
+    # calling `header.name` (where `header` is a slot) will call `name`
+    # on the `HeaderComponent` instance.
+    #
+    # Where the component may look like:
+    #
+    # class MyComponent < ViewComponent::Base
+    #   has_one :header, HeaderComponent
+    #
+    #   class HeaderComponent < ViewComponent::Base
+    #     def name
+    #       @name
+    #     end
+    #   end
+    # end
+    #
+    def method_missing(symbol, *args, **kwargs, &block)
+      @__vc_component_instance.public_send(symbol, *args, **kwargs, &block)
+    end
+
+    def html_safe?
+      to_s.html_safe?
+    end
+
+    def respond_to_missing?(symbol, include_all = false)
+      __vc_component_instance? && @__vc_component_instance.respond_to?(symbol, include_all)
+    end
+
+    private
+
+    def __vc_component_instance?
+      defined?(@__vc_component_instance)
+    end
+  end
+end