rhodes 3.2.0.beta.4 → 3.2.0.beta.5

data/lib/extensions/net-http/timeout.rb

@@ -1,114 +0,0 @@
-# = timeout.rb
-#
-# execution timeout
-#
-# = Synopsis
-#
-#   require 'timeout'
-#   status = Timeout::timeout(5) {
-#     # Something that should be interrupted if it takes too much time...
-#   }
-#
-# = Description
-#
-# A way of performing a potentially long-running operation in a thread, and terminating
-# it's execution if it hasn't finished by a fixed amount of time.
-#
-# Previous versions of timeout didn't provide use a module for namespace. This version
-# provides both Timeout.timeout, and a backwards-compatible #timeout.
-#
-# = Copyright
-#
-# Copyright:: (C) 2000  Network Applied Communication Laboratory, Inc.
-# Copyright:: (C) 2000  Information-technology Promotion Agency, Japan
-
-module Timeout
-  # Raised by Timeout#timeout when the block times out.
-  class Error < RuntimeError
-  end
-  class ExitException < ::Exception # :nodoc:
-  end
-
-  THIS_FILE = /\A#{Regexp.quote(__FILE__)}:/o
-  CALLER_OFFSET = ((c = caller[0]) && THIS_FILE =~ c) ? 1 : 0
-
-  # Executes the method's block.  If the block execution terminates before
-  # +sec+ seconds has passed, it returns the result value of the block.
-  # If not, it terminates the execution and raises +exception+ (which defaults
-  # to Timeout::Error).
-  #
-  # Note that this is both a method of module Timeout, so you can 'include Timeout'
-  # into your classes so they have a #timeout method, as well as a module method,
-  # so you can call it directly as Timeout.timeout().
-  def timeout(sec, klass = nil)   #:yield: +sec+
-    return yield(sec) if sec == nil or sec.zero?
-    exception = klass || Class.new(ExitException)
-    @is_stoptimeout = false
-    begin
-      x = Thread.current
-      y = Thread.start {
-        sleep sec
-        
-        if !@is_stoptimeout
-            x.raise exception, "execution expired" if x.alive?
-        end    
-      }
-      return yield(sec)
-    rescue exception => e
-      rej = /\A#{Regexp.quote(__FILE__)}:#{__LINE__-4}\z/o
-      (bt = e.backtrace).reject! {|m| rej =~ m}
-      level = -caller(CALLER_OFFSET).size
-      while THIS_FILE =~ bt[level]
-        bt.delete_at(level)
-        level += 1
-      end
-      raise if klass            # if exception class is specified, it
-                                # would be expected outside.
-      raise Error, e.message, e.backtrace
-    ensure
-      if y and y.alive?
-        @is_stoptimeout = true
-      
-        y.kill 
-        y.join # make sure y is dead.
-      end
-    end
-  end
-
-  module_function :timeout
-end
-
-# Identical to:
-#
-#   Timeout::timeout(n, e, &block).
-#
-# Defined for backwards compatibility with earlier versions of timeout.rb, see
-# Timeout#timeout.
-def timeout(n, e = nil, &block)
-  Timeout::timeout(n, e, &block)
-end
-
-# Another name for Timeout::Error, defined for backwards compatibility with
-# earlier versions of timeout.rb.
-TimeoutError = Timeout::Error
-
-if __FILE__ == $0
-  p timeout(5) {
-    45
-  }
-  p timeout(5, TimeoutError) {
-    45
-  }
-  p timeout(nil) {
-    54
-  }
-  p timeout(0) {
-    54
-  }
-  p timeout(5) {
-    loop {
-      p 10
-      sleep 1
-    }
-  }
-end

data/lib/extensions/net-http/uri.rb

