tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/actionpack-8.1.2/lib/action_dispatch/testing/assertions/routing.rb

@@ -0,0 +1,355 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "uri"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/string/access"
+require "active_support/core_ext/module/redefine_method"
+require "action_controller/metal/exceptions"
+
+module ActionDispatch
+  module Assertions
+    # Suite of assertions to test routes generated by Rails and the handling of
+    # requests made to them.
+    module RoutingAssertions
+      extend ActiveSupport::Concern
+
+      module WithIntegrationRouting # :nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def with_routing(&block)
+            old_routes = nil
+            old_routes_call_method = nil
+            old_integration_session = nil
+
+            setup do
+              old_routes = initialize_lazy_routes(app.routes)
+              old_routes_call_method = old_routes.method(:call)
+              old_integration_session = integration_session
+              create_routes(&block)
+            end
+
+            teardown do
+              reset_routes(old_routes, old_routes_call_method, old_integration_session)
+            end
+          end
+        end
+
+        def with_routing(&block)
+          old_routes = initialize_lazy_routes(app.routes)
+          old_routes_call_method = old_routes.method(:call)
+          old_integration_session = integration_session
+          create_routes(&block)
+        ensure
+          reset_routes(old_routes, old_routes_call_method, old_integration_session)
+        end
+
+        private
+          def initialize_lazy_routes(routes)
+            if defined?(Rails::Engine::LazyRouteSet) && routes.is_a?(Rails::Engine::LazyRouteSet)
+              routes.tap(&:routes)
+            else
+              routes
+            end
+          end
+
+          def create_routes
+            app = self.app
+            routes = ActionDispatch::Routing::RouteSet.new
+
+            @original_routes ||= app.routes
+            @original_routes.singleton_class.redefine_method(:call, &routes.method(:call))
+
+            https = integration_session.https?
+            host = integration_session.host
+
+            app.instance_variable_set(:@routes, routes)
+            @integration_session = Class.new(ActionDispatch::Integration::Session) do
+              include app.routes.url_helpers
+              include app.routes.mounted_helpers
+            end.new(app)
+            @integration_session.https! https
+            @integration_session.host! host
+            @routes = routes
+
+            yield routes
+          end
+
+          def reset_routes(old_routes, old_routes_call_method, old_integration_session)
+            app.instance_variable_set(:@routes, old_routes)
+            @original_routes.singleton_class.redefine_method(:call, &old_routes_call_method)
+            @integration_session = old_integration_session
+            @routes = old_routes
+          end
+      end
+
+      module ClassMethods
+        # A helper to make it easier to test different route configurations. This method
+        # temporarily replaces @routes with a new RouteSet instance before each test.
+        #
+        # The new instance is yielded to the passed block. Typically the block will
+        # create some routes using `set.draw { match ... }`:
+        #
+        #     with_routing do |set|
+        #       set.draw do
+        #         resources :users
+        #       end
+        #     end
+        #
+        def with_routing(&block)
+          old_routes, old_controller = nil
+
+          setup do
+            old_routes, old_controller = @routes, @controller
+            create_routes(&block)
+          end
+
+          teardown do
+            reset_routes(old_routes, old_controller)
+          end
+        end
+      end
+
+      def setup # :nodoc:
+        @routes ||= nil
+        super
+      end
+
+      # A helper to make it easier to test different route configurations. This method
+      # temporarily replaces @routes with a new RouteSet instance.
+      #
+      # The new instance is yielded to the passed block. Typically the block will
+      # create some routes using `set.draw { match ... }`:
+      #
+      #     with_routing do |set|
+      #       set.draw do
+      #         resources :users
+      #       end
+      #       assert_equal "/users", users_path
+      #     end
+      #
+      def with_routing(config = nil, &block)
+        old_routes, old_controller = @routes, @controller
+        create_routes(config, &block)
+      ensure
+        reset_routes(old_routes, old_controller)
+      end
+
+      # Asserts that the routing of the given `path` was handled correctly and that
+      # the parsed options (given in the `expected_options` hash) match `path`.
+      # Basically, it asserts that Rails recognizes the route given by
+      # `expected_options`.
+      #
+      # Pass a hash in the second argument (`path`) to specify the request method.
+      # This is useful for routes requiring a specific HTTP method. The hash should
+      # contain a `:path` with the incoming request path and a `:method` containing
+      # the required HTTP verb.
+      #
+      #     # Asserts that POSTing to /items will call the create action on ItemsController
+      #     assert_recognizes({controller: 'items', action: 'create'}, {path: 'items', method: :post})
+      #
+      # You can also pass in `extras` with a hash containing URL parameters that would
+      # normally be in the query string. This can be used to assert that values in the
+      # query string will end up in the params hash correctly. To test query strings
+      # you must use the extras argument because appending the query string on the
+      # path directly will not work. For example:
+      #
+      #     # Asserts that a path of '/items/list/1?view=print' returns the correct options
+      #     assert_recognizes({controller: 'items', action: 'list', id: '1', view: 'print'}, 'items/list/1', { view: "print" })
+      #
+      # The `message` parameter allows you to pass in an error message that is
+      # displayed upon failure.
+      #
+      #     # Check the default route (i.e., the index action)
+      #     assert_recognizes({controller: 'items', action: 'index'}, 'items')
+      #
+      #     # Test a specific action
+      #     assert_recognizes({controller: 'items', action: 'list'}, 'items/list')
+      #
+      #     # Test an action with a parameter
+      #     assert_recognizes({controller: 'items', action: 'destroy', id: '1'}, 'items/destroy/1')
+      #
+      #     # Test a custom route
+      #     assert_recognizes({controller: 'items', action: 'show', id: '1'}, 'view/item1')
+      def assert_recognizes(expected_options, path, extras = {}, msg = nil)
+        if path.is_a?(Hash) && path[:method].to_s == "all"
+          [:get, :post, :put, :delete].each do |method|
+            assert_recognizes(expected_options, path.merge(method: method), extras, msg)
+          end
+        else
+          request = recognized_request_for(path, extras, msg)
+
+          expected_options = expected_options.clone
+
+          expected_options.stringify_keys!
+
+          msg = message(msg, "") {
+            sprintf("The recognized options <%s> did not match <%s>, difference:",
+                    request.path_parameters, expected_options)
+          }
+
+          assert_equal(expected_options, request.path_parameters, msg)
+        end
+      end
+
+      # Asserts that the provided options can be used to generate the provided path.
+      # This is the inverse of `assert_recognizes`. The `extras` parameter is used to
+      # tell the request the names and values of additional request parameters that
+      # would be in a query string. The `message` parameter allows you to specify a
+      # custom error message for assertion failures.
+      #
+      # The `defaults` parameter is unused.
+      #
+      #     # Asserts that the default action is generated for a route with no action
+      #     assert_generates "/items", controller: "items", action: "index"
+      #
+      #     # Tests that the list action is properly routed
+      #     assert_generates "/items/list", controller: "items", action: "list"
+      #
+      #     # Tests the generation of a route with a parameter
+      #     assert_generates "/items/list/1", { controller: "items", action: "list", id: "1" }
+      #
+      #     # Asserts that the generated route gives us our custom route
+      #     assert_generates "changesets/12", { controller: 'scm', action: 'show_diff', revision: "12" }
+      def assert_generates(expected_path, options, defaults = {}, extras = {}, message = nil)
+        if expected_path.include?("://")
+          fail_on(URI::InvalidURIError, message) do
+            uri = URI.parse(expected_path)
+            expected_path = uri.path.to_s.empty? ? "/" : uri.path
+          end
+        else
+          expected_path = "/#{expected_path}" unless expected_path.start_with?("/")
+        end
+
+        options = options.clone
+        generated_path, query_string_keys = @routes.generate_extras(options, defaults)
+        found_extras = options.reject { |k, _| ! query_string_keys.include? k }
+
+        msg = message || sprintf("found extras <%s>, not <%s>", found_extras, extras)
+        assert_equal(extras, found_extras, msg)
+
+        msg = message || sprintf("The generated path <%s> did not match <%s>", generated_path,
+            expected_path)
+        assert_equal(expected_path, generated_path, msg)
+      end
+
+      # Asserts that path and options match both ways; in other words, it verifies
+      # that `path` generates `options` and then that `options` generates `path`. This
+      # essentially combines `assert_recognizes` and `assert_generates` into one step.
+      #
+      # The `extras` hash allows you to specify options that would normally be
+      # provided as a query string to the action. The `message` parameter allows you
+      # to specify a custom error message to display upon failure.
+      #
+      #     # Asserts a basic route: a controller with the default action (index)
+      #     assert_routing '/home', controller: 'home', action: 'index'
+      #
+      #     # Test a route generated with a specific controller, action, and parameter (id)
+      #     assert_routing '/entries/show/23', controller: 'entries', action: 'show', id: 23
+      #
+      #     # Asserts a basic route (controller + default action), with an error message if it fails
+      #     assert_routing '/store', { controller: 'store', action: 'index' }, {}, {}, 'Route for store index not generated properly'
+      #
+      #     # Tests a route, providing a defaults hash
+      #     assert_routing 'controller/action/9', {id: "9", item: "square"}, {controller: "controller", action: "action"}, {}, {item: "square"}
+      #
+      #     # Tests a route with an HTTP method
+      #     assert_routing({ method: 'put', path: '/product/321' }, { controller: "product", action: "update", id: "321" })
+      def assert_routing(path, options, defaults = {}, extras = {}, message = nil)
+        assert_recognizes(options, path, extras, message)
+
+        controller, default_controller = options[:controller], defaults[:controller]
+        if controller && controller.include?(?/) && default_controller && default_controller.include?(?/)
+          options[:controller] = "/#{controller}"
+        end
+
+        generate_options = options.dup.delete_if { |k, _| defaults.key?(k) }
+        assert_generates(path.is_a?(Hash) ? path[:path] : path, generate_options, defaults, extras, message)
+      end
+
+      # ROUTES TODO: These assertions should really work in an integration context
+      def method_missing(selector, ...)
+        if @controller && @routes&.named_routes&.route_defined?(selector)
+          @controller.public_send(selector, ...)
+        else
+          super
+        end
+      end
+
+      private
+        def create_routes(config = nil)
+          @routes = ActionDispatch::Routing::RouteSet.new(config || ActionDispatch::Routing::RouteSet::DEFAULT_CONFIG)
+          if @controller
+            @controller = @controller.clone
+            _routes = @routes
+
+            @controller.singleton_class.include(_routes.url_helpers)
+
+            if @controller.respond_to? :view_context_class
+              view_context_class = Class.new(@controller.view_context_class) do
+                include _routes.url_helpers
+              end
+
+              custom_view_context = Module.new {
+                define_method(:view_context_class) do
+                  view_context_class
+                end
+              }
+              @controller.extend(custom_view_context)
+            end
+          end
+          yield @routes
+        end
+
+        def reset_routes(old_routes, old_controller)
+          @routes = old_routes
+          if @controller
+            @controller = old_controller
+          end
+        end
+
+        # Recognizes the route for a given path.
+        def recognized_request_for(path, extras = {}, msg)
+          if path.is_a?(Hash)
+            method = path[:method]
+            path   = path[:path]
+          else
+            method = :get
+          end
+
+          controller = @controller if defined?(@controller)
+          request = ActionController::TestRequest.create controller&.class
+
+          if path.include?("://")
+            fail_on(URI::InvalidURIError, msg) do
+              uri = URI.parse(path)
+              request.env["rack.url_scheme"] = uri.scheme || "http"
+              request.host = uri.host if uri.host
+              request.port = uri.port if uri.port
+              request.path = uri.path.to_s.empty? ? "/" : uri.path
+            end
+          else
+            path = "/#{path}" unless path.start_with?("/")
+            request.path = path
+          end
+
+          request.request_method = method if method
+
+          params = fail_on(ActionController::RoutingError, msg) do
+            @routes.recognize_path(path, method: method, extras: extras)
+          end
+          request.path_parameters = params.with_indifferent_access
+
+          request
+        end
+
+        def fail_on(exception_class, message)
+          yield
+        rescue exception_class => e
+          flunk(message || e.message)
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/actionpack-8.1.2/lib/action_dispatch.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#++
+
+# :markup: markdown
+
+require "active_support"
+require "active_support/rails"
+require "active_support/core_ext/module/attribute_accessors"
+
+require "action_pack"
+require "rack"
+require "action_dispatch/deprecator"
+
+module Rack # :nodoc:
+  autoload :Test, "rack/test"
+end
+
+# # Action Dispatch
+#
+# Action Dispatch is a module of Action Pack.
+#
+# Action Dispatch parses information about the web request, handles routing as
+# defined by the user, and does advanced processing related to HTTP such as
+# MIME-type negotiation, decoding parameters in POST, PATCH, or PUT bodies,
+# handling HTTP caching logic, cookies and sessions.
+module ActionDispatch
+  extend ActiveSupport::Autoload
+
+  class MissingController < NameError
+  end
+
+  eager_autoload do
+    autoload_under "http" do
+      autoload :ContentSecurityPolicy
+      autoload :InvalidParameterError, "action_dispatch/http/param_error"
+      autoload :ParamBuilder
+      autoload :ParamError
+      autoload :ParameterTypeError, "action_dispatch/http/param_error"
+      autoload :ParamsTooDeepError, "action_dispatch/http/param_error"
+      autoload :PermissionsPolicy
+      autoload :QueryParser
+      autoload :Request
+      autoload :Response
+    end
+  end
+
+  autoload_under "middleware" do
+    autoload :AssumeSSL
+    autoload :HostAuthorization
+    autoload :RequestId
+    autoload :Callbacks
+    autoload :Cookies
+    autoload :ActionableExceptions
+    autoload :DebugExceptions
+    autoload :DebugLocks
+    autoload :DebugView
+    autoload :ExceptionWrapper
+    autoload :Executor
+    autoload :Flash
+    autoload :PublicExceptions
+    autoload :Reloader
+    autoload :RemoteIp
+    autoload :ServerTiming
+    autoload :ShowExceptions
+    autoload :SSL
+    autoload :Static
+  end
+
+  autoload :Constants
+  autoload :Journey
+  autoload :MiddlewareStack, "action_dispatch/middleware/stack"
+  autoload :Routing
+
+  module Http
+    extend ActiveSupport::Autoload
+
+    autoload :Cache
+    autoload :Headers
+    autoload :MimeNegotiation
+    autoload :Parameters
+    autoload :UploadedFile, "action_dispatch/http/upload"
+    autoload :URL
+  end
+
+  module Session
+    autoload :AbstractStore,       "action_dispatch/middleware/session/abstract_store"
+    autoload :AbstractSecureStore, "action_dispatch/middleware/session/abstract_store"
+    autoload :CookieStore,         "action_dispatch/middleware/session/cookie_store"
+    autoload :MemCacheStore,       "action_dispatch/middleware/session/mem_cache_store"
+    autoload :CacheStore,          "action_dispatch/middleware/session/cache_store"
+
+    def self.resolve_store(session_store) # :nodoc:
+      self.const_get(session_store.to_s.camelize)
+    rescue NameError
+      raise <<~ERROR
+        Unable to resolve session store #{session_store.inspect}.
+
+        #{session_store.inspect} resolves to ActionDispatch::Session::#{session_store.to_s.camelize},
+        but that class is undefined.
+
+        Is #{session_store.inspect} spelled correctly, and are any necessary gems installed?
+      ERROR
+    end
+  end
+
+  mattr_accessor :test_app
+
+  autoload_under "testing" do
+    autoload :Assertions
+    autoload :Integration
+    autoload :IntegrationTest, "action_dispatch/testing/integration"
+    autoload :TestProcess
+    autoload :TestRequest
+    autoload :TestResponse
+    autoload :AssertionResponse
+  end
+
+  autoload :SystemTestCase, "action_dispatch/system_test_case"
+
+  ##
+  # :singleton-method:
+  #
+  # Specifies if the methods calling redirects in controllers and routes should
+  #  be logged below their relevant log lines. Defaults to false.
+  singleton_class.attr_accessor :verbose_redirect_logs
+  self.verbose_redirect_logs = false
+
+  def eager_load!
+    super
+    Routing.eager_load!
+  end
+end
+
+autoload :Mime, "action_dispatch/http/mime_type"
+
+ActiveSupport.on_load(:action_view) do
+  ActionView::Base.default_formats ||= Mime::SET.symbols
+  ActionView::Template.mime_types_implementation = Mime
+  ActionView::LookupContext::DetailsKey.clear
+end

