RubyGems - video_chat_get - Versions diffs - 0.1.9 → 0.2.0 - Mend

video_chat_get 0.1.9 → 0.2.0

Files changed (853) hide show

data/vendor/bundle/ruby/2.5.0/gems/httpclient-2.8.3/lib/httpclient/connection.rb DELETED Viewed

@@ -1,88 +0,0 @@
-# HTTPClient - HTTP client library.
-# Copyright (C) 2000-2015  NAKAMURA, Hiroshi  <nahi@ruby-lang.org>.
-#
-# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
-# redistribute it and/or modify it under the same terms of Ruby's license;
-# either the dual license version in 2003, or any later version.
-class HTTPClient
-  # Represents a HTTP response to an asynchronous request.  Async methods of
-  # HTTPClient such as get_async, post_async, etc. returns an instance of
-  # Connection.
-  #
-  # == How to use
-  #
-  # 1. Invoke HTTP method asynchronously and check if it's been finished
-  #    periodically.
-  #
-  #     connection = clnt.post_async(url, body)
-  #     print 'posting.'
-  #     while true
-  #       break if connection.finished?
-  #       print '.'
-  #       sleep 1
-  #     end
-  #     puts '.'
-  #     res = connection.pop
-  #     p res.status
-  #
-  # 2. Read the response as an IO.
-  #
-  #     connection = clnt.get_async('http://dev.ctor.org/')
-  #     io = connection.pop.content
-  #     while str = io.read(40)
-  #       p str
-  #     end
-  class Connection
-    attr_accessor :async_thread
-    def initialize(header_queue = [], body_queue = []) # :nodoc:
-      @headers = header_queue
-      @body = body_queue
-      @async_thread = nil
-      @queue = Queue.new
-    end
-    # Checks if the asynchronous invocation has been finished or not.
-    def finished?
-      if !@async_thread
-        # Not in async mode.
-        true
-      elsif @async_thread.alive?
-        # Working...
-        false
-      else
-        # Async thread have been finished.
-        join
-        true
-      end
-    end
-    # Retrieves a HTTP::Message instance of HTTP response.  Do not invoke this
-    # method twice for now.  The second invocation will be blocked.
-    def pop
-      response_or_exception = @queue.pop
-      if response_or_exception.is_a? Exception
-        raise response_or_exception
-      end
-      response_or_exception
-    end
-    def push(result) # :nodoc:
-      @queue.push(result)
-    end
-    # Waits the completion of the asynchronous invocation.
-    def join
-      if @async_thread
-        @async_thread.join
-      end
-      nil
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/httpclient-2.8.3/lib/httpclient/cookie.rb DELETED Viewed

