lightning_ui_kit 0.3.4 → 0.3.5

data/vendor/bundle/ruby/3.4.0/gems/view_component-3.23.2/lib/view_component/template.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-module ViewComponent
-  class Template
-    DataWithSource = Struct.new(:format, :identifier, :short_identifier, :type, keyword_init: true)
-    DataNoSource = Struct.new(:source, :identifier, :type, keyword_init: true)
-
-    attr_reader :variant, :this_format, :type
-
-    def initialize(
-      component:,
-      type:,
-      this_format: nil,
-      variant: nil,
-      lineno: nil,
-      path: nil,
-      extension: nil,
-      source: nil,
-      method_name: nil,
-      defined_on_self: true
-    )
-      @component = component
-      @type = type
-      @this_format = this_format
-      @variant = variant&.to_sym
-      @lineno = lineno
-      @path = path
-      @extension = extension
-      @source = source
-      @method_name = method_name
-      @defined_on_self = defined_on_self
-
-      @source_originally_nil = @source.nil?
-
-      @call_method_name =
-        if @method_name
-          @method_name
-        else
-          out = +"call"
-          out << "_#{normalized_variant_name}" if @variant.present?
-          out << "_#{@this_format}" if @this_format.present? && @this_format != ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT
-          out
-        end
-    end
-
-    def compile_to_component
-      if !inline_call?
-        @component.silence_redefinition_of_method(@call_method_name)
-
-        # rubocop:disable Style/EvalWithLocation
-        @component.class_eval <<-RUBY, @path, @lineno
-        def #{@call_method_name}
-          #{compiled_source}
-        end
-        RUBY
-        # rubocop:enable Style/EvalWithLocation
-      end
-
-      @component.define_method(safe_method_name, @component.instance_method(@call_method_name))
-    end
-
-    def safe_method_name_call
-      return safe_method_name unless inline_call?
-
-      "maybe_escape_html(#{safe_method_name}) " \
-      "{ Kernel.warn(\"WARNING: The #{@component} component rendered HTML-unsafe output. " \
-      "The output will be automatically escaped, but you may want to investigate.\") } "
-    end
-
-    def requires_compiled_superclass?
-      inline_call? && !defined_on_self?
-    end
-
-    def inline_call?
-      @type == :inline_call
-    end
-
-    def inline?
-      @type == :inline
-    end
-
-    def default_format?
-      @this_format == ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT
-    end
-
-    def format
-      @this_format
-    end
-
-    def safe_method_name
-      "_#{@call_method_name}_#{@component.name.underscore.gsub("/", "__")}"
-    end
-
-    def normalized_variant_name
-      @variant.to_s.gsub("-", "__").gsub(".", "___")
-    end
-
-    def defined_on_self?
-      @defined_on_self
-    end
-
-    private
-
-    def source
-      if @source_originally_nil
-        # Load file each time we look up #source in case the file has been modified
-        File.read(@path)
-      else
-        @source
-      end
-    end
-
-    def compiled_source
-      handler = ActionView::Template.handler_for_extension(@extension)
-      this_source = source
-      this_source.rstrip! if @component.strip_trailing_whitespace?
-
-      short_identifier = defined?(Rails.root) ? @path.sub("#{Rails.root}/", "") : @path
-      type = ActionView::Template::Types[@this_format]
-
-      if handler.method(:call).parameters.length > 1
-        handler.call(
-          DataWithSource.new(format: @this_format, identifier: @path, short_identifier: short_identifier, type: type),
-          this_source
-        )
-      # :nocov:
-      # TODO: Remove in v4
-      else
-        handler.call(DataNoSource.new(source: this_source, identifier: @path, type: type))
-      end
-      # :nocov:
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/view_component-3.23.2/lib/view_component/test_helpers.rb

