pract6 0.1.0

data/.gem/ruby/2.3.0/gems/rack-test-0.7.0/lib/rack/test/cookie_jar.rb

@@ -0,0 +1,198 @@
+require "uri"
+require "time"
+
+module Rack
+  module Test
+
+    class Cookie # :nodoc:
+      include Rack::Utils
+
+      # :api: private
+      attr_reader :name, :value
+
+      # :api: private
+      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
+        @name_value_raw, options = raw.split(/[;,] */n, 2)
+
+        @name, @value = parse_query(@name_value_raw, ';').to_a.first
+        @options = parse_query(options, ';')
+
+        @options["domain"]  ||= (uri.host || default_host)
+        @options["path"]    ||= uri.path.sub(/\/[^\/]*\Z/, "")
+      end
+
+      def replaces?(other)
+        [name.downcase, domain, path] == [other.name.downcase, other.domain, other.path]
+      end
+
+      # :api: private
+      def raw
+        @name_value_raw
+      end
+
+      # :api: private
+      def empty?
+        @value.nil? || @value.empty?
+      end
+
+      # :api: private
+      def domain
+        @options["domain"]
+      end
+
+      def secure?
+        @options.has_key?("secure")
+      end
+
+      def http_only?
+        @options.has_key?('HttpOnly')
+      end
+
+      # :api: private
+      def path
+        @options["path"].strip || "/"
+      end
+
+      # :api: private
+      def expires
+        Time.parse(@options["expires"]) if @options["expires"]
+      end
+
+      # :api: private
+      def expired?
+        expires && expires < Time.now
+      end
+
+      # :api: private
+      def valid?(uri)
+        uri ||= default_uri
+
+        if uri.host.nil?
+          uri.host = @default_host
+        end
+
+        real_domain = domain =~ /^\./ ? domain[1..-1] : domain
+        (!secure? || (secure? && uri.scheme == "https")) &&
+        uri.host =~ Regexp.new("#{Regexp.escape(real_domain)}$", Regexp::IGNORECASE) &&
+        uri.path =~ Regexp.new("^#{Regexp.escape(path)}")
+      end
+
+      # :api: private
+      def matches?(uri)
+        ! expired? && valid?(uri)
+      end
+
+      # :api: private
+      def <=>(other)
+        # Orders the cookies from least specific to most
+        [name, path, domain.reverse] <=> [other.name, other.path, other.domain.reverse]
+      end
+      def to_h
+        @options.merge(
+          'value'    => @value,
+          'HttpOnly' => http_only?,
+          'secure'   => secure?,
+        )
+      end
+      alias_method :to_hash, :to_h
+
+    protected
+
+      def default_uri
+        URI.parse("//" + @default_host + "/")
+      end
+
+    end
+
+    class CookieJar # :nodoc:
+
+      # :api: private
+      def initialize(cookies = [], default_host = DEFAULT_HOST)
+        @default_host = default_host
+        @cookies = cookies
+        @cookies.sort!
+      end
+
+      def [](name)
+        cookies = hash_for(nil)
+        # TODO: Should be case insensitive
+        cookies[name.to_s] && cookies[name.to_s].value
+      end
+
+      def []=(name, value)
+        merge("#{name}=#{Rack::Utils.escape(value)}")
+      end
+
+      def get_cookie(name)
+        hash_for(nil).fetch(name,nil)
+      end
+
+      def delete(name)
+        @cookies.reject! do |cookie|
+          cookie.name == name
+        end
+      end
+
+      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!{|c| c.empty? }
+        end
+
+        raw_cookies.each do |raw_cookie|
+          cookie = Cookie.new(raw_cookie, uri, @default_host)
+          self << cookie if cookie.valid?(uri)
+        end
+      end
+
+      def <<(new_cookie)
+        @cookies.reject! do |existing_cookie|
+          new_cookie.replaces?(existing_cookie)
+        end
+
+        @cookies << new_cookie
+        @cookies.sort!
+      end
+
+      # :api: private
+      def for(uri)
+        hash_for(uri).values.map { |c| c.raw }.join(';')
+      end
+
+      def to_hash
+        cookies = {}
+
+        hash_for(nil).each do |name, cookie|
+          cookies[name] = cookie.value
+        end
+
+        return cookies
+      end
+
+    protected
+
+      def hash_for(uri = nil)
+        cookies = {}
+
+        # 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.
+        @cookies.each do |cookie|
+          cookies[cookie.name] = cookie if !uri || cookie.matches?(uri)
+        end
+
+        return cookies
+      end
+
+    end
+
+  end
+end

