tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/rack-test-2.0.2/lib/rack/test/cookie_jar.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'time'
+
+module Rack
+  module Test
+    # Represents individual cookies in the cookie jar.  This is considered private
+    # API and behavior of this class can change at any time.
+    class Cookie # :nodoc:
+      include Rack::Utils
+
+      # The name of the cookie, will be a string
+      attr_reader :name
+      
+      # The value of the cookie, will be a string or nil if there is no value.
+      attr_reader :value
+
+      # The raw string for the cookie, without options. Will generally be in
+      # name=value format is name and value are provided.
+      attr_reader :raw
+
+      def initialize(raw, uri = nil, default_host = DEFAULT_HOST)
+        @default_host = default_host
+        uri ||= default_uri
+
+        # separate the name / value pair from the cookie options
+        @raw, options = raw.split(/[;,] */n, 2)
+
+        @name, @value = parse_query(@raw, ';').to_a.first
+        @options = parse_query(options, ';')
+
+        if @options['domain']
+          @exact_domain_match = false
+        else
+          # If the domain attribute is not present in the cookie,
+          # the domain must match exactly.
+          @exact_domain_match = true
+          @options['domain'] = (uri.host || default_host)
+        end
+
+        # Set the path for the cookie to the directory containing
+        # the request if it isn't set.
+        @options['path'] ||= uri.path.sub(/\/[^\/]*\Z/, '')
+      end
+
+      # Wether the given cookie can replace the current cookie in the cookie jar.
+      def replaces?(other)
+        [name.downcase, domain, path] == [other.name.downcase, other.domain, other.path]
+      end
+
+      # Whether the cookie has a value.
+      def empty?
+        @value.nil? || @value.empty?
+      end
+
+      # The explicit or implicit domain for the cookie.
+      def domain
+        @options['domain']
+      end
+
+      # Whether the cookie has the secure flag, indicating it can only be sent over
+      # an encrypted connection.
+      def secure?
+        @options.key?('secure')
+      end
+
+      # Whether the cookie has the httponly flag, indicating it is not available via
+      # a javascript API.
+      def http_only?
+        @options.key?('HttpOnly') || @options.key?('httponly')
+      end
+
+      # The explicit or implicit path for the cookie.
+      def path
+        ([*@options['path']].first.split(',').first || '/').strip
+      end
+
+      # A Time value for when the cookie expires, if the expires option is set.
+      def expires
+        Time.parse(@options['expires']) if @options['expires']
+      end
+
+      # Whether the cookie is currently expired.
+      def expired?
+        expires && expires < Time.now
+      end
+
+      # Whether the cookie is valid for the given URI.
+      def valid?(uri)
+        uri ||= default_uri
+
+        uri.host = @default_host if uri.host.nil?
+
+        real_domain = domain =~ /^\./ ? domain[1..-1] : domain
+        !!((!secure? || (secure? && uri.scheme == 'https')) &&
+          uri.host =~ Regexp.new("#{'^' if @exact_domain_match}#{Regexp.escape(real_domain)}$", Regexp::IGNORECASE) &&
+          uri.path =~ Regexp.new("^#{Regexp.escape(path)}"))
+      end
+
+      # Cookies that do not match the URI will not be sent in requests to the URI.
+      def matches?(uri)
+        !expired? && valid?(uri)
+      end
+
+      # Order cookies by name, path, and domain.
+      def <=>(other)
+        [name, path, domain.reverse] <=> [other.name, other.path, other.domain.reverse]
+      end
+
+      # A hash of cookie options, including the cookie value, but excluding the cookie name.
+      def to_h
+        @options.merge(
+          'value'    => @value,
+          'HttpOnly' => http_only?,
+          'secure'   => secure?
+        )
+      end
+      alias to_hash to_h
+
+      private
+
+      # The default URI to use for the cookie, including just the host.
+      def default_uri
+        URI.parse('//' + @default_host + '/')
+      end
+    end
+
+    # Represents all cookies for a session, handling adding and
+    # removing cookies, and finding which cookies apply to a given
+    # request.  This is considered private API and behavior of this
+    # class can change at any time.
+    class CookieJar # :nodoc:
+      DELIMITER = '; '.freeze
+
+      def initialize(cookies = [], default_host = DEFAULT_HOST)
+        @default_host = default_host
+        @cookies = cookies.sort!
+      end
+
+      # Return the value for first cookie with the given name, or nil
+      # if no such cookie exists.
+      def [](name)
+        name = name.to_s
+        @cookies.each do |cookie|
+          return cookie.value if cookie.name == name
+        end
+        nil
+      end
+
+      # Set a cookie with the given name and value in the
+      # cookie jar.
+      def []=(name, value)
+        merge("#{name}=#{Rack::Utils.escape(value)}")
+      end
+
+      # Return the first cookie with the given name, or nil if
+      # no such cookie exists.
+      def get_cookie(name)
+        @cookies.each do |cookie|
+          return cookie if cookie.name == name
+        end
+        nil
+      end
+
+      # Delete all cookies with the given name from the cookie jar.
+      def delete(name)
+        @cookies.reject! do |cookie|
+          cookie.name == name
+        end
+        nil
+      end
+
+      # Add a string of raw cookie information to the cookie jar,
+      # if the cookie is valid for the given URI.
+      # Cookies should be separated with a newline.
+      def merge(raw_cookies, uri = nil)
+        return unless raw_cookies
+
+        if raw_cookies.is_a? String
+          raw_cookies = raw_cookies.split("\n")
+          raw_cookies.reject!(&:empty?)
+        end
+
+        raw_cookies.each do |raw_cookie|
+          cookie = Cookie.new(raw_cookie, uri, @default_host)
+          self << cookie if cookie.valid?(uri)
+        end
+      end
+
+      # Add a Cookie to the cookie jar.
+      def <<(new_cookie)
+        @cookies.reject! do |existing_cookie|
+          new_cookie.replaces?(existing_cookie)
+        end
+
+        @cookies << new_cookie
+        @cookies.sort!
+      end
+
+      # Return a raw cookie string for the cookie header to
+      # use for the given URI.
+      def for(uri)
+        buf = String.new
+        delimiter = nil
+
+        each_cookie_for(uri) do |cookie|
+          if delimiter
+            buf << delimiter
+          else
+            delimiter = DELIMITER
+          end
+          buf << cookie.raw
+        end
+
+        buf
+      end
+
+      # Return a hash cookie names and cookie values for cookies in the jar.
+      def to_hash
+        cookies = {}
+
+        @cookies.each do |cookie|
+          cookies[cookie.name] = cookie.value
+        end
+
+        cookies
+      end
+
+      private
+
+      # Yield each cookie that matches for the URI.
+      #
+      # The cookies are sorted by most specific first. So, we loop through
+      # all the cookies in order and add it to a hash by cookie name if
+      # the cookie can be sent to the current URI. It's added to the hash
+      # so that when we are done, the cookies will be unique by name and
+      # we'll have grabbed the most specific to the URI.
+      def each_cookie_for(uri)
+        @cookies.each do |cookie|
+          yield cookie if !uri || cookie.matches?(uri)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/rack-test-2.0.2/lib/rack/test/methods.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Rack
+  module Test
+    # This module serves as the primary integration point for using Rack::Test
+    # in a testing environment. It depends on an app method being defined in the
+    # same context, and provides the Rack::Test API methods (see Rack::Test::Session
+    # for their documentation). It defines the following methods that are delegated
+    # to the current session: :request, :get, :post, :put, :patch, :delete, :options,
+    # :head, :custom_request, :follow_redirect!, :header, :env, :set_cookie,
+    # :clear_cookies, :authorize, :basic_authorize, :last_response, and :last_request.
+    #
+    # Example:
+    #
+    #   class HomepageTest < Test::Unit::TestCase
+    #     include Rack::Test::Methods
+    #
+    #     def app
+    #       MyApp
+    #     end
+    #   end
+    module Methods
+      extend Forwardable
+
+      # Return the existing session with the given name, or a new
+      # rack session.  Always use a new session if name is nil.
+      def rack_test_session(name = :default) # :nodoc:
+        return build_rack_test_session(name) unless name
+
+        @_rack_test_sessions ||= {}
+        @_rack_test_sessions[name] ||= build_rack_test_session(name)
+      end
+
+      # For backwards compatibility with older rack-test versions.
+      alias rack_mock_session rack_test_session # :nodoc:
+
+      # Create a new Rack::Test::Session for #app.
+      def build_rack_test_session(_name) # :nodoc:
+        if respond_to?(:build_rack_mock_session, true)
+          # Backwards compatibility for capybara
+          build_rack_mock_session
+        else
+          Session.new(app)
+        end
+      end
+
+      # Return the currently actively session.  This is the session to
+      # which the delegated methods are sent.
+      def current_session
+        @_rack_test_current_session ||= rack_test_session
+      end
+
+      # Create a new session (or reuse an existing session with the given name),
+      # and make it the current session for the given block.
+      def with_session(name)
+        session = _rack_test_current_session
+        yield(@_rack_test_current_session = rack_test_session(name))
+      ensure
+        @_rack_test_current_session = session
+      end
+
+      def digest_authorize(username, password) # :nodoc:
+        warn 'digest authentication support will be removed in rack-test 2.1', uplevel: 1
+        current_session._digest_authorize(username, password)
+      end
+
+      def_delegators(:current_session,
+        :request,
+        :get,
+        :post,
+        :put,
+        :patch,
+        :delete,
+        :options,
+        :head,
+        :custom_request,
+        :follow_redirect!,
+        :header,
+        :env,
+        :set_cookie,
+        :clear_cookies,
+        :authorize,
+        :basic_authorize,
+        :last_response,
+        :last_request,
+      )
+
+      # Private accessor to avoid uninitialized instance variable warning in Ruby 2.*
+      attr_accessor :_rack_test_current_session
+      private :_rack_test_current_session
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/rack-test-2.0.2/lib/rack/test/mock_digest_request.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# :nocov:
+require 'rack/auth/digest' unless defined?(Rack::Auth::Digest)
+# :nocov:
+
+module Rack
+  module Test
+    class MockDigestRequest_ # :nodoc:
+      def initialize(params)
+        @params = params
+      end
+
+      def method_missing(sym)
+        if @params.key? k = sym.to_s
+          return @params[k]
+        end
+
+        super
+      end
+
+      def method
+        @params['method']
+      end
+
+      def response(password)
+        Rack::Auth::Digest::MD5.new(nil).send :digest, self, password
+      end
+    end
+    MockDigestRequest = MockDigestRequest_
+    # :nocov:
+    deprecate_constant :MockDigestRequest if respond_to?(:deprecate_constant, true)
+    # :nocov:
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/rack-test-2.0.2/lib/rack/test/uploaded_file.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tempfile'
+require 'stringio'
+
+module Rack
+  module Test
+    # Wraps a Tempfile with a content type. Including one or more UploadedFile's
+    # in the params causes Rack::Test to build and issue a multipart request.
+    #
+    # Example:
+    #   post "/photos", "file" => Rack::Test::UploadedFile.new("me.jpg", "image/jpeg")
+    class UploadedFile
+      # The filename, *not* including the path, of the "uploaded" file
+      attr_reader :original_filename
+
+      # The tempfile
+      attr_reader :tempfile
+
+      # The content type of the "uploaded" file
+      attr_accessor :content_type
+
+      # Creates a new UploadedFile instance.
+      #
+      # Arguments:
+      # content :: is a path to a file, or an {IO} or {StringIO} object representing the content.
+      # content_type :: MIME type of the file
+      # binary :: Whether the file should be set to binmode (content treated as binary).
+      # original_filename :: The filename to use for the file if +content+ is a StringIO.
+      def initialize(content, content_type = 'text/plain', binary = false, original_filename: nil)
+        case content
+        when StringIO
+          initialize_from_stringio(content, original_filename)
+        else
+          initialize_from_file_path(content)
+        end
+
+        @content_type = content_type
+        @tempfile.binmode if binary
+      end
+
+      # The path to the tempfile. Will not work if the receiver's content is from a StringIO.
+      def path
+        tempfile.path
+      end
+      alias local_path path
+
+      # Delegate all methods not handled to the tempfile.
+      def method_missing(method_name, *args, &block)
+        tempfile.public_send(method_name, *args, &block)
+      end
+
+      # Append to given buffer in 64K chunks to avoid multiple large
+      # copies of file data in memory.  Rewind tempfile before and
+      # after to make sure all data in tempfile is appended to the
+      # buffer.
+      def append_to(buffer)
+        tempfile.rewind
+
+        buf = String.new
+        buffer << tempfile.readpartial(65_536, buf) until tempfile.eof?
+
+        tempfile.rewind
+
+        nil
+      end
+
+      def respond_to_missing?(method_name, include_private = false) #:nodoc:
+        tempfile.respond_to?(method_name, include_private) || super
+      end
+
+      # A proc that can be used as a finalizer to close and unlink the tempfile.
+      def self.finalize(file)
+        proc { actually_finalize file }
+      end
+
+      # Close and unlink the given file, used as a finalizer for the tempfile,
+      # if the tempfile is backed by a file in the filesystem.
+      def self.actually_finalize(file)
+        file.close
+        file.unlink
+      end
+
+      private
+
+      # Use the StringIO as the tempfile.
+      def initialize_from_stringio(stringio, original_filename)
+        @tempfile = stringio
+        @original_filename = original_filename || raise(ArgumentError, 'Missing `original_filename` for StringIO object')
+      end
+
+      # Create a tempfile and copy the content from the given path into the tempfile.
+      def initialize_from_file_path(path)
+        raise "#{path} file does not exist" unless ::File.exist?(path)
+
+        @original_filename = ::File.basename(path)
+        extension = ::File.extname(@original_filename)
+
+        @tempfile = Tempfile.new([::File.basename(@original_filename, extension), extension])
+        @tempfile.set_encoding(Encoding::BINARY)
+
+        ObjectSpace.define_finalizer(self, self.class.finalize(@tempfile))
+
+        FileUtils.copy_file(path, @tempfile.path)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/rack-test-2.0.2/lib/rack/test/utils.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Rack
+  module Test
+    module Utils # :nodoc:
+      include Rack::Utils
+      extend self
+
+      # Build a query string for the given value and prefix. The value
+      # can be an array or hash of parameters.
+      def build_nested_query(value, prefix = nil)
+        case value
+        when Array
+          if value.empty?
+            "#{prefix}[]="
+          else
+            prefix += "[]" unless unescape(prefix).end_with?('[]')
+            value.map do |v|
+              build_nested_query(v, prefix.to_s)
+            end.join('&')
+          end
+        when Hash
+          value.map do |k, v|
+            build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+          end.join('&')
+        when NilClass
+          prefix.to_s
+        else
+          "#{prefix}=#{escape(value)}"
+        end
+      end
+
+      # Build a multipart body for the given params.
+      def build_multipart(params, _first = true, multipart = false)
+        raise ArgumentError, 'value must be a Hash' unless params.is_a?(Hash)
+
+        unless multipart
+          query = lambda { |value|
+            case value
+            when Array
+              value.each(&query)
+            when Hash
+              value.values.each(&query)
+            when UploadedFile
+              multipart = true
+            end
+          }
+          params.values.each(&query)
+          return nil unless multipart
+        end
+
+        params = normalize_multipart_params(params, true)
+
+        buffer = String.new
+        build_parts(buffer, params)
+        buffer
+      end
+
+      private
+
+      # Return a flattened hash of parameter values based on the given params.
+      def normalize_multipart_params(params, first=false)
+        flattened_params = {}
+
+        params.each do |key, value|
+          k = first ? key.to_s : "[#{key}]"
+
+          case value
+          when Array
+            value.map do |v|
+              if v.is_a?(Hash)
+                nested_params = {}
+                normalize_multipart_params(v).each do |subkey, subvalue|
+                  nested_params[subkey] = subvalue
+                end
+                (flattened_params["#{k}[]"] ||= []) << nested_params
+              else
+                flattened_params["#{k}[]"] = value
+              end
+            end
+          when Hash
+            normalize_multipart_params(value).each do |subkey, subvalue|
+              flattened_params[k + subkey] = subvalue
+            end
+          else
+            flattened_params[k] = value
+          end
+        end
+
+        flattened_params
+      end
+
+      # Build the multipart content for uploading.
+      def build_parts(buffer, parameters)
+        _build_parts(buffer, parameters)
+        buffer << END_BOUNDARY
+      end
+
+      # Append each multipart parameter value to the buffer.
+      def _build_parts(buffer, parameters)
+        parameters.map do |name, value|
+          if name =~ /\[\]\Z/ && value.is_a?(Array) && value.all? { |v| v.is_a?(Hash) }
+            value.each do |hash|
+              new_value = {}
+              hash.each { |k, v| new_value[name + k] = v }
+              _build_parts(buffer, new_value)
+            end
+          else
+            [value].flatten.map do |v|
+              if v.respond_to?(:original_filename)
+                build_file_part(buffer, name, v)
+              else
+                build_primitive_part(buffer, name, v)
+              end
+            end
+          end
+        end
+      end
+
+      # Append the multipart fragment for a parameter that isn't a file upload to the buffer.
+      def build_primitive_part(buffer, parameter_name, value)
+        buffer <<
+          START_BOUNDARY <<
+          "content-disposition: form-data; name=\"" <<
+          parameter_name.to_s.b <<
+          "\"\r\n\r\n" <<
+          value.to_s.b <<
+          "\r\n"
+        buffer
+      end
+
+      # Append the multipart fragment for a parameter that is a file upload to the buffer.
+      def build_file_part(buffer, parameter_name, uploaded_file)
+        buffer <<
+          START_BOUNDARY <<
+          "content-disposition: form-data; name=\"" <<
+          parameter_name.to_s.b <<
+          "\"; filename=\"" <<
+          escape_path(uploaded_file.original_filename).b <<
+          "\"\r\ncontent-type: " <<
+          uploaded_file.content_type.to_s.b <<
+          "\r\ncontent-length: " <<
+          uploaded_file.size.to_s.b <<
+          "\r\n\r\n"
+
+        # Handle old versions of Capybara::RackTest::Form::NilUploadedFile
+        if uploaded_file.respond_to?(:set_encoding)
+          uploaded_file.set_encoding(Encoding::BINARY)
+          uploaded_file.append_to(buffer)
+        end
+
+        buffer << "\r\n"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/rack-test-2.0.2/lib/rack/test/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  module Test
+    VERSION = '2.0.2'.freeze
+  end
+end