RubyGems - tdiary - Versions diffs - 5.2.2 → 5.2.3 - Mend

tdiary 5.2.2 → 5.2.3

Files changed (1533) hide show

data/vendor/bundle/ruby/3.1.0/gems/rack-test-1.1.0/lib/rack/test/methods.rb DELETED Viewed

@@ -1,83 +0,0 @@
-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).
-    #
-    # Example:
-    #
-    #   class HomepageTest < Test::Unit::TestCase
-    #     include Rack::Test::Methods
-    #
-    #     def app
-    #       MyApp.new
-    #     end
-    #   end
-    module Methods
-      extend Forwardable
-      def rack_mock_session(name = :default) # :nodoc:
-        return build_rack_mock_session unless name
-        @_rack_mock_sessions ||= {}
-        @_rack_mock_sessions[name] ||= build_rack_mock_session
-      end
-      def build_rack_mock_session # :nodoc:
-        Rack::MockSession.new(app)
-      end
-      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
-      def build_rack_test_session(name) # :nodoc:
-        Rack::Test::Session.new(rack_mock_session(name))
-      end
-      def current_session # :nodoc:
-        rack_test_session(_current_session_names.last)
-      end
-      def with_session(name) # :nodoc:
-        _current_session_names.push(name)
-        yield rack_test_session(name)
-        _current_session_names.pop
-      end
-      def _current_session_names # :nodoc:
-        @_current_session_names ||= [:default]
-      end
-      METHODS = %i[
-        request
-        get
-        post
-        put
-        patch
-        delete
-        options
-        head
-        custom_request
-        follow_redirect!
-        header
-        env
-        set_cookie
-        clear_cookies
-        authorize
-        basic_authorize
-        digest_authorize
-        last_response
-        last_request
-      ].freeze
-      def_delegators :current_session, *METHODS
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-test-1.1.0/lib/rack/test/mock_digest_request.rb DELETED Viewed

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

data/vendor/bundle/ruby/3.1.0/gems/rack-test-1.1.0/lib/rack/test/uploaded_file.rb DELETED Viewed

@@ -1,85 +0,0 @@
-require 'fileutils'
-require 'pathname'
-require 'tempfile'
-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.
-      #
-      # @param content [IO, Pathname, String, StringIO] a path to a file, or an {IO} or {StringIO} object representing the
-      #   file.
-      # @param content_type [String]
-      # @param binary [Boolean] an optional flag that indicates whether the file should be open in binary mode or not.
-      # @param original_filename [String] an optional parameter that provides the original filename if `content` is a StringIO
-      #   object. Not used for other kind of `content` objects.
-      def initialize(content, content_type = 'text/plain', binary = false, original_filename: nil)
-        if original_filename
-          initialize_from_stringio(content, original_filename)
-        else
-          initialize_from_file_path(content)
-        end
-        @content_type = content_type
-        @tempfile.binmode if binary
-      end
-      def path
-        tempfile.path
-      end
-      alias local_path path
-      def method_missing(method_name, *args, &block) #:nodoc:
-        tempfile.public_send(method_name, *args, &block)
-      end
-      def respond_to_missing?(method_name, include_private = false) #:nodoc:
-        tempfile.respond_to?(method_name, include_private) || super
-      end
-      def self.finalize(file)
-        proc { actually_finalize file }
-      end
-      def self.actually_finalize(file)
-        file.close
-        file.unlink
-      end
-      private
-      def initialize_from_stringio(stringio, original_filename)
-        @tempfile = stringio
-        @original_filename = original_filename || raise(ArgumentError, 'Missing `original_filename` for StringIO object')
-      end
-      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) if @tempfile.respond_to?(:set_encoding)
-        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-1.1.0/lib/rack/test/utils.rb DELETED Viewed