@@ -1,29 +0,0 @@
-#
-# URI support for Ruby
-#
-# Author:: Akira Yamada <akira@ruby-lang.org>
-# Documentation:: Akira Yamada <akira@ruby-lang.org>, Dmitry V. Sabanin <sdmitry@lrn.ru>
-# License:: 
-#  Copyright (c) 2001 akira yamada <akira@ruby-lang.org>
-#  You can redistribute it and/or modify it under the same term as Ruby.
-# Revision:: $Id: uri.rb 13772 2007-10-25 00:53:34Z akira $
-# 
-# See URI for documentation
-#
-
-module URI
-  # :stopdoc:
-  VERSION_CODE = '000911'.freeze
-  VERSION = VERSION_CODE.scan(/../).collect{|n| n.to_i}.join('.').freeze
-  # :startdoc:
-
-end
-
-require 'uri/common'
-require 'uri/generic'
-require 'uri/ftp'
-require 'uri/http'
-require 'uri/https'
-require 'uri/ldap'
-require 'uri/ldaps'
-require 'uri/mailto'

data/lib/extensions/net-http/uri/common.rb

@@ -1,727 +0,0 @@
-# = uri/common.rb
-#
-# Author:: Akira Yamada <akira@ruby-lang.org>
-# Revision:: $Id: common.rb 22760 2009-03-04 09:21:12Z yugui $
-# License:: 
-#   You can redistribute it and/or modify it under the same term as Ruby.
-#
-
-module URI
-  module REGEXP
-    #
-    # Patterns used to parse URI's
-    #
-    module PATTERN
-      # :stopdoc:
-
-      # RFC 2396 (URI Generic Syntax)
-      # RFC 2732 (IPv6 Literal Addresses in URL's)
-      # RFC 2373 (IPv6 Addressing Architecture)
-
-      # alpha         = lowalpha | upalpha
-      ALPHA = "a-zA-Z"
-      # alphanum      = alpha | digit
-      ALNUM = "#{ALPHA}\\d"
-
-      # hex           = digit | "A" | "B" | "C" | "D" | "E" | "F" |
-      #                         "a" | "b" | "c" | "d" | "e" | "f"
-      HEX     = "a-fA-F\\d"
-      # escaped       = "%" hex hex
-      ESCAPED = "%[#{HEX}]{2}"
-      # mark          = "-" | "_" | "." | "!" | "~" | "*" | "'" |
-      #                 "(" | ")"
-      # unreserved    = alphanum | mark
-      UNRESERVED = "-_.!~*'()#{ALNUM}"
-      # reserved      = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
-      #                 "$" | ","
-      # reserved      = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | 
-      #                 "$" | "," | "[" | "]" (RFC 2732)
-      RESERVED = ";/?:@&=+$,\\[\\]"
-
-      # domainlabel   = alphanum | alphanum *( alphanum | "-" ) alphanum
-      DOMLABEL = "(?:[#{ALNUM}](?:[-#{ALNUM}]*[#{ALNUM}])?)"
-      # toplabel      = alpha | alpha *( alphanum | "-" ) alphanum
-      TOPLABEL = "(?:[#{ALPHA}](?:[-#{ALNUM}]*[#{ALNUM}])?)"
-      # hostname      = *( domainlabel "." ) toplabel [ "." ]
-      HOSTNAME = "(?:#{DOMLABEL}\\.)*#{TOPLABEL}\\.?"
-
-      # :startdoc:
-    end # PATTERN
-
-    # :startdoc:
-  end # REGEXP
-
-  class Parser
-    include REGEXP
-
-    #
-    # == Synopsis
-    #
-    #   URI::Parser.new([opts])
-    #
-    # == Args
-    #
-    # The constructor accepts a hash as options for parser.
-    # Keys of options are pattern names of URI components
-    # and values of options are pattern strings.
-    # The constructor generetes set of regexps for parsing URIs.
-    #
-    # You can use the following keys:
-    #
-    #   * <tt>:ESCAPED</tt> (URI::PATTERN::ESCAPED in default)
-    #   * <tt>:UNRESERVED</tt> (URI::PATTERN::UNRESERVED in default)
-    #   * <tt>:DOMLABEL</tt> (URI::PATTERN::DOMLABEL in default)
-    #   * <tt>:TOPLABEL</tt> (URI::PATTERN::TOPLABEL in default)
-    #   * <tt>:HOSTNAME</tt> (URI::PATTERN::HOSTNAME in default)
-    #
-    # == Examples
-    #
-    #   p = URI::Parser.new(:ESCPAED => "(?:%[a-fA-F0-9]{2}|%u[a-fA-F0-9]{4})"
-    #   u = p.parse("http://example.jp/%uABCD") #=> #<URI::HTTP:0xb78cf4f8 URL:http://example.jp/%uABCD>
-    #   URI.parse(u.to_s) #=> raises URI::InvalidURIError
-    #
-    #   s = "http://examle.com/ABCD"
-    #   u1 = p.parse(s) #=> #<URI::HTTP:0xb78c3220 URL:http://example.com/ABCD>
-    #   u2 = URI.parse(s) #=> #<URI::HTTP:0xb78b6d54 URL:http://example.com/ABCD>
-    #   u1 == u2 #=> true
-    #   u1.eql?(u2) #=> false
-    #
-    def initialize(opts = {})
-      @pattern = initialize_pattern(opts)
-      @pattern.each_value {|v| v.freeze}
-      @pattern.freeze
-
-      @regexp = initialize_regexp(@pattern)
-      @regexp.each_value {|v| v.freeze}
-      @regexp.freeze
-    end
-    attr_reader :pattern, :regexp
-
-    def split(uri)
-      case uri
-      when ''
-	# null uri
-
-      when @regexp[:ABS_URI]
-	scheme, opaque, userinfo, host, port, 
-	  registry, path, query, fragment = $~[1..-1]
-
-	# URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]
-
-	# absoluteURI   = scheme ":" ( hier_part | opaque_part )
-	# hier_part     = ( net_path | abs_path ) [ "?" query ]
-	# opaque_part   = uric_no_slash *uric
-
-	# abs_path      = "/"  path_segments
-	# net_path      = "//" authority [ abs_path ]
-
-	# authority     = server | reg_name
-	# server        = [ [ userinfo "@" ] hostport ]
-
-	if !scheme
-	  raise InvalidURIError, 
-	    "bad URI(absolute but no scheme): #{uri}"
-	end
-	if !opaque && (!path && (!host && !registry))
-	  raise InvalidURIError,
-	    "bad URI(absolute but no path): #{uri}" 
-	end
-
-      when @regexp[:REL_URI]
-	scheme = nil
-	opaque = nil
-
-	userinfo, host, port, registry, 
-	  rel_segment, abs_path, query, fragment = $~[1..-1]
-	if rel_segment && abs_path
-	  path = rel_segment + abs_path
-	elsif rel_segment
-	  path = rel_segment
-	elsif abs_path
-	  path = abs_path
-	end
-
-	# URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]
-
-	# relativeURI   = ( net_path | abs_path | rel_path ) [ "?" query ]
-
-	# net_path      = "//" authority [ abs_path ]
-	# abs_path      = "/"  path_segments
-	# rel_path      = rel_segment [ abs_path ]
-
-	# authority     = server | reg_name
-	# server        = [ [ userinfo "@" ] hostport ]
-
-      else
-	raise InvalidURIError, "bad URI(is not URI?): #{uri}"
-      end
-
-      path = '' if !path && !opaque # (see RFC2396 Section 5.2)
-      ret = [
-	scheme, 
-	userinfo, host, port,         # X
-	registry,                     # X
-	path,                         # Y
-	opaque,                       # Y
-	query,
-	fragment
-      ]
-      return ret
-    end
-
-    def parse(uri)
-      scheme, userinfo, host, port, 
-       	registry, path, opaque, query, fragment = self.split(uri)
-
-      if scheme && URI.scheme_list.include?(scheme.upcase)
-	URI.scheme_list[scheme.upcase].new(scheme, userinfo, host, port, 
-                                           registry, path, opaque, query, 
-                                           fragment, self)
-      else
-	Generic.new(scheme, userinfo, host, port, 
-	   	    registry, path, opaque, query, 
-	    	    fragment, self)
-      end
-    end
-
-    def join(*str)
-      u = self.parse(str[0])
-      str[1 .. -1].each do |x|
-	u = u.merge(x)
-      end
-      u
-    end
-
-    def extract(str, schemes = nil, &block)
-      if block_given?
-       	str.scan(make_regexp(schemes)) { yield $& }
-	nil
-      else
-	result = []
-	str.scan(make_regexp(schemes)) { result.push $& }
-	result
-      end
-    end
-
-    def make_regexp(schemes = nil)
-      unless schemes
-       	@regexp[:ABS_URI_REF]
-      else
-	/(?=#{Regexp.union(*schemes)}:)#{@pattern[:X_ABS_URI]}/x
-      end
-    end
-
-    def escape(str, unsafe = @regexp[:UNSAFE])
-      unless unsafe.kind_of?(Regexp)
-        # perhaps unsafe is String object
-        unsafe = Regexp.new("[#{Regexp.quote(unsafe)}]", false)
-      end
-      str.gsub(unsafe) do
-        us = $&
-        tmp = ''
-        us.each_byte do |uc|
-          tmp << sprintf('%%%02X', uc)
-        end
-        tmp
-      end.force_encoding("US-ASCII")#Encoding::US_ASCII)
-    end
-
-    def unescape(str, escaped = @regexp[:ESCAPED])
-      str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(str.encoding)
-    end
-
-    @@to_s = Kernel.instance_method(:to_s)
-    def inspect
-      @@to_s.bind(self).call
-    end
-
-    private
-
-    def initialize_pattern(opts = {})
-      ret = {}
-      ret[:ESCAPED] = escaped = (opts.delete(:ESCAPED) || PATTERN::ESCAPED)
-      ret[:UNRESERVED] = unreserved = opts.delete(:UNRESERVED) || PATTERN::UNRESERVED
-      ret[:RESERVED] = reserved = opts.delete(:RESERVED) || PATTERN::RESERVED
-      ret[:DOMLABEL] = domlabel = opts.delete(:DOMLABEL) || PATTERN::DOMLABEL
-      ret[:TOPLABEL] = toplabel = opts.delete(:TOPLABEL) || PATTERN::TOPLABEL
-      ret[:HOSTNAME] = hostname = opts.delete(:HOSTNAME)
-
-      # RFC 2396 (URI Generic Syntax)
-      # RFC 2732 (IPv6 Literal Addresses in URL's)
-      # RFC 2373 (IPv6 Addressing Architecture)
-
-      # uric          = reserved | unreserved | escaped
-      ret[:URIC] = uric = "(?:[#{unreserved}#{reserved}]|#{escaped})"
-      # uric_no_slash = unreserved | escaped | ";" | "?" | ":" | "@" |
-      #                 "&" | "=" | "+" | "$" | ","
-      ret[:URIC_NO_SLASH] = uric_no_slash = "(?:[#{unreserved};?:@&=+$,]|#{escaped})"
-      # query         = *uric
-      ret[:QUERY] = query = "#{uric}*"
-      # fragment      = *uric
-      ret[:FRAGMENT] = fragment = "#{uric}*"
-
-      # hostname      = *( domainlabel "." ) toplabel [ "." ]
-      unless hostname
-	ret[:HOSTNAME] = hostname = "(?:#{domlabel}\\.)*#{toplabel}\\.?"
-      end
-
-      # RFC 2373, APPENDIX B:
-      # IPv6address = hexpart [ ":" IPv4address ]
-      # IPv4address   = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT
-      # hexpart = hexseq | hexseq "::" [ hexseq ] | "::" [ hexseq ]
-      # hexseq  = hex4 *( ":" hex4)
-      # hex4    = 1*4HEXDIG
-      #
-      # XXX: This definition has a flaw. "::" + IPv4address must be
-      # allowed too.  Here is a replacement.
-      #
-      # IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT
-      ret[:IPV4ADDR] = ipv4addr = "\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"
-      # hex4     = 1*4HEXDIG
-      hex4 = "[#{PATTERN::HEX}]{1,4}"
-      # lastpart = hex4 | IPv4address
-      lastpart = "(?:#{hex4}|#{ipv4addr})"
-      # hexseq1  = *( hex4 ":" ) hex4
-      hexseq1 = "(?:#{hex4}:)*#{hex4}"
-      # hexseq2  = *( hex4 ":" ) lastpart
-      hexseq2 = "(?:#{hex4}:)*#{lastpart}"
-      # IPv6address = hexseq2 | [ hexseq1 ] "::" [ hexseq2 ]
-      ret[:IPV6ADDR] = ipv6addr = "(?:#{hexseq2}|(?:#{hexseq1})?::(?:#{hexseq2})?)"
-
-      # IPv6prefix  = ( hexseq1 | [ hexseq1 ] "::" [ hexseq1 ] ) "/" 1*2DIGIT
-      # unused
-
-      # ipv6reference = "[" IPv6address "]" (RFC 2732)
-      ret[:IPV6REF] = ipv6ref = "\\[#{ipv6addr}\\]"
-
-      # host          = hostname | IPv4address
-      # host          = hostname | IPv4address | IPv6reference (RFC 2732)
-      ret[:HOST] = host = "(?:#{hostname}|#{ipv4addr}|#{ipv6ref})"
-      # port          = *digit
-      port = '\d*'
-      # hostport      = host [ ":" port ]
-      ret[:HOSTPORT] = hostport = "#{host}(?::#{port})?"
-
-      # userinfo      = *( unreserved | escaped |
-      #                    ";" | ":" | "&" | "=" | "+" | "$" | "," )
-      ret[:USERINFO] = userinfo = "(?:[#{unreserved};:&=+$,]|#{escaped})*"
-
-      # pchar         = unreserved | escaped |
-      #                 ":" | "@" | "&" | "=" | "+" | "$" | ","
-      pchar = "(?:[#{unreserved}:@&=+$,]|#{escaped})"
-      # param         = *pchar
-      param = "#{pchar}*"
-      # segment       = *pchar *( ";" param )
-      segment = "#{pchar}*(?:;#{param})*"
-      # path_segments = segment *( "/" segment )
-      ret[:PATH_SEGMENTS] = path_segments = "#{segment}(?:/#{segment})*"
-
-      # server        = [ [ userinfo "@" ] hostport ]
-      server = "(?:#{userinfo}@)?#{hostport}"
-      # reg_name      = 1*( unreserved | escaped | "$" | "," |
-      #                     ";" | ":" | "@" | "&" | "=" | "+" )
-      ret[:REG_NAME] = reg_name = "(?:[#{unreserved}$,;:@&=+]|#{escaped})+"
-      # authority     = server | reg_name
-      authority = "(?:#{server}|#{reg_name})"
-
-      # rel_segment   = 1*( unreserved | escaped |
-      #                     ";" | "@" | "&" | "=" | "+" | "$" | "," )
-      ret[:REL_SEGMENT] = rel_segment = "(?:[#{unreserved};@&=+$,]|#{escaped})+"
-
-      # scheme        = alpha *( alpha | digit | "+" | "-" | "." )
-      ret[:SCHEME] = scheme = "[#{PATTERN::ALPHA}][-+.#{PATTERN::ALPHA}\\d]*"
-
-      # abs_path      = "/"  path_segments
-      ret[:ABS_PATH] = abs_path = "/#{path_segments}"
-      # rel_path      = rel_segment [ abs_path ]
-      ret[:REL_PATH] = rel_path = "#{rel_segment}(?:#{abs_path})?"
-      # net_path      = "//" authority [ abs_path ]
-      ret[:NET_PATH] = net_path = "//#{authority}(?:#{abs_path})?"
-
-      # hier_part     = ( net_path | abs_path ) [ "?" query ]
-      ret[:HIER_PART] = hier_part = "(?:#{net_path}|#{abs_path})(?:\\?(?:#{query}))?"
-      # opaque_part   = uric_no_slash *uric
-      ret[:OPAQUE_PART] = opaque_part = "#{uric_no_slash}#{uric}*"
-
-      # absoluteURI   = scheme ":" ( hier_part | opaque_part )
-      ret[:ABS_URI] = abs_uri = "#{scheme}:(?:#{hier_part}|#{opaque_part})"
-      # relativeURI   = ( net_path | abs_path | rel_path ) [ "?" query ]
-      ret[:REL_URI] = rel_uri = "(?:#{net_path}|#{abs_path}|#{rel_path})(?:\\?#{query})?"
-
-      # URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]
-      ret[:URI_REF] = uri_ref = "(?:#{abs_uri}|#{rel_uri})?(?:##{fragment})?"
-
-      ret[:X_ABS_URI] = "
-        (#{scheme}):                           (?# 1: scheme)
-        (?:
-           (#{opaque_part})                    (?# 2: opaque)
-        |
-           (?:(?:
-             //(?:
-                 (?:(?:(#{userinfo})@)?        (?# 3: userinfo)
-                   (?:(#{host})(?::(\\d*))?))? (?# 4: host, 5: port)
-               |
-                 (#{reg_name})                 (?# 6: registry)
-               )
-             |
-             (?!//))                           (?# XXX: '//' is the mark for hostport)
-             (#{abs_path})?                    (?# 7: path)
-           )(?:\\?(#{query}))?                 (?# 8: query)
-        )
-        (?:\\#(#{fragment}))?                  (?# 9: fragment)
-      "
-
-      ret[:X_REL_URI] = "
-        (?:
-          (?:
-            //
-            (?:
-              (?:(#{userinfo})@)?       (?# 1: userinfo)
-                (#{host})?(?::(\\d*))?  (?# 2: host, 3: port)
-            |
-              (#{reg_name})             (?# 4: registry)
-            )
-          )
-        |
-          (#{rel_segment})              (?# 5: rel_segment)
-        )?
-        (#{abs_path})?                  (?# 6: abs_path)
-        (?:\\?(#{query}))?              (?# 7: query)
-        (?:\\#(#{fragment}))?           (?# 8: fragment)
-      "
-
-      ret
-    end
-
-    def initialize_regexp(pattern)
-      ret = {}
-
-      # for URI::split
-      ret[:ABS_URI] = Regexp.new('^' + pattern[:X_ABS_URI] + '$', Regexp::EXTENDED)
-      ret[:REL_URI] = Regexp.new('^' + pattern[:X_REL_URI] + '$', Regexp::EXTENDED)
-
-      # for URI::extract
-      ret[:URI_REF]     = Regexp.new(pattern[:URI_REF])
-      ret[:ABS_URI_REF] = Regexp.new(pattern[:X_ABS_URI], Regexp::EXTENDED)
-      ret[:REL_URI_REF] = Regexp.new(pattern[:X_REL_URI], Regexp::EXTENDED)
-
-      # for URI::escape/unescape
-      ret[:ESCAPED] = Regexp.new(pattern[:ESCAPED])
-      ret[:UNSAFE]  = Regexp.new("[^#{pattern[:UNRESERVED]}#{pattern[:RESERVED]}]")
-
-      # for Generic#initialize
-      ret[:SCHEME]   = Regexp.new("^#{pattern[:SCHEME]}$")
-      ret[:USERINFO] = Regexp.new("^#{pattern[:USERINFO]}$")
-      ret[:HOST]     = Regexp.new("^#{pattern[:HOST]}$")
-      ret[:PORT]     = Regexp.new("^#{pattern[:PORT]}$")
-      ret[:OPAQUE]   = Regexp.new("^#{pattern[:OPAQUE_PART]}$")
-      ret[:REGISTRY] = Regexp.new("^#{pattern[:REG_NAME]}$")
-      ret[:ABS_PATH] = Regexp.new("^#{pattern[:ABS_PATH]}$")
-      ret[:REL_PATH] = Regexp.new("^#{pattern[:REL_PATH]}$")
-      ret[:QUERY]    = Regexp.new("^#{pattern[:QUERY]}$")
-      ret[:FRAGMENT] = Regexp.new("^#{pattern[:FRAGMENT]}$")
-
-      ret
-    end
-  end # class Parser
-
-  DEFAULT_PARSER = Parser.new
-  DEFAULT_PARSER.pattern.each_pair do |sym, str|
-    unless REGEXP::PATTERN.const_defined?(sym)
-      REGEXP::PATTERN.const_set(sym, str)
-    end
-  end
-  DEFAULT_PARSER.regexp.each_pair do |sym, str|
-    const_set(sym, str)
-  end
-
-  module Util # :nodoc:
-    def make_components_hash(klass, array_hash)
-      tmp = {}
-      if array_hash.kind_of?(Array) &&
-          array_hash.size == klass.component.size - 1
-        klass.component[1..-1].each_index do |i|
-          begin
-            tmp[klass.component[i + 1]] = array_hash[i].clone
-          rescue TypeError
-            tmp[klass.component[i + 1]] = array_hash[i]
-          end
-        end
-
-      elsif array_hash.kind_of?(Hash)
-        array_hash.each do |key, value|
-          begin
-            tmp[key] = value.clone
-          rescue TypeError
-            tmp[key] = value
-          end
-        end
-      else
-        raise ArgumentError, 
-          "expected Array of or Hash of components of #{klass.to_s} (#{klass.component[1..-1].join(', ')})"
-      end
-      tmp[:scheme] = klass.to_s.sub(/\A.*::/, '').downcase
-
-      return tmp
-    end
-    module_function :make_components_hash
-  end
-
-  module Escape
-    #
-    # == Synopsis
-    #
-    #   URI.escape(str [, unsafe])
-    #
-    # == Args
-    #
-    # +str+::
-    #   String to replaces in.
-    # +unsafe+::
-    #   Regexp that matches all symbols that must be replaced with codes.
-    #   By default uses <tt>REGEXP::UNSAFE</tt>.
-    #   When this argument is a String, it represents a character set.
-    #
-    # == Description
-    #
-    # Escapes the string, replacing all unsafe characters with codes.
-    #
-    # == Usage
-    #
-    #   require 'uri'
-    #
-    #   enc_uri = URI.escape("http://example.com/?a=\11\15")
-    #   p enc_uri
-    #   # => "http://example.com/?a=%09%0D"
-    #
-    #   p URI.unescape(enc_uri)
-    #   # => "http://example.com/?a=\t\r"
-    #
-    #   p URI.escape("@?@!", "!?")
-    #   # => "@%3F@%21"
-    #
-    def escape(*arg)
-      DEFAULT_PARSER.escape(*arg)
-    end
-    alias encode escape
-    #
-    # == Synopsis
-    #
-    #   URI.unescape(str)
-    #
-    # == Args
-    #
-    # +str+::
-    #   Unescapes the string.
-    #
-    # == Usage
-    #
-    #   require 'uri'
-    #
-    #   enc_uri = URI.escape("http://example.com/?a=\11\15")
-    #   p enc_uri
-    #   # => "http://example.com/?a=%09%0D"
-    #
-    #   p URI.unescape(enc_uri)
-    #   # => "http://example.com/?a=\t\r"
-    #
-    def unescape(*arg)
-      DEFAULT_PARSER.unescape(*arg)
-    end
-    alias decode unescape
-  end
-
-  extend Escape
-  include REGEXP
-
-  @@schemes = {}
-  def self.scheme_list
-    @@schemes
-  end
-  
-  #
-  # Base class for all URI exceptions.
-  #
-  class Error < StandardError; end
-  #
-  # Not a URI.
-  #
-  class InvalidURIError < Error; end
-  #
-  # Not a URI component.
-  #
-  class InvalidComponentError < Error; end
-  #
-  # URI is valid, bad usage is not.
-  #
-  class BadURIError < Error; end
-
-  #
-  # == Synopsis
-  #
-  #   URI::split(uri)
-  #
-  # == Args
-  #
-  # +uri+::
-  #   String with URI.
-  #
-  # == Description
-  #
-  # Splits the string on following parts and returns array with result:
-  #
-  #   * Scheme
-  #   * Userinfo
-  #   * Host
-  #   * Port
-  #   * Registry
-  #   * Path
-  #   * Opaque
-  #   * Query
-  #   * Fragment
-  # 
-  # == Usage
-  #
-  #   require 'uri'
-  #
-  #   p URI.split("http://www.ruby-lang.org/")
-  #   # => ["http", nil, "www.ruby-lang.org", nil, nil, "/", nil, nil, nil]
-  #
-  def self.split(uri)
-    DEFAULT_PARSER.split(uri)
-  end
-
-  #
-  # == Synopsis
-  #
-  #   URI::parse(uri_str)
-  #
-  # == Args
-  #
-  # +uri_str+::
-  #   String with URI.
-  #
-  # == Description
-  #
-  # Creates one of the URI's subclasses instance from the string.
-  #  
-  # == Raises
-  #
-  # URI::InvalidURIError
-  #   Raised if URI given is not a correct one.
-  #
-  # == Usage
-  #
-  #   require 'uri'
-  #
-  #   uri = URI.parse("http://www.ruby-lang.org/")
-  #   p uri
-  #   # => #<URI::HTTP:0x202281be URL:http://www.ruby-lang.org/>
-  #   p uri.scheme 
-  #   # => "http" 
-  #   p uri.host 
-  #   # => "www.ruby-lang.org" 
-  # 
-  def self.parse(uri)
-    DEFAULT_PARSER.parse(uri)
-  end
-
-  #
-  # == Synopsis
-  #
-  #   URI::join(str[, str, ...])
-  #
-  # == Args
-  #
-  # +str+::
-  #   String(s) to work with
-  #
-  # == Description
-  #
-  # Joins URIs.
-  #
-  # == Usage
-  #
-  #   require 'uri'
-  #
-  #   p URI.join("http://localhost/","main.rbx")
-  #   # => #<URI::HTTP:0x2022ac02 URL:http://localhost/main.rbx>
-  #
-  def self.join(*str)
-    DEFAULT_PARSER.join(*str)
-  end
-
-  #
-  # == Synopsis
-  #
-  #   URI::extract(str[, schemes][,&blk])
-  #
-  # == Args
-  #
-  # +str+:: 
-  #   String to extract URIs from.
-  # +schemes+::
-  #   Limit URI matching to a specific schemes.
-  #
-  # == Description
-  #
-  # Extracts URIs from a string. If block given, iterates through all matched URIs.
-  # Returns nil if block given or array with matches.
-  #
-  # == Usage
-  #
-  #   require "uri"
-  #
-  #   URI.extract("text here http://foo.example.org/bla and here mailto:test@example.com and here also.")
-  #   # => ["http://foo.example.com/bla", "mailto:test@example.com"]
-  #
-  def self.extract(str, schemes = nil, &block)
-    DEFAULT_PARSER.extract(str, schemes, &block)
-  end
-
-  #
-  # == Synopsis
-  #
-  #   URI::regexp([match_schemes])
-  #
-  # == Args
-  #
-  # +match_schemes+:: 
-  #   Array of schemes. If given, resulting regexp matches to URIs
-  #   whose scheme is one of the match_schemes.
-  # 
-  # == Description
-  # Returns a Regexp object which matches to URI-like strings.
-  # The Regexp object returned by this method includes arbitrary
-  # number of capture group (parentheses).  Never rely on it's number.
-  # 
-  # == Usage
-  #
-  #   require 'uri'
-  #
-  #   # extract first URI from html_string
-  #   html_string.slice(URI.regexp)
-  # 
-  #   # remove ftp URIs
-  #   html_string.sub(URI.regexp(['ftp'])
-  # 
-  #   # You should not rely on the number of parentheses
-  #   html_string.scan(URI.regexp) do |*matches|
-  #     p $&
-  #   end
-  #
-  def self.regexp(schemes = nil)
-    DEFAULT_PARSER.make_regexp(schemes)
-  end
-
-end
-
-module Kernel
-  # alias for URI.parse.
-  #
-  # This method is introduced at 1.8.2.
-  def URI(uri_str) # :doc:
-    URI.parse(uri_str)
-  end
-  module_function :URI
-end