@@ -1,301 +0,0 @@
-# frozen_string_literal: true
-
-module ViewComponent
-  module TestHelpers
-    begin
-      require "capybara/minitest"
-
-      include Capybara::Minitest::Assertions
-
-      def page
-        @page ||= Capybara::Node::Simple.new(rendered_content)
-      end
-
-      def refute_component_rendered
-        assert_no_selector("body")
-      end
-
-      def assert_component_rendered
-        assert_selector("body")
-      end
-    rescue LoadError
-      # We don't have a test case for running an application without capybara installed.
-      # It's probably fine to leave this without coverage.
-      # :nocov:
-      if ENV["DEBUG"]
-        warn(
-          "WARNING in `ViewComponent::TestHelpers`: Add `capybara` " \
-          "to Gemfile to use Capybara assertions."
-        )
-      end
-
-      # :nocov:
-    end
-
-    # Returns the result of a render_inline call.
-    #
-    # @return [ActionView::OutputBuffer]
-    attr_reader :rendered_content
-
-    # Render a component inline. Internally sets `page` to be a `Capybara::Node::Simple`,
-    # allowing for Capybara assertions to be used:
-    #
-    # ```ruby
-    # render_inline(MyComponent.new)
-    # assert_text("Hello, World!")
-    # ```
-    #
-    # @param component [ViewComponent::Base, ViewComponent::Collection] The instance of the component to be rendered.
-    # @return [Nokogiri::HTML]
-    def render_inline(component, **args, &block)
-      @page = nil
-      @rendered_content =
-        if Rails.version.to_f >= 6.1
-          vc_test_controller.view_context.render(component, args, &block)
-
-        # :nocov:
-        else
-          vc_test_controller.view_context.render_component(component, &block)
-        end
-
-      # :nocov:
-
-      Nokogiri::HTML.fragment(@rendered_content)
-    end
-
-    # `JSON.parse`-d component output.
-    #
-    # ```ruby
-    # render_inline(MyJsonComponent.new)
-    # assert_equal(rendered_json["hello"], "world")
-    # ```
-    def rendered_json
-      JSON.parse(rendered_content)
-    end
-
-    # Render a preview inline. Internally sets `page` to be a `Capybara::Node::Simple`,
-    # allowing for Capybara assertions to be used:
-    #
-    # ```ruby
-    # render_preview(:default)
-    # assert_text("Hello, World!")
-    # ```
-    #
-    # Note: `#rendered_preview` expects a preview to be defined with the same class
-    # name as the calling test, but with `Test` replaced with `Preview`:
-    #
-    # MyComponentTest -> MyComponentPreview etc.
-    #
-    # In RSpec, `Preview` is appended to `described_class`.
-    #
-    # @param name [String] The name of the preview to be rendered.
-    # @param from [ViewComponent::Preview] The class of the preview to be rendered.
-    # @param params [Hash] Parameters to be passed to the preview.
-    # @return [Nokogiri::HTML]
-    def render_preview(name, from: __vc_test_helpers_preview_class, params: {})
-      previews_controller = __vc_test_helpers_build_controller(Rails.application.config.view_component.preview_controller.constantize)
-
-      # From what I can tell, it's not possible to overwrite all request parameters
-      # at once, so we set them individually here.
-      params.each do |k, v|
-        previews_controller.request.params[k] = v
-      end
-
-      previews_controller.request.params[:path] = "#{from.preview_name}/#{name}"
-      previews_controller.set_response!(ActionDispatch::Response.new)
-      result = previews_controller.previews
-
-      @rendered_content = result
-
-      Nokogiri::HTML.fragment(@rendered_content)
-    end
-
-    # Execute the given block in the view context (using `instance_exec`).
-    # Internally sets `page` to be a `Capybara::Node::Simple`, allowing for
-    # Capybara assertions to be used. All arguments are forwarded to the block.
-    #
-    # ```ruby
-    # render_in_view_context(arg1, arg2: nil) do |arg1, arg2:|
-    #   render(MyComponent.new(arg1, arg2))
-    # end
-    #
-    # assert_text("Hello, World!")
-    # ```
-    def render_in_view_context(*args, &block)
-      @page = nil
-      @rendered_content = vc_test_controller.view_context.instance_exec(*args, &block)
-      Nokogiri::HTML.fragment(@rendered_content)
-    end
-    ruby2_keywords(:render_in_view_context) if respond_to?(:ruby2_keywords, true)
-
-    # Set the Action Pack request variant for the given block:
-    #
-    # ```ruby
-    # with_variant(:phone) do
-    #   render_inline(MyComponent.new)
-    # end
-    # ```
-    #
-    # @param variant [Symbol] The variant to be set for the provided block.
-    def with_variant(variant)
-      old_variants = vc_test_controller.view_context.lookup_context.variants
-
-      vc_test_controller.view_context.lookup_context.variants = variant
-      yield
-    ensure
-      vc_test_controller.view_context.lookup_context.variants = old_variants
-    end
-
-    # Set the controller to be used while executing the given block,
-    # allowing access to controller-specific methods:
-    #
-    # ```ruby
-    # with_controller_class(UsersController) do
-    #   render_inline(MyComponent.new)
-    # end
-    # ```
-    #
-    # @param klass [Class<ActionController::Base>] The controller to be used.
-    def with_controller_class(klass)
-      old_controller = defined?(@vc_test_controller) && @vc_test_controller
-
-      @vc_test_controller = __vc_test_helpers_build_controller(klass)
-      yield
-    ensure
-      @vc_test_controller = old_controller
-    end
-
-    # Set format of the current request
-    #
-    # ```ruby
-    # with_format(:json) do
-    #   render_inline(MyComponent.new)
-    # end
-    # ```
-    #
-    # @param format [Symbol] The format to be set for the provided block.
-    def with_format(format)
-      with_request_url("/", format: format) { yield }
-    end
-
-    # Set the URL of the current request (such as when using request-dependent path helpers):
-    #
-    # ```ruby
-    # with_request_url("/users/42") do
-    #   render_inline(MyComponent.new)
-    # end
-    # ```
-    #
-    # To use a specific host, pass the host param:
-    #
-    # ```ruby
-    # with_request_url("/users/42", host: "app.example.com") do
-    #   render_inline(MyComponent.new)
-    # end
-    # ```
-    #
-    # To specify a request method, pass the method param:
-    #
-    # ```ruby
-    # with_request_url("/users/42", method: "POST") do
-    #   render_inline(MyComponent.new)
-    # end
-    # ```
-    #
-    # @param full_path [String] The path to set for the current request.
-    # @param host [String] The host to set for the current request.
-    # @param method [String] The request method to set for the current request.
-    def with_request_url(full_path, host: nil, method: nil, format: ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT)
-      old_request_host = vc_test_request.host
-      old_request_method = vc_test_request.request_method
-      old_request_path_info = vc_test_request.path_info
-      old_request_path_parameters = vc_test_request.path_parameters
-      old_request_query_parameters = vc_test_request.query_parameters
-      old_request_query_string = vc_test_request.query_string
-      old_request_format = vc_test_request.format.symbol
-      old_controller = defined?(@vc_test_controller) && @vc_test_controller
-
-      path, query = full_path.split("?", 2)
-      vc_test_request.instance_variable_set(:@fullpath, full_path)
-      vc_test_request.instance_variable_set(:@original_fullpath, full_path)
-      vc_test_request.host = host if host
-      vc_test_request.request_method = method if method
-      vc_test_request.path_info = path
-      vc_test_request.path_parameters = Rails.application.routes.recognize_path_with_request(vc_test_request, path, {})
-      vc_test_request.set_header("action_dispatch.request.query_parameters",
-        Rack::Utils.parse_nested_query(query).with_indifferent_access)
-      vc_test_request.set_header(Rack::QUERY_STRING, query)
-      vc_test_request.format = format
-      yield
-    ensure
-      vc_test_request.host = old_request_host
-      vc_test_request.request_method = old_request_method
-      vc_test_request.path_info = old_request_path_info
-      vc_test_request.path_parameters = old_request_path_parameters
-      vc_test_request.set_header("action_dispatch.request.query_parameters", old_request_query_parameters)
-      vc_test_request.set_header(Rack::QUERY_STRING, old_request_query_string)
-      vc_test_request.format = old_request_format
-      @vc_test_controller = old_controller
-    end
-
-    # Access the controller used by `render_inline`:
-    #
-    # ```ruby
-    # test "logged out user sees login link" do
-    #   vc_test_controller.expects(:logged_in?).at_least_once.returns(false)
-    #   render_inline(LoginComponent.new)
-    #   assert_selector("[aria-label='You must be signed in']")
-    # end
-    # ```
-    #
-    # @return [ActionController::Base]
-    def vc_test_controller
-      @vc_test_controller ||= __vc_test_helpers_build_controller(Base.test_controller.constantize)
-    end
-
-    # Access the request used by `render_inline`:
-    #
-    # ```ruby
-    # test "component does not render in Firefox" do
-    #   request.env["HTTP_USER_AGENT"] = "Mozilla/5.0"
-    #   render_inline(NoFirefoxComponent.new)
-    #   refute_component_rendered
-    # end
-    # ```
-    #
-    # @return [ActionDispatch::TestRequest]
-    def vc_test_request
-      require "action_controller/test_case"
-
-      @vc_test_request ||=
-        begin
-          out = ActionDispatch::TestRequest.create
-          out.session = ActionController::TestSession.new
-          out
-        end
-    end
-
-    # Note: We prefix private methods here to prevent collisions in consumer's tests.
-    private
-
-    def __vc_test_helpers_build_controller(klass)
-      klass.new.tap { |c| c.request = vc_test_request }.extend(Rails.application.routes.url_helpers)
-    end
-
-    def __vc_test_helpers_preview_class
-      result = if respond_to?(:described_class)
-        # :nocov:
-        raise "`render_preview` expected a described_class, but it is nil." if described_class.nil?
-
-        "#{described_class}Preview"
-        # :nocov:
-      else
-        self.class.name.gsub("Test", "Preview")
-      end
-      result = result.constantize
-    rescue NameError
-      raise NameError, "`render_preview` expected to find #{result}, but it does not exist."
-    end
-    # :nocov:
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/view_component-3.23.2/lib/view_component/translatable.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-require "erb"
-require "set"
-require "i18n"
-require "active_support/concern"
-
-module ViewComponent
-  module Translatable
-    extend ActiveSupport::Concern
-
-    HTML_SAFE_TRANSLATION_KEY = /(?:_|\b)html\z/
-    TRANSLATION_EXTENSIONS = %w[yml yaml].freeze
-
-    included do
-      class_attribute :i18n_backend, instance_writer: false, instance_predicate: false
-    end
-
-    class_methods do
-      def i18n_scope
-        @i18n_scope ||= virtual_path.sub(%r{^/}, "").gsub(%r{/_?}, ".")
-      end
-
-      def build_i18n_backend
-        return if compiled?
-
-        # We need to load the translations files from the ancestors so a component
-        # can inherit translations from its parent and is able to overwrite them.
-        translation_files = ancestors.reverse_each.with_object([]) do |ancestor, files|
-          if ancestor.is_a?(Class) && ancestor < ViewComponent::Base
-            files.concat(ancestor.sidecar_files(TRANSLATION_EXTENSIONS))
-          end
-        end
-
-        # In development it will become nil if the translations file is removed
-        self.i18n_backend = if translation_files.any?
-          I18nBackend.new(
-            i18n_scope: i18n_scope,
-            load_paths: translation_files
-          )
-        end
-      end
-
-      def i18n_key(key, scope = nil)
-        scope = scope.join(".") if scope.is_a? Array
-        key = key&.to_s unless key.is_a?(String)
-        key = "#{scope}.#{key}" if scope
-        key = "#{i18n_scope}#{key}" if key.start_with?(".")
-        key
-      end
-
-      def translate(key = nil, **options)
-        return key.map { |k| translate(k, **options) } if key.is_a?(Array)
-
-        ensure_compiled
-
-        locale = options.delete(:locale) || ::I18n.locale
-        key = i18n_key(key, options.delete(:scope))
-
-        i18n_backend.translate(locale, key, options)
-      end
-
-      alias_method :t, :translate
-    end
-
-    class I18nBackend < ::I18n::Backend::Simple
-      EMPTY_HASH = {}.freeze
-
-      def initialize(i18n_scope:, load_paths:)
-        @i18n_scope = i18n_scope.split(".").map(&:to_sym)
-        @load_paths = load_paths
-      end
-
-      # Ensure the Simple backend won't load paths from ::I18n.load_path
-      def load_translations
-        super(@load_paths)
-      end
-
-      def scope_data(data)
-        @i18n_scope.reverse_each do |part|
-          data = {part => data}
-        end
-        data
-      end
-
-      def store_translations(locale, data, options = EMPTY_HASH)
-        super(locale, scope_data(data), options)
-      end
-    end
-
-    def translate(key = nil, **options)
-      raise ViewComponent::TranslateCalledBeforeRenderError if view_context.nil?
-
-      return super unless i18n_backend
-      return key.map { |k| translate(k, **options) } if key.is_a?(Array)
-
-      locale = options.delete(:locale) || ::I18n.locale
-      key = self.class.i18n_key(key, options.delete(:scope))
-      as_html = HTML_SAFE_TRANSLATION_KEY.match?(key)
-
-      html_escape_translation_options!(options) if as_html
-
-      if key.start_with?(i18n_scope + ".")
-        translated =
-          catch(:exception) do
-            i18n_backend.translate(locale, key, options)
-          end
-
-        # Fallback to the global translations
-        if translated.is_a? ::I18n::MissingTranslation
-          return super(key, locale: locale, **options)
-        end
-
-        translated = html_safe_translation(translated) if as_html
-        translated
-      else
-        super(key, locale: locale, **options)
-      end
-    end
-    alias_method :t, :translate
-
-    # Exposes .i18n_scope as an instance method
-    def i18n_scope
-      self.class.i18n_scope
-    end
-
-    private
-
-    def html_safe_translation(translation)
-      if translation.respond_to?(:map)
-        translation.map { |element| html_safe_translation(element) }
-      else
-        # It's assumed here that objects loaded by the i18n backend will respond to `#html_safe?`.
-        # It's reasonable that if we're in Rails, `active_support/core_ext/string/output_safety.rb`
-        # will provide this to `Object`.
-        translation.html_safe
-      end
-    end
-
-    def html_escape_translation_options!(options)
-      options.except(*::I18n::RESERVED_KEYS).each do |name, value|
-        next if name == :count && value.is_a?(Numeric)
-
-        options[name] = ERB::Util.html_escape(value.to_s)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/view_component-3.23.2/lib/view_component/use_helpers.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module ViewComponent::UseHelpers
-  extend ActiveSupport::Concern
-
-  class_methods do
-    def use_helpers(*args, from: nil, prefix: false)
-      args.each { |helper_method| use_helper(helper_method, from: from, prefix: prefix) }
-    end
-
-    def use_helper(helper_method, from: nil, prefix: false)
-      helper_method_name = full_helper_method_name(helper_method, prefix: prefix, source: from)
-
-      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        def #{helper_method_name}(*args, &block)
-          raise HelpersCalledBeforeRenderError if view_context.nil?
-
-          #{define_helper(helper_method: helper_method, source: from)}
-        end
-      RUBY
-      ruby2_keywords(helper_method_name) if respond_to?(:ruby2_keywords, true)
-    end
-
-    private
-
-    def full_helper_method_name(helper_method, prefix: false, source: nil)
-      return helper_method unless prefix.present?
-
-      if !!prefix == prefix
-        "#{source.to_s.underscore}_#{helper_method}"
-      else
-        "#{prefix}_#{helper_method}"
-      end
-    end
-
-    def define_helper(helper_method:, source:)
-      return "__vc_original_view_context.#{helper_method}(*args, &block)" unless source.present?
-
-      "#{source}.instance_method(:#{helper_method}).bind(self).call(*args, &block)"
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/view_component-3.23.2/lib/view_component/version.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module ViewComponent
-  module VERSION
-    MAJOR = 3
-    MINOR = 23
-    PATCH = 2
-    PRE = nil
-
-    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
-  end
-end
-
-puts ViewComponent::VERSION::STRING if __FILE__ == $PROGRAM_NAME

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "action_view"
-require "active_support/dependencies/autoload"
-
-module ViewComponent
-  extend ActiveSupport::Autoload
-
-  autoload :Base
-  autoload :CaptureCompatibility
-  autoload :Compiler
-  autoload :CompileCache
-  autoload :ComponentError
-  autoload :Config
-  autoload :Deprecation
-  autoload :InlineTemplate
-  autoload :Instrumentation
-  autoload :Preview
-  autoload :TestHelpers
-  autoload :SystemTestHelpers
-  autoload :TestCase
-  autoload :SystemTestCase
-  autoload :Translatable
-end
-
-require "view_component/engine" if defined?(Rails::Engine)

