Vendor bundled gems for deployment

27 files changed, 13803 insertions, 0 deletions

diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/CHANGELOG.md b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/CHANGELOG.md
new file mode 100644
index 0000000..bf21002
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/CHANGELOG.md
@@ -0,0 +1,301 @@
+# Addressable 2.8.7 <a name="v2.8.7">
+- Allow `public_suffix` 6 ([#535])
+
+[#535]: https://github.com/sporkmonger/addressable/pull/535
+
+# Addressable 2.8.6 <a name="v2.8.6">
+- Memoize regexps for common character classes ([#524])
+
+[#524]: https://github.com/sporkmonger/addressable/pull/524
+
+# Addressable 2.8.5 <a name="v2.8.5">
+- Fix thread safety issue with encoding tables ([#515])
+- Define URI::NONE as a module to avoid serialization issues ([#509])
+- Fix YAML serialization ([#508])
+
+[#508]: https://github.com/sporkmonger/addressable/pull/508
+[#509]: https://github.com/sporkmonger/addressable/pull/509
+[#515]: https://github.com/sporkmonger/addressable/pull/515
+
+# Addressable 2.8.4 <a name="v2.8.4">
+- Restore `Addressable::IDNA.unicode_normalize_kc` as a deprecated method ([#504])
+
+[#504]: https://github.com/sporkmonger/addressable/pull/504
+
+# Addressable 2.8.3 <a name="v2.8.3">
+- Fix template expand level 2 hash support for non-string objects ([#499], [#498])
+
+[#499]: https://github.com/sporkmonger/addressable/pull/499
+[#498]: https://github.com/sporkmonger/addressable/pull/498
+
+# Addressable 2.8.2 <a name="v2.8.2">
+- Improve cache hits and JIT friendliness ([#486](https://github.com/sporkmonger/addressable/pull/486))
+- Improve code style and test coverage ([#482](https://github.com/sporkmonger/addressable/pull/482))
+- Ensure reset of deferred validation ([#481](https://github.com/sporkmonger/addressable/pull/481))
+- Resolve normalization differences between `IDNA::Native` and `IDNA::Pure` ([#408](https://github.com/sporkmonger/addressable/issues/408), [#492])
+- Remove redundant colon in `Addressable::URI::CharacterClasses::AUTHORITY` regex ([#438](https://github.com/sporkmonger/addressable/pull/438)) (accidentally reverted by [#449] merge but [added back](https://github.com/sporkmonger/addressable/pull/492#discussion_r1105125280) in [#492])
+
+[#492]: https://github.com/sporkmonger/addressable/pull/492
+
+# Addressable 2.8.1 <a name="v2.8.1">
+- refactor `Addressable::URI.normalize_path` to address linter offenses ([#430](https://github.com/sporkmonger/addressable/pull/430))
+- update gemspec to reflect supported Ruby versions ([#466], [#464], [#463])
+- compatibility w/ public_suffix 5.x ([#466], [#465], [#460])
+- fixes "invalid byte sequence in UTF-8" exception when unencoding URLs containing non UTF-8 characters ([#459](https://github.com/sporkmonger/addressable/pull/459))
+- `Ractor` compatibility ([#449])
+- use the whole string instead of a single line for template match ([#431](https://github.com/sporkmonger/addressable/pull/431))
+- force UTF-8 encoding only if needed ([#341](https://github.com/sporkmonger/addressable/pull/341))
+
+[#449]: https://github.com/sporkmonger/addressable/pull/449
+[#460]: https://github.com/sporkmonger/addressable/pull/460
+[#463]: https://github.com/sporkmonger/addressable/pull/463
+[#464]: https://github.com/sporkmonger/addressable/pull/464
+[#465]: https://github.com/sporkmonger/addressable/pull/465
+[#466]: https://github.com/sporkmonger/addressable/pull/466
+
+# Addressable 2.8.0 <a name="v2.8.0">
+- fixes ReDoS vulnerability in Addressable::Template#match
+- no longer replaces `+` with spaces in queries for non-http(s) schemes
+- fixed encoding ipv6 literals
+- the `:compacted` flag for `normalized_query` now dedupes parameters
+- fix broken `escape_component` alias
+- dropping support for Ruby 2.0 and 2.1
+- adding Ruby 3.0 compatibility for development tasks
+- drop support for `rack-mount` and remove Addressable::Template#generate
+- performance improvements
+- switch CI/CD to GitHub Actions
+
+# Addressable 2.7.0 <a name="v2.7.0">
+- added `:compacted` flag to `normalized_query`
+- `heuristic_parse` handles `mailto:` more intuitively
+- dropped explicit support for JRuby 9.0.5.0
+- compatibility w/ public_suffix 4.x
+- performance improvements
+
+# Addressable 2.6.0 <a name="v2.6.0">
+- added `tld=` method to allow assignment to the public suffix
+- most `heuristic_parse` patterns are now case-insensitive
+- `heuristic_parse` handles more `file://` URI variations
+- fixes bug in `heuristic_parse` when uri starts with digit
+- fixes bug in `request_uri=` with query strings
+- fixes template issues with `nil` and `?` operator
+- `frozen_string_literal` pragmas added
+- minor performance improvements in regexps
+- fixes to eliminate warnings
+
+# Addressable 2.5.2 <a name="v2.5.2">
+- better support for frozen string literals
+- fixed bug w/ uppercase characters in scheme
+- IDNA errors w/ emoji URLs
+- compatibility w/ public_suffix 3.x
+
+# Addressable 2.5.1 <a name="v2.5.1">
+- allow unicode normalization to be disabled for URI Template expansion
+- removed duplicate test
+
+# Addressable 2.5.0 <a name="v2.5.0">
+- dropping support for Ruby 1.9
+- adding support for Ruby 2.4 preview
+- add support for public suffixes and tld; first runtime dependency
+- hostname escaping should match RFC; underscores in hostnames no longer escaped
+- paths beginning with // and missing an authority are now considered invalid
+- validation now also takes place after setting a path
+- handle backslashes in authority more like a browser for `heuristic_parse`
+- unescaped backslashes in host now raise an `InvalidURIError`
+- `merge!`, `join!`, `omit!` and `normalize!` don't disable deferred validation
+- `heuristic_parse` now trims whitespace before parsing
+- host parts longer than 63 bytes will be ignored and not passed to libidn
+- normalized values always encoded as UTF-8
+
+# Addressable 2.4.0 <a name="v2.4.0">
+- support for 1.8.x dropped
+- double quotes in a host now raises an error
+- newlines in host will no longer get unescaped during normalization
+- stricter handling of bogus scheme values
+- stricter handling of encoded port values
+- calling `require 'addressable'` will now load both the URI and Template files
+- assigning to the `hostname` component with an `IPAddr` object is now supported
+- assigning to the `origin` component is now supported
+- fixed minor bug where an exception would be thrown for a missing ACE suffix
+- better partial expansion of URI templates
+
+# Addressable 2.3.8 <a name="v2.3.8">
+- fix warnings
+- update dependency gems
+- support for 1.8.x officially deprecated
+
+# Addressable 2.3.7 <a name="v2.3.7">
+- fix scenario in which invalid URIs don't get an exception until inspected
+- handle hostnames with two adjacent periods correctly
+- upgrade of RSpec
+
+# Addressable 2.3.6 <a name="v2.3.6">
+- normalization drops empty query string
+- better handling in template extract for missing values
+- template modifier for `'?'` now treated as optional
+- fixed issue where character class parameters were modified
+- templates can now be tested for equality
+- added `:sorted` option to normalization of query strings
+- fixed issue with normalization of hosts given in `'example.com.'` form
+
+# Addressable 2.3.5 <a name="v2.3.5">
+- added Addressable::URI#empty? method
+- Addressable::URI#hostname methods now strip square brackets from IPv6 hosts
+- compatibility with Net::HTTP in Ruby 2.0.0
+- Addressable::URI#route_from should always give relative URIs
+
+# Addressable 2.3.4 <a name="v2.3.4">
+- fixed issue with encoding altering its inputs
+- query string normalization now leaves ';' characters alone
+- FakeFS is detected before attempting to load unicode tables
+- additional testing to ensure frozen objects don't cause problems
+
+# Addressable 2.3.3 <a name="v2.3.3">
+- fixed issue with converting common primitives during template expansion
+- fixed port encoding issue
+- removed a few warnings
+- normalize should now ignore %2B in query strings
+- the IDNA logic should now be handled by libidn in Ruby 1.9
+- no template match should now result in nil instead of an empty MatchData
+- added license information to gemspec
+
+# Addressable 2.3.2 <a name="v2.3.2">
+- added Addressable::URI#default_port method
+- fixed issue with Marshalling Unicode data on Windows
+- improved heuristic parsing to better handle IPv4 addresses
+
+# Addressable 2.3.1 <a name="v2.3.1">
+- fixed missing unicode data file
+
+# Addressable 2.3.0 <a name="v2.3.0">
+- updated Addressable::Template to use RFC 6570, level 4
+- fixed compatibility problems with some versions of Ruby
+- moved unicode tables into a data file for performance reasons
+- removing support for multiple query value notations
+
+# Addressable 2.2.8 <a name="v2.2.8">
+- fixed issues with dot segment removal code
+- form encoding can now handle multiple values per key
+- updated development environment
+
+# Addressable 2.2.7 <a name="v2.2.7">
+- fixed issues related to Addressable::URI#query_values=
+- the Addressable::URI.parse method is now polymorphic
+
+# Addressable 2.2.6 <a name="v2.2.6">
+- changed the way ambiguous paths are handled
+- fixed bug with frozen URIs
+- https supported in heuristic parsing
+
+# Addressable 2.2.5 <a name="v2.2.5">
+- 'parsing' a pre-parsed URI object is now a dup operation
+- introduced conditional support for libidn
+- fixed normalization issue on ampersands in query strings
+- added additional tests around handling of query strings
+
+# Addressable 2.2.4 <a name="v2.2.4">
+- added origin support from draft-ietf-websec-origin-00
+- resolved issue with attempting to navigate below root
+- fixed bug with string splitting in query strings
+
+# Addressable 2.2.3 <a name="v2.2.3">
+- added :flat_array notation for query strings
+
+# Addressable 2.2.2 <a name="v2.2.2">
+- fixed issue with percent escaping of '+' character in query strings
+
+# Addressable 2.2.1 <a name="v2.2.1">
+- added support for application/x-www-form-urlencoded.
+
+# Addressable 2.2.0 <a name="v2.2.0">
+- added site methods
+- improved documentation
+
+# Addressable 2.1.2 <a name="v2.1.2">
+- added HTTP request URI methods
+- better handling of Windows file paths
+- validation_deferred boolean replaced with defer_validation block
+- normalization of percent-encoded paths should now be correct
+- fixed issue with constructing URIs with relative paths
+- fixed warnings
+
+# Addressable 2.1.1 <a name="v2.1.1">
+- more type checking changes
+- fixed issue with unicode normalization
+- added method to find template defaults
+- symbolic keys are now allowed in template mappings
+- numeric values and symbolic values are now allowed in template mappings
+
+# Addressable 2.1.0 <a name="v2.1.0">
+- refactored URI template support out into its own class
+- removed extract method due to being useless and unreliable
+- removed Addressable::URI.expand_template
+- removed Addressable::URI#extract_mapping
+- added partial template expansion
+- fixed minor bugs in the parse and heuristic_parse methods
+- fixed incompatibility with Ruby 1.9.1
+- fixed bottleneck in Addressable::URI#hash and Addressable::URI#to_s
+- fixed unicode normalization exception
+- updated query_values methods to better handle subscript notation
+- worked around issue with freezing URIs
+- improved specs
+
+# Addressable 2.0.2 <a name="v2.0.2">
+- fixed issue with URI template expansion
+- fixed issue with percent escaping characters 0-15
+
+# Addressable 2.0.1 <a name="v2.0.1">
+- fixed issue with query string assignment
+- fixed issue with improperly encoded components
+
+# Addressable 2.0.0 <a name="v2.0.0">
+- the initialize method now takes an options hash as its only parameter
+- added query_values method to URI class
+- completely replaced IDNA implementation with pure Ruby
+- renamed Addressable::ADDRESSABLE_VERSION to Addressable::VERSION
+- completely reworked the Rakefile
+- changed the behavior of the port method significantly
+- Addressable::URI.encode_segment, Addressable::URI.unencode_segment renamed
+- documentation is now in YARD format
+- more rigorous type checking
+- to_str method implemented, implicit conversion to Strings now allowed
+- Addressable::URI#omit method added, Addressable::URI#merge method replaced
+- updated URI Template code to match v 03 of the draft spec
+- added a bunch of new specifications
+
+# Addressable 1.0.4 <a name="v1.0.4">
+- switched to using RSpec's pending system for specs that rely on IDN
+- fixed issue with creating URIs with paths that are not prefixed with '/'
+
+# Addressable 1.0.3 <a name="v1.0.3">
+- implemented a hash method
+
+# Addressable 1.0.2 <a name="v1.0.2">
+- fixed minor bug with the extract_mapping method
+
+# Addressable 1.0.1 <a name="v1.0.1">
+- fixed minor bug with the extract_mapping method
+
+# Addressable 1.0.0 <a name="v1.0.0">
+- heuristic parse method added
+- parsing is slightly more strict
+- replaced to_h with to_hash
+- fixed routing methods
+- improved specifications
+- improved heckle rake task
+- no surviving heckle mutations
+
+# Addressable 0.1.2 <a name="v0.1.2">
+- improved normalization
+- fixed bug in joining algorithm
+- updated specifications
+
+# Addressable 0.1.1 <a name="v0.1.1">
+- updated documentation
+- added URI Template variable extraction
+
+# Addressable 0.1.0 <a name="v0.1.0">
+- initial release
+- implementation based on RFC 3986, 3987
+- support for IRIs via libidn
+- support for the URI Template draft spec
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/Gemfile b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/Gemfile
new file mode 100644
index 0000000..87cf771
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/Gemfile
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'bigdecimal' if RUBY_VERSION > '2.4'
+  gem 'rspec', '~> 3.8'
+  gem 'rspec-its', '~> 1.3'
+end
+
+group :coverage do
+  gem "coveralls", "> 0.7", require: false, platforms: :mri
+  gem "simplecov", require: false
+end
+
+group :development do
+  gem 'launchy', '~> 2.4', '>= 2.4.3'
+  gem 'redcarpet', :platform => :mri_19
+  gem 'yard'
+end
+
+group :test, :development do
+  gem 'memory_profiler'
+  gem "rake", ">= 12.3.3"
+end
+
+unless ENV["IDNA_MODE"] == "pure"
+  gem "idn-ruby", platform: :mri
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/LICENSE.txt b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/LICENSE.txt
new file mode 100644
index 0000000..ef51da2
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/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.
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/README.md b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/README.md
new file mode 100644
index 0000000..9892f61
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/README.md
@@ -0,0 +1,121 @@
+# 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 © Bob Aman</dd>
+  <dt>License</dt><dd>Apache 2.0</dd>
+</dl>
+
+[![Gem Version](https://img.shields.io/gem/dt/addressable.svg)][gem]
+[![Build Status](https://github.com/sporkmonger/addressable/workflows/CI/badge.svg)][actions]
+[![Test Coverage Status](https://img.shields.io/coveralls/sporkmonger/addressable.svg)][coveralls]
+[![Documentation Coverage Status](https://inch-ci.org/github/sporkmonger/addressable.svg?branch=master)][inch]
+
+[gem]: https://rubygems.org/gems/addressable
+[actions]: https://github.com/sporkmonger/addressable/actions
+[coveralls]: https://coveralls.io/r/sporkmonger/addressable
+[inch]: https://inch-ci.org/github/sporkmonger/addressable
+
+# Description
+
+Addressable is an alternative implementation to the URI implementation
+that is part of Ruby's standard library. It is flexible, offers heuristic
+parsing, and additionally provides extensive support for IRIs and URI templates.
+
+Addressable closely conforms to RFC 3986, RFC 3987, and RFC 6570 (level 4).
+
+# 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
+$ gem install addressable
+```
+
+You may optionally turn on native IDN support by installing libidn and the
+idn gem:
+
+```console
+$ sudo apt-get install libidn11-dev # Debian/Ubuntu
+$ brew install libidn # OS X
+$ gem install idn-ruby
+```
+
+# Semantic Versioning
+
+This project uses [Semantic Versioning](https://semver.org/). You can (and should) specify your
+dependency using a pessimistic version constraint covering the major and minor
+values:
+
+```ruby
+spec.add_dependency 'addressable', '~> 2.7'
+```
+
+If you need a specific bug fix, you can also specify minimum tiny versions
+without preventing updates to the latest minor release:
+
+```ruby
+spec.add_dependency 'addressable', '~> 2.3', '>= 2.3.7'
+```
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/Rakefile b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/Rakefile
new file mode 100644
index 0000000..46fbbd0
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/Rakefile
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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 an alternative implementation to the URI implementation that is
+part of Ruby's standard library. It is flexible, offers heuristic parsing, and
+additionally provides extensive support for IRIs and URI templates.
+TEXT
+
+PKG_FILES = FileList[
+    "data/**/*",
+    "lib/**/*.rb",
+    "spec/**/*.rb",
+    "tasks/**/*.rake",
+    "addressable.gemspec",
+    "CHANGELOG.md",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+]
+
+task :default => "spec"
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/addressable.gemspec b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/addressable.gemspec
new file mode 100644
index 0000000..bb1f2fa
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/addressable.gemspec
@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+# stub: addressable 2.8.7 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "addressable".freeze
+  s.version = "2.8.7".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "changelog_uri" => "https://github.com/sporkmonger/addressable/blob/main/CHANGELOG.md#v2.8.7" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Bob Aman".freeze]
+  s.date = "2024-06-21"
+  s.description = "Addressable is an alternative implementation to the URI implementation that is\npart of Ruby's standard library. It is flexible, offers heuristic parsing, and\nadditionally provides extensive support for IRIs and URI templates.\n".freeze
+  s.email = "bob@sporkmonger.com".freeze
+  s.extra_rdoc_files = ["README.md".freeze]
+  s.files = ["CHANGELOG.md".freeze, "Gemfile".freeze, "LICENSE.txt".freeze, "README.md".freeze, "Rakefile".freeze, "addressable.gemspec".freeze, "data/unicode.data".freeze, "lib/addressable.rb".freeze, "lib/addressable/idna.rb".freeze, "lib/addressable/idna/native.rb".freeze, "lib/addressable/idna/pure.rb".freeze, "lib/addressable/template.rb".freeze, "lib/addressable/uri.rb".freeze, "lib/addressable/version.rb".freeze, "spec/addressable/idna_spec.rb".freeze, "spec/addressable/net_http_compat_spec.rb".freeze, "spec/addressable/security_spec.rb".freeze, "spec/addressable/template_spec.rb".freeze, "spec/addressable/uri_spec.rb".freeze, "spec/spec_helper.rb".freeze, "tasks/clobber.rake".freeze, "tasks/gem.rake".freeze, "tasks/git.rake".freeze, "tasks/metrics.rake".freeze, "tasks/profile.rake".freeze, "tasks/rspec.rake".freeze, "tasks/yard.rake".freeze]
+  s.homepage = "https://github.com/sporkmonger/addressable".freeze
+  s.licenses = ["Apache-2.0".freeze]
+  s.rdoc_options = ["--main".freeze, "README.md".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.2".freeze)
+  s.rubygems_version = "3.5.11".freeze
+  s.summary = "URI Implementation".freeze
+
+  s.specification_version = 4
+
+  s.add_runtime_dependency(%q<public_suffix>.freeze, [">= 2.0.2".freeze, "< 7.0".freeze])
+  s.add_development_dependency(%q<bundler>.freeze, [">= 1.0".freeze, "< 3.0".freeze])
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/data/unicode.data b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/data/unicode.data
new file mode 100644
index 0000000..cdfc224
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/data/unicode.data
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable.rb
new file mode 100644
index 0000000..b4e98b6
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable.rb
@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'addressable/uri'
+require 'addressable/template'
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/idna.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/idna.rb
new file mode 100644
index 0000000..2dbd393
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/idna.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (C) 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.
+#++
+
+
+begin
+  require "addressable/idna/native"
+rescue LoadError
+  # libidn or the idn gem was not available, fall back on a pure-Ruby
+  # implementation...
+  require "addressable/idna/pure"
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/idna/native.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/idna/native.rb
new file mode 100644
index 0000000..a718364
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/idna/native.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (C) 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
+
+    class << self
+      # @deprecated Use {String#unicode_normalize(:nfkc)} instead
+      def unicode_normalize_kc(value)
+        value.to_s.unicode_normalize(:nfkc)
+      end
+
+      extend Gem::Deprecate
+      deprecate :unicode_normalize_kc, "String#unicode_normalize(:nfkc)", 2023, 4
+    end
+
+    def self.to_ascii(value)
+      value.to_s.split('.', -1).map do |segment|
+        if segment.size > 0 && segment.size < 64
+          IDN::Idna.toASCII(segment, IDN::Idna::ALLOW_UNASSIGNED)
+        elsif segment.size >= 64
+          segment
+        else
+          ''
+        end
+      end.join('.')
+    end
+
+    def self.to_unicode(value)
+      value.to_s.split('.', -1).map do |segment|
+        if segment.size > 0 && segment.size < 64
+          IDN::Idna.toUnicode(segment, IDN::Idna::ALLOW_UNASSIGNED)
+        elsif segment.size >= 64
+          segment
+        else
+          ''
+        end
+      end.join('.')
+    end
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/idna/pure.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/idna/pure.rb
new file mode 100644
index 0000000..3d6ffba
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/idna/pure.rb
@@ -0,0 +1,505 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (C) 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.force_encoding(Encoding::UTF_8).unicode_normalize(:nfkc)
+      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(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}(.+)/
+          begin
+            punycode_decode(part[/^#{ACE_PREFIX}(.+)/, 1])
+          rescue Addressable::IDNA::PunycodeBadInput
+            # toUnicode is explicitly defined as never-fails by the spec
+            part
+          end
+        else
+          part
+        end
+      end
+      output = parts.join('.')
+      if output.respond_to?(:force_encoding)
+        output.force_encoding(Encoding::UTF_8)
+      end
+      output
+    end
+
+    class << self
+      # @deprecated Use {String#unicode_normalize(:nfkc)} instead
+      def unicode_normalize_kc(value)
+        value.to_s.unicode_normalize(:nfkc)
+      end
+
+      extend Gem::Deprecate
+      deprecate :unicode_normalize_kc, "String#unicode_normalize(:nfkc)", 2023, 4
+    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
+    private_class_method :unicode_downcase
+
+    def self.lookup_unicode_lowercase(codepoint)
+      codepoint_data = UNICODE_DATA[codepoint]
+      (codepoint_data ?
+        (codepoint_data[UNICODE_DATA_LOWERCASE] || codepoint) :
+        codepoint)
+    end
+    private_class_method :lookup_unicode_lowercase
+
+    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 = {}
+    UNICODE_DATA.each do |codepoint, 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
+    private_class_method :punycode_encode
+
+    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
+    private_class_method :punycode_decode
+
+    def self.punycode_basic?(codepoint)
+      codepoint < 0x80
+    end
+    private_class_method :punycode_basic?
+
+    def self.punycode_delimiter?(codepoint)
+      codepoint == PUNYCODE_DELIMITER
+    end
+    private_class_method :punycode_delimiter?
+
+    def self.punycode_encode_digit(d)
+      d + 22 + 75 * ((d < 26) ? 1 : 0)
+    end
+    private_class_method :punycode_encode_digit
+
+    # 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
+    private_class_method :punycode_decode_digit
+
+    # 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
+    private_class_method :punycode_adapt
+  end
+  # :startdoc:
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/template.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/template.rb
new file mode 100644
index 0000000..08556d9
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/template.rb
@@ -0,0 +1,1029 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (C) 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 "addressable/version"
+require "addressable/uri"
+
+module Addressable
+  ##
+  # This is an implementation of a URI template based on
+  # RFC 6570 (http://tools.ietf.org/html/rfc6570).
+  class Template
+    # Constants used throughout the template code.
+    anything =
+      Addressable::URI::CharacterClasses::RESERVED +
+      Addressable::URI::CharacterClasses::UNRESERVED
+
+
+    variable_char_class =
+      Addressable::URI::CharacterClasses::ALPHA +
+      Addressable::URI::CharacterClasses::DIGIT + '_'
+
+    var_char =
+      "(?>(?:[#{variable_char_class}]|%[a-fA-F0-9][a-fA-F0-9])+)"
+    RESERVED =
+      "(?:[#{anything}]|%[a-fA-F0-9][a-fA-F0-9])"
+    UNRESERVED =
+      "(?:[#{
+        Addressable::URI::CharacterClasses::UNRESERVED
+      }]|%[a-fA-F0-9][a-fA-F0-9])"
+    variable =
+      "(?:#{var_char}(?:\\.?#{var_char})*)"
+    varspec =
+      "(?:(#{variable})(\\*|:\\d+)?)"
+    VARNAME =
+      /^#{variable}$/
+    VARSPEC =
+      /^#{varspec}$/
+    VARIABLE_LIST =
+      /^#{varspec}(?:,#{varspec})*$/
+    operator =
+      "+#./;?&=,!@|"
+    EXPRESSION =
+      /\{([#{operator}])?(#{varspec}(?:,#{varspec})*)\}/
+
+
+    LEADERS = {
+      '?' => '?',
+      '/' => '/',
+      '#' => '#',
+      '.' => '.',
+      ';' => ';',
+      '&' => '&'
+    }
+    JOINERS = {
+      '?' => '&',
+      '.' => '.',
+      ';' => ';',
+      '&' => '&',
+      '/' => '/'
+    }
+
+    ##
+    # Raised if an invalid template value is supplied.
+    class InvalidTemplateValueError < StandardError
+    end
+
+    ##
+    # Raised if an invalid template operator is used in a pattern.
+    class InvalidTemplateOperatorError < StandardError
+    end
+
+    ##
+    # Raised if an invalid template operator is used in a pattern.
+    class TemplateOperatorAbortedError < StandardError
+    end
+
+    ##
+    # This class represents the data that is extracted when a Template
+    # is matched against a URI.
+    class MatchData
+      ##
+      # Creates a new MatchData object.
+      # MatchData objects should never be instantiated directly.
+      #
+      # @param [Addressable::URI] uri
+      #   The URI that the template was matched against.
+      def initialize(uri, template, mapping)
+        @uri = uri.dup.freeze
+        @template = template
+        @mapping = mapping.dup.freeze
+      end
+
+      ##
+      # @return [Addressable::URI]
+      #   The URI that the Template was matched against.
+      attr_reader :uri
+
+      ##
+      # @return [Addressable::Template]
+      #   The Template used for the match.
+      attr_reader :template
+
+      ##
+      # @return [Hash]
+      #   The mapping that resulted from the match.
+      #   Note that this mapping does not include keys or values for
+      #   variables that appear in the Template, but are not present
+      #   in the URI.
+      attr_reader :mapping
+
+      ##
+      # @return [Array]
+      #   The list of variables that were present in the Template.
+      #   Note that this list will include variables which do not appear
+      #   in the mapping because they were not present in URI.
+      def variables
+        self.template.variables
+      end
+      alias_method :keys, :variables
+      alias_method :names, :variables
+
+      ##
+      # @return [Array]
+      #   The list of values that were captured by the Template.
+      #   Note that this list will include nils for any variables which
+      #   were in the Template, but did not appear in the URI.
+      def values
+        @values ||= self.variables.inject([]) do |accu, key|
+          accu << self.mapping[key]
+          accu
+        end
+      end
+      alias_method :captures, :values
+
+      ##
+      # Accesses captured values by name or by index.
+      #
+      # @param [String, Symbol, Fixnum] key
+      #   Capture index or name. Note that when accessing by with index
+      #   of 0, the full URI will be returned. The intention is to mimic
+      #   the ::MatchData#[] behavior.
+      #
+      # @param [#to_int, nil] len
+      #   If provided, an array of values will be returned with the given
+      #   parameter used as length.
+      #
+      # @return [Array, String, nil]
+      #   The captured value corresponding to the index or name. If the
+      #   value was not provided or the key is unknown, nil will be
+      #   returned.
+      #
+      #   If the second parameter is provided, an array of that length will
+      #   be returned instead.
+      def [](key, len = nil)
+        if len
+          to_a[key, len]
+        elsif String === key or Symbol === key
+          mapping[key.to_s]
+        else
+          to_a[key]
+        end
+      end
+
+      ##
+      # @return [Array]
+      #   Array with the matched URI as first element followed by the captured
+      #   values.
+      def to_a
+        [to_s, *values]
+      end
+
+      ##
+      # @return [String]
+      #   The matched URI as String.
+      def to_s
+        uri.to_s
+      end
+      alias_method :string, :to_s
+
+      # Returns multiple captured values at once.
+      #
+      # @param [String, Symbol, Fixnum] *indexes
+      #   Indices of the captures to be returned
+      #
+      # @return [Array]
+      #   Values corresponding to given indices.
+      #
+      # @see Addressable::Template::MatchData#[]
+      def values_at(*indexes)
+        indexes.map { |i| self[i] }
+      end
+
+      ##
+      # Returns a <tt>String</tt> representation of the MatchData's state.
+      #
+      # @return [String] The MatchData's state, as a <tt>String</tt>.
+      def inspect
+        sprintf("#<%s:%#0x RESULT:%s>",
+          self.class.to_s, self.object_id, self.mapping.inspect)
+      end
+
+      ##
+      # Dummy method for code expecting a ::MatchData instance
+      #
+      # @return [String] An empty string.
+      def pre_match
+        ""
+      end
+      alias_method :post_match, :pre_match
+    end
+
+    ##
+    # Creates a new <tt>Addressable::Template</tt> object.
+    #
+    # @param [#to_str] pattern The URI Template pattern.
+    #
+    # @return [Addressable::Template] The initialized Template object.
+    def initialize(pattern)
+      if !pattern.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{pattern.class} into String."
+      end
+      @pattern = pattern.to_str.dup.freeze
+    end
+
+    ##
+    # Freeze URI, initializing instance variables.
+    #
+    # @return [Addressable::URI] The frozen URI object.
+    def freeze
+      self.variables
+      self.variable_defaults
+      self.named_captures
+      super
+    end
+
+    ##
+    # @return [String] The Template object's pattern.
+    attr_reader :pattern
+
+    ##
+    # Returns a <tt>String</tt> representation of the Template object's state.
+    #
+    # @return [String] The Template object's state, as a <tt>String</tt>.
+    def inspect
+      sprintf("#<%s:%#0x PATTERN:%s>",
+        self.class.to_s, self.object_id, self.pattern)
+    end
+
+    ##
+    # Returns <code>true</code> if the Template objects are equal. This method
+    # does NOT normalize either Template before doing the comparison.
+    #
+    # @param [Object] template The Template to compare.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the Templates are equivalent, <code>false</code>
+    #   otherwise.
+    def ==(template)
+      return false unless template.kind_of?(Template)
+      return self.pattern == template.pattern
+    end
+
+    ##
+    # Addressable::Template makes no distinction between `==` and `eql?`.
+    #
+    # @see #==
+    alias_method :eql?, :==
+
+    ##
+    # Extracts a mapping from the URI using a URI Template pattern.
+    #
+    # @param [Addressable::URI, #to_str] uri
+    #   The URI to extract from.
+    #
+    # @param [#restore, #match] processor
+    #   A template processor object may optionally be supplied.
+    #
+    #   The object should respond to either the <tt>restore</tt> or
+    #   <tt>match</tt> messages or both. The <tt>restore</tt> method should
+    #   take two parameters: `[String] name` and `[String] value`.
+    #   The <tt>restore</tt> method should reverse any transformations that
+    #   have been performed on the value to ensure a valid URI.
+    #   The <tt>match</tt> method should take a single
+    #   parameter: `[String] name`.  The <tt>match</tt> method should return
+    #   a <tt>String</tt> containing a regular expression capture group for
+    #   matching on that particular variable. The default value is `".*?"`.
+    #   The <tt>match</tt> method has no effect on multivariate operator
+    #   expansions.
+    #
+    # @return [Hash, NilClass]
+    #   The <tt>Hash</tt> mapping that was extracted from the URI, or
+    #   <tt>nil</tt> if the URI didn't match the template.
+    #
+    # @example
+    #   class ExampleProcessor
+    #     def self.restore(name, value)
+    #       return value.gsub(/\+/, " ") if name == "query"
+    #       return value
+    #     end
+    #
+    #     def self.match(name)
+    #       return ".*?" if name == "first"
+    #       return ".*"
+    #     end
+    #   end
+    #
+    #   uri = Addressable::URI.parse(
+    #     "http://example.com/search/an+example+search+query/"
+    #   )
+    #   Addressable::Template.new(
+    #     "http://example.com/search/{query}/"
+    #   ).extract(uri, ExampleProcessor)
+    #   #=> {"query" => "an example search query"}
+    #
+    #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
+    #   Addressable::Template.new(
+    #     "http://example.com/{first}/{second}/"
+    #   ).extract(uri, ExampleProcessor)
+    #   #=> {"first" => "a", "second" => "b/c"}
+    #
+    #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
+    #   Addressable::Template.new(
+    #     "http://example.com/{first}/{-list|/|second}/"
+    #   ).extract(uri)
+    #   #=> {"first" => "a", "second" => ["b", "c"]}
+    def extract(uri, processor=nil)
+      match_data = self.match(uri, processor)
+      return (match_data ? match_data.mapping : nil)
+    end
+
+    ##
+    # Extracts match data from the URI using a URI Template pattern.
+    #
+    # @param [Addressable::URI, #to_str] uri
+    #   The URI to extract from.
+    #
+    # @param [#restore, #match] processor
+    #   A template processor object may optionally be supplied.
+    #
+    #   The object should respond to either the <tt>restore</tt> or
+    #   <tt>match</tt> messages or both. The <tt>restore</tt> method should
+    #   take two parameters: `[String] name` and `[String] value`.
+    #   The <tt>restore</tt> method should reverse any transformations that
+    #   have been performed on the value to ensure a valid URI.
+    #   The <tt>match</tt> method should take a single
+    #   parameter: `[String] name`. The <tt>match</tt> method should return
+    #   a <tt>String</tt> containing a regular expression capture group for
+    #   matching on that particular variable. The default value is `".*?"`.
+    #   The <tt>match</tt> method has no effect on multivariate operator
+    #   expansions.
+    #
+    # @return [Hash, NilClass]
+    #   The <tt>Hash</tt> mapping that was extracted from the URI, or
+    #   <tt>nil</tt> if the URI didn't match the template.
+    #
+    # @example
+    #   class ExampleProcessor
+    #     def self.restore(name, value)
+    #       return value.gsub(/\+/, " ") if name == "query"
+    #       return value
+    #     end
+    #
+    #     def self.match(name)
+    #       return ".*?" if name == "first"
+    #       return ".*"
+    #     end
+    #   end
+    #
+    #   uri = Addressable::URI.parse(
+    #     "http://example.com/search/an+example+search+query/"
+    #   )
+    #   match = Addressable::Template.new(
+    #     "http://example.com/search/{query}/"
+    #   ).match(uri, ExampleProcessor)
+    #   match.variables
+    #   #=> ["query"]
+    #   match.captures
+    #   #=> ["an example search query"]
+    #
+    #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
+    #   match = Addressable::Template.new(
+    #     "http://example.com/{first}/{+second}/"
+    #   ).match(uri, ExampleProcessor)
+    #   match.variables
+    #   #=> ["first", "second"]
+    #   match.captures
+    #   #=> ["a", "b/c"]
+    #
+    #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
+    #   match = Addressable::Template.new(
+    #     "http://example.com/{first}{/second*}/"
+    #   ).match(uri)
+    #   match.variables
+    #   #=> ["first", "second"]
+    #   match.captures
+    #   #=> ["a", ["b", "c"]]
+    def match(uri, processor=nil)
+      uri = Addressable::URI.parse(uri) unless uri.is_a?(Addressable::URI)
+      mapping = {}
+
+      # First, we need to process the pattern, and extract the values.
+      expansions, expansion_regexp =
+        parse_template_pattern(pattern, processor)
+
+      return nil unless uri.to_str.match(expansion_regexp)
+      unparsed_values = uri.to_str.scan(expansion_regexp).flatten
+
+      if uri.to_str == pattern
+        return Addressable::Template::MatchData.new(uri, self, mapping)
+      elsif expansions.size > 0
+        index = 0
+        expansions.each do |expansion|
+          _, operator, varlist = *expansion.match(EXPRESSION)
+          varlist.split(',').each do |varspec|
+            _, name, modifier = *varspec.match(VARSPEC)
+            mapping[name] ||= nil
+            case operator
+            when nil, '+', '#', '/', '.'
+              unparsed_value = unparsed_values[index]
+              name = varspec[VARSPEC, 1]
+              value = unparsed_value
+              value = value.split(JOINERS[operator]) if value && modifier == '*'
+            when ';', '?', '&'
+              if modifier == '*'
+                if unparsed_values[index]
+                  value = unparsed_values[index].split(JOINERS[operator])
+                  value = value.inject({}) do |acc, v|
+                    key, val = v.split('=')
+                    val = "" if val.nil?
+                    acc[key] = val
+                    acc
+                  end
+                end
+              else
+                if (unparsed_values[index])
+                  name, value = unparsed_values[index].split('=')
+                  value = "" if value.nil?
+                end
+              end
+            end
+            if processor != nil && processor.respond_to?(:restore)
+              value = processor.restore(name, value)
+            end
+            if processor == nil
+              if value.is_a?(Hash)
+                value = value.inject({}){|acc, (k, v)|
+                  acc[Addressable::URI.unencode_component(k)] =
+                    Addressable::URI.unencode_component(v)
+                  acc
+                }
+              elsif value.is_a?(Array)
+                value = value.map{|v| Addressable::URI.unencode_component(v) }
+              else
+                value = Addressable::URI.unencode_component(value)
+              end
+            end
+            if !mapping.has_key?(name) || mapping[name].nil?
+              # Doesn't exist, set to value (even if value is nil)
+              mapping[name] = value
+            end
+            index = index + 1
+          end
+        end
+        return Addressable::Template::MatchData.new(uri, self, mapping)
+      else
+        return nil
+      end
+    end
+
+    ##
+    # Expands a URI template into another URI template.
+    #
+    # @param [Hash] mapping The mapping that corresponds to the pattern.
+    # @param [#validate, #transform] processor
+    #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
+    #
+    # The object should respond to either the <tt>validate</tt> or
+    # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
+    # <tt>transform</tt> methods should take two parameters: <tt>name</tt> and
+    # <tt>value</tt>. The <tt>validate</tt> method should return <tt>true</tt>
+    # or <tt>false</tt>; <tt>true</tt> if the value of the variable is valid,
+    # <tt>false</tt> otherwise. An <tt>InvalidTemplateValueError</tt>
+    # exception will be raised if the value is invalid. The <tt>transform</tt>
+    # method should return the transformed variable value as a <tt>String</tt>.
+    # If a <tt>transform</tt> method is used, the value will not be percent
+    # encoded automatically. Unicode normalization will be performed both
+    # before and after sending the value to the transform method.
+    #
+    # @return [Addressable::Template] The partially expanded URI template.
+    #
+    # @example
+    #   Addressable::Template.new(
+    #     "http://example.com/{one}/{two}/"
+    #   ).partial_expand({"one" => "1"}).pattern
+    #   #=> "http://example.com/1/{two}/"
+    #
+    #   Addressable::Template.new(
+    #     "http://example.com/{?one,two}/"
+    #   ).partial_expand({"one" => "1"}).pattern
+    #   #=> "http://example.com/?one=1{&two}/"
+    #
+    #   Addressable::Template.new(
+    #     "http://example.com/{?one,two,three}/"
+    #   ).partial_expand({"one" => "1", "three" => 3}).pattern
+    #   #=> "http://example.com/?one=1{&two}&three=3"
+    def partial_expand(mapping, processor=nil, normalize_values=true)
+      result = self.pattern.dup
+      mapping = normalize_keys(mapping)
+      result.gsub!( EXPRESSION ) do |capture|
+        transform_partial_capture(mapping, capture, processor, normalize_values)
+      end
+      return Addressable::Template.new(result)
+    end
+
+    ##
+    # Expands a URI template into a full URI.
+    #
+    # @param [Hash] mapping The mapping that corresponds to the pattern.
+    # @param [#validate, #transform] processor
+    #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
+    #
+    # The object should respond to either the <tt>validate</tt> or
+    # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
+    # <tt>transform</tt> methods should take two parameters: <tt>name</tt> and
+    # <tt>value</tt>. The <tt>validate</tt> method should return <tt>true</tt>
+    # or <tt>false</tt>; <tt>true</tt> if the value of the variable is valid,
+    # <tt>false</tt> otherwise. An <tt>InvalidTemplateValueError</tt>
+    # exception will be raised if the value is invalid. The <tt>transform</tt>
+    # method should return the transformed variable value as a <tt>String</tt>.
+    # If a <tt>transform</tt> method is used, the value will not be percent
+    # encoded automatically. Unicode normalization will be performed both
+    # before and after sending the value to the transform method.
+    #
+    # @return [Addressable::URI] The expanded URI template.
+    #
+    # @example
+    #   class ExampleProcessor
+    #     def self.validate(name, value)
+    #       return !!(value =~ /^[\w ]+$/) if name == "query"
+    #       return true
+    #     end
+    #
+    #     def self.transform(name, value)
+    #       return value.gsub(/ /, "+") if name == "query"
+    #       return value
+    #     end
+    #   end
+    #
+    #   Addressable::Template.new(
+    #     "http://example.com/search/{query}/"
+    #   ).expand(
+    #     {"query" => "an example search query"},
+    #     ExampleProcessor
+    #   ).to_str
+    #   #=> "http://example.com/search/an+example+search+query/"
+    #
+    #   Addressable::Template.new(
+    #     "http://example.com/search/{query}/"
+    #   ).expand(
+    #     {"query" => "an example search query"}
+    #   ).to_str
+    #   #=> "http://example.com/search/an%20example%20search%20query/"
+    #
+    #   Addressable::Template.new(
+    #     "http://example.com/search/{query}/"
+    #   ).expand(
+    #     {"query" => "bogus!"},
+    #     ExampleProcessor
+    #   ).to_str
+    #   #=> Addressable::Template::InvalidTemplateValueError
+    def expand(mapping, processor=nil, normalize_values=true)
+      result = self.pattern.dup
+      mapping = normalize_keys(mapping)
+      result.gsub!( EXPRESSION ) do |capture|
+        transform_capture(mapping, capture, processor, normalize_values)
+      end
+      return Addressable::URI.parse(result)
+    end
+
+    ##
+    # Returns an Array of variables used within the template pattern.
+    # The variables are listed in the Array in the order they appear within
+    # the pattern.  Multiple occurrences of a variable within a pattern are
+    # not represented in this Array.
+    #
+    # @return [Array] The variables present in the template's pattern.
+    def variables
+      @variables ||= ordered_variable_defaults.map { |var, val| var }.uniq
+    end
+    alias_method :keys, :variables
+    alias_method :names, :variables
+
+    ##
+    # Returns a mapping of variables to their default values specified
+    # in the template. Variables without defaults are not returned.
+    #
+    # @return [Hash] Mapping of template variables to their defaults
+    def variable_defaults
+      @variable_defaults ||=
+        Hash[*ordered_variable_defaults.reject { |k, v| v.nil? }.flatten]
+    end
+
+    ##
+    # Coerces a template into a `Regexp` object. This regular expression will
+    # behave very similarly to the actual template, and should match the same
+    # URI values, but it cannot fully handle, for example, values that would
+    # extract to an `Array`.
+    #
+    # @return [Regexp] A regular expression which should match the template.
+    def to_regexp
+      _, source = parse_template_pattern(pattern)
+      Regexp.new(source)
+    end
+
+    ##
+    # Returns the source of the coerced `Regexp`.
+    #
+    # @return [String] The source of the `Regexp` given by {#to_regexp}.
+    #
+    # @api private
+    def source
+      self.to_regexp.source
+    end
+
+    ##
+    # Returns the named captures of the coerced `Regexp`.
+    #
+    # @return [Hash] The named captures of the `Regexp` given by {#to_regexp}.
+    #
+    # @api private
+    def named_captures
+      self.to_regexp.named_captures
+    end
+
+  private
+    def ordered_variable_defaults
+      @ordered_variable_defaults ||= begin
+        expansions, _ = parse_template_pattern(pattern)
+        expansions.flat_map do |capture|
+          _, _, varlist = *capture.match(EXPRESSION)
+          varlist.split(',').map do |varspec|
+            varspec[VARSPEC, 1]
+          end
+        end
+      end
+    end
+
+
+    ##
+    # Loops through each capture and expands any values available in mapping
+    #
+    # @param [Hash] mapping
+    #   Set of keys to expand
+    # @param [String] capture
+    #   The expression to expand
+    # @param [#validate, #transform] processor
+    #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
+    #
+    # The object should respond to either the <tt>validate</tt> or
+    # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
+    # <tt>transform</tt> methods should take two parameters: <tt>name</tt> and
+    # <tt>value</tt>. The <tt>validate</tt> method should return <tt>true</tt>
+    # or <tt>false</tt>; <tt>true</tt> if the value of the variable is valid,
+    # <tt>false</tt> otherwise. An <tt>InvalidTemplateValueError</tt> exception
+    # will be raised if the value is invalid. The <tt>transform</tt> method
+    # should return the transformed variable value as a <tt>String</tt>. If a
+    # <tt>transform</tt> method is used, the value will not be percent encoded
+    # automatically. Unicode normalization will be performed both before and
+    # after sending the value to the transform method.
+    #
+    # @return [String] The expanded expression
+    def transform_partial_capture(mapping, capture, processor = nil,
+                                  normalize_values = true)
+      _, operator, varlist = *capture.match(EXPRESSION)
+
+      vars = varlist.split(",")
+
+      if operator == "?"
+        # partial expansion of form style query variables sometimes requires a
+        # slight reordering of the variables to produce a valid url.
+        first_to_expand = vars.find { |varspec|
+          _, name, _ =  *varspec.match(VARSPEC)
+          mapping.key?(name) && !mapping[name].nil?
+        }
+
+        vars = [first_to_expand] + vars.reject {|varspec| varspec == first_to_expand}  if first_to_expand
+      end
+
+      vars.
+        inject("".dup) do |acc, varspec|
+          _, name, _ =  *varspec.match(VARSPEC)
+          next_val = if mapping.key? name
+                       transform_capture(mapping, "{#{operator}#{varspec}}",
+                                         processor, normalize_values)
+                     else
+                       "{#{operator}#{varspec}}"
+                     end
+          # If we've already expanded at least one '?' operator with non-empty
+          # value, change to '&'
+          operator = "&" if (operator == "?") && (next_val != "")
+          acc << next_val
+      end
+    end
+
+    ##
+    # Transforms a mapped value so that values can be substituted into the
+    # template.
+    #
+    # @param [Hash] mapping The mapping to replace captures
+    # @param [String] capture
+    #   The expression to replace
+    # @param [#validate, #transform] processor
+    #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
+    #
+    #
+    # The object should respond to either the <tt>validate</tt> or
+    # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
+    # <tt>transform</tt> methods should take two parameters: <tt>name</tt> and
+    # <tt>value</tt>. The <tt>validate</tt> method should return <tt>true</tt>
+    # or <tt>false</tt>; <tt>true</tt> if the value of the variable is valid,
+    # <tt>false</tt> otherwise. An <tt>InvalidTemplateValueError</tt> exception
+    # will be raised if the value is invalid. The <tt>transform</tt> method
+    # should return the transformed variable value as a <tt>String</tt>. If a
+    # <tt>transform</tt> method is used, the value will not be percent encoded
+    # automatically. Unicode normalization will be performed both before and
+    # after sending the value to the transform method.
+    #
+    # @return [String] The expanded expression
+    def transform_capture(mapping, capture, processor=nil,
+                          normalize_values=true)
+      _, operator, varlist = *capture.match(EXPRESSION)
+      return_value = varlist.split(',').inject([]) do |acc, varspec|
+        _, name, modifier = *varspec.match(VARSPEC)
+        value = mapping[name]
+        unless value == nil || value == {}
+          allow_reserved = %w(+ #).include?(operator)
+          # Common primitives where the .to_s output is well-defined
+          if Numeric === value || Symbol === value ||
+              value == true || value == false
+            value = value.to_s
+          end
+          length = modifier.gsub(':', '').to_i if modifier =~ /^:\d+/
+
+          unless (Hash === value) ||
+            value.respond_to?(:to_ary) || value.respond_to?(:to_str)
+            raise TypeError,
+              "Can't convert #{value.class} into String or Array."
+          end
+
+          value = normalize_value(value) if normalize_values
+
+          if processor == nil || !processor.respond_to?(:transform)
+            # Handle percent escaping
+            if allow_reserved
+              encode_map =
+                Addressable::URI::CharacterClasses::RESERVED +
+                Addressable::URI::CharacterClasses::UNRESERVED
+            else
+              encode_map = Addressable::URI::CharacterClasses::UNRESERVED
+            end
+            if value.kind_of?(Array)
+              transformed_value = value.map do |val|
+                if length
+                  Addressable::URI.encode_component(val[0...length], encode_map)
+                else
+                  Addressable::URI.encode_component(val, encode_map)
+                end
+              end
+              unless modifier == "*"
+                transformed_value = transformed_value.join(',')
+              end
+            elsif value.kind_of?(Hash)
+              transformed_value = value.map do |key, val|
+                if modifier == "*"
+                  "#{
+                    Addressable::URI.encode_component( key, encode_map)
+                  }=#{
+                    Addressable::URI.encode_component( val, encode_map)
+                  }"
+                else
+                  "#{
+                    Addressable::URI.encode_component( key, encode_map)
+                  },#{
+                    Addressable::URI.encode_component( val, encode_map)
+                  }"
+                end
+              end
+              unless modifier == "*"
+                transformed_value = transformed_value.join(',')
+              end
+            else
+              if length
+                transformed_value = Addressable::URI.encode_component(
+                  value[0...length], encode_map)
+              else
+                transformed_value = Addressable::URI.encode_component(
+                  value, encode_map)
+              end
+            end
+          end
+
+          # Process, if we've got a processor
+          if processor != nil
+            if processor.respond_to?(:validate)
+              if !processor.validate(name, value)
+                display_value = value.kind_of?(Array) ? value.inspect : value
+                raise InvalidTemplateValueError,
+                  "#{name}=#{display_value} is an invalid template value."
+              end
+            end
+            if processor.respond_to?(:transform)
+              transformed_value = processor.transform(name, value)
+              if normalize_values
+                transformed_value = normalize_value(transformed_value)
+              end
+            end
+          end
+          acc << [name, transformed_value]
+        end
+        acc
+      end
+      return "" if return_value.empty?
+      join_values(operator, return_value)
+    end
+
+    ##
+    # Takes a set of values, and joins them together based on the
+    # operator.
+    #
+    # @param [String, Nil] operator One of the operators from the set
+    #   (?,&,+,#,;,/,.), or nil if there wasn't one.
+    # @param [Array] return_value
+    #   The set of return values (as [variable_name, value] tuples) that will
+    #   be joined together.
+    #
+    # @return [String] The transformed mapped value
+    def join_values(operator, return_value)
+      leader = LEADERS.fetch(operator, '')
+      joiner = JOINERS.fetch(operator, ',')
+      case operator
+      when '&', '?'
+        leader + return_value.map{|k,v|
+          if v.is_a?(Array) && v.first =~ /=/
+            v.join(joiner)
+          elsif v.is_a?(Array)
+            v.map{|inner_value| "#{k}=#{inner_value}"}.join(joiner)
+          else
+            "#{k}=#{v}"
+          end
+        }.join(joiner)
+      when ';'
+        return_value.map{|k,v|
+          if v.is_a?(Array) && v.first =~ /=/
+            ';' + v.join(";")
+          elsif v.is_a?(Array)
+            ';' + v.map{|inner_value| "#{k}=#{inner_value}"}.join(";")
+          else
+            v && v != '' ?  ";#{k}=#{v}" : ";#{k}"
+          end
+        }.join
+      else
+        leader + return_value.map{|k,v| v}.join(joiner)
+      end
+    end
+
+    ##
+    # Takes a set of values, and joins them together based on the
+    # operator.
+    #
+    # @param [Hash, Array, String] value
+    #   Normalizes unicode keys and values with String#unicode_normalize (NFC)
+    #
+    # @return [Hash, Array, String] The normalized values
+    def normalize_value(value)
+      # Handle unicode normalization
+      if value.respond_to?(:to_ary)
+        value.to_ary.map! { |val| normalize_value(val) }
+      elsif value.kind_of?(Hash)
+        value = value.inject({}) { |acc, (k, v)|
+          acc[normalize_value(k)] = normalize_value(v)
+          acc
+        }
+      else
+        value = value.to_s if !value.kind_of?(String)
+        if value.encoding != Encoding::UTF_8
+          value = value.dup.force_encoding(Encoding::UTF_8)
+        end
+        value = value.unicode_normalize(:nfc)
+      end
+      value
+    end
+
+    ##
+    # Generates a hash with string keys
+    #
+    # @param [Hash] mapping A mapping hash to normalize
+    #
+    # @return [Hash]
+    #   A hash with stringified keys
+    def normalize_keys(mapping)
+      return mapping.inject({}) do |accu, pair|
+        name, value = pair
+        if Symbol === name
+          name = name.to_s
+        elsif name.respond_to?(:to_str)
+          name = name.to_str
+        else
+          raise TypeError,
+            "Can't convert #{name.class} into String."
+        end
+        accu[name] = value
+        accu
+      end
+    end
+
+    ##
+    # Generates the <tt>Regexp</tt> that parses a template pattern. Memoizes the
+    # value if template processor not set (processors may not be deterministic)
+    #
+    # @param [String] pattern The URI template pattern.
+    # @param [#match] processor The template processor to use.
+    #
+    # @return [Array, Regexp]
+    #   An array of expansion variables nad a regular expression which may be
+    #   used to parse a template pattern
+    def parse_template_pattern(pattern, processor = nil)
+      if processor.nil? && pattern == @pattern
+        @cached_template_parse ||=
+          parse_new_template_pattern(pattern, processor)
+      else
+        parse_new_template_pattern(pattern, processor)
+      end
+    end
+
+    ##
+    # Generates the <tt>Regexp</tt> that parses a template pattern.
+    #
+    # @param [String] pattern The URI template pattern.
+    # @param [#match] processor The template processor to use.
+    #
+    # @return [Array, Regexp]
+    #   An array of expansion variables nad a regular expression which may be
+    #   used to parse a template pattern
+    def parse_new_template_pattern(pattern, processor = nil)
+      # Escape the pattern. The two gsubs restore the escaped curly braces
+      # back to their original form. Basically, escape everything that isn't
+      # within an expansion.
+      escaped_pattern = Regexp.escape(
+        pattern
+      ).gsub(/\\\{(.*?)\\\}/) do |escaped|
+        escaped.gsub(/\\(.)/, "\\1")
+      end
+
+      expansions = []
+
+      # Create a regular expression that captures the values of the
+      # variables in the URI.
+      regexp_string = escaped_pattern.gsub( EXPRESSION ) do |expansion|
+
+        expansions << expansion
+        _, operator, varlist = *expansion.match(EXPRESSION)
+        leader = Regexp.escape(LEADERS.fetch(operator, ''))
+        joiner = Regexp.escape(JOINERS.fetch(operator, ','))
+        combined = varlist.split(',').map do |varspec|
+          _, name, modifier = *varspec.match(VARSPEC)
+
+          result = processor && processor.respond_to?(:match) ? processor.match(name) : nil
+          if result
+            "(?<#{name}>#{ result })"
+          else
+            group = case operator
+            when '+'
+              "#{ RESERVED }*?"
+            when '#'
+              "#{ RESERVED }*?"
+            when '/'
+              "#{ UNRESERVED }*?"
+            when '.'
+              "#{ UNRESERVED.gsub('\.', '') }*?"
+            when ';'
+              "#{ UNRESERVED }*=?#{ UNRESERVED }*?"
+            when '?'
+              "#{ UNRESERVED }*=#{ UNRESERVED }*?"
+            when '&'
+              "#{ UNRESERVED }*=#{ UNRESERVED }*?"
+            else
+              "#{ UNRESERVED }*?"
+            end
+            if modifier == '*'
+              "(?<#{name}>#{group}(?:#{joiner}?#{group})*)?"
+            else
+              "(?<#{name}>#{group})?"
+            end
+          end
+        end.join("#{joiner}?")
+        "(?:|#{leader}#{combined})"
+      end
+
+      # Ensure that the regular expression matches the whole URI.
+      regexp_string = "\\A#{regexp_string}\\z"
+      return expansions, Regexp.new(regexp_string)
+    end
+
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/uri.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/uri.rb
new file mode 100644
index 0000000..40b80cf
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/uri.rb
@@ -0,0 +1,2602 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (C) 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 "addressable/version"
+require "addressable/idna"
+require "public_suffix"
+
+##
+# Addressable is a library for processing links and URIs.
+module Addressable
+  ##
+  # This is an implementation of a URI parser based on
+  # <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>,
+  # <a href="http://www.ietf.org/rfc/rfc3987.txt">RFC 3987</a>.
+  class URI
+    ##
+    # Raised if something other than a uri is supplied.
+    class InvalidURIError < StandardError
+    end
+
+    ##
+    # Container for the character classes specified in
+    # <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    #
+    # Note: Concatenated and interpolated `String`s are not affected by the
+    #       `frozen_string_literal` directive and must be frozen explicitly.
+    #
+    #       Interpolated `String`s *were* frozen this way before Ruby 3.0:
+    #       https://bugs.ruby-lang.org/issues/17104
+    module CharacterClasses
+      ALPHA = "a-zA-Z"
+      DIGIT = "0-9"
+      GEN_DELIMS = "\\:\\/\\?\\#\\[\\]\\@"
+      SUB_DELIMS = "\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\="
+      RESERVED = (GEN_DELIMS + SUB_DELIMS).freeze
+      UNRESERVED = (ALPHA + DIGIT + "\\-\\.\\_\\~").freeze
+      RESERVED_AND_UNRESERVED = RESERVED + UNRESERVED
+      PCHAR = (UNRESERVED + SUB_DELIMS + "\\:\\@").freeze
+      SCHEME = (ALPHA + DIGIT + "\\-\\+\\.").freeze
+      HOST = (UNRESERVED + SUB_DELIMS + "\\[\\:\\]").freeze
+      AUTHORITY = (PCHAR + "\\[\\]").freeze
+      PATH = (PCHAR + "\\/").freeze
+      QUERY = (PCHAR + "\\/\\?").freeze
+      FRAGMENT = (PCHAR + "\\/\\?").freeze
+    end
+
+    module NormalizeCharacterClasses
+      HOST = /[^#{CharacterClasses::HOST}]/
+      UNRESERVED = /[^#{CharacterClasses::UNRESERVED}]/
+      PCHAR = /[^#{CharacterClasses::PCHAR}]/
+      SCHEME = /[^#{CharacterClasses::SCHEME}]/
+      FRAGMENT = /[^#{CharacterClasses::FRAGMENT}]/
+      QUERY = %r{[^a-zA-Z0-9\-\.\_\~\!\$\'\(\)\*\+\,\=\:\@\/\?%]|%(?!2B|2b)}
+    end
+
+    module CharacterClassesRegexps
+      AUTHORITY = /[^#{CharacterClasses::AUTHORITY}]/
+      FRAGMENT = /[^#{CharacterClasses::FRAGMENT}]/
+      HOST = /[^#{CharacterClasses::HOST}]/
+      PATH = /[^#{CharacterClasses::PATH}]/
+      QUERY = /[^#{CharacterClasses::QUERY}]/
+      RESERVED = /[^#{CharacterClasses::RESERVED}]/
+      RESERVED_AND_UNRESERVED = /[^#{CharacterClasses::RESERVED_AND_UNRESERVED}]/
+      SCHEME = /[^#{CharacterClasses::SCHEME}]/
+      UNRESERVED = /[^#{CharacterClasses::UNRESERVED}]/
+    end
+
+    SLASH = '/'
+    EMPTY_STR = ''
+
+    URIREGEX = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/
+
+    PORT_MAPPING = {
+      "http" => 80,
+      "https" => 443,
+      "ftp" => 21,
+      "tftp" => 69,
+      "sftp" => 22,
+      "ssh" => 22,
+      "svn+ssh" => 22,
+      "telnet" => 23,
+      "nntp" => 119,
+      "gopher" => 70,
+      "wais" => 210,
+      "ldap" => 389,
+      "prospero" => 1525
+    }.freeze
+
+    ##
+    # Returns a URI object based on the parsed string.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI string to parse.
+    #   No parsing is performed if the object is already an
+    #   <code>Addressable::URI</code>.
+    #
+    # @return [Addressable::URI] The parsed URI.
+    def self.parse(uri)
+      # If we were given nil, return nil.
+      return nil unless uri
+      # If a URI object is passed, just return itself.
+      return uri.dup if uri.kind_of?(self)
+
+      # If a URI object of the Ruby standard library variety is passed,
+      # convert it to a string, then parse the string.
+      # We do the check this way because we don't want to accidentally
+      # cause a missing constant exception to be thrown.
+      if uri.class.name =~ /^URI\b/
+        uri = uri.to_s
+      end
+
+      # Otherwise, convert to a String
+      begin
+        uri = uri.to_str
+      rescue TypeError, NoMethodError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end unless uri.is_a?(String)
+
+      # This Regexp supplied as an example in RFC 3986, and it works great.
+      scan = uri.scan(URIREGEX)
+      fragments = scan[0]
+      scheme = fragments[1]
+      authority = fragments[3]
+      path = fragments[4]
+      query = fragments[6]
+      fragment = fragments[8]
+      user = nil
+      password = nil
+      host = nil
+      port = nil
+      if authority != nil
+        # The Regexp above doesn't split apart the authority.
+        userinfo = authority[/^([^\[\]]*)@/, 1]
+        if userinfo != nil
+          user = userinfo.strip[/^([^:]*):?/, 1]
+          password = userinfo.strip[/:(.*)$/, 1]
+        end
+
+        host = authority.sub(
+          /^([^\[\]]*)@/, EMPTY_STR
+        ).sub(
+          /:([^:@\[\]]*?)$/, EMPTY_STR
+        )
+
+        port = authority[/:([^:@\[\]]*?)$/, 1]
+        port = nil if port == EMPTY_STR
+      end
+
+      return new(
+        :scheme => scheme,
+        :user => user,
+        :password => password,
+        :host => host,
+        :port => port,
+        :path => path,
+        :query => query,
+        :fragment => fragment
+      )
+    end
+
+    ##
+    # Converts an input to a URI. The input does not have to be a valid
+    # URI — the method will use heuristics to guess what URI was intended.
+    # This is not standards-compliant, merely user-friendly.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI string to parse.
+    #   No parsing is performed if the object is already an
+    #   <code>Addressable::URI</code>.
+    # @param [Hash] hints
+    #   A <code>Hash</code> of hints to the heuristic parser.
+    #   Defaults to <code>{:scheme => "http"}</code>.
+    #
+    # @return [Addressable::URI] The parsed URI.
+    def self.heuristic_parse(uri, hints={})
+      # If we were given nil, return nil.
+      return nil unless uri
+      # If a URI object is passed, just return itself.
+      return uri.dup if uri.kind_of?(self)
+
+      # If a URI object of the Ruby standard library variety is passed,
+      # convert it to a string, then parse the string.
+      # We do the check this way because we don't want to accidentally
+      # cause a missing constant exception to be thrown.
+      if uri.class.name =~ /^URI\b/
+        uri = uri.to_s
+      end
+
+      unless uri.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end
+      # Otherwise, convert to a String
+      uri = uri.to_str.dup.strip
+      hints = {
+        :scheme => "http"
+      }.merge(hints)
+      case uri
+      when /^http:\//i
+        uri.sub!(/^http:\/+/i, "http://")
+      when /^https:\//i
+        uri.sub!(/^https:\/+/i, "https://")
+      when /^feed:\/+http:\//i
+        uri.sub!(/^feed:\/+http:\/+/i, "feed:http://")
+      when /^feed:\//i
+        uri.sub!(/^feed:\/+/i, "feed://")
+      when %r[^file:/{4}]i
+        uri.sub!(%r[^file:/+]i, "file:////")
+      when %r[^file://localhost/]i
+        uri.sub!(%r[^file://localhost/+]i, "file:///")
+      when %r[^file:/+]i
+        uri.sub!(%r[^file:/+]i, "file:///")
+      when /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+        uri.sub!(/^/, hints[:scheme] + "://")
+      when /\A\d+\..*:\d+\z/
+        uri = "#{hints[:scheme]}://#{uri}"
+      end
+      match = uri.match(URIREGEX)
+      fragments = match.captures
+      authority = fragments[3]
+      if authority && authority.length > 0
+        new_authority = authority.tr("\\", "/").gsub(" ", "%20")
+        # NOTE: We want offset 4, not 3!
+        offset = match.offset(4)
+        uri = uri.dup
+        uri[offset[0]...offset[1]] = new_authority
+      end
+      parsed = self.parse(uri)
+      if parsed.scheme =~ /^[^\/?#\.]+\.[^\/?#]+$/
+        parsed = self.parse(hints[:scheme] + "://" + uri)
+      end
+      if parsed.path.include?(".")
+        if parsed.path[/\b@\b/]
+          parsed.scheme = "mailto" unless parsed.scheme
+        elsif new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
+          parsed.defer_validation do
+            new_path = parsed.path.sub(
+              Regexp.new("^" + Regexp.escape(new_host)), EMPTY_STR)
+            parsed.host = new_host
+            parsed.path = new_path
+            parsed.scheme = hints[:scheme] unless parsed.scheme
+          end
+        end
+      end
+      return parsed
+    end
+
+    ##
+    # Converts a path to a file scheme URI. If the path supplied is
+    # relative, it will be returned as a relative URI. If the path supplied
+    # is actually a non-file URI, it will parse the URI as if it had been
+    # parsed with <code>Addressable::URI.parse</code>. Handles all of the
+    # various Microsoft-specific formats for specifying paths.
+    #
+    # @param [String, Addressable::URI, #to_str] path
+    #   Typically a <code>String</code> path to a file or directory, but
+    #   will return a sensible return value if an absolute URI is supplied
+    #   instead.
+    #
+    # @return [Addressable::URI]
+    #   The parsed file scheme URI or the original URI if some other URI
+    #   scheme was provided.
+    #
+    # @example
+    #   base = Addressable::URI.convert_path("/absolute/path/")
+    #   uri = Addressable::URI.convert_path("relative/path")
+    #   (base + uri).to_s
+    #   #=> "file:///absolute/path/relative/path"
+    #
+    #   Addressable::URI.convert_path(
+    #     "c:\\windows\\My Documents 100%20\\foo.txt"
+    #   ).to_s
+    #   #=> "file:///c:/windows/My%20Documents%20100%20/foo.txt"
+    #
+    #   Addressable::URI.convert_path("http://example.com/").to_s
+    #   #=> "http://example.com/"
+    def self.convert_path(path)
+      # If we were given nil, return nil.
+      return nil unless path
+      # If a URI object is passed, just return itself.
+      return path if path.kind_of?(self)
+      unless path.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{path.class} into String."
+      end
+      # Otherwise, convert to a String
+      path = path.to_str.strip
+
+      path.sub!(/^file:\/?\/?/, EMPTY_STR) if path =~ /^file:\/?\/?/
+      path = SLASH + path if path =~ /^([a-zA-Z])[\|:]/
+      uri = self.parse(path)
+
+      if uri.scheme == nil
+        # Adjust windows-style uris
+        uri.path.sub!(/^\/?([a-zA-Z])[\|:][\\\/]/) do
+          "/#{$1.downcase}:/"
+        end
+        uri.path.tr!("\\", SLASH)
+        if File.exist?(uri.path) &&
+            File.stat(uri.path).directory?
+          uri.path.chomp!(SLASH)
+          uri.path = uri.path + '/'
+        end
+
+        # If the path is absolute, set the scheme and host.
+        if uri.path.start_with?(SLASH)
+          uri.scheme = "file"
+          uri.host = EMPTY_STR
+        end
+        uri.normalize!
+      end
+
+      return uri
+    end
+
+    ##
+    # Joins several URIs together.
+    #
+    # @param [String, Addressable::URI, #to_str] *uris
+    #   The URIs to join.
+    #
+    # @return [Addressable::URI] The joined URI.
+    #
+    # @example
+    #   base = "http://example.com/"
+    #   uri = Addressable::URI.parse("relative/path")
+    #   Addressable::URI.join(base, uri)
+    #   #=> #<Addressable::URI:0xcab390 URI:http://example.com/relative/path>
+    def self.join(*uris)
+      uri_objects = uris.collect do |uri|
+        unless uri.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{uri.class} into String."
+        end
+        uri.kind_of?(self) ? uri : self.parse(uri.to_str)
+      end
+      result = uri_objects.shift.dup
+      uri_objects.each do |uri|
+        result.join!(uri)
+      end
+      return result
+    end
+
+    ##
+    # Tables used to optimize encoding operations in `self.encode_component`
+    # and `self.normalize_component`
+    SEQUENCE_ENCODING_TABLE = (0..255).map do |byte|
+      format("%02x", byte).freeze
+    end.freeze
+
+    SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = (0..255).map do |byte|
+      format("%%%02X", byte).freeze
+    end.freeze
+
+    ##
+    # Percent encodes a URI component.
+    #
+    # @param [String, #to_str] component The URI component to encode.
+    #
+    # @param [String, Regexp] character_class
+    #   The characters which are not percent encoded. If a <code>String</code>
+    #   is passed, the <code>String</code> must be formatted as a regular
+    #   expression character class. (Do not include the surrounding square
+    #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
+    #   everything but the letters 'b' through 'z' and the numbers '0' through
+    #  '9' to be percent encoded. If a <code>Regexp</code> is passed, the
+    #   value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A set of
+    #   useful <code>String</code> values may be found in the
+    #   <code>Addressable::URI::CharacterClasses</code> module. The default
+    #   value is the reserved plus unreserved character classes specified in
+    #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    #
+    # @param [Regexp] upcase_encoded
+    #   A string of characters that may already be percent encoded, and whose
+    #   encodings should be upcased. This allows normalization of percent
+    #   encodings for characters not included in the
+    #   <code>character_class</code>.
+    #
+    # @return [String] The encoded component.
+    #
+    # @example
+    #   Addressable::URI.encode_component("simple/example", "b-zB-Z0-9")
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.encode_component("simple/example", /[^b-zB-Z0-9]/)
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.encode_component(
+    #     "simple/example", Addressable::URI::CharacterClasses::UNRESERVED
+    #   )
+    #   => "simple%2Fexample"
+    def self.encode_component(component, character_class=CharacterClassesRegexps::RESERVED_AND_UNRESERVED, upcase_encoded='')
+      return nil if component.nil?
+
+      begin
+        if component.kind_of?(Symbol) ||
+            component.kind_of?(Numeric) ||
+            component.kind_of?(TrueClass) ||
+            component.kind_of?(FalseClass)
+          component = component.to_s
+        else
+          component = component.to_str
+        end
+      rescue TypeError, NoMethodError
+        raise TypeError, "Can't convert #{component.class} into String."
+      end if !component.is_a? String
+
+      if ![String, Regexp].include?(character_class.class)
+        raise TypeError,
+          "Expected String or Regexp, got #{character_class.inspect}"
+      end
+      if character_class.kind_of?(String)
+        character_class = /[^#{character_class}]/
+      end
+      # We can't perform regexps on invalid UTF sequences, but
+      # here we need to, so switch to ASCII.
+      component = component.dup
+      component.force_encoding(Encoding::ASCII_8BIT)
+      # Avoiding gsub! because there are edge cases with frozen strings
+      component = component.gsub(character_class) do |char|
+        SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE[char.ord]
+      end
+      if upcase_encoded.length > 0
+        upcase_encoded_chars = upcase_encoded.bytes.map do |byte|
+          SEQUENCE_ENCODING_TABLE[byte]
+        end
+        component = component.gsub(/%(#{upcase_encoded_chars.join('|')})/,
+                                   &:upcase)
+      end
+
+      return component
+    end
+
+    class << self
+      alias_method :escape_component, :encode_component
+    end
+
+    ##
+    # Unencodes any percent encoded characters within a URI component.
+    # This method may be used for unencoding either components or full URIs,
+    # however, it is recommended to use the <code>unencode_component</code>
+    # alias when unencoding components.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI or component to unencode.
+    #
+    # @param [Class] return_type
+    #   The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    #
+    # @param [String] leave_encoded
+    #   A string of characters to leave encoded. If a percent encoded character
+    #   in this list is encountered then it will remain percent encoded.
+    #
+    # @return [String, Addressable::URI]
+    #   The unencoded component or URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    def self.unencode(uri, return_type=String, leave_encoded='')
+      return nil if uri.nil?
+
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end if !uri.is_a? String
+      if ![String, ::Addressable::URI].include?(return_type)
+        raise TypeError,
+          "Expected Class (String or Addressable::URI), " +
+          "got #{return_type.inspect}"
+      end
+
+      result = uri.gsub(/%[0-9a-f]{2}/i) do |sequence|
+        c = sequence[1..3].to_i(16).chr
+        c.force_encoding(sequence.encoding)
+        leave_encoded.include?(c) ? sequence : c
+      end
+
+      result.force_encoding(Encoding::UTF_8)
+      if return_type == String
+        return result
+      elsif return_type == ::Addressable::URI
+        return ::Addressable::URI.parse(result)
+      end
+    end
+
+    class << self
+      alias_method :unescape, :unencode
+      alias_method :unencode_component, :unencode
+      alias_method :unescape_component, :unencode
+    end
+
+
+    ##
+    # Normalizes the encoding of a URI component.
+    #
+    # @param [String, #to_str] component The URI component to encode.
+    #
+    # @param [String, Regexp] character_class
+    #   The characters which are not percent encoded. If a <code>String</code>
+    #   is passed, the <code>String</code> must be formatted as a regular
+    #   expression character class. (Do not include the surrounding square
+    #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
+    #   everything but the letters 'b' through 'z' and the numbers '0'
+    #   through '9' to be percent encoded. If a <code>Regexp</code> is passed,
+    #   the value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A
+    #   set of useful <code>String</code> values may be found in the
+    #   <code>Addressable::URI::CharacterClasses</code> module. The default
+    #   value is the reserved plus unreserved character classes specified in
+    #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    #
+    # @param [String] leave_encoded
+    #   When <code>character_class</code> is a <code>String</code> then
+    #   <code>leave_encoded</code> is a string of characters that should remain
+    #   percent encoded while normalizing the component; if they appear percent
+    #   encoded in the original component, then they will be upcased ("%2f"
+    #   normalized to "%2F") but otherwise left alone.
+    #
+    # @return [String] The normalized component.
+    #
+    # @example
+    #   Addressable::URI.normalize_component("simpl%65/%65xampl%65", "b-zB-Z")
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.normalize_component(
+    #     "simpl%65/%65xampl%65", /[^b-zB-Z]/
+    #   )
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.normalize_component(
+    #     "simpl%65/%65xampl%65",
+    #     Addressable::URI::CharacterClasses::UNRESERVED
+    #   )
+    #   => "simple%2Fexample"
+    #   Addressable::URI.normalize_component(
+    #     "one%20two%2fthree%26four",
+    #     "0-9a-zA-Z &/",
+    #     "/"
+    #   )
+    #   => "one two%2Fthree&four"
+    def self.normalize_component(component, character_class=
+        CharacterClassesRegexps::RESERVED_AND_UNRESERVED,
+        leave_encoded='')
+      return nil if component.nil?
+
+      begin
+        component = component.to_str
+      rescue NoMethodError, TypeError
+        raise TypeError, "Can't convert #{component.class} into String."
+      end if !component.is_a? String
+
+      if ![String, Regexp].include?(character_class.class)
+        raise TypeError,
+          "Expected String or Regexp, got #{character_class.inspect}"
+      end
+      if character_class.kind_of?(String)
+        leave_re = if leave_encoded.length > 0
+          character_class = "#{character_class}%" unless character_class.include?('%')
+
+          bytes = leave_encoded.bytes
+          leave_encoded_pattern = bytes.map { |b| SEQUENCE_ENCODING_TABLE[b] }.join('|')
+          "|%(?!#{leave_encoded_pattern}|#{leave_encoded_pattern.upcase})"
+        end
+
+        character_class = if leave_re
+                            /[^#{character_class}]#{leave_re}/
+                          else
+                            /[^#{character_class}]/
+                          end
+      end
+      # We can't perform regexps on invalid UTF sequences, but
+      # here we need to, so switch to ASCII.
+      component = component.dup
+      component.force_encoding(Encoding::ASCII_8BIT)
+      unencoded = self.unencode_component(component, String, leave_encoded)
+      begin
+        encoded = self.encode_component(
+          unencoded.unicode_normalize(:nfc),
+          character_class,
+          leave_encoded
+        )
+      rescue ArgumentError
+        encoded = self.encode_component(unencoded)
+      end
+      encoded.force_encoding(Encoding::UTF_8)
+      return encoded
+    end
+
+    ##
+    # Percent encodes any special characters in the URI.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI to encode.
+    #
+    # @param [Class] return_type
+    #   The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    #
+    # @return [String, Addressable::URI]
+    #   The encoded URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    def self.encode(uri, return_type=String)
+      return nil if uri.nil?
+
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end if !uri.is_a? String
+
+      if ![String, ::Addressable::URI].include?(return_type)
+        raise TypeError,
+          "Expected Class (String or Addressable::URI), " +
+          "got #{return_type.inspect}"
+      end
+      uri_object = uri.kind_of?(self) ? uri : self.parse(uri)
+      encoded_uri = Addressable::URI.new(
+        :scheme => self.encode_component(uri_object.scheme,
+          Addressable::URI::CharacterClassesRegexps::SCHEME),
+        :authority => self.encode_component(uri_object.authority,
+          Addressable::URI::CharacterClassesRegexps::AUTHORITY),
+        :path => self.encode_component(uri_object.path,
+          Addressable::URI::CharacterClassesRegexps::PATH),
+        :query => self.encode_component(uri_object.query,
+          Addressable::URI::CharacterClassesRegexps::QUERY),
+        :fragment => self.encode_component(uri_object.fragment,
+          Addressable::URI::CharacterClassesRegexps::FRAGMENT)
+      )
+      if return_type == String
+        return encoded_uri.to_s
+      elsif return_type == ::Addressable::URI
+        return encoded_uri
+      end
+    end
+
+    class << self
+      alias_method :escape, :encode
+    end
+
+    ##
+    # Normalizes the encoding of a URI. Characters within a hostname are
+    # not percent encoded to allow for internationalized domain names.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI to encode.
+    #
+    # @param [Class] return_type
+    #   The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    #
+    # @return [String, Addressable::URI]
+    #   The encoded URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    def self.normalized_encode(uri, return_type=String)
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end if !uri.is_a? String
+
+      if ![String, ::Addressable::URI].include?(return_type)
+        raise TypeError,
+          "Expected Class (String or Addressable::URI), " +
+          "got #{return_type.inspect}"
+      end
+      uri_object = uri.kind_of?(self) ? uri : self.parse(uri)
+      components = {
+        :scheme => self.unencode_component(uri_object.scheme),
+        :user => self.unencode_component(uri_object.user),
+        :password => self.unencode_component(uri_object.password),
+        :host => self.unencode_component(uri_object.host),
+        :port => (uri_object.port.nil? ? nil : uri_object.port.to_s),
+        :path => self.unencode_component(uri_object.path),
+        :query => self.unencode_component(uri_object.query),
+        :fragment => self.unencode_component(uri_object.fragment)
+      }
+      components.each do |key, value|
+        if value != nil
+          begin
+            components[key] = value.to_str.unicode_normalize(:nfc)
+          rescue ArgumentError
+            # Likely a malformed UTF-8 character, skip unicode normalization
+            components[key] = value.to_str
+          end
+        end
+      end
+      encoded_uri = Addressable::URI.new(
+        :scheme => self.encode_component(components[:scheme],
+          Addressable::URI::CharacterClassesRegexps::SCHEME),
+        :user => self.encode_component(components[:user],
+          Addressable::URI::CharacterClassesRegexps::UNRESERVED),
+        :password => self.encode_component(components[:password],
+          Addressable::URI::CharacterClassesRegexps::UNRESERVED),
+        :host => components[:host],
+        :port => components[:port],
+        :path => self.encode_component(components[:path],
+          Addressable::URI::CharacterClassesRegexps::PATH),
+        :query => self.encode_component(components[:query],
+          Addressable::URI::CharacterClassesRegexps::QUERY),
+        :fragment => self.encode_component(components[:fragment],
+          Addressable::URI::CharacterClassesRegexps::FRAGMENT)
+      )
+      if return_type == String
+        return encoded_uri.to_s
+      elsif return_type == ::Addressable::URI
+        return encoded_uri
+      end
+    end
+
+    ##
+    # Encodes a set of key/value pairs according to the rules for the
+    # <code>application/x-www-form-urlencoded</code> MIME type.
+    #
+    # @param [#to_hash, #to_ary] form_values
+    #   The form values to encode.
+    #
+    # @param [TrueClass, FalseClass] sort
+    #   Sort the key/value pairs prior to encoding.
+    #   Defaults to <code>false</code>.
+    #
+    # @return [String]
+    #   The encoded value.
+    def self.form_encode(form_values, sort=false)
+      if form_values.respond_to?(:to_hash)
+        form_values = form_values.to_hash.to_a
+      elsif form_values.respond_to?(:to_ary)
+        form_values = form_values.to_ary
+      else
+        raise TypeError, "Can't convert #{form_values.class} into Array."
+      end
+
+      form_values = form_values.inject([]) do |accu, (key, value)|
+        if value.kind_of?(Array)
+          value.each do |v|
+            accu << [key.to_s, v.to_s]
+          end
+        else
+          accu << [key.to_s, value.to_s]
+        end
+        accu
+      end
+
+      if sort
+        # Useful for OAuth and optimizing caching systems
+        form_values = form_values.sort
+      end
+      escaped_form_values = form_values.map do |(key, value)|
+        # Line breaks are CRLF pairs
+        [
+          self.encode_component(
+            key.gsub(/(\r\n|\n|\r)/, "\r\n"),
+            CharacterClassesRegexps::UNRESERVED
+          ).gsub("%20", "+"),
+          self.encode_component(
+            value.gsub(/(\r\n|\n|\r)/, "\r\n"),
+            CharacterClassesRegexps::UNRESERVED
+          ).gsub("%20", "+")
+        ]
+      end
+      return escaped_form_values.map do |(key, value)|
+        "#{key}=#{value}"
+      end.join("&")
+    end
+
+    ##
+    # Decodes a <code>String</code> according to the rules for the
+    # <code>application/x-www-form-urlencoded</code> MIME type.
+    #
+    # @param [String, #to_str] encoded_value
+    #   The form values to decode.
+    #
+    # @return [Array]
+    #   The decoded values.
+    #   This is not a <code>Hash</code> because of the possibility for
+    #   duplicate keys.
+    def self.form_unencode(encoded_value)
+      if !encoded_value.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{encoded_value.class} into String."
+      end
+      encoded_value = encoded_value.to_str
+      split_values = encoded_value.split("&").map do |pair|
+        pair.split("=", 2)
+      end
+      return split_values.map do |(key, value)|
+        [
+          key ? self.unencode_component(
+            key.gsub("+", "%20")).gsub(/(\r\n|\n|\r)/, "\n") : nil,
+          value ? (self.unencode_component(
+            value.gsub("+", "%20")).gsub(/(\r\n|\n|\r)/, "\n")) : nil
+        ]
+      end
+    end
+
+    ##
+    # Creates a new uri object from component parts.
+    #
+    # @option [String, #to_str] scheme The scheme component.
+    # @option [String, #to_str] user The user component.
+    # @option [String, #to_str] password The password component.
+    # @option [String, #to_str] userinfo
+    #   The userinfo component. If this is supplied, the user and password
+    #   components must be omitted.
+    # @option [String, #to_str] host The host component.
+    # @option [String, #to_str] port The port component.
+    # @option [String, #to_str] authority
+    #   The authority component. If this is supplied, the user, password,
+    #   userinfo, host, and port components must be omitted.
+    # @option [String, #to_str] path The path component.
+    # @option [String, #to_str] query The query component.
+    # @option [String, #to_str] fragment The fragment component.
+    #
+    # @return [Addressable::URI] The constructed URI object.
+    def initialize(options={})
+      if options.has_key?(:authority)
+        if (options.keys & [:userinfo, :user, :password, :host, :port]).any?
+          raise ArgumentError,
+            "Cannot specify both an authority and any of the components " +
+            "within the authority."
+        end
+      end
+      if options.has_key?(:userinfo)
+        if (options.keys & [:user, :password]).any?
+          raise ArgumentError,
+            "Cannot specify both a userinfo and either the user or password."
+        end
+      end
+
+      reset_ivs
+
+      defer_validation do
+        # Bunch of crazy logic required because of the composite components
+        # like userinfo and authority.
+        self.scheme = options[:scheme] if options[:scheme]
+        self.user = options[:user] if options[:user]
+        self.password = options[:password] if options[:password]
+        self.userinfo = options[:userinfo] if options[:userinfo]
+        self.host = options[:host] if options[:host]
+        self.port = options[:port] if options[:port]
+        self.authority = options[:authority] if options[:authority]
+        self.path = options[:path] if options[:path]
+        self.query = options[:query] if options[:query]
+        self.query_values = options[:query_values] if options[:query_values]
+        self.fragment = options[:fragment] if options[:fragment]
+      end
+
+      to_s # force path validation
+    end
+
+    ##
+    # Freeze URI, initializing instance variables.
+    #
+    # @return [Addressable::URI] The frozen URI object.
+    def freeze
+      self.normalized_scheme
+      self.normalized_user
+      self.normalized_password
+      self.normalized_userinfo
+      self.normalized_host
+      self.normalized_port
+      self.normalized_authority
+      self.normalized_site
+      self.normalized_path
+      self.normalized_query
+      self.normalized_fragment
+      self.hash
+      super
+    end
+
+    ##
+    # The scheme component for this URI.
+    #
+    # @return [String] The scheme component.
+    attr_reader :scheme
+
+    ##
+    # The scheme component for this URI, normalized.
+    #
+    # @return [String] The scheme component, normalized.
+    def normalized_scheme
+      return nil unless self.scheme
+      if @normalized_scheme == NONE
+        @normalized_scheme = if self.scheme =~ /^\s*ssh\+svn\s*$/i
+          "svn+ssh".dup
+        else
+          Addressable::URI.normalize_component(
+            self.scheme.strip.downcase,
+            Addressable::URI::NormalizeCharacterClasses::SCHEME
+          )
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_scheme)
+      @normalized_scheme
+    end
+
+    ##
+    # Sets the scheme component for this URI.
+    #
+    # @param [String, #to_str] new_scheme The new scheme component.
+    def scheme=(new_scheme)
+      if new_scheme && !new_scheme.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_scheme.class} into String."
+      elsif new_scheme
+        new_scheme = new_scheme.to_str
+      end
+      if new_scheme && new_scheme !~ /\A[a-z][a-z0-9\.\+\-]*\z/i
+        raise InvalidURIError, "Invalid scheme format: '#{new_scheme}'"
+      end
+      @scheme = new_scheme
+      @scheme = nil if @scheme.to_s.strip.empty?
+
+      # Reset dependent values
+      @normalized_scheme = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The user component for this URI.
+    #
+    # @return [String] The user component.
+    attr_reader :user
+
+    ##
+    # The user component for this URI, normalized.
+    #
+    # @return [String] The user component, normalized.
+    def normalized_user
+      return nil unless self.user
+      return @normalized_user unless @normalized_user == NONE
+      @normalized_user = begin
+        if normalized_scheme =~ /https?/ && self.user.strip.empty? &&
+            (!self.password || self.password.strip.empty?)
+          nil
+        else
+          Addressable::URI.normalize_component(
+            self.user.strip,
+            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
+          )
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_user)
+      @normalized_user
+    end
+
+    ##
+    # Sets the user component for this URI.
+    #
+    # @param [String, #to_str] new_user The new user component.
+    def user=(new_user)
+      if new_user && !new_user.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_user.class} into String."
+      end
+      @user = new_user ? new_user.to_str : nil
+
+      # You can't have a nil user with a non-nil password
+      if password != nil
+        @user = EMPTY_STR unless user
+      end
+
+      # Reset dependent values
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      @authority = nil
+      @normalized_user = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The password component for this URI.
+    #
+    # @return [String] The password component.
+    attr_reader :password
+
+    ##
+    # The password component for this URI, normalized.
+    #
+    # @return [String] The password component, normalized.
+    def normalized_password
+      return nil unless self.password
+      return @normalized_password unless @normalized_password == NONE
+      @normalized_password = begin
+        if self.normalized_scheme =~ /https?/ && self.password.strip.empty? &&
+            (!self.user || self.user.strip.empty?)
+          nil
+        else
+          Addressable::URI.normalize_component(
+            self.password.strip,
+            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
+          )
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_password)
+      @normalized_password
+    end
+
+    ##
+    # Sets the password component for this URI.
+    #
+    # @param [String, #to_str] new_password The new password component.
+    def password=(new_password)
+      if new_password && !new_password.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_password.class} into String."
+      end
+      @password = new_password ? new_password.to_str : nil
+
+      # You can't have a nil user with a non-nil password
+      if @password != nil
+        self.user = EMPTY_STR if user.nil?
+      end
+
+      # Reset dependent values
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      @authority = nil
+      @normalized_password = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The userinfo component for this URI.
+    # Combines the user and password components.
+    #
+    # @return [String] The userinfo component.
+    def userinfo
+      current_user = self.user
+      current_password = self.password
+      (current_user || current_password) && @userinfo ||= begin
+        if current_user && current_password
+          "#{current_user}:#{current_password}"
+        elsif current_user && !current_password
+          "#{current_user}"
+        end
+      end
+    end
+
+    ##
+    # The userinfo component for this URI, normalized.
+    #
+    # @return [String] The userinfo component, normalized.
+    def normalized_userinfo
+      return nil unless self.userinfo
+      return @normalized_userinfo unless @normalized_userinfo == NONE
+      @normalized_userinfo = begin
+        current_user = self.normalized_user
+        current_password = self.normalized_password
+        if !current_user && !current_password
+          nil
+        elsif current_user && current_password
+          "#{current_user}:#{current_password}".dup
+        elsif current_user && !current_password
+          "#{current_user}".dup
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_userinfo)
+      @normalized_userinfo
+    end
+
+    ##
+    # Sets the userinfo component for this URI.
+    #
+    # @param [String, #to_str] new_userinfo The new userinfo component.
+    def userinfo=(new_userinfo)
+      if new_userinfo && !new_userinfo.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_userinfo.class} into String."
+      end
+      new_user, new_password = if new_userinfo
+        [
+          new_userinfo.to_str.strip[/^(.*):/, 1],
+          new_userinfo.to_str.strip[/:(.*)$/, 1]
+        ]
+      else
+        [nil, nil]
+      end
+
+      # Password assigned first to ensure validity in case of nil
+      self.password = new_password
+      self.user = new_user
+
+      # Reset dependent values
+      @authority = nil
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The host component for this URI.
+    #
+    # @return [String] The host component.
+    attr_reader :host
+
+    ##
+    # The host component for this URI, normalized.
+    #
+    # @return [String] The host component, normalized.
+    def normalized_host
+      return nil unless self.host
+
+      @normalized_host ||= begin
+        if !self.host.strip.empty?
+          result = ::Addressable::IDNA.to_ascii(
+            URI.unencode_component(self.host.strip.downcase)
+          )
+          if result =~ /[^\.]\.$/
+            # Single trailing dots are unnecessary.
+            result = result[0...-1]
+          end
+          result = Addressable::URI.normalize_component(
+            result,
+            NormalizeCharacterClasses::HOST
+          )
+          result
+        else
+          EMPTY_STR.dup
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_host)
+      @normalized_host
+    end
+
+    ##
+    # Sets the host component for this URI.
+    #
+    # @param [String, #to_str] new_host The new host component.
+    def host=(new_host)
+      if new_host && !new_host.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_host.class} into String."
+      end
+      @host = new_host ? new_host.to_str : nil
+
+      # Reset dependent values
+      @authority = nil
+      @normalized_host = nil
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # This method is same as URI::Generic#host except
+    # brackets for IPv6 (and 'IPvFuture') addresses are removed.
+    #
+    # @see Addressable::URI#host
+    #
+    # @return [String] The hostname for this URI.
+    def hostname
+      v = self.host
+      /\A\[(.*)\]\z/ =~ v ? $1 : v
+    end
+
+    ##
+    # This method is same as URI::Generic#host= except
+    # the argument can be a bare IPv6 address (or 'IPvFuture').
+    #
+    # @see Addressable::URI#host=
+    #
+    # @param [String, #to_str] new_hostname The new hostname for this URI.
+    def hostname=(new_hostname)
+      if new_hostname &&
+          (new_hostname.respond_to?(:ipv4?) || new_hostname.respond_to?(:ipv6?))
+        new_hostname = new_hostname.to_s
+      elsif new_hostname && !new_hostname.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_hostname.class} into String."
+      end
+      v = new_hostname ? new_hostname.to_str : nil
+      v = "[#{v}]" if /\A\[.*\]\z/ !~ v && /:/ =~ v
+      self.host = v
+    end
+
+    ##
+    # Returns the top-level domain for this host.
+    #
+    # @example
+    #   Addressable::URI.parse("http://www.example.co.uk").tld # => "co.uk"
+    def tld
+      PublicSuffix.parse(self.host, ignore_private: true).tld
+    end
+
+    ##
+    # Sets the top-level domain for this URI.
+    #
+    # @param [String, #to_str] new_tld The new top-level domain.
+    def tld=(new_tld)
+      replaced_tld = host.sub(/#{tld}\z/, new_tld)
+      self.host = PublicSuffix::Domain.new(replaced_tld).to_s
+    end
+
+    ##
+    # Returns the public suffix domain for this host.
+    #
+    # @example
+    #   Addressable::URI.parse("http://www.example.co.uk").domain # => "example.co.uk"
+    def domain
+      PublicSuffix.domain(self.host, ignore_private: true)
+    end
+
+    ##
+    # The authority component for this URI.
+    # Combines the user, password, host, and port components.
+    #
+    # @return [String] The authority component.
+    def authority
+      self.host && @authority ||= begin
+        authority = String.new
+        if self.userinfo != nil
+          authority << "#{self.userinfo}@"
+        end
+        authority << self.host
+        if self.port != nil
+          authority << ":#{self.port}"
+        end
+        authority
+      end
+    end
+
+    ##
+    # The authority component for this URI, normalized.
+    #
+    # @return [String] The authority component, normalized.
+    def normalized_authority
+      return nil unless self.authority
+      @normalized_authority ||= begin
+        authority = String.new
+        if self.normalized_userinfo != nil
+          authority << "#{self.normalized_userinfo}@"
+        end
+        authority << self.normalized_host
+        if self.normalized_port != nil
+          authority << ":#{self.normalized_port}"
+        end
+        authority
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_authority)
+      @normalized_authority
+    end
+
+    ##
+    # Sets the authority component for this URI.
+    #
+    # @param [String, #to_str] new_authority The new authority component.
+    def authority=(new_authority)
+      if new_authority
+        if !new_authority.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{new_authority.class} into String."
+        end
+        new_authority = new_authority.to_str
+        new_userinfo = new_authority[/^([^\[\]]*)@/, 1]
+        if new_userinfo
+          new_user = new_userinfo.strip[/^([^:]*):?/, 1]
+          new_password = new_userinfo.strip[/:(.*)$/, 1]
+        end
+        new_host = new_authority.sub(
+          /^([^\[\]]*)@/, EMPTY_STR
+        ).sub(
+          /:([^:@\[\]]*?)$/, EMPTY_STR
+        )
+        new_port =
+          new_authority[/:([^:@\[\]]*?)$/, 1]
+      end
+
+      # Password assigned first to ensure validity in case of nil
+      self.password = new_password
+      self.user = new_user
+      self.host = new_host
+      self.port = new_port
+
+      # Reset dependent values
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The origin for this URI, serialized to ASCII, as per
+    # RFC 6454, section 6.2.
+    #
+    # @return [String] The serialized origin.
+    def origin
+      if self.scheme && self.authority
+        if self.normalized_port
+          "#{self.normalized_scheme}://#{self.normalized_host}" +
+          ":#{self.normalized_port}"
+        else
+          "#{self.normalized_scheme}://#{self.normalized_host}"
+        end
+      else
+        "null"
+      end
+    end
+
+    ##
+    # Sets the origin for this URI, serialized to ASCII, as per
+    # RFC 6454, section 6.2. This assignment will reset the `userinfo`
+    # component.
+    #
+    # @param [String, #to_str] new_origin The new origin component.
+    def origin=(new_origin)
+      if new_origin
+        if !new_origin.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{new_origin.class} into String."
+        end
+        new_origin = new_origin.to_str
+        new_scheme = new_origin[/^([^:\/?#]+):\/\//, 1]
+        unless new_scheme
+          raise InvalidURIError, 'An origin cannot omit the scheme.'
+        end
+        new_host = new_origin[/:\/\/([^\/?#:]+)/, 1]
+        unless new_host
+          raise InvalidURIError, 'An origin cannot omit the host.'
+        end
+        new_port = new_origin[/:([^:@\[\]\/]*?)$/, 1]
+      end
+
+      self.scheme = new_scheme
+      self.host = new_host
+      self.port = new_port
+      self.userinfo = nil
+
+      # Reset dependent values
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      @authority = nil
+      @normalized_authority = nil
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    # Returns an array of known ip-based schemes. These schemes typically
+    # use a similar URI form:
+    # <code>//<user>:<password>@<host>:<port>/<url-path></code>
+    def self.ip_based_schemes
+      return self.port_mapping.keys
+    end
+
+    # Returns a hash of common IP-based schemes and their default port
+    # numbers. Adding new schemes to this hash, as necessary, will allow
+    # for better URI normalization.
+    def self.port_mapping
+      PORT_MAPPING
+    end
+
+    ##
+    # The port component for this URI.
+    # This is the port number actually given in the URI. This does not
+    # infer port numbers from default values.
+    #
+    # @return [Integer] The port component.
+    attr_reader :port
+
+    ##
+    # The port component for this URI, normalized.
+    #
+    # @return [Integer] The port component, normalized.
+    def normalized_port
+      return nil unless self.port
+      return @normalized_port unless @normalized_port == NONE
+      @normalized_port = begin
+        if URI.port_mapping[self.normalized_scheme] == self.port
+          nil
+        else
+          self.port
+        end
+      end
+    end
+
+    ##
+    # Sets the port component for this URI.
+    #
+    # @param [String, Integer, #to_s] new_port The new port component.
+    def port=(new_port)
+      if new_port != nil && new_port.respond_to?(:to_str)
+        new_port = Addressable::URI.unencode_component(new_port.to_str)
+      end
+
+      if new_port.respond_to?(:valid_encoding?) && !new_port.valid_encoding?
+        raise InvalidURIError, "Invalid encoding in port"
+      end
+
+      if new_port != nil && !(new_port.to_s =~ /^\d+$/)
+        raise InvalidURIError,
+          "Invalid port number: #{new_port.inspect}"
+      end
+
+      @port = new_port.to_s.to_i
+      @port = nil if @port == 0
+
+      # Reset dependent values
+      @authority = nil
+      @normalized_port = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The inferred port component for this URI.
+    # This method will normalize to the default port for the URI's scheme if
+    # the port isn't explicitly specified in the URI.
+    #
+    # @return [Integer] The inferred port component.
+    def inferred_port
+      if self.port.to_i == 0
+        self.default_port
+      else
+        self.port.to_i
+      end
+    end
+
+    ##
+    # The default port for this URI's scheme.
+    # This method will always returns the default port for the URI's scheme
+    # regardless of the presence of an explicit port in the URI.
+    #
+    # @return [Integer] The default port.
+    def default_port
+      URI.port_mapping[self.scheme.strip.downcase] if self.scheme
+    end
+
+    ##
+    # The combination of components that represent a site.
+    # Combines the scheme, user, password, host, and port components.
+    # Primarily useful for HTTP and HTTPS.
+    #
+    # For example, <code>"http://example.com/path?query"</code> would have a
+    # <code>site</code> value of <code>"http://example.com"</code>.
+    #
+    # @return [String] The components that identify a site.
+    def site
+      (self.scheme || self.authority) && @site ||= begin
+        site_string = "".dup
+        site_string << "#{self.scheme}:" if self.scheme != nil
+        site_string << "//#{self.authority}" if self.authority != nil
+        site_string
+      end
+    end
+
+    ##
+    # The normalized combination of components that represent a site.
+    # Combines the scheme, user, password, host, and port components.
+    # Primarily useful for HTTP and HTTPS.
+    #
+    # For example, <code>"http://example.com/path?query"</code> would have a
+    # <code>site</code> value of <code>"http://example.com"</code>.
+    #
+    # @return [String] The normalized components that identify a site.
+    def normalized_site
+      return nil unless self.site
+      @normalized_site ||= begin
+        site_string = "".dup
+        if self.normalized_scheme != nil
+          site_string << "#{self.normalized_scheme}:"
+        end
+        if self.normalized_authority != nil
+          site_string << "//#{self.normalized_authority}"
+        end
+        site_string
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_site)
+      @normalized_site
+    end
+
+    ##
+    # Sets the site value for this URI.
+    #
+    # @param [String, #to_str] new_site The new site value.
+    def site=(new_site)
+      if new_site
+        if !new_site.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{new_site.class} into String."
+        end
+        new_site = new_site.to_str
+        # These two regular expressions derived from the primary parsing
+        # expression
+        self.scheme = new_site[/^(?:([^:\/?#]+):)?(?:\/\/(?:[^\/?#]*))?$/, 1]
+        self.authority = new_site[
+          /^(?:(?:[^:\/?#]+):)?(?:\/\/([^\/?#]*))?$/, 1
+        ]
+      else
+        self.scheme = nil
+        self.authority = nil
+      end
+    end
+
+    ##
+    # The path component for this URI.
+    #
+    # @return [String] The path component.
+    attr_reader :path
+
+    NORMPATH = /^(?!\/)[^\/:]*:.*$/
+    ##
+    # The path component for this URI, normalized.
+    #
+    # @return [String] The path component, normalized.
+    def normalized_path
+      @normalized_path ||= begin
+        path = self.path.to_s
+        if self.scheme == nil && path =~ NORMPATH
+          # Relative paths with colons in the first segment are ambiguous.
+          path = path.sub(":", "%2F")
+        end
+        # String#split(delimiter, -1) uses the more strict splitting behavior
+        # found by default in Python.
+        result = path.strip.split(SLASH, -1).map do |segment|
+          Addressable::URI.normalize_component(
+            segment,
+            Addressable::URI::NormalizeCharacterClasses::PCHAR
+          )
+        end.join(SLASH)
+
+        result = URI.normalize_path(result)
+        if result.empty? &&
+            ["http", "https", "ftp", "tftp"].include?(self.normalized_scheme)
+          result = SLASH.dup
+        end
+        result
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_path)
+      @normalized_path
+    end
+
+    ##
+    # Sets the path component for this URI.
+    #
+    # @param [String, #to_str] new_path The new path component.
+    def path=(new_path)
+      if new_path && !new_path.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_path.class} into String."
+      end
+      @path = (new_path || EMPTY_STR).to_str
+      if !@path.empty? && @path[0..0] != SLASH && host != nil
+        @path = "/#{@path}"
+      end
+
+      # Reset dependent values
+      @normalized_path = nil
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The basename, if any, of the file in the path component.
+    #
+    # @return [String] The path's basename.
+    def basename
+      # Path cannot be nil
+      return File.basename(self.path).sub(/;[^\/]*$/, EMPTY_STR)
+    end
+
+    ##
+    # The extname, if any, of the file in the path component.
+    # Empty string if there is no extension.
+    #
+    # @return [String] The path's extname.
+    def extname
+      return nil unless self.path
+      return File.extname(self.basename)
+    end
+
+    ##
+    # The query component for this URI.
+    #
+    # @return [String] The query component.
+    attr_reader :query
+
+    ##
+    # The query component for this URI, normalized.
+    #
+    # @return [String] The query component, normalized.
+    def normalized_query(*flags)
+      return nil unless self.query
+      return @normalized_query unless @normalized_query == NONE
+      @normalized_query = begin
+        modified_query_class = Addressable::URI::CharacterClasses::QUERY.dup
+        # Make sure possible key-value pair delimiters are escaped.
+        modified_query_class.sub!("\\&", "").sub!("\\;", "")
+        pairs = (query || "").split("&", -1)
+        pairs.delete_if(&:empty?).uniq! if flags.include?(:compacted)
+        pairs.sort! if flags.include?(:sorted)
+        component = pairs.map do |pair|
+          Addressable::URI.normalize_component(
+            pair,
+            Addressable::URI::NormalizeCharacterClasses::QUERY,
+            "+"
+          )
+        end.join("&")
+        component == "" ? nil : component
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_query)
+      @normalized_query
+    end
+
+    ##
+    # Sets the query component for this URI.
+    #
+    # @param [String, #to_str] new_query The new query component.
+    def query=(new_query)
+      if new_query && !new_query.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_query.class} into String."
+      end
+      @query = new_query ? new_query.to_str : nil
+
+      # Reset dependent values
+      @normalized_query = NONE
+      remove_composite_values
+    end
+
+    ##
+    # Converts the query component to a Hash value.
+    #
+    # @param [Class] return_type The return type desired. Value must be either
+    #   `Hash` or `Array`.
+    #
+    # @return [Hash, Array, nil] The query string parsed as a Hash or Array
+    #   or nil if the query string is blank.
+    #
+    # @example
+    #   Addressable::URI.parse("?one=1&two=2&three=3").query_values
+    #   #=> {"one" => "1", "two" => "2", "three" => "3"}
+    #   Addressable::URI.parse("?one=two&one=three").query_values(Array)
+    #   #=> [["one", "two"], ["one", "three"]]
+    #   Addressable::URI.parse("?one=two&one=three").query_values(Hash)
+    #   #=> {"one" => "three"}
+    #   Addressable::URI.parse("?").query_values
+    #   #=> {}
+    #   Addressable::URI.parse("").query_values
+    #   #=> nil
+    def query_values(return_type=Hash)
+      empty_accumulator = Array == return_type ? [] : {}
+      if return_type != Hash && return_type != Array
+        raise ArgumentError, "Invalid return type. Must be Hash or Array."
+      end
+      return nil if self.query == nil
+      split_query = self.query.split("&").map do |pair|
+        pair.split("=", 2) if pair && !pair.empty?
+      end.compact
+      return split_query.inject(empty_accumulator.dup) do |accu, pair|
+        # I'd rather use key/value identifiers instead of array lookups,
+        # but in this case I really want to maintain the exact pair structure,
+        # so it's best to make all changes in-place.
+        pair[0] = URI.unencode_component(pair[0])
+        if pair[1].respond_to?(:to_str)
+          value = pair[1].to_str
+          # I loathe the fact that I have to do this. Stupid HTML 4.01.
+          # Treating '+' as a space was just an unbelievably bad idea.
+          # There was nothing wrong with '%20'!
+          # If it ain't broke, don't fix it!
+          value = value.tr("+", " ") if ["http", "https", nil].include?(scheme)
+          pair[1] = URI.unencode_component(value)
+        end
+        if return_type == Hash
+          accu[pair[0]] = pair[1]
+        else
+          accu << pair
+        end
+        accu
+      end
+    end
+
+    ##
+    # Sets the query component for this URI from a Hash object.
+    # An empty Hash or Array will result in an empty query string.
+    #
+    # @param [Hash, #to_hash, Array] new_query_values The new query values.
+    #
+    # @example
+    #   uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['a', 'a'], ['b', 'c'], ['b', 'd'], ['b', 'e']]
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['a', 'a'], ['b', ['c', 'd', 'e']]]
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['flag'], ['key', 'value']]
+    #   uri.query
+    #   # => "flag&key=value"
+    def query_values=(new_query_values)
+      if new_query_values == nil
+        self.query = nil
+        return nil
+      end
+
+      if !new_query_values.is_a?(Array)
+        if !new_query_values.respond_to?(:to_hash)
+          raise TypeError,
+            "Can't convert #{new_query_values.class} into Hash."
+        end
+        new_query_values = new_query_values.to_hash
+        new_query_values = new_query_values.map do |key, value|
+          key = key.to_s if key.kind_of?(Symbol)
+          [key, value]
+        end
+        # Useful default for OAuth and caching.
+        # Only to be used for non-Array inputs. Arrays should preserve order.
+        new_query_values.sort!
+      end
+
+      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
+      buffer = "".dup
+      new_query_values.each do |key, value|
+        encoded_key = URI.encode_component(
+          key, CharacterClassesRegexps::UNRESERVED
+        )
+        if value == nil
+          buffer << "#{encoded_key}&"
+        elsif value.kind_of?(Array)
+          value.each do |sub_value|
+            encoded_value = URI.encode_component(
+              sub_value, CharacterClassesRegexps::UNRESERVED
+            )
+            buffer << "#{encoded_key}=#{encoded_value}&"
+          end
+        else
+          encoded_value = URI.encode_component(
+            value, CharacterClassesRegexps::UNRESERVED
+          )
+          buffer << "#{encoded_key}=#{encoded_value}&"
+        end
+      end
+      self.query = buffer.chop
+    end
+
+    ##
+    # The HTTP request URI for this URI.  This is the path and the
+    # query string.
+    #
+    # @return [String] The request URI required for an HTTP request.
+    def request_uri
+      return nil if self.absolute? && self.scheme !~ /^https?$/i
+      return (
+        (!self.path.empty? ? self.path : SLASH) +
+        (self.query ? "?#{self.query}" : EMPTY_STR)
+      )
+    end
+
+    ##
+    # Sets the HTTP request URI for this URI.
+    #
+    # @param [String, #to_str] new_request_uri The new HTTP request URI.
+    def request_uri=(new_request_uri)
+      if !new_request_uri.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_request_uri.class} into String."
+      end
+      if self.absolute? && self.scheme !~ /^https?$/i
+        raise InvalidURIError,
+          "Cannot set an HTTP request URI for a non-HTTP URI."
+      end
+      new_request_uri = new_request_uri.to_str
+      path_component = new_request_uri[/^([^\?]*)\??(?:.*)$/, 1]
+      query_component = new_request_uri[/^(?:[^\?]*)\?(.*)$/, 1]
+      path_component = path_component.to_s
+      path_component = (!path_component.empty? ? path_component : SLASH)
+      self.path = path_component
+      self.query = query_component
+
+      # Reset dependent values
+      remove_composite_values
+    end
+
+    ##
+    # The fragment component for this URI.
+    #
+    # @return [String] The fragment component.
+    attr_reader :fragment
+
+    ##
+    # The fragment component for this URI, normalized.
+    #
+    # @return [String] The fragment component, normalized.
+    def normalized_fragment
+      return nil unless self.fragment
+      return @normalized_fragment unless @normalized_fragment == NONE
+      @normalized_fragment = begin
+        component = Addressable::URI.normalize_component(
+          self.fragment,
+          Addressable::URI::NormalizeCharacterClasses::FRAGMENT
+        )
+        component == "" ? nil : component
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_fragment)
+      @normalized_fragment
+    end
+
+    ##
+    # Sets the fragment component for this URI.
+    #
+    # @param [String, #to_str] new_fragment The new fragment component.
+    def fragment=(new_fragment)
+      if new_fragment && !new_fragment.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_fragment.class} into String."
+      end
+      @fragment = new_fragment ? new_fragment.to_str : nil
+
+      # Reset dependent values
+      @normalized_fragment = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # Determines if the scheme indicates an IP-based protocol.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the scheme indicates an IP-based protocol.
+    #   <code>false</code> otherwise.
+    def ip_based?
+      if self.scheme
+        return URI.ip_based_schemes.include?(
+          self.scheme.strip.downcase)
+      end
+      return false
+    end
+
+    ##
+    # Determines if the URI is relative.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URI is relative. <code>false</code>
+    #   otherwise.
+    def relative?
+      return self.scheme.nil?
+    end
+
+    ##
+    # Determines if the URI is absolute.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URI is absolute. <code>false</code>
+    #   otherwise.
+    def absolute?
+      return !relative?
+    end
+
+    ##
+    # Joins two URIs together.
+    #
+    # @param [String, Addressable::URI, #to_str] The URI to join with.
+    #
+    # @return [Addressable::URI] The joined URI.
+    def join(uri)
+      if !uri.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end
+      if !uri.kind_of?(URI)
+        # Otherwise, convert to a String, then parse.
+        uri = URI.parse(uri.to_str)
+      end
+      if uri.to_s.empty?
+        return self.dup
+      end
+
+      joined_scheme = nil
+      joined_user = nil
+      joined_password = nil
+      joined_host = nil
+      joined_port = nil
+      joined_path = nil
+      joined_query = nil
+      joined_fragment = nil
+
+      # Section 5.2.2 of RFC 3986
+      if uri.scheme != nil
+        joined_scheme = uri.scheme
+        joined_user = uri.user
+        joined_password = uri.password
+        joined_host = uri.host
+        joined_port = uri.port
+        joined_path = URI.normalize_path(uri.path)
+        joined_query = uri.query
+      else
+        if uri.authority != nil
+          joined_user = uri.user
+          joined_password = uri.password
+          joined_host = uri.host
+          joined_port = uri.port
+          joined_path = URI.normalize_path(uri.path)
+          joined_query = uri.query
+        else
+          if uri.path == nil || uri.path.empty?
+            joined_path = self.path
+            if uri.query != nil
+              joined_query = uri.query
+            else
+              joined_query = self.query
+            end
+          else
+            if uri.path[0..0] == SLASH
+              joined_path = URI.normalize_path(uri.path)
+            else
+              base_path = self.path.dup
+              base_path = EMPTY_STR if base_path == nil
+              base_path = URI.normalize_path(base_path)
+
+              # Section 5.2.3 of RFC 3986
+              #
+              # Removes the right-most path segment from the base path.
+              if base_path.include?(SLASH)
+                base_path.sub!(/\/[^\/]+$/, SLASH)
+              else
+                base_path = EMPTY_STR
+              end
+
+              # If the base path is empty and an authority segment has been
+              # defined, use a base path of SLASH
+              if base_path.empty? && self.authority != nil
+                base_path = SLASH
+              end
+
+              joined_path = URI.normalize_path(base_path + uri.path)
+            end
+            joined_query = uri.query
+          end
+          joined_user = self.user
+          joined_password = self.password
+          joined_host = self.host
+          joined_port = self.port
+        end
+        joined_scheme = self.scheme
+      end
+      joined_fragment = uri.fragment
+
+      return self.class.new(
+        :scheme => joined_scheme,
+        :user => joined_user,
+        :password => joined_password,
+        :host => joined_host,
+        :port => joined_port,
+        :path => joined_path,
+        :query => joined_query,
+        :fragment => joined_fragment
+      )
+    end
+    alias_method :+, :join
+
+    ##
+    # Destructive form of <code>join</code>.
+    #
+    # @param [String, Addressable::URI, #to_str] The URI to join with.
+    #
+    # @return [Addressable::URI] The joined URI.
+    #
+    # @see Addressable::URI#join
+    def join!(uri)
+      replace_self(self.join(uri))
+    end
+
+    ##
+    # Merges a URI with a <code>Hash</code> of components.
+    # This method has different behavior from <code>join</code>. Any
+    # components present in the <code>hash</code> parameter will override the
+    # original components. The path component is not treated specially.
+    #
+    # @param [Hash, Addressable::URI, #to_hash] The components to merge with.
+    #
+    # @return [Addressable::URI] The merged URI.
+    #
+    # @see Hash#merge
+    def merge(hash)
+      unless hash.respond_to?(:to_hash)
+        raise TypeError, "Can't convert #{hash.class} into Hash."
+      end
+      hash = hash.to_hash
+
+      if hash.has_key?(:authority)
+        if (hash.keys & [:userinfo, :user, :password, :host, :port]).any?
+          raise ArgumentError,
+            "Cannot specify both an authority and any of the components " +
+            "within the authority."
+        end
+      end
+      if hash.has_key?(:userinfo)
+        if (hash.keys & [:user, :password]).any?
+          raise ArgumentError,
+            "Cannot specify both a userinfo and either the user or password."
+        end
+      end
+
+      uri = self.class.new
+      uri.defer_validation do
+        # Bunch of crazy logic required because of the composite components
+        # like userinfo and authority.
+        uri.scheme =
+          hash.has_key?(:scheme) ? hash[:scheme] : self.scheme
+        if hash.has_key?(:authority)
+          uri.authority =
+            hash.has_key?(:authority) ? hash[:authority] : self.authority
+        end
+        if hash.has_key?(:userinfo)
+          uri.userinfo =
+            hash.has_key?(:userinfo) ? hash[:userinfo] : self.userinfo
+        end
+        if !hash.has_key?(:userinfo) && !hash.has_key?(:authority)
+          uri.user =
+            hash.has_key?(:user) ? hash[:user] : self.user
+          uri.password =
+            hash.has_key?(:password) ? hash[:password] : self.password
+        end
+        if !hash.has_key?(:authority)
+          uri.host =
+            hash.has_key?(:host) ? hash[:host] : self.host
+          uri.port =
+            hash.has_key?(:port) ? hash[:port] : self.port
+        end
+        uri.path =
+          hash.has_key?(:path) ? hash[:path] : self.path
+        uri.query =
+          hash.has_key?(:query) ? hash[:query] : self.query
+        uri.fragment =
+          hash.has_key?(:fragment) ? hash[:fragment] : self.fragment
+      end
+
+      return uri
+    end
+
+    ##
+    # Destructive form of <code>merge</code>.
+    #
+    # @param [Hash, Addressable::URI, #to_hash] The components to merge with.
+    #
+    # @return [Addressable::URI] The merged URI.
+    #
+    # @see Addressable::URI#merge
+    def merge!(uri)
+      replace_self(self.merge(uri))
+    end
+
+    ##
+    # Returns the shortest normalized relative form of this URI that uses the
+    # supplied URI as a base for resolution. Returns an absolute URI if
+    # necessary. This is effectively the opposite of <code>route_to</code>.
+    #
+    # @param [String, Addressable::URI, #to_str] uri The URI to route from.
+    #
+    # @return [Addressable::URI]
+    #   The normalized relative URI that is equivalent to the original URI.
+    def route_from(uri)
+      uri = URI.parse(uri).normalize
+      normalized_self = self.normalize
+      if normalized_self.relative?
+        raise ArgumentError, "Expected absolute URI, got: #{self.to_s}"
+      end
+      if uri.relative?
+        raise ArgumentError, "Expected absolute URI, got: #{uri.to_s}"
+      end
+      if normalized_self == uri
+        return Addressable::URI.parse("##{normalized_self.fragment}")
+      end
+      components = normalized_self.to_hash
+      if normalized_self.scheme == uri.scheme
+        components[:scheme] = nil
+        if normalized_self.authority == uri.authority
+          components[:user] = nil
+          components[:password] = nil
+          components[:host] = nil
+          components[:port] = nil
+          if normalized_self.path == uri.path
+            components[:path] = nil
+            if normalized_self.query == uri.query
+              components[:query] = nil
+            end
+          else
+            if uri.path != SLASH and components[:path]
+              self_splitted_path = split_path(components[:path])
+              uri_splitted_path = split_path(uri.path)
+              self_dir = self_splitted_path.shift
+              uri_dir = uri_splitted_path.shift
+              while !self_splitted_path.empty? && !uri_splitted_path.empty? and self_dir == uri_dir
+                self_dir = self_splitted_path.shift
+                uri_dir = uri_splitted_path.shift
+              end
+              components[:path] = (uri_splitted_path.fill('..') + [self_dir] + self_splitted_path).join(SLASH)
+            end
+          end
+        end
+      end
+      # Avoid network-path references.
+      if components[:host] != nil
+        components[:scheme] = normalized_self.scheme
+      end
+      return Addressable::URI.new(
+        :scheme => components[:scheme],
+        :user => components[:user],
+        :password => components[:password],
+        :host => components[:host],
+        :port => components[:port],
+        :path => components[:path],
+        :query => components[:query],
+        :fragment => components[:fragment]
+      )
+    end
+
+    ##
+    # Returns the shortest normalized relative form of the supplied URI that
+    # uses this URI as a base for resolution. Returns an absolute URI if
+    # necessary. This is effectively the opposite of <code>route_from</code>.
+    #
+    # @param [String, Addressable::URI, #to_str] uri The URI to route to.
+    #
+    # @return [Addressable::URI]
+    #   The normalized relative URI that is equivalent to the supplied URI.
+    def route_to(uri)
+      return URI.parse(uri).route_from(self)
+    end
+
+    ##
+    # Returns a normalized URI object.
+    #
+    # NOTE: This method does not attempt to fully conform to specifications.
+    # It exists largely to correct other people's failures to read the
+    # specifications, and also to deal with caching issues since several
+    # different URIs may represent the same resource and should not be
+    # cached multiple times.
+    #
+    # @return [Addressable::URI] The normalized URI.
+    def normalize
+      # This is a special exception for the frequently misused feed
+      # URI scheme.
+      if normalized_scheme == "feed"
+        if self.to_s =~ /^feed:\/*http:\/*/
+          return URI.parse(
+            self.to_s[/^feed:\/*(http:\/*.*)/, 1]
+          ).normalize
+        end
+      end
+
+      return self.class.new(
+        :scheme => normalized_scheme,
+        :authority => normalized_authority,
+        :path => normalized_path,
+        :query => normalized_query,
+        :fragment => normalized_fragment
+      )
+    end
+
+    ##
+    # Destructively normalizes this URI object.
+    #
+    # @return [Addressable::URI] The normalized URI.
+    #
+    # @see Addressable::URI#normalize
+    def normalize!
+      replace_self(self.normalize)
+    end
+
+    ##
+    # Creates a URI suitable for display to users. If semantic attacks are
+    # likely, the application should try to detect these and warn the user.
+    # See <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>,
+    # section 7.6 for more information.
+    #
+    # @return [Addressable::URI] A URI suitable for display purposes.
+    def display_uri
+      display_uri = self.normalize
+      display_uri.host = ::Addressable::IDNA.to_unicode(display_uri.host)
+      return display_uri
+    end
+
+    ##
+    # Returns <code>true</code> if the URI objects are equal. This method
+    # normalizes both URIs before doing the comparison, and allows comparison
+    # against <code>Strings</code>.
+    #
+    # @param [Object] uri The URI to compare.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URIs are equivalent, <code>false</code>
+    #   otherwise.
+    def ===(uri)
+      if uri.respond_to?(:normalize)
+        uri_string = uri.normalize.to_s
+      else
+        begin
+          uri_string = ::Addressable::URI.parse(uri).normalize.to_s
+        rescue InvalidURIError, TypeError
+          return false
+        end
+      end
+      return self.normalize.to_s == uri_string
+    end
+
+    ##
+    # Returns <code>true</code> if the URI objects are equal. This method
+    # normalizes both URIs before doing the comparison.
+    #
+    # @param [Object] uri The URI to compare.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URIs are equivalent, <code>false</code>
+    #   otherwise.
+    def ==(uri)
+      return false unless uri.kind_of?(URI)
+      return self.normalize.to_s == uri.normalize.to_s
+    end
+
+    ##
+    # Returns <code>true</code> if the URI objects are equal. This method
+    # does NOT normalize either URI before doing the comparison.
+    #
+    # @param [Object] uri The URI to compare.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URIs are equivalent, <code>false</code>
+    #   otherwise.
+    def eql?(uri)
+      return false unless uri.kind_of?(URI)
+      return self.to_s == uri.to_s
+    end
+
+    ##
+    # A hash value that will make a URI equivalent to its normalized
+    # form.
+    #
+    # @return [Integer] A hash of the URI.
+    def hash
+      @hash ||= self.to_s.hash * -1
+    end
+
+    ##
+    # Clones the URI object.
+    #
+    # @return [Addressable::URI] The cloned URI.
+    def dup
+      duplicated_uri = self.class.new(
+        :scheme => self.scheme ? self.scheme.dup : nil,
+        :user => self.user ? self.user.dup : nil,
+        :password => self.password ? self.password.dup : nil,
+        :host => self.host ? self.host.dup : nil,
+        :port => self.port,
+        :path => self.path ? self.path.dup : nil,
+        :query => self.query ? self.query.dup : nil,
+        :fragment => self.fragment ? self.fragment.dup : nil
+      )
+      return duplicated_uri
+    end
+
+    ##
+    # Omits components from a URI.
+    #
+    # @param [Symbol] *components The components to be omitted.
+    #
+    # @return [Addressable::URI] The URI with components omitted.
+    #
+    # @example
+    #   uri = Addressable::URI.parse("http://example.com/path?query")
+    #   #=> #<Addressable::URI:0xcc5e7a URI:http://example.com/path?query>
+    #   uri.omit(:scheme, :authority)
+    #   #=> #<Addressable::URI:0xcc4d86 URI:/path?query>
+    def omit(*components)
+      invalid_components = components - [
+        :scheme, :user, :password, :userinfo, :host, :port, :authority,
+        :path, :query, :fragment
+      ]
+      unless invalid_components.empty?
+        raise ArgumentError,
+          "Invalid component names: #{invalid_components.inspect}."
+      end
+      duplicated_uri = self.dup
+      duplicated_uri.defer_validation do
+        components.each do |component|
+          duplicated_uri.send((component.to_s + "=").to_sym, nil)
+        end
+        duplicated_uri.user = duplicated_uri.normalized_user
+      end
+      duplicated_uri
+    end
+
+    ##
+    # Destructive form of omit.
+    #
+    # @param [Symbol] *components The components to be omitted.
+    #
+    # @return [Addressable::URI] The URI with components omitted.
+    #
+    # @see Addressable::URI#omit
+    def omit!(*components)
+      replace_self(self.omit(*components))
+    end
+
+    ##
+    # Determines if the URI is an empty string.
+    #
+    # @return [TrueClass, FalseClass]
+    #   Returns <code>true</code> if empty, <code>false</code> otherwise.
+    def empty?
+      return self.to_s.empty?
+    end
+
+    ##
+    # Converts the URI to a <code>String</code>.
+    #
+    # @return [String] The URI's <code>String</code> representation.
+    def to_s
+      if self.scheme == nil && self.path != nil && !self.path.empty? &&
+          self.path =~ NORMPATH
+        raise InvalidURIError,
+          "Cannot assemble URI string with ambiguous path: '#{self.path}'"
+      end
+      @uri_string ||= begin
+        uri_string = String.new
+        uri_string << "#{self.scheme}:" if self.scheme != nil
+        uri_string << "//#{self.authority}" if self.authority != nil
+        uri_string << self.path.to_s
+        uri_string << "?#{self.query}" if self.query != nil
+        uri_string << "##{self.fragment}" if self.fragment != nil
+        uri_string.force_encoding(Encoding::UTF_8)
+        uri_string
+      end
+    end
+
+    ##
+    # URI's are glorified <code>Strings</code>. Allow implicit conversion.
+    alias_method :to_str, :to_s
+
+    ##
+    # Returns a Hash of the URI components.
+    #
+    # @return [Hash] The URI as a <code>Hash</code> of components.
+    def to_hash
+      return {
+        :scheme => self.scheme,
+        :user => self.user,
+        :password => self.password,
+        :host => self.host,
+        :port => self.port,
+        :path => self.path,
+        :query => self.query,
+        :fragment => self.fragment
+      }
+    end
+
+    ##
+    # Returns a <code>String</code> representation of the URI object's state.
+    #
+    # @return [String] The URI object's state, as a <code>String</code>.
+    def inspect
+      sprintf("#<%s:%#0x URI:%s>", URI.to_s, self.object_id, self.to_s)
+    end
+
+    ##
+    # This method allows you to make several changes to a URI simultaneously,
+    # which separately would cause validation errors, but in conjunction,
+    # are valid.  The URI will be revalidated as soon as the entire block has
+    # been executed.
+    #
+    # @param [Proc] block
+    #   A set of operations to perform on a given URI.
+    def defer_validation
+      raise LocalJumpError, "No block given." unless block_given?
+      @validation_deferred = true
+      yield
+      @validation_deferred = false
+      validate
+    ensure
+      @validation_deferred = false
+    end
+
+    def encode_with(coder)
+      instance_variables.each do |ivar|
+        value = instance_variable_get(ivar)
+        if value != NONE
+          key = ivar.to_s.slice(1..-1)
+          coder[key] = value
+        end
+      end
+      nil
+    end
+
+    def init_with(coder)
+      reset_ivs
+      coder.map.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+      nil
+    end
+
+  protected
+    SELF_REF = '.'
+    PARENT = '..'
+
+    RULE_2A = /\/\.\/|\/\.$/
+    RULE_2B_2C = /\/([^\/]*)\/\.\.\/|\/([^\/]*)\/\.\.$/
+    RULE_2D = /^\.\.?\/?/
+    RULE_PREFIXED_PARENT = /^\/\.\.?\/|^(\/\.\.?)+\/?$/
+
+    ##
+    # Resolves paths to their simplest form.
+    #
+    # @param [String] path The path to normalize.
+    #
+    # @return [String] The normalized path.
+    def self.normalize_path(path)
+      # Section 5.2.4 of RFC 3986
+
+      return if path.nil?
+      normalized_path = path.dup
+      loop do
+        mod ||= normalized_path.gsub!(RULE_2A, SLASH)
+
+        pair = normalized_path.match(RULE_2B_2C)
+        if pair
+          parent  = pair[1]
+          current = pair[2]
+        else
+          parent  = nil
+          current = nil
+        end
+
+        regexp = "/#{Regexp.escape(parent.to_s)}/\\.\\./|"
+        regexp += "(/#{Regexp.escape(current.to_s)}/\\.\\.$)"
+
+        if pair && ((parent != SELF_REF && parent != PARENT) ||
+            (current != SELF_REF && current != PARENT))
+          mod ||= normalized_path.gsub!(Regexp.new(regexp), SLASH)
+        end
+
+        mod ||= normalized_path.gsub!(RULE_2D, EMPTY_STR)
+        # Non-standard, removes prefixed dotted segments from path.
+        mod ||= normalized_path.gsub!(RULE_PREFIXED_PARENT, SLASH)
+        break if mod.nil?
+      end
+
+      normalized_path
+    end
+
+    ##
+    # Ensures that the URI is valid.
+    def validate
+      return if !!@validation_deferred
+      if self.scheme != nil && self.ip_based? &&
+          (self.host == nil || self.host.empty?) &&
+          (self.path == nil || self.path.empty?)
+        raise InvalidURIError,
+          "Absolute URI missing hierarchical segment: '#{self.to_s}'"
+      end
+      if self.host == nil
+        if self.port != nil ||
+            self.user != nil ||
+            self.password != nil
+          raise InvalidURIError, "Hostname not supplied: '#{self.to_s}'"
+        end
+      end
+      if self.path != nil && !self.path.empty? && self.path[0..0] != SLASH &&
+          self.authority != nil
+        raise InvalidURIError,
+          "Cannot have a relative path with an authority set: '#{self.to_s}'"
+      end
+      if self.path != nil && !self.path.empty? &&
+          self.path[0..1] == SLASH + SLASH && self.authority == nil
+        raise InvalidURIError,
+          "Cannot have a path with two leading slashes " +
+          "without an authority set: '#{self.to_s}'"
+      end
+      unreserved = CharacterClasses::UNRESERVED
+      sub_delims = CharacterClasses::SUB_DELIMS
+      if !self.host.nil? && (self.host =~ /[<>{}\/\\\?\#\@"[[:space:]]]/ ||
+          (self.host[/^\[(.*)\]$/, 1] != nil && self.host[/^\[(.*)\]$/, 1] !~
+          Regexp.new("^[#{unreserved}#{sub_delims}:]*$")))
+        raise InvalidURIError, "Invalid character in host: '#{self.host.to_s}'"
+      end
+      return nil
+    end
+
+    ##
+    # Replaces the internal state of self with the specified URI's state.
+    # Used in destructive operations to avoid massive code repetition.
+    #
+    # @param [Addressable::URI] uri The URI to replace <code>self</code> with.
+    #
+    # @return [Addressable::URI] <code>self</code>.
+    def replace_self(uri)
+      # Reset dependent values
+      reset_ivs
+
+      @scheme = uri.scheme
+      @user = uri.user
+      @password = uri.password
+      @host = uri.host
+      @port = uri.port
+      @path = uri.path
+      @query = uri.query
+      @fragment = uri.fragment
+      return self
+    end
+
+    ##
+    # Splits path string with "/" (slash).
+    # It is considered that there is empty string after last slash when
+    # path ends with slash.
+    #
+    # @param [String] path The path to split.
+    #
+    # @return [Array<String>] An array of parts of path.
+    def split_path(path)
+      splitted = path.split(SLASH)
+      splitted << EMPTY_STR if path.end_with? SLASH
+      splitted
+    end
+
+    ##
+    # Resets composite values for the entire URI
+    #
+    # @api private
+    def remove_composite_values
+      @uri_string = nil
+      @hash = nil
+    end
+
+    ##
+    # Converts the string to be UTF-8 if it is not already UTF-8
+    #
+    # @api private
+    def force_utf8_encoding_if_needed(str)
+      if str && str.encoding != Encoding::UTF_8
+        str.force_encoding(Encoding::UTF_8)
+      end
+    end
+
+    private
+
+    ##
+    # Resets instance variables
+    #
+    # @api private
+    def reset_ivs
+      @scheme = nil
+      @user = nil
+      @normalized_scheme = NONE
+      @normalized_user = NONE
+      @uri_string = nil
+      @hash = nil
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      @authority = nil
+      @password = nil
+      @normalized_authority = nil
+      @port = nil
+      @normalized_password = NONE
+      @host = nil
+      @normalized_host = nil
+      @normalized_port = NONE
+      @path = EMPTY_STR
+      @normalized_path = nil
+      @normalized_query = NONE
+      @fragment = nil
+      @normalized_fragment = NONE
+      @query = nil
+    end
+
+    NONE = Module.new.freeze
+
+    private_constant :NONE
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/version.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/version.rb
new file mode 100644
index 0000000..2eec3e6
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/lib/addressable/version.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (C) 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.
+#++
+
+
+# Used to prevent the class/module from being loaded more than once
+if !defined?(Addressable::VERSION)
+  module Addressable
+    module VERSION
+      MAJOR = 2
+      MINOR = 8
+      TINY  = 7
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/idna_spec.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/idna_spec.rb
new file mode 100644
index 0000000..428c9ec
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/idna_spec.rb
@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+# Copyright (C) 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 "spec_helper"
+
+# Have to use RubyGems to load the idn gem.
+require "rubygems"
+
+require "addressable/idna"
+
+shared_examples_for "converting from unicode to ASCII" do
+  it "should convert 'www.google.com' correctly" do
+    expect(Addressable::IDNA.to_ascii("www.google.com")).to eq("www.google.com")
+  end
+
+  long = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
+  it "should convert '#{long}' correctly" do
+    expect(Addressable::IDNA.to_ascii(long)).to eq(long)
+  end
+
+  it "should convert 'www.詹姆斯.com' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "www.詹姆斯.com"
+    )).to eq("www.xn--8ws00zhy3a.com")
+  end
+
+  it "also accepts unicode strings encoded as ascii-8bit" do
+    expect(Addressable::IDNA.to_ascii(
+      "www.詹姆斯.com".b
+    )).to eq("www.xn--8ws00zhy3a.com")
+  end
+
+  it "should convert 'www.Iñtërnâtiônàlizætiøn.com' correctly" do
+    "www.Iñtërnâtiônàlizætiøn.com"
+    expect(Addressable::IDNA.to_ascii(
+      "www.I\xC3\xB1t\xC3\xABrn\xC3\xA2ti\xC3\xB4" +
+      "n\xC3\xA0liz\xC3\xA6ti\xC3\xB8n.com"
+    )).to eq("www.xn--itrntinliztin-vdb0a5exd8ewcye.com")
+  end
+
+  it "should convert 'www.Iñtërnâtiônàlizætiøn.com' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "www.In\xCC\x83te\xCC\x88rna\xCC\x82tio\xCC\x82n" +
+      "a\xCC\x80liz\xC3\xA6ti\xC3\xB8n.com"
+    )).to eq("www.xn--itrntinliztin-vdb0a5exd8ewcye.com")
+  end
+
+  it "should convert " +
+      "'www.ほんとうにながいわけのわからないどめいんめいのらべるまだながくしないとたりない.w3.mag.keio.ac.jp' " +
+      "correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "www.\343\201\273\343\202\223\343\201\250\343\201\206\343\201\253\343" +
+      "\201\252\343\201\214\343\201\204\343\202\217\343\201\221\343\201\256" +
+      "\343\202\217\343\201\213\343\202\211\343\201\252\343\201\204\343\201" +
+      "\251\343\202\201\343\201\204\343\202\223\343\202\201\343\201\204\343" +
+      "\201\256\343\202\211\343\201\271\343\202\213\343\201\276\343\201\240" +
+      "\343\201\252\343\201\214\343\201\217\343\201\227\343\201\252\343\201" +
+      "\204\343\201\250\343\201\237\343\202\212\343\201\252\343\201\204." +
+      "w3.mag.keio.ac.jp"
+    )).to eq(
+      "www.xn--n8jaaaaai5bhf7as8fsfk3jnknefdde3" +
+      "fg11amb5gzdb4wi9bya3kc6lra.w3.mag.keio.ac.jp"
+    )
+  end
+
+  it "should convert " +
+      "'www.ほんとうにながいわけのわからないどめいんめいのらべるまだながくしないとたりない.w3.mag.keio.ac.jp' " +
+      "correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "www.\343\201\273\343\202\223\343\201\250\343\201\206\343\201\253\343" +
+      "\201\252\343\201\213\343\202\231\343\201\204\343\202\217\343\201\221" +
+      "\343\201\256\343\202\217\343\201\213\343\202\211\343\201\252\343\201" +
+      "\204\343\201\250\343\202\231\343\202\201\343\201\204\343\202\223\343" +
+      "\202\201\343\201\204\343\201\256\343\202\211\343\201\270\343\202\231" +
+      "\343\202\213\343\201\276\343\201\237\343\202\231\343\201\252\343\201" +
+      "\213\343\202\231\343\201\217\343\201\227\343\201\252\343\201\204\343" +
+      "\201\250\343\201\237\343\202\212\343\201\252\343\201\204." +
+      "w3.mag.keio.ac.jp"
+    )).to eq(
+      "www.xn--n8jaaaaai5bhf7as8fsfk3jnknefdde3" +
+      "fg11amb5gzdb4wi9bya3kc6lra.w3.mag.keio.ac.jp"
+    )
+  end
+
+  it "should convert '点心和烤鸭.w3.mag.keio.ac.jp' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "点心和烤鸭.w3.mag.keio.ac.jp"
+    )).to eq("xn--0trv4xfvn8el34t.w3.mag.keio.ac.jp")
+  end
+
+  it "should convert '가각갂갃간갅갆갇갈갉힢힣.com' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "가각갂갃간갅갆갇갈갉힢힣.com"
+    )).to eq("xn--o39acdefghijk5883jma.com")
+  end
+
+  it "should convert " +
+      "'\347\242\274\346\250\231\346\272\226\350" +
+      "\220\254\345\234\213\347\242\274.com' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "\347\242\274\346\250\231\346\272\226\350" +
+      "\220\254\345\234\213\347\242\274.com"
+    )).to eq("xn--9cs565brid46mda086o.com")
+  end
+
+  it "should convert 'ﾘ宠퐱〹.com' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "\357\276\230\345\256\240\355\220\261\343\200\271.com"
+    )).to eq("xn--eek174hoxfpr4k.com")
+  end
+
+  it "should convert 'リ宠퐱卄.com' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "\343\203\252\345\256\240\355\220\261\345\215\204.com"
+    )).to eq("xn--eek174hoxfpr4k.com")
+  end
+
+  it "should convert 'ᆵ' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "\341\206\265"
+    )).to eq("xn--4ud")
+  end
+
+  it "should convert 'ﾯ' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "\357\276\257"
+    )).to eq("xn--4ud")
+  end
+
+  it "should convert '🌹🌹🌹.ws' correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "\360\237\214\271\360\237\214\271\360\237\214\271.ws"
+    )).to eq("xn--2h8haa.ws")
+  end
+
+  it "should handle two adjacent '.'s correctly" do
+    expect(Addressable::IDNA.to_ascii(
+      "example..host"
+    )).to eq("example..host")
+  end
+end
+
+shared_examples_for "converting from ASCII to unicode" do
+  long = 'AcinusFallumTrompetumNullunCreditumVisumEstAtCuadLongumEtCefallum.com'
+  it "should convert '#{long}' correctly" do
+    expect(Addressable::IDNA.to_unicode(long)).to eq(long)
+  end
+
+  it "should return the identity conversion when punycode decode fails" do
+    expect(Addressable::IDNA.to_unicode("xn--zckp1cyg1.sblo.jp")).to eq(
+      "xn--zckp1cyg1.sblo.jp")
+  end
+
+  it "should return the identity conversion when the ACE prefix has no suffix" do
+    expect(Addressable::IDNA.to_unicode("xn--...-")).to eq("xn--...-")
+  end
+
+  it "should convert 'www.google.com' correctly" do
+    expect(Addressable::IDNA.to_unicode("www.google.com")).to eq(
+      "www.google.com")
+  end
+
+  it "should convert 'www.詹姆斯.com' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "www.xn--8ws00zhy3a.com"
+    )).to eq("www.詹姆斯.com")
+  end
+
+  it "should convert '詹姆斯.com' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--8ws00zhy3a.com"
+    )).to eq("詹姆斯.com")
+  end
+
+  it "should convert 'www.iñtërnâtiônàlizætiøn.com' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "www.xn--itrntinliztin-vdb0a5exd8ewcye.com"
+    )).to eq("www.iñtërnâtiônàlizætiøn.com")
+  end
+
+  it "should convert 'iñtërnâtiônàlizætiøn.com' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--itrntinliztin-vdb0a5exd8ewcye.com"
+    )).to eq("iñtërnâtiônàlizætiøn.com")
+  end
+
+  it "should convert " +
+      "'www.ほんとうにながいわけのわからないどめいんめいのらべるまだながくしないとたりない.w3.mag.keio.ac.jp' " +
+      "correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "www.xn--n8jaaaaai5bhf7as8fsfk3jnknefdde3" +
+      "fg11amb5gzdb4wi9bya3kc6lra.w3.mag.keio.ac.jp"
+    )).to eq(
+      "www.ほんとうにながいわけのわからないどめいんめいのらべるまだながくしないとたりない.w3.mag.keio.ac.jp"
+    )
+  end
+
+  it "should convert '点心和烤鸭.w3.mag.keio.ac.jp' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--0trv4xfvn8el34t.w3.mag.keio.ac.jp"
+    )).to eq("点心和烤鸭.w3.mag.keio.ac.jp")
+  end
+
+  it "should convert '가각갂갃간갅갆갇갈갉힢힣.com' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--o39acdefghijk5883jma.com"
+    )).to eq("가각갂갃간갅갆갇갈갉힢힣.com")
+  end
+
+  it "should convert " +
+      "'\347\242\274\346\250\231\346\272\226\350" +
+      "\220\254\345\234\213\347\242\274.com' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--9cs565brid46mda086o.com"
+    )).to eq(
+      "\347\242\274\346\250\231\346\272\226\350" +
+      "\220\254\345\234\213\347\242\274.com"
+    )
+  end
+
+  it "should convert 'リ宠퐱卄.com' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--eek174hoxfpr4k.com"
+    )).to eq("\343\203\252\345\256\240\355\220\261\345\215\204.com")
+  end
+
+  it "should convert 'ﾯ' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--4ud"
+    )).to eq("\341\206\265")
+  end
+
+  it "should convert '🌹🌹🌹.ws' correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "xn--2h8haa.ws"
+    )).to eq("\360\237\214\271\360\237\214\271\360\237\214\271.ws")
+  end
+
+  it "should handle two adjacent '.'s correctly" do
+    expect(Addressable::IDNA.to_unicode(
+      "example..host"
+    )).to eq("example..host")
+  end
+end
+
+describe Addressable::IDNA, "when using the pure-Ruby implementation" do
+  before do
+    Addressable.send(:remove_const, :IDNA)
+    load "addressable/idna/pure.rb"
+  end
+
+  it_should_behave_like "converting from unicode to ASCII"
+  it_should_behave_like "converting from ASCII to unicode"
+
+  begin
+    require "fiber"
+
+    it "should not blow up inside fibers" do
+      f = Fiber.new do
+        Addressable.send(:remove_const, :IDNA)
+        load "addressable/idna/pure.rb"
+      end
+      f.resume
+    end
+  rescue LoadError
+    # Fibers aren't supported in this version of Ruby, skip this test.
+    warn('Fibers unsupported.')
+  end
+end
+
+begin
+  require "idn"
+
+  describe Addressable::IDNA, "when using the native-code implementation" do
+    before do
+      Addressable.send(:remove_const, :IDNA)
+      load "addressable/idna/native.rb"
+    end
+
+    it_should_behave_like "converting from unicode to ASCII"
+    it_should_behave_like "converting from ASCII to unicode"
+  end
+rescue LoadError => error
+  raise error if ENV["CI"] && TestHelper.native_supported?
+
+  # Cannot test the native implementation without libidn support.
+  warn('Could not load native IDN implementation.')
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/net_http_compat_spec.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/net_http_compat_spec.rb
new file mode 100644
index 0000000..d07a43e
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/net_http_compat_spec.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Copyright (C) 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 "spec_helper"
+
+require "addressable/uri"
+require "net/http"
+
+describe Net::HTTP do
+  it "should be compatible with Addressable" do
+    response_body =
+      Net::HTTP.get(Addressable::URI.parse('http://www.google.com/'))
+    expect(response_body).not_to be_nil
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/security_spec.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/security_spec.rb
new file mode 100644
index 0000000..3bf90a2
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/security_spec.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Copyright (C) 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 "spec_helper"
+
+require "addressable/uri"
+
+describe Addressable::URI, "when created with a URI known to cause crashes " +
+    "in certain browsers" do
+  it "should parse correctly" do
+    uri = Addressable::URI.parse('%%30%30')
+    expect(uri.path).to eq('%%30%30')
+    expect(uri.normalize.path).to eq('%2500')
+  end
+
+  it "should parse correctly as a full URI" do
+    uri = Addressable::URI.parse('http://www.example.com/%%30%30')
+    expect(uri.path).to eq('/%%30%30')
+    expect(uri.normalize.path).to eq('/%2500')
+  end
+end
+
+describe Addressable::URI, "when created with a URI known to cause crashes " +
+    "in certain browsers" do
+  it "should parse correctly" do
+    uri = Addressable::URI.parse('لُصّبُلُلصّبُررً ॣ ॣh ॣ ॣ 冗')
+    expect(uri.path).to eq('لُصّبُلُلصّبُررً ॣ ॣh ॣ ॣ 冗')
+    expect(uri.normalize.path).to eq(
+      '%D9%84%D9%8F%D8%B5%D9%91%D8%A8%D9%8F%D9%84%D9%8F%D9%84%D8%B5%D9%91' +
+      '%D8%A8%D9%8F%D8%B1%D8%B1%D9%8B%20%E0%A5%A3%20%E0%A5%A3h%20%E0%A5' +
+      '%A3%20%E0%A5%A3%20%E5%86%97'
+    )
+  end
+
+  it "should parse correctly as a full URI" do
+    uri = Addressable::URI.parse('http://www.example.com/لُصّبُلُلصّبُررً ॣ ॣh ॣ ॣ 冗')
+    expect(uri.path).to eq('/لُصّبُلُلصّبُررً ॣ ॣh ॣ ॣ 冗')
+    expect(uri.normalize.path).to eq(
+      '/%D9%84%D9%8F%D8%B5%D9%91%D8%A8%D9%8F%D9%84%D9%8F%D9%84%D8%B5%D9%91' +
+      '%D8%A8%D9%8F%D8%B1%D8%B1%D9%8B%20%E0%A5%A3%20%E0%A5%A3h%20%E0%A5' +
+      '%A3%20%E0%A5%A3%20%E5%86%97'
+    )
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/template_spec.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/template_spec.rb
new file mode 100644
index 0000000..24616c2
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/template_spec.rb
@@ -0,0 +1,1264 @@
+# frozen_string_literal: true
+
+# Copyright (C) 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 "spec_helper"
+
+require "bigdecimal"
+require "timeout"
+require "addressable/template"
+
+shared_examples_for 'expands' do |tests|
+  tests.each do |template, expansion|
+    exp = expansion.is_a?(Array) ? expansion.first : expansion
+    it "#{template} to #{exp}" do
+      tmpl = Addressable::Template.new(template).expand(subject)
+      expect(tmpl.to_str).to eq(expansion)
+    end
+  end
+end
+
+describe "eql?" do
+  let(:template) { Addressable::Template.new('https://www.example.com/{foo}') }
+  it 'is equal when the pattern matches' do
+    other_template = Addressable::Template.new('https://www.example.com/{foo}')
+    expect(template).to be_eql(other_template)
+    expect(other_template).to be_eql(template)
+  end
+  it 'is not equal when the pattern differs' do
+    other_template = Addressable::Template.new('https://www.example.com/{bar}')
+    expect(template).to_not be_eql(other_template)
+    expect(other_template).to_not be_eql(template)
+  end
+  it 'is not equal to non-templates' do
+    uri = 'https://www.example.com/foo/bar'
+    addressable_template = Addressable::Template.new uri
+    addressable_uri = Addressable::URI.parse uri
+    expect(addressable_template).to_not be_eql(addressable_uri)
+    expect(addressable_uri).to_not be_eql(addressable_template)
+  end
+end
+
+describe "==" do
+  let(:template) { Addressable::Template.new('https://www.example.com/{foo}') }
+  it 'is equal when the pattern matches' do
+    other_template = Addressable::Template.new('https://www.example.com/{foo}')
+    expect(template).to eq other_template
+    expect(other_template).to eq template
+  end
+  it 'is not equal when the pattern differs' do
+    other_template = Addressable::Template.new('https://www.example.com/{bar}')
+    expect(template).not_to eq other_template
+    expect(other_template).not_to eq template
+  end
+  it 'is not equal to non-templates' do
+    uri = 'https://www.example.com/foo/bar'
+    addressable_template = Addressable::Template.new uri
+    addressable_uri = Addressable::URI.parse uri
+    expect(addressable_template).not_to eq addressable_uri
+    expect(addressable_uri).not_to eq addressable_template
+  end
+end
+
+describe "#to_regexp" do
+  it "does not match the first line of multiline strings" do
+    uri = "https://www.example.com/bar"
+    template = Addressable::Template.new(uri)
+    expect(template.match(uri)).not_to be_nil
+    expect(template.match("#{uri}\ngarbage")).to be_nil
+  end
+end
+
+describe "Type conversion" do
+  subject {
+    {
+      :var => true,
+      :hello => 1234,
+      :nothing => nil,
+      :sym => :symbolic,
+      :decimal => BigDecimal('1')
+    }
+  }
+
+  it_behaves_like 'expands', {
+    '{var}' => 'true',
+    '{hello}' => '1234',
+    '{nothing}' => '',
+    '{sym}' => 'symbolic',
+    '{decimal}' => RUBY_VERSION < '2.4.0' ? '0.1E1' : '0.1e1'
+  }
+end
+
+describe "Level 1:" do
+  subject {
+    {:var => "value", :hello => "Hello World!"}
+  }
+  it_behaves_like 'expands', {
+    '{var}' => 'value',
+    '{hello}' => 'Hello%20World%21'
+  }
+end
+
+describe "Level 2" do
+  subject {
+    {
+      :var => "value",
+      :hello => "Hello World!",
+      :path => "/foo/bar"
+    }
+  }
+  context "Operator +:" do
+    it_behaves_like 'expands', {
+      '{+var}' => 'value',
+      '{+hello}' => 'Hello%20World!',
+      '{+path}/here' => '/foo/bar/here',
+      'here?ref={+path}' => 'here?ref=/foo/bar'
+    }
+  end
+  context "Operator #:" do
+    it_behaves_like 'expands', {
+      'X{#var}' => 'X#value',
+      'X{#hello}' => 'X#Hello%20World!'
+    }
+  end
+end
+
+describe "Level 3" do
+  subject {
+    {
+      :var => "value",
+      :hello => "Hello World!",
+      :empty => "",
+      :path => "/foo/bar",
+      :x => "1024",
+      :y => "768"
+    }
+  }
+  context "Operator nil (multiple vars):" do
+    it_behaves_like 'expands', {
+      'map?{x,y}' => 'map?1024,768',
+      '{x,hello,y}' => '1024,Hello%20World%21,768'
+    }
+  end
+  context "Operator + (multiple vars):" do
+    it_behaves_like 'expands', {
+      '{+x,hello,y}' => '1024,Hello%20World!,768',
+      '{+path,x}/here' => '/foo/bar,1024/here'
+    }
+  end
+  context "Operator # (multiple vars):" do
+    it_behaves_like 'expands', {
+      '{#x,hello,y}' => '#1024,Hello%20World!,768',
+      '{#path,x}/here' => '#/foo/bar,1024/here'
+    }
+  end
+  context "Operator ." do
+    it_behaves_like 'expands', {
+      'X{.var}' => 'X.value',
+      'X{.x,y}' => 'X.1024.768'
+    }
+  end
+  context "Operator /" do
+    it_behaves_like 'expands', {
+      '{/var}' => '/value',
+      '{/var,x}/here' => '/value/1024/here'
+    }
+  end
+  context "Operator ;" do
+    it_behaves_like 'expands', {
+      '{;x,y}' => ';x=1024;y=768',
+      '{;x,y,empty}' => ';x=1024;y=768;empty'
+    }
+  end
+  context "Operator ?" do
+    it_behaves_like 'expands', {
+      '{?x,y}' => '?x=1024&y=768',
+      '{?x,y,empty}' => '?x=1024&y=768&empty='
+    }
+  end
+  context "Operator &" do
+    it_behaves_like 'expands', {
+      '?fixed=yes{&x}' => '?fixed=yes&x=1024',
+      '{&x,y,empty}' => '&x=1024&y=768&empty='
+    }
+  end
+end
+
+describe "Level 4" do
+  subject {
+    {
+      :var => "value",
+      :hello => "Hello World!",
+      :path => "/foo/bar",
+      :semi => ";",
+      :list => %w(red green blue),
+      :keys => {"semi" => ';', "dot" => '.', :comma => ','}
+    }
+  }
+  context "Expansion with value modifiers" do
+    it_behaves_like 'expands', {
+      '{var:3}' => 'val',
+      '{var:30}' => 'value',
+      '{list}' => 'red,green,blue',
+      '{list*}' => 'red,green,blue',
+      '{keys}' => 'semi,%3B,dot,.,comma,%2C',
+      '{keys*}' => 'semi=%3B,dot=.,comma=%2C',
+    }
+  end
+  context "Operator + with value modifiers" do
+    it_behaves_like 'expands', {
+      '{+path:6}/here' => '/foo/b/here',
+      '{+list}' => 'red,green,blue',
+      '{+list*}' => 'red,green,blue',
+      '{+keys}' => 'semi,;,dot,.,comma,,',
+      '{+keys*}' => 'semi=;,dot=.,comma=,',
+    }
+  end
+  context "Operator # with value modifiers" do
+    it_behaves_like 'expands', {
+      '{#path:6}/here' => '#/foo/b/here',
+      '{#list}' => '#red,green,blue',
+      '{#list*}' => '#red,green,blue',
+      '{#keys}' => '#semi,;,dot,.,comma,,',
+      '{#keys*}' => '#semi=;,dot=.,comma=,',
+    }
+  end
+  context "Operator . with value modifiers" do
+    it_behaves_like 'expands', {
+      'X{.var:3}' => 'X.val',
+      'X{.list}' => 'X.red,green,blue',
+      'X{.list*}' => 'X.red.green.blue',
+      'X{.keys}' => 'X.semi,%3B,dot,.,comma,%2C',
+      'X{.keys*}' => 'X.semi=%3B.dot=..comma=%2C',
+    }
+  end
+  context "Operator / with value modifiers" do
+    it_behaves_like 'expands', {
+      '{/var:1,var}' => '/v/value',
+      '{/list}' => '/red,green,blue',
+      '{/list*}' => '/red/green/blue',
+      '{/list*,path:4}' => '/red/green/blue/%2Ffoo',
+      '{/keys}' => '/semi,%3B,dot,.,comma,%2C',
+      '{/keys*}' => '/semi=%3B/dot=./comma=%2C',
+    }
+  end
+  context "Operator ; with value modifiers" do
+    it_behaves_like 'expands', {
+      '{;hello:5}' => ';hello=Hello',
+      '{;list}' => ';list=red,green,blue',
+      '{;list*}' => ';list=red;list=green;list=blue',
+      '{;keys}' => ';keys=semi,%3B,dot,.,comma,%2C',
+      '{;keys*}' => ';semi=%3B;dot=.;comma=%2C',
+    }
+  end
+  context "Operator ? with value modifiers" do
+    it_behaves_like 'expands', {
+      '{?var:3}' => '?var=val',
+      '{?list}' => '?list=red,green,blue',
+      '{?list*}' => '?list=red&list=green&list=blue',
+      '{?keys}' => '?keys=semi,%3B,dot,.,comma,%2C',
+      '{?keys*}' => '?semi=%3B&dot=.&comma=%2C',
+    }
+  end
+  context "Operator & with value modifiers" do
+    it_behaves_like 'expands', {
+      '{&var:3}' => '&var=val',
+      '{&list}' => '&list=red,green,blue',
+      '{&list*}' => '&list=red&list=green&list=blue',
+      '{&keys}' => '&keys=semi,%3B,dot,.,comma,%2C',
+      '{&keys*}' => '&semi=%3B&dot=.&comma=%2C',
+    }
+  end
+end
+describe "Modifiers" do
+  subject {
+    {
+      :var => "value",
+      :semi => ";",
+      :year => [1965, 2000, 2012],
+      :dom => %w(example com)
+    }
+  }
+  context "length" do
+    it_behaves_like 'expands', {
+      '{var:3}' => 'val',
+      '{var:30}' => 'value',
+      '{var}' => 'value',
+      '{semi}' => '%3B',
+      '{semi:2}' => '%3B'
+    }
+  end
+  context "explode" do
+    it_behaves_like 'expands', {
+      'find{?year*}' => 'find?year=1965&year=2000&year=2012',
+      'www{.dom*}' => 'www.example.com',
+    }
+  end
+end
+describe "Expansion" do
+  subject {
+    {
+      :count => ["one", "two", "three"],
+      :dom => ["example", "com"],
+      :dub   => "me/too",
+      :hello => "Hello World!",
+      :half  => "50%",
+      :var   => "value",
+      :who   => "fred",
+      :base  => "http://example.com/home/",
+      :path  => "/foo/bar",
+      :list  => ["red", "green", "blue"],
+      :keys  => {"semi" => ";","dot" => ".",:comma => ","},
+      :v     => "6",
+      :x     => "1024",
+      :y     => "768",
+      :empty => "",
+      :empty_keys  => {},
+      :undef => nil
+    }
+  }
+  context "concatenation" do
+    it_behaves_like 'expands', {
+      '{count}' => 'one,two,three',
+      '{count*}' => 'one,two,three',
+      '{/count}' => '/one,two,three',
+      '{/count*}' => '/one/two/three',
+      '{;count}' => ';count=one,two,three',
+      '{;count*}' => ';count=one;count=two;count=three',
+      '{?count}' => '?count=one,two,three',
+      '{?count*}' => '?count=one&count=two&count=three',
+      '{&count*}' => '&count=one&count=two&count=three'
+    }
+  end
+  context "simple expansion" do
+    it_behaves_like 'expands', {
+      '{var}' => 'value',
+      '{hello}' => 'Hello%20World%21',
+      '{half}' => '50%25',
+      'O{empty}X' => 'OX',
+      'O{undef}X' => 'OX',
+      '{x,y}' => '1024,768',
+      '{x,hello,y}' => '1024,Hello%20World%21,768',
+      '?{x,empty}' => '?1024,',
+      '?{x,undef}' => '?1024',
+      '?{undef,y}' => '?768',
+      '{var:3}' => 'val',
+      '{var:30}' => 'value',
+      '{list}' => 'red,green,blue',
+      '{list*}' => 'red,green,blue',
+      '{keys}' => 'semi,%3B,dot,.,comma,%2C',
+      '{keys*}' => 'semi=%3B,dot=.,comma=%2C',
+    }
+  end
+  context "reserved expansion (+)" do
+    it_behaves_like 'expands', {
+      '{+var}' => 'value',
+      '{+hello}' => 'Hello%20World!',
+      '{+half}' => '50%25',
+      '{base}index' => 'http%3A%2F%2Fexample.com%2Fhome%2Findex',
+      '{+base}index' => 'http://example.com/home/index',
+      'O{+empty}X' => 'OX',
+      'O{+undef}X' => 'OX',
+      '{+path}/here' => '/foo/bar/here',
+      'here?ref={+path}' => 'here?ref=/foo/bar',
+      'up{+path}{var}/here' => 'up/foo/barvalue/here',
+      '{+x,hello,y}' => '1024,Hello%20World!,768',
+      '{+path,x}/here' => '/foo/bar,1024/here',
+      '{+path:6}/here' => '/foo/b/here',
+      '{+list}' => 'red,green,blue',
+      '{+list*}' => 'red,green,blue',
+      '{+keys}' => 'semi,;,dot,.,comma,,',
+      '{+keys*}' => 'semi=;,dot=.,comma=,',
+    }
+  end
+  context "fragment expansion (#)" do
+    it_behaves_like 'expands', {
+      '{#var}' => '#value',
+      '{#hello}' => '#Hello%20World!',
+      '{#half}' => '#50%25',
+      'foo{#empty}' => 'foo#',
+      'foo{#undef}' => 'foo',
+      '{#x,hello,y}' => '#1024,Hello%20World!,768',
+      '{#path,x}/here' => '#/foo/bar,1024/here',
+      '{#path:6}/here' => '#/foo/b/here',
+      '{#list}' => '#red,green,blue',
+      '{#list*}' => '#red,green,blue',
+      '{#keys}' => '#semi,;,dot,.,comma,,',
+      '{#keys*}' => '#semi=;,dot=.,comma=,',
+    }
+  end
+  context "label expansion (.)" do
+    it_behaves_like 'expands', {
+      '{.who}' => '.fred',
+      '{.who,who}' => '.fred.fred',
+      '{.half,who}' => '.50%25.fred',
+      'www{.dom*}' => 'www.example.com',
+      'X{.var}' => 'X.value',
+      'X{.empty}' => 'X.',
+      'X{.undef}' => 'X',
+      'X{.var:3}' => 'X.val',
+      'X{.list}' => 'X.red,green,blue',
+      'X{.list*}' => 'X.red.green.blue',
+      'X{.keys}' => 'X.semi,%3B,dot,.,comma,%2C',
+      'X{.keys*}' => 'X.semi=%3B.dot=..comma=%2C',
+      'X{.empty_keys}' => 'X',
+      'X{.empty_keys*}' => 'X'
+    }
+  end
+  context "path expansion (/)" do
+    it_behaves_like 'expands', {
+      '{/who}' => '/fred',
+      '{/who,who}' => '/fred/fred',
+      '{/half,who}' => '/50%25/fred',
+      '{/who,dub}' => '/fred/me%2Ftoo',
+      '{/var}' => '/value',
+      '{/var,empty}' => '/value/',
+      '{/var,undef}' => '/value',
+      '{/var,x}/here' => '/value/1024/here',
+      '{/var:1,var}' => '/v/value',
+      '{/list}' => '/red,green,blue',
+      '{/list*}' => '/red/green/blue',
+      '{/list*,path:4}' => '/red/green/blue/%2Ffoo',
+      '{/keys}' => '/semi,%3B,dot,.,comma,%2C',
+      '{/keys*}' => '/semi=%3B/dot=./comma=%2C',
+    }
+  end
+  context "path-style expansion (;)" do
+    it_behaves_like 'expands', {
+      '{;who}' => ';who=fred',
+      '{;half}' => ';half=50%25',
+      '{;empty}' => ';empty',
+      '{;v,empty,who}' => ';v=6;empty;who=fred',
+      '{;v,bar,who}' => ';v=6;who=fred',
+      '{;x,y}' => ';x=1024;y=768',
+      '{;x,y,empty}' => ';x=1024;y=768;empty',
+      '{;x,y,undef}' => ';x=1024;y=768',
+      '{;hello:5}' => ';hello=Hello',
+      '{;list}' => ';list=red,green,blue',
+      '{;list*}' => ';list=red;list=green;list=blue',
+      '{;keys}' => ';keys=semi,%3B,dot,.,comma,%2C',
+      '{;keys*}' => ';semi=%3B;dot=.;comma=%2C',
+    }
+  end
+  context "form query expansion (?)" do
+    it_behaves_like 'expands', {
+      '{?who}' => '?who=fred',
+      '{?half}' => '?half=50%25',
+      '{?x,y}' => '?x=1024&y=768',
+      '{?x,y,empty}' => '?x=1024&y=768&empty=',
+      '{?x,y,undef}' => '?x=1024&y=768',
+      '{?var:3}' => '?var=val',
+      '{?list}' => '?list=red,green,blue',
+      '{?list*}' => '?list=red&list=green&list=blue',
+      '{?keys}' => '?keys=semi,%3B,dot,.,comma,%2C',
+      '{?keys*}' => '?semi=%3B&dot=.&comma=%2C',
+    }
+  end
+  context "form query expansion (&)" do
+    it_behaves_like 'expands', {
+      '{&who}' => '&who=fred',
+      '{&half}' => '&half=50%25',
+      '?fixed=yes{&x}' => '?fixed=yes&x=1024',
+      '{&x,y,empty}' => '&x=1024&y=768&empty=',
+      '{&x,y,undef}' => '&x=1024&y=768',
+      '{&var:3}' => '&var=val',
+      '{&list}' => '&list=red,green,blue',
+      '{&list*}' => '&list=red&list=green&list=blue',
+      '{&keys}' => '&keys=semi,%3B,dot,.,comma,%2C',
+      '{&keys*}' => '&semi=%3B&dot=.&comma=%2C',
+    }
+  end
+  context "non-string key in match data" do
+    subject {Addressable::Template.new("http://example.com/{one}")}
+
+    it "raises TypeError" do
+      expect { subject.expand(Object.new => "1") }.to raise_error TypeError
+    end
+  end
+end
+
+class ExampleTwoProcessor
+  def self.restore(name, value)
+    return value.gsub(/-/, " ") if name == "query"
+    return value
+  end
+
+  def self.match(name)
+    return ".*?" if name == "first"
+    return ".*"
+  end
+  def self.validate(name, value)
+    return !!(value =~ /^[\w ]+$/) if name == "query"
+    return true
+  end
+
+  def self.transform(name, value)
+    return value.gsub(/ /, "+") if name == "query"
+    return value
+  end
+end
+
+class DumbProcessor
+  def self.match(name)
+    return ".*?" if name == "first"
+  end
+end
+
+describe Addressable::Template do
+  describe 'initialize' do
+    context 'with a non-string' do
+      it 'raises a TypeError' do
+        expect { Addressable::Template.new(nil) }.to raise_error(TypeError)
+      end
+    end
+  end
+
+  describe 'freeze' do
+    subject { Addressable::Template.new("http://example.com/{first}/{+second}/") }
+    it 'freezes the template' do
+      expect(subject.freeze).to be_frozen
+    end
+  end
+
+  describe "Matching" do
+    let(:uri){
+      Addressable::URI.parse(
+        "http://example.com/search/an-example-search-query/"
+      )
+    }
+    let(:uri2){
+      Addressable::URI.parse("http://example.com/a/b/c/")
+    }
+    let(:uri3){
+      Addressable::URI.parse("http://example.com/;a=1;b=2;c=3;first=foo")
+    }
+    let(:uri4){
+      Addressable::URI.parse("http://example.com/?a=1&b=2&c=3&first=foo")
+    }
+    let(:uri5){
+      "http://example.com/foo"
+    }
+    context "first uri with ExampleTwoProcessor" do
+      subject {
+        Addressable::Template.new(
+          "http://example.com/search/{query}/"
+        ).match(uri, ExampleTwoProcessor)
+      }
+      its(:variables){ should == ["query"] }
+      its(:captures){ should == ["an example search query"] }
+    end
+
+    context "second uri with ExampleTwoProcessor" do
+      subject {
+        Addressable::Template.new(
+          "http://example.com/{first}/{+second}/"
+        ).match(uri2, ExampleTwoProcessor)
+      }
+      its(:variables){ should == ["first", "second"] }
+      its(:captures){ should == ["a", "b/c"] }
+    end
+
+    context "second uri with DumbProcessor" do
+      subject {
+        Addressable::Template.new(
+          "http://example.com/{first}/{+second}/"
+        ).match(uri2, DumbProcessor)
+      }
+      its(:variables){ should == ["first", "second"] }
+      its(:captures){ should == ["a", "b/c"] }
+    end
+
+    context "second uri" do
+      subject {
+        Addressable::Template.new(
+          "http://example.com/{first}{/second*}/"
+        ).match(uri2)
+      }
+      its(:variables){ should == ["first", "second"] }
+      its(:captures){ should == ["a", ["b","c"]] }
+    end
+    context "third uri" do
+      subject {
+        Addressable::Template.new(
+          "http://example.com/{;hash*,first}"
+        ).match(uri3)
+      }
+      its(:variables){ should == ["hash", "first"] }
+      its(:captures){ should == [
+        {"a" => "1", "b" => "2", "c" => "3", "first" => "foo"}, nil] }
+    end
+    # Note that this expansion is impossible to revert deterministically - the
+    # * operator means first could have been a key of hash or a separate key.
+    # Semantically, a separate key is more likely, but both are possible.
+    context "fourth uri" do
+      subject {
+        Addressable::Template.new(
+          "http://example.com/{?hash*,first}"
+        ).match(uri4)
+      }
+      its(:variables){ should == ["hash", "first"] }
+      its(:captures){ should == [
+        {"a" => "1", "b" => "2", "c" => "3", "first"=> "foo"}, nil] }
+    end
+    context "fifth uri" do
+      subject {
+        Addressable::Template.new(
+          "http://example.com/{path}{?hash*,first}"
+        ).match(uri5)
+      }
+      its(:variables){ should == ["path", "hash", "first"] }
+      its(:captures){ should == ["foo", nil, nil] }
+    end
+  end
+
+  describe 'match' do
+    subject { Addressable::Template.new('http://example.com/first/second/') }
+    context 'when the URI is the same as the template' do
+      it 'returns the match data itself with an empty mapping' do
+        uri = Addressable::URI.parse('http://example.com/first/second/')
+        match_data = subject.match(uri)
+        expect(match_data).to be_an Addressable::Template::MatchData
+        expect(match_data.uri).to eq(uri)
+        expect(match_data.template).to eq(subject)
+        expect(match_data.mapping).to be_empty
+        expect(match_data.inspect).to be_an String
+      end
+    end
+  end
+
+  describe "extract" do
+    let(:template) {
+      Addressable::Template.new(
+        "http://{host}{/segments*}/{?one,two,bogus}{#fragment}"
+      )
+    }
+    let(:uri){ "http://example.com/a/b/c/?one=1&two=2#foo" }
+    let(:uri2){ "http://example.com/a/b/c/#foo" }
+    it "should be able to extract with queries" do
+      expect(template.extract(uri)).to eq({
+        "host" => "example.com",
+        "segments" => %w(a b c),
+        "one" => "1",
+        "bogus" => nil,
+        "two" => "2",
+        "fragment" => "foo"
+      })
+    end
+    it "should be able to extract without queries" do
+      expect(template.extract(uri2)).to eq({
+        "host" => "example.com",
+        "segments" => %w(a b c),
+        "one" => nil,
+        "bogus" => nil,
+        "two" => nil,
+        "fragment" => "foo"
+      })
+    end
+
+    context "issue #137" do
+      subject { Addressable::Template.new('/path{?page,per_page}') }
+
+      it "can match empty" do
+        data = subject.extract("/path")
+        expect(data["page"]).to eq(nil)
+        expect(data["per_page"]).to eq(nil)
+        expect(data.keys.sort).to eq(['page', 'per_page'])
+      end
+
+      it "can match first var" do
+        data = subject.extract("/path?page=1")
+        expect(data["page"]).to eq("1")
+        expect(data["per_page"]).to eq(nil)
+        expect(data.keys.sort).to eq(['page', 'per_page'])
+      end
+
+      it "can match second var" do
+        data = subject.extract("/path?per_page=1")
+        expect(data["page"]).to eq(nil)
+        expect(data["per_page"]).to eq("1")
+        expect(data.keys.sort).to eq(['page', 'per_page'])
+      end
+
+      it "can match both vars" do
+        data = subject.extract("/path?page=2&per_page=1")
+        expect(data["page"]).to eq("2")
+        expect(data["per_page"]).to eq("1")
+        expect(data.keys.sort).to eq(['page', 'per_page'])
+      end
+    end
+  end
+
+  describe "Partial expand with symbols" do
+    context "partial_expand with two simple values" do
+      subject {
+        Addressable::Template.new("http://example.com/{one}/{two}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand(:one => "1").pattern).to eq(
+          "http://example.com/1/{two}/"
+        )
+      end
+    end
+    context "partial_expand query with missing param in middle" do
+      subject {
+        Addressable::Template.new("http://example.com/{?one,two,three}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand(:one => "1", :three => "3").pattern).to eq(
+          "http://example.com/?one=1{&two}&three=3/"
+        )
+      end
+    end
+    context "partial_expand form style query with missing param at beginning" do
+      subject {
+        Addressable::Template.new("http://example.com/{?one,two}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand(:two => "2").pattern).to eq(
+          "http://example.com/?two=2{&one}/"
+        )
+      end
+    end
+    context "issue #307 - partial_expand form query with nil params" do
+      subject do
+        Addressable::Template.new("http://example.com/{?one,two,three}/")
+      end
+      it "builds a new pattern with two=nil" do
+        expect(subject.partial_expand(two: nil).pattern).to eq(
+          "http://example.com/{?one}{&three}/"
+        )
+      end
+      it "builds a new pattern with one=nil and two=nil" do
+        expect(subject.partial_expand(one: nil, two: nil).pattern).to eq(
+          "http://example.com/{?three}/"
+        )
+      end
+      it "builds a new pattern with one=1 and two=nil" do
+        expect(subject.partial_expand(one: 1, two: nil).pattern).to eq(
+          "http://example.com/?one=1{&three}/"
+        )
+      end
+      it "builds a new pattern with one=nil and two=2" do
+        expect(subject.partial_expand(one: nil, two: 2).pattern).to eq(
+          "http://example.com/?two=2{&three}/"
+        )
+      end
+      it "builds a new pattern with one=nil" do
+        expect(subject.partial_expand(one: nil).pattern).to eq(
+          "http://example.com/{?two}{&three}/"
+        )
+      end
+    end
+    context "partial_expand with query string" do
+      subject {
+        Addressable::Template.new("http://example.com/{?two,one}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand(:one => "1").pattern).to eq(
+          "http://example.com/?one=1{&two}/"
+        )
+      end
+    end
+    context "partial_expand with path operator" do
+      subject {
+        Addressable::Template.new("http://example.com{/one,two}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand(:one => "1").pattern).to eq(
+          "http://example.com/1{/two}/"
+        )
+      end
+    end
+    context "partial expand with unicode values" do
+      subject do
+        Addressable::Template.new("http://example.com/{resource}/{query}/")
+      end
+      it "normalizes unicode by default" do
+        template = subject.partial_expand("query" => "Cafe\u0301")
+        expect(template.pattern).to eq(
+          "http://example.com/{resource}/Caf%C3%A9/"
+        )
+      end
+
+      it "normalizes as unicode even with wrong encoding specified" do
+        template = subject.partial_expand("query" => "Cafe\u0301".b)
+        expect(template.pattern).to eq(
+          "http://example.com/{resource}/Caf%C3%A9/"
+        )
+      end
+
+      it "raises on invalid unicode input" do
+        expect {
+          subject.partial_expand("query" => "M\xE9thode".b)
+        }.to raise_error(ArgumentError, "invalid byte sequence in UTF-8")
+      end
+
+      it "does not normalize unicode when byte semantics requested" do
+        template = subject.partial_expand({"query" => "Cafe\u0301"}, nil, false)
+        expect(template.pattern).to eq(
+          "http://example.com/{resource}/Cafe%CC%81/"
+        )
+      end
+    end
+  end
+  describe "Partial expand with strings" do
+    context "partial_expand with two simple values" do
+      subject {
+        Addressable::Template.new("http://example.com/{one}/{two}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand("one" => "1").pattern).to eq(
+          "http://example.com/1/{two}/"
+        )
+      end
+    end
+    context "partial_expand query with missing param in middle" do
+      subject {
+        Addressable::Template.new("http://example.com/{?one,two,three}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand("one" => "1", "three" => "3").pattern).to eq(
+          "http://example.com/?one=1{&two}&three=3/"
+        )
+      end
+    end
+    context "partial_expand with query string" do
+      subject {
+        Addressable::Template.new("http://example.com/{?two,one}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand("one" => "1").pattern).to eq(
+          "http://example.com/?one=1{&two}/"
+        )
+      end
+    end
+    context "partial_expand with path operator" do
+      subject {
+        Addressable::Template.new("http://example.com{/one,two}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand("one" => "1").pattern).to eq(
+          "http://example.com/1{/two}/"
+        )
+      end
+    end
+  end
+  describe "Expand" do
+    context "expand with unicode values" do
+      subject do
+        Addressable::Template.new("http://example.com/search/{query}/")
+      end
+      it "normalizes unicode by default" do
+        uri = subject.expand("query" => "Cafe\u0301").to_str
+        expect(uri).to eq("http://example.com/search/Caf%C3%A9/")
+      end
+
+      it "normalizes as unicode even with wrong encoding specified" do
+        uri = subject.expand("query" => "Cafe\u0301".b).to_str
+        expect(uri).to eq("http://example.com/search/Caf%C3%A9/")
+      end
+
+      it "raises on invalid unicode input" do
+        expect {
+          subject.expand("query" => "M\xE9thode".b).to_str
+        }.to raise_error(ArgumentError, "invalid byte sequence in UTF-8")
+      end
+
+      it "does not normalize unicode when byte semantics requested" do
+        uri = subject.expand({ "query" => "Cafe\u0301" }, nil, false).to_str
+        expect(uri).to eq("http://example.com/search/Cafe%CC%81/")
+      end
+    end
+    context "expand with a processor" do
+      subject {
+        Addressable::Template.new("http://example.com/search/{query}/")
+      }
+      it "processes spaces" do
+        expect(subject.expand({"query" => "an example search query"},
+                      ExampleTwoProcessor).to_str).to eq(
+          "http://example.com/search/an+example+search+query/"
+        )
+      end
+      it "validates" do
+        expect{
+          subject.expand({"query" => "Bogus!"},
+                      ExampleTwoProcessor).to_str
+        }.to raise_error(Addressable::Template::InvalidTemplateValueError)
+      end
+    end
+    context "partial_expand query with missing param in middle" do
+      subject {
+        Addressable::Template.new("http://example.com/{?one,two,three}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand("one" => "1", "three" => "3").pattern).to eq(
+          "http://example.com/?one=1{&two}&three=3/"
+        )
+      end
+    end
+    context "partial_expand with query string" do
+      subject {
+        Addressable::Template.new("http://example.com/{?two,one}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand("one" => "1").pattern).to eq(
+          "http://example.com/?one=1{&two}/"
+        )
+      end
+    end
+    context "partial_expand with path operator" do
+      subject {
+        Addressable::Template.new("http://example.com{/one,two}/")
+      }
+      it "builds a new pattern" do
+        expect(subject.partial_expand("one" => "1").pattern).to eq(
+          "http://example.com/1{/two}/"
+        )
+      end
+    end
+  end
+  context "Matching with operators" do
+    describe "Level 1:" do
+      subject { Addressable::Template.new("foo{foo}/{bar}baz") }
+      it "can match" do
+        data = subject.match("foofoo/bananabaz")
+        expect(data.mapping["foo"]).to eq("foo")
+        expect(data.mapping["bar"]).to eq("banana")
+      end
+      it "can fail" do
+        expect(subject.match("bar/foo")).to be_nil
+        expect(subject.match("foobaz")).to be_nil
+      end
+      it "can match empty" do
+        data = subject.match("foo/baz")
+        expect(data.mapping["foo"]).to eq(nil)
+        expect(data.mapping["bar"]).to eq(nil)
+      end
+      it "lists vars" do
+        expect(subject.variables).to eq(["foo", "bar"])
+      end
+    end
+
+    describe "Level 2:" do
+      subject { Addressable::Template.new("foo{+foo}{#bar}baz") }
+      it "can match" do
+        data = subject.match("foo/test/banana#bazbaz")
+        expect(data.mapping["foo"]).to eq("/test/banana")
+        expect(data.mapping["bar"]).to eq("baz")
+      end
+      it "can match empty level 2 #" do
+        data = subject.match("foo/test/bananabaz")
+        expect(data.mapping["foo"]).to eq("/test/banana")
+        expect(data.mapping["bar"]).to eq(nil)
+        data = subject.match("foo/test/banana#baz")
+        expect(data.mapping["foo"]).to eq("/test/banana")
+        expect(data.mapping["bar"]).to eq("")
+      end
+      it "can match empty level 2 +" do
+        data = subject.match("foobaz")
+        expect(data.mapping["foo"]).to eq(nil)
+        expect(data.mapping["bar"]).to eq(nil)
+        data = subject.match("foo#barbaz")
+        expect(data.mapping["foo"]).to eq(nil)
+        expect(data.mapping["bar"]).to eq("bar")
+      end
+      it "lists vars" do
+        expect(subject.variables).to eq(["foo", "bar"])
+      end
+    end
+
+    describe "Level 3:" do
+      context "no operator" do
+        subject { Addressable::Template.new("foo{foo,bar}baz") }
+        it "can match" do
+          data = subject.match("foofoo,barbaz")
+          expect(data.mapping["foo"]).to eq("foo")
+          expect(data.mapping["bar"]).to eq("bar")
+        end
+        it "lists vars" do
+          expect(subject.variables).to eq(["foo", "bar"])
+        end
+      end
+      context "+ operator" do
+        subject { Addressable::Template.new("foo{+foo,bar}baz") }
+        it "can match" do
+          data = subject.match("foofoo/bar,barbaz")
+          expect(data.mapping["bar"]).to eq("foo/bar,bar")
+          expect(data.mapping["foo"]).to eq("")
+        end
+        it "lists vars" do
+          expect(subject.variables).to eq(["foo", "bar"])
+        end
+      end
+      context ". operator" do
+        subject { Addressable::Template.new("foo{.foo,bar}baz") }
+        it "can match" do
+          data = subject.match("foo.foo.barbaz")
+          expect(data.mapping["foo"]).to eq("foo")
+          expect(data.mapping["bar"]).to eq("bar")
+        end
+        it "lists vars" do
+          expect(subject.variables).to eq(["foo", "bar"])
+        end
+      end
+      context "/ operator" do
+        subject { Addressable::Template.new("foo{/foo,bar}baz") }
+        it "can match" do
+          data = subject.match("foo/foo/barbaz")
+          expect(data.mapping["foo"]).to eq("foo")
+          expect(data.mapping["bar"]).to eq("bar")
+        end
+        it "lists vars" do
+          expect(subject.variables).to eq(["foo", "bar"])
+        end
+      end
+      context "; operator" do
+        subject { Addressable::Template.new("foo{;foo,bar,baz}baz") }
+        it "can match" do
+          data = subject.match("foo;foo=bar%20baz;bar=foo;bazbaz")
+          expect(data.mapping["foo"]).to eq("bar baz")
+          expect(data.mapping["bar"]).to eq("foo")
+          expect(data.mapping["baz"]).to eq("")
+        end
+        it "lists vars" do
+          expect(subject.variables).to eq(%w(foo bar baz))
+        end
+      end
+      context "? operator" do
+        context "test" do
+          subject { Addressable::Template.new("foo{?foo,bar}baz") }
+          it "can match" do
+            data = subject.match("foo?foo=bar%20baz&bar=foobaz")
+            expect(data.mapping["foo"]).to eq("bar baz")
+            expect(data.mapping["bar"]).to eq("foo")
+          end
+          it "lists vars" do
+            expect(subject.variables).to eq(%w(foo bar))
+          end
+        end
+
+        context "issue #137" do
+          subject { Addressable::Template.new('/path{?page,per_page}') }
+
+          it "can match empty" do
+            data = subject.match("/path")
+            expect(data.mapping["page"]).to eq(nil)
+            expect(data.mapping["per_page"]).to eq(nil)
+            expect(data.mapping.keys.sort).to eq(['page', 'per_page'])
+          end
+
+          it "can match first var" do
+            data = subject.match("/path?page=1")
+            expect(data.mapping["page"]).to eq("1")
+            expect(data.mapping["per_page"]).to eq(nil)
+            expect(data.mapping.keys.sort).to eq(['page', 'per_page'])
+          end
+
+          it "can match second var" do
+            data = subject.match("/path?per_page=1")
+            expect(data.mapping["page"]).to eq(nil)
+            expect(data.mapping["per_page"]).to eq("1")
+            expect(data.mapping.keys.sort).to eq(['page', 'per_page'])
+          end
+
+          it "can match both vars" do
+            data = subject.match("/path?page=2&per_page=1")
+            expect(data.mapping["page"]).to eq("2")
+            expect(data.mapping["per_page"]).to eq("1")
+            expect(data.mapping.keys.sort).to eq(['page', 'per_page'])
+          end
+        end
+
+        context "issue #71" do
+          subject { Addressable::Template.new("http://cyberscore.dev/api/users{?username}") }
+          it "can match" do
+            data = subject.match("http://cyberscore.dev/api/users?username=foobaz")
+            expect(data.mapping["username"]).to eq("foobaz")
+          end
+          it "lists vars" do
+            expect(subject.variables).to eq(%w(username))
+            expect(subject.keys).to eq(%w(username))
+          end
+        end
+      end
+      context "& operator" do
+        subject { Addressable::Template.new("foo{&foo,bar}baz") }
+        it "can match" do
+          data = subject.match("foo&foo=bar%20baz&bar=foobaz")
+          expect(data.mapping["foo"]).to eq("bar baz")
+          expect(data.mapping["bar"]).to eq("foo")
+        end
+        it "lists vars" do
+          expect(subject.variables).to eq(%w(foo bar))
+        end
+      end
+    end
+  end
+
+  context "support regexes:" do
+    context "EXPRESSION" do
+      subject { Addressable::Template::EXPRESSION }
+      it "should be able to match an expression" do
+        expect(subject).to match("{foo}")
+        expect(subject).to match("{foo,9}")
+        expect(subject).to match("{foo.bar,baz}")
+        expect(subject).to match("{+foo.bar,baz}")
+        expect(subject).to match("{foo,foo%20bar}")
+        expect(subject).to match("{#foo:20,baz*}")
+        expect(subject).to match("stuff{#foo:20,baz*}things")
+      end
+      it "should fail on non vars" do
+        expect(subject).not_to match("!{foo")
+        expect(subject).not_to match("{foo.bar.}")
+        expect(subject).not_to match("!{}")
+      end
+    end
+    context "VARNAME" do
+      subject { Addressable::Template::VARNAME }
+      it "should be able to match a variable" do
+        expect(subject).to match("foo")
+        expect(subject).to match("9")
+        expect(subject).to match("foo.bar")
+        expect(subject).to match("foo_bar")
+        expect(subject).to match("foo_bar.baz")
+        expect(subject).to match("foo%20bar")
+        expect(subject).to match("foo%20bar.baz")
+      end
+      it "should fail on non vars" do
+        expect(subject).not_to match("!foo")
+        expect(subject).not_to match("foo.bar.")
+        expect(subject).not_to match("foo%2%00bar")
+        expect(subject).not_to match("foo_ba%r")
+        expect(subject).not_to match("foo_bar*")
+        expect(subject).not_to match("foo_bar:20")
+      end
+
+      it 'should parse in a reasonable time' do
+        expect do
+          Timeout.timeout(0.1) do
+            expect(subject).not_to match("0"*25 + "!")
+          end
+        end.not_to raise_error
+      end
+    end
+    context "VARIABLE_LIST" do
+      subject { Addressable::Template::VARIABLE_LIST }
+      it "should be able to match a variable list" do
+        expect(subject).to match("foo,bar")
+        expect(subject).to match("foo")
+        expect(subject).to match("foo,bar*,baz")
+        expect(subject).to match("foo.bar,bar_baz*,baz:12")
+      end
+      it "should fail on non vars" do
+        expect(subject).not_to match(",foo,bar*,baz")
+        expect(subject).not_to match("foo,*bar,baz")
+        expect(subject).not_to match("foo,,bar*,baz")
+      end
+    end
+    context "VARSPEC" do
+      subject { Addressable::Template::VARSPEC }
+      it "should be able to match a variable with modifier" do
+        expect(subject).to match("9:8")
+        expect(subject).to match("foo.bar*")
+        expect(subject).to match("foo_bar:12")
+        expect(subject).to match("foo_bar.baz*")
+        expect(subject).to match("foo%20bar:12")
+        expect(subject).to match("foo%20bar.baz*")
+      end
+      it "should fail on non vars" do
+        expect(subject).not_to match("!foo")
+        expect(subject).not_to match("*foo")
+        expect(subject).not_to match("fo*o")
+        expect(subject).not_to match("fo:o")
+        expect(subject).not_to match("foo:")
+      end
+    end
+  end
+end
+
+describe Addressable::Template::MatchData do
+  let(:template) { Addressable::Template.new('{foo}/{bar}') }
+  subject(:its) { template.match('ab/cd') }
+  its(:uri) { should == Addressable::URI.parse('ab/cd') }
+  its(:template) { should == template }
+  its(:mapping) { should == { 'foo' => 'ab', 'bar' => 'cd' } }
+  its(:variables) { should == ['foo', 'bar'] }
+  its(:keys) { should == ['foo', 'bar'] }
+  its(:names) { should == ['foo', 'bar'] }
+  its(:values) { should == ['ab', 'cd'] }
+  its(:captures) { should == ['ab', 'cd'] }
+  its(:to_a) { should == ['ab/cd', 'ab', 'cd'] }
+  its(:to_s) { should == 'ab/cd' }
+  its(:string) { should == its.to_s }
+  its(:pre_match) { should == "" }
+  its(:post_match) { should == "" }
+
+  describe 'values_at' do
+    it 'returns an array with the values' do
+      expect(its.values_at(0, 2)).to eq(['ab/cd', 'cd'])
+    end
+    it 'allows mixing integer an string keys' do
+      expect(its.values_at('foo', 1)).to eq(['ab', 'ab'])
+    end
+    it 'accepts unknown keys' do
+      expect(its.values_at('baz', 'foo')).to eq([nil, 'ab'])
+    end
+  end
+
+  describe '[]' do
+    context 'string key' do
+      it 'returns the corresponding capture' do
+        expect(its['foo']).to eq('ab')
+        expect(its['bar']).to eq('cd')
+      end
+      it 'returns nil for unknown keys' do
+        expect(its['baz']).to be_nil
+      end
+    end
+    context 'symbol key' do
+      it 'returns the corresponding capture' do
+        expect(its[:foo]).to eq('ab')
+        expect(its[:bar]).to eq('cd')
+      end
+      it 'returns nil for unknown keys' do
+        expect(its[:baz]).to be_nil
+      end
+    end
+    context 'integer key' do
+      it 'returns the full URI for index 0' do
+        expect(its[0]).to eq('ab/cd')
+      end
+      it 'returns the corresponding capture' do
+        expect(its[1]).to eq('ab')
+        expect(its[2]).to eq('cd')
+      end
+      it 'returns nil for unknown keys' do
+        expect(its[3]).to be_nil
+      end
+    end
+    context 'other key' do
+      it 'raises an exception' do
+        expect { its[Object.new] }.to raise_error(TypeError)
+      end
+    end
+    context 'with length' do
+      it 'returns an array starting at index with given length' do
+        expect(its[0, 2]).to eq(['ab/cd', 'ab'])
+        expect(its[2, 1]).to eq(['cd'])
+      end
+    end
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/uri_spec.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/uri_spec.rb
new file mode 100644
index 0000000..26ee923
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/addressable/uri_spec.rb
@@ -0,0 +1,6840 @@
+# frozen_string_literal: true
+
+# Copyright (C) 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 "spec_helper"
+
+require "addressable/uri"
+require "uri"
+require "ipaddr"
+require "yaml"
+
+if !"".respond_to?("force_encoding")
+  class String
+    def force_encoding(encoding)
+      @encoding = encoding
+    end
+
+    def encoding
+      @encoding ||= Encoding::ASCII_8BIT
+    end
+  end
+
+  class Encoding
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      return @name
+    end
+
+    UTF_8 = Encoding.new("UTF-8")
+    ASCII_8BIT = Encoding.new("US-ASCII")
+  end
+end
+
+module Fake
+  module URI
+    class HTTP
+      def initialize(uri)
+        @uri = uri
+      end
+
+      def to_s
+        return @uri.to_s
+      end
+
+      alias :to_str :to_s
+    end
+  end
+end
+
+describe Addressable::URI, "when created with a non-numeric port number" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:port => "bogus")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with a invalid encoded port number" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:port => "%eb")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with a non-string scheme" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:scheme => :bogus)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when created with a non-string user" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:user => :bogus)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when created with a non-string password" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:password => :bogus)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when created with a non-string userinfo" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:userinfo => :bogus)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when created with a non-string host" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:host => :bogus)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when created with a non-string authority" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:authority => :bogus)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when created with a non-string path" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:path => :bogus)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when created with a non-string query" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:query => :bogus)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when created with a non-string fragment" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:fragment => :bogus)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when created with a scheme but no hierarchical " +
+    "segment" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.parse("http:")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "quote handling" do
+  describe 'in host name' do
+    it "should raise an error for single quote" do
+      expect do
+        Addressable::URI.parse("http://local\"host/")
+      end.to raise_error(Addressable::URI::InvalidURIError)
+    end
+  end
+end
+
+describe Addressable::URI, "newline normalization" do
+  it "should not accept newlines in scheme" do
+    expect do
+      Addressable::URI.parse("ht%0atp://localhost/")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not unescape newline in path" do
+    uri = Addressable::URI.parse("http://localhost/%0a").normalize
+    expect(uri.to_s).to eq("http://localhost/%0A")
+  end
+
+  it "should not unescape newline in hostname" do
+    uri = Addressable::URI.parse("http://local%0ahost/").normalize
+    expect(uri.to_s).to eq("http://local%0Ahost/")
+  end
+
+  it "should not unescape newline in username" do
+    uri = Addressable::URI.parse("http://foo%0abar@localhost/").normalize
+    expect(uri.to_s).to eq("http://foo%0Abar@localhost/")
+  end
+
+  it "should not unescape newline in username" do
+    uri = Addressable::URI.parse("http://example:foo%0abar@example/").normalize
+    expect(uri.to_s).to eq("http://example:foo%0Abar@example/")
+  end
+
+  it "should not accept newline in hostname" do
+    uri = Addressable::URI.parse("http://localhost/")
+    expect do
+      uri.host = "local\nhost"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with ambiguous path" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.parse("::http")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with an invalid host" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:host => "<invalid>")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with a host consisting of " +
+    "sub-delims characters" do
+  it "should not raise an error" do
+    expect do
+      Addressable::URI.new(
+        :host => Addressable::URI::CharacterClasses::SUB_DELIMS.gsub(/\\/, '')
+      )
+    end.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when created with a host consisting of " +
+    "unreserved characters" do
+  it "should not raise an error" do
+    expect do
+      Addressable::URI.new(
+        :host => Addressable::URI::CharacterClasses::UNRESERVED.gsub(/\\/, '')
+      )
+    end.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when created from nil components" do
+  before do
+    @uri = Addressable::URI.new
+  end
+
+  it "should have a nil site value" do
+    expect(@uri.site).to eq(nil)
+  end
+
+  it "should have an empty path" do
+    expect(@uri.path).to eq("")
+  end
+
+  it "should be an empty uri" do
+    expect(@uri.to_s).to eq("")
+  end
+
+  it "should have a nil default port" do
+    expect(@uri.default_port).to eq(nil)
+  end
+
+  it "should be empty" do
+    expect(@uri).to be_empty
+  end
+
+  it "should raise an error if the scheme is set to whitespace" do
+    expect do
+      @uri.scheme = "\t \n"
+    end.to raise_error(Addressable::URI::InvalidURIError, /'\t \n'/)
+  end
+
+  it "should raise an error if the scheme is set to all digits" do
+    expect do
+      @uri.scheme = "123"
+    end.to raise_error(Addressable::URI::InvalidURIError, /'123'/)
+  end
+
+  it "should raise an error if the scheme begins with a digit" do
+    expect do
+      @uri.scheme = "1scheme"
+    end.to raise_error(Addressable::URI::InvalidURIError, /'1scheme'/)
+  end
+
+  it "should raise an error if the scheme begins with a plus" do
+    expect do
+      @uri.scheme = "+scheme"
+    end.to raise_error(Addressable::URI::InvalidURIError, /'\+scheme'/)
+  end
+
+  it "should raise an error if the scheme begins with a dot" do
+    expect do
+      @uri.scheme = ".scheme"
+    end.to raise_error(Addressable::URI::InvalidURIError, /'\.scheme'/)
+  end
+
+  it "should raise an error if the scheme begins with a dash" do
+    expect do
+      @uri.scheme = "-scheme"
+    end.to raise_error(Addressable::URI::InvalidURIError, /'-scheme'/)
+  end
+
+  it "should raise an error if the scheme contains an illegal character" do
+    expect do
+      @uri.scheme = "scheme!"
+    end.to raise_error(Addressable::URI::InvalidURIError, /'scheme!'/)
+  end
+
+  it "should raise an error if the scheme contains whitespace" do
+    expect do
+      @uri.scheme = "sch eme"
+    end.to raise_error(Addressable::URI::InvalidURIError, /'sch eme'/)
+  end
+
+  it "should raise an error if the scheme contains a newline" do
+    expect do
+      @uri.scheme = "sch\neme"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if set into an invalid state" do
+    expect do
+      @uri.user = "user"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if set into an invalid state" do
+    expect do
+      @uri.password = "pass"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if set into an invalid state" do
+    expect do
+      @uri.scheme = "http"
+      @uri.fragment = "fragment"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if set into an invalid state" do
+    expect do
+      @uri.fragment = "fragment"
+      @uri.scheme = "http"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when initialized from individual components" do
+  before do
+    @uri = Addressable::URI.new(
+      :scheme => "http",
+      :user => "user",
+      :password => "password",
+      :host => "example.com",
+      :port => 8080,
+      :path => "/path",
+      :query => "query=value",
+      :fragment => "fragment"
+    )
+  end
+
+  it "returns 'http' for #scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "returns 'http' for #normalized_scheme" do
+    expect(@uri.normalized_scheme).to eq("http")
+  end
+
+  it "returns 'user' for #user" do
+    expect(@uri.user).to eq("user")
+  end
+
+  it "returns 'user' for #normalized_user" do
+    expect(@uri.normalized_user).to eq("user")
+  end
+
+  it "returns 'password' for #password" do
+    expect(@uri.password).to eq("password")
+  end
+
+  it "returns 'password' for #normalized_password" do
+    expect(@uri.normalized_password).to eq("password")
+  end
+
+  it "returns 'user:password' for #userinfo" do
+    expect(@uri.userinfo).to eq("user:password")
+  end
+
+  it "returns 'user:password' for #normalized_userinfo" do
+    expect(@uri.normalized_userinfo).to eq("user:password")
+  end
+
+  it "returns 'example.com' for #host" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "returns 'example.com' for #normalized_host" do
+    expect(@uri.normalized_host).to eq("example.com")
+  end
+
+  it "returns 'com' for #tld" do
+    expect(@uri.tld).to eq("com")
+  end
+
+  it "returns 'user:password@example.com:8080' for #authority" do
+    expect(@uri.authority).to eq("user:password@example.com:8080")
+  end
+
+  it "returns 'user:password@example.com:8080' for #normalized_authority" do
+    expect(@uri.normalized_authority).to eq("user:password@example.com:8080")
+  end
+
+  it "returns 8080 for #port" do
+    expect(@uri.port).to eq(8080)
+  end
+
+  it "returns 8080 for #normalized_port" do
+    expect(@uri.normalized_port).to eq(8080)
+  end
+
+  it "returns 80 for #default_port" do
+    expect(@uri.default_port).to eq(80)
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #site" do
+    expect(@uri.site).to eq("http://user:password@example.com:8080")
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #normalized_site" do
+    expect(@uri.normalized_site).to eq("http://user:password@example.com:8080")
+  end
+
+  it "returns '/path' for #path" do
+    expect(@uri.path).to eq("/path")
+  end
+
+  it "returns '/path' for #normalized_path" do
+    expect(@uri.normalized_path).to eq("/path")
+  end
+
+  it "returns 'query=value' for #query" do
+    expect(@uri.query).to eq("query=value")
+  end
+
+  it "returns 'query=value' for #normalized_query" do
+    expect(@uri.normalized_query).to eq("query=value")
+  end
+
+  it "returns 'fragment' for #fragment" do
+    expect(@uri.fragment).to eq("fragment")
+  end
+
+  it "returns 'fragment' for #normalized_fragment" do
+    expect(@uri.normalized_fragment).to eq("fragment")
+  end
+
+  it "returns #hash" do
+    expect(@uri.hash).not_to be nil
+  end
+
+  it "returns #to_s" do
+    expect(@uri.to_s).to eq(
+      "http://user:password@example.com:8080/path?query=value#fragment"
+    )
+  end
+
+  it "should not be empty" do
+    expect(@uri).not_to be_empty
+  end
+
+  it "should not be frozen" do
+    expect(@uri).not_to be_frozen
+  end
+
+  it "should allow destructive operations" do
+    expect { @uri.normalize! }.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when initialized from " +
+    "frozen individual components" do
+  before do
+    @uri = Addressable::URI.new(
+      :scheme => "http".freeze,
+      :user => "user".freeze,
+      :password => "password".freeze,
+      :host => "example.com".freeze,
+      :port => "8080".freeze,
+      :path => "/path".freeze,
+      :query => "query=value".freeze,
+      :fragment => "fragment".freeze
+    )
+  end
+
+  it "returns 'http' for #scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "returns 'http' for #normalized_scheme" do
+    expect(@uri.normalized_scheme).to eq("http")
+  end
+
+  it "returns 'user' for #user" do
+    expect(@uri.user).to eq("user")
+  end
+
+  it "returns 'user' for #normalized_user" do
+    expect(@uri.normalized_user).to eq("user")
+  end
+
+  it "returns 'password' for #password" do
+    expect(@uri.password).to eq("password")
+  end
+
+  it "returns 'password' for #normalized_password" do
+    expect(@uri.normalized_password).to eq("password")
+  end
+
+  it "returns 'user:password' for #userinfo" do
+    expect(@uri.userinfo).to eq("user:password")
+  end
+
+  it "returns 'user:password' for #normalized_userinfo" do
+    expect(@uri.normalized_userinfo).to eq("user:password")
+  end
+
+  it "returns 'example.com' for #host" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "returns 'example.com' for #normalized_host" do
+    expect(@uri.normalized_host).to eq("example.com")
+  end
+
+  it "returns 'user:password@example.com:8080' for #authority" do
+    expect(@uri.authority).to eq("user:password@example.com:8080")
+  end
+
+  it "returns 'user:password@example.com:8080' for #normalized_authority" do
+    expect(@uri.normalized_authority).to eq("user:password@example.com:8080")
+  end
+
+  it "returns 8080 for #port" do
+    expect(@uri.port).to eq(8080)
+  end
+
+  it "returns 8080 for #normalized_port" do
+    expect(@uri.normalized_port).to eq(8080)
+  end
+
+  it "returns 80 for #default_port" do
+    expect(@uri.default_port).to eq(80)
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #site" do
+    expect(@uri.site).to eq("http://user:password@example.com:8080")
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #normalized_site" do
+    expect(@uri.normalized_site).to eq("http://user:password@example.com:8080")
+  end
+
+  it "returns '/path' for #path" do
+    expect(@uri.path).to eq("/path")
+  end
+
+  it "returns '/path' for #normalized_path" do
+    expect(@uri.normalized_path).to eq("/path")
+  end
+
+  it "returns 'query=value' for #query" do
+    expect(@uri.query).to eq("query=value")
+  end
+
+  it "returns 'query=value' for #normalized_query" do
+    expect(@uri.normalized_query).to eq("query=value")
+  end
+
+  it "returns 'fragment' for #fragment" do
+    expect(@uri.fragment).to eq("fragment")
+  end
+
+  it "returns 'fragment' for #normalized_fragment" do
+    expect(@uri.normalized_fragment).to eq("fragment")
+  end
+
+  it "returns #hash" do
+    expect(@uri.hash).not_to be nil
+  end
+
+  it "returns #to_s" do
+    expect(@uri.to_s).to eq(
+      "http://user:password@example.com:8080/path?query=value#fragment"
+    )
+  end
+
+  it "should not be empty" do
+    expect(@uri).not_to be_empty
+  end
+
+  it "should not be frozen" do
+    expect(@uri).not_to be_frozen
+  end
+
+  it "should allow destructive operations" do
+    expect { @uri.normalize! }.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when parsed from a frozen string" do
+  before do
+    @uri = Addressable::URI.parse(
+      "http://user:password@example.com:8080/path?query=value#fragment".freeze
+    )
+  end
+
+  it "returns 'http' for #scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "returns 'http' for #normalized_scheme" do
+    expect(@uri.normalized_scheme).to eq("http")
+  end
+
+  it "returns 'user' for #user" do
+    expect(@uri.user).to eq("user")
+  end
+
+  it "returns 'user' for #normalized_user" do
+    expect(@uri.normalized_user).to eq("user")
+  end
+
+  it "returns 'password' for #password" do
+    expect(@uri.password).to eq("password")
+  end
+
+  it "returns 'password' for #normalized_password" do
+    expect(@uri.normalized_password).to eq("password")
+  end
+
+  it "returns 'user:password' for #userinfo" do
+    expect(@uri.userinfo).to eq("user:password")
+  end
+
+  it "returns 'user:password' for #normalized_userinfo" do
+    expect(@uri.normalized_userinfo).to eq("user:password")
+  end
+
+  it "returns 'example.com' for #host" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "returns 'example.com' for #normalized_host" do
+    expect(@uri.normalized_host).to eq("example.com")
+  end
+
+  it "returns 'user:password@example.com:8080' for #authority" do
+    expect(@uri.authority).to eq("user:password@example.com:8080")
+  end
+
+  it "returns 'user:password@example.com:8080' for #normalized_authority" do
+    expect(@uri.normalized_authority).to eq("user:password@example.com:8080")
+  end
+
+  it "returns 8080 for #port" do
+    expect(@uri.port).to eq(8080)
+  end
+
+  it "returns 8080 for #normalized_port" do
+    expect(@uri.normalized_port).to eq(8080)
+  end
+
+  it "returns 80 for #default_port" do
+    expect(@uri.default_port).to eq(80)
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #site" do
+    expect(@uri.site).to eq("http://user:password@example.com:8080")
+  end
+
+  it "returns 'http://user:password@example.com:8080' for #normalized_site" do
+    expect(@uri.normalized_site).to eq("http://user:password@example.com:8080")
+  end
+
+  it "returns '/path' for #path" do
+    expect(@uri.path).to eq("/path")
+  end
+
+  it "returns '/path' for #normalized_path" do
+    expect(@uri.normalized_path).to eq("/path")
+  end
+
+  it "returns 'query=value' for #query" do
+    expect(@uri.query).to eq("query=value")
+  end
+
+  it "returns 'query=value' for #normalized_query" do
+    expect(@uri.normalized_query).to eq("query=value")
+  end
+
+  it "returns 'fragment' for #fragment" do
+    expect(@uri.fragment).to eq("fragment")
+  end
+
+  it "returns 'fragment' for #normalized_fragment" do
+    expect(@uri.normalized_fragment).to eq("fragment")
+  end
+
+  it "returns #hash" do
+    expect(@uri.hash).not_to be nil
+  end
+
+  it "returns #to_s" do
+    expect(@uri.to_s).to eq(
+      "http://user:password@example.com:8080/path?query=value#fragment"
+    )
+  end
+
+  it "should not be empty" do
+    expect(@uri).not_to be_empty
+  end
+
+  it "should not be frozen" do
+    expect(@uri).not_to be_frozen
+  end
+
+  it "should allow destructive operations" do
+    expect { @uri.normalize! }.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when frozen" do
+  before do
+    @uri = Addressable::URI.new.freeze
+  end
+
+  it "returns nil for #scheme" do
+    expect(@uri.scheme).to eq(nil)
+  end
+
+  it "returns nil for #normalized_scheme" do
+    expect(@uri.normalized_scheme).to eq(nil)
+  end
+
+  it "returns nil for #user" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "returns nil for #normalized_user" do
+    expect(@uri.normalized_user).to eq(nil)
+  end
+
+  it "returns nil for #password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "returns nil for #normalized_password" do
+    expect(@uri.normalized_password).to eq(nil)
+  end
+
+  it "returns nil for #userinfo" do
+    expect(@uri.userinfo).to eq(nil)
+  end
+
+  it "returns nil for #normalized_userinfo" do
+    expect(@uri.normalized_userinfo).to eq(nil)
+  end
+
+  it "returns nil for #host" do
+    expect(@uri.host).to eq(nil)
+  end
+
+  it "returns nil for #normalized_host" do
+    expect(@uri.normalized_host).to eq(nil)
+  end
+
+  it "returns nil for #authority" do
+    expect(@uri.authority).to eq(nil)
+  end
+
+  it "returns nil for #normalized_authority" do
+    expect(@uri.normalized_authority).to eq(nil)
+  end
+
+  it "returns nil for #port" do
+    expect(@uri.port).to eq(nil)
+  end
+
+  it "returns nil for #normalized_port" do
+    expect(@uri.normalized_port).to eq(nil)
+  end
+
+  it "returns nil for #default_port" do
+    expect(@uri.default_port).to eq(nil)
+  end
+
+  it "returns nil for #site" do
+    expect(@uri.site).to eq(nil)
+  end
+
+  it "returns nil for #normalized_site" do
+    expect(@uri.normalized_site).to eq(nil)
+  end
+
+  it "returns '' for #path" do
+    expect(@uri.path).to eq('')
+  end
+
+  it "returns '' for #normalized_path" do
+    expect(@uri.normalized_path).to eq('')
+  end
+
+  it "returns nil for #query" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "returns nil for #normalized_query" do
+    expect(@uri.normalized_query).to eq(nil)
+  end
+
+  it "returns nil for #fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+
+  it "returns nil for #normalized_fragment" do
+    expect(@uri.normalized_fragment).to eq(nil)
+  end
+
+  it "returns #hash" do
+    expect(@uri.hash).not_to be nil
+  end
+
+  it "returns #to_s" do
+    expect(@uri.to_s).to eq('')
+  end
+
+  it "should be empty" do
+    expect(@uri).to be_empty
+  end
+
+  it "should be frozen" do
+    expect(@uri).to be_frozen
+  end
+
+  it "should not be frozen after duping" do
+    expect(@uri.dup).not_to be_frozen
+  end
+
+  it "should not allow destructive operations" do
+    expect { @uri.normalize! }.to raise_error { |error|
+      expect(error.message).to match(/can't modify frozen/)
+      expect(error).to satisfy { |e| RuntimeError === e || TypeError === e }
+    }
+  end
+end
+
+describe Addressable::URI, "when frozen" do
+  before do
+    @uri = Addressable::URI.parse(
+      "HTTP://example.com.:%38%30/%70a%74%68?a=%31#1%323"
+    ).freeze
+  end
+
+  it "returns 'HTTP' for #scheme" do
+    expect(@uri.scheme).to eq("HTTP")
+  end
+
+  it "returns 'http' for #normalized_scheme" do
+    expect(@uri.normalized_scheme).to eq("http")
+    expect(@uri.normalize.scheme).to eq("http")
+  end
+
+  it "returns nil for #user" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "returns nil for #normalized_user" do
+    expect(@uri.normalized_user).to eq(nil)
+  end
+
+  it "returns nil for #password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "returns nil for #normalized_password" do
+    expect(@uri.normalized_password).to eq(nil)
+  end
+
+  it "returns nil for #userinfo" do
+    expect(@uri.userinfo).to eq(nil)
+  end
+
+  it "returns nil for #normalized_userinfo" do
+    expect(@uri.normalized_userinfo).to eq(nil)
+  end
+
+  it "returns 'example.com.' for #host" do
+    expect(@uri.host).to eq("example.com.")
+  end
+
+  it "returns nil for #normalized_host" do
+    expect(@uri.normalized_host).to eq("example.com")
+    expect(@uri.normalize.host).to eq("example.com")
+  end
+
+  it "returns 'example.com.:80' for #authority" do
+    expect(@uri.authority).to eq("example.com.:80")
+  end
+
+  it "returns 'example.com:80' for #normalized_authority" do
+    expect(@uri.normalized_authority).to eq("example.com")
+    expect(@uri.normalize.authority).to eq("example.com")
+  end
+
+  it "returns 80 for #port" do
+    expect(@uri.port).to eq(80)
+  end
+
+  it "returns nil for #normalized_port" do
+    expect(@uri.normalized_port).to eq(nil)
+    expect(@uri.normalize.port).to eq(nil)
+  end
+
+  it "returns 80 for #default_port" do
+    expect(@uri.default_port).to eq(80)
+  end
+
+  it "returns 'HTTP://example.com.:80' for #site" do
+    expect(@uri.site).to eq("HTTP://example.com.:80")
+  end
+
+  it "returns 'http://example.com' for #normalized_site" do
+    expect(@uri.normalized_site).to eq("http://example.com")
+    expect(@uri.normalize.site).to eq("http://example.com")
+  end
+
+  it "returns '/%70a%74%68' for #path" do
+    expect(@uri.path).to eq("/%70a%74%68")
+  end
+
+  it "returns '/path' for #normalized_path" do
+    expect(@uri.normalized_path).to eq("/path")
+    expect(@uri.normalize.path).to eq("/path")
+  end
+
+  it "returns 'a=%31' for #query" do
+    expect(@uri.query).to eq("a=%31")
+  end
+
+  it "returns 'a=1' for #normalized_query" do
+    expect(@uri.normalized_query).to eq("a=1")
+    expect(@uri.normalize.query).to eq("a=1")
+  end
+
+  it "returns '/%70a%74%68?a=%31' for #request_uri" do
+    expect(@uri.request_uri).to eq("/%70a%74%68?a=%31")
+  end
+
+  it "returns '1%323' for #fragment" do
+    expect(@uri.fragment).to eq("1%323")
+  end
+
+  it "returns '123' for #normalized_fragment" do
+    expect(@uri.normalized_fragment).to eq("123")
+    expect(@uri.normalize.fragment).to eq("123")
+  end
+
+  it "returns #hash" do
+    expect(@uri.hash).not_to be nil
+  end
+
+  it "returns #to_s" do
+    expect(@uri.to_s).to eq('HTTP://example.com.:80/%70a%74%68?a=%31#1%323')
+    expect(@uri.normalize.to_s).to eq('http://example.com/path?a=1#123')
+  end
+
+  it "should not be empty" do
+    expect(@uri).not_to be_empty
+  end
+
+  it "should be frozen" do
+    expect(@uri).to be_frozen
+  end
+
+  it "should not be frozen after duping" do
+    expect(@uri.dup).not_to be_frozen
+  end
+
+  it "should not allow destructive operations" do
+    expect { @uri.normalize! }.to raise_error { |error|
+      expect(error.message).to match(/can't modify frozen/)
+      expect(error).to satisfy { |e| RuntimeError === e || TypeError === e }
+    }
+  end
+end
+
+describe Addressable::URI, "when normalized and then deeply frozen" do
+  before do
+    @uri = Addressable::URI.parse(
+      "http://user:password@example.com:8080/path?query=value#fragment"
+    ).normalize!
+
+    @uri.instance_variables.each do |var|
+      @uri.instance_variable_set(var, @uri.instance_variable_get(var).freeze)
+    end
+
+    @uri.freeze
+  end
+
+  it "#normalized_scheme should not error" do
+    expect { @uri.normalized_scheme }.not_to raise_error
+  end
+
+  it "#normalized_user should not error" do
+    expect { @uri.normalized_user }.not_to raise_error
+  end
+
+  it "#normalized_password should not error" do
+    expect { @uri.normalized_password }.not_to raise_error
+  end
+
+  it "#normalized_userinfo should not error" do
+    expect { @uri.normalized_userinfo }.not_to raise_error
+  end
+
+  it "#normalized_host should not error" do
+    expect { @uri.normalized_host }.not_to raise_error
+  end
+
+  it "#normalized_authority should not error" do
+    expect { @uri.normalized_authority }.not_to raise_error
+  end
+
+  it "#normalized_port should not error" do
+    expect { @uri.normalized_port }.not_to raise_error
+  end
+
+  it "#normalized_site should not error" do
+    expect { @uri.normalized_site }.not_to raise_error
+  end
+
+  it "#normalized_path should not error" do
+    expect { @uri.normalized_path }.not_to raise_error
+  end
+
+  it "#normalized_query should not error" do
+    expect { @uri.normalized_query }.not_to raise_error
+  end
+
+  it "#normalized_fragment should not error" do
+    expect { @uri.normalized_fragment }.not_to raise_error
+  end
+
+  it "should be frozen" do
+    expect(@uri).to be_frozen
+  end
+
+  it "should not allow destructive operations" do
+    expect { @uri.normalize! }.to raise_error(RuntimeError)
+  end
+end
+
+describe Addressable::URI, "when created from string components" do
+  before do
+    @uri = Addressable::URI.new(
+      :scheme => "http", :host => "example.com"
+    )
+  end
+
+  it "should have a site value of 'http://example.com'" do
+    expect(@uri.site).to eq("http://example.com")
+  end
+
+  it "should be equal to the equivalent parsed URI" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com"))
+  end
+
+  it "should raise an error if invalid components omitted" do
+    expect do
+      @uri.omit(:bogus)
+    end.to raise_error(ArgumentError)
+    expect do
+      @uri.omit(:scheme, :bogus, :path)
+    end.to raise_error(ArgumentError)
+  end
+end
+
+describe Addressable::URI, "when created with a nil host but " +
+    "non-nil authority components" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:user => "user", :password => "pass", :port => 80)
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with both an authority and a user" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(
+        :user => "user", :authority => "user@example.com:80"
+      )
+    end.to raise_error(ArgumentError)
+  end
+end
+
+describe Addressable::URI, "when created with an authority and no port" do
+  before do
+    @uri = Addressable::URI.new(:authority => "user@example.com")
+  end
+
+  it "should not infer a port" do
+    expect(@uri.port).to eq(nil)
+    expect(@uri.default_port).to eq(nil)
+    expect(@uri.inferred_port).to eq(nil)
+  end
+
+  it "should have a site value of '//user@example.com'" do
+    expect(@uri.site).to eq("//user@example.com")
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when created with a host with trailing dots" do
+  before do
+    @uri = Addressable::URI.new(:authority => "example...")
+  end
+
+  it "should have a stable normalized form" do
+    expect(@uri.normalize.normalize.normalize.host).to eq(
+      @uri.normalize.host
+    )
+  end
+end
+
+describe Addressable::URI, "when created with a host with a backslash" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:authority => "example\\example")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with a host with a slash" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:authority => "example/example")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with a host with a space" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:authority => "example example")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with both a userinfo and a user" do
+  it "should raise an error" do
+    expect do
+      Addressable::URI.new(:user => "user", :userinfo => "user:pass")
+    end.to raise_error(ArgumentError)
+  end
+end
+
+describe Addressable::URI, "when created with a path that hasn't been " +
+    "prefixed with a '/' but a host specified" do
+  before do
+    @uri = Addressable::URI.new(
+      :scheme => "http", :host => "example.com", :path => "path"
+    )
+  end
+
+  it "should prefix a '/' to the path" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com/path"))
+  end
+
+  it "should have a site value of 'http://example.com'" do
+    expect(@uri.site).to eq("http://example.com")
+  end
+
+  it "should have an origin of 'http://example.com" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+end
+
+describe Addressable::URI, "when created with a path that hasn't been " +
+    "prefixed with a '/' but no host specified" do
+  before do
+    @uri = Addressable::URI.new(
+      :scheme => "http", :path => "path"
+    )
+  end
+
+  it "should not prefix a '/' to the path" do
+    expect(@uri).to eq(Addressable::URI.parse("http:path"))
+  end
+
+  it "should have a site value of 'http:'" do
+    expect(@uri.site).to eq("http:")
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when parsed from an Addressable::URI object" do
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.parse(original_uri)
+    new_uri.host = 'www.example.com'
+    expect(new_uri.host).to eq('www.example.com')
+    expect(new_uri.to_s).to eq('http://www.example.com/')
+    expect(original_uri.host).to eq('example.com')
+    expect(original_uri.to_s).to eq('http://example.com/')
+  end
+
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.heuristic_parse(original_uri)
+    new_uri.host = 'www.example.com'
+    expect(new_uri.host).to eq('www.example.com')
+    expect(new_uri.to_s).to eq('http://www.example.com/')
+    expect(original_uri.host).to eq('example.com')
+    expect(original_uri.to_s).to eq('http://example.com/')
+  end
+
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.parse(original_uri)
+    new_uri.origin = 'https://www.example.com:8080'
+    expect(new_uri.host).to eq('www.example.com')
+    expect(new_uri.to_s).to eq('https://www.example.com:8080/')
+    expect(original_uri.host).to eq('example.com')
+    expect(original_uri.to_s).to eq('http://example.com/')
+  end
+
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.heuristic_parse(original_uri)
+    new_uri.origin = 'https://www.example.com:8080'
+    expect(new_uri.host).to eq('www.example.com')
+    expect(new_uri.to_s).to eq('https://www.example.com:8080/')
+    expect(original_uri.host).to eq('example.com')
+    expect(original_uri.to_s).to eq('http://example.com/')
+  end
+end
+
+describe Addressable::URI, "when parsed from something that looks " +
+    "like a URI object" do
+  it "should parse without error" do
+    uri = Addressable::URI.parse(Fake::URI::HTTP.new("http://example.com/"))
+    expect do
+      Addressable::URI.parse(uri)
+    end.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when parsed from a standard library URI object" do
+  it "should parse without error" do
+    uri = Addressable::URI.parse(URI.parse("http://example.com/"))
+    expect do
+      Addressable::URI.parse(uri)
+    end.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when parsed from ''" do
+  before do
+    @uri = Addressable::URI.parse("")
+  end
+
+  it "should have no scheme" do
+    expect(@uri.scheme).to eq(nil)
+  end
+
+  it "should not be considered to be ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should have a path of ''" do
+    expect(@uri.path).to eq("")
+  end
+
+  it "should have a request URI of '/'" do
+    expect(@uri.request_uri).to eq("/")
+  end
+
+  it "should be considered relative" do
+    expect(@uri).to be_relative
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+# Section 1.1.2 of RFC 3986
+describe Addressable::URI, "when parsed from " +
+    "'ftp://ftp.is.co.za/rfc/rfc1808.txt'" do
+  before do
+    @uri = Addressable::URI.parse("ftp://ftp.is.co.za/rfc/rfc1808.txt")
+  end
+
+  it "should use the 'ftp' scheme" do
+    expect(@uri.scheme).to eq("ftp")
+  end
+
+  it "should be considered to be ip-based" do
+    expect(@uri).to be_ip_based
+  end
+
+  it "should have a host of 'ftp.is.co.za'" do
+    expect(@uri.host).to eq("ftp.is.co.za")
+  end
+
+  it "should have inferred_port of 21" do
+    expect(@uri.inferred_port).to eq(21)
+  end
+
+  it "should have a path of '/rfc/rfc1808.txt'" do
+    expect(@uri.path).to eq("/rfc/rfc1808.txt")
+  end
+
+  it "should not have a request URI" do
+    expect(@uri.request_uri).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have an origin of 'ftp://ftp.is.co.za'" do
+    expect(@uri.origin).to eq('ftp://ftp.is.co.za')
+  end
+end
+
+# Section 1.1.2 of RFC 3986
+describe Addressable::URI, "when parsed from " +
+    "'http://www.ietf.org/rfc/rfc2396.txt'" do
+  before do
+    @uri = Addressable::URI.parse("http://www.ietf.org/rfc/rfc2396.txt")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should be considered to be ip-based" do
+    expect(@uri).to be_ip_based
+  end
+
+  it "should have a host of 'www.ietf.org'" do
+    expect(@uri.host).to eq("www.ietf.org")
+  end
+
+  it "should have inferred_port of 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have a path of '/rfc/rfc2396.txt'" do
+    expect(@uri.path).to eq("/rfc/rfc2396.txt")
+  end
+
+  it "should have a request URI of '/rfc/rfc2396.txt'" do
+    expect(@uri.request_uri).to eq("/rfc/rfc2396.txt")
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should correctly omit components" do
+    expect(@uri.omit(:scheme).to_s).to eq("//www.ietf.org/rfc/rfc2396.txt")
+    expect(@uri.omit(:path).to_s).to eq("http://www.ietf.org")
+  end
+
+  it "should correctly omit components destructively" do
+    @uri.omit!(:scheme)
+    expect(@uri.to_s).to eq("//www.ietf.org/rfc/rfc2396.txt")
+  end
+
+  it "should have an origin of 'http://www.ietf.org'" do
+    expect(@uri.origin).to eq('http://www.ietf.org')
+  end
+end
+
+# Section 1.1.2 of RFC 3986
+describe Addressable::URI, "when parsed from " +
+    "'ldap://[2001:db8::7]/c=GB?objectClass?one'" do
+  before do
+    @uri = Addressable::URI.parse("ldap://[2001:db8::7]/c=GB?objectClass?one")
+  end
+
+  it "should use the 'ldap' scheme" do
+    expect(@uri.scheme).to eq("ldap")
+  end
+
+  it "should be considered to be ip-based" do
+    expect(@uri).to be_ip_based
+  end
+
+  it "should have a host of '[2001:db8::7]'" do
+    expect(@uri.host).to eq("[2001:db8::7]")
+  end
+
+  it "should have inferred_port of 389" do
+    expect(@uri.inferred_port).to eq(389)
+  end
+
+  it "should have a path of '/c=GB'" do
+    expect(@uri.path).to eq("/c=GB")
+  end
+
+  it "should not have a request URI" do
+    expect(@uri.request_uri).to eq(nil)
+  end
+
+  it "should not allow request URI assignment" do
+    expect do
+      @uri.request_uri = "/"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should have a query of 'objectClass?one'" do
+    expect(@uri.query).to eq("objectClass?one")
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should correctly omit components" do
+    expect(@uri.omit(:scheme, :authority).to_s).to eq("/c=GB?objectClass?one")
+    expect(@uri.omit(:path).to_s).to eq("ldap://[2001:db8::7]?objectClass?one")
+  end
+
+  it "should correctly omit components destructively" do
+    @uri.omit!(:scheme, :authority)
+    expect(@uri.to_s).to eq("/c=GB?objectClass?one")
+  end
+
+  it "should raise an error if omission would create an invalid URI" do
+    expect do
+      @uri.omit(:authority, :path)
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should have an origin of 'ldap://[2001:db8::7]'" do
+    expect(@uri.origin).to eq('ldap://[2001:db8::7]')
+  end
+end
+
+# Section 1.1.2 of RFC 3986
+describe Addressable::URI, "when parsed from " +
+    "'mailto:John.Doe@example.com'" do
+  before do
+    @uri = Addressable::URI.parse("mailto:John.Doe@example.com")
+  end
+
+  it "should use the 'mailto' scheme" do
+    expect(@uri.scheme).to eq("mailto")
+  end
+
+  it "should not be considered to be ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should not have an inferred_port" do
+    expect(@uri.inferred_port).to eq(nil)
+  end
+
+  it "should have a path of 'John.Doe@example.com'" do
+    expect(@uri.path).to eq("John.Doe@example.com")
+  end
+
+  it "should not have a request URI" do
+    expect(@uri.request_uri).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+# Section 2 of RFC 6068
+describe Addressable::URI, "when parsed from " +
+    "'mailto:?to=addr1@an.example,addr2@an.example'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "mailto:?to=addr1@an.example,addr2@an.example"
+    )
+  end
+
+  it "should use the 'mailto' scheme" do
+    expect(@uri.scheme).to eq("mailto")
+  end
+
+  it "should not be considered to be ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should not have an inferred_port" do
+    expect(@uri.inferred_port).to eq(nil)
+  end
+
+  it "should have a path of ''" do
+    expect(@uri.path).to eq("")
+  end
+
+  it "should not have a request URI" do
+    expect(@uri.request_uri).to eq(nil)
+  end
+
+  it "should have the To: field value parameterized" do
+    expect(@uri.query_values(Hash)["to"]).to eq(
+      "addr1@an.example,addr2@an.example"
+    )
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+# Section 1.1.2 of RFC 3986
+describe Addressable::URI, "when parsed from " +
+    "'news:comp.infosystems.www.servers.unix'" do
+  before do
+    @uri = Addressable::URI.parse("news:comp.infosystems.www.servers.unix")
+  end
+
+  it "should use the 'news' scheme" do
+    expect(@uri.scheme).to eq("news")
+  end
+
+  it "should not have an inferred_port" do
+    expect(@uri.inferred_port).to eq(nil)
+  end
+
+  it "should not be considered to be ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should have a path of 'comp.infosystems.www.servers.unix'" do
+    expect(@uri.path).to eq("comp.infosystems.www.servers.unix")
+  end
+
+  it "should not have a request URI" do
+    expect(@uri.request_uri).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+# Section 1.1.2 of RFC 3986
+describe Addressable::URI, "when parsed from " +
+    "'tel:+1-816-555-1212'" do
+  before do
+    @uri = Addressable::URI.parse("tel:+1-816-555-1212")
+  end
+
+  it "should use the 'tel' scheme" do
+    expect(@uri.scheme).to eq("tel")
+  end
+
+  it "should not be considered to be ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should not have an inferred_port" do
+    expect(@uri.inferred_port).to eq(nil)
+  end
+
+  it "should have a path of '+1-816-555-1212'" do
+    expect(@uri.path).to eq("+1-816-555-1212")
+  end
+
+  it "should not have a request URI" do
+    expect(@uri.request_uri).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+# Section 1.1.2 of RFC 3986
+describe Addressable::URI, "when parsed from " +
+    "'telnet://192.0.2.16:80/'" do
+  before do
+    @uri = Addressable::URI.parse("telnet://192.0.2.16:80/")
+  end
+
+  it "should use the 'telnet' scheme" do
+    expect(@uri.scheme).to eq("telnet")
+  end
+
+  it "should have a host of '192.0.2.16'" do
+    expect(@uri.host).to eq("192.0.2.16")
+  end
+
+  it "should have a port of 80" do
+    expect(@uri.port).to eq(80)
+  end
+
+  it "should have a inferred_port of 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have a default_port of 23" do
+    expect(@uri.default_port).to eq(23)
+  end
+
+  it "should be considered to be ip-based" do
+    expect(@uri).to be_ip_based
+  end
+
+  it "should have a path of '/'" do
+    expect(@uri.path).to eq("/")
+  end
+
+  it "should not have a request URI" do
+    expect(@uri.request_uri).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have an origin of 'telnet://192.0.2.16:80'" do
+    expect(@uri.origin).to eq('telnet://192.0.2.16:80')
+  end
+end
+
+# Section 1.1.2 of RFC 3986
+describe Addressable::URI, "when parsed from " +
+    "'urn:oasis:names:specification:docbook:dtd:xml:4.1.2'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "urn:oasis:names:specification:docbook:dtd:xml:4.1.2")
+  end
+
+  it "should use the 'urn' scheme" do
+    expect(@uri.scheme).to eq("urn")
+  end
+
+  it "should not have an inferred_port" do
+    expect(@uri.inferred_port).to eq(nil)
+  end
+
+  it "should not be considered to be ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should have a path of " +
+      "'oasis:names:specification:docbook:dtd:xml:4.1.2'" do
+    expect(@uri.path).to eq("oasis:names:specification:docbook:dtd:xml:4.1.2")
+  end
+
+  it "should not have a request URI" do
+    expect(@uri.request_uri).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when heuristically parsed from " +
+    "'192.0.2.16:8000/path'" do
+  before do
+    @uri = Addressable::URI.heuristic_parse("192.0.2.16:8000/path")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have a host of '192.0.2.16'" do
+    expect(@uri.host).to eq("192.0.2.16")
+  end
+
+  it "should have a port of '8000'" do
+    expect(@uri.port).to eq(8000)
+  end
+
+  it "should be considered to be ip-based" do
+    expect(@uri).to be_ip_based
+  end
+
+  it "should have a path of '/path'" do
+    expect(@uri.path).to eq("/path")
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have an origin of 'http://192.0.2.16:8000'" do
+    expect(@uri.origin).to eq('http://192.0.2.16:8000')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com")
+  end
+
+  it "when inspected, should have the correct URI" do
+    expect(@uri.inspect).to include("http://example.com")
+  end
+
+  it "when inspected, should have the correct class name" do
+    expect(@uri.inspect).to include("Addressable::URI")
+  end
+
+  it "when inspected, should have the correct object id" do
+    expect(@uri.inspect).to include("%#0x" % @uri.object_id)
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should be considered to be ip-based" do
+    expect(@uri).to be_ip_based
+  end
+
+  it "should have an authority segment of 'example.com'" do
+    expect(@uri.authority).to eq("example.com")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should be considered ip-based" do
+    expect(@uri).to be_ip_based
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should not have a specified port" do
+    expect(@uri.port).to eq(nil)
+  end
+
+  it "should have an empty path" do
+    expect(@uri.path).to eq("")
+  end
+
+  it "should have no query string" do
+    expect(@uri.query).to eq(nil)
+    expect(@uri.query_values).to eq(nil)
+  end
+
+  it "should have a request URI of '/'" do
+    expect(@uri.request_uri).to eq("/")
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+
+  it "should be considered absolute" do
+    expect(@uri).to be_absolute
+  end
+
+  it "should not be considered relative" do
+    expect(@uri).not_to be_relative
+  end
+
+  it "should not be exactly equal to 42" do
+    expect(@uri.eql?(42)).to eq(false)
+  end
+
+  it "should not be equal to 42" do
+    expect(@uri == 42).to eq(false)
+  end
+
+  it "should not be roughly equal to 42" do
+    expect(@uri === 42).to eq(false)
+  end
+
+  it "should be exactly equal to http://example.com" do
+    expect(@uri.eql?(Addressable::URI.parse("http://example.com"))).to eq(true)
+  end
+
+  it "should be roughly equal to http://example.com/" do
+    expect(@uri === Addressable::URI.parse("http://example.com/")).to eq(true)
+  end
+
+  it "should be roughly equal to the string 'http://example.com/'" do
+    expect(@uri === "http://example.com/").to eq(true)
+  end
+
+  it "should not be roughly equal to the string " +
+      "'http://example.com:bogus/'" do
+    expect do
+      expect(@uri === "http://example.com:bogus/").to eq(false)
+    end.not_to raise_error
+  end
+
+  it "should result in itself when joined with itself" do
+    expect(@uri.join(@uri).to_s).to eq("http://example.com")
+    expect(@uri.join!(@uri).to_s).to eq("http://example.com")
+  end
+
+  it "should be equivalent to http://EXAMPLE.com" do
+    expect(@uri).to eq(Addressable::URI.parse("http://EXAMPLE.com"))
+  end
+
+  it "should be equivalent to http://EXAMPLE.com:80/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://EXAMPLE.com:80/"))
+  end
+
+  it "should have the same hash as http://example.com" do
+    expect(@uri.hash).to eq(Addressable::URI.parse("http://example.com").hash)
+  end
+
+  it "should have the same hash as http://EXAMPLE.com after assignment" do
+    @uri.origin = "http://EXAMPLE.com"
+    expect(@uri.hash).to eq(Addressable::URI.parse("http://EXAMPLE.com").hash)
+  end
+
+  it "should have a different hash from http://EXAMPLE.com" do
+    expect(@uri.hash).not_to eq(Addressable::URI.parse("http://EXAMPLE.com").hash)
+  end
+
+  it "should not allow origin assignment without scheme" do
+    expect do
+      @uri.origin = "example.com"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow origin assignment without host" do
+    expect do
+      @uri.origin = "http://"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow origin assignment with bogus type" do
+    expect do
+      @uri.origin = :bogus
+    end.to raise_error(TypeError)
+  end
+
+  # Section 6.2.3 of RFC 3986
+  it "should be equivalent to http://example.com/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com/"))
+  end
+
+  # Section 6.2.3 of RFC 3986
+  it "should be equivalent to http://example.com:/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com:/"))
+  end
+
+  # Section 6.2.3 of RFC 3986
+  it "should be equivalent to http://example.com:80/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com:80/"))
+  end
+
+  # Section 6.2.2.1 of RFC 3986
+  it "should be equivalent to http://EXAMPLE.COM/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://EXAMPLE.COM/"))
+  end
+
+  it "should have a route of '/path/' to 'http://example.com/path/'" do
+    expect(@uri.route_to("http://example.com/path/")).to eq(
+      Addressable::URI.parse("/path/")
+    )
+  end
+
+  it "should have a route of '..' from 'http://example.com/path/'" do
+    expect(@uri.route_from("http://example.com/path/")).to eq(
+      Addressable::URI.parse("..")
+    )
+  end
+
+  it "should have a route of '#' to 'http://example.com/'" do
+    expect(@uri.route_to("http://example.com/")).to eq(
+      Addressable::URI.parse("#")
+    )
+  end
+
+  it "should have a route of 'http://elsewhere.com/' to " +
+      "'http://elsewhere.com/'" do
+    expect(@uri.route_to("http://elsewhere.com/")).to eq(
+      Addressable::URI.parse("http://elsewhere.com/")
+    )
+  end
+
+  it "when joined with 'relative/path' should be " +
+      "'http://example.com/relative/path'" do
+    expect(@uri.join('relative/path')).to eq(
+      Addressable::URI.parse("http://example.com/relative/path")
+    )
+  end
+
+  it "when joined with a bogus object a TypeError should be raised" do
+    expect do
+      @uri.join(42)
+    end.to raise_error(TypeError)
+  end
+
+  it "should have the correct username after assignment" do
+    @uri.user = "newuser"
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq(nil)
+    expect(@uri.to_s).to eq("http://newuser@example.com")
+  end
+
+  it "should have the correct username after assignment" do
+    @uri.user = "user@123!"
+    expect(@uri.user).to eq("user@123!")
+    expect(@uri.normalized_user).to eq("user%40123%21")
+    expect(@uri.password).to eq(nil)
+    expect(@uri.normalize.to_s).to eq("http://user%40123%21@example.com/")
+  end
+
+  it "should have the correct password after assignment" do
+    @uri.password = "newpass"
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.user).to eq("")
+    expect(@uri.to_s).to eq("http://:newpass@example.com")
+  end
+
+  it "should have the correct password after assignment" do
+    @uri.password = "#secret@123!"
+    expect(@uri.password).to eq("#secret@123!")
+    expect(@uri.normalized_password).to eq("%23secret%40123%21")
+    expect(@uri.user).to eq("")
+    expect(@uri.normalize.to_s).to eq("http://:%23secret%40123%21@example.com/")
+    expect(@uri.omit(:password).to_s).to eq("http://example.com")
+  end
+
+  it "should have the correct user/pass after repeated assignment" do
+    @uri.user = nil
+    expect(@uri.user).to eq(nil)
+    @uri.password = "newpass"
+    expect(@uri.password).to eq("newpass")
+    # Username cannot be nil if the password is set
+    expect(@uri.user).to eq("")
+    expect(@uri.to_s).to eq("http://:newpass@example.com")
+    @uri.user = "newuser"
+    expect(@uri.user).to eq("newuser")
+    @uri.password = nil
+    expect(@uri.password).to eq(nil)
+    expect(@uri.to_s).to eq("http://newuser@example.com")
+    @uri.user = "newuser"
+    expect(@uri.user).to eq("newuser")
+    @uri.password = ""
+    expect(@uri.password).to eq("")
+    expect(@uri.to_s).to eq("http://newuser:@example.com")
+    @uri.password = "newpass"
+    expect(@uri.password).to eq("newpass")
+    @uri.user = nil
+    # Username cannot be nil if the password is set
+    expect(@uri.user).to eq("")
+    expect(@uri.to_s).to eq("http://:newpass@example.com")
+  end
+
+  it "should have the correct user/pass after userinfo assignment" do
+    @uri.user = "newuser"
+    expect(@uri.user).to eq("newuser")
+    @uri.password = "newpass"
+    expect(@uri.password).to eq("newpass")
+    @uri.userinfo = nil
+    expect(@uri.userinfo).to eq(nil)
+    expect(@uri.user).to eq(nil)
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => nil,
+      :path => "",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+end
+
+# Section 5.1.2 of RFC 2616
+describe Addressable::URI, "when parsed from " +
+    "'HTTP://www.w3.org/pub/WWW/TheProject.html'" do
+  before do
+    @uri = Addressable::URI.parse("HTTP://www.w3.org/pub/WWW/TheProject.html")
+  end
+
+  it "should have the correct request URI" do
+    expect(@uri.request_uri).to eq("/pub/WWW/TheProject.html")
+  end
+
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/pub/WWW/TheProject.html?"
+    expect(@uri.request_uri).to eq("/pub/WWW/TheProject.html?")
+    expect(@uri.path).to eq("/pub/WWW/TheProject.html")
+    expect(@uri.query).to eq("")
+  end
+
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/some/where/else.html"
+    expect(@uri.request_uri).to eq("/some/where/else.html")
+    expect(@uri.path).to eq("/some/where/else.html")
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/some/where/else.html?query?string"
+    expect(@uri.request_uri).to eq("/some/where/else.html?query?string")
+    expect(@uri.path).to eq("/some/where/else.html")
+    expect(@uri.query).to eq("query?string")
+  end
+
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "?x=y"
+    expect(@uri.request_uri).to eq("/?x=y")
+    expect(@uri.path).to eq("/")
+    expect(@uri.query).to eq("x=y")
+  end
+
+  it "should raise an error if the site value is set to something bogus" do
+    expect do
+      @uri.site = 42
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise an error if the request URI is set to something bogus" do
+    expect do
+      @uri.request_uri = 42
+    end.to raise_error(TypeError)
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "HTTP",
+      :user => nil,
+      :password => nil,
+      :host => "www.w3.org",
+      :port => nil,
+      :path => "/pub/WWW/TheProject.html",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should have an origin of 'http://www.w3.org'" do
+    expect(@uri.origin).to eq('http://www.w3.org')
+  end
+end
+
+describe Addressable::URI, "when parsing IPv6 addresses" do
+  it "should not raise an error for " +
+      "'http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[fe80:0:0:0:200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[fe80:0:0:0:200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[fe80::200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[fe80::200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[::1]/'" do
+    Addressable::URI.parse("http://[::1]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[fe80::1]/'" do
+    Addressable::URI.parse("http://[fe80::1]/")
+  end
+
+  it "should raise an error for " +
+      "'http://[<invalid>]/'" do
+    expect do
+      Addressable::URI.parse("http://[<invalid>]/")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when parsing IPv6 address" do
+  subject { Addressable::URI.parse("http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/") }
+  its(:host) { should == '[3ffe:1900:4545:3:200:f8ff:fe21:67cf]' }
+  its(:hostname) { should == '3ffe:1900:4545:3:200:f8ff:fe21:67cf' }
+end
+
+describe Addressable::URI, "when assigning IPv6 address" do
+  it "should allow to set bare IPv6 address as hostname" do
+    uri = Addressable::URI.parse("http://[::1]/")
+    uri.hostname = '3ffe:1900:4545:3:200:f8ff:fe21:67cf'
+    expect(uri.to_s).to eq('http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/')
+  end
+
+  it "should allow to set bare IPv6 address as hostname with IPAddr object" do
+    uri = Addressable::URI.parse("http://[::1]/")
+    uri.hostname = IPAddr.new('3ffe:1900:4545:3:200:f8ff:fe21:67cf')
+    expect(uri.to_s).to eq('http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/')
+  end
+
+  it "should not allow to set bare IPv6 address as host" do
+    uri = Addressable::URI.parse("http://[::1]/")
+    skip "not checked"
+    expect do
+      uri.host = '3ffe:1900:4545:3:200:f8ff:fe21:67cf'
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when parsing IPvFuture addresses" do
+  it "should not raise an error for " +
+      "'http://[v9.3ffe:1900:4545:3:200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[v9.3ffe:1900:4545:3:200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[vff.fe80:0:0:0:200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[vff.fe80:0:0:0:200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[v12.fe80::200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[v12.fe80::200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[va0.::1]/'" do
+    Addressable::URI.parse("http://[va0.::1]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[v255.fe80::1]/'" do
+    Addressable::URI.parse("http://[v255.fe80::1]/")
+  end
+
+  it "should raise an error for " +
+      "'http://[v0.<invalid>]/'" do
+    expect do
+      Addressable::URI.parse("http://[v0.<invalid>]/")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/")
+  end
+
+  # Based on http://intertwingly.net/blog/2004/07/31/URI-Equivalence
+  it "should be equivalent to http://example.com" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com"))
+  end
+
+  # Based on http://intertwingly.net/blog/2004/07/31/URI-Equivalence
+  it "should be equivalent to HTTP://example.com/" do
+    expect(@uri).to eq(Addressable::URI.parse("HTTP://example.com/"))
+  end
+
+  # Based on http://intertwingly.net/blog/2004/07/31/URI-Equivalence
+  it "should be equivalent to http://example.com:/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com:/"))
+  end
+
+  # Based on http://intertwingly.net/blog/2004/07/31/URI-Equivalence
+  it "should be equivalent to http://example.com:80/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com:80/"))
+  end
+
+  # Based on http://intertwingly.net/blog/2004/07/31/URI-Equivalence
+  it "should be equivalent to http://Example.com/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://Example.com/"))
+  end
+
+  it "should have the correct username after assignment" do
+    @uri.user = nil
+    expect(@uri.user).to eq(nil)
+    expect(@uri.password).to eq(nil)
+    expect(@uri.to_s).to eq("http://example.com/")
+  end
+
+  it "should have the correct password after assignment" do
+    @uri.password = nil
+    expect(@uri.password).to eq(nil)
+    expect(@uri.user).to eq(nil)
+    expect(@uri.to_s).to eq("http://example.com/")
+  end
+
+  it "should have a request URI of '/'" do
+    expect(@uri.request_uri).to eq("/")
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => nil,
+      :path => "/",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have the same hash as its duplicate" do
+    expect(@uri.hash).to eq(@uri.dup.hash)
+  end
+
+  it "should have a different hash from its equivalent String value" do
+    expect(@uri.hash).not_to eq(@uri.to_s.hash)
+  end
+
+  it "should have the same hash as an equal URI" do
+    expect(@uri.hash).to eq(Addressable::URI.parse("http://example.com/").hash)
+  end
+
+  it "should be equivalent to http://EXAMPLE.com" do
+    expect(@uri).to eq(Addressable::URI.parse("http://EXAMPLE.com"))
+  end
+
+  it "should be equivalent to http://EXAMPLE.com:80/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://EXAMPLE.com:80/"))
+  end
+
+  it "should have the same hash as http://example.com/" do
+    expect(@uri.hash).to eq(Addressable::URI.parse("http://example.com/").hash)
+  end
+
+  it "should have the same hash as http://example.com after assignment" do
+    @uri.path = ""
+    expect(@uri.hash).to eq(Addressable::URI.parse("http://example.com").hash)
+  end
+
+  it "should have the same hash as http://example.com/? after assignment" do
+    @uri.query = ""
+    expect(@uri.hash).to eq(Addressable::URI.parse("http://example.com/?").hash)
+  end
+
+  it "should have the same hash as http://example.com/? after assignment" do
+    @uri.query_values = {}
+    expect(@uri.hash).to eq(Addressable::URI.parse("http://example.com/?").hash)
+  end
+
+  it "should have the same hash as http://example.com/# after assignment" do
+    @uri.fragment = ""
+    expect(@uri.hash).to eq(Addressable::URI.parse("http://example.com/#").hash)
+  end
+
+  it "should have a different hash from http://example.com" do
+    expect(@uri.hash).not_to eq(Addressable::URI.parse("http://example.com").hash)
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com?#'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com?#")
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => nil,
+      :path => "",
+      :query => "",
+      :fragment => ""
+    })
+  end
+
+  it "should have a request URI of '/?'" do
+    expect(@uri.request_uri).to eq("/?")
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/")
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq("http://example.com")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://@example.com/'" do
+  before do
+    @uri = Addressable::URI.parse("http://@example.com/")
+  end
+
+  it "should be equivalent to http://example.com" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com"))
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "http",
+      :user => "",
+      :password => nil,
+      :host => "example.com",
+      :port => nil,
+      :path => "/",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com./'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com./")
+  end
+
+  it "should be equivalent to http://example.com" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com"))
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://:@example.com/'" do
+  before do
+    @uri = Addressable::URI.parse("http://:@example.com/")
+  end
+
+  it "should be equivalent to http://example.com" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com"))
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "http",
+      :user => "",
+      :password => "",
+      :host => "example.com",
+      :port => nil,
+      :path => "/",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'HTTP://EXAMPLE.COM/'" do
+  before do
+    @uri = Addressable::URI.parse("HTTP://EXAMPLE.COM/")
+  end
+
+  it "should be equivalent to http://example.com" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com"))
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "HTTP",
+      :user => nil,
+      :password => nil,
+      :host => "EXAMPLE.COM",
+      :port => nil,
+      :path => "/",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+
+  it "should have a tld of 'com'" do
+    expect(@uri.tld).to eq('com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://www.example.co.uk/'" do
+  before do
+    @uri = Addressable::URI.parse("http://www.example.co.uk/")
+  end
+
+  it "should have an origin of 'http://www.example.co.uk'" do
+    expect(@uri.origin).to eq('http://www.example.co.uk')
+  end
+
+  it "should have a tld of 'co.uk'" do
+    expect(@uri.tld).to eq('co.uk')
+  end
+
+  it "should have a domain of 'example.co.uk'" do
+    expect(@uri.domain).to eq('example.co.uk')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://sub_domain.blogspot.com/'" do
+  before do
+    @uri = Addressable::URI.parse("http://sub_domain.blogspot.com/")
+  end
+
+  it "should have an origin of 'http://sub_domain.blogspot.com'" do
+    expect(@uri.origin).to eq('http://sub_domain.blogspot.com')
+  end
+
+  it "should have a tld of 'com'" do
+    expect(@uri.tld).to eq('com')
+  end
+
+  it "should have a domain of 'blogspot.com'" do
+    expect(@uri.domain).to eq('blogspot.com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/~smith/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/~smith/")
+  end
+
+  # Based on http://intertwingly.net/blog/2004/07/31/URI-Equivalence
+  it "should be equivalent to http://example.com/%7Esmith/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com/%7Esmith/"))
+  end
+
+  # Based on http://intertwingly.net/blog/2004/07/31/URI-Equivalence
+  it "should be equivalent to http://example.com/%7esmith/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com/%7esmith/"))
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/%E8'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/%E8")
+  end
+
+  it "should not raise an exception when normalized" do
+    expect do
+      @uri.normalize
+    end.not_to raise_error
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should not change if encoded with the normalizing algorithm" do
+    expect(Addressable::URI.normalized_encode(@uri).to_s).to eq(
+      "http://example.com/%E8"
+    )
+    expect(Addressable::URI.normalized_encode(@uri, Addressable::URI).to_s).to be ===
+      "http://example.com/%E8"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/path%2Fsegment/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/path%2Fsegment/")
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should be equal to 'http://example.com/path%2Fsegment/'" do
+    expect(@uri.normalize).to be_eql(
+      Addressable::URI.parse("http://example.com/path%2Fsegment/")
+    )
+  end
+
+  it "should not be equal to 'http://example.com/path/segment/'" do
+    expect(@uri).not_to eq(
+      Addressable::URI.parse("http://example.com/path/segment/")
+    )
+  end
+
+  it "should not be equal to 'http://example.com/path/segment/'" do
+    expect(@uri.normalize).not_to be_eql(
+      Addressable::URI.parse("http://example.com/path/segment/")
+    )
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?%F6'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?%F6")
+  end
+
+  it "should not raise an exception when normalized" do
+    expect do
+      @uri.normalize
+    end.not_to raise_error
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should not change if encoded with the normalizing algorithm" do
+    expect(Addressable::URI.normalized_encode(@uri).to_s).to eq(
+      "http://example.com/?%F6"
+    )
+    expect(Addressable::URI.normalized_encode(@uri, Addressable::URI).to_s).to be ===
+      "http://example.com/?%F6"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/#%F6'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/#%F6")
+  end
+
+  it "should not raise an exception when normalized" do
+    expect do
+      @uri.normalize
+    end.not_to raise_error
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should not change if encoded with the normalizing algorithm" do
+    expect(Addressable::URI.normalized_encode(@uri).to_s).to eq(
+      "http://example.com/#%F6"
+    )
+    expect(Addressable::URI.normalized_encode(@uri, Addressable::URI).to_s).to be ===
+      "http://example.com/#%F6"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/%C3%87'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/%C3%87")
+  end
+
+  # Based on http://intertwingly.net/blog/2004/07/31/URI-Equivalence
+  it "should be equivalent to 'http://example.com/C%CC%A7'" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com/C%CC%A7"))
+  end
+
+  it "should not change if encoded with the normalizing algorithm" do
+    expect(Addressable::URI.normalized_encode(@uri).to_s).to eq(
+      "http://example.com/%C3%87"
+    )
+    expect(Addressable::URI.normalized_encode(@uri, Addressable::URI).to_s).to be ===
+      "http://example.com/%C3%87"
+  end
+
+  it "should raise an error if encoding with an unexpected return type" do
+    expect do
+      Addressable::URI.normalized_encode(@uri, Integer)
+    end.to raise_error(TypeError)
+  end
+
+  it "if percent encoded should be 'http://example.com/C%25CC%25A7'" do
+    expect(Addressable::URI.encode(@uri).to_s).to eq(
+      "http://example.com/%25C3%2587"
+    )
+  end
+
+  it "if percent encoded should be 'http://example.com/C%25CC%25A7'" do
+    expect(Addressable::URI.encode(@uri, Addressable::URI)).to eq(
+      Addressable::URI.parse("http://example.com/%25C3%2587")
+    )
+  end
+
+  it "should raise an error if encoding with an unexpected return type" do
+    expect do
+      Addressable::URI.encode(@uri, Integer)
+    end.to raise_error(TypeError)
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q=string'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q=string")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have an authority segment of 'example.com'" do
+    expect(@uri.authority).to eq("example.com")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have a path of '/'" do
+    expect(@uri.path).to eq("/")
+  end
+
+  it "should have a query string of 'q=string'" do
+    expect(@uri.query).to eq("q=string")
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+
+  it "should be considered absolute" do
+    expect(@uri).to be_absolute
+  end
+
+  it "should not be considered relative" do
+    expect(@uri).not_to be_relative
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com:80/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com:80/")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have an authority segment of 'example.com:80'" do
+    expect(@uri.authority).to eq("example.com:80")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have explicit port 80" do
+    expect(@uri.port).to eq(80)
+  end
+
+  it "should have a path of '/'" do
+    expect(@uri.path).to eq("/")
+  end
+
+  it "should have no query string" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+
+  it "should be considered absolute" do
+    expect(@uri).to be_absolute
+  end
+
+  it "should not be considered relative" do
+    expect(@uri).not_to be_relative
+  end
+
+  it "should be exactly equal to http://example.com:80/" do
+    expect(@uri.eql?(Addressable::URI.parse("http://example.com:80/"))).to eq(true)
+  end
+
+  it "should be roughly equal to http://example.com/" do
+    expect(@uri === Addressable::URI.parse("http://example.com/")).to eq(true)
+  end
+
+  it "should be roughly equal to the string 'http://example.com/'" do
+    expect(@uri === "http://example.com/").to eq(true)
+  end
+
+  it "should not be roughly equal to the string " +
+      "'http://example.com:bogus/'" do
+    expect do
+      expect(@uri === "http://example.com:bogus/").to eq(false)
+    end.not_to raise_error
+  end
+
+  it "should result in itself when joined with itself" do
+    expect(@uri.join(@uri).to_s).to eq("http://example.com:80/")
+    expect(@uri.join!(@uri).to_s).to eq("http://example.com:80/")
+  end
+
+  # Section 6.2.3 of RFC 3986
+  it "should be equal to http://example.com/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com/"))
+  end
+
+  # Section 6.2.3 of RFC 3986
+  it "should be equal to http://example.com:/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com:/"))
+  end
+
+  # Section 6.2.3 of RFC 3986
+  it "should be equal to http://example.com:80/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com:80/"))
+  end
+
+  # Section 6.2.2.1 of RFC 3986
+  it "should be equal to http://EXAMPLE.COM/" do
+    expect(@uri).to eq(Addressable::URI.parse("http://EXAMPLE.COM/"))
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => 80,
+      :path => "/",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+
+  it "should not change if encoded with the normalizing algorithm" do
+    expect(Addressable::URI.normalized_encode(@uri).to_s).to eq(
+      "http://example.com:80/"
+    )
+    expect(Addressable::URI.normalized_encode(@uri, Addressable::URI).to_s).to be ===
+      "http://example.com:80/"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com:8080/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com:8080/")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have an authority segment of 'example.com:8080'" do
+    expect(@uri.authority).to eq("example.com:8080")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should use port 8080" do
+    expect(@uri.inferred_port).to eq(8080)
+  end
+
+  it "should have explicit port 8080" do
+    expect(@uri.port).to eq(8080)
+  end
+
+  it "should have default port 80" do
+    expect(@uri.default_port).to eq(80)
+  end
+
+  it "should have a path of '/'" do
+    expect(@uri.path).to eq("/")
+  end
+
+  it "should have no query string" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+
+  it "should be considered absolute" do
+    expect(@uri).to be_absolute
+  end
+
+  it "should not be considered relative" do
+    expect(@uri).not_to be_relative
+  end
+
+  it "should be exactly equal to http://example.com:8080/" do
+    expect(@uri.eql?(Addressable::URI.parse(
+      "http://example.com:8080/"))).to eq(true)
+  end
+
+  it "should have a route of 'http://example.com:8080/' from " +
+      "'http://example.com/path/to/'" do
+    expect(@uri.route_from("http://example.com/path/to/")).to eq(
+      Addressable::URI.parse("http://example.com:8080/")
+    )
+  end
+
+  it "should have a route of 'http://example.com:8080/' from " +
+      "'http://example.com:80/path/to/'" do
+    expect(@uri.route_from("http://example.com:80/path/to/")).to eq(
+      Addressable::URI.parse("http://example.com:8080/")
+    )
+  end
+
+  it "should have a route of '../../' from " +
+      "'http://example.com:8080/path/to/'" do
+    expect(@uri.route_from("http://example.com:8080/path/to/")).to eq(
+      Addressable::URI.parse("../../")
+    )
+  end
+
+  it "should have a route of 'http://example.com:8080/' from " +
+      "'http://user:pass@example.com/path/to/'" do
+    expect(@uri.route_from("http://user:pass@example.com/path/to/")).to eq(
+      Addressable::URI.parse("http://example.com:8080/")
+    )
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => 8080,
+      :path => "/",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have an origin of 'http://example.com:8080'" do
+    expect(@uri.origin).to eq('http://example.com:8080')
+  end
+
+  it "should not change if encoded with the normalizing algorithm" do
+    expect(Addressable::URI.normalized_encode(@uri).to_s).to eq(
+      "http://example.com:8080/"
+    )
+    expect(Addressable::URI.normalized_encode(@uri, Addressable::URI).to_s).to be ===
+      "http://example.com:8080/"
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com:%38%30/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com:%38%30/")
+  end
+
+  it "should have the correct port" do
+    expect(@uri.port).to eq(80)
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/")
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+end
+
+describe Addressable::URI, "when parsed with empty port" do
+  subject(:uri) do
+    Addressable::URI.parse("//example.com:")
+  end
+
+  it "should not infer a port" do
+    expect(uri.port).to be(nil)
+  end
+
+  it "should have a site value of '//example.com'" do
+    expect(uri.site).to eq("//example.com")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/%2E/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/%2E/")
+  end
+
+  it "should be considered to be in normal form" do
+    skip(
+      'path segment normalization should happen before ' +
+      'percent escaping normalization'
+    )
+    @uri.normalize.should be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/%2E/'" do
+    skip(
+      'path segment normalization should happen before ' +
+      'percent escaping normalization'
+    )
+    expect(@uri.normalize).to eq("http://example.com/%2E/")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/..'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/..")
+  end
+
+  it "should have the correct port" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/../..'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/../..")
+  end
+
+  it "should have the correct port" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/path(/..'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/path(/..")
+  end
+
+  it "should have the correct port" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/(path)/..'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/(path)/..")
+  end
+
+  it "should have the correct port" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/path(/../'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/path(/../")
+  end
+
+  it "should have the correct port" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/(path)/../'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/(path)/../")
+  end
+
+  it "should have the correct port" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'/..//example.com'" do
+  before do
+    @uri = Addressable::URI.parse("/..//example.com")
+  end
+
+  it "should become invalid when normalized" do
+    expect do
+      @uri.normalize
+    end.to raise_error(Addressable::URI::InvalidURIError, /authority/)
+  end
+
+  it "should have a path of '/..//example.com'" do
+    expect(@uri.path).to eq("/..//example.com")
+  end
+end
+
+describe Addressable::URI, "when parsed from '/a/b/c/./../../g'" do
+  before do
+    @uri = Addressable::URI.parse("/a/b/c/./../../g")
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  # Section 5.2.4 of RFC 3986
+  it "should normalize to '/a/g'" do
+    expect(@uri.normalize.to_s).to eq("/a/g")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'mid/content=5/../6'" do
+  before do
+    @uri = Addressable::URI.parse("mid/content=5/../6")
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  # Section 5.2.4 of RFC 3986
+  it "should normalize to 'mid/6'" do
+    expect(@uri.normalize.to_s).to eq("mid/6")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://www.example.com///../'" do
+  before do
+    @uri = Addressable::URI.parse('http://www.example.com///../')
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+
+  it "should normalize to 'http://www.example.com//'" do
+    expect(@uri.normalize.to_s).to eq("http://www.example.com//")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/path/to/resource/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/path/to/resource/")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have an authority segment of 'example.com'" do
+    expect(@uri.authority).to eq("example.com")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have a path of '/path/to/resource/'" do
+    expect(@uri.path).to eq("/path/to/resource/")
+  end
+
+  it "should have no query string" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+
+  it "should be considered absolute" do
+    expect(@uri).to be_absolute
+  end
+
+  it "should not be considered relative" do
+    expect(@uri).not_to be_relative
+  end
+
+  it "should be exactly equal to http://example.com:8080/" do
+    expect(@uri.eql?(Addressable::URI.parse(
+      "http://example.com/path/to/resource/"))).to eq(true)
+  end
+
+  it "should have a route of 'resource/' from " +
+      "'http://example.com/path/to/'" do
+    expect(@uri.route_from("http://example.com/path/to/")).to eq(
+      Addressable::URI.parse("resource/")
+    )
+  end
+
+  it "should have a route of '../' from " +
+    "'http://example.com/path/to/resource/sub'" do
+    expect(@uri.route_from("http://example.com/path/to/resource/sub")).to eq(
+      Addressable::URI.parse("../")
+    )
+  end
+
+
+  it "should have a route of 'resource/' from " +
+    "'http://example.com/path/to/another'" do
+    expect(@uri.route_from("http://example.com/path/to/another")).to eq(
+      Addressable::URI.parse("resource/")
+    )
+  end
+
+  it "should have a route of 'resource/' from " +
+      "'http://example.com/path/to/res'" do
+    expect(@uri.route_from("http://example.com/path/to/res")).to eq(
+      Addressable::URI.parse("resource/")
+    )
+  end
+
+  it "should have a route of 'resource/' from " +
+      "'http://example.com:80/path/to/'" do
+    expect(@uri.route_from("http://example.com:80/path/to/")).to eq(
+      Addressable::URI.parse("resource/")
+    )
+  end
+
+  it "should have a route of 'http://example.com/path/to/' from " +
+      "'http://example.com:8080/path/to/'" do
+    expect(@uri.route_from("http://example.com:8080/path/to/")).to eq(
+      Addressable::URI.parse("http://example.com/path/to/resource/")
+    )
+  end
+
+  it "should have a route of 'http://example.com/path/to/' from " +
+      "'http://user:pass@example.com/path/to/'" do
+    expect(@uri.route_from("http://user:pass@example.com/path/to/")).to eq(
+      Addressable::URI.parse("http://example.com/path/to/resource/")
+    )
+  end
+
+  it "should have a route of '../../path/to/resource/' from " +
+      "'http://example.com/to/resource/'" do
+    expect(@uri.route_from("http://example.com/to/resource/")).to eq(
+      Addressable::URI.parse("../../path/to/resource/")
+    )
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "http",
+      :user => nil,
+      :password => nil,
+      :host => "example.com",
+      :port => nil,
+      :path => "/path/to/resource/",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'relative/path/to/resource'" do
+  before do
+    @uri = Addressable::URI.parse("relative/path/to/resource")
+  end
+
+  it "should not have a scheme" do
+    expect(@uri.scheme).to eq(nil)
+  end
+
+  it "should not be considered ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should not have an authority segment" do
+    expect(@uri.authority).to eq(nil)
+  end
+
+  it "should not have a host" do
+    expect(@uri.host).to eq(nil)
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should not have a port" do
+    expect(@uri.port).to eq(nil)
+  end
+
+  it "should have a path of 'relative/path/to/resource'" do
+    expect(@uri.path).to eq("relative/path/to/resource")
+  end
+
+  it "should have no query string" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+
+  it "should not be considered absolute" do
+    expect(@uri).not_to be_absolute
+  end
+
+  it "should be considered relative" do
+    expect(@uri).to be_relative
+  end
+
+  it "should raise an error if routing is attempted" do
+    expect do
+      @uri.route_to("http://example.com/")
+    end.to raise_error(ArgumentError, /relative\/path\/to\/resource/)
+    expect do
+      @uri.route_from("http://example.com/")
+    end.to raise_error(ArgumentError, /relative\/path\/to\/resource/)
+  end
+
+  it "when joined with 'another/relative/path' should be " +
+      "'relative/path/to/another/relative/path'" do
+    expect(@uri.join('another/relative/path')).to eq(
+      Addressable::URI.parse("relative/path/to/another/relative/path")
+    )
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'relative_path_with_no_slashes'" do
+  before do
+    @uri = Addressable::URI.parse("relative_path_with_no_slashes")
+  end
+
+  it "should not have a scheme" do
+    expect(@uri.scheme).to eq(nil)
+  end
+
+  it "should not be considered ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should not have an authority segment" do
+    expect(@uri.authority).to eq(nil)
+  end
+
+  it "should not have a host" do
+    expect(@uri.host).to eq(nil)
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should not have a port" do
+    expect(@uri.port).to eq(nil)
+  end
+
+  it "should have a path of 'relative_path_with_no_slashes'" do
+    expect(@uri.path).to eq("relative_path_with_no_slashes")
+  end
+
+  it "should have no query string" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+
+  it "should not be considered absolute" do
+    expect(@uri).not_to be_absolute
+  end
+
+  it "should be considered relative" do
+    expect(@uri).to be_relative
+  end
+
+  it "when joined with 'another_relative_path' should be " +
+      "'another_relative_path'" do
+    expect(@uri.join('another_relative_path')).to eq(
+      Addressable::URI.parse("another_relative_path")
+    )
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/file.txt'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/file.txt")
+  end
+
+  it "should have a scheme of 'http'" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have an authority segment of 'example.com'" do
+    expect(@uri.authority).to eq("example.com")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have a path of '/file.txt'" do
+    expect(@uri.path).to eq("/file.txt")
+  end
+
+  it "should have a basename of 'file.txt'" do
+    expect(@uri.basename).to eq("file.txt")
+  end
+
+  it "should have an extname of '.txt'" do
+    expect(@uri.extname).to eq(".txt")
+  end
+
+  it "should have no query string" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/file.txt;parameter'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/file.txt;parameter")
+  end
+
+  it "should have a scheme of 'http'" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have an authority segment of 'example.com'" do
+    expect(@uri.authority).to eq("example.com")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have a path of '/file.txt;parameter'" do
+    expect(@uri.path).to eq("/file.txt;parameter")
+  end
+
+  it "should have a basename of 'file.txt'" do
+    expect(@uri.basename).to eq("file.txt")
+  end
+
+  it "should have an extname of '.txt'" do
+    expect(@uri.extname).to eq(".txt")
+  end
+
+  it "should have no query string" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/file.txt;x=y'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/file.txt;x=y")
+  end
+
+  it "should have a scheme of 'http'" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have a scheme of 'http'" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have an authority segment of 'example.com'" do
+    expect(@uri.authority).to eq("example.com")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should have no username" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have a path of '/file.txt;x=y'" do
+    expect(@uri.path).to eq("/file.txt;x=y")
+  end
+
+  it "should have an extname of '.txt'" do
+    expect(@uri.extname).to eq(".txt")
+  end
+
+  it "should have no query string" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have no fragment" do
+    expect(@uri.fragment).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'svn+ssh://developername@rubyforge.org/var/svn/project'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "svn+ssh://developername@rubyforge.org/var/svn/project"
+    )
+  end
+
+  it "should have a scheme of 'svn+ssh'" do
+    expect(@uri.scheme).to eq("svn+ssh")
+  end
+
+  it "should be considered to be ip-based" do
+    expect(@uri).to be_ip_based
+  end
+
+  it "should have a path of '/var/svn/project'" do
+    expect(@uri.path).to eq("/var/svn/project")
+  end
+
+  it "should have a username of 'developername'" do
+    expect(@uri.user).to eq("developername")
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'ssh+svn://developername@RUBYFORGE.ORG/var/svn/project'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "ssh+svn://developername@RUBYFORGE.ORG/var/svn/project"
+    )
+  end
+
+  it "should have a scheme of 'ssh+svn'" do
+    expect(@uri.scheme).to eq("ssh+svn")
+  end
+
+  it "should have a normalized scheme of 'svn+ssh'" do
+    expect(@uri.normalized_scheme).to eq("svn+ssh")
+  end
+
+  it "should have a normalized site of 'svn+ssh'" do
+    expect(@uri.normalized_site).to eq("svn+ssh://developername@rubyforge.org")
+  end
+
+  it "should not be considered to be ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should have a path of '/var/svn/project'" do
+    expect(@uri.path).to eq("/var/svn/project")
+  end
+
+  it "should have a username of 'developername'" do
+    expect(@uri.user).to eq("developername")
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should not be considered to be in normal form" do
+    expect(@uri.normalize).not_to be_eql(@uri)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'mailto:user@example.com'" do
+  before do
+    @uri = Addressable::URI.parse("mailto:user@example.com")
+  end
+
+  it "should have a scheme of 'mailto'" do
+    expect(@uri.scheme).to eq("mailto")
+  end
+
+  it "should not be considered to be ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should have a path of 'user@example.com'" do
+    expect(@uri.path).to eq("user@example.com")
+  end
+
+  it "should have no user" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'tag:example.com,2006-08-18:/path/to/something'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "tag:example.com,2006-08-18:/path/to/something")
+  end
+
+  it "should have a scheme of 'tag'" do
+    expect(@uri.scheme).to eq("tag")
+  end
+
+  it "should be considered to be ip-based" do
+    expect(@uri).not_to be_ip_based
+  end
+
+  it "should have a path of " +
+      "'example.com,2006-08-18:/path/to/something'" do
+    expect(@uri.path).to eq("example.com,2006-08-18:/path/to/something")
+  end
+
+  it "should have no user" do
+    expect(@uri.user).to eq(nil)
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/x;y/'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/x;y/")
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?x=1&y=2'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?x=1&y=2")
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'view-source:http://example.com/'" do
+  before do
+    @uri = Addressable::URI.parse("view-source:http://example.com/")
+  end
+
+  it "should have a scheme of 'view-source'" do
+    expect(@uri.scheme).to eq("view-source")
+  end
+
+  it "should have a path of 'http://example.com/'" do
+    expect(@uri.path).to eq("http://example.com/")
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://user:pass@example.com/path/to/resource?query=x#fragment'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "http://user:pass@example.com/path/to/resource?query=x#fragment")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have an authority segment of 'user:pass@example.com'" do
+    expect(@uri.authority).to eq("user:pass@example.com")
+  end
+
+  it "should have a username of 'user'" do
+    expect(@uri.user).to eq("user")
+  end
+
+  it "should have a password of 'pass'" do
+    expect(@uri.password).to eq("pass")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have a path of '/path/to/resource'" do
+    expect(@uri.path).to eq("/path/to/resource")
+  end
+
+  it "should have a query string of 'query=x'" do
+    expect(@uri.query).to eq("query=x")
+  end
+
+  it "should have a fragment of 'fragment'" do
+    expect(@uri.fragment).to eq("fragment")
+  end
+
+  it "should be considered to be in normal form" do
+    expect(@uri.normalize).to be_eql(@uri)
+  end
+
+  it "should have a route of '../../' to " +
+      "'http://user:pass@example.com/path/'" do
+    expect(@uri.route_to("http://user:pass@example.com/path/")).to eq(
+      Addressable::URI.parse("../../")
+    )
+  end
+
+  it "should have a route of 'to/resource?query=x#fragment' " +
+      "from 'http://user:pass@example.com/path/'" do
+    expect(@uri.route_from("http://user:pass@example.com/path/")).to eq(
+      Addressable::URI.parse("to/resource?query=x#fragment")
+    )
+  end
+
+  it "should have a route of '?query=x#fragment' " +
+      "from 'http://user:pass@example.com/path/to/resource'" do
+    expect(@uri.route_from("http://user:pass@example.com/path/to/resource")).to eq(
+      Addressable::URI.parse("?query=x#fragment")
+    )
+  end
+
+  it "should have a route of '#fragment' " +
+      "from 'http://user:pass@example.com/path/to/resource?query=x'" do
+    expect(@uri.route_from(
+      "http://user:pass@example.com/path/to/resource?query=x")).to eq(
+        Addressable::URI.parse("#fragment")
+    )
+  end
+
+  it "should have a route of '#fragment' from " +
+      "'http://user:pass@example.com/path/to/resource?query=x#fragment'" do
+    expect(@uri.route_from(
+      "http://user:pass@example.com/path/to/resource?query=x#fragment"
+    )).to eq(Addressable::URI.parse("#fragment"))
+  end
+
+  it "should have a route of 'http://elsewhere.com/' to " +
+      "'http://elsewhere.com/'" do
+    expect(@uri.route_to("http://elsewhere.com/")).to eq(
+      Addressable::URI.parse("http://elsewhere.com/")
+    )
+  end
+
+  it "should have a route of " +
+      "'http://user:pass@example.com/path/to/resource?query=x#fragment' " +
+      "from 'http://example.com/path/to/'" do
+    expect(@uri.route_from("http://elsewhere.com/path/to/")).to eq(
+      Addressable::URI.parse(
+        "http://user:pass@example.com/path/to/resource?query=x#fragment")
+    )
+  end
+
+  it "should have the correct scheme after assignment" do
+    @uri.scheme = "ftp"
+    expect(@uri.scheme).to eq("ftp")
+    expect(@uri.to_s).to eq(
+      "ftp://user:pass@example.com/path/to/resource?query=x#fragment"
+    )
+    expect(@uri.to_str).to eq(
+      "ftp://user:pass@example.com/path/to/resource?query=x#fragment"
+    )
+  end
+
+  it "should have the correct site segment after assignment" do
+    @uri.site = "https://newuser:newpass@example.com:443"
+    expect(@uri.scheme).to eq("https")
+    expect(@uri.authority).to eq("newuser:newpass@example.com:443")
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.userinfo).to eq("newuser:newpass")
+    expect(@uri.normalized_userinfo).to eq("newuser:newpass")
+    expect(@uri.host).to eq("example.com")
+    expect(@uri.port).to eq(443)
+    expect(@uri.inferred_port).to eq(443)
+    expect(@uri.to_s).to eq(
+      "https://newuser:newpass@example.com:443" +
+      "/path/to/resource?query=x#fragment"
+    )
+  end
+
+  it "should have the correct authority segment after assignment" do
+    @uri.authority = "newuser:newpass@example.com:80"
+    expect(@uri.authority).to eq("newuser:newpass@example.com:80")
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.userinfo).to eq("newuser:newpass")
+    expect(@uri.normalized_userinfo).to eq("newuser:newpass")
+    expect(@uri.host).to eq("example.com")
+    expect(@uri.port).to eq(80)
+    expect(@uri.inferred_port).to eq(80)
+    expect(@uri.to_s).to eq(
+      "http://newuser:newpass@example.com:80" +
+      "/path/to/resource?query=x#fragment"
+    )
+  end
+
+  it "should have the correct userinfo segment after assignment" do
+    @uri.userinfo = "newuser:newpass"
+    expect(@uri.userinfo).to eq("newuser:newpass")
+    expect(@uri.authority).to eq("newuser:newpass@example.com")
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.host).to eq("example.com")
+    expect(@uri.port).to eq(nil)
+    expect(@uri.inferred_port).to eq(80)
+    expect(@uri.to_s).to eq(
+      "http://newuser:newpass@example.com" +
+      "/path/to/resource?query=x#fragment"
+    )
+  end
+
+  it "should have the correct username after assignment" do
+    @uri.user = "newuser"
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.authority).to eq("newuser:pass@example.com")
+  end
+
+  it "should have the correct password after assignment" do
+    @uri.password = "newpass"
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.authority).to eq("user:newpass@example.com")
+  end
+
+  it "should have the correct host after assignment" do
+    @uri.host = "newexample.com"
+    expect(@uri.host).to eq("newexample.com")
+    expect(@uri.authority).to eq("user:pass@newexample.com")
+  end
+
+  it "should have the correct host after assignment" do
+    @uri.hostname = "newexample.com"
+    expect(@uri.host).to eq("newexample.com")
+    expect(@uri.hostname).to eq("newexample.com")
+    expect(@uri.authority).to eq("user:pass@newexample.com")
+  end
+
+  it "should raise an error if assigning a bogus object to the hostname" do
+    expect do
+      @uri.hostname = Object.new
+    end.to raise_error(TypeError)
+  end
+
+  it "should have the correct port after assignment" do
+    @uri.port = 8080
+    expect(@uri.port).to eq(8080)
+    expect(@uri.authority).to eq("user:pass@example.com:8080")
+  end
+
+  it "should have the correct origin after assignment" do
+    @uri.origin = "http://newexample.com"
+    expect(@uri.host).to eq("newexample.com")
+    expect(@uri.authority).to eq("newexample.com")
+  end
+
+  it "should have the correct path after assignment" do
+    @uri.path = "/newpath/to/resource"
+    expect(@uri.path).to eq("/newpath/to/resource")
+    expect(@uri.to_s).to eq(
+      "http://user:pass@example.com/newpath/to/resource?query=x#fragment"
+    )
+  end
+
+  it "should have the correct scheme and authority after nil assignment" do
+    @uri.site = nil
+    expect(@uri.scheme).to eq(nil)
+    expect(@uri.authority).to eq(nil)
+    expect(@uri.to_s).to eq("/path/to/resource?query=x#fragment")
+  end
+
+  it "should have the correct scheme and authority after assignment" do
+    @uri.site = "file://"
+    expect(@uri.scheme).to eq("file")
+    expect(@uri.authority).to eq("")
+    expect(@uri.to_s).to eq("file:///path/to/resource?query=x#fragment")
+  end
+
+  it "should have the correct path after nil assignment" do
+    @uri.path = nil
+    expect(@uri.path).to eq("")
+    expect(@uri.to_s).to eq(
+      "http://user:pass@example.com?query=x#fragment"
+    )
+  end
+
+  it "should have the correct query string after assignment" do
+    @uri.query = "newquery=x"
+    expect(@uri.query).to eq("newquery=x")
+    expect(@uri.to_s).to eq(
+      "http://user:pass@example.com/path/to/resource?newquery=x#fragment"
+    )
+    @uri.query = nil
+    expect(@uri.query).to eq(nil)
+    expect(@uri.to_s).to eq(
+      "http://user:pass@example.com/path/to/resource#fragment"
+    )
+  end
+
+  it "should have the correct query string after hash assignment" do
+    @uri.query_values = {"?uestion mark" => "=sign", "hello" => "g\xC3\xBCnther"}
+    expect(@uri.query.split("&")).to include("%3Fuestion%20mark=%3Dsign")
+    expect(@uri.query.split("&")).to include("hello=g%C3%BCnther")
+    expect(@uri.query_values).to eq({
+      "?uestion mark" => "=sign", "hello" => "g\xC3\xBCnther"
+    })
+  end
+
+  it "should have the correct query string after flag hash assignment" do
+    @uri.query_values = {'flag?1' => nil, 'fl=ag2' => nil, 'flag3' => nil}
+    expect(@uri.query.split("&")).to include("flag%3F1")
+    expect(@uri.query.split("&")).to include("fl%3Dag2")
+    expect(@uri.query.split("&")).to include("flag3")
+    expect(@uri.query_values(Array).sort).to eq([["fl=ag2"], ["flag3"], ["flag?1"]])
+    expect(@uri.query_values(Hash)).to eq({
+      'flag?1' => nil, 'fl=ag2' => nil, 'flag3' => nil
+    })
+  end
+
+  it "should raise an error if query values are set to a bogus type" do
+    expect do
+      @uri.query_values = "bogus"
+    end.to raise_error(TypeError)
+  end
+
+  it "should have the correct fragment after assignment" do
+    @uri.fragment = "newfragment"
+    expect(@uri.fragment).to eq("newfragment")
+    expect(@uri.to_s).to eq(
+      "http://user:pass@example.com/path/to/resource?query=x#newfragment"
+    )
+
+    @uri.fragment = nil
+    expect(@uri.fragment).to eq(nil)
+    expect(@uri.to_s).to eq(
+      "http://user:pass@example.com/path/to/resource?query=x"
+    )
+  end
+
+  it "should have the correct values after a merge" do
+    expect(@uri.merge(:fragment => "newfragment").to_s).to eq(
+      "http://user:pass@example.com/path/to/resource?query=x#newfragment"
+    )
+  end
+
+  it "should have the correct values after a merge" do
+    expect(@uri.merge(:fragment => nil).to_s).to eq(
+      "http://user:pass@example.com/path/to/resource?query=x"
+    )
+  end
+
+  it "should have the correct values after a merge" do
+    expect(@uri.merge(:userinfo => "newuser:newpass").to_s).to eq(
+      "http://newuser:newpass@example.com/path/to/resource?query=x#fragment"
+    )
+  end
+
+  it "should have the correct values after a merge" do
+    expect(@uri.merge(:userinfo => nil).to_s).to eq(
+      "http://example.com/path/to/resource?query=x#fragment"
+    )
+  end
+
+  it "should have the correct values after a merge" do
+    expect(@uri.merge(:path => "newpath").to_s).to eq(
+      "http://user:pass@example.com/newpath?query=x#fragment"
+    )
+  end
+
+  it "should have the correct values after a merge" do
+    expect(@uri.merge(:port => "42", :path => "newpath", :query => "").to_s).to eq(
+      "http://user:pass@example.com:42/newpath?#fragment"
+    )
+  end
+
+  it "should have the correct values after a merge" do
+    expect(@uri.merge(:authority => "foo:bar@baz:42").to_s).to eq(
+      "http://foo:bar@baz:42/path/to/resource?query=x#fragment"
+    )
+    # Ensure the operation was not destructive
+    expect(@uri.to_s).to eq(
+      "http://user:pass@example.com/path/to/resource?query=x#fragment"
+    )
+  end
+
+  it "should have the correct values after a destructive merge" do
+    @uri.merge!(:authority => "foo:bar@baz:42")
+    # Ensure the operation was destructive
+    expect(@uri.to_s).to eq(
+      "http://foo:bar@baz:42/path/to/resource?query=x#fragment"
+    )
+  end
+
+  it "should fail to merge with bogus values" do
+    expect do
+      @uri.merge(:port => "bogus")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should fail to merge with bogus values" do
+    expect do
+      @uri.merge(:authority => "bar@baz:bogus")
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should fail to merge with bogus parameters" do
+    expect do
+      @uri.merge(42)
+    end.to raise_error(TypeError)
+  end
+
+  it "should fail to merge with bogus parameters" do
+    expect do
+      @uri.merge("http://example.com/")
+    end.to raise_error(TypeError)
+  end
+
+  it "should fail to merge with both authority and subcomponents" do
+    expect do
+      @uri.merge(:authority => "foo:bar@baz:42", :port => "42")
+    end.to raise_error(ArgumentError)
+  end
+
+  it "should fail to merge with both userinfo and subcomponents" do
+    expect do
+      @uri.merge(:userinfo => "foo:bar", :user => "foo")
+    end.to raise_error(ArgumentError)
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+  "'http://example.com/search?q=Q%26A'" do
+
+  before do
+    @uri = Addressable::URI.parse("http://example.com/search?q=Q%26A")
+  end
+
+  it "should have a query of 'q=Q%26A'" do
+    expect(@uri.query).to eq("q=Q%26A")
+  end
+
+  it "should have query_values of {'q' => 'Q&A'}" do
+    expect(@uri.query_values).to eq({ 'q' => 'Q&A' })
+  end
+
+  it "should normalize to the original uri " +
+      "(with the ampersand properly percent-encoded)" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/search?q=Q%26A")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?&x=b'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?&x=b")
+  end
+
+  it "should have a query of '&x=b'" do
+    expect(@uri.query).to eq("&x=b")
+  end
+
+  it "should have query_values of {'x' => 'b'}" do
+    expect(@uri.query_values).to eq({'x' => 'b'})
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q='one;two'&x=1'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q='one;two'&x=1")
+  end
+
+  it "should have a query of 'q='one;two'&x=1'" do
+    expect(@uri.query).to eq("q='one;two'&x=1")
+  end
+
+  it "should have query_values of {\"q\" => \"'one;two'\", \"x\" => \"1\"}" do
+    expect(@uri.query_values).to eq({"q" => "'one;two'", "x" => "1"})
+  end
+
+  it "should escape the ';' character when normalizing to avoid ambiguity " +
+      "with the W3C HTML 4.01 specification" do
+    # HTML 4.01 Section B.2.2
+    expect(@uri.normalize.query).to eq("q='one%3Btwo'&x=1")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?&&x=b'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?&&x=b")
+  end
+
+  it "should have a query of '&&x=b'" do
+    expect(@uri.query).to eq("&&x=b")
+  end
+
+  it "should have query_values of {'x' => 'b'}" do
+    expect(@uri.query_values).to eq({'x' => 'b'})
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q=a&&x=b'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q=a&&x=b")
+  end
+
+  it "should have a query of 'q=a&&x=b'" do
+    expect(@uri.query).to eq("q=a&&x=b")
+  end
+
+  it "should have query_values of {'q' => 'a, 'x' => 'b'}" do
+    expect(@uri.query_values).to eq({'q' => 'a', 'x' => 'b'})
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q&&x=b'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q&&x=b")
+  end
+
+  it "should have a query of 'q&&x=b'" do
+    expect(@uri.query).to eq("q&&x=b")
+  end
+
+  it "should have query_values of {'q' => true, 'x' => 'b'}" do
+    expect(@uri.query_values).to eq({'q' => nil, 'x' => 'b'})
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q=a+b")
+  end
+
+  it "should have a query of 'q=a+b'" do
+    expect(@uri.query).to eq("q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a b'}" do
+    expect(@uri.query_values).to eq({'q' => 'a b'})
+  end
+
+  it "should have a normalized query of 'q=a+b'" do
+    expect(@uri.normalized_query).to eq("q=a+b")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'https://example.com/?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("https://example.com/?q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a b'}" do
+    expect(@uri.query_values).to eq("q" => "a b")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'example.com?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("example.com?q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a b'}" do
+    expect(@uri.query_values).to eq("q" => "a b")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'mailto:?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("mailto:?q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a+b'}" do
+    expect(@uri.query_values).to eq("q" => "a+b")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q=a%2bb'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q=a%2bb")
+  end
+
+  it "should have a query of 'q=a+b'" do
+    expect(@uri.query).to eq("q=a%2bb")
+  end
+
+  it "should have query_values of {'q' => 'a+b'}" do
+    expect(@uri.query_values).to eq({'q' => 'a+b'})
+  end
+
+  it "should have a normalized query of 'q=a%2Bb'" do
+    expect(@uri.normalized_query).to eq("q=a%2Bb")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?v=%7E&w=%&x=%25&y=%2B&z=C%CC%A7'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?v=%7E&w=%&x=%25&y=%2B&z=C%CC%A7")
+  end
+
+  it "should have a normalized query of 'v=~&w=%25&x=%25&y=%2B&z=%C3%87'" do
+    expect(@uri.normalized_query).to eq("v=~&w=%25&x=%25&y=%2B&z=%C3%87")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?v=%7E&w=%&x=%25&y=+&z=C%CC%A7'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?v=%7E&w=%&x=%25&y=+&z=C%CC%A7")
+  end
+
+  it "should have a normalized query of 'v=~&w=%25&x=%25&y=+&z=%C3%87'" do
+    expect(@uri.normalized_query).to eq("v=~&w=%25&x=%25&y=+&z=%C3%87")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'http://example/?b=1&a=2&c=3'" do
+  before do
+    @uri = Addressable::URI.parse("http://example/?b=1&a=2&c=3")
+  end
+
+  it "should have a sorted normalized query of 'a=2&b=1&c=3'" do
+    expect(@uri.normalized_query(:sorted)).to eq("a=2&b=1&c=3")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'http://example/?&a&&c&'" do
+  before do
+    @uri = Addressable::URI.parse("http://example/?&a&&c&")
+  end
+
+  it "should have a compacted normalized query of 'a&c'" do
+    expect(@uri.normalized_query(:compacted)).to eq("a&c")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'http://example.com/?a=1&a=1'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?a=1&a=1")
+  end
+
+  it "should have a compacted normalized query of 'a=1'" do
+    expect(@uri.normalized_query(:compacted)).to eq("a=1")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'http://example.com/?a=1&a=2'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?a=1&a=2")
+  end
+
+  it "should have a compacted normalized query of 'a=1&a=2'" do
+    expect(@uri.normalized_query(:compacted)).to eq("a=1&a=2")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/sound%2bvision'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/sound%2bvision")
+  end
+
+  it "should have a normalized path of '/sound+vision'" do
+    expect(@uri.normalized_path).to eq('/sound+vision')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/?q='" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?q=")
+  end
+
+  it "should have a query of 'q='" do
+    expect(@uri.query).to eq("q=")
+  end
+
+  it "should have query_values of {'q' => ''}" do
+    expect(@uri.query_values).to eq({'q' => ''})
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://user@example.com'" do
+  before do
+    @uri = Addressable::URI.parse("http://user@example.com")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have a username of 'user'" do
+    expect(@uri.user).to eq("user")
+  end
+
+  it "should have no password" do
+    expect(@uri.password).to eq(nil)
+  end
+
+  it "should have a userinfo of 'user'" do
+    expect(@uri.userinfo).to eq("user")
+  end
+
+  it "should have a normalized userinfo of 'user'" do
+    expect(@uri.normalized_userinfo).to eq("user")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should have default_port 80" do
+    expect(@uri.default_port).to eq(80)
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have the correct username after assignment" do
+    @uri.user = "newuser"
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq(nil)
+    expect(@uri.to_s).to eq("http://newuser@example.com")
+  end
+
+  it "should have the correct password after assignment" do
+    @uri.password = "newpass"
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.to_s).to eq("http://user:newpass@example.com")
+  end
+
+  it "should have the correct userinfo segment after assignment" do
+    @uri.userinfo = "newuser:newpass"
+    expect(@uri.userinfo).to eq("newuser:newpass")
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.host).to eq("example.com")
+    expect(@uri.port).to eq(nil)
+    expect(@uri.inferred_port).to eq(80)
+    expect(@uri.to_s).to eq("http://newuser:newpass@example.com")
+  end
+
+  it "should have the correct userinfo segment after nil assignment" do
+    @uri.userinfo = nil
+    expect(@uri.userinfo).to eq(nil)
+    expect(@uri.user).to eq(nil)
+    expect(@uri.password).to eq(nil)
+    expect(@uri.host).to eq("example.com")
+    expect(@uri.port).to eq(nil)
+    expect(@uri.inferred_port).to eq(80)
+    expect(@uri.to_s).to eq("http://example.com")
+  end
+
+  it "should have the correct authority segment after assignment" do
+    @uri.authority = "newuser@example.com"
+    expect(@uri.authority).to eq("newuser@example.com")
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq(nil)
+    expect(@uri.host).to eq("example.com")
+    expect(@uri.port).to eq(nil)
+    expect(@uri.inferred_port).to eq(80)
+    expect(@uri.to_s).to eq("http://newuser@example.com")
+  end
+
+  it "should raise an error after nil assignment of authority segment" do
+    expect do
+      # This would create an invalid URI
+      @uri.authority = nil
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://user:@example.com'" do
+  before do
+    @uri = Addressable::URI.parse("http://user:@example.com")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have a username of 'user'" do
+    expect(@uri.user).to eq("user")
+  end
+
+  it "should have a password of ''" do
+    expect(@uri.password).to eq("")
+  end
+
+  it "should have a normalized userinfo of 'user:'" do
+    expect(@uri.normalized_userinfo).to eq("user:")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have the correct username after assignment" do
+    @uri.user = "newuser"
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq("")
+    expect(@uri.to_s).to eq("http://newuser:@example.com")
+  end
+
+  it "should have the correct password after assignment" do
+    @uri.password = "newpass"
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.to_s).to eq("http://user:newpass@example.com")
+  end
+
+  it "should have the correct authority segment after assignment" do
+    @uri.authority = "newuser:@example.com"
+    expect(@uri.authority).to eq("newuser:@example.com")
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq("")
+    expect(@uri.host).to eq("example.com")
+    expect(@uri.port).to eq(nil)
+    expect(@uri.inferred_port).to eq(80)
+    expect(@uri.to_s).to eq("http://newuser:@example.com")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://:pass@example.com'" do
+  before do
+    @uri = Addressable::URI.parse("http://:pass@example.com")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have a username of ''" do
+    expect(@uri.user).to eq("")
+  end
+
+  it "should have a password of 'pass'" do
+    expect(@uri.password).to eq("pass")
+  end
+
+  it "should have a userinfo of ':pass'" do
+    expect(@uri.userinfo).to eq(":pass")
+  end
+
+  it "should have a normalized userinfo of ':pass'" do
+    expect(@uri.normalized_userinfo).to eq(":pass")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have the correct username after assignment" do
+    @uri.user = "newuser"
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq("pass")
+    expect(@uri.to_s).to eq("http://newuser:pass@example.com")
+  end
+
+  it "should have the correct password after assignment" do
+    @uri.password = "newpass"
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.user).to eq("")
+    expect(@uri.to_s).to eq("http://:newpass@example.com")
+  end
+
+  it "should have the correct authority segment after assignment" do
+    @uri.authority = ":newpass@example.com"
+    expect(@uri.authority).to eq(":newpass@example.com")
+    expect(@uri.user).to eq("")
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.host).to eq("example.com")
+    expect(@uri.port).to eq(nil)
+    expect(@uri.inferred_port).to eq(80)
+    expect(@uri.to_s).to eq("http://:newpass@example.com")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://:@example.com'" do
+  before do
+    @uri = Addressable::URI.parse("http://:@example.com")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have a username of ''" do
+    expect(@uri.user).to eq("")
+  end
+
+  it "should have a password of ''" do
+    expect(@uri.password).to eq("")
+  end
+
+  it "should have a normalized userinfo of nil" do
+    expect(@uri.normalized_userinfo).to eq(nil)
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have the correct username after assignment" do
+    @uri.user = "newuser"
+    expect(@uri.user).to eq("newuser")
+    expect(@uri.password).to eq("")
+    expect(@uri.to_s).to eq("http://newuser:@example.com")
+  end
+
+  it "should have the correct password after assignment" do
+    @uri.password = "newpass"
+    expect(@uri.password).to eq("newpass")
+    expect(@uri.user).to eq("")
+    expect(@uri.to_s).to eq("http://:newpass@example.com")
+  end
+
+  it "should have the correct authority segment after assignment" do
+    @uri.authority = ":@newexample.com"
+    expect(@uri.authority).to eq(":@newexample.com")
+    expect(@uri.user).to eq("")
+    expect(@uri.password).to eq("")
+    expect(@uri.host).to eq("newexample.com")
+    expect(@uri.port).to eq(nil)
+    expect(@uri.inferred_port).to eq(80)
+    expect(@uri.to_s).to eq("http://:@newexample.com")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'#example'" do
+  before do
+    @uri = Addressable::URI.parse("#example")
+  end
+
+  it "should be considered relative" do
+    expect(@uri).to be_relative
+  end
+
+  it "should have a host of nil" do
+    expect(@uri.host).to eq(nil)
+  end
+
+  it "should have a site of nil" do
+    expect(@uri.site).to eq(nil)
+  end
+
+  it "should have a normalized_site of nil" do
+    expect(@uri.normalized_site).to eq(nil)
+  end
+
+  it "should have a path of ''" do
+    expect(@uri.path).to eq("")
+  end
+
+  it "should have a query string of nil" do
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should have a fragment of 'example'" do
+    expect(@uri.fragment).to eq("example")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "the network-path reference '//example.com/'" do
+  before do
+    @uri = Addressable::URI.parse("//example.com/")
+  end
+
+  it "should be considered relative" do
+    expect(@uri).to be_relative
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should have a path of '/'" do
+    expect(@uri.path).to eq("/")
+  end
+
+  it "should raise an error if routing is attempted" do
+    expect do
+      @uri.route_to("http://example.com/")
+    end.to raise_error(ArgumentError, /\/\/example.com\//)
+    expect do
+      @uri.route_from("http://example.com/")
+    end.to raise_error(ArgumentError, /\/\/example.com\//)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'feed://http://example.com/'" do
+  before do
+    @uri = Addressable::URI.parse("feed://http://example.com/")
+  end
+
+  it "should have a host of 'http'" do
+    expect(@uri.host).to eq("http")
+  end
+
+  it "should have a path of '//example.com/'" do
+    expect(@uri.path).to eq("//example.com/")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'feed:http://example.com/'" do
+  before do
+    @uri = Addressable::URI.parse("feed:http://example.com/")
+  end
+
+  it "should have a path of 'http://example.com/'" do
+    expect(@uri.path).to eq("http://example.com/")
+  end
+
+  it "should normalize to 'http://example.com/'" do
+    expect(@uri.normalize.to_s).to eq("http://example.com/")
+    expect(@uri.normalize!.to_s).to eq("http://example.com/")
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'example://a/b/c/%7Bfoo%7D'" do
+  before do
+    @uri = Addressable::URI.parse("example://a/b/c/%7Bfoo%7D")
+  end
+
+  # Section 6.2.2 of RFC 3986
+  it "should be equivalent to eXAMPLE://a/./b/../b/%63/%7bfoo%7d" do
+    expect(@uri).to eq(
+      Addressable::URI.parse("eXAMPLE://a/./b/../b/%63/%7bfoo%7d")
+    )
+  end
+
+  it "should have an origin of 'example://a'" do
+    expect(@uri.origin).to eq('example://a')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://example.com/indirect/path/./to/../resource/'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "http://example.com/indirect/path/./to/../resource/")
+  end
+
+  it "should use the 'http' scheme" do
+    expect(@uri.scheme).to eq("http")
+  end
+
+  it "should have a host of 'example.com'" do
+    expect(@uri.host).to eq("example.com")
+  end
+
+  it "should use port 80" do
+    expect(@uri.inferred_port).to eq(80)
+  end
+
+  it "should have a path of '/indirect/path/./to/../resource/'" do
+    expect(@uri.path).to eq("/indirect/path/./to/../resource/")
+  end
+
+  # Section 6.2.2.3 of RFC 3986
+  it "should have a normalized path of '/indirect/path/resource/'" do
+    expect(@uri.normalize.path).to eq("/indirect/path/resource/")
+    expect(@uri.normalize!.path).to eq("/indirect/path/resource/")
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://under_score.example.com/'" do
+  it "should not cause an error" do
+    expect do
+      Addressable::URI.parse("http://under_score.example.com/")
+    end.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'./this:that'" do
+  before do
+    @uri = Addressable::URI.parse("./this:that")
+  end
+
+  it "should be considered relative" do
+    expect(@uri).to be_relative
+  end
+
+  it "should have no scheme" do
+    expect(@uri.scheme).to eq(nil)
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'this:that'" do
+  before do
+    @uri = Addressable::URI.parse("this:that")
+  end
+
+  it "should be considered absolute" do
+    expect(@uri).to be_absolute
+  end
+
+  it "should have a scheme of 'this'" do
+    expect(@uri.scheme).to eq("this")
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when parsed from '?'" do
+  before do
+    @uri = Addressable::URI.parse("?")
+  end
+
+  it "should normalize to ''" do
+    expect(@uri.normalize.to_s).to eq("")
+  end
+
+  it "should have the correct return type" do
+    expect(@uri.query_values).to eq({})
+    expect(@uri.query_values(Hash)).to eq({})
+    expect(@uri.query_values(Array)).to eq([])
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when parsed from '?one=1&two=2&three=3'" do
+  before do
+    @uri = Addressable::URI.parse("?one=1&two=2&three=3")
+  end
+
+  it "should have the correct query values" do
+    expect(@uri.query_values).to eq({"one" => "1", "two" => "2", "three" => "3"})
+  end
+
+  it "should raise an error for invalid return type values" do
+    expect do
+      @uri.query_values(Integer)
+    end.to raise_error(ArgumentError)
+  end
+
+  it "should have the correct array query values" do
+    expect(@uri.query_values(Array)).to eq([
+      ["one", "1"], ["two", "2"], ["three", "3"]
+    ])
+  end
+
+  it "should have a 'null' origin" do
+    expect(@uri.origin).to eq('null')
+  end
+end
+
+describe Addressable::URI, "when parsed from '?one=1=uno&two=2=dos'" do
+  before do
+    @uri = Addressable::URI.parse("?one=1=uno&two=2=dos")
+  end
+
+  it "should have the correct query values" do
+    expect(@uri.query_values).to eq({"one" => "1=uno", "two" => "2=dos"})
+  end
+
+  it "should have the correct array query values" do
+    expect(@uri.query_values(Array)).to eq([
+      ["one", "1=uno"], ["two", "2=dos"]
+    ])
+  end
+end
+
+describe Addressable::URI, "when parsed from '?one[two][three]=four'" do
+  before do
+    @uri = Addressable::URI.parse("?one[two][three]=four")
+  end
+
+  it "should have the correct query values" do
+    expect(@uri.query_values).to eq({"one[two][three]" => "four"})
+  end
+
+  it "should have the correct array query values" do
+    expect(@uri.query_values(Array)).to eq([
+      ["one[two][three]", "four"]
+    ])
+  end
+end
+
+describe Addressable::URI, "when parsed from '?one.two.three=four'" do
+  before do
+    @uri = Addressable::URI.parse("?one.two.three=four")
+  end
+
+  it "should have the correct query values" do
+    expect(@uri.query_values).to eq({
+      "one.two.three" => "four"
+    })
+  end
+
+  it "should have the correct array query values" do
+    expect(@uri.query_values(Array)).to eq([
+      ["one.two.three", "four"]
+    ])
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'?one[two][three]=four&one[two][five]=six'" do
+  before do
+    @uri = Addressable::URI.parse("?one[two][three]=four&one[two][five]=six")
+  end
+
+  it "should have the correct query values" do
+    expect(@uri.query_values).to eq({
+      "one[two][three]" => "four", "one[two][five]" => "six"
+    })
+  end
+
+  it "should have the correct array query values" do
+    expect(@uri.query_values(Array)).to eq([
+      ["one[two][three]", "four"], ["one[two][five]", "six"]
+    ])
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'?one.two.three=four&one.two.five=six'" do
+  before do
+    @uri = Addressable::URI.parse("?one.two.three=four&one.two.five=six")
+  end
+
+  it "should have the correct query values" do
+    expect(@uri.query_values).to eq({
+      "one.two.three" => "four", "one.two.five" => "six"
+    })
+  end
+
+  it "should have the correct array query values" do
+    expect(@uri.query_values(Array)).to eq([
+      ["one.two.three", "four"], ["one.two.five", "six"]
+    ])
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'?one=two&one=three'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "?one=two&one=three&one=four"
+    )
+  end
+
+  it "should have correct array query values" do
+    expect(@uri.query_values(Array)).to eq(
+      [['one', 'two'], ['one', 'three'], ['one', 'four']]
+    )
+  end
+
+  it "should have correct hash query values" do
+    skip("This is probably more desirable behavior.")
+    expect(@uri.query_values(Hash)).to eq(
+      {'one' => ['two', 'three', 'four']}
+      )
+  end
+
+  it "should handle assignment with keys of mixed type" do
+    @uri.query_values = @uri.query_values(Hash).merge({:one => 'three'})
+    expect(@uri.query_values(Hash)).to eq({'one' => 'three'})
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'?one[two][three][]=four&one[two][three][]=five'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "?one[two][three][]=four&one[two][three][]=five"
+    )
+  end
+
+  it "should have correct query values" do
+    expect(@uri.query_values(Hash)).to eq({"one[two][three][]" => "five"})
+  end
+
+  it "should have correct array query values" do
+    expect(@uri.query_values(Array)).to eq([
+      ["one[two][three][]", "four"], ["one[two][three][]", "five"]
+    ])
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'?one[two][three][0]=four&one[two][three][1]=five'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "?one[two][three][0]=four&one[two][three][1]=five"
+    )
+  end
+
+  it "should have the correct query values" do
+    expect(@uri.query_values).to eq({
+      "one[two][three][0]" => "four", "one[two][three][1]" => "five"
+    })
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'?one[two][three][1]=four&one[two][three][0]=five'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "?one[two][three][1]=four&one[two][three][0]=five"
+    )
+  end
+
+  it "should have the correct query values" do
+    expect(@uri.query_values).to eq({
+      "one[two][three][1]" => "four", "one[two][three][0]" => "five"
+    })
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'?one[two][three][2]=four&one[two][three][1]=five'" do
+  before do
+    @uri = Addressable::URI.parse(
+      "?one[two][three][2]=four&one[two][three][1]=five"
+    )
+  end
+
+  it "should have the correct query values" do
+    expect(@uri.query_values).to eq({
+      "one[two][three][2]" => "four", "one[two][three][1]" => "five"
+    })
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://www.詹姆斯.com/'" do
+  before do
+    @uri = Addressable::URI.parse("http://www.詹姆斯.com/")
+  end
+
+  it "should be equivalent to 'http://www.xn--8ws00zhy3a.com/'" do
+    expect(@uri).to eq(
+      Addressable::URI.parse("http://www.xn--8ws00zhy3a.com/")
+    )
+  end
+
+  it "should not have domain name encoded during normalization" do
+    expect(Addressable::URI.normalized_encode(@uri.to_s)).to eq(
+      "http://www.詹姆斯.com/"
+    )
+  end
+
+  it "should have an origin of 'http://www.xn--8ws00zhy3a.com'" do
+    expect(@uri.origin).to eq('http://www.xn--8ws00zhy3a.com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://www.詹姆斯.com/ some spaces /'" do
+  before do
+    @uri = Addressable::URI.parse("http://www.詹姆斯.com/ some spaces /")
+  end
+
+  it "should be equivalent to " +
+      "'http://www.xn--8ws00zhy3a.com/%20some%20spaces%20/'" do
+    expect(@uri).to eq(
+      Addressable::URI.parse(
+        "http://www.xn--8ws00zhy3a.com/%20some%20spaces%20/")
+    )
+  end
+
+  it "should not have domain name encoded during normalization" do
+    expect(Addressable::URI.normalized_encode(@uri.to_s)).to eq(
+      "http://www.詹姆斯.com/%20some%20spaces%20/"
+    )
+  end
+
+  it "should have an origin of 'http://www.xn--8ws00zhy3a.com'" do
+    expect(@uri.origin).to eq('http://www.xn--8ws00zhy3a.com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://www.xn--8ws00zhy3a.com/'" do
+  before do
+    @uri = Addressable::URI.parse("http://www.xn--8ws00zhy3a.com/")
+  end
+
+  it "should be displayed as http://www.詹姆斯.com/" do
+    expect(@uri.display_uri.to_s).to eq("http://www.詹姆斯.com/")
+  end
+
+  it "should properly force the encoding" do
+    display_string = @uri.display_uri.to_str
+    expect(display_string).to eq("http://www.詹姆斯.com/")
+    if display_string.respond_to?(:encoding)
+      expect(display_string.encoding.to_s).to eq(Encoding::UTF_8.to_s)
+    end
+  end
+
+  it "should have an origin of 'http://www.xn--8ws00zhy3a.com'" do
+    expect(@uri.origin).to eq('http://www.xn--8ws00zhy3a.com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://www.詹姆斯.com/atomtests/iri/詹.html'" do
+  before do
+    @uri = Addressable::URI.parse("http://www.詹姆斯.com/atomtests/iri/詹.html")
+  end
+
+  it "should normalize to " +
+      "http://www.xn--8ws00zhy3a.com/atomtests/iri/%E8%A9%B9.html" do
+    expect(@uri.normalize.to_s).to eq(
+      "http://www.xn--8ws00zhy3a.com/atomtests/iri/%E8%A9%B9.html"
+    )
+    expect(@uri.normalize!.to_s).to eq(
+      "http://www.xn--8ws00zhy3a.com/atomtests/iri/%E8%A9%B9.html"
+    )
+  end
+end
+
+describe Addressable::URI, "when parsed from a percent-encoded IRI" do
+  before do
+    @uri = Addressable::URI.parse(
+      "http://www.%E3%81%BB%E3%82%93%E3%81%A8%E3%81%86%E3%81%AB%E3%81%AA" +
+      "%E3%81%8C%E3%81%84%E3%82%8F%E3%81%91%E3%81%AE%E3%82%8F%E3%81%8B%E3" +
+      "%82%89%E3%81%AA%E3%81%84%E3%81%A9%E3%82%81%E3%81%84%E3%82%93%E3%82" +
+      "%81%E3%81%84%E3%81%AE%E3%82%89%E3%81%B9%E3%82%8B%E3%81%BE%E3%81%A0" +
+      "%E3%81%AA%E3%81%8C%E3%81%8F%E3%81%97%E3%81%AA%E3%81%84%E3%81%A8%E3" +
+      "%81%9F%E3%82%8A%E3%81%AA%E3%81%84.w3.mag.keio.ac.jp"
+    )
+  end
+
+  it "should normalize to something sane" do
+    expect(@uri.normalize.to_s).to eq(
+      "http://www.xn--n8jaaaaai5bhf7as8fsfk3jnknefdde3f" +
+      "g11amb5gzdb4wi9bya3kc6lra.w3.mag.keio.ac.jp/"
+    )
+    expect(@uri.normalize!.to_s).to eq(
+      "http://www.xn--n8jaaaaai5bhf7as8fsfk3jnknefdde3f" +
+      "g11amb5gzdb4wi9bya3kc6lra.w3.mag.keio.ac.jp/"
+    )
+  end
+
+  it "should have the correct origin" do
+    expect(@uri.origin).to eq(
+      "http://www.xn--n8jaaaaai5bhf7as8fsfk3jnknefdde3f" +
+      "g11amb5gzdb4wi9bya3kc6lra.w3.mag.keio.ac.jp"
+    )
+  end
+end
+
+describe Addressable::URI, "with a base uri of 'http://a/b/c/d;p?q'" do
+  before do
+    @uri = Addressable::URI.parse("http://a/b/c/d;p?q")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with 'g:h' should resolve to g:h" do
+    expect((@uri + "g:h").to_s).to eq("g:h")
+    expect(Addressable::URI.join(@uri, "g:h").to_s).to eq("g:h")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with 'g' should resolve to http://a/b/c/g" do
+    expect((@uri + "g").to_s).to eq("http://a/b/c/g")
+    expect(Addressable::URI.join(@uri.to_s, "g").to_s).to eq("http://a/b/c/g")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with './g' should resolve to http://a/b/c/g" do
+    expect((@uri + "./g").to_s).to eq("http://a/b/c/g")
+    expect(Addressable::URI.join(@uri.to_s, "./g").to_s).to eq("http://a/b/c/g")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with 'g/' should resolve to http://a/b/c/g/" do
+    expect((@uri + "g/").to_s).to eq("http://a/b/c/g/")
+    expect(Addressable::URI.join(@uri.to_s, "g/").to_s).to eq("http://a/b/c/g/")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '/g' should resolve to http://a/g" do
+    expect((@uri + "/g").to_s).to eq("http://a/g")
+    expect(Addressable::URI.join(@uri.to_s, "/g").to_s).to eq("http://a/g")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '//g' should resolve to http://g" do
+    expect((@uri + "//g").to_s).to eq("http://g")
+    expect(Addressable::URI.join(@uri.to_s, "//g").to_s).to eq("http://g")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '?y' should resolve to http://a/b/c/d;p?y" do
+    expect((@uri + "?y").to_s).to eq("http://a/b/c/d;p?y")
+    expect(Addressable::URI.join(@uri.to_s, "?y").to_s).to eq("http://a/b/c/d;p?y")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with 'g?y' should resolve to http://a/b/c/g?y" do
+    expect((@uri + "g?y").to_s).to eq("http://a/b/c/g?y")
+    expect(Addressable::URI.join(@uri.to_s, "g?y").to_s).to eq("http://a/b/c/g?y")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '#s' should resolve to http://a/b/c/d;p?q#s" do
+    expect((@uri + "#s").to_s).to eq("http://a/b/c/d;p?q#s")
+    expect(Addressable::URI.join(@uri.to_s, "#s").to_s).to eq(
+      "http://a/b/c/d;p?q#s"
+    )
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with 'g#s' should resolve to http://a/b/c/g#s" do
+    expect((@uri + "g#s").to_s).to eq("http://a/b/c/g#s")
+    expect(Addressable::URI.join(@uri.to_s, "g#s").to_s).to eq("http://a/b/c/g#s")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with 'g?y#s' should resolve to http://a/b/c/g?y#s" do
+    expect((@uri + "g?y#s").to_s).to eq("http://a/b/c/g?y#s")
+    expect(Addressable::URI.join(
+      @uri.to_s, "g?y#s").to_s).to eq("http://a/b/c/g?y#s")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with ';x' should resolve to http://a/b/c/;x" do
+    expect((@uri + ";x").to_s).to eq("http://a/b/c/;x")
+    expect(Addressable::URI.join(@uri.to_s, ";x").to_s).to eq("http://a/b/c/;x")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with 'g;x' should resolve to http://a/b/c/g;x" do
+    expect((@uri + "g;x").to_s).to eq("http://a/b/c/g;x")
+    expect(Addressable::URI.join(@uri.to_s, "g;x").to_s).to eq("http://a/b/c/g;x")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with 'g;x?y#s' should resolve to http://a/b/c/g;x?y#s" do
+    expect((@uri + "g;x?y#s").to_s).to eq("http://a/b/c/g;x?y#s")
+    expect(Addressable::URI.join(
+      @uri.to_s, "g;x?y#s").to_s).to eq("http://a/b/c/g;x?y#s")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '' should resolve to http://a/b/c/d;p?q" do
+    expect((@uri + "").to_s).to eq("http://a/b/c/d;p?q")
+    expect(Addressable::URI.join(@uri.to_s, "").to_s).to eq("http://a/b/c/d;p?q")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '.' should resolve to http://a/b/c/" do
+    expect((@uri + ".").to_s).to eq("http://a/b/c/")
+    expect(Addressable::URI.join(@uri.to_s, ".").to_s).to eq("http://a/b/c/")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with './' should resolve to http://a/b/c/" do
+    expect((@uri + "./").to_s).to eq("http://a/b/c/")
+    expect(Addressable::URI.join(@uri.to_s, "./").to_s).to eq("http://a/b/c/")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '..' should resolve to http://a/b/" do
+    expect((@uri + "..").to_s).to eq("http://a/b/")
+    expect(Addressable::URI.join(@uri.to_s, "..").to_s).to eq("http://a/b/")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '../' should resolve to http://a/b/" do
+    expect((@uri + "../").to_s).to eq("http://a/b/")
+    expect(Addressable::URI.join(@uri.to_s, "../").to_s).to eq("http://a/b/")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '../g' should resolve to http://a/b/g" do
+    expect((@uri + "../g").to_s).to eq("http://a/b/g")
+    expect(Addressable::URI.join(@uri.to_s, "../g").to_s).to eq("http://a/b/g")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '../..' should resolve to http://a/" do
+    expect((@uri + "../..").to_s).to eq("http://a/")
+    expect(Addressable::URI.join(@uri.to_s, "../..").to_s).to eq("http://a/")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '../../' should resolve to http://a/" do
+    expect((@uri + "../../").to_s).to eq("http://a/")
+    expect(Addressable::URI.join(@uri.to_s, "../../").to_s).to eq("http://a/")
+  end
+
+  # Section 5.4.1 of RFC 3986
+  it "when joined with '../../g' should resolve to http://a/g" do
+    expect((@uri + "../../g").to_s).to eq("http://a/g")
+    expect(Addressable::URI.join(@uri.to_s, "../../g").to_s).to eq("http://a/g")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with '../../../g' should resolve to http://a/g" do
+    expect((@uri + "../../../g").to_s).to eq("http://a/g")
+    expect(Addressable::URI.join(@uri.to_s, "../../../g").to_s).to eq("http://a/g")
+  end
+
+  it "when joined with '../.././../g' should resolve to http://a/g" do
+    expect((@uri + "../.././../g").to_s).to eq("http://a/g")
+    expect(Addressable::URI.join(@uri.to_s, "../.././../g").to_s).to eq(
+      "http://a/g"
+    )
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with '../../../../g' should resolve to http://a/g" do
+    expect((@uri + "../../../../g").to_s).to eq("http://a/g")
+    expect(Addressable::URI.join(
+      @uri.to_s, "../../../../g").to_s).to eq("http://a/g")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with '/./g' should resolve to http://a/g" do
+    expect((@uri + "/./g").to_s).to eq("http://a/g")
+    expect(Addressable::URI.join(@uri.to_s, "/./g").to_s).to eq("http://a/g")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with '/../g' should resolve to http://a/g" do
+    expect((@uri + "/../g").to_s).to eq("http://a/g")
+    expect(Addressable::URI.join(@uri.to_s, "/../g").to_s).to eq("http://a/g")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g.' should resolve to http://a/b/c/g." do
+    expect((@uri + "g.").to_s).to eq("http://a/b/c/g.")
+    expect(Addressable::URI.join(@uri.to_s, "g.").to_s).to eq("http://a/b/c/g.")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with '.g' should resolve to http://a/b/c/.g" do
+    expect((@uri + ".g").to_s).to eq("http://a/b/c/.g")
+    expect(Addressable::URI.join(@uri.to_s, ".g").to_s).to eq("http://a/b/c/.g")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g..' should resolve to http://a/b/c/g.." do
+    expect((@uri + "g..").to_s).to eq("http://a/b/c/g..")
+    expect(Addressable::URI.join(@uri.to_s, "g..").to_s).to eq("http://a/b/c/g..")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with '..g' should resolve to http://a/b/c/..g" do
+    expect((@uri + "..g").to_s).to eq("http://a/b/c/..g")
+    expect(Addressable::URI.join(@uri.to_s, "..g").to_s).to eq("http://a/b/c/..g")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with './../g' should resolve to http://a/b/g" do
+    expect((@uri + "./../g").to_s).to eq("http://a/b/g")
+    expect(Addressable::URI.join(@uri.to_s, "./../g").to_s).to eq("http://a/b/g")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with './g/.' should resolve to http://a/b/c/g/" do
+    expect((@uri + "./g/.").to_s).to eq("http://a/b/c/g/")
+    expect(Addressable::URI.join(@uri.to_s, "./g/.").to_s).to eq("http://a/b/c/g/")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g/./h' should resolve to http://a/b/c/g/h" do
+    expect((@uri + "g/./h").to_s).to eq("http://a/b/c/g/h")
+    expect(Addressable::URI.join(@uri.to_s, "g/./h").to_s).to eq("http://a/b/c/g/h")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g/../h' should resolve to http://a/b/c/h" do
+    expect((@uri + "g/../h").to_s).to eq("http://a/b/c/h")
+    expect(Addressable::URI.join(@uri.to_s, "g/../h").to_s).to eq("http://a/b/c/h")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g;x=1/./y' " +
+      "should resolve to http://a/b/c/g;x=1/y" do
+    expect((@uri + "g;x=1/./y").to_s).to eq("http://a/b/c/g;x=1/y")
+    expect(Addressable::URI.join(
+      @uri.to_s, "g;x=1/./y").to_s).to eq("http://a/b/c/g;x=1/y")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g;x=1/../y' should resolve to http://a/b/c/y" do
+    expect((@uri + "g;x=1/../y").to_s).to eq("http://a/b/c/y")
+    expect(Addressable::URI.join(
+      @uri.to_s, "g;x=1/../y").to_s).to eq("http://a/b/c/y")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g?y/./x' " +
+      "should resolve to http://a/b/c/g?y/./x" do
+    expect((@uri + "g?y/./x").to_s).to eq("http://a/b/c/g?y/./x")
+    expect(Addressable::URI.join(
+      @uri.to_s, "g?y/./x").to_s).to eq("http://a/b/c/g?y/./x")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g?y/../x' " +
+      "should resolve to http://a/b/c/g?y/../x" do
+    expect((@uri + "g?y/../x").to_s).to eq("http://a/b/c/g?y/../x")
+    expect(Addressable::URI.join(
+      @uri.to_s, "g?y/../x").to_s).to eq("http://a/b/c/g?y/../x")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g#s/./x' " +
+      "should resolve to http://a/b/c/g#s/./x" do
+    expect((@uri + "g#s/./x").to_s).to eq("http://a/b/c/g#s/./x")
+    expect(Addressable::URI.join(
+      @uri.to_s, "g#s/./x").to_s).to eq("http://a/b/c/g#s/./x")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'g#s/../x' " +
+      "should resolve to http://a/b/c/g#s/../x" do
+    expect((@uri + "g#s/../x").to_s).to eq("http://a/b/c/g#s/../x")
+    expect(Addressable::URI.join(
+      @uri.to_s, "g#s/../x").to_s).to eq("http://a/b/c/g#s/../x")
+  end
+
+  # Section 5.4.2 of RFC 3986
+  it "when joined with 'http:g' should resolve to http:g" do
+    expect((@uri + "http:g").to_s).to eq("http:g")
+    expect(Addressable::URI.join(@uri.to_s, "http:g").to_s).to eq("http:g")
+  end
+
+  # Edge case to be sure
+  it "when joined with '//example.com/' should " +
+      "resolve to http://example.com/" do
+    expect((@uri + "//example.com/").to_s).to eq("http://example.com/")
+    expect(Addressable::URI.join(
+      @uri.to_s, "//example.com/").to_s).to eq("http://example.com/")
+  end
+
+  it "when joined with a bogus object a TypeError should be raised" do
+    expect do
+      Addressable::URI.join(@uri, 42)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when converting the path " +
+    "'relative/path/to/something'" do
+  before do
+    @path = 'relative/path/to/something'
+  end
+
+  it "should convert to " +
+      "\'relative/path/to/something\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("relative/path/to/something")
+  end
+
+  it "should join with an absolute file path correctly" do
+    @base = Addressable::URI.convert_path("/absolute/path/")
+    @uri = Addressable::URI.convert_path(@path)
+    expect((@base + @uri).to_str).to eq(
+      "file:///absolute/path/relative/path/to/something"
+    )
+  end
+end
+
+describe Addressable::URI, "when converting a bogus path" do
+  it "should raise a TypeError" do
+    expect do
+      Addressable::URI.convert_path(42)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when given a UNIX root directory" do
+  before do
+    @path = "/"
+  end
+
+  it "should convert to \'file:///\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("file:///")
+  end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.origin).to eq('file://')
+  end
+end
+
+describe Addressable::URI, "when given a Windows root directory" do
+  before do
+    @path = "C:\\"
+  end
+
+  it "should convert to \'file:///c:/\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("file:///c:/")
+  end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.origin).to eq('file://')
+  end
+end
+
+describe Addressable::URI, "when given the path '/one/two/'" do
+  before do
+    @path = '/one/two/'
+  end
+
+  it "should convert to " +
+      "\'file:///one/two/\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("file:///one/two/")
+  end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.origin).to eq('file://')
+  end
+end
+
+describe Addressable::URI, "when given the tld " do
+  it "'uk' should have a tld of 'uk'" do
+    uri = Addressable::URI.parse("http://example.com")
+    uri.tld = "uk"
+
+    expect(uri.tld).to eq("uk")
+  end
+
+  context "which " do
+    let (:uri) { Addressable::URI.parse("http://www.comrade.net/path/to/source/") }
+
+    it "contains a subdomain" do
+      uri.tld = "co.uk"
+
+      expect(uri.to_s).to eq("http://www.comrade.co.uk/path/to/source/")
+    end
+
+    it "is part of the domain" do
+      uri.tld = "com"
+
+      expect(uri.to_s).to eq("http://www.comrade.com/path/to/source/")
+    end
+  end
+end
+
+describe Addressable::URI, "when given the path " +
+    "'c:\\windows\\My Documents 100%20\\foo.txt'" do
+  before do
+    @path = "c:\\windows\\My Documents 100%20\\foo.txt"
+  end
+
+  it "should convert to " +
+      "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("file:///c:/windows/My%20Documents%20100%20/foo.txt")
+  end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.origin).to eq('file://')
+  end
+end
+
+describe Addressable::URI, "when given the path " +
+    "'file://c:\\windows\\My Documents 100%20\\foo.txt'" do
+  before do
+    @path = "file://c:\\windows\\My Documents 100%20\\foo.txt"
+  end
+
+  it "should convert to " +
+      "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("file:///c:/windows/My%20Documents%20100%20/foo.txt")
+  end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.origin).to eq('file://')
+  end
+end
+
+describe Addressable::URI, "when given the path " +
+    "'file:c:\\windows\\My Documents 100%20\\foo.txt'" do
+  before do
+    @path = "file:c:\\windows\\My Documents 100%20\\foo.txt"
+  end
+
+  it "should convert to " +
+      "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("file:///c:/windows/My%20Documents%20100%20/foo.txt")
+  end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.origin).to eq('file://')
+  end
+end
+
+describe Addressable::URI, "when given the path " +
+    "'file:/c:\\windows\\My Documents 100%20\\foo.txt'" do
+  before do
+    @path = "file:/c:\\windows\\My Documents 100%20\\foo.txt"
+  end
+
+  it "should convert to " +
+      "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("file:///c:/windows/My%20Documents%20100%20/foo.txt")
+  end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.origin).to eq('file://')
+  end
+end
+
+describe Addressable::URI, "when given the path " +
+    "'file:///c|/windows/My%20Documents%20100%20/foo.txt'" do
+  before do
+    @path = "file:///c|/windows/My%20Documents%20100%20/foo.txt"
+  end
+
+  it "should convert to " +
+      "\'file:///c:/windows/My%20Documents%20100%20/foo.txt\'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("file:///c:/windows/My%20Documents%20100%20/foo.txt")
+  end
+
+  it "should have an origin of 'file://'" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.origin).to eq('file://')
+  end
+end
+
+describe Addressable::URI, "when given an http protocol URI" do
+  before do
+    @path = "http://example.com/"
+  end
+
+  it "should not do any conversion at all" do
+    @uri = Addressable::URI.convert_path(@path)
+    expect(@uri.to_str).to eq("http://example.com/")
+  end
+end
+
+class SuperString
+  def initialize(string)
+    @string = string.to_s
+  end
+
+  def to_str
+    return @string
+  end
+end
+
+describe Addressable::URI, "when parsing a non-String object" do
+  it "should correctly parse anything with a 'to_str' method" do
+    Addressable::URI.parse(SuperString.new(42))
+  end
+
+  it "should raise a TypeError for objects than cannot be converted" do
+    expect do
+      Addressable::URI.parse(42)
+    end.to raise_error(TypeError)
+  end
+
+  it "should correctly parse heuristically anything with a 'to_str' method" do
+    Addressable::URI.heuristic_parse(SuperString.new(42))
+  end
+
+  it "should raise a TypeError for objects than cannot be converted" do
+    expect do
+      Addressable::URI.heuristic_parse(42)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when form encoding a hash" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.form_encode(
+      [["&one", "/1"], ["=two", "?2"], [":three", "#3"]]
+    )).to eq("%26one=%2F1&%3Dtwo=%3F2&%3Athree=%233")
+  end
+
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.form_encode(
+      {"q" => "one two three"}
+    )).to eq("q=one+two+three")
+  end
+
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.form_encode(
+      {"key" => nil}
+    )).to eq("key=")
+  end
+
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.form_encode(
+      {"q" => ["one", "two", "three"]}
+    )).to eq("q=one&q=two&q=three")
+  end
+
+  it "should result in correctly encoded newlines" do
+    expect(Addressable::URI.form_encode(
+      {"text" => "one\ntwo\rthree\r\nfour\n\r"}
+    )).to eq("text=one%0D%0Atwo%0D%0Athree%0D%0Afour%0D%0A%0D%0A")
+  end
+
+  it "should result in a sorted percent encoded sequence" do
+    expect(Addressable::URI.form_encode(
+      [["a", "1"], ["dup", "3"], ["dup", "2"]], true
+    )).to eq("a=1&dup=2&dup=3")
+  end
+end
+
+describe Addressable::URI, "when form encoding a non-Array object" do
+  it "should raise a TypeError for objects than cannot be converted" do
+    expect do
+      Addressable::URI.form_encode(42)
+    end.to raise_error(TypeError)
+  end
+end
+
+# See https://tools.ietf.org/html/rfc6749#appendix-B
+describe Addressable::URI, "when form encoding the example value from OAuth 2" do
+  it "should result in correct values" do
+    expect(Addressable::URI.form_encode(
+      {"value" => " %&+£€"}
+    )).to eq("value=+%25%26%2B%C2%A3%E2%82%AC")
+  end
+end
+
+# See https://tools.ietf.org/html/rfc6749#appendix-B
+describe Addressable::URI, "when form unencoding the example value from OAuth 2" do
+  it "should result in correct values" do
+    expect(Addressable::URI.form_unencode(
+      "value=+%25%26%2B%C2%A3%E2%82%AC"
+    )).to eq([["value", " %&+£€"]])
+  end
+end
+
+describe Addressable::URI, "when form unencoding a string" do
+  it "should result in correct values" do
+    expect(Addressable::URI.form_unencode(
+      "%26one=%2F1&%3Dtwo=%3F2&%3Athree=%233"
+    )).to eq([["&one", "/1"], ["=two", "?2"], [":three", "#3"]])
+  end
+
+  it "should result in correct values" do
+    expect(Addressable::URI.form_unencode(
+      "q=one+two+three"
+    )).to eq([["q", "one two three"]])
+  end
+
+  it "should result in correct values" do
+    expect(Addressable::URI.form_unencode(
+      "text=one%0D%0Atwo%0D%0Athree%0D%0Afour%0D%0A%0D%0A"
+    )).to eq([["text", "one\ntwo\nthree\nfour\n\n"]])
+  end
+
+  it "should result in correct values" do
+    expect(Addressable::URI.form_unencode(
+      "a=1&dup=2&dup=3"
+    )).to eq([["a", "1"], ["dup", "2"], ["dup", "3"]])
+  end
+
+  it "should result in correct values" do
+    expect(Addressable::URI.form_unencode(
+      "key"
+    )).to eq([["key", nil]])
+  end
+
+  it "should result in correct values" do
+    expect(Addressable::URI.form_unencode("GivenName=Ren%C3%A9")).to eq(
+      [["GivenName", "René"]]
+    )
+  end
+end
+
+describe Addressable::URI, "when form unencoding a non-String object" do
+  it "should correctly parse anything with a 'to_str' method" do
+    Addressable::URI.form_unencode(SuperString.new(42))
+  end
+
+  it "should raise a TypeError for objects than cannot be converted" do
+    expect do
+      Addressable::URI.form_unencode(42)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when normalizing a non-String object" do
+  it "should correctly parse anything with a 'to_str' method" do
+    Addressable::URI.normalize_component(SuperString.new(42))
+  end
+
+  it "should raise a TypeError for objects than cannot be converted" do
+    expect do
+      Addressable::URI.normalize_component(42)
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise a TypeError for objects than cannot be converted" do
+    expect do
+      Addressable::URI.normalize_component("component", 42)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when normalizing a path with an encoded slash" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.parse("/path%2Fsegment/").normalize.path).to eq(
+      "/path%2Fsegment/"
+    )
+  end
+end
+
+describe Addressable::URI, "when normalizing a path with special unicode" do
+  it "does not stop at or ignore null bytes" do
+    expect(Addressable::URI.parse("/path%00segment/").normalize.path).to eq(
+      "/path%00segment/"
+    )
+  end
+
+  it "does apply NFC unicode normalization" do
+    expect(Addressable::URI.parse("/%E2%84%A6").normalize.path).to eq(
+      "/%CE%A9"
+    )
+  end
+
+  it "does not apply NFKC unicode normalization" do
+    expect(Addressable::URI.parse("/%C2%AF%C2%A0").normalize.path).to eq(
+      "/%C2%AF%C2%A0"
+    )
+  end
+end
+
+describe Addressable::URI, "when normalizing a partially encoded string" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.normalize_component(
+      "partially % encoded%21"
+    )).to eq("partially%20%25%20encoded!")
+  end
+
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.normalize_component(
+      "partially %25 encoded!"
+    )).to eq("partially%20%25%20encoded!")
+  end
+end
+
+describe Addressable::URI, "when normalizing a unicode sequence" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.normalize_component(
+      "/C%CC%A7"
+    )).to eq("/%C3%87")
+  end
+
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.normalize_component(
+      "/%C3%87"
+    )).to eq("/%C3%87")
+  end
+end
+
+describe Addressable::URI, "when normalizing a multibyte string" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.normalize_component("günther")).to eq(
+      "g%C3%BCnther"
+    )
+  end
+
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.normalize_component("g%C3%BCnther")).to eq(
+      "g%C3%BCnther"
+    )
+  end
+end
+
+describe Addressable::URI, "when normalizing a string but leaving some characters encoded" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.normalize_component("%58X%59Y%5AZ", "0-9a-zXY", "Y")).to eq(
+      "XX%59Y%5A%5A"
+    )
+  end
+
+  it "should not modify the character class" do
+    character_class = "0-9a-zXY"
+
+    character_class_copy = character_class.dup
+
+    Addressable::URI.normalize_component("%58X%59Y%5AZ", character_class, "Y")
+
+    expect(character_class).to eq(character_class_copy)
+  end
+end
+
+describe Addressable::URI, "when encoding IP literals" do
+  it "should work for IPv4" do
+    input = "http://127.0.0.1/"
+    expect(Addressable::URI.encode(input)).to eq(input)
+  end
+
+  it "should work for IPv6" do
+    input = "http://[fe80::200:f8ff:fe21:67cf]/"
+    expect(Addressable::URI.encode(input)).to eq(input)
+  end
+end
+
+describe Addressable::URI, "when encoding a string with existing encodings to upcase" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.encode_component("JK%4c", "0-9A-IKM-Za-z%", "L")).to eq("%4AK%4C")
+  end
+end
+
+describe Addressable::URI, "when encoding a multibyte string" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.encode_component("günther")).to eq("g%C3%BCnther")
+  end
+
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.encode_component(
+      "günther", /[^a-zA-Z0-9\:\/\?\#\[\]\@\!\$\&\'\(\)\*\+\,\;\=\-\.\_\~]/
+    )).to eq("g%C3%BCnther")
+  end
+end
+
+describe Addressable::URI, "when form encoding a multibyte string" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.form_encode({"GivenName" => "René"})).to eq(
+      "GivenName=Ren%C3%A9"
+    )
+  end
+end
+
+describe Addressable::URI, "when encoding a string with ASCII chars 0-15" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.encode_component("one\ntwo")).to eq("one%0Atwo")
+  end
+
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.encode_component(
+      "one\ntwo", /[^a-zA-Z0-9\:\/\?\#\[\]\@\!\$\&\'\(\)\*\+\,\;\=\-\.\_\~]/
+    )).to eq("one%0Atwo")
+  end
+end
+
+describe Addressable::URI, "when unencoding a multibyte string" do
+  it "should result in correct percent encoded sequence" do
+    expect(Addressable::URI.unencode_component("g%C3%BCnther")).to eq("günther")
+  end
+
+  it "should consistently use UTF-8 internally" do
+    expect(Addressable::URI.unencode_component("ski=%BA%DAɫ")).to eq("ski=\xBA\xDAɫ")
+  end
+
+  it "should not fail with UTF-8 incompatible string" do
+    url = "/M%E9/\xE9?p=\xFC".b
+    expect(Addressable::URI.unencode_component(url)).to eq("/M\xE9/\xE9?p=\xFC")
+  end
+
+  it "should result in correct percent encoded sequence as a URI" do
+    expect(Addressable::URI.unencode(
+      "/path?g%C3%BCnther", ::Addressable::URI
+    )).to eq(Addressable::URI.new(
+      :path => "/path", :query => "günther"
+    ))
+  end
+end
+
+describe Addressable::URI, "when partially unencoding a string" do
+  it "should unencode all characters by default" do
+    expect(Addressable::URI.unencode('%%25~%7e+%2b', String)).to eq('%%~~++')
+  end
+
+  it "should unencode characters not in leave_encoded" do
+    expect(Addressable::URI.unencode('%%25~%7e+%2b', String, '~')).to eq('%%~%7e++')
+  end
+
+  it "should leave characters in leave_encoded alone" do
+    expect(Addressable::URI.unencode('%%25~%7e+%2b', String, '%~+')).to eq('%%25~%7e+%2b')
+  end
+end
+
+describe Addressable::URI, "when unencoding a bogus object" do
+  it "should raise a TypeError" do
+    expect do
+      Addressable::URI.unencode_component(42)
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise a TypeError" do
+    expect do
+      Addressable::URI.unencode("/path?g%C3%BCnther", Integer)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when encoding a bogus object" do
+  it "should raise a TypeError" do
+    expect do
+      Addressable::URI.encode(Object.new)
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise a TypeError" do
+    expect do
+      Addressable::URI.normalized_encode(Object.new)
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise a TypeError" do
+    expect do
+      Addressable::URI.encode_component("günther", Object.new)
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise a TypeError" do
+    expect do
+      Addressable::URI.encode_component(Object.new)
+    end.to raise_error(TypeError)
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://example.com/'" do
+  before do
+    @input = "http://example.com/"
+  end
+
+  it "should heuristically parse to 'http://example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("http://example.com/")
+  end
+
+  it "should not raise error when frozen" do
+    expect do
+      Addressable::URI.heuristic_parse(@input).freeze.to_s
+    end.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'https://example.com/'" do
+  before do
+    @input = "https://example.com/"
+  end
+
+  it "should heuristically parse to 'https://example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("https://example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http:example.com/'" do
+  before do
+    @input = "http:example.com/"
+  end
+
+  it "should heuristically parse to 'http://example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("http://example.com/")
+  end
+
+  it "should heuristically parse to 'http://example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'https:example.com/'" do
+  before do
+    @input = "https:example.com/"
+  end
+
+  it "should heuristically parse to 'https://example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("https://example.com/")
+  end
+
+  it "should heuristically parse to 'https://example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("https://example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://example.com/example.com/'" do
+  before do
+    @input = "http://example.com/example.com/"
+  end
+
+  it "should heuristically parse to 'http://example.com/example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("http://example.com/example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://prefix\\.example.com/'" do
+  before do
+    @input = "http://prefix\\.example.com/"
+  end
+
+  it "should heuristically parse to 'http://prefix/.example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("prefix")
+    expect(@uri.to_s).to eq("http://prefix/.example.com/")
+  end
+
+  it "should heuristically parse to 'http://prefix/.example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://prefix/.example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://p:\\/'" do
+  before do
+    @input = "http://p:\\/"
+  end
+
+  it "should heuristically parse to 'http://p//'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("p")
+    expect(@uri.to_s).to eq("http://p//")
+  end
+
+  it "should heuristically parse to 'http://p//' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://p//")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://p://'" do
+  before do
+    @input = "http://p://"
+  end
+
+  it "should heuristically parse to 'http://p//'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("p")
+    expect(@uri.to_s).to eq("http://p//")
+  end
+
+  it "should heuristically parse to 'http://p//' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://p//")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://p://p'" do
+  before do
+    @input = "http://p://p"
+  end
+
+  it "should heuristically parse to 'http://p//p'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("p")
+    expect(@uri.to_s).to eq("http://p//p")
+  end
+
+  it "should heuristically parse to 'http://p//p' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://p//p")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://prefix .example.com/'" do
+  before do
+    @input = "http://prefix .example.com/"
+  end
+
+  # Justification here being that no browser actually tries to resolve this.
+  # They all treat this as a web search.
+  it "should heuristically parse to 'http://prefix%20.example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("prefix%20.example.com")
+    expect(@uri.to_s).to eq("http://prefix%20.example.com/")
+  end
+
+  it "should heuristically parse to 'http://prefix%20.example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://prefix%20.example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'  http://www.example.com/  '" do
+  before do
+    @input = "  http://www.example.com/  "
+  end
+
+  it "should heuristically parse to 'http://prefix%20.example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.scheme).to eq("http")
+    expect(@uri.path).to eq("/")
+    expect(@uri.to_s).to eq("http://www.example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://prefix%2F.example.com/'" do
+  before do
+    @input = "http://prefix%2F.example.com/"
+  end
+
+  it "should heuristically parse to 'http://prefix%2F.example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("prefix%2F.example.com")
+    expect(@uri.to_s).to eq("http://prefix%2F.example.com/")
+  end
+
+  it "should heuristically parse to 'http://prefix%2F.example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://prefix%2F.example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'/path/to/resource'" do
+  before do
+    @input = "/path/to/resource"
+  end
+
+  it "should heuristically parse to '/path/to/resource'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("/path/to/resource")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'relative/path/to/resource'" do
+  before do
+    @input = "relative/path/to/resource"
+  end
+
+  it "should heuristically parse to 'relative/path/to/resource'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("relative/path/to/resource")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'example.com'" do
+  before do
+    @input = "example.com"
+  end
+
+  it "should heuristically parse to 'http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("http://example.com")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'example.com' and a scheme hint of 'ftp'" do
+  before do
+    @input = "example.com"
+    @hints = {:scheme => 'ftp'}
+  end
+
+  it "should heuristically parse to 'http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input, @hints)
+    expect(@uri.to_s).to eq("ftp://example.com")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'example.com:21' and a scheme hint of 'ftp'" do
+  before do
+    @input = "example.com:21"
+    @hints = {:scheme => 'ftp'}
+  end
+
+  it "should heuristically parse to 'http://example.com:21'" do
+    @uri = Addressable::URI.heuristic_parse(@input, @hints)
+    expect(@uri.to_s).to eq("ftp://example.com:21")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'example.com/path/to/resource'" do
+  before do
+    @input = "example.com/path/to/resource"
+  end
+
+  it "should heuristically parse to 'http://example.com/path/to/resource'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("http://example.com/path/to/resource")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http:///example.com'" do
+  before do
+    @input = "http:///example.com"
+  end
+
+  it "should heuristically parse to 'http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("http://example.com")
+  end
+end
+
+describe Addressable::URI, "when given the input which "\
+  "start with digits and has specified port" do
+  before do
+    @input = "7777.example.org:8089"
+  end
+
+  it "should heuristically parse to 'http://7777.example.org:8089'" do
+    uri = Addressable::URI.heuristic_parse(@input)
+    expect(uri.to_s).to eq("http://7777.example.org:8089")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'feed:///example.com'" do
+  before do
+    @input = "feed:///example.com"
+  end
+
+  it "should heuristically parse to 'feed://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("feed://example.com")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'file://localhost/path/to/resource/'" do
+  before do
+    @input = "file://localhost/path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:///path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("file:///path/to/resource/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'file://path/to/resource/'" do
+  before do
+    @input = "file://path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:///path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("file:///path/to/resource/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'file://///path/to/resource/'" do
+  before do
+    @input = "file:///////path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:////path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("file:////path/to/resource/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'feed://http://example.com'" do
+  before do
+    @input = "feed://http://example.com"
+  end
+
+  it "should heuristically parse to 'feed:http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("feed:http://example.com")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "::URI.parse('http://example.com')" do
+  before do
+    @input = ::URI.parse('http://example.com')
+  end
+
+  it "should heuristically parse to 'http://example.com'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("http://example.com")
+  end
+end
+
+describe Addressable::URI, "when given the input: 'user@domain.com'" do
+  before do
+    @input = "user@domain.com"
+  end
+
+  context "for heuristic parse" do
+    it "should remain 'mailto:user@domain.com'" do
+      uri = Addressable::URI.heuristic_parse("mailto:#{@input}")
+      expect(uri.to_s).to eq("mailto:user@domain.com")
+    end
+
+    it "should have a scheme of 'mailto'" do
+      uri = Addressable::URI.heuristic_parse(@input)
+      expect(uri.to_s).to   eq("mailto:user@domain.com")
+      expect(uri.scheme).to eq("mailto")
+    end
+
+    it "should remain 'acct:user@domain.com'" do
+      uri = Addressable::URI.heuristic_parse("acct:#{@input}")
+      expect(uri.to_s).to eq("acct:user@domain.com")
+    end
+
+    context "HTTP" do
+      before do
+        @uri = Addressable::URI.heuristic_parse("http://#{@input}/")
+      end
+
+      it "should remain 'http://user@domain.com/'" do
+        expect(@uri.to_s).to eq("http://user@domain.com/")
+      end
+
+      it "should have the username 'user' for HTTP basic authentication" do
+        expect(@uri.user).to eq("user")
+      end
+    end
+  end
+end
+
+describe Addressable::URI, "when assigning query values" do
+  before do
+    @uri = Addressable::URI.new
+  end
+
+  it "should correctly assign {:a => 'a', :b => ['c', 'd', 'e']}" do
+    @uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
+    expect(@uri.query).to eq("a=a&b=c&b=d&b=e")
+  end
+
+  it "should raise an error attempting to assign {'a' => {'b' => ['c']}}" do
+    expect do
+      @uri.query_values = { 'a' => {'b' => ['c'] } }
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise an error attempting to assign " +
+      "{:b => '2', :a => {:c => '1'}}" do
+    expect do
+      @uri.query_values = {:b => '2', :a => {:c => '1'}}
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise an error attempting to assign " +
+      "{:a => 'a', :b => [{:c => 'c', :d => 'd'}, " +
+      "{:e => 'e', :f => 'f'}]}" do
+    expect do
+      @uri.query_values = {
+        :a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]
+      }
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise an error attempting to assign " +
+      "{:a => 'a', :b => [{:c => true, :d => 'd'}, " +
+      "{:e => 'e', :f => 'f'}]}" do
+    expect do
+      @uri.query_values = {
+        :a => 'a', :b => [{:c => true, :d => 'd'}, {:e => 'e', :f => 'f'}]
+      }
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise an error attempting to assign " +
+      "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
+    expect do
+      @uri.query_values = {
+        :a => 'a', :b => {:c => true, :d => 'd'}
+      }
+    end.to raise_error(TypeError)
+  end
+
+  it "should raise an error attempting to assign " +
+      "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
+    expect do
+      @uri.query_values = {
+        :a => 'a', :b => {:c => true, :d => 'd'}
+      }
+    end.to raise_error(TypeError)
+  end
+
+  it "should correctly assign {:a => 1, :b => 1.5}" do
+    @uri.query_values = { :a => 1, :b => 1.5 }
+    expect(@uri.query).to eq("a=1&b=1.5")
+  end
+
+  it "should raise an error attempting to assign " +
+      "{:z => 1, :f => [2, {999.1 => [3,'4']}, ['h', 'i']], " +
+      ":a => {:b => ['c', 'd'], :e => true, :y => 0.5}}" do
+    expect do
+      @uri.query_values = {
+        :z => 1,
+        :f => [ 2, {999.1 => [3,'4']}, ['h', 'i'] ],
+        :a => { :b => ['c', 'd'], :e => true, :y => 0.5 }
+      }
+    end.to raise_error(TypeError)
+  end
+
+  it "should correctly assign {}" do
+    @uri.query_values = {}
+    expect(@uri.query).to eq('')
+  end
+
+  it "should correctly assign nil" do
+    @uri.query_values = nil
+    expect(@uri.query).to eq(nil)
+  end
+
+  it "should correctly sort {'ab' => 'c', :ab => 'a', :a => 'x'}" do
+    @uri.query_values = {'ab' => 'c', :ab => 'a', :a => 'x'}
+    expect(@uri.query).to eq("a=x&ab=a&ab=c")
+  end
+
+  it "should correctly assign " +
+      "[['b', 'c'], ['b', 'a'], ['a', 'a']]" do
+    # Order can be guaranteed in this format, so preserve it.
+    @uri.query_values = [['b', 'c'], ['b', 'a'], ['a', 'a']]
+    expect(@uri.query).to eq("b=c&b=a&a=a")
+  end
+
+  it "should preserve query string order" do
+    query_string = (('a'..'z').to_a.reverse.map { |e| "#{e}=#{e}" }).join("&")
+    @uri.query = query_string
+    original_uri = @uri.to_s
+    @uri.query_values = @uri.query_values(Array)
+    expect(@uri.to_s).to eq(original_uri)
+  end
+
+  describe 'when a hash with mixed types is assigned to query_values' do
+    it 'should not raise an error' do
+      skip 'Issue #94'
+      expect { subject.query_values = { "page" => "1", :page => 2 } }.to_not raise_error
+    end
+  end
+end
+
+describe Addressable::URI, "when assigning path values" do
+  before do
+    @uri = Addressable::URI.new
+  end
+
+  it "should correctly assign paths containing colons" do
+    @uri.path = "acct:bob@sporkmonger.com"
+    expect(@uri.path).to eq("acct:bob@sporkmonger.com")
+    expect(@uri.normalize.to_str).to eq("acct%2Fbob@sporkmonger.com")
+    expect { @uri.to_s }.to raise_error(
+      Addressable::URI::InvalidURIError
+    )
+  end
+
+  it "should correctly assign paths containing colons" do
+    @uri.path = "/acct:bob@sporkmonger.com"
+    @uri.authority = "example.com"
+    expect(@uri.normalize.to_str).to eq("//example.com/acct:bob@sporkmonger.com")
+  end
+
+  it "should correctly assign paths containing colons" do
+    @uri.path = "acct:bob@sporkmonger.com"
+    @uri.scheme = "something"
+    expect(@uri.normalize.to_str).to eq("something:acct:bob@sporkmonger.com")
+  end
+
+  it "should not allow relative paths to be assigned on absolute URIs" do
+    expect do
+      @uri.scheme = "http"
+      @uri.host = "example.com"
+      @uri.path = "acct:bob@sporkmonger.com"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow relative paths to be assigned on absolute URIs" do
+    expect do
+      @uri.path = "acct:bob@sporkmonger.com"
+      @uri.scheme = "http"
+      @uri.host = "example.com"
+    end.to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow relative paths to be assigned on absolute URIs" do
+    expect do
+      @uri.path = "uuid:0b3ecf60-3f93-11df-a9c3-001f5bfffe12"
+      @uri.scheme = "urn"
+    end.not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when initializing a subclass of Addressable::URI" do
+  before do
+    @uri = Class.new(Addressable::URI).new
+  end
+
+  it "should have the same class after being parsed" do
+    expect(@uri.class).to eq(Addressable::URI.parse(@uri).class)
+  end
+
+  it "should have the same class as its duplicate" do
+    expect(@uri.class).to eq(@uri.dup.class)
+  end
+
+  it "should have the same class after being normalized" do
+    expect(@uri.class).to eq(@uri.normalize.class)
+  end
+
+  it "should have the same class after being merged" do
+    expect(@uri.class).to eq(@uri.merge(:path => 'path').class)
+  end
+
+  it "should have the same class after being joined" do
+    expect(@uri.class).to eq(@uri.join('path').class)
+  end
+end
+
+describe Addressable::URI, "support serialization roundtrip" do
+  before do
+    @uri = Addressable::URI.new(
+      :scheme => "http",
+      :user => "user",
+      :password => "password",
+      :host => "example.com",
+      :port => 80,
+      :path => "/path",
+      :query => "query=value",
+      :fragment => "fragment"
+    )
+  end
+
+  it "is in a working state after being serialized with Marshal" do
+    @uri = Addressable::URI.parse("http://example.com")
+    cloned_uri = Marshal.load(Marshal.dump(@uri))
+    expect(cloned_uri.normalized_scheme).to be == @uri.normalized_scheme
+  end
+
+  it "is in a working state after being serialized with YAML" do
+    @uri = Addressable::URI.parse("http://example.com")
+    cloned_uri = if YAML.respond_to?(:unsafe_load)
+      YAML.unsafe_load(YAML.dump(@uri))
+    else
+      YAML.load(YAML.dump(@uri))
+    end
+    expect(cloned_uri.normalized_scheme).to be == @uri.normalized_scheme
+  end
+end
+
+describe Addressable::URI, "when initialized in a non-main `Ractor`" do
+  it "should have the same value as if used in the main `Ractor`" do
+    pending("Ruby 3.0+ for `Ractor` support") unless defined?(Ractor)
+    main = Addressable::URI.parse("http://example.com")
+    expect(
+      Ractor.new { Addressable::URI.parse("http://example.com") }.take
+    ).to eq(main)
+  end
+end
+
+describe Addressable::URI, "when deferring validation" do
+  subject(:deferred) { uri.instance_variable_get(:@validation_deferred) }
+
+  let(:uri) { Addressable::URI.parse("http://example.com") }
+
+  it "defers validation within the block" do
+    uri.defer_validation do
+      expect(deferred).to be true
+    end
+  end
+
+  it "always resets deferral afterward" do
+    expect { uri.defer_validation { raise "boom" } }.to raise_error("boom")
+    expect(deferred).to be false
+  end
+
+  it "returns nil" do
+    res = uri.defer_validation {}
+    expect(res).to be nil
+  end
+end
+
+describe Addressable::URI, "YAML safe loading" do
+  it "doesn't serialize anonymous objects" do
+    url = Addressable::URI.parse("http://example.com/")
+    expect(YAML.dump(url)).to_not include("!ruby/object {}")
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/spec_helper.rb b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/spec_helper.rb
new file mode 100644
index 0000000..bd8e395
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/spec/spec_helper.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'rspec/its'
+
+begin
+  require 'coveralls'
+  Coveralls.wear! do
+    add_filter "spec/"
+    add_filter "vendor/"
+  end
+rescue LoadError
+  warn "warning: coveralls gem not found; skipping Coveralls"
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "spec/"
+    add_filter "vendor/"
+  end
+end if Gem.loaded_specs.key?("simplecov")
+
+class TestHelper
+  def self.native_supported?
+    mri = RUBY_ENGINE == "ruby"
+    windows = RUBY_PLATFORM.include?("mingw")
+
+    mri && !windows
+  end
+end
+
+RSpec.configure do |config|
+  config.warnings = true
+  config.filter_run_when_matching :focus
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/clobber.rake b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/clobber.rake
new file mode 100644
index 0000000..a9e32b3
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/clobber.rake
@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+desc "Remove all build products"
+task "clobber"
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/gem.rake b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/gem.rake
new file mode 100644
index 0000000..70b1f97
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/gem.rake
@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "rubygems/package_task"
+
+namespace :gem do
+  GEM_SPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.summary = PKG_SUMMARY
+    s.description = PKG_DESCRIPTION
+
+    s.files = PKG_FILES.to_a
+
+    s.extra_rdoc_files = %w( README.md )
+    s.rdoc_options.concat ["--main",  "README.md"]
+
+    if !s.respond_to?(:add_development_dependency)
+      puts "Cannot build Gem with this version of RubyGems."
+      exit(1)
+    end
+
+    s.required_ruby_version = ">= 2.2"
+
+    s.add_runtime_dependency "public_suffix", ">= 2.0.2", "< 7.0"
+    s.add_development_dependency "bundler", ">= 1.0", "< 3.0"
+
+    s.require_path = "lib"
+
+    s.author = "Bob Aman"
+    s.email = "bob@sporkmonger.com"
+    s.homepage = "https://github.com/sporkmonger/addressable"
+    s.license = "Apache-2.0"
+    s.metadata = {
+      "changelog_uri" => "https://github.com/sporkmonger/addressable/blob/main/CHANGELOG.md#v#{PKG_VERSION}"
+    }
+  end
+
+  Gem::PackageTask.new(GEM_SPEC) do |p|
+    p.gem_spec = GEM_SPEC
+    p.need_tar = true
+    p.need_zip = true
+  end
+
+  desc "Generates .gemspec file"
+  task :gemspec do
+    spec_string = GEM_SPEC.to_ruby
+    File.open("#{GEM_SPEC.name}.gemspec", "w") do |file|
+      file.write spec_string
+    end
+  end
+
+  desc "Show information about the gem"
+  task :debug do
+    puts GEM_SPEC.to_ruby
+  end
+
+  desc "Install the gem"
+  task :install => ["clobber", "gem:package"] do
+    sh "gem install --local ./pkg/#{GEM_SPEC.full_name}.gem"
+  end
+
+  desc "Uninstall the gem"
+  task :uninstall do
+    installed_list = Gem.source_index.find_name(PKG_NAME)
+    if installed_list &&
+        (installed_list.collect { |s| s.version.to_s}.include?(PKG_VERSION))
+      sh(
+        "gem uninstall --version '#{PKG_VERSION}' " +
+        "--ignore-dependencies --executables #{PKG_NAME}"
+      )
+    end
+  end
+
+  desc "Reinstall the gem"
+  task :reinstall => [:uninstall, :install]
+
+  desc "Package for release"
+  task :release => ["gem:package", "gem:gemspec"] do |t|
+    v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+    abort "Versions don't match #{v} vs #{PROJ.version}" if v != PKG_VERSION
+    pkg = "pkg/#{GEM_SPEC.full_name}"
+
+    changelog = File.open("CHANGELOG.md") { |file| file.read }
+
+    puts "Releasing #{PKG_NAME} v. #{PKG_VERSION}"
+    Rake::Task["git:tag:create"].invoke
+  end
+end
+
+desc "Alias to gem:package"
+task "gem" => "gem:package"
+
+task "gem:release" => "gem:gemspec"
+
+task "clobber" => ["gem:clobber_package"]
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/git.rake b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/git.rake
new file mode 100644
index 0000000..1238c8d
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/git.rake
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+namespace :git do
+  namespace :tag do
+    desc "List tags from the Git repository"
+    task :list do
+      tags = `git tag -l`
+      tags.gsub!("\r", "")
+      tags = tags.split("\n").sort {|a, b| b <=> a }
+      puts tags.join("\n")
+    end
+
+    desc "Create a new tag in the Git repository"
+    task :create do
+      changelog = File.open("CHANGELOG.md", "r") { |file| file.read }
+      puts "-" * 80
+      puts changelog
+      puts "-" * 80
+      puts
+
+      v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+      abort "Versions don't match #{v} vs #{PKG_VERSION}" if v != PKG_VERSION
+
+      git_status = `git status`
+      if git_status !~ /^nothing to commit/
+        abort "Working directory isn't clean."
+      end
+
+      tag = "#{PKG_NAME}-#{PKG_VERSION}"
+      msg = "Release #{PKG_NAME}-#{PKG_VERSION}"
+
+      existing_tags = `git tag -l #{PKG_NAME}-*`.split('\n')
+      if existing_tags.include?(tag)
+        warn("Tag already exists, deleting...")
+        unless system "git tag -d #{tag}"
+          abort "Tag deletion failed."
+        end
+      end
+      puts "Creating git tag '#{tag}'..."
+      unless system "git tag -a -m \"#{msg}\" #{tag}"
+        abort "Tag creation failed."
+      end
+    end
+  end
+end
+
+task "gem:release" => "git:tag:create"
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/metrics.rake b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/metrics.rake
new file mode 100644
index 0000000..107cc24
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/metrics.rake
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+namespace :metrics do
+  task :lines do
+    lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+    for file_name in FileList["lib/**/*.rb"]
+      f = File.open(file_name)
+      while line = f.gets
+        lines += 1
+        next if line =~ /^\s*$/
+        next if line =~ /^\s*#/
+        codelines += 1
+      end
+      puts "L: #{sprintf("%4d", lines)}, " +
+        "LOC #{sprintf("%4d", codelines)} | #{file_name}"
+      total_lines     += lines
+      total_codelines += codelines
+
+      lines, codelines = 0, 0
+    end
+
+    puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/profile.rake b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/profile.rake
new file mode 100644
index 0000000..b697d48
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/profile.rake
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+namespace :profile do
+  desc "Profile Template match memory allocations"
+  task :template_match_memory do
+    require "memory_profiler"
+    require "addressable/template"
+
+    start_at = Time.now.to_f
+    template = Addressable::Template.new("http://example.com/{?one,two,three}")
+    report = MemoryProfiler.report do
+      30_000.times do
+        template.match(
+          "http://example.com/?one=one&two=floo&three=me"
+        )
+      end
+    end
+    end_at = Time.now.to_f
+    print_options = { scale_bytes: true, normalize_paths: true }
+    puts "\n\n"
+
+    if ENV["CI"]
+      report.pretty_print(print_options)
+    else
+      t_allocated = report.scale_bytes(report.total_allocated_memsize)
+      t_retained  = report.scale_bytes(report.total_retained_memsize)
+
+      puts "Total allocated: #{t_allocated} (#{report.total_allocated} objects)"
+      puts "Total retained:  #{t_retained} (#{report.total_retained} objects)"
+      puts "Took #{end_at - start_at} seconds"
+
+      FileUtils.mkdir_p("tmp")
+      report.pretty_print(to_file: "tmp/memprof.txt", **print_options)
+    end
+  end
+
+  desc "Profile URI parse memory allocations"
+  task :memory do
+    require "memory_profiler"
+    require "addressable/uri"
+    if ENV["IDNA_MODE"] == "pure"
+      Addressable.send(:remove_const, :IDNA)
+      load "addressable/idna/pure.rb"
+    end
+
+    start_at = Time.now.to_f
+    report = MemoryProfiler.report do
+      30_000.times do
+        Addressable::URI.parse(
+          "http://google.com/stuff/../?with_lots=of&params=asdff#!stuff"
+        ).normalize
+      end
+    end
+    end_at = Time.now.to_f
+    print_options = { scale_bytes: true, normalize_paths: true }
+    puts "\n\n"
+
+    if ENV["CI"]
+      report.pretty_print(**print_options)
+    else
+      t_allocated = report.scale_bytes(report.total_allocated_memsize)
+      t_retained  = report.scale_bytes(report.total_retained_memsize)
+
+      puts "Total allocated: #{t_allocated} (#{report.total_allocated} objects)"
+      puts "Total retained:  #{t_retained} (#{report.total_retained} objects)"
+      puts "Took #{end_at - start_at} seconds"
+
+      FileUtils.mkdir_p("tmp")
+      report.pretty_print(to_file: "tmp/memprof.txt", **print_options)
+    end
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/rspec.rake b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/rspec.rake
new file mode 100644
index 0000000..e3d9f01
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/rspec.rake
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:simplecov) do |t|
+    t.pattern = FileList['spec/**/*_spec.rb']
+    t.rspec_opts = %w[--color --format documentation] unless ENV["CI"]
+  end
+
+  namespace :simplecov do
+    desc "Browse the code coverage report."
+    task :browse => "spec:simplecov" do
+      require "launchy"
+      Launchy.open("coverage/index.html")
+    end
+  end
+end
+
+desc "Alias to spec:simplecov"
+task "spec" => "spec:simplecov"
+
+task "clobber" => ["spec:clobber_simplecov"]
diff --git a/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/yard.rake b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/yard.rake
new file mode 100644
index 0000000..515f960
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/addressable-2.8.7/tasks/yard.rake
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rake"
+
+begin
+  require "yard"
+  require "yard/rake/yardoc_task"
+
+  namespace :doc do
+    desc "Generate Yardoc documentation"
+    YARD::Rake::YardocTask.new do |yardoc|
+      yardoc.name = "yard"
+      yardoc.options = ["--verbose", "--markup", "markdown"]
+      yardoc.files = FileList[
+        "lib/**/*.rb", "ext/**/*.c",
+        "README.md", "CHANGELOG.md", "LICENSE.txt"
+      ].exclude(/idna/)
+    end
+  end
+
+  task "clobber" => ["doc:clobber_yard"]
+
+  desc "Alias to doc:yard"
+  task "doc" => "doc:yard"
+rescue LoadError
+  # If yard isn't available, it's not the end of the world
+  desc "Alias to doc:rdoc"
+  task "doc" => "doc:rdoc"
+end