dwolla_swagger 1.0.5 → 1.0.6

data/vendor/bundle/ruby/2.2.0/gems/addressable-2.4.0/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/vendor/bundle/ruby/2.2.0/gems/addressable-2.4.0/README.md

@@ -0,0 +1,105 @@
+# Addressable
+
+<dl>
+  <dt>Homepage</dt><dd><a href="https://github.com/sporkmonger/addressable">github.com/sporkmonger/addressable</a></dd>
+  <dt>Author</dt><dd><a href="mailto:bob@sporkmonger.com">Bob Aman</a></dd>
+  <dt>Copyright</dt><dd>Copyright © 2006-2015 Bob Aman</dd>
+  <dt>License</dt><dd>Apache 2.0</dd>
+</dl>
+
+[![Gem Version](http://img.shields.io/gem/dt/addressable.svg)][gem]
+[![Build Status](https://secure.travis-ci.org/sporkmonger/addressable.png?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/sporkmonger/addressable.png?travis)][gemnasium]
+[![Test Coverage Status](https://img.shields.io/coveralls/sporkmonger/addressable.svg)][coveralls]
+[![Documentation Coverage Status](http://inch-ci.org/github/sporkmonger/addressable.svg?branch=master)][inch]
+[![Gittip Donate](http://img.shields.io/gittip/sporkmonger.png)](https://www.gittip.com/sporkmonger/ "Support Open Source Development w/ Gittip")
+
+[gem]: https://rubygems.org/gems/addressable
+[travis]: http://travis-ci.org/sporkmonger/addressable
+[gemnasium]: https://gemnasium.com/sporkmonger/addressable
+[coveralls]: https://coveralls.io/r/sporkmonger/addressable
+[inch]: http://inch-ci.org/github/sporkmonger/addressable
+
+# Description
+
+Addressable is a replacement for the URI implementation that is part of
+Ruby's standard library. It more closely conforms to RFC 3986, RFC 3987, and
+RFC 6570 (level 4), providing support for IRIs and URI templates.
+
+# Reference
+
+- {Addressable::URI}
+- {Addressable::Template}
+
+# Example usage
+
+```ruby
+require "addressable/uri"
+
+uri = Addressable::URI.parse("http://example.com/path/to/resource/")
+uri.scheme
+#=> "http"
+uri.host
+#=> "example.com"
+uri.path
+#=> "/path/to/resource/"
+
+uri = Addressable::URI.parse("http://www.詹姆斯.com/")
+uri.normalize
+#=> #<Addressable::URI:0xc9a4c8 URI:http://www.xn--8ws00zhy3a.com/>
+```
+
+
+# URI Templates
+
+For more details, see [RFC 6570](https://www.rfc-editor.org/rfc/rfc6570.txt).
+
+
+```ruby
+
+require "addressable/template"
+
+template = Addressable::Template.new("http://example.com/{?query*}/")
+template.expand({
+  "query" => {
+    'foo' => 'bar',
+    'color' => 'red'
+  }
+})
+#=> #<Addressable::URI:0xc9d95c URI:http://example.com/?foo=bar&color=red>
+
+template = Addressable::Template.new("http://example.com/{?one,two,three}")
+template.partial_expand({"one" => "1", "three" => 3}).pattern
+#=> "http://example.com/?one=1{&two}&three=3"
+
+template = Addressable::Template.new(
+  "http://{host}{/segments*}/{?one,two,bogus}{#fragment}"
+)
+uri = Addressable::URI.parse(
+  "http://example.com/a/b/c/?one=1&two=2#foo"
+)
+template.extract(uri)
+#=>
+# {
+#   "host" => "example.com",
+#   "segments" => ["a", "b", "c"],
+#   "one" => "1",
+#   "two" => "2",
+#   "fragment" => "foo"
+# }
+```
+
+# Install
+
+```console
+$ sudo gem install addressable
+```
+
+You may optionally turn on native IDN support by installing libidn and the
+idn gem:
+
+```console
+$ sudo apt-get install idn # Debian/Ubuntu
+$ brew install libidn # OS X
+$ gem install idn-ruby
+```

data/vendor/bundle/ruby/2.2.0/gems/addressable-2.4.0/Rakefile

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'rake'
+
+require File.join(File.dirname(__FILE__), 'lib', 'addressable', 'version')
+
+PKG_DISPLAY_NAME   = 'Addressable'
+PKG_NAME           = PKG_DISPLAY_NAME.downcase
+PKG_VERSION        = Addressable::VERSION::STRING
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME       = "REL #{PKG_VERSION}"
+
+PKG_SUMMARY        = "URI Implementation"
+PKG_DESCRIPTION    = <<-TEXT
+Addressable is a replacement for the URI implementation that is part of
+Ruby's standard library. It more closely conforms to the relevant RFCs and
+adds support for IRIs and URI templates.
+TEXT
+
+PKG_FILES = FileList[
+    "lib/**/*", "spec/**/*", "vendor/**/*", "data/**/*",
+    "tasks/**/*",
+    "[A-Z]*", "Rakefile"
+].exclude(/pkg/).exclude(/database\.yml/).
+  exclude(/Gemfile\.lock/).exclude(/[_\.]git$/)
+
+task :default => "spec"
+
+WINDOWS = (RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/) rescue false
+SUDO = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/vendor/bundle/ruby/2.2.0/gems/addressable-2.4.0/addressable.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+# stub: addressable 2.4.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "addressable"
+  s.version = "2.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Bob Aman"]
+  s.date = "2015-12-07"
+  s.description = "Addressable is a replacement for the URI implementation that is part of\nRuby's standard library. It more closely conforms to the relevant RFCs and\nadds support for IRIs and URI templates.\n"
+  s.email = "bob@sporkmonger.com"
+  s.extra_rdoc_files = ["README.md"]
+  s.files = ["CHANGELOG.md", "Gemfile", "LICENSE.txt", "README.md", "Rakefile", "addressable.gemspec", "data/unicode.data", "lib/addressable.rb", "lib/addressable/idna.rb", "lib/addressable/idna/native.rb", "lib/addressable/idna/pure.rb", "lib/addressable/template.rb", "lib/addressable/uri.rb", "lib/addressable/version.rb", "spec/addressable/idna_spec.rb", "spec/addressable/net_http_compat_spec.rb", "spec/addressable/rack_mount_compat_spec.rb", "spec/addressable/security_spec.rb", "spec/addressable/template_spec.rb", "spec/addressable/uri_spec.rb", "spec/spec_helper.rb", "tasks/clobber.rake", "tasks/gem.rake", "tasks/git.rake", "tasks/metrics.rake", "tasks/rspec.rake", "tasks/yard.rake"]
+  s.homepage = "https://github.com/sporkmonger/addressable"
+  s.licenses = ["Apache-2.0"]
+  s.rdoc_options = ["--main", "README.md"]
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.0")
+  s.rubygems_version = "2.5.0"
+  s.summary = "URI Implementation"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/addressable-2.4.0/lib/addressable/idna/native.rb

@@ -0,0 +1,55 @@
+# encoding:utf-8
+#--
+# Copyright (C) 2006-2015 Bob Aman
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#++
+
+
+require "idn"
+
+module Addressable
+  module IDNA
+    def self.punycode_encode(value)
+      IDN::Punycode.encode(value.to_s)
+    end
+
+     def self.punycode_decode(value)
+       IDN::Punycode.decode(value.to_s)
+     end
+
+    def self.unicode_normalize_kc(value)
+      IDN::Stringprep.nfkc_normalize(value.to_s)
+    end
+
+    def self.to_ascii(value)
+      value.to_s.split('.', -1).map do |segment|
+        if segment.size > 0
+          IDN::Idna.toASCII(segment)
+        else
+          ''
+        end
+      end.join('.')
+    end
+
+    def self.to_unicode(value)
+      value.to_s.split('.', -1).map do |segment|
+        if segment.size > 0
+          IDN::Idna.toUnicode(segment)
+        else
+          ''
+        end
+      end.join('.')
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/addressable-2.4.0/lib/addressable/idna/pure.rb

@@ -0,0 +1,672 @@
+# encoding:utf-8
+#--
+# Copyright (C) 2006-2015 Bob Aman
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#++
+
+
+module Addressable
+  module IDNA
+    # This module is loosely based on idn_actionmailer by Mick Staugaard,
+    # the unicode library by Yoshida Masato, and the punycode implementation
+    # by Kazuhiro Nishiyama.  Most of the code was copied verbatim, but
+    # some reformatting was done, and some translation from C was done.
+    #
+    # Without their code to work from as a base, we'd all still be relying
+    # on the presence of libidn.  Which nobody ever seems to have installed.
+    #
+    # Original sources:
+    # http://github.com/staugaard/idn_actionmailer
+    # http://www.yoshidam.net/Ruby.html#unicode
+    # http://rubyforge.org/frs/?group_id=2550
+
+
+    UNICODE_TABLE = File.expand_path(
+      File.join(File.dirname(__FILE__), '../../..', 'data/unicode.data')
+    )
+
+    ACE_PREFIX = "xn--"
+
+    UTF8_REGEX = /\A(?:
+      [\x09\x0A\x0D\x20-\x7E]               # ASCII
+      | [\xC2-\xDF][\x80-\xBF]              # non-overlong 2-byte
+      | \xE0[\xA0-\xBF][\x80-\xBF]          # excluding overlongs
+      | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}   # straight 3-byte
+      | \xED[\x80-\x9F][\x80-\xBF]          # excluding surrogates
+      | \xF0[\x90-\xBF][\x80-\xBF]{2}       # planes 1-3
+      | [\xF1-\xF3][\x80-\xBF]{3}           # planes 4nil5
+      | \xF4[\x80-\x8F][\x80-\xBF]{2}       # plane 16
+      )*\z/mnx
+
+    UTF8_REGEX_MULTIBYTE = /(?:
+      [\xC2-\xDF][\x80-\xBF]                # non-overlong 2-byte
+      | \xE0[\xA0-\xBF][\x80-\xBF]          # excluding overlongs
+      | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}   # straight 3-byte
+      | \xED[\x80-\x9F][\x80-\xBF]          # excluding surrogates
+      | \xF0[\x90-\xBF][\x80-\xBF]{2}       # planes 1-3
+      | [\xF1-\xF3][\x80-\xBF]{3}           # planes 4nil5
+      | \xF4[\x80-\x8F][\x80-\xBF]{2}       # plane 16
+      )/mnx
+
+    # :startdoc:
+
+    # Converts from a Unicode internationalized domain name to an ASCII
+    # domain name as described in RFC 3490.
+    def self.to_ascii(input)
+      input = input.to_s unless input.is_a?(String)
+      input = input.dup
+      if input.respond_to?(:force_encoding)
+        input.force_encoding(Encoding::ASCII_8BIT)
+      end
+      if input =~ UTF8_REGEX && input =~ UTF8_REGEX_MULTIBYTE
+        parts = unicode_downcase(input).split('.')
+        parts.map! do |part|
+          if part.respond_to?(:force_encoding)
+            part.force_encoding(Encoding::ASCII_8BIT)
+          end
+          if part =~ UTF8_REGEX && part =~ UTF8_REGEX_MULTIBYTE
+            ACE_PREFIX + punycode_encode(unicode_normalize_kc(part))
+          else
+            part
+          end
+        end
+        parts.join('.')
+      else
+        input
+      end
+    end
+
+    # Converts from an ASCII domain name to a Unicode internationalized
+    # domain name as described in RFC 3490.
+    def self.to_unicode(input)
+      input = input.to_s unless input.is_a?(String)
+      parts = input.split('.')
+      parts.map! do |part|
+        if part =~ /^#{ACE_PREFIX}(.+)/
+          punycode_decode(part[/^#{ACE_PREFIX}(.+)/, 1])
+        else
+          part
+        end
+      end
+      output = parts.join('.')
+      if output.respond_to?(:force_encoding)
+        output.force_encoding(Encoding::UTF_8)
+      end
+      output
+    end
+
+    # Unicode normalization form KC.
+    def self.unicode_normalize_kc(input)
+      input = input.to_s unless input.is_a?(String)
+      unpacked = input.unpack("U*")
+      unpacked =
+        unicode_compose(unicode_sort_canonical(unicode_decompose(unpacked)))
+      return unpacked.pack("U*")
+    end
+
+    ##
+    # Unicode aware downcase method.
+    #
+    # @api private
+    # @param [String] input
+    #   The input string.
+    # @return [String] The downcased result.
+    def self.unicode_downcase(input)
+      input = input.to_s unless input.is_a?(String)
+      unpacked = input.unpack("U*")
+      unpacked.map! { |codepoint| lookup_unicode_lowercase(codepoint) }
+      return unpacked.pack("U*")
+    end
+    (class <<self; private :unicode_downcase; end)
+
+    def self.unicode_compose(unpacked)
+      unpacked_result = []
+      length = unpacked.length
+
+      return unpacked if length == 0
+
+      starter = unpacked[0]
+      starter_cc = lookup_unicode_combining_class(starter)
+      starter_cc = 256 if starter_cc != 0
+      for i in 1...length
+        ch = unpacked[i]
+        cc = lookup_unicode_combining_class(ch)
+
+        if (starter_cc == 0 &&
+            (composite = unicode_compose_pair(starter, ch)) != nil)
+          starter = composite
+          startercc = lookup_unicode_combining_class(composite)
+        else
+          unpacked_result << starter
+          starter = ch
+          startercc = cc
+        end
+      end
+      unpacked_result << starter
+      return unpacked_result
+    end
+    (class <<self; private :unicode_compose; end)
+
+    def self.unicode_compose_pair(ch_one, ch_two)
+      if ch_one >= HANGUL_LBASE && ch_one < HANGUL_LBASE + HANGUL_LCOUNT &&
+          ch_two >= HANGUL_VBASE && ch_two < HANGUL_VBASE + HANGUL_VCOUNT
+        # Hangul L + V
+        return HANGUL_SBASE + (
+          (ch_one - HANGUL_LBASE) * HANGUL_VCOUNT + (ch_two - HANGUL_VBASE)
+        ) * HANGUL_TCOUNT
+      elsif ch_one >= HANGUL_SBASE &&
+          ch_one < HANGUL_SBASE + HANGUL_SCOUNT &&
+          (ch_one - HANGUL_SBASE) % HANGUL_TCOUNT == 0 &&
+          ch_two >= HANGUL_TBASE && ch_two < HANGUL_TBASE + HANGUL_TCOUNT
+           # Hangul LV + T
+        return ch_one + (ch_two - HANGUL_TBASE)
+      end
+
+      p = []
+      ucs4_to_utf8 = lambda do |ch|
+        if ch < 128
+          p << ch
+        elsif ch < 2048
+          p << (ch >> 6 | 192)
+          p << (ch & 63 | 128)
+        elsif ch < 0x10000
+          p << (ch >> 12 | 224)
+          p << (ch >> 6 & 63 | 128)
+          p << (ch & 63 | 128)
+        elsif ch < 0x200000
+          p << (ch >> 18 | 240)
+          p << (ch >> 12 & 63 | 128)
+          p << (ch >> 6 & 63 | 128)
+          p << (ch & 63 | 128)
+        elsif ch < 0x4000000
+          p << (ch >> 24 | 248)
+          p << (ch >> 18 & 63 | 128)
+          p << (ch >> 12 & 63 | 128)
+          p << (ch >> 6 & 63 | 128)
+          p << (ch & 63 | 128)
+        elsif ch < 0x80000000
+          p << (ch >> 30 | 252)
+          p << (ch >> 24 & 63 | 128)
+          p << (ch >> 18 & 63 | 128)
+          p << (ch >> 12 & 63 | 128)
+          p << (ch >> 6 & 63 | 128)
+          p << (ch & 63 | 128)
+        end
+      end
+
+      ucs4_to_utf8.call(ch_one)
+      ucs4_to_utf8.call(ch_two)
+
+      return lookup_unicode_composition(p)
+    end
+    (class <<self; private :unicode_compose_pair; end)
+
+    def self.unicode_sort_canonical(unpacked)
+      unpacked = unpacked.dup
+      i = 1
+      length = unpacked.length
+
+      return unpacked if length < 2
+
+      while i < length
+        last = unpacked[i-1]
+        ch = unpacked[i]
+        last_cc = lookup_unicode_combining_class(last)
+        cc = lookup_unicode_combining_class(ch)
+        if cc != 0 && last_cc != 0 && last_cc > cc
+          unpacked[i] = last
+          unpacked[i-1] = ch
+          i -= 1 if i > 1
+        else
+          i += 1
+        end
+      end
+      return unpacked
+    end
+    (class <<self; private :unicode_sort_canonical; end)
+
+    def self.unicode_decompose(unpacked)
+      unpacked_result = []
+      for cp in unpacked
+        if cp >= HANGUL_SBASE && cp < HANGUL_SBASE + HANGUL_SCOUNT
+          l, v, t = unicode_decompose_hangul(cp)
+          unpacked_result << l
+          unpacked_result << v if v
+          unpacked_result << t if t
+        else
+          dc = lookup_unicode_compatibility(cp)
+          unless dc
+            unpacked_result << cp
+          else
+            unpacked_result.concat(unicode_decompose(dc.unpack("U*")))
+          end
+        end
+      end
+      return unpacked_result
+    end
+    (class <<self; private :unicode_decompose; end)
+
+    def self.unicode_decompose_hangul(codepoint)
+      sindex = codepoint - HANGUL_SBASE;
+      if sindex < 0 || sindex >= HANGUL_SCOUNT
+        l = codepoint
+        v = t = nil
+        return l, v, t
+      end
+      l = HANGUL_LBASE + sindex / HANGUL_NCOUNT
+      v = HANGUL_VBASE + (sindex % HANGUL_NCOUNT) / HANGUL_TCOUNT
+      t = HANGUL_TBASE + sindex % HANGUL_TCOUNT
+      if t == HANGUL_TBASE
+        t = nil
+      end
+      return l, v, t
+    end
+    (class <<self; private :unicode_decompose_hangul; end)
+
+    def self.lookup_unicode_combining_class(codepoint)
+      codepoint_data = UNICODE_DATA[codepoint]
+      (codepoint_data ?
+        (codepoint_data[UNICODE_DATA_COMBINING_CLASS] || 0) :
+        0)
+    end
+    (class <<self; private :lookup_unicode_combining_class; end)
+
+    def self.lookup_unicode_compatibility(codepoint)
+      codepoint_data = UNICODE_DATA[codepoint]
+      (codepoint_data ?
+        codepoint_data[UNICODE_DATA_COMPATIBILITY] : nil)
+    end
+    (class <<self; private :lookup_unicode_compatibility; end)
+
+    def self.lookup_unicode_lowercase(codepoint)
+      codepoint_data = UNICODE_DATA[codepoint]
+      (codepoint_data ?
+        (codepoint_data[UNICODE_DATA_LOWERCASE] || codepoint) :
+        codepoint)
+    end
+    (class <<self; private :lookup_unicode_lowercase; end)
+
+    def self.lookup_unicode_composition(unpacked)
+      return COMPOSITION_TABLE[unpacked]
+    end
+    (class <<self; private :lookup_unicode_composition; end)
+
+    HANGUL_SBASE =  0xac00
+    HANGUL_LBASE =  0x1100
+    HANGUL_LCOUNT = 19
+    HANGUL_VBASE =  0x1161
+    HANGUL_VCOUNT = 21
+    HANGUL_TBASE =  0x11a7
+    HANGUL_TCOUNT = 28
+    HANGUL_NCOUNT = HANGUL_VCOUNT * HANGUL_TCOUNT # 588
+    HANGUL_SCOUNT = HANGUL_LCOUNT * HANGUL_NCOUNT # 11172
+
+    UNICODE_DATA_COMBINING_CLASS = 0
+    UNICODE_DATA_EXCLUSION = 1
+    UNICODE_DATA_CANONICAL = 2
+    UNICODE_DATA_COMPATIBILITY = 3
+    UNICODE_DATA_UPPERCASE = 4
+    UNICODE_DATA_LOWERCASE = 5
+    UNICODE_DATA_TITLECASE = 6
+
+    begin
+      if defined?(FakeFS)
+        fakefs_state = FakeFS.activated?
+        FakeFS.deactivate!
+      end
+      # This is a sparse Unicode table.  Codepoints without entries are
+      # assumed to have the value: [0, 0, nil, nil, nil, nil, nil]
+      UNICODE_DATA = File.open(UNICODE_TABLE, "rb") do |file|
+        Marshal.load(file.read)
+      end
+    ensure
+      if defined?(FakeFS)
+        FakeFS.activate! if fakefs_state
+      end
+    end
+
+    COMPOSITION_TABLE = {}
+    for codepoint, data in UNICODE_DATA
+      canonical = data[UNICODE_DATA_CANONICAL]
+      exclusion = data[UNICODE_DATA_EXCLUSION]
+
+      if canonical && exclusion == 0
+        COMPOSITION_TABLE[canonical.unpack("C*")] = codepoint
+      end
+    end
+
+    UNICODE_MAX_LENGTH = 256
+    ACE_MAX_LENGTH = 256
+
+    PUNYCODE_BASE = 36
+    PUNYCODE_TMIN = 1
+    PUNYCODE_TMAX = 26
+    PUNYCODE_SKEW = 38
+    PUNYCODE_DAMP = 700
+    PUNYCODE_INITIAL_BIAS = 72
+    PUNYCODE_INITIAL_N = 0x80
+    PUNYCODE_DELIMITER = 0x2D
+
+    PUNYCODE_MAXINT = 1 << 64
+
+    PUNYCODE_PRINT_ASCII =
+      "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n" +
+      "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n" +
+      " !\"\#$%&'()*+,-./" +
+      "0123456789:;<=>?" +
+      "@ABCDEFGHIJKLMNO" +
+      "PQRSTUVWXYZ[\\]^_" +
+      "`abcdefghijklmno" +
+      "pqrstuvwxyz{|}~\n"
+
+    # Input is invalid.
+    class PunycodeBadInput < StandardError; end
+    # Output would exceed the space provided.
+    class PunycodeBigOutput < StandardError; end
+    # Input needs wider integers to process.
+    class PunycodeOverflow < StandardError; end
+
+    def self.punycode_encode(unicode)
+      unicode = unicode.to_s unless unicode.is_a?(String)
+      input = unicode.unpack("U*")
+      output = [0] * (ACE_MAX_LENGTH + 1)
+      input_length = input.size
+      output_length = [ACE_MAX_LENGTH]
+
+      # Initialize the state
+      n = PUNYCODE_INITIAL_N
+      delta = out = 0
+      max_out = output_length[0]
+      bias = PUNYCODE_INITIAL_BIAS
+
+      # Handle the basic code points:
+      input_length.times do |j|
+        if punycode_basic?(input[j])
+          if max_out - out < 2
+            raise PunycodeBigOutput,
+              "Output would exceed the space provided."
+          end
+          output[out] = input[j]
+          out += 1
+        end
+      end
+
+      h = b = out
+
+      # h is the number of code points that have been handled, b is the
+      # number of basic code points, and out is the number of characters
+      # that have been output.
+
+      if b > 0
+        output[out] = PUNYCODE_DELIMITER
+        out += 1
+      end
+
+      # Main encoding loop:
+
+      while h < input_length
+        # All non-basic code points < n have been
+        # handled already.  Find the next larger one:
+
+        m = PUNYCODE_MAXINT
+        input_length.times do |j|
+          m = input[j] if (n...m) === input[j]
+        end
+
+        # Increase delta enough to advance the decoder's
+        # <n,i> state to <m,0>, but guard against overflow:
+
+        if m - n > (PUNYCODE_MAXINT - delta) / (h + 1)
+          raise PunycodeOverflow, "Input needs wider integers to process."
+        end
+        delta += (m - n) * (h + 1)
+        n = m
+
+        input_length.times do |j|
+          # Punycode does not need to check whether input[j] is basic:
+          if input[j] < n
+            delta += 1
+            if delta == 0
+              raise PunycodeOverflow,
+                "Input needs wider integers to process."
+            end
+          end
+
+          if input[j] == n
+            # Represent delta as a generalized variable-length integer:
+
+            q = delta; k = PUNYCODE_BASE
+            while true
+              if out >= max_out
+                raise PunycodeBigOutput,
+                  "Output would exceed the space provided."
+              end
+              t = (
+                if k <= bias
+                  PUNYCODE_TMIN
+                elsif k >= bias + PUNYCODE_TMAX
+                  PUNYCODE_TMAX
+                else
+                  k - bias
+                end
+              )
+              break if q < t
+              output[out] =
+                punycode_encode_digit(t + (q - t) % (PUNYCODE_BASE - t))
+              out += 1
+              q = (q - t) / (PUNYCODE_BASE - t)
+              k += PUNYCODE_BASE
+            end
+
+            output[out] = punycode_encode_digit(q)
+            out += 1
+            bias = punycode_adapt(delta, h + 1, h == b)
+            delta = 0
+            h += 1
+          end
+        end
+
+        delta += 1
+        n += 1
+      end
+
+      output_length[0] = out
+
+      outlen = out
+      outlen.times do |j|
+        c = output[j]
+        unless c >= 0 && c <= 127
+          raise StandardError, "Invalid output char."
+        end
+        unless PUNYCODE_PRINT_ASCII[c]
+          raise PunycodeBadInput, "Input is invalid."
+        end
+      end
+
+      output[0..outlen].map { |x| x.chr }.join("").sub(/\0+\z/, "")
+    end
+    (class <<self; private :punycode_encode; end)
+
+    def self.punycode_decode(punycode)
+      input = []
+      output = []
+
+      if ACE_MAX_LENGTH * 2 < punycode.size
+        raise PunycodeBigOutput, "Output would exceed the space provided."
+      end
+      punycode.each_byte do |c|
+        unless c >= 0 && c <= 127
+          raise PunycodeBadInput, "Input is invalid."
+        end
+        input.push(c)
+      end
+
+      input_length = input.length
+      output_length = [UNICODE_MAX_LENGTH]
+
+      # Initialize the state
+      n = PUNYCODE_INITIAL_N
+
+      out = i = 0
+      max_out = output_length[0]
+      bias = PUNYCODE_INITIAL_BIAS
+
+      # Handle the basic code points:  Let b be the number of input code
+      # points before the last delimiter, or 0 if there is none, then
+      # copy the first b code points to the output.
+
+      b = 0
+      input_length.times do |j|
+        b = j if punycode_delimiter?(input[j])
+      end
+      if b > max_out
+        raise PunycodeBigOutput, "Output would exceed the space provided."
+      end
+
+      b.times do |j|
+        unless punycode_basic?(input[j])
+          raise PunycodeBadInput, "Input is invalid."
+        end
+        output[out] = input[j]
+        out+=1
+      end
+
+      # Main decoding loop:  Start just after the last delimiter if any
+      # basic code points were copied; start at the beginning otherwise.
+
+      in_ = b > 0 ? b + 1 : 0
+      while in_ < input_length
+
+        # in_ is the index of the next character to be consumed, and
+        # out is the number of code points in the output array.
+
+        # Decode a generalized variable-length integer into delta,
+        # which gets added to i.  The overflow checking is easier
+        # if we increase i as we go, then subtract off its starting
+        # value at the end to obtain delta.
+
+        oldi = i; w = 1; k = PUNYCODE_BASE
+        while true
+          if in_ >= input_length
+            raise PunycodeBadInput, "Input is invalid."
+          end
+          digit = punycode_decode_digit(input[in_])
+          in_+=1
+          if digit >= PUNYCODE_BASE
+            raise PunycodeBadInput, "Input is invalid."
+          end
+          if digit > (PUNYCODE_MAXINT - i) / w
+            raise PunycodeOverflow, "Input needs wider integers to process."
+          end
+          i += digit * w
+          t = (
+            if k <= bias
+              PUNYCODE_TMIN
+            elsif k >= bias + PUNYCODE_TMAX
+              PUNYCODE_TMAX
+            else
+              k - bias
+            end
+          )
+          break if digit < t
+          if w > PUNYCODE_MAXINT / (PUNYCODE_BASE - t)
+            raise PunycodeOverflow, "Input needs wider integers to process."
+          end
+          w *= PUNYCODE_BASE - t
+          k += PUNYCODE_BASE
+        end
+
+        bias = punycode_adapt(i - oldi, out + 1, oldi == 0)
+
+        # I was supposed to wrap around from out + 1 to 0,
+        # incrementing n each time, so we'll fix that now:
+
+        if i / (out + 1) > PUNYCODE_MAXINT - n
+          raise PunycodeOverflow, "Input needs wider integers to process."
+        end
+        n += i / (out + 1)
+        i %= out + 1
+
+        # Insert n at position i of the output:
+
+        # not needed for Punycode:
+        # raise PUNYCODE_INVALID_INPUT if decode_digit(n) <= base
+        if out >= max_out
+          raise PunycodeBigOutput, "Output would exceed the space provided."
+        end
+
+        #memmove(output + i + 1, output + i, (out - i) * sizeof *output)
+        output[i + 1, out - i] = output[i, out - i]
+        output[i] = n
+        i += 1
+
+        out += 1
+      end
+
+      output_length[0] = out
+
+      output.pack("U*")
+    end
+    (class <<self; private :punycode_decode; end)
+
+    def self.punycode_basic?(codepoint)
+      codepoint < 0x80
+    end
+    (class <<self; private :punycode_basic?; end)
+
+    def self.punycode_delimiter?(codepoint)
+      codepoint == PUNYCODE_DELIMITER
+    end
+    (class <<self; private :punycode_delimiter?; end)
+
+    def self.punycode_encode_digit(d)
+      d + 22 + 75 * ((d < 26) ? 1 : 0)
+    end
+    (class <<self; private :punycode_encode_digit; end)
+
+    # Returns the numeric value of a basic codepoint
+    # (for use in representing integers) in the range 0 to
+    # base - 1, or PUNYCODE_BASE if codepoint does not represent a value.
+    def self.punycode_decode_digit(codepoint)
+      if codepoint - 48 < 10
+        codepoint - 22
+      elsif codepoint - 65 < 26
+        codepoint - 65
+      elsif codepoint - 97 < 26
+        codepoint - 97
+      else
+        PUNYCODE_BASE
+      end
+    end
+    (class <<self; private :punycode_decode_digit; end)
+
+    # Bias adaptation method
+    def self.punycode_adapt(delta, numpoints, firsttime)
+      delta = firsttime ? delta / PUNYCODE_DAMP : delta >> 1
+      # delta >> 1 is a faster way of doing delta / 2
+      delta += delta / numpoints
+      difference = PUNYCODE_BASE - PUNYCODE_TMIN
+
+      k = 0
+      while delta > (difference * PUNYCODE_TMAX) / 2
+        delta /= difference
+        k += PUNYCODE_BASE
+      end
+
+      k + (difference + 1) * delta / (delta + PUNYCODE_SKEW)
+    end
+    (class <<self; private :punycode_adapt; end)
+  end
+  # :startdoc:
+end