@@ -1,144 +0,0 @@
-module Rack
-  module Test
-    module Utils # :nodoc:
-      include Rack::Utils
-      extend Rack::Utils
-      def build_nested_query(value, prefix = nil)
-        case value
-        when Array
-          if value.empty?
-            "#{prefix}[]="
-          else
-            value.map do |v|
-              prefix = "#{prefix}[]" unless unescape(prefix) =~ /\[\]$/
-              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
-      module_function :build_nested_query
-      def build_multipart(params, first = true, multipart = false)
-        if first
-          raise ArgumentError, 'value must be a Hash' unless params.is_a?(Hash)
-          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
-        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 = {}
-                build_multipart(v, false).each do |subkey, subvalue|
-                  nested_params[subkey] = subvalue
-                end
-                flattened_params["#{k}[]"] ||= []
-                flattened_params["#{k}[]"] << nested_params
-              else
-                flattened_params["#{k}[]"] = value
-              end
-            end
-          when Hash
-            build_multipart(value, false).each do |subkey, subvalue|
-              flattened_params[k + subkey] = subvalue
-            end
-          else
-            flattened_params[k] = value
-          end
-        end
-        if first
-          build_parts(flattened_params)
-        else
-          flattened_params
-        end
-      end
-      module_function :build_multipart
-      private
-      def build_parts(parameters)
-        get_parts(parameters).join + "--#{MULTIPART_BOUNDARY}--\r"
-      end
-      module_function :build_parts
-      def get_parts(parameters)
-        parameters.map do |name, value|
-          if name =~ /\[\]\Z/ && value.is_a?(Array) && value.all? { |v| v.is_a?(Hash) }
-            value.map do |hash|
-              new_value = {}
-              hash.each { |k, v| new_value[name + k] = v }
-              get_parts(new_value).join
-            end.join
-          else
-            if value.respond_to?(:original_filename)
-              build_file_part(name, value)
-            elsif value.is_a?(Array) && value.all? { |v| v.respond_to?(:original_filename) }
-              value.map do |v|
-                build_file_part(name, v)
-              end.join
-            else
-              primitive_part = build_primitive_part(name, value)
-              Rack::Test.encoding_aware_strings? ? primitive_part.force_encoding('BINARY') : primitive_part
-            end
-          end
-        end
-      end
-      module_function :get_parts
-      def build_primitive_part(parameter_name, value)
-        value = [value] unless value.is_a? Array
-        value.map do |v|
-          <<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{parameter_name}"\r
-\r
-#{v}\r
-EOF
-        end.join
-      end
-      module_function :build_primitive_part
-      def build_file_part(parameter_name, uploaded_file)
-        uploaded_file.set_encoding(Encoding::BINARY) if uploaded_file.respond_to?(:set_encoding)
-        <<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{parameter_name}"; filename="#{escape(uploaded_file.original_filename)}"\r
-Content-Type: #{uploaded_file.content_type}\r
-Content-Length: #{uploaded_file.size}\r
-\r
-#{uploaded_file.read}\r
-EOF
-      end
-      module_function :build_file_part
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-test-1.1.0/lib/rack/test/version.rb DELETED Viewed

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

data/vendor/bundle/ruby/3.1.0/gems/rack-test-1.1.0/lib/rack/test.rb DELETED Viewed