data/vendor/bundle/ruby/3.4.0/gems/actionpack-8.1.2/lib/action_pack/gem_version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionPack
+  # Returns the currently loaded version of Action Pack as a `Gem::Version`.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 8
+    MINOR = 1
+    TINY  = 2
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/actiontext-8.1.2/CHANGELOG.md

@@ -0,0 +1,73 @@
+## Rails 8.1.2 (January 08, 2026) ##
+
+*   No changes.
+
+
+## Rails 8.1.1 (October 28, 2025) ##
+
+*   No changes.
+
+
+## Rails 8.1.0 (October 22, 2025) ##
+
+*   De-couple `@rails/actiontext/attachment_upload.js` from `Trix.Attachment`
+
+    Implement `@rails/actiontext/index.js` with a `direct-upload:progress` event
+    listeners and `Promise` resolution.
+
+    *Sean Doyle*
+
+*   Capture block content for form helper methods
+
+    ```erb
+    <%= rich_textarea_tag :content, nil do %>
+      <h1>hello world</h1>
+    <% end %>
+    <!-- <input type="hidden" name="content" id="trix_input_1" value="&lt;h1&gt;hello world&lt;/h1&gt;"/><trix-editor … -->
+
+    <%= rich_textarea :message, :content, input: "trix_input_1" do %>
+      <h1>hello world</h1>
+    <% end %>
+    <!-- <input type="hidden" name="message[content]" id="trix_input_1" value="&lt;h1&gt;hello world&lt;/h1&gt;"/><trix-editor … -->
+
+    <%= form_with model: Message.new do |form| %>
+      <%= form.rich_textarea :content do %>
+        <h1>hello world</h1>
+      <% end %>
+    <% end %>
+    <!-- <form action="/messages" accept-charset="UTF-8" method="post"><input type="hidden" name="message[content]" id="message_content_trix_input_message" value="&lt;h1&gt;hello world&lt;/h1&gt;"/><trix-editor … -->
+    ```
+
+    *Sean Doyle*
+
+*   Generalize `:rich_text_area` Capybara selector
+
+    Prepare for more Action Text-capable WYSIWYG editors by making
+    `:rich_text_area` rely on the presence of `[role="textbox"]` and
+    `[contenteditable]` HTML attributes rather than a `<trix-editor>` element.
+
+    *Sean Doyle*
+
+*   Forward `fill_in_rich_text_area` options to Capybara
+
+    ```ruby
+    fill_in_rich_textarea "Rich text editor", id: "trix_editor_1", with: "Hello world!"
+    ```
+
+    *Sean Doyle*
+
+*   Attachment upload progress accounts for server processing time.
+
+    *Jeremy Daer*
+
+*   The Trix dependency is now satisfied by a gem, `action_text-trix`, rather than vendored
+    files. This allows applications to bump Trix versions independently of Rails
+    releases. Effectively this also upgrades Trix to `>= 2.1.15`.
+
+    *Mike Dalessio*
+
+*   Change `ActionText::RichText#embeds` assignment from `before_save` to `before_validation`
+
+    *Sean Doyle*
+
+Please check [8-0-stable](https://github.com/rails/rails/blob/8-0-stable/actiontext/CHANGELOG.md) for previous changes.