@@ -1,220 +0,0 @@
-# do not override if httpclient/webagent-cookie is loaded already
-unless defined?(HTTPClient::CookieManager)
-begin # for catching LoadError and load webagent-cookie instead
-require 'http-cookie'
-require 'httpclient/util'
-class HTTPClient
-  class CookieManager
-    include HTTPClient::Util
-    attr_reader :format, :jar
-    attr_accessor :cookies_file
-    def initialize(cookies_file = nil, format = WebAgentSaver, jar = HTTP::CookieJar.new)
-      @cookies_file = cookies_file
-      @format = format
-      @jar = jar
-      load_cookies if @cookies_file
-    end
-    def load_cookies
-      check_cookies_file
-      @jar.clear
-      @jar.load(@cookies_file, :format => @format)
-    end
-    def save_cookies(session = false)
-      check_cookies_file
-      @jar.save(@cookies_file, :format => @format, :session => session)
-    end
-    def cookies(uri = nil)
-      cookies = @jar.cookies(uri)
-      # TODO: return HTTP::Cookie in the future
-      cookies.map { |cookie|
-        WebAgent::Cookie.new(
-          :name => cookie.name,
-          :value => cookie.value,
-          :domain => cookie.domain,
-          :path => cookie.path,
-          :origin => cookie.origin,
-          :for_domain => cookie.for_domain,
-          :expires => cookie.expires,
-          :httponly => cookie.httponly,
-          :secure => cookie.secure
-        )
-      }
-    end
-    def cookie_value(uri)
-      cookies = self.cookies(uri)
-      unless cookies.empty?
-        HTTP::Cookie.cookie_value(cookies)
-      end
-    end
-    def parse(value, uri)
-      @jar.parse(value, uri)
-    end
-    def cookies=(cookies)
-      @jar.clear
-      cookies.each do |cookie|
-        add(cookie)
-      end
-    end
-    def add(cookie)
-      @jar.add(cookie)
-    end
-    def find(uri)
-      warning('CookieManager#find is deprecated and will be removed in near future. Use HTTP::Cookie.cookie_value(CookieManager#cookies) instead')
-      if cookie = cookies(uri)
-        HTTP::Cookie.cookie_value(cookie)
-      end
-    end
-  private
-    def check_cookies_file
-      unless @cookies_file
-        raise ArgumentError.new('Cookies file not specified')
-      end
-    end
-  end
-  class WebAgentSaver < HTTP::CookieJar::AbstractSaver
-    # no option
-    def default_options
-      {}
-    end
-    # same as HTTP::CookieJar::CookiestxtSaver
-    def save(io, jar)
-      jar.each { |cookie|
-        next if !@session && cookie.session?
-        io.print cookie_to_record(cookie)
-      }
-    end
-    # same as HTTP::CookieJar::CookiestxtSaver
-    def load(io, jar)
-      io.each_line { |line|
-        cookie = parse_record(line) and jar.add(cookie)
-      }
-    end
-  private
-    def cookie_to_record(cookie)
-      [
-        cookie.origin,
-        cookie.name,
-        cookie.value,
-        cookie.expires.to_i,
-        cookie.dot_domain,
-        cookie.path,
-        self.class.flag(cookie)
-      ].join("\t") + "\n"
-    end
-    def parse_record(line)
-      return nil if /\A#/ =~ line
-      col = line.chomp.split(/\t/)
-      origin = col[0]
-      name = col[1]
-      value = col[2]
-      value.chomp!
-      if col[3].empty? or col[3] == '0'
-        expires = nil
-      else
-        expires = Time.at(col[3].to_i)
-        return nil if expires < Time.now
-      end
-      domain = col[4]
-      path = col[5]
-      cookie = WebAgent::Cookie.new(name, value,
-        :origin => origin,
-        :domain => domain,
-        :path => path,
-        :expires => expires
-      )
-      self.class.set_flag(cookie, col[6].to_i)
-      cookie
-    end
-    USE = 1
-    SECURE = 2
-    DOMAIN = 4
-    PATH = 8
-    HTTP_ONLY = 64
-    def self.flag(cookie)
-      flg = 0
-      flg += USE # not used
-      flg += SECURE  if cookie.secure?
-      flg += DOMAIN  if cookie.for_domain?
-      flg += HTTP_ONLY  if cookie.httponly?
-      flg += PATH  if cookie.path # not used
-      flg
-    end
-    def self.set_flag(cookie, flag)
-      cookie.secure = true if flag & SECURE > 0
-      cookie.for_domain = true if flag & DOMAIN > 0
-      cookie.httponly = true if flag & HTTP_ONLY > 0
-    end
-  end
-end
-# for backward compatibility
-class WebAgent
-  CookieManager = ::HTTPClient::CookieManager
-  class Cookie < HTTP::Cookie
-    include HTTPClient::Util
-    def url
-      deprecated('url', 'origin')
-      self.origin
-    end
-    def url=(url)
-      deprecated('url=', 'origin=')
-      self.origin = url
-    end
-    def http_only?
-      deprecated('http_only?', 'httponly?')
-      self.httponly?
-    end
-    alias original_domain domain
-    def domain
-      warning('Cookie#domain returns dot-less domain name now. Use Cookie#dot_domain if you need "." at the beginning.')
-      self.original_domain
-    end
-    def flag
-      deprecated('flag', 'secure, for_domain, etc.')
-      HTTPClient::WebAgentSaver.flag(self)
-    end
-  private
-    def deprecated(old, new)
-      warning("WebAgent::Cookie is deprecated and will be replaced with HTTP::Cookie in the near future. Please use Cookie##{new} instead of Cookie##{old} for the replacement.")
-    end
-  end
-end
-rescue LoadError
-  require 'httpclient/webagent-cookie'
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/httpclient-2.8.3/lib/httpclient/http.rb DELETED Viewed