data/vendor/bundle/ruby/3.4.0/specifications/benchmark-0.4.1.gemspec

@@ -1,23 +0,0 @@
-# -*- encoding: utf-8 -*-
-# stub: benchmark 0.4.1 ruby lib
-
-Gem::Specification.new do |s|
-  s.name = "benchmark".freeze
-  s.version = "0.4.1".freeze
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
-  s.metadata = { "homepage_uri" => "https://github.com/ruby/benchmark", "source_code_uri" => "https://github.com/ruby/benchmark" } if s.respond_to? :metadata=
-  s.require_paths = ["lib".freeze]
-  s.authors = ["Yukihiro Matsumoto".freeze]
-  s.bindir = "exe".freeze
-  s.date = "2025-05-30"
-  s.description = "a performance benchmarking library".freeze
-  s.email = ["matz@ruby-lang.org".freeze]
-  s.homepage = "https://github.com/ruby/benchmark".freeze
-  s.licenses = ["Ruby".freeze, "BSD-2-Clause".freeze]
-  s.required_ruby_version = Gem::Requirement.new(">= 2.1.0".freeze)
-  s.rubygems_version = "3.5.11".freeze
-  s.summary = "a performance benchmarking library".freeze
-
-  s.installed_by_version = "3.6.9".freeze
-end