data/.gem/ruby/2.3.0/gems/rack-test-0.7.0/lib/rack/test/methods.rb

@@ -0,0 +1,83 @@
+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 = [
+        :request,
+        :get,
+        :post,
+        :put,
+        :patch,
+        :delete,
+        :options,
+        :head,
+        :follow_redirect!,
+        :header,
+        :env,
+        :set_cookie,
+        :clear_cookies,
+        :authorize,
+        :basic_authorize,
+        :digest_authorize,
+        :last_response,
+        :last_request
+      ]
+
+      def_delegators :current_session, *METHODS
+    end
+  end
+end

data/.gem/ruby/2.3.0/gems/rack-test-0.7.0/lib/rack/test/mock_digest_request.rb

@@ -0,0 +1,29 @@
+module Rack
+  module Test
+
+    class MockDigestRequest # :nodoc:
+
+      def initialize(params)
+        @params = params
+      end
+
+      def method_missing(sym)
+        if @params.has_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/.gem/ruby/2.3.0/gems/rack-test-0.7.0/lib/rack/test/uploaded_file.rb

@@ -0,0 +1,64 @@
+require "tempfile"
+require "fileutils"
+
+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
+
+      def initialize(path, content_type = "text/plain", binary = false)
+        raise "#{path} file does not exist" unless ::File.exist?(path)
+
+        @content_type = content_type
+        @original_filename = ::File.basename(path)
+
+        @tempfile = Tempfile.new([@original_filename, ::File.extname(path)])
+        @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
+        @tempfile.binmode if binary
+
+        ObjectSpace.define_finalizer(self, self.class.finalize(@tempfile))
+
+        FileUtils.copy_file(path, @tempfile.path)
+      end
+
+      def path
+        @tempfile.path
+      end
+
+      alias_method :local_path, :path
+
+      def method_missing(method_name, *args, &block) #:nodoc:
+        @tempfile.__send__(method_name, *args, &block)
+      end
+
+      def respond_to?(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
+
+    end
+
+  end
+end

data/.gem/ruby/2.3.0/gems/rack-test-0.7.0/lib/rack/test/utils.rb

@@ -0,0 +1,156 @@
+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|
+              unless unescape(prefix) =~ /\[\]$/
+                prefix = "#{prefix}[]"
+              end
+              build_nested_query(v, "#{prefix}")
+            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
+          unless params.is_a?(Hash)
+            raise ArgumentError, "value must be a Hash"
+          end
+
+          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 = Hash.new
+
+        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 { |subkey, subvalue|
+                  nested_params[subkey] = subvalue
+                }
+                flattened_params["#{k}[]"] ||= []
+                flattened_params["#{k}[]"] << nested_params
+              else
+                flattened_params["#{k}[]"] = value
+              end
+
+            end
+          when Hash
+            build_multipart(value, false).each { |subkey, subvalue|
+              flattened_params[k + subkey] = subvalue
+            }
+          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 { |name, value|
+          if name =~ /\[\]\Z/ && value.is_a?(Array) && value.all? {|v| v.is_a?(Hash)}
+            value.map { |hash|
+              new_value = {}
+              hash.each { |k, v| new_value[name+k] = v }
+              get_parts(new_value).join
+            }.join
+          else
+            if value.respond_to?(:original_filename)
+              build_file_part(name, value)
+
+            elsif value.is_a?(Array) and 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
+      module_function :get_parts
+
+      def build_primitive_part(parameter_name, value)
+        unless value.is_a? Array
+          value = [value]
+        end
+        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)
+        ::File.open(uploaded_file.path, "rb") do |physical_file|
+          physical_file.set_encoding(Encoding::BINARY) if physical_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: #{::File.stat(uploaded_file.path).size}\r
+\r
+#{physical_file.read}\r
+EOF
+        end
+      end
+      module_function :build_file_part
+
+    end
+
+  end
+end