@@ -1,1082 +0,0 @@
-# -*- encoding: utf-8 -*-
-# HTTPClient - HTTP client library.
-# Copyright (C) 2000-2015  NAKAMURA, Hiroshi  <nahi@ruby-lang.org>.
-#
-# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
-# redistribute it and/or modify it under the same terms of Ruby's license;
-# either the dual license version in 2003, or any later version.
-require 'time'
-if defined?(Encoding::ASCII_8BIT)
-  require 'open-uri' # for encoding
-end
-require 'httpclient/util'
-# A namespace module for HTTP Message definitions used by HTTPClient.
-module HTTP
-  # Represents HTTP response status code.  Defines constants for HTTP response
-  # and some conditional methods.
-  module Status
-    OK = 200
-    CREATED = 201
-    ACCEPTED = 202
-    NON_AUTHORITATIVE_INFORMATION = 203
-    NO_CONTENT = 204
-    RESET_CONTENT = 205
-    PARTIAL_CONTENT = 206
-    MOVED_PERMANENTLY = 301
-    FOUND = 302
-    SEE_OTHER = 303
-    TEMPORARY_REDIRECT = MOVED_TEMPORARILY = 307
-    BAD_REQUEST = 400
-    UNAUTHORIZED = 401
-    PROXY_AUTHENTICATE_REQUIRED = 407
-    INTERNAL = 500
-    # Status codes for successful HTTP response.
-    SUCCESSFUL_STATUS = [
-      OK, CREATED, ACCEPTED,
-      NON_AUTHORITATIVE_INFORMATION, NO_CONTENT,
-      RESET_CONTENT, PARTIAL_CONTENT
-    ]
-    # Status codes which is a redirect.
-    REDIRECT_STATUS = [
-      MOVED_PERMANENTLY, FOUND, SEE_OTHER,
-      TEMPORARY_REDIRECT, MOVED_TEMPORARILY
-    ]
-    # Returns true if the given status represents successful HTTP response.
-    # See also SUCCESSFUL_STATUS.
-    def self.successful?(status)
-      SUCCESSFUL_STATUS.include?(status)
-    end
-    # Returns true if the given status is thought to be redirect.
-    # See also REDIRECT_STATUS.
-    def self.redirect?(status)
-      REDIRECT_STATUS.include?(status)
-    end
-  end
-  # Represents a HTTP message.  A message is for a request or a response.
-  #
-  # Request message is generated from given parameters internally so users
-  # don't need to care about it.  Response message is the instance that
-  # methods of HTTPClient returns so users need to know how to extract
-  # HTTP response data from Message.
-  #
-  # Some attributes are only for a request or a response, not both.
-  #
-  # == How to use HTTP response message
-  #
-  # 1. Gets response message body.
-  #
-  #     res = clnt.get(url)
-  #     p res.content #=> String
-  #
-  # 2. Gets response status code.
-  #
-  #     res = clnt.get(url)
-  #     p res.status #=> 200, 501, etc. (Integer)
-  #
-  # 3. Gets response header.
-  #
-  #     res = clnt.get(url)
-  #     res.header['set-cookie'].each do |value|
-  #       p value
-  #     end
-  #     assert_equal(1, res.header['last-modified'].size)
-  #     p res.header['last-modified'].first
-  #
-  class Message
-    include HTTPClient::Util
-    CRLF = "\r\n"
-    # Represents HTTP message header.
-    class Headers
-      # HTTP version in a HTTP header.  String.
-      attr_accessor :http_version
-      # Size of body.  nil when size is unknown (e.g. chunked response).
-      attr_reader :body_size
-      # Request/Response is chunked or not.
-      attr_accessor :chunked
-      # Request only.  Requested method.
-      attr_reader :request_method
-      # Request only.  Requested URI.
-      attr_accessor :request_uri
-      # Request only.  Requested query.
-      attr_accessor :request_query
-      # Request only.  Requested via proxy or not.
-      attr_accessor :request_absolute_uri
-      # Response only.  HTTP status
-      attr_reader :status_code
-      # Response only.  HTTP status reason phrase.
-      attr_accessor :reason_phrase
-      # Used for dumping response.
-      attr_accessor :body_type # :nodoc:
-      # Used for dumping response.
-      attr_accessor :body_charset # :nodoc:
-      # Used for dumping response.
-      attr_accessor :body_date # :nodoc:
-      # Used for keeping content encoding.
-      attr_reader :body_encoding # :nodoc:
-      # HTTP response status code to reason phrase mapping definition.
-      STATUS_CODE_MAP = {
-        Status::OK => 'OK',
-        Status::CREATED => "Created",
-        Status::NON_AUTHORITATIVE_INFORMATION => "Non-Authoritative Information",
-        Status::NO_CONTENT => "No Content",
-        Status::RESET_CONTENT => "Reset Content",
-        Status::PARTIAL_CONTENT => "Partial Content",
-        Status::MOVED_PERMANENTLY => 'Moved Permanently',
-        Status::FOUND => 'Found',
-        Status::SEE_OTHER => 'See Other',
-        Status::TEMPORARY_REDIRECT => 'Temporary Redirect',
-        Status::MOVED_TEMPORARILY => 'Temporary Redirect',
-        Status::BAD_REQUEST => 'Bad Request',
-        Status::INTERNAL => 'Internal Server Error',
-      }
-      # $KCODE to charset mapping definition.
-      CHARSET_MAP = {
-        'NONE' => 'us-ascii',
-        'EUC'  => 'euc-jp',
-        'SJIS' => 'shift_jis',
-        'UTF8' => 'utf-8',
-      }
-      # Creates a Message::Headers.  Use init_request, init_response, or
-      # init_connect_request for acutual initialize.
-      def initialize
-        @http_version = '1.1'
-        @body_size = nil
-        @chunked = false
-        @request_method = nil
-        @request_uri = nil
-        @request_query = nil
-        @request_absolute_uri = nil
-        @status_code = nil
-        @reason_phrase = nil
-        @body_type = nil
-        @body_charset = nil
-        @body_date = nil
-        @body_encoding = nil
-        @is_request = nil
-        @header_item = []
-        @dumped = false
-      end
-      # Initialize this instance as a CONNECT request.
-      def init_connect_request(uri)
-        @is_request = true
-        @request_method = 'CONNECT'
-        @request_uri = uri
-        @request_query = nil
-        @http_version = '1.0'
-      end
-      # Placeholder URI object for nil uri.
-      NIL_URI = HTTPClient::Util.urify('http://nil-uri-given/')
-      # Initialize this instance as a general request.
-      def init_request(method, uri, query = nil)
-        @is_request = true
-        @request_method = method
-        @request_uri = uri || NIL_URI
-        @request_query = query
-        @request_absolute_uri = false
-        self
-      end
-      # Initialize this instance as a response.
-      def init_response(status_code, req = nil)
-        @is_request = false
-        self.status_code = status_code
-        if req
-          @request_method = req.request_method
-          @request_uri = req.request_uri
-          @request_query = req.request_query
-        end
-        self
-      end
-      # Sets status code and reason phrase.
-      def status_code=(status_code)
-        @status_code = status_code
-        @reason_phrase = STATUS_CODE_MAP[@status_code]
-      end
-      # Returns 'Content-Type' header value.
-      def content_type
-        self['Content-Type'][0]
-      end
-      # Sets 'Content-Type' header value.  Overrides if already exists.
-      def content_type=(content_type)
-        delete('Content-Type')
-        self['Content-Type'] = content_type
-      end
-      alias contenttype content_type
-      alias contenttype= content_type=
-      if defined?(Encoding::ASCII_8BIT)
-        def set_body_encoding
-          if type = self.content_type
-            OpenURI::Meta.init(o = '')
-            o.meta_add_field('content-type', type)
-            @body_encoding = o.encoding
-          end
-        end
-      else
-        def set_body_encoding
-          @body_encoding = nil
-        end
-      end
-      # Sets byte size of message body.
-      # body_size == nil means that the body is_a? IO
-      def body_size=(body_size)
-        @body_size = body_size
-      end
-      # Dumps message header part and returns a dumped String.
-      def dump
-        set_header
-        str = nil
-        if @is_request
-          str = request_line
-        else
-          str = response_status_line
-        end
-        str + @header_item.collect { |key, value|
-          "#{ key }: #{ value }#{ CRLF }"
-        }.join
-      end
-      # Set Date header
-      def set_date_header
-        set('Date', Time.now.httpdate)
-      end
-      # Adds a header.  Addition order is preserved.
-      def add(key, value)
-        if value.is_a?(Array)
-          value.each do |v|
-            @header_item.push([key, v])
-          end
-        else
-          @header_item.push([key, value])
-        end
-      end
-      # Sets a header.
-      def set(key, value)
-        delete(key)
-        add(key, value)
-      end
-      # Returns an Array of headers for the given key.  Each element is a pair
-      # of key and value.  It returns an single element Array even if the only
-      # one header exists.  If nil key given, it returns all headers.
-      def get(key = nil)
-        if key.nil?
-          all
-        else
-          key = key.upcase
-          @header_item.find_all { |k, v| k.upcase == key }
-        end
-      end
-      # Returns an Array of all headers.
-      def all
-        @header_item
-      end
-      # Deletes headers of the given key.
-      def delete(key)
-        key = key.upcase
-        @header_item.delete_if { |k, v| k.upcase == key }
-      end
-      # Adds a header.  See set.
-      def []=(key, value)
-        set(key, value)
-      end
-      # Returns an Array of header values for the given key.
-      def [](key)
-        get(key).collect { |item| item[1] }
-      end
-      def set_headers(headers)
-        headers.each do |key, value|
-          add(key, value)
-        end
-        set_body_encoding
-      end
-      def create_query_uri()
-        if @request_method == 'CONNECT'
-          return "#{@request_uri.host}:#{@request_uri.port}"
-        end
-        path = @request_uri.path
-        path = '/' if path.nil? or path.empty?
-        if query_str = create_query_part()
-          path += "?#{query_str}"
-        end
-        path
-      end
-      def create_query_part()
-        query_str = nil
-        if @request_uri.query
-          query_str = @request_uri.query
-        end
-        if @request_query
-          if query_str
-            query_str += "&#{Message.create_query_part_str(@request_query)}"
-          else
-            query_str = Message.create_query_part_str(@request_query)
-          end
-        end
-        query_str
-      end
-    private
-      def request_line
-        path = create_query_uri()
-        if @request_absolute_uri
-          path = "#{ @request_uri.scheme }://#{ @request_uri.host }:#{ @request_uri.port }#{ path }"
-        end
-        "#{ @request_method } #{ path } HTTP/#{ @http_version }#{ CRLF }"
-      end
-      def response_status_line
-        if defined?(Apache)
-          "HTTP/#{ @http_version } #{ @status_code } #{ @reason_phrase }#{ CRLF }"
-        else
-          "Status: #{ @status_code } #{ @reason_phrase }#{ CRLF }"
-        end
-      end
-      def set_header
-        if @is_request
-          set_request_header
-        else
-          set_response_header
-        end
-      end
-      def set_request_header
-        return if @dumped
-        @dumped = true
-        keep_alive = Message.keep_alive_enabled?(@http_version)
-        if !keep_alive and @request_method != 'CONNECT'
-          set('Connection', 'close')
-        end
-        if @chunked
-          set('Transfer-Encoding', 'chunked')
-        elsif @body_size and (keep_alive or @body_size != 0)
-          set('Content-Length', @body_size.to_s)
-        end
-        if @http_version >= '1.1' and get('Host').empty?
-          if @request_uri.port == @request_uri.default_port
-            # GFE/1.3 dislikes default port number (returns 404)
-            set('Host', "#{@request_uri.hostname}")
-          else
-            set('Host', "#{@request_uri.hostname}:#{@request_uri.port}")
-          end
-        end
-      end
-      def set_response_header
-        return if @dumped
-        @dumped = true
-        if defined?(Apache) && self['Date'].empty?
-          set_date_header
-        end
-        keep_alive = Message.keep_alive_enabled?(@http_version)
-        if @chunked
-          set('Transfer-Encoding', 'chunked')
-        else
-          if keep_alive or @body_size != 0
-            set('Content-Length', @body_size.to_s)
-          end
-        end
-        if @body_date
-          set('Last-Modified', @body_date.httpdate)
-        end
-        if self['Content-Type'].empty?
-          set('Content-Type', "#{ @body_type || 'text/html' }; charset=#{ charset_label }")
-        end
-      end
-      def charset_label
-        # TODO: should handle response encoding for 1.9 correctly.
-        if RUBY_VERSION > "1.9"
-          CHARSET_MAP[@body_charset] || 'us-ascii'
-        else
-          CHARSET_MAP[@body_charset || $KCODE] || 'us-ascii'
-        end
-      end
-    end
-    # Represents HTTP message body.
-    class Body
-      # Size of body.  nil when size is unknown (e.g. chunked response).
-      attr_reader :size
-      # maxbytes of IO#read for streaming request.  See DEFAULT_CHUNK_SIZE.
-      attr_accessor :chunk_size
-      # Hash that keeps IO positions
-      attr_accessor :positions
-      # Default value for chunk_size
-      DEFAULT_CHUNK_SIZE = 1024 * 16
-      # Creates a Message::Body.  Use init_request or init_response
-      # for acutual initialize.
-      def initialize
-        @body = nil
-        @size = nil
-        @positions = nil
-        @chunk_size = nil
-      end
-      # Initialize this instance as a request.
-      def init_request(body = nil, boundary = nil)
-        @boundary = boundary
-        @positions = {}
-        set_content(body, boundary)
-        @chunk_size = DEFAULT_CHUNK_SIZE
-        self
-      end
-      # Initialize this instance as a response.
-      def init_response(body = nil)
-        @body = body
-        if @body.respond_to?(:bytesize)
-          @size = @body.bytesize
-        elsif @body.respond_to?(:size)
-          @size = @body.size
-        else
-          @size = nil
-        end
-        self
-      end
-      # Dumps message body to given dev.
-      # dev needs to respond to <<.
-      #
-      # Message header must be given as the first argument for performance
-      # reason. (header is dumped to dev, too)
-      # If no dev (the second argument) given, this method returns a dumped
-      # String.
-      #
-      # assert: @size is not nil
-      def dump(header = '', dev = '')
-        if @body.is_a?(Parts)
-          dev << header
-          @body.parts.each do |part|
-            if Message.file?(part)
-              reset_pos(part)
-              dump_file(part, dev, @body.sizes[part])
-            else
-              dev << part
-            end
-          end
-        elsif Message.file?(@body)
-          dev << header
-          reset_pos(@body)
-          dump_file(@body, dev, @size)
-        elsif @body
-          dev << header + @body
-        else
-          dev << header
-        end
-        dev
-      end
-      # Dumps message body with chunked encoding to given dev.
-      # dev needs to respond to <<.
-      #
-      # Message header must be given as the first argument for performance
-      # reason. (header is dumped to dev, too)
-      # If no dev (the second argument) given, this method returns a dumped
-      # String.
-      def dump_chunked(header = '', dev = '')
-        dev << header
-        if @body.is_a?(Parts)
-          @body.parts.each do |part|
-            if Message.file?(part)
-              reset_pos(part)
-              dump_chunks(part, dev)
-            else
-              dev << dump_chunk(part)
-            end
-          end
-          dev << (dump_last_chunk + CRLF)
-        elsif @body
-          reset_pos(@body)
-          dump_chunks(@body, dev)
-          dev << (dump_last_chunk + CRLF)
-        end
-        dev
-      end
-      # Returns a message body itself.
-      def content
-        @body
-      end
-    private
-      def set_content(body, boundary = nil)
-        if Message.file?(body)
-          # uses Transfer-Encoding: chunked if body does not respond to :size.
-          # bear in mind that server may not support it. at least ruby's CGI doesn't.
-          @body = body
-          remember_pos(@body)
-          @size = body.respond_to?(:size) ? body.size - body.pos : nil
-        elsif boundary and Message.multiparam_query?(body)
-          @body = build_query_multipart_str(body, boundary)
-          @size = @body.size
-        else
-          @body = Message.create_query_part_str(body)
-          @size = @body.bytesize
-        end
-      end
-      def remember_pos(io)
-        # IO may not support it (ex. IO.pipe)
-        @positions[io] = io.pos if io.respond_to?(:pos)
-      end
-      def reset_pos(io)
-        io.pos = @positions[io] if @positions.key?(io)
-      end
-      def dump_file(io, dev, sz)
-        buf = ''
-        rest = sz
-        while rest > 0
-          n = io.read([rest, @chunk_size].min, buf)
-          raise ArgumentError.new("Illegal size value: #size returns #{sz} but cannot read") if n.nil?
-          dev << buf
-          rest -= n.bytesize
-        end
-      end
-      def dump_chunks(io, dev)
-        buf = ''
-        while !io.read(@chunk_size, buf).nil?
-          dev << dump_chunk(buf)
-        end
-      end
-      def dump_chunk(str)
-        dump_chunk_size(str.bytesize) + (str + CRLF)
-      end
-      def dump_last_chunk
-        dump_chunk_size(0)
-      end
-      def dump_chunk_size(size)
-        sprintf("%x", size) + CRLF
-      end
-      class Parts
-        attr_reader :size
-        attr_reader :sizes
-        def initialize
-          @body = []
-          @sizes = {}
-          @size = 0 # total
-          @as_stream = false
-        end
-        def add(part)
-          if Message.file?(part)
-            @as_stream = true
-            @body << part
-            if part.respond_to?(:lstat)
-              sz = part.lstat.size
-              add_size(part, sz)
-            elsif part.respond_to?(:size)
-              if sz = part.size
-                add_size(part, sz)
-              else
-                @sizes.clear
-                @size = nil
-              end
-            else
-              # use chunked upload
-              @sizes.clear
-              @size = nil
-            end
-          elsif @body[-1].is_a?(String)
-            @body[-1] += part.to_s
-            @size += part.to_s.bytesize if @size
-          else
-            @body << part.to_s
-            @size += part.to_s.bytesize if @size
-          end
-        end
-        def parts
-          if @as_stream
-            @body
-          else
-            [@body.join]
-          end
-        end
-      private
-        def add_size(part, sz)
-          if @size
-            @sizes[part] = sz
-            @size += sz
-          end
-        end
-      end
-      def build_query_multipart_str(query, boundary)
-        parts = Parts.new
-        query.each do |attr, value|
-          headers = ["--#{boundary}"]
-          if Message.file?(value)
-            remember_pos(value)
-            param_str = params_from_file(value).collect { |k, v|
-              "#{k}=\"#{v}\""
-            }.join("; ")
-            if value.respond_to?(:mime_type)
-              content_type = value.mime_type
-            elsif value.respond_to?(:content_type)
-              content_type = value.content_type
-            else
-              path = value.respond_to?(:path) ? value.path : nil
-              content_type = Message.mime_type(path)
-            end
-            headers << %{Content-Disposition: form-data; name="#{attr}"; #{param_str}}
-            headers << %{Content-Type: #{content_type}}
-          elsif attr.is_a?(Hash)
-            h = attr
-            value = h[:content]
-            h.each do |h_key, h_val|
-              headers << %{#{h_key}: #{h_val}} if h_key != :content
-            end
-            remember_pos(value) if Message.file?(value)
-          else
-            headers << %{Content-Disposition: form-data; name="#{attr}"}
-            value = value.to_s
-          end
-          parts.add(headers.join(CRLF) + CRLF + CRLF)
-          parts.add(value)
-          parts.add(CRLF)
-        end
-        parts.add("--#{boundary}--" + CRLF + CRLF) # empty epilogue
-        parts
-      end
-      def params_from_file(value)
-        params = {}
-        original_filename = value.respond_to?(:original_filename) ? value.original_filename : nil
-        path = value.respond_to?(:path) ? value.path : nil
-        params['filename'] = original_filename || File.basename(path || '')
-        # Creation time is not available from File::Stat
-        if value.respond_to?(:mtime)
-          params['modification-date'] = value.mtime.rfc822
-        end
-        if value.respond_to?(:atime)
-          params['read-date'] = value.atime.rfc822
-        end
-        params
-      end
-    end
-    class << self
-      private :new
-      # Creates a Message instance of 'CONNECT' request.
-      # 'CONNECT' request does not have Body.
-      # uri:: an URI that need to connect.  Only uri.host and uri.port are used.
-      def new_connect_request(uri)
-        m = new
-        m.http_header.init_connect_request(uri)
-        m.http_header.body_size = nil
-        m
-      end
-      # Creates a Message instance of general request.
-      # method:: HTTP method String.
-      # uri:: an URI object which represents an URL of web resource.
-      # query:: a Hash or an Array of query part of URL.
-      #         e.g. { "a" => "b" } => 'http://host/part?a=b'
-      #         Give an array to pass multiple value like
-      #         [["a", "b"], ["a", "c"]] => 'http://host/part?a=b&a=c'
-      # body:: a Hash or an Array of body part.
-      #        e.g. { "a" => "b" } => 'a=b'.
-      #        Give an array to pass multiple value like
-      #        [["a", "b"], ["a", "c"]] => 'a=b&a=c'.
-      # boundary:: When the boundary given, it is sent as
-      #            a multipart/form-data using this boundary String.
-      def new_request(method, uri, query = nil, body = nil, boundary = nil)
-        m = new
-        m.http_header.init_request(method, uri, query)
-        m.http_body = Body.new
-        m.http_body.init_request(body || '', boundary)
-        if body
-          m.http_header.body_size = m.http_body.size
-          m.http_header.chunked = true if m.http_body.size.nil?
-        else
-          m.http_header.body_size = nil
-        end
-        m
-      end
-      # Creates a Message instance of response.
-      # body:: a String or an IO of response message body.
-      def new_response(body, req = nil)
-        m = new
-        m.http_header.init_response(Status::OK, req)
-        m.http_body = Body.new
-        m.http_body.init_response(body)
-        m.http_header.body_size = m.http_body.size || 0
-        m
-      end
-      @@mime_type_handler = nil
-      # Sets MIME type handler.
-      #
-      # handler must respond to :call with a single argument :path and returns
-      # a MIME type String e.g. 'text/html'.
-      # When the handler returns nil or an empty String,
-      # 'application/octet-stream' is used.
-      #
-      # When you set nil to the handler, internal_mime_type is used instead.
-      # The handler is nil by default.
-      def mime_type_handler=(handler)
-        @@mime_type_handler = handler
-      end
-      # Returns MIME type handler.
-      def mime_type_handler
-        @@mime_type_handler
-      end
-      # For backward compatibility.
-      alias set_mime_type_func mime_type_handler=
-      alias get_mime_type_func mime_type_handler
-      def mime_type(path) # :nodoc:
-        if @@mime_type_handler
-          res = @@mime_type_handler.call(path)
-          if !res || res.to_s == ''
-            return 'application/octet-stream'
-          else
-            return res
-          end
-        else
-          internal_mime_type(path)
-        end
-      end
-      # Default MIME type handler.
-      # See mime_type_handler=.
-      def internal_mime_type(path)
-        case path
-        when /\.txt$/i
-          'text/plain'
-        when /\.xml$/i
-          'text/xml'
-        when /\.(htm|html)$/i
-          'text/html'
-        when /\.doc$/i
-          'application/msword'
-        when /\.png$/i
-          'image/png'
-        when /\.gif$/i
-          'image/gif'
-        when /\.(jpg|jpeg)$/i
-          'image/jpeg'
-        else
-          'application/octet-stream'
-        end
-      end
-      # Returns true if the given HTTP version allows keep alive connection.
-      # version:: String
-      def keep_alive_enabled?(version)
-        version >= '1.1'
-      end
-      # Returns true if the given query (or body) has a multiple parameter.
-      def multiparam_query?(query)
-        query.is_a?(Array) or query.is_a?(Hash)
-      end
-      # Returns true if the given object is a File.  In HTTPClient, a file is;
-      # * must respond to :read for retrieving String chunks.
-      # * must respond to :pos and :pos= to rewind for reading.
-      #   Rewinding is only needed for following HTTP redirect.  Some IO impl
-      #   defines :pos= but raises an Exception for pos= such as StringIO
-      #   but there's no problem as far as using it for non-following methods
-      #   (get/post/etc.)
-      def file?(obj)
-        obj.respond_to?(:read) and obj.respond_to?(:pos) and
-          obj.respond_to?(:pos=)
-      end
-      def create_query_part_str(query) # :nodoc:
-        if multiparam_query?(query)
-          escape_query(query)
-        elsif query.respond_to?(:read)
-          query = query.read
-        else
-          query.to_s
-        end
-      end
-      def Array.try_convert(value)
-        return value if value.instance_of?(Array)
-        return nil if !value.respond_to?(:to_ary)
-        converted = value.to_ary
-        return converted if converted.instance_of?(Array)
-        cname = value.class.name
-        raise TypeError, "can't convert %s to %s (%s#%s gives %s)" %
-          [cname, Array.name, cname, :to_ary, converted.class.name]
-      end unless Array.respond_to?(:try_convert)
-      def escape_query(query) # :nodoc:
-        pairs = []
-        query.each { |attr, value|
-          left = escape(attr.to_s) << '='
-          if values = Array.try_convert(value)
-            values.each { |v|
-              if v.respond_to?(:read)
-                v = v.read
-              end
-              pairs.push(left + escape(v.to_s))
-            }
-          else
-            if value.respond_to?(:read)
-              value = value.read
-            end
-            pairs.push(left << escape(value.to_s))
-          end
-        }
-        pairs.join('&')
-      end
-      # from CGI.escape
-      if defined?(Encoding::ASCII_8BIT)
-        def escape(str) # :nodoc:
-          str.dup.force_encoding(Encoding::ASCII_8BIT).gsub(/([^ a-zA-Z0-9_.-]+)/) {
-            '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
-          }.tr(' ', '+')
-        end
-      else
-        def escape(str) # :nodoc:
-          str.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
-            '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
-          }.tr(' ', '+')
-        end
-      end
-      # from CGI.parse
-      def parse(query)
-        params = Hash.new([].freeze)
-        query.split(/[&;]/n).each do |pairs|
-          key, value = pairs.split('=',2).collect{|v| unescape(v) }
-          if params.has_key?(key)
-            params[key].push(value)
-          else
-            params[key] = [value]
-          end
-        end
-        params
-      end
-      # from CGI.unescape
-      def unescape(string)
-        string.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
-          [$1.delete('%')].pack('H*')
-        end
-      end
-    end
-    # HTTP::Message::Headers:: message header.
-    attr_accessor :http_header
-    # HTTP::Message::Body:: message body.
-    attr_reader :http_body
-    # OpenSSL::X509::Certificate:: response only.  server certificate which is
-    #                              used for retrieving the response.
-    attr_accessor :peer_cert
-    # The other Message object when this Message is generated instead of
-    # the Message because of redirection, negotiation, or format conversion.
-    attr_accessor :previous
-    # Creates a Message.  This method should be used internally.
-    # Use Message.new_connect_request, Message.new_request or
-    # Message.new_response instead.
-    def initialize # :nodoc:
-      @http_header = Headers.new
-      @http_body = @peer_cert = nil
-      @previous = nil
-    end
-    # Dumps message (header and body) to given dev.
-    # dev needs to respond to <<.
-    def dump(dev = '')
-      str = @http_header.dump + CRLF
-      if @http_header.chunked
-        dev = @http_body.dump_chunked(str, dev)
-      elsif @http_body
-        dev = @http_body.dump(str, dev)
-      else
-        dev << str
-      end
-      dev
-    end
-    # Sets a new body.  header.body_size is updated with new body.size.
-    def http_body=(body)
-      @http_body = body
-      @http_header.body_size = @http_body.size if @http_header
-    end
-    alias body= http_body=
-    # Returns HTTP version in a HTTP header.  String.
-    def http_version
-      @http_header.http_version
-    end
-    # Sets HTTP version in a HTTP header.  String.
-    def http_version=(http_version)
-      @http_header.http_version = http_version
-    end
-    VERSION_WARNING = 'Message#version (Float) is deprecated. Use Message#http_version (String) instead.'
-    def version
-      warning(VERSION_WARNING)
-      @http_header.http_version.to_f
-    end
-    def version=(version)
-      warning(VERSION_WARNING)
-      @http_header.http_version = version
-    end
-    # Returns HTTP status code in response.  Integer.
-    def status
-      @http_header.status_code
-    end
-    alias code status
-    alias status_code status
-    # Sets HTTP status code of response.  Integer.
-    # Reason phrase is updated, too.
-    def status=(status)
-      @http_header.status_code = status
-    end
-    # Returns  HTTP status reason phrase in response.  String.
-    def reason
-      @http_header.reason_phrase
-    end
-    # Sets  HTTP status reason phrase of response.  String.
-    def reason=(reason)
-      @http_header.reason_phrase = reason
-    end
-    # Returns 'Content-Type' header value.
-    def content_type
-      @http_header.content_type
-    end
-    # Sets 'Content-Type' header value.  Overrides if already exists.
-    def content_type=(content_type)
-      @http_header.content_type = content_type
-    end
-    alias contenttype content_type
-    alias contenttype= content_type=
-    # Returns content encoding
-    def body_encoding
-      @http_header.body_encoding
-    end
-    # Returns a content of message body.  A String or an IO.
-    def content
-      @http_body.content
-    end
-    alias header http_header
-    alias body content
-    # Returns Hash of header. key and value are both String. Each key has a
-    # single value so you can't extract exact value when a message has multiple
-    # headers like 'Set-Cookie'. Use header['Set-Cookie'] for that purpose.
-    # (It returns an Array always)
-    def headers
-      Hash[*http_header.all.flatten]
-    end
-    # Extracts cookies from 'Set-Cookie' header.
-    # Supports 'Set-Cookie' in response header only.
-    # Do we need 'Cookie' support in request header?
-    def cookies
-      set_cookies = http_header['set-cookie']
-      unless set_cookies.empty?
-        uri = http_header.request_uri
-        set_cookies.map { |str|
-          WebAgent::Cookie.parse(str, uri)
-        }.flatten
-      end
-    end
-    # Convenience method to return boolean of whether we had a successful request
-    def ok?
-      HTTP::Status.successful?(status)
-    end
-    def redirect?
-      HTTP::Status.redirect?(status)
-    end
-    # SEE_OTHER is a redirect, but it should sent as GET
-    def see_other?
-      status == HTTP::Status::SEE_OTHER
-    end
-  end
-end