@@ -1,334 +0,0 @@
-require 'uri'
-require 'rack'
-require 'rack/mock_session'
-require 'rack/test/cookie_jar'
-require 'rack/test/mock_digest_request'
-require 'rack/test/utils'
-require 'rack/test/methods'
-require 'rack/test/uploaded_file'
-require 'rack/test/version'
-module Rack
-  module Test
-    DEFAULT_HOST = 'example.org'.freeze
-    MULTIPART_BOUNDARY = '----------XnJLe9ZIbbGUYtzPQJ16u1'.freeze
-    # The common base class for exceptions raised by Rack::Test
-    class Error < StandardError; end
-    # This class represents a series of requests issued to a Rack app, sharing
-    # a single cookie jar
-    #
-    # Rack::Test::Session's methods are most often called through Rack::Test::Methods,
-    # which will automatically build a session when it's first used.
-    class Session
-      extend Forwardable
-      include Rack::Test::Utils
-      def_delegators :@rack_mock_session, :clear_cookies, :set_cookie, :last_response, :last_request
-      # Creates a Rack::Test::Session for a given Rack app or Rack::MockSession.
-      #
-      # Note: Generally, you won't need to initialize a Rack::Test::Session directly.
-      # Instead, you should include Rack::Test::Methods into your testing context.
-      # (See README.rdoc for an example)
-      def initialize(mock_session)
-        @headers = {}
-        @env = {}
-        @digest_username = nil
-        @digest_password = nil
-        @rack_mock_session = if mock_session.is_a?(MockSession)
-          mock_session
-        else
-          MockSession.new(mock_session)
-        end
-        @default_host = @rack_mock_session.default_host
-      end
-      # Issue a GET request for the given URI with the given params and Rack
-      # environment. Stores the issues request object in #last_request and
-      # the app's response in #last_response. Yield #last_response to a block
-      # if given.
-      #
-      # Example:
-      #   get "/"
-      def get(uri, params = {}, env = {}, &block)
-        custom_request('GET', uri, params, env, &block)
-      end
-      # Issue a POST request for the given URI. See #get
-      #
-      # Example:
-      #   post "/signup", "name" => "Bryan"
-      def post(uri, params = {}, env = {}, &block)
-        custom_request('POST', uri, params, env, &block)
-      end
-      # Issue a PUT request for the given URI. See #get
-      #
-      # Example:
-      #   put "/"
-      def put(uri, params = {}, env = {}, &block)
-        custom_request('PUT', uri, params, env, &block)
-      end
-      # Issue a PATCH request for the given URI. See #get
-      #
-      # Example:
-      #   patch "/"
-      def patch(uri, params = {}, env = {}, &block)
-        custom_request('PATCH', uri, params, env, &block)
-      end
-      # Issue a DELETE request for the given URI. See #get
-      #
-      # Example:
-      #   delete "/"
-      def delete(uri, params = {}, env = {}, &block)
-        custom_request('DELETE', uri, params, env, &block)
-      end
-      # Issue an OPTIONS request for the given URI. See #get
-      #
-      # Example:
-      #   options "/"
-      def options(uri, params = {}, env = {}, &block)
-        custom_request('OPTIONS', uri, params, env, &block)
-      end
-      # Issue a HEAD request for the given URI. See #get
-      #
-      # Example:
-      #   head "/"
-      def head(uri, params = {}, env = {}, &block)
-        custom_request('HEAD', uri, params, env, &block)
-      end
-      # Issue a request to the Rack app for the given URI and optional Rack
-      # environment. Stores the issues request object in #last_request and
-      # the app's response in #last_response. Yield #last_response to a block
-      # if given.
-      #
-      # Example:
-      #   request "/"
-      def request(uri, env = {}, &block)
-        uri = parse_uri(uri, env)
-        env = env_for(uri, env)
-        process_request(uri, env, &block)
-      end
-      # Issue a request using the given verb for the given URI. See #get
-      #
-      # Example:
-      #   custom_request "LINK", "/"
-      def custom_request(verb, uri, params = {}, env = {}, &block)
-        uri = parse_uri(uri, env)
-        env = env_for(uri, env.merge(method: verb.to_s.upcase, params: params))
-        process_request(uri, env, &block)
-      end
-      # Set a header to be included on all subsequent requests through the
-      # session. Use a value of nil to remove a previously configured header.
-      #
-      # In accordance with the Rack spec, headers will be included in the Rack
-      # environment hash in HTTP_USER_AGENT form.
-      #
-      # Example:
-      #   header "User-Agent", "Firefox"
-      def header(name, value)
-        if value.nil?
-          @headers.delete(name)
-        else
-          @headers[name] = value
-        end
-      end
-      # Set an env var to be included on all subsequent requests through the
-      # session. Use a value of nil to remove a previously configured env.
-      #
-      # Example:
-      #   env "rack.session", {:csrf => 'token'}
-      def env(name, value)
-        if value.nil?
-          @env.delete(name)
-        else
-          @env[name] = value
-        end
-      end
-      # Set the username and password for HTTP Basic authorization, to be
-      # included in subsequent requests in the HTTP_AUTHORIZATION header.
-      #
-      # Example:
-      #   basic_authorize "bryan", "secret"
-      def basic_authorize(username, password)
-        encoded_login = ["#{username}:#{password}"].pack('m0')
-        header('Authorization', "Basic #{encoded_login}")
-      end
-      alias authorize basic_authorize
-      # Set the username and password for HTTP Digest authorization, to be
-      # included in subsequent requests in the HTTP_AUTHORIZATION header.
-      #
-      # Example:
-      #   digest_authorize "bryan", "secret"
-      def digest_authorize(username, password)
-        @digest_username = username
-        @digest_password = password
-      end
-      # Rack::Test will not follow any redirects automatically. This method
-      # will follow the redirect returned (including setting the Referer header
-      # on the new request) in the last response. If the last response was not
-      # a redirect, an error will be raised.
-      def follow_redirect!
-        unless last_response.redirect?
-          raise Error, 'Last response was not a redirect. Cannot follow_redirect!'
-        end
-        request_method, params =
-          if last_response.status == 307
-            [last_request.request_method.downcase.to_sym, last_request.params]
-          else
-            [:get, {}]
-          end
-        # Compute the next location by appending the location header with the
-        # last request, as per https://tools.ietf.org/html/rfc7231#section-7.1.2
-        # Adding two absolute locations returns the right-hand location
-        next_location = URI.parse(last_request.url) + URI.parse(last_response['Location'])
-        send(
-          request_method, next_location.to_s, params,
-          'HTTP_REFERER' => last_request.url,
-          'rack.session' => last_request.session,
-          'rack.session.options' => last_request.session_options
-        )
-      end
-      private
-      def parse_uri(path, env)
-        URI.parse(path).tap do |uri|
-          uri.path = "/#{uri.path}" unless uri.path[0] == '/'
-          uri.host ||= @default_host
-          uri.scheme ||= 'https' if env['HTTPS'] == 'on'
-        end
-      end
-      def env_for(uri, env)
-        env = default_env.merge(env)
-        env['HTTP_HOST'] ||= [uri.host, (uri.port if uri.port != uri.default_port)].compact.join(':')
-        env.update('HTTPS' => 'on') if URI::HTTPS === uri
-        env['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest' if env[:xhr]
-        # TODO: Remove this after Rack 1.1 has been released.
-        # Stringifying and upcasing methods has be commit upstream
-        env['REQUEST_METHOD'] ||= env[:method] ? env[:method].to_s.upcase : 'GET'
-        params = env.delete(:params) do {} end
-        if env['REQUEST_METHOD'] == 'GET'
-          # merge :params with the query string
-          if params
-            params = parse_nested_query(params) if params.is_a?(String)
-            uri.query = [uri.query, build_nested_query(params)].compact.reject { |v| v == '' }.join('&')
-          end
-        elsif !env.key?(:input)
-          env['CONTENT_TYPE'] ||= 'application/x-www-form-urlencoded'
-          if params.is_a?(Hash)
-            if data = build_multipart(params)
-              env[:input] = data
-              env['CONTENT_LENGTH'] ||= data.length.to_s
-              env['CONTENT_TYPE'] = "multipart/form-data; boundary=#{MULTIPART_BOUNDARY}"
-            else
-              # NB: We do not need to set CONTENT_LENGTH here;
-              # Rack::ContentLength will determine it automatically.
-              env[:input] = params_to_string(params)
-            end
-          else
-            env[:input] = params
-          end
-        end
-        set_cookie(env.delete(:cookie), uri) if env.key?(:cookie)
-        Rack::MockRequest.env_for(uri.to_s, env)
-      end
-      def process_request(uri, env)
-        @rack_mock_session.request(uri, env)
-        if retry_with_digest_auth?(env)
-          auth_env = env.merge('HTTP_AUTHORIZATION' => digest_auth_header,
-                               'rack-test.digest_auth_retry' => true)
-          auth_env.delete('rack.request')
-          process_request(uri.path, auth_env)
-        else
-          yield last_response if block_given?
-          last_response
-        end
-      end
-      def digest_auth_header
-        challenge = last_response['WWW-Authenticate'].split(' ', 2).last
-        params = Rack::Auth::Digest::Params.parse(challenge)
-        params.merge!('username' => @digest_username,
-                      'nc'        => '00000001',
-                      'cnonce'    => 'nonsensenonce',
-                      'uri'       => last_request.fullpath,
-                      'method'    => last_request.env['REQUEST_METHOD'])
-        params['response'] = MockDigestRequest.new(params).response(@digest_password)
-        "Digest #{params}"
-      end
-      def retry_with_digest_auth?(env)
-        last_response.status == 401 &&
-          digest_auth_configured? &&
-          !env['rack-test.digest_auth_retry']
-      end
-      def digest_auth_configured?
-        @digest_username
-      end
-      def default_env
-        { 'rack.test' => true, 'REMOTE_ADDR' => '127.0.0.1' }.merge(@env).merge(headers_for_env)
-      end
-      def headers_for_env
-        converted_headers = {}
-        @headers.each do |name, value|
-          env_key = name.upcase.tr('-', '_')
-          env_key = 'HTTP_' + env_key unless env_key == 'CONTENT_TYPE'
-          converted_headers[env_key] = value
-        end
-        converted_headers
-      end
-      def params_to_string(params)
-        case params
-        when Hash then build_nested_query(params)
-        when nil  then ''
-        else params
-        end
-      end
-    end
-    def self.encoding_aware_strings?
-      defined?(Encoding) && ''.respond_to?(:encode)
-    end
-  end
-end