addressable-2.7.0/ 0000755 0000041 0000041 00000000000 13534474053 014031 5 ustar www-data www-data addressable-2.7.0/README.md 0000644 0000041 0000041 00000006247 13534474053 015321 0 ustar www-data www-data # Addressable
- Homepage
- github.com/sporkmonger/addressable
- Author
- Bob Aman
- Copyright
- Copyright © Bob Aman
- License
- Apache 2.0
[][gem]
[][travis]
[][coveralls]
[][inch]
[gem]: https://rubygems.org/gems/addressable
[travis]: http://travis-ci.org/sporkmonger/addressable
[coveralls]: https://coveralls.io/r/sporkmonger/addressable
[inch]: http://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
#=> #
```
# 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'
}
})
#=> #
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 idn # 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.5'
```
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'
```
addressable-2.7.0/tasks/ 0000755 0000041 0000041 00000000000 13534474053 015156 5 ustar www-data www-data addressable-2.7.0/tasks/git.rake 0000644 0000041 0000041 00000002427 13534474053 016612 0 ustar www-data www-data # 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"
addressable-2.7.0/tasks/clobber.rake 0000644 0000041 0000041 00000000117 13534474053 017431 0 ustar www-data www-data # frozen_string_literal: true
desc "Remove all build products"
task "clobber"
addressable-2.7.0/tasks/metrics.rake 0000644 0000041 0000041 00000001172 13534474053 017471 0 ustar www-data www-data # 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
addressable-2.7.0/tasks/rspec.rake 0000644 0000041 0000041 00000001042 13534474053 017133 0 ustar www-data www-data # 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 = ['--color', '--format', 'documentation']
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"]
addressable-2.7.0/tasks/yard.rake 0000644 0000041 0000041 00000001255 13534474053 016764 0 ustar www-data www-data # 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
addressable-2.7.0/tasks/gem.rake 0000644 0000041 0000041 00000004555 13534474053 016603 0 ustar www-data www-data # 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.has_rdoc = true
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.0"
s.add_runtime_dependency "public_suffix", ">= 2.0.2", "< 5.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"
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 "#{SUDO} gem install --local pkg/#{GEM_SPEC.full_name}"
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(
"#{SUDO} 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"]
addressable-2.7.0/spec/ 0000755 0000041 0000041 00000000000 13534474053 014763 5 ustar www-data www-data addressable-2.7.0/spec/addressable/ 0000755 0000041 0000041 00000000000 13534474053 017234 5 ustar www-data www-data addressable-2.7.0/spec/addressable/uri_spec.rb 0000644 0000041 0000041 00000554255 13534474053 021412 0 ustar www-data www-data # frozen_string_literal: true
# coding: utf-8
# 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"
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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda do
Addressable::URI.new(:host => "")
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(lambda 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(lambda 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(lambda do
@uri.scheme = "\t \n"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should raise an error if the scheme is set to all digits" do
expect(lambda do
@uri.scheme = "123"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should raise an error if the scheme begins with a digit" do
expect(lambda do
@uri.scheme = "1scheme"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should raise an error if the scheme begins with a plus" do
expect(lambda do
@uri.scheme = "+scheme"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should raise an error if the scheme begins with a dot" do
expect(lambda do
@uri.scheme = ".scheme"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should raise an error if the scheme begins with a dash" do
expect(lambda do
@uri.scheme = "-scheme"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should raise an error if the scheme contains an illegal character" do
expect(lambda do
@uri.scheme = "scheme!"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should raise an error if the scheme contains whitespace" do
expect(lambda do
@uri.scheme = "sch eme"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should raise an error if the scheme contains a newline" do
expect(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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 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(lambda do
@uri.omit(:bogus)
end).to raise_error(ArgumentError)
expect(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda do
@uri.origin = "example.com"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should not allow origin assignment without host" do
expect(lambda do
@uri.origin = "http://"
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should not allow origin assignment with bogus type" do
expect(lambda 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(lambda 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(lambda 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(lambda 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://[]/'" do
expect(lambda do
Addressable::URI.parse("http://[]/")
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(lambda 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.]/'" do
expect(lambda do
Addressable::URI.parse("http://[v0.]/")
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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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 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(lambda 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(lambda do
@uri.route_to("http://example.com/")
end).to raise_error(ArgumentError, /relative\/path\/to\/resource/)
expect(lambda 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(lambda 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(lambda 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(lambda do
@uri.merge(:port => "bogus")
end).to raise_error(Addressable::URI::InvalidURIError)
end
it "should fail to merge with bogus values" do
expect(lambda 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(lambda do
@uri.merge(42)
end).to raise_error(TypeError)
end
it "should fail to merge with bogus parameters" do
expect(lambda do
@uri.merge("http://example.com/")
end).to raise_error(TypeError)
end
it "should fail to merge with both authority and subcomponents" do
expect(lambda 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(lambda 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 " +
"'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/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(lambda 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(lambda do
@uri.route_to("http://example.com/")
end).to raise_error(ArgumentError, /\/\/example.com\//)
expect(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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 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 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 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(lambda do
Addressable::URI.unencode_component(42)
end).to raise_error(TypeError)
end
it "should raise a TypeError" do
expect(lambda 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(lambda do
Addressable::URI.encode(Object.new)
end).to raise_error(TypeError)
end
it "should raise a TypeError" do
expect(lambda do
Addressable::URI.normalized_encode(Object.new)
end).to raise_error(TypeError)
end
it "should raise a TypeError" do
expect(lambda do
Addressable::URI.encode_component("günther", Object.new)
end).to raise_error(TypeError)
end
it "should raise a TypeError" do
expect(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda 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(lambda { @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(lambda 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(lambda 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(lambda 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
addressable-2.7.0/spec/addressable/template_spec.rb 0000644 0000041 0000041 00000132306 13534474053 022413 0 ustar www-data www-data # frozen_string_literal: true
# coding: utf-8
# 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 "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)
if expansion.is_a?(Array)
expect(expansion.any?{|i| i == tmpl.to_str}).to be true
else
expect(tmpl.to_str).to eq(expansion)
end
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 "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',
'dot,.,semi,%3B,comma,%2C',
'comma,%2C,semi,%3B,dot,.',
'semi,%3B,comma,%2C,dot,.',
'dot,.,comma,%2C,semi,%3B',
'comma,%2C,dot,.,semi,%3B'
],
'{keys*}' => [
'semi=%3B,dot=.,comma=%2C',
'dot=.,semi=%3B,comma=%2C',
'comma=%2C,semi=%3B,dot=.',
'semi=%3B,comma=%2C,dot=.',
'dot=.,comma=%2C,semi=%3B',
'comma=%2C,dot=.,semi=%3B'
]
}
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,,',
'dot,.,semi,;,comma,,',
'comma,,,semi,;,dot,.',
'semi,;,comma,,,dot,.',
'dot,.,comma,,,semi,;',
'comma,,,dot,.,semi,;'
],
'{+keys*}' => [
'semi=;,dot=.,comma=,',
'dot=.,semi=;,comma=,',
'comma=,,semi=;,dot=.',
'semi=;,comma=,,dot=.',
'dot=.,comma=,,semi=;',
'comma=,,dot=.,semi=;'
]
}
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,,',
'#dot,.,semi,;,comma,,',
'#comma,,,semi,;,dot,.',
'#semi,;,comma,,,dot,.',
'#dot,.,comma,,,semi,;',
'#comma,,,dot,.,semi,;'
],
'{#keys*}' => [
'#semi=;,dot=.,comma=,',
'#dot=.,semi=;,comma=,',
'#comma=,,semi=;,dot=.',
'#semi=;,comma=,,dot=.',
'#dot=.,comma=,,semi=;',
'#comma=,,dot=.,semi=;'
]
}
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.dot,.,semi,%3B,comma,%2C',
'X.comma,%2C,semi,%3B,dot,.',
'X.semi,%3B,comma,%2C,dot,.',
'X.dot,.,comma,%2C,semi,%3B',
'X.comma,%2C,dot,.,semi,%3B'
],
'X{.keys*}' => [
'X.semi=%3B.dot=..comma=%2C',
'X.dot=..semi=%3B.comma=%2C',
'X.comma=%2C.semi=%3B.dot=.',
'X.semi=%3B.comma=%2C.dot=.',
'X.dot=..comma=%2C.semi=%3B',
'X.comma=%2C.dot=..semi=%3B'
]
}
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',
'/dot,.,semi,%3B,comma,%2C',
'/comma,%2C,semi,%3B,dot,.',
'/semi,%3B,comma,%2C,dot,.',
'/dot,.,comma,%2C,semi,%3B',
'/comma,%2C,dot,.,semi,%3B'
],
'{/keys*}' => [
'/semi=%3B/dot=./comma=%2C',
'/dot=./semi=%3B/comma=%2C',
'/comma=%2C/semi=%3B/dot=.',
'/semi=%3B/comma=%2C/dot=.',
'/dot=./comma=%2C/semi=%3B',
'/comma=%2C/dot=./semi=%3B'
]
}
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=dot,.,semi,%3B,comma,%2C',
';keys=comma,%2C,semi,%3B,dot,.',
';keys=semi,%3B,comma,%2C,dot,.',
';keys=dot,.,comma,%2C,semi,%3B',
';keys=comma,%2C,dot,.,semi,%3B'
],
'{;keys*}' => [
';semi=%3B;dot=.;comma=%2C',
';dot=.;semi=%3B;comma=%2C',
';comma=%2C;semi=%3B;dot=.',
';semi=%3B;comma=%2C;dot=.',
';dot=.;comma=%2C;semi=%3B',
';comma=%2C;dot=.;semi=%3B'
]
}
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=dot,.,semi,%3B,comma,%2C',
'?keys=comma,%2C,semi,%3B,dot,.',
'?keys=semi,%3B,comma,%2C,dot,.',
'?keys=dot,.,comma,%2C,semi,%3B',
'?keys=comma,%2C,dot,.,semi,%3B'
],
'{?keys*}' => [
'?semi=%3B&dot=.&comma=%2C',
'?dot=.&semi=%3B&comma=%2C',
'?comma=%2C&semi=%3B&dot=.',
'?semi=%3B&comma=%2C&dot=.',
'?dot=.&comma=%2C&semi=%3B',
'?comma=%2C&dot=.&semi=%3B'
]
}
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=dot,.,semi,%3B,comma,%2C',
'&keys=comma,%2C,semi,%3B,dot,.',
'&keys=semi,%3B,comma,%2C,dot,.',
'&keys=dot,.,comma,%2C,semi,%3B',
'&keys=comma,%2C,dot,.,semi,%3B'
],
'{&keys*}' => [
'&semi=%3B&dot=.&comma=%2C',
'&dot=.&semi=%3B&comma=%2C',
'&comma=%2C&semi=%3B&dot=.',
'&semi=%3B&comma=%2C&dot=.',
'&dot=.&comma=%2C&semi=%3B',
'&comma=%2C&dot=.&semi=%3B'
]
}
end
end
describe "Modifiers" do
subject {
{
:var => "value",
:semi => ";",
:year => %w(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',
'dot,.,semi,%3B,comma,%2C',
'comma,%2C,semi,%3B,dot,.',
'semi,%3B,comma,%2C,dot,.',
'dot,.,comma,%2C,semi,%3B',
'comma,%2C,dot,.,semi,%3B'
],
'{keys*}' => [
'semi=%3B,dot=.,comma=%2C',
'dot=.,semi=%3B,comma=%2C',
'comma=%2C,semi=%3B,dot=.',
'semi=%3B,comma=%2C,dot=.',
'dot=.,comma=%2C,semi=%3B',
'comma=%2C,dot=.,semi=%3B'
]
}
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,,',
'dot,.,semi,;,comma,,',
'comma,,,semi,;,dot,.',
'semi,;,comma,,,dot,.',
'dot,.,comma,,,semi,;',
'comma,,,dot,.,semi,;'
],
'{+keys*}' => [
'semi=;,dot=.,comma=,',
'dot=.,semi=;,comma=,',
'comma=,,semi=;,dot=.',
'semi=;,comma=,,dot=.',
'dot=.,comma=,,semi=;',
'comma=,,dot=.,semi=;'
]
}
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,,',
'#dot,.,semi,;,comma,,',
'#comma,,,semi,;,dot,.',
'#semi,;,comma,,,dot,.',
'#dot,.,comma,,,semi,;',
'#comma,,,dot,.,semi,;'
],
'{#keys*}' => [
'#semi=;,dot=.,comma=,',
'#dot=.,semi=;,comma=,',
'#comma=,,semi=;,dot=.',
'#semi=;,comma=,,dot=.',
'#dot=.,comma=,,semi=;',
'#comma=,,dot=.,semi=;'
]
}
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.dot,.,semi,%3B,comma,%2C',
'X.comma,%2C,semi,%3B,dot,.',
'X.semi,%3B,comma,%2C,dot,.',
'X.dot,.,comma,%2C,semi,%3B',
'X.comma,%2C,dot,.,semi,%3B'
],
'X{.keys*}' => [
'X.semi=%3B.dot=..comma=%2C',
'X.dot=..semi=%3B.comma=%2C',
'X.comma=%2C.semi=%3B.dot=.',
'X.semi=%3B.comma=%2C.dot=.',
'X.dot=..comma=%2C.semi=%3B',
'X.comma=%2C.dot=..semi=%3B'
],
'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',
'/dot,.,semi,%3B,comma,%2C',
'/comma,%2C,semi,%3B,dot,.',
'/semi,%3B,comma,%2C,dot,.',
'/dot,.,comma,%2C,semi,%3B',
'/comma,%2C,dot,.,semi,%3B'
],
'{/keys*}' => [
'/semi=%3B/dot=./comma=%2C',
'/dot=./semi=%3B/comma=%2C',
'/comma=%2C/semi=%3B/dot=.',
'/semi=%3B/comma=%2C/dot=.',
'/dot=./comma=%2C/semi=%3B',
'/comma=%2C/dot=./semi=%3B'
]
}
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=dot,.,semi,%3B,comma,%2C',
';keys=comma,%2C,semi,%3B,dot,.',
';keys=semi,%3B,comma,%2C,dot,.',
';keys=dot,.,comma,%2C,semi,%3B',
';keys=comma,%2C,dot,.,semi,%3B'
],
'{;keys*}' => [
';semi=%3B;dot=.;comma=%2C',
';dot=.;semi=%3B;comma=%2C',
';comma=%2C;semi=%3B;dot=.',
';semi=%3B;comma=%2C;dot=.',
';dot=.;comma=%2C;semi=%3B',
';comma=%2C;dot=.;semi=%3B'
]
}
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=dot,.,semi,%3B,comma,%2C',
'?keys=comma,%2C,semi,%3B,dot,.',
'?keys=semi,%3B,comma,%2C,dot,.',
'?keys=dot,.,comma,%2C,semi,%3B',
'?keys=comma,%2C,dot,.,semi,%3B'
],
'{?keys*}' => [
'?semi=%3B&dot=.&comma=%2C',
'?dot=.&semi=%3B&comma=%2C',
'?comma=%2C&semi=%3B&dot=.',
'?semi=%3B&comma=%2C&dot=.',
'?dot=.&comma=%2C&semi=%3B',
'?comma=%2C&dot=.&semi=%3B'
]
}
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=dot,.,semi,%3B,comma,%2C',
'&keys=comma,%2C,semi,%3B,dot,.',
'&keys=semi,%3B,comma,%2C,dot,.',
'&keys=dot,.,comma,%2C,semi,%3B',
'&keys=comma,%2C,dot,.,semi,%3B'
],
'{&keys*}' => [
'&semi=%3B&dot=.&comma=%2C',
'&dot=.&semi=%3B&comma=%2C',
'&comma=%2C&semi=%3B&dot=.',
'&semi=%3B&comma=%2C&dot=.',
'&dot=.&comma=%2C&semi=%3B',
'&comma=%2C&dot=.&semi=%3B'
]
}
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 "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 "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
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
addressable-2.7.0/spec/addressable/rack_mount_compat_spec.rb 0000644 0000041 0000041 00000006423 13534474053 024305 0 ustar www-data www-data # frozen_string_literal: true
# coding: utf-8
# 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 "addressable/template"
require "rack/mount"
describe Rack::Mount do
let(:app_one) do
proc { |env| [200, {'Content-Type' => 'text/plain'}, 'Route 1'] }
end
let(:app_two) do
proc { |env| [200, {'Content-Type' => 'text/plain'}, 'Route 2'] }
end
let(:app_three) do
proc { |env| [200, {'Content-Type' => 'text/plain'}, 'Route 3'] }
end
let(:routes) do
s = Rack::Mount::RouteSet.new do |set|
set.add_route(app_one, {
:request_method => 'GET',
:path_info => Addressable::Template.new('/one/{id}/')
}, {:id => 'unidentified'}, :one)
set.add_route(app_two, {
:request_method => 'GET',
:path_info => Addressable::Template.new('/two/')
}, {:id => 'unidentified'}, :two)
set.add_route(app_three, {
:request_method => 'GET',
:path_info => Addressable::Template.new('/three/{id}/').to_regexp
}, {:id => 'unidentified'}, :three)
end
s.rehash
s
end
it "should generate from routes with Addressable::Template" do
path, _ = routes.generate(:path_info, :one, {:id => '123'})
expect(path).to eq '/one/123/'
end
it "should generate from routes with Addressable::Template using defaults" do
path, _ = routes.generate(:path_info, :one, {})
expect(path).to eq '/one/unidentified/'
end
it "should recognize routes with Addressable::Template" do
request = Rack::Request.new(
'REQUEST_METHOD' => 'GET',
'PATH_INFO' => '/one/123/'
)
route, _, params = routes.recognize(request)
expect(route).not_to be_nil
expect(route.app).to eq app_one
expect(params).to eq({id: '123'})
end
it "should generate from routes with Addressable::Template" do
path, _ = routes.generate(:path_info, :two, {:id => '654'})
expect(path).to eq '/two/'
end
it "should generate from routes with Addressable::Template using defaults" do
path, _ = routes.generate(:path_info, :two, {})
expect(path).to eq '/two/'
end
it "should recognize routes with Addressable::Template" do
request = Rack::Request.new(
'REQUEST_METHOD' => 'GET',
'PATH_INFO' => '/two/'
)
route, _, params = routes.recognize(request)
expect(route).not_to be_nil
expect(route.app).to eq app_two
expect(params).to eq({id: 'unidentified'})
end
it "should recognize routes with derived Regexp" do
request = Rack::Request.new(
'REQUEST_METHOD' => 'GET',
'PATH_INFO' => '/three/789/'
)
route, _, params = routes.recognize(request)
expect(route).not_to be_nil
expect(route.app).to eq app_three
expect(params).to eq({id: '789'})
end
end
addressable-2.7.0/spec/addressable/security_spec.rb 0000644 0000041 0000041 00000004262 13534474053 022446 0 ustar www-data www-data # frozen_string_literal: true
# coding: utf-8
# 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
addressable-2.7.0/spec/addressable/idna_spec.rb 0000644 0000041 0000041 00000024277 13534474053 021522 0 ustar www-data www-data # frozen_string_literal: true
# coding: utf-8
# 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 "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
it "should normalize 'string' correctly" do
expect(Addressable::IDNA.unicode_normalize_kc(:'string')).to eq("string")
expect(Addressable::IDNA.unicode_normalize_kc("string")).to eq("string")
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
# Cannot test the native implementation without libidn support.
warn('Could not load native IDN implementation.')
end
addressable-2.7.0/spec/addressable/net_http_compat_spec.rb 0000644 0000041 0000041 00000001636 13534474053 023771 0 ustar www-data www-data # frozen_string_literal: true
# coding: utf-8
# 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
addressable-2.7.0/spec/spec_helper.rb 0000644 0000041 0000041 00000000712 13534474053 017601 0 ustar www-data www-data # 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
RSpec.configure do |config|
config.warnings = true
config.filter_run_when_matching :focus
end
addressable-2.7.0/CHANGELOG.md 0000644 0000041 0000041 00000020717 13534474053 015651 0 ustar www-data www-data # Addressable 2.7.0
- added `:compacted` flag to `normalized_query`
- `heuristic_parse` handles `mailto:` more intuitively
- refactored validation to use a prepended module
- dropped explicit support for JRuby 9.0.5.0
- compatibility w/ public_suffix 4.x
- performance improvements
# Addressable 2.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
- 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
- allow unicode normalization to be disabled for URI Template expansion
- removed duplicate test
# Addressable 2.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
- 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
- fix warnings
- update dependency gems
- support for 1.8.x officially deprecated
# Addressable 2.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
- 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
- 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
- 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
- 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
- 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
- fixed missing unicode data file
# Addressable 2.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
- fixed issues with dot segment removal code
- form encoding can now handle multiple values per key
- updated development environment
# Addressable 2.2.7
- fixed issues related to Addressable::URI#query_values=
- the Addressable::URI.parse method is now polymorphic
# Addressable 2.2.6
- changed the way ambiguous paths are handled
- fixed bug with frozen URIs
- https supported in heuristic parsing
# Addressable 2.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
- 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
- added :flat_array notation for query strings
# Addressable 2.2.2
- fixed issue with percent escaping of '+' character in query strings
# Addressable 2.2.1
- added support for application/x-www-form-urlencoded.
# Addressable 2.2.0
- added site methods
- improved documentation
# Addressable 2.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
- 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
- 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
- fixed issue with URI template expansion
- fixed issue with percent escaping characters 0-15
# Addressable 2.0.1
- fixed issue with query string assignment
- fixed issue with improperly encoded components
# Addressable 2.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
- 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
- implemented a hash method
# Addressable 1.0.2
- fixed minor bug with the extract_mapping method
# Addressable 1.0.1
- fixed minor bug with the extract_mapping method
# Addressable 1.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
- improved normalization
- fixed bug in joining algorithm
- updated specifications
# Addressable 0.1.1
- updated documentation
- added URI Template variable extraction
# Addressable 0.1.0
- initial release
- implementation based on RFC 3986, 3987
- support for IRIs via libidn
- support for the URI Template draft spec
addressable-2.7.0/addressable.gemspec 0000644 0000041 0000041 00000005125 13534474053 017652 0 ustar www-data www-data #########################################################
# This file has been automatically generated by gem2tgz #
#########################################################
# -*- encoding: utf-8 -*-
# stub: addressable 2.7.0 ruby lib
Gem::Specification.new do |s|
s.name = "addressable".freeze
s.version = "2.7.0"
s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
s.require_paths = ["lib".freeze]
s.authors = ["Bob Aman".freeze]
s.date = "2019-08-31"
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, "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/rack_mount_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/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.0".freeze)
s.rubygems_version = "2.5.2.1".freeze
s.summary = "URI Implementation".freeze
if s.respond_to? :specification_version then
s.specification_version = 4
if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
s.add_development_dependency(%q.freeze, ["< 3.0", ">= 1.0"])
s.add_runtime_dependency(%q.freeze, ["< 5.0", ">= 2.0.2"])
else
s.add_dependency(%q.freeze, ["< 3.0", ">= 1.0"])
s.add_dependency(%q.freeze, ["< 5.0", ">= 2.0.2"])
end
else
s.add_dependency(%q.freeze, ["< 3.0", ">= 1.0"])
s.add_dependency(%q.freeze, ["< 5.0", ">= 2.0.2"])
end
end
addressable-2.7.0/data/ 0000755 0000041 0000041 00000000000 13534474053 014742 5 ustar www-data www-data addressable-2.7.0/data/unicode.data 0000644 0000041 0000041 00000342034 13534474053 017231 0 ustar www-data www-data {iF[ i i 000if0iG[ i i 000ig0iH[ i i 000ih0iI[ i i 000ii0iJ[ i i 000ij0iK[ i i 000ik0iL[ i i 000il0iM[ i i 000im0iN[ i i 000in0iO[ i i 000io0iP[ i i 000ip0iQ[ i i 000iq0iR[ i i 000ir0iS[ i i 000is0iT[ i i 000it0iU[ i i 000iu0iV[ i i 000iv0iW[ i i 000iw0iX[ i i 000ix0iY[ i i 000iy0iZ[ i i 000iz0i[[ i i 000i{0i\[ i i 000i|0i][ i i 000i}0i^[ i i 000i~0i_[ i i 000i0if[ i i 00iF0iFig[ i i 00iG0iGih[ i i 00iH0iHii[ i i 00iI0iIij[ i i 00iJ0iJik[ i i 00iK0iKil[ i i 00iL0iLim[ i i 00iM0iMin[ i i 00iN0iNio[ i i 00iO0iOip[ i i 00iP0iPiq[ i i 00iQ0iQir[ i i 00iR0iRis[ i i 00iS0iSit[ i i 00iT0iTiu[ i i 00iU0iUiv[ i i 00iV0iViw[ i i 00iW0iWix[ i i 00iX0iXiy[ i i 00iY0iYiz[ i i 00iZ0iZi{[ i i 00i[0i[i|[ i i 00i\0i\i}[ i i 00i]0i]i~[ i i 00i^0i^i[ i i 00i_0i_i[ i i 0I" :ET000i[ i i 0I" ̈; T000i[ i i 0I"a; T000i[ i i 0I" ̄; T000i[ i i 0I"2; T000i[ i i 0I"3; T000i[ i i 0I" ́; T000i[ i i 0I"μ; Ti0ii[ i i 0I" ̧; T000i[ i i 0I"1; T000i[ i i 0I"o; T000i[ i i 0I"
1⁄4; T000i[ i i 0I"
1⁄2; T000i[ i i 0I"
3⁄4; T000i[ i i I"À; TI"À; T0i0i[ i i I"Á; TI"Á; T0i0i[ i i I"Â; TI"Â; T0i0i[ i i I"Ã; TI"Ã; T0i0i[ i i I"Ä; TI"Ä; T0i0i[ i i I"Å; TI"Å; T0i0i[ i i 000i0i[ i i I"Ç; TI"Ç; T0i0i[ i i I"È; TI"È; T0i0i[ i i I"É; TI"É; T0i0i[ i i I"Ê; TI"Ê; T0i0i[ i i I"Ë; TI"Ë; T0i0i[ i i I"Ì; TI"Ì; T0i0i[ i i I"Í; TI"Í; T0i0i[ i i I"Î; TI"Î; T0i0i[ i i I"Ï; TI"Ï; T0i0i[ i i 000i0i[ i i I"Ñ; TI"Ñ; T0i0i[ i i I"Ò; TI"Ò; T0i0i[ i i I"Ó; TI"Ó; T0i0i[ i i I"Ô; TI"Ô; T0i0i[ i i I"Õ; TI"Õ; T0i0i[ i i I"Ö; TI"Ö; T0i0i[ i i 000i0i[ i i I"Ù; TI"Ù; T0i0i[ i i I"Ú; TI"Ú; T0i0i[ i i I"Û; TI"Û; T0i0i[ i i I"Ü; TI"Ü; T0i0i[ i i I"Ý; TI"Ý; T0i0i[ i i 000i0i[ i i I"à; TI"à; Ti0ii[ i i I"á; TI"á; Ti0ii[ i i I"â; TI"â; Ti0ii[ i i I"ã; TI"ã; Ti0ii[ i i I"ä; TI"ä; Ti0ii[ i i I"å; TI"å; Ti0ii[ i i 00i0ii[ i i I"ç; TI"ç; Ti0ii[ i i I"è; TI"è; Ti0ii[ i i I"é; TI"é; Ti0ii[ i i I"ê; TI"ê; Ti0ii[ i i I"ë; TI"ë; Ti0ii[ i i I"ì; TI"ì; Ti0ii[ i i I"í; TI"í; Ti0ii[ i i I"î; TI"î; Ti0ii[ i i I"ï; TI"ï; Ti0ii[ i i 00i0ii[ i i I"ñ; TI"ñ; Ti0ii[ i i I"ò; TI"ò; Ti0ii[ i i I"ó; TI"ó; Ti0ii[ i i I"ô; TI"ô; Ti0ii[ i i I"õ; TI"õ; Ti0ii[ i i I"ö; TI"ö; Ti0ii[ i i 00i0ii[ i i I"ù; TI"ù; Ti0ii[ i i I"ú; TI"ú; Ti0ii[ i i I"û; TI"û; Ti0ii[ i i I"ü; TI"ü; Ti0ii[ i i I"ý; TI"ý; Ti0ii[ i i 00i0ii[ i i I"ÿ; TI"ÿ; Tix0ixi [ i i I"Ā; TI"Ā; T0i0i[ i i I"ā; TI"ā; Ti 0i i[ i i I"Ă; TI"Ă; T0i0i[ i i I"ă; TI"ă; Ti0ii[ i i I"Ą; TI"Ą; T0i0i[ i i I"ą; TI"ą; Ti0ii[ i i I"Ć; TI"Ć; T0i0i[ i i I"ć; TI"ć; Ti0ii[ i i I"Ĉ; TI"Ĉ; T0i 0i [ i i I"ĉ; TI"ĉ; Ti0ii
[ i i I"Ċ; TI"Ċ; T0i 0i [ i i I"ċ; TI"ċ; Ti
0i
i [ i i I"Č; TI"Č; T0i
0i
[ i i I"č; TI"č; Ti 0i i[ i i I"Ď; TI"Ď; T0i0i[ i i I"ď; TI"ď; Ti0ii[ i i 000i0i[ i i 00i0ii[ i i I"Ē; TI"Ē; T0i0i[ i i I"ē; TI"ē; Ti0ii[ i i I"Ĕ; TI"Ĕ; T0i0i[ i i I"ĕ; TI"ĕ; Ti0ii[ i i I"Ė; TI"Ė; T0i0i[ i i I"ė; TI"ė; Ti0ii[ i i I"Ę; TI"Ę; T0i0i[ i i I"ę; TI"ę; Ti0ii[ i i I"Ě; TI"Ě; T0i0i[ i i I"ě; TI"ě; Ti0ii [ i i I"Ĝ; TI"Ĝ; T0i 0i [ i i I"ĝ; TI"ĝ; Ti 0i i [ i i I"Ğ; TI"Ğ; T0i 0i [ i i I"ğ; TI"ğ; Ti 0i i [ i i I"Ġ; TI"Ġ; T0i!0i![ i i I"ġ; TI"ġ; Ti 0i i"[ i i I"Ģ; TI"Ģ; T0i#0i#[ i i I"ģ; TI"ģ; Ti"0i"i$[ i i I"Ĥ; TI"Ĥ; T0i%0i%[ i i I"ĥ; TI"ĥ; Ti$0i$i&[ i i 000i'0i'[ i i 00i&0i&i([ i i I"Ĩ; TI"Ĩ; T0i)0i)[ i i I"ĩ; TI"ĩ; Ti(0i(i*[ i i I"Ī; TI"Ī; T0i+0i+[ i i I"ī; TI"ī; Ti*0i*i,[ i i I"Ĭ; TI"Ĭ; T0i-0i-[ i i I"ĭ; TI"ĭ; Ti,0i,i.[ i i I"Į; TI"Į; T0i/0i/[ i i I"į; TI"į; Ti.0i.i0[ i i I"İ; TI"İ; T0in0i1[ i i 00iN0iNi2[ i i 0I"IJ; T0i30i3[ i i 0I"ij; Ti20i2i4[ i i I"Ĵ; TI"Ĵ; T0i50i5[ i i I"ĵ; TI"ĵ; Ti40i4i6[ i i I"Ķ; TI"Ķ; T0i70i7[ i i I"ķ; TI"ķ; Ti60i6i9[ i i I"Ĺ; TI"Ĺ; T0i:0i:[ i i I"ĺ; TI"ĺ; Ti90i9i;[ i i I"Ļ; TI"Ļ; T0i<0i<[ i i I"ļ; TI"ļ; Ti;0i;i=[ i i I"Ľ; TI"Ľ; T0i>0i>[ i i I"ľ; TI"ľ; Ti=0i=i?[ i i 0I"L·; T0i@0i@[ i i 0I"l·; Ti?0i?iA[ i i 000iB0iB[ i i 00iA0iAiC[ i i I"Ń; TI"Ń; T0iD0iD[ i i I"ń; TI"ń; TiC0iCiE[ i i I"Ņ; TI"Ņ; T0iF0iF[ i i I"ņ; TI"ņ; TiE0iEiG[ i i I"Ň; TI"Ň; T0iH0iH[ i i I"ň; TI"ň; TiG0iGiI[ i i 0I"ʼn; T000iJ[ i i 000iK0iK[ i i 00iJ0iJiL[ i i I"Ō; TI"Ō; T0iM0iM[ i i I"ō; TI"ō; TiL0iLiN[ i i I"Ŏ; TI"Ŏ; T0iO0iO[ i i I"ŏ; TI"ŏ; TiN0iNiP[ i i I"Ő; TI"Ő; T0iQ0iQ[ i i I"ő; TI"ő; TiP0iPiR[ i i 000iS0iS[ i i 00iR0iRiT[ i i I"Ŕ; TI"Ŕ; T0iU0iU[ i i I"ŕ; TI"ŕ; TiT0iTiV[ i i I"Ŗ; TI"Ŗ; T0iW0iW[ i i I"ŗ; TI"ŗ; TiV0iViX[ i i I"Ř; TI"Ř; T0iY0iY[ i i I"ř; TI"ř; TiX0iXiZ[ i i I"Ś; TI"Ś; T0i[0i[[ i i I"ś; TI"ś; TiZ0iZi\[ i i I"Ŝ; TI"Ŝ; T0i]0i][ i i I"ŝ; TI"ŝ; Ti\0i\i^[ i i I"Ş; TI"Ş; T0i_0i_[ i i I"ş; TI"ş; Ti^0i^i`[ i i I"Š; TI"Š; T0ia0ia[ i i I"š; TI"š; Ti`0i`ib[ i i I"Ţ; TI"Ţ; T0ic0ic[ i i I"ţ; TI"ţ; Tib0ibid[ i i I"Ť; TI"Ť; T0ie0ie[ i i I"ť; TI"ť; Tid0idif[ i i 000ig0ig[ i i 00if0ifih[ i i I"Ũ; TI"Ũ; T0ii0ii[ i i I"ũ; TI"ũ; Tih0ihij[ i i I"Ū; TI"Ū; T0ik0ik[ i i I"ū; TI"ū; Tij0ijil[ i i I"Ŭ; TI"Ŭ; T0im0im[ i i I"ŭ; TI"ŭ; Til0ilin[ i i I"Ů; TI"Ů; T0io0io[ i i I"ů; TI"ů; Tin0inip[ i i I"Ű; TI"Ű; T0iq0iq[ i i I"ű; TI"ű; Tip0ipir[ i i I"Ų; TI"Ų; T0is0is[ i i I"ų; TI"ų; Tir0irit[ i i I"Ŵ; TI"Ŵ; T0iu0iu[ i i I"ŵ; TI"ŵ; Tit0itiv[ i i I"Ŷ; TI"Ŷ; T0iw0iw[ i i I"ŷ; TI"ŷ; Tiv0ivix[ i i I"Ÿ; TI"Ÿ; T0i0iy[ i i I"Ź; TI"Ź; T0iz0iz[ i i I"ź; TI"ź; Tiy0iyi{[ i i I"Ż; TI"Ż; T0i|0i|[ i i I"ż; TI"ż; Ti{0i{i}[ i i I"Ž; TI"Ž; T0i~0i~[ i i I"ž; TI"ž; Ti}0i}i[ i i 0I"s; TiX0iXi[ i i 000iS0i[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000iT0i[ i i 000i0i[ i i 00i0ii[ i i 000iV0i[ i i 000iW0i[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 000iY0i[ i i 000i[0i[ i i 000i0i[ i i 00i0ii[ i i 000i`0i[ i i 000ic0i[ i i 00i0ii[ i i 000ii0i[ i i 000ih0i[ i i 000i0i[ i i 00i0ii[ i i 000io0i[ i i 000ir0i[ i i 000iu0i[ i i I"Ơ; TI"Ơ; T0i0i[ i i I"ơ; TI"ơ; Ti0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i I"Ư; TI"Ư; T0i0i[ i i I"ư; TI"ư; Ti0ii[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 00i0ii[ i i 0I"DŽ; T0iii[ i i 0I"Dž; Tii0i[ i i 0I"dž; Ti0ii[ i i 0I"LJ; T0iii[ i i 0I"Lj; Tii0i[ i i 0I"lj; Ti0ii[ i i 0I"NJ; T0iii[ i i 0I"Nj; Tii0i[ i i 0I"nj; Ti0ii[ i i I"Ǎ; TI"Ǎ; T0i0i[ i i I"ǎ; TI"ǎ; Ti0ii[ i i I"Ǐ; TI"Ǐ; T0i0i[ i i I"ǐ; TI"ǐ; Ti0ii[ i i I"Ǒ; TI"Ǒ; T0i0i[ i i I"ǒ; TI"ǒ; Ti0ii[ i i I"Ǔ; TI"Ǔ; T0i0i[ i i I"ǔ; TI"ǔ; Ti0ii[ i i I" Ǖ; TI" Ǖ; T0i0i[ i i I" ǖ; TI" ǖ; Ti0ii[ i i I" Ǘ; TI" Ǘ; T0i0i[ i i I" ǘ; TI" ǘ; Ti0ii[ i i I" Ǚ; TI" Ǚ; T0i0i[ i i I" ǚ; TI" ǚ; Ti0ii[ i i I" Ǜ; TI" Ǜ; T0i0i[ i i I" ǜ; TI" ǜ; Ti0ii[ i i 00i0ii[ i i I" Ǟ; TI" Ǟ; T0i0i[ i i I" ǟ; TI" ǟ; Ti0ii[ i i I" Ǡ; TI" Ǡ; T0i0i[ i i I" ǡ; TI" ǡ; Ti0ii[ i i I" Ǣ; TI" Ǣ; T0i0i[ i i I" ǣ; TI" ǣ; Ti0ii[ i i 000i0i[ i i 00i0ii[ i i I"Ǧ; TI"Ǧ; T0i0i[ i i I"ǧ; TI"ǧ; Ti0ii[ i i I"Ǩ; TI"Ǩ; T0i0i[ i i I"ǩ; TI"ǩ; Ti0ii[ i i I"Ǫ; TI"Ǫ; T0i0i[ i i I"ǫ; TI"ǫ; Ti0ii[ i i I" Ǭ; TI" Ǭ; T0i0i[ i i I" ǭ; TI" ǭ; Ti0ii[ i i I" Ǯ; TI" Ǯ; T0i0i[ i i I" ǯ; TI" ǯ; Ti0ii[ i i I"ǰ; TI"ǰ; T000i[ i i 0I"DZ; T0iii[ i i 0I"Dz; Tii0i[ i i 0I"dz; Ti0ii[ i i I"Ǵ; TI"Ǵ; T0i0i[ i i I"ǵ; TI"ǵ; Ti0ii[ i i 000i0i[ i i 000i0i[ i i I"Ǹ; TI"Ǹ; T0i0i[ i i I"ǹ; TI"ǹ; Ti0ii[ i i I" Ǻ; TI" Ǻ; T0i0i[ i i I" ǻ; TI" ǻ; Ti0ii[ i i I" Ǽ; TI" Ǽ; T0i0i[ i i I" ǽ; TI" ǽ; Ti0ii[ i i I" Ǿ; TI" Ǿ; T0i0i[ i i I" ǿ; TI" ǿ; Ti0ii [ i i I"Ȁ; TI"Ȁ; T0i0i[ i i I"ȁ; TI"ȁ; Ti 0i i[ i i I"Ȃ; TI"Ȃ; T0i0i[ i i I"ȃ; TI"ȃ; Ti0ii[ i i I"Ȅ; TI"Ȅ; T0i0i[ i i I"ȅ; TI"ȅ; Ti0ii[ i i I"Ȇ; TI"Ȇ; T0i0i[ i i I"ȇ; TI"ȇ; Ti0ii[ i i I"Ȉ; TI"Ȉ; T0i 0i [ i i I"ȉ; TI"ȉ; Ti0ii
[ i i I"Ȋ; TI"Ȋ; T0i 0i [ i i I"ȋ; TI"ȋ; Ti
0i
i [ i i I"Ȍ; TI"Ȍ; T0i
0i
[ i i I"ȍ; TI"ȍ; Ti 0i i[ i i I"Ȏ; TI"Ȏ; T0i0i[ i i I"ȏ; TI"ȏ; Ti0ii[ i i I"Ȑ; TI"Ȑ; T0i0i[ i i I"ȑ; TI"ȑ; Ti0ii[ i i I"Ȓ; TI"Ȓ; T0i0i[ i i I"ȓ; TI"ȓ; Ti0ii[ i i I"Ȕ; TI"Ȕ; T0i0i[ i i I"ȕ; TI"ȕ; Ti0ii[ i i I"Ȗ; TI"Ȗ; T0i0i[ i i I"ȗ; TI"ȗ; Ti0ii[ i i I"Ș; TI"Ș; T0i0i[ i i I"ș; TI"ș; Ti0ii[ i i I"Ț; TI"Ț; T0i0i[ i i I"ț; TI"ț; Ti0ii [ i i 000i 0i [ i i 00i 0i i [ i i I"Ȟ; TI"Ȟ; T0i 0i [ i i I"ȟ; TI"ȟ; Ti 0i i"[ i i 000i#0i#[ i i 00i"0i"i$[ i i 000i%0i%[ i i 00i$0i$i&[ i i I"Ȧ; TI"Ȧ; T0i'0i'[ i i I"ȧ; TI"ȧ; Ti&0i&i([ i i I"Ȩ; TI"Ȩ; T0i)0i)[ i i I"ȩ; TI"ȩ; Ti(0i(i*[ i i I" Ȫ; TI" Ȫ; T0i+0i+[ i i I" ȫ; TI" ȫ; Ti*0i*i,[ i i I" Ȭ; TI" Ȭ; T0i-0i-[ i i I" ȭ; TI" ȭ; Ti,0i,i.[ i i I"Ȯ; TI"Ȯ; T0i/0i/[ i i I"ȯ; TI"ȯ; Ti.0i.i0[ i i I" Ȱ; TI" Ȱ; T0i10i1[ i i I" ȱ; TI" ȱ; Ti00i0i2[ i i I"Ȳ; TI"Ȳ; T0i30i3[ i i I"ȳ; TI"ȳ; Ti20i2iS[ i i 00i0iiT[ i i 00i0iiV[ i i 00i0iiW[ i i 00i0iiY[ i i 00i0ii[[ i i 00i0ii`[ i i 00i0iic[ i i 00i0iih[ i i 00i0iii[ i i 00i0iio[ i i 00i0iir[ i i 00i0iiu[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 0I"h; T000i[ i i 0I"ɦ; T000i[ i i 0I"j; T000i[ i i 0I"r; T000i[ i i 0I"ɹ; T000i[ i i 0I"ɻ; T000i[ i i 0I"ʁ; T000i[ i i 0I"w; T000i[ i i 0I"y; T000i[ i i 0I" ̆; T000i[ i i 0I" ̇; T000i[ i i 0I" ̊; T000i[ i i 0I" ̨; T000i[ i i 0I" ̃; T000i[ i i 0I" ̋; T000i[ i i 0I"ɣ; T000i[ i i 0I"l; T000i[ i i 0I"s; T000i[ i i 0I"x; T000i[ i i 0I"ʕ; T000i [ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i [ ii 00000i
[ ii 00000i [ ii 00000i [ ii 00000i
[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i![ ii 00000i"[ ii 00000i#[ ii 00000i$[ ii 00000i%[ ii 00000i&[ ii 00000i'[ ii 00000i([ ii 00000i)[ ii 00000i*[ ii 00000i+[ ii 00000i,[ ii 00000i-[ ii 00000i.[ ii 00000i/[ ii 00000i0[ ii 00000i1[ ii 00000i2[ ii 00000i3[ ii 00000i4[ ii 00000i5[ ii 00000i6[ ii 00000i7[ ii 00000i8[ ii 00000i9[ ii 00000i:[ ii 00000i;[ ii 00000i<[ ii 00000i=[ ii 00000i>[ ii 00000i?[ ii 00000i@[ iiI"̀; TI"̀; T000iA[ iiI"́; TI"́; T000iB[ ii 00000iC[ iiI"̓; TI"̓; T000iD[ iiI" ̈́; TI" ̈́; T000iE[ ii 00i0iiF[ ii 00000iG[ ii 00000iH[ ii 00000iI[ ii 00000iJ[ ii 00000iK[ ii 00000iL[ ii 00000iM[ ii 00000iN[ ii 00000i`[ ii 00000ia[ ii 00000ib[ ii 00000it[ i iI"ʹ; TI"ʹ; T000iz[ i i 0I" ͅ; T000i~[ i iI";; TI";; T000i[ i i 0I" ́; T000i[ i i I" ΅; TI" ΅; T000i[ i i I" Ά; TI" Ά; T0i0i[ i iI"·; TI"·; T000i[ i i I" Έ; TI" Έ; T0i0i[ i i I" Ή; TI" Ή; T0i0i[ i i I" Ί; TI" Ί; T0i0i[ i i I" Ό; TI" Ό; T0i0i[ i i I" Ύ; TI" Ύ; T0i0i[ i i I" Ώ; TI" Ώ; T0i0i[ i i I" ΐ; TI" ΐ; T000i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i 000i0i[ i i I" Ϊ; TI" Ϊ; T0i0i[ i i I" Ϋ; TI" Ϋ; T0i0i[ i i I" ά; TI" ά; Ti0ii[ i i I" έ; TI" έ; Ti0ii[ i i I" ή; TI" ή; Ti0ii[ i i I" ί; TI" ί; Ti0ii[ i i I" ΰ; TI" ΰ; T000i[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i 00i0ii[ i i I" ϊ; TI" ϊ; Ti0ii[ i i I" ϋ; TI" ϋ; Ti0ii[ i i I" ό; TI" ό; Ti0ii[ i i I" ύ; TI" ύ; Ti0ii[ i i I" ώ; TI" ώ; Ti0ii[ i i 0I"β; Ti0ii[ i i 0I"θ; Ti0ii[ i i 0I"Υ; T000i[ i i I" ϓ; TI" ϓ; T000i[ i i I" ϔ; TI" ϔ; T000i[ i i 0I"φ; Ti0ii[ i i 0I"π; Ti0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 0I"κ; Ti0ii[ i i 0I"ρ; Ti0ii[ i i 0I"ς; Ti0ii [ i i I" Ѐ; TI" Ѐ; T0iP0i[ i i I" Ё; TI" Ё; T0iQ0i[ i i 000iR0i[ i i I" Ѓ; TI" Ѓ; T0iS0i[ i i 000iT0i[ i i 000iU0i[ i i 000iV0i[ i i I" Ї; TI" Ї; T0iW0i[ i i 000iX0i [ i i 000iY0i
[ i i 000iZ0i [ i i 000i[0i [ i i I" Ќ; TI" Ќ; T0i\0i
[ i i I" Ѝ; TI" Ѝ; T0i]0i[ i i I" Ў; TI" Ў; T0i^0i[ i i 000i_0i[ i i 000i00i[ i i 000i10i[ i i 000i20i[ i i 000i30i[ i i 000i40i[ i i 000i50i[ i i 000i60i[ i i 000i70i[ i i 000i80i[ i i I" Й; TI" Й; T0i90i[ i i 000i:0i[ i i 000i;0i [ i i 000i<0i [ i i 000i=0i [ i i 000i>0i [ i i 000i?0i [ i i 000i@0i![ i i 000iA0i"[ i i 000iB0i#[ i i 000iC0i$[ i i 000iD0i%[ i i 000iE0i&[ i i 000iF0i'[ i i 000iG0i([ i i 000iH0i)[ i i 000iI0i*[ i i 000iJ0i+[ i i 000iK0i,[ i i 000iL0i-[ i i 000iM0i.[ i i 000iN0i/[ i i 000iO0i0[ i i 00i0ii1[ i i 00i0ii2[ i i 00i0ii3[ i i 00i0ii4[ i i 00i0ii5[ i i 00i0ii6[ i i 00i0ii7[ i i 00i0ii8[ i i 00i0ii9[ i i I" й; TI" й; Ti0ii:[ i i 00i0ii;[ i i 00i0ii<[ i i 00i 0i i=[ i i 00i 0i i>[ i i 00i 0i i?[ i i 00i 0i i@[ i i 00i 0i iA[ i i 00i!0i!iB[ i i 00i"0i"iC[ i i 00i#0i#iD[ i i 00i$0i$iE[ i i 00i%0i%iF[ i i 00i&0i&iG[ i i 00i'0i'iH[ i i 00i(0i(iI[ i i 00i)0i)iJ[ i i 00i*0i*iK[ i i 00i+0i+iL[ i i 00i,0i,iM[ i i 00i-0i-iN[ i i 00i.0i.iO[ i i 00i/0i/iP[ i i I" ѐ; TI" ѐ; Ti 0i iQ[ i i I" ё; TI" ё; Ti0iiR[ i i 00i0iiS[ i i I" ѓ; TI" ѓ; Ti0iiT[ i i 00i0iiU[ i i 00i0iiV[ i i 00i0iiW[ i i I" ї; TI" ї; Ti0iiX[ i i 00i0iiY[ i i 00i 0i iZ[ i i 00i
0i
i[[ i i 00i 0i i\[ i i I" ќ; TI" ќ; Ti 0i i][ i i I" ѝ; TI" ѝ; Ti
0i
i^[ i i I" ў; TI" ў; Ti0ii_[ i i 00i0ii`[ i i 000ia0ia[ i i 00i`0i`ib[ i i 000ic0ic[ i i 00ib0ibid[ i i 000ie0ie[ i i 00id0idif[ i i 000ig0ig[ i i 00if0ifih[ i i 000ii0ii[ i i 00ih0ihij[ i i 000ik0ik[ i i 00ij0ijil[ i i 000im0im[ i i 00il0ilin[ i i 000io0io[ i i 00in0inip[ i i 000iq0iq[ i i 00ip0ipir[ i i 000is0is[ i i 00ir0irit[ i i 000iu0iu[ i i 00it0itiv[ i i I" Ѷ; TI" Ѷ; T0iw0iw[ i i I" ѷ; TI" ѷ; Tiv0ivix[ i i 000iy0iy[ i i 00ix0ixiz[ i i 000i{0i{[ i i 00iz0izi|[ i i 000i}0i}[ i i 00i|0i|i~[ i i 000i0i[ i i 00i~0i~i[ i i 000i0i[ i i 00i0ii[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i I" Ӂ; TI" Ӂ; T0i0i[ i i I" ӂ; TI" ӂ; Ti0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i 000i0i[ i i 00i0ii[ i i I" Ӑ; TI" Ӑ; T0i0i[ i i I" ӑ; TI" ӑ; Ti0ii[ i i I" Ӓ; TI" Ӓ; T0i0i[ i i I" ӓ; TI" ӓ; Ti0ii[ i i 000i0i[ i i 00i0ii[ i i I" Ӗ; TI" Ӗ; T0i0i[ i i I" ӗ; TI" ӗ; Ti0ii[ i i 000i0i[ i i 00i0ii[ i i I" Ӛ; TI" Ӛ; T0i0i[ i i I" ӛ; TI" ӛ; Ti0ii[ i i I" Ӝ; TI" Ӝ; T0i0i[ i i I" ӝ; TI" ӝ; Ti0ii[ i i I" Ӟ; TI" Ӟ; T0i0i[ i i I" ӟ; TI" ӟ; Ti0ii[ i i 000i0i[ i i 00i0ii[ i i I" Ӣ; TI" Ӣ; T0i0i[ i i I" ӣ; TI" ӣ; Ti0ii[ i i I" Ӥ; TI" Ӥ; T0i0i[ i i I" ӥ; TI" ӥ; Ti0ii[ i i I" Ӧ; TI" Ӧ; T0i0i[ i i I" ӧ; TI" ӧ; Ti0ii[ i i 000i0i[ i i 00i0ii[ i i I" Ӫ; TI" Ӫ; T0i0i[ i i I" ӫ; TI" ӫ; Ti0ii[ i i I" Ӭ; TI" Ӭ; T0i0i[ i i I" ӭ; TI" ӭ; Ti0ii[ i i I" Ӯ; TI" Ӯ; T0i0i[ i i I" ӯ; TI" ӯ; Ti0ii[ i i I" Ӱ; TI" Ӱ; T0i0i[ i i I" ӱ; TI" ӱ; Ti0ii[ i i I" Ӳ; TI" Ӳ; T0i0i[ i i I" ӳ; TI" ӳ; Ti0ii[ i i I" Ӵ; TI" Ӵ; T0i0i[ i i I" ӵ; TI" ӵ; Ti0ii[ i i I" Ӹ; TI" Ӹ; T0i0i[ i i I" ӹ; TI" ӹ; Ti0ii1[ i i 000ia0i2[ i i 000ib0i3[ i i 000ic0i4[ i i 000id0i5[ i i 000ie0i6[ i i 000if0i7[ i i 000ig0i8[ i i 000ih0i9[ i i 000ii0i:[ i i 000ij0i;[ i i 000ik0i<[ i i 000il0i=[ i i 000im0i>[ i i 000in0i?[ i i 000io0i@[ i i 000ip0iA[ i i 000iq0iB[ i i 000ir0iC[ i i 000is0iD[ i i 000it0iE[ i i 000iu0iF[ i i 000iv0iG[ i i 000iw0iH[ i i 000ix0iI[ i i 000iy0iJ[ i i 000iz0iK[ i i 000i{0iL[ i i 000i|0iM[ i i 000i}0iN[ i i 000i~0iO[ i i 000i0iP[ i i 000i0iQ[ i i 000i0iR[ i i 000i0iS[ i i 000i0iT[ i i 000i0iU[ i i 000i0iV[ i i 000i0ia[ i i 00i10i1ib[ i i 00i20i2ic[ i i 00i30i3id[ i i 00i40i4ie[ i i 00i50i5if[ i i 00i60i6ig[ i i 00i70i7ih[ i i 00i80i8ii[ i i 00i90i9ij[ i i 00i:0i:ik[ i i 00i;0i;il[ i i 00i<0i<im[ i i 00i=0i=in[ i i 00i>0i>io[ i i 00i?0i?ip[ i i 00i@0i@iq[ i i 00iA0iAir[ i i 00iB0iBis[ i i 00iC0iCit[ i i 00iD0iDiu[ i i 00iE0iEiv[ i i 00iF0iFiw[ i i 00iG0iGix[ i i 00iH0iHiy[ i i 00iI0iIiz[ i i 00iJ0iJi{[ i i 00iK0iKi|[ i i 00iL0iLi}[ i i 00iM0iMi~[ i i 00iN0iNi[ i i 00iO0iOi[ i i 00iP0iPi[ i i 00iQ0iQi[ i i 00iR0iRi[ i i 00iS0iSi[ i i 00iT0iTi[ i i 00iU0iUi[ i i 00iV0iVi[ i i 0I" եւ; T000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ i i 00000i[ i i 00000i[ i i 00000i[ ii 00000i"[ i i I" آ; TI" آ; T000i#[ i i I" أ; TI" أ; T000i$[ i i I" ؤ; TI" ؤ; T000i%[ i i I" إ; TI" إ; T000i&[ i i I" ئ; TI" ئ; T000iK[ i i 00000iL[ i!i 00000iM[ i"i 00000iN[ i#i 00000iO[ i$i 00000iP[ i%i 00000iQ[ i&i 00000iR[ i'i 00000iS[ ii 00000iT[ ii 00000iU[ ii 00000ip[ i(i 00000iu[ i i 0I" اٴ; T000iv[ i i 0I" وٴ; T000iw[ i i 0I" ۇٴ; T000ix[ i i 0I" يٴ; T000i[ i i I" ۀ; TI" ۀ; T000i[ i i I" ۂ; TI" ۂ; T000i[ i i I" ۓ; TI" ۓ; T000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ i)i 00000i0[ ii 00000i1[ ii 00000i2[ ii 00000i3[ ii 00000i4[ ii 00000i5[ ii 00000i6[ ii 00000i7[ ii 00000i8[ ii 00000i9[ ii 00000i:[ ii 00000i;[ ii 00000i<[ ii 00000i=[ ii 00000i>[ ii 00000i?[ ii 00000i@[ ii 00000iA[ ii 00000iB[ ii 00000iC[ ii 00000iD[ ii 00000iE[ ii 00000iF[ ii 00000iG[ ii 00000iH[ ii 00000iI[ ii 00000iJ[ ii 00000i) [ i i I" ऩ; TI" ऩ; T000i1 [ i i I" ऱ; TI" ऱ; T000i4 [ i i I" ऴ; TI" ऴ; T000i< [ i i 00000iM [ ii 00000iQ [ ii 00000iR [ ii 00000iS [ ii 00000iT [ ii 00000iX [ i iI" क़; TI" क़; T000iY [ i iI" ख़; TI" ख़; T000iZ [ i iI" ग़; TI" ग़; T000i[ [ i iI" ज़; TI" ज़; T000i\ [ i iI" ड़; TI" ड़; T000i] [ i iI" ढ़; TI" ढ़; T000i^ [ i iI" फ़; TI" फ़; T000i_ [ i iI" य़; TI" य़; T000i [ i i 00000i [ i i I" ো; TI" ো; T000i [ i i I" ৌ; TI" ৌ; T000i [ ii 00000i [ i iI" ড়; TI" ড়; T000i [ i iI" ঢ়; TI" ঢ়; T000i [ i iI" য়; TI" য়; T000i3
[ i iI" ਲ਼; TI" ਲ਼; T000i6
[ i iI" ਸ਼; TI" ਸ਼; T000i<
[ i i 00000iM
[ ii 00000iY
[ i iI" ਖ਼; TI" ਖ਼; T000iZ
[ i iI" ਗ਼; TI" ਗ਼; T000i[
[ i iI" ਜ਼; TI" ਜ਼; T000i^
[ i iI" ਫ਼; TI" ਫ਼; T000i
[ i i 00000i
[ ii 00000i< [ i i 00000iH [ i i I" ୈ; TI" ୈ; T000iK [ i i I" ୋ; TI" ୋ; T000iL [ i i I" ୌ; TI" ୌ; T000iM [ ii 00000i\ [ i iI" ଡ଼; TI" ଡ଼; T000i] [ i iI" ଢ଼; TI" ଢ଼; T000i [ i i I" ஔ; TI" ஔ; T000i [ i i I" ொ; TI" ொ; T000i [ i i I" ோ; TI" ோ; T000i [ i i I" ௌ; TI" ௌ; T000i [ ii 00000iH [ i i I" ై; TI" ై; T000iM [ ii 00000iU [ iYi 00000iV [ i`i 00000i [ i i I" ೀ; TI" ೀ; T000i [ i i I" ೇ; TI" ೇ; T000i [ i i I" ೈ; TI" ೈ; T000i [ i i I" ೊ; TI" ೊ; T000i [ i i I" ೋ; TI" ೋ; T000i [ ii 00000iJ
[ i i I" ൊ; TI" ൊ; T000iK
[ i i I" ോ; TI" ോ; T000iL
[ i i I" ൌ; TI" ൌ; T000iM
[ ii 00000i
[ ii 00000i
[ i i I" ේ; TI" ේ; T000i
[ i i I" ො; TI" ො; T000i
[ i i I" ෝ; TI" ෝ; T000i
[ i i I" ෞ; TI" ෞ; T000i3[ i i 0I" ํา; T000i8[ ili 00000i9[ ili 00000i:[ ii 00000iH[ ipi 00000iI[ ipi 00000iJ[ ipi 00000iK[ ipi 00000i[ i i 0I" ໍາ; T000i[ i{i 00000i[ i{i 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ i i 0I" ຫນ; T000i[ i i 0I" ຫມ; T000i [ i i 0I"་; T000i[ ii 00000i[ ii 00000i5[ ii 00000i7[ ii 00000i9[ ii 00000iC[ i iI" གྷ; TI" གྷ; T000iM[ i iI" ཌྷ; TI" ཌྷ; T000iR[ i iI" དྷ; TI" དྷ; T000iW[ i iI" བྷ; TI" བྷ; T000i\[ i iI" ཛྷ; TI" ཛྷ; T000ii[ i iI" ཀྵ; TI" ཀྵ; T000iq[ ii 00000ir[ ii 00000is[ i iI" ཱི; TI" ཱི; T000it[ ii 00000iu[ i iI" ཱུ; TI" ཱུ; T000iv[ i iI" ྲྀ; TI" ྲྀ; T000iw[ i i 0I" ྲཱྀ; T000ix[ i iI" ླྀ; TI" ླྀ; T000iy[ i i 0I" ླཱྀ; T000iz[ ii 00000i{[ ii 00000i|[ ii 00000i}[ ii 00000i[ ii 00000i[ i iI" ཱྀ; TI" ཱྀ; T000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ ii 00000i[ i iI" ྒྷ; TI" ྒྷ; T000i[ i iI" ྜྷ; TI" ྜྷ; T000i[ i iI" ྡྷ; TI" ྡྷ; T000i[ i iI" ྦྷ; TI" ྦྷ; T000i[ i iI" ྫྷ; TI" ྫྷ; T000i[ i iI" ྐྵ; TI" ྐྵ; T000i[ ii 00000i&[ i i I" ဦ; TI" ဦ; T000i7[ i i 00000i9[ ii 00000i[ ii 00000i[ ii 00000i [ i i I"Ḁ; TI"Ḁ; T0i 0i [ i i I"ḁ; TI"ḁ; Ti 0i i [ i i I"Ḃ; TI"Ḃ; T0i 0i [ i i I"ḃ; TI"ḃ; Ti 0i i [ i i I"Ḅ; TI"Ḅ; T0i 0i [ i i I"ḅ; TI"ḅ; Ti 0i i [ i i I"Ḇ; TI"Ḇ; T0i 0i [ i i I"ḇ; TI"ḇ; Ti 0i i [ i i I" Ḉ; TI" Ḉ; T0i 0i [ i i I" ḉ; TI" ḉ; Ti 0i i
[ i i I"Ḋ; TI"Ḋ; T0i 0i [ i i I"ḋ; TI"ḋ; Ti
0i
i [ i i I"Ḍ; TI"Ḍ; T0i
0i
[ i i I"ḍ; TI"ḍ; Ti 0i i [ i i I"Ḏ; TI"Ḏ; T0i 0i [ i i I"ḏ; TI"ḏ; Ti 0i i [ i i I"Ḑ; TI"Ḑ; T0i 0i [ i i I"ḑ; TI"ḑ; Ti 0i i [ i i I"Ḓ; TI"Ḓ; T0i 0i [ i i I"ḓ; TI"ḓ; Ti 0i i [ i i I" Ḕ; TI" Ḕ; T0i 0i [ i i I" ḕ; TI" ḕ; Ti 0i i [ i i I" Ḗ; TI" Ḗ; T0i 0i [ i i I" ḗ; TI" ḗ; Ti 0i i [ i i I"Ḙ; TI"Ḙ; T0i 0i [ i i I"ḙ; TI"ḙ; Ti 0i i [ i i I"Ḛ; TI"Ḛ; T0i 0i [ i i I"ḛ; TI"ḛ; Ti 0i i [ i i I" Ḝ; TI" Ḝ; T0i 0i [ i i I" ḝ; TI" ḝ; Ti 0i i [ i i I"Ḟ; TI"Ḟ; T0i 0i [ i i I"ḟ; TI"ḟ; Ti 0i i [ i i I"Ḡ; TI"Ḡ; T0i! 0i! [ i i I"ḡ; TI"ḡ; Ti 0i i" [ i i I"Ḣ; TI"Ḣ; T0i# 0i# [ i i I"ḣ; TI"ḣ; Ti" 0i" i$ [ i i I"Ḥ; TI"Ḥ; T0i% 0i% [ i i I"ḥ; TI"ḥ; Ti$ 0i$ i& [ i i I"Ḧ; TI"Ḧ; T0i' 0i' [ i i I"ḧ; TI"ḧ; Ti& 0i& i( [ i i I"Ḩ; TI"Ḩ; T0i) 0i) [ i i I"ḩ; TI"ḩ; Ti( 0i( i* [ i i I"Ḫ; TI"Ḫ; T0i+ 0i+ [ i i I"ḫ; TI"ḫ; Ti* 0i* i, [ i i I"Ḭ; TI"Ḭ; T0i- 0i- [ i i I"ḭ; TI"ḭ; Ti, 0i, i. [ i i I" Ḯ; TI" Ḯ; T0i/ 0i/ [ i i I" ḯ; TI" ḯ; Ti. 0i. i0 [ i i I"Ḱ; TI"Ḱ; T0i1 0i1 [ i i I"ḱ; TI"ḱ; Ti0 0i0 i2 [ i i I"Ḳ; TI"Ḳ; T0i3 0i3 [ i i I"ḳ; TI"ḳ; Ti2 0i2 i4 [ i i I"Ḵ; TI"Ḵ; T0i5 0i5 [ i i I"ḵ; TI"ḵ; Ti4 0i4 i6 [ i i I"Ḷ; TI"Ḷ; T0i7 0i7 [ i i I"ḷ; TI"ḷ; Ti6 0i6 i8 [ i i I"
Ḹ; TI"
Ḹ; T0i9 0i9 [ i i I"
ḹ; TI"
ḹ; Ti8 0i8 i: [ i i I"Ḻ; TI"Ḻ; T0i; 0i; [ i i I"ḻ; TI"ḻ; Ti: 0i: i< [ i i I"Ḽ; TI"Ḽ; T0i= 0i= [ i i I"ḽ; TI"ḽ; Ti< 0i< i> [ i i I"Ḿ; TI"Ḿ; T0i? 0i? [ i i I"ḿ; TI"ḿ; Ti> 0i> i@ [ i i I"Ṁ; TI"Ṁ; T0iA 0iA [ i i I"ṁ; TI"ṁ; Ti@ 0i@ iB [ i i I"Ṃ; TI"Ṃ; T0iC 0iC [ i i I"ṃ; TI"ṃ; TiB 0iB iD [ i i I"Ṅ; TI"Ṅ; T0iE 0iE [ i i I"ṅ; TI"ṅ; TiD 0iD iF [ i i I"Ṇ; TI"Ṇ; T0iG 0iG [ i i I"ṇ; TI"ṇ; TiF 0iF iH [ i i I"Ṉ; TI"Ṉ; T0iI 0iI [ i i I"ṉ; TI"ṉ; TiH 0iH iJ [ i i I"Ṋ; TI"Ṋ; T0iK 0iK [ i i I"ṋ; TI"ṋ; TiJ 0iJ iL [ i i I" Ṍ; TI" Ṍ; T0iM 0iM [ i i I" ṍ; TI" ṍ; TiL 0iL iN [ i i I" Ṏ; TI" Ṏ; T0iO 0iO [ i i I" ṏ; TI" ṏ; TiN 0iN iP [ i i I" Ṑ; TI" Ṑ; T0iQ 0iQ [ i i I" ṑ; TI" ṑ; TiP 0iP iR [ i i I" Ṓ; TI" Ṓ; T0iS 0iS [ i i I" ṓ; TI" ṓ; TiR 0iR iT [ i i I"Ṕ; TI"Ṕ; T0iU 0iU [ i i I"ṕ; TI"ṕ; TiT 0iT iV [ i i I"Ṗ; TI"Ṗ; T0iW 0iW [ i i I"ṗ; TI"ṗ; TiV 0iV iX [ i i I"Ṙ; TI"Ṙ; T0iY 0iY [ i i I"ṙ; TI"ṙ; TiX 0iX iZ [ i i I"Ṛ; TI"Ṛ; T0i[ 0i[ [ i i I"ṛ; TI"ṛ; TiZ 0iZ i\ [ i i I"
Ṝ; TI"
Ṝ; T0i] 0i] [ i i I"
ṝ; TI"
ṝ; Ti\ 0i\ i^ [ i i I"Ṟ; TI"Ṟ; T0i_ 0i_ [ i i I"ṟ; TI"ṟ; Ti^ 0i^ i` [ i i I"Ṡ; TI"Ṡ; T0ia 0ia [ i i I"ṡ; TI"ṡ; Ti` 0i` ib [ i i I"Ṣ; TI"Ṣ; T0ic 0ic [ i i I"ṣ; TI"ṣ; Tib 0ib id [ i i I" Ṥ; TI" Ṥ; T0ie 0ie [ i i I" ṥ; TI" ṥ; Tid 0id if [ i i I" Ṧ; TI" Ṧ; T0ig 0ig [ i i I" ṧ; TI" ṧ; Tif 0if ih [ i i I"
Ṩ; TI"
Ṩ; T0ii 0ii [ i i I"
ṩ; TI"
ṩ; Tih 0ih ij [ i i I"Ṫ; TI"Ṫ; T0ik 0ik [ i i I"ṫ; TI"ṫ; Tij 0ij il [ i i I"Ṭ; TI"Ṭ; T0im 0im [ i i I"ṭ; TI"ṭ; Til 0il in [ i i I"Ṯ; TI"Ṯ; T0io 0io [ i i I"ṯ; TI"ṯ; Tin 0in ip [ i i I"Ṱ; TI"Ṱ; T0iq 0iq [ i i I"ṱ; TI"ṱ; Tip 0ip ir [ i i I"Ṳ; TI"Ṳ; T0is 0is [ i i I"ṳ; TI"ṳ; Tir 0ir it [ i i I"Ṵ; TI"Ṵ; T0iu 0iu [ i i I"ṵ; TI"ṵ; Tit 0it iv [ i i I"Ṷ; TI"Ṷ; T0iw 0iw [ i i I"ṷ; TI"ṷ; Tiv 0iv ix [ i i I" Ṹ; TI" Ṹ; T0iy 0iy [ i i I" ṹ; TI" ṹ; Tix 0ix iz [ i i I" Ṻ; TI" Ṻ; T0i{ 0i{ [ i i I" ṻ; TI" ṻ; Tiz 0iz i| [ i i I"Ṽ; TI"Ṽ; T0i} 0i} [ i i I"ṽ; TI"ṽ; Ti| 0i| i~ [ i i I"Ṿ; TI"Ṿ; T0i 0i [ i i I"ṿ; TI"ṿ; Ti~ 0i~ i [ i i I"Ẁ; TI"Ẁ; T0i 0i [ i i I"ẁ; TI"ẁ; Ti 0i i [ i i I"Ẃ; TI"Ẃ; T0i 0i [ i i I"ẃ; TI"ẃ; Ti 0i i [ i i I"Ẅ; TI"Ẅ; T0i 0i [ i i I"ẅ; TI"ẅ; Ti 0i i [ i i I"Ẇ; TI"Ẇ; T0i 0i [ i i I"ẇ; TI"ẇ; Ti 0i i [ i i I"Ẉ; TI"Ẉ; T0i 0i [ i i I"ẉ; TI"ẉ; Ti 0i i [ i i I"Ẋ; TI"Ẋ; T0i 0i [ i i I"ẋ; TI"ẋ; Ti 0i i [ i i I"Ẍ; TI"Ẍ; T0i 0i [ i i I"ẍ; TI"ẍ; Ti 0i i [ i i I"Ẏ; TI"Ẏ; T0i 0i [ i i I"ẏ; TI"ẏ; Ti 0i i [ i i I"Ẑ; TI"Ẑ; T0i 0i [ i i I"ẑ; TI"ẑ; Ti 0i i [ i i I"Ẓ; TI"Ẓ; T0i 0i [ i i I"ẓ; TI"ẓ; Ti 0i i [ i i I"Ẕ; TI"Ẕ; T0i 0i [ i i I"ẕ; TI"ẕ; Ti 0i i [ i i I"ẖ; TI"ẖ; T000i [ i i I"ẗ; TI"ẗ; T000i [ i i I"ẘ; TI"ẘ; T000i [ i i I"ẙ; TI"ẙ; T000i [ i i 0I"aʾ; T000i [ i i I" ẛ; TI" ẛ; Ti` 0i` i [ i i I"Ạ; TI"Ạ; T0i 0i [ i i I"ạ; TI"ạ; Ti 0i i [ i i I"Ả; TI"Ả; T0i 0i [ i i I"ả; TI"ả; Ti 0i i [ i i I" Ấ; TI" Ấ; T0i 0i [ i i I" ấ; TI" ấ; Ti 0i i [ i i I" Ầ; TI" Ầ; T0i 0i [ i i I" ầ; TI" ầ; Ti 0i i [ i i I" Ẩ; TI" Ẩ; T0i 0i [ i i I" ẩ; TI" ẩ; Ti 0i i [ i i I" Ẫ; TI" Ẫ; T0i 0i [ i i I" ẫ; TI" ẫ; Ti 0i i [ i i I"
Ậ; TI"
Ậ; T0i 0i [ i i I"
ậ; TI"
ậ; Ti 0i i [ i i I" Ắ; TI" Ắ; T0i 0i [ i i I" ắ; TI" ắ; Ti 0i i [ i i I" Ằ; TI" Ằ; T0i 0i [ i i I" ằ; TI" ằ; Ti 0i i [ i i I" Ẳ; TI" Ẳ; T0i 0i [ i i I" ẳ; TI" ẳ; Ti 0i i [ i i I" Ẵ; TI" Ẵ; T0i 0i [ i i I" ẵ; TI" ẵ; Ti 0i i [ i i I"
Ặ; TI"
Ặ; T0i 0i [ i i I"
ặ; TI"
ặ; Ti 0i i [ i i I"Ẹ; TI"Ẹ; T0i 0i [ i i I"ẹ; TI"ẹ; Ti 0i i [ i i I"Ẻ; TI"Ẻ; T0i 0i [ i i I"ẻ; TI"ẻ; Ti 0i i [ i i I"Ẽ; TI"Ẽ; T0i 0i [ i i I"ẽ; TI"ẽ; Ti 0i i [ i i I" Ế; TI" Ế; T0i 0i [ i i I" ế; TI" ế; Ti 0i i [ i i I" Ề; TI" Ề; T0i 0i [ i i I" ề; TI" ề; Ti 0i i [ i i I" Ể; TI" Ể; T0i 0i [ i i I" ể; TI" ể; Ti 0i i [ i i I" Ễ; TI" Ễ; T0i 0i [ i i I" ễ; TI" ễ; Ti 0i i [ i i I"
Ệ; TI"
Ệ; T0i 0i [ i i I"
ệ; TI"
ệ; Ti 0i i [ i i I"Ỉ; TI"Ỉ; T0i 0i [ i i I"ỉ; TI"ỉ; Ti 0i i [ i i I"Ị; TI"Ị; T0i 0i [ i i I"ị; TI"ị; Ti 0i i [ i i I"Ọ; TI"Ọ; T0i 0i [ i i I"ọ; TI"ọ; Ti 0i i [ i i I"Ỏ; TI"Ỏ; T0i 0i [ i i I"ỏ; TI"ỏ; Ti 0i i [ i i I" Ố; TI" Ố; T0i 0i [ i i I" ố; TI" ố; Ti 0i i [ i i I" Ồ; TI" Ồ; T0i 0i [ i i I" ồ; TI" ồ; Ti 0i i [ i i I" Ổ; TI" Ổ; T0i 0i [ i i I" ổ; TI" ổ; Ti 0i i [ i i I" Ỗ; TI" Ỗ; T0i 0i [ i i I" ỗ; TI" ỗ; Ti 0i i [ i i I"
Ộ; TI"
Ộ; T0i 0i [ i i I"
ộ; TI"
ộ; Ti 0i i [ i i I" Ớ; TI" Ớ; T0i 0i [ i i I" ớ; TI" ớ; Ti 0i i [ i i I" Ờ; TI" Ờ; T0i 0i [ i i I" ờ; TI" ờ; Ti 0i i [ i i I" Ở; TI" Ở; T0i 0i [ i i I" ở; TI" ở; Ti 0i i [ i i I" Ỡ; TI" Ỡ; T0i 0i [ i i I" ỡ; TI" ỡ; Ti 0i i [ i i I" Ợ; TI" Ợ; T0i 0i [ i i I" ợ; TI" ợ; Ti 0i i [ i i I"Ụ; TI"Ụ; T0i 0i [ i i I"ụ; TI"ụ; Ti 0i i [ i i I"Ủ; TI"Ủ; T0i 0i [ i i I"ủ; TI"ủ; Ti 0i i [ i i I" Ứ; TI" Ứ; T0i 0i [ i i I" ứ; TI" ứ; Ti 0i i [ i i I" Ừ; TI" Ừ; T0i 0i [ i i I" ừ; TI" ừ; Ti 0i i [ i i I" Ử; TI" Ử; T0i 0i [ i i I" ử; TI" ử; Ti 0i i [ i i I" Ữ; TI" Ữ; T0i 0i [ i i I" ữ; TI" ữ; Ti 0i i [ i i I" Ự; TI" Ự; T0i 0i [ i i I" ự; TI" ự; Ti 0i i [ i i I"Ỳ; TI"Ỳ; T0i 0i [ i i I"ỳ; TI"ỳ; Ti 0i i [ i i I"Ỵ; TI"Ỵ; T0i 0i [ i i I"ỵ; TI"ỵ; Ti 0i i [ i i I"Ỷ; TI"Ỷ; T0i 0i [ i i I"ỷ; TI"ỷ; Ti 0i i [ i i I"Ỹ; TI"Ỹ; T0i 0i [ i i I"ỹ; TI"ỹ; Ti 0i i [ i i I" ἀ; TI" ἀ; Ti 0i i [ i i I" ἁ; TI" ἁ; Ti 0i i [ i i I"
ἂ; TI"
ἂ; Ti
0i
i [ i i I"
ἃ; TI"
ἃ; Ti 0i i [ i i I"
ἄ; TI"
ἄ; Ti 0i i [ i i I"
ἅ; TI"
ἅ; Ti
0i
i [ i i I"
ἆ; TI"
ἆ; Ti 0i i [ i i I"
ἇ; TI"
ἇ; Ti 0i i [ i i I" Ἀ; TI" Ἀ; T0i 0i [ i i I" Ἁ; TI" Ἁ; T0i 0i
[ i i I"
Ἂ; TI"
Ἂ; T0i 0i [ i i I"
Ἃ; TI"
Ἃ; T0i 0i [ i i I"
Ἄ; TI"
Ἄ; T0i 0i
[ i i I"
Ἅ; TI"
Ἅ; T0i 0i [ i i I"
Ἆ; TI"
Ἆ; T0i 0i [ i i I"
Ἇ; TI"
Ἇ; T0i 0i [ i i I" ἐ; TI" ἐ; Ti 0i i [ i i I" ἑ; TI" ἑ; Ti 0i i [ i i I"
ἒ; TI"
ἒ; Ti 0i i [ i i I"
ἓ; TI"
ἓ; Ti 0i i [ i i I"
ἔ; TI"
ἔ; Ti 0i i [ i i I"
ἕ; TI"
ἕ; Ti 0i i [ i i I" Ἐ; TI" Ἐ; T0i 0i [ i i I" Ἑ; TI" Ἑ; T0i 0i [ i i I"
Ἒ; TI"
Ἒ; T0i 0i [ i i I"
Ἓ; TI"
Ἓ; T0i 0i [ i i I"
Ἔ; TI"
Ἔ; T0i 0i [ i i I"
Ἕ; TI"
Ἕ; T0i 0i [ i i I" ἠ; TI" ἠ; Ti( 0i( i! [ i i I" ἡ; TI" ἡ; Ti) 0i) i" [ i i I"
ἢ; TI"
ἢ; Ti* 0i* i# [ i i I"
ἣ; TI"
ἣ; Ti+ 0i+ i$ [ i i I"
ἤ; TI"
ἤ; Ti, 0i, i% [ i i I"
ἥ; TI"
ἥ; Ti- 0i- i& [ i i I"
ἦ; TI"
ἦ; Ti. 0i. i' [ i i I"
ἧ; TI"
ἧ; Ti/ 0i/ i( [ i i I" Ἠ; TI" Ἠ; T0i 0i) [ i i I" Ἡ; TI" Ἡ; T0i! 0i* [ i i I"
Ἢ; TI"
Ἢ; T0i" 0i+ [ i i I"
Ἣ; TI"
Ἣ; T0i# 0i, [ i i I"
Ἤ; TI"
Ἤ; T0i$ 0i- [ i i I"
Ἥ; TI"
Ἥ; T0i% 0i. [ i i I"
Ἦ; TI"
Ἦ; T0i& 0i/ [ i i I"
Ἧ; TI"
Ἧ; T0i' 0i0 [ i i I" ἰ; TI" ἰ; Ti8 0i8 i1 [ i i I" ἱ; TI" ἱ; Ti9 0i9 i2 [ i i I"
ἲ; TI"
ἲ; Ti: 0i: i3 [ i i I"
ἳ; TI"
ἳ; Ti; 0i; i4 [ i i I"
ἴ; TI"
ἴ; Ti< 0i< i5 [ i i I"
ἵ; TI"
ἵ; Ti= 0i= i6 [ i i I"
ἶ; TI"
ἶ; Ti> 0i> i7 [ i i I"
ἷ; TI"
ἷ; Ti? 0i? i8 [ i i I" Ἰ; TI" Ἰ; T0i0 0i9 [ i i I" Ἱ; TI" Ἱ; T0i1 0i: [ i i I"
Ἲ; TI"
Ἲ; T0i2 0i; [ i i I"
Ἳ; TI"
Ἳ; T0i3 0i< [ i i I"
Ἴ; TI"
Ἴ; T0i4 0i= [ i i I"
Ἵ; TI"
Ἵ; T0i5 0i> [ i i I"
Ἶ; TI"
Ἶ; T0i6 0i? [ i i I"
Ἷ; TI"
Ἷ; T0i7 0i@ [ i i I" ὀ; TI" ὀ; TiH 0iH iA [ i i I" ὁ; TI" ὁ; TiI 0iI iB [ i i I"
ὂ; TI"
ὂ; TiJ 0iJ iC [ i i I"
ὃ; TI"
ὃ; TiK 0iK iD [ i i I"
ὄ; TI"
ὄ; TiL 0iL iE [ i i I"
ὅ; TI"
ὅ; TiM 0iM iH [ i i I" Ὀ; TI" Ὀ; T0i@ 0iI [ i i I" Ὁ; TI" Ὁ; T0iA 0iJ [ i i I"
Ὂ; TI"
Ὂ; T0iB 0iK [ i i I"
Ὃ; TI"
Ὃ; T0iC 0iL [ i i I"
Ὄ; TI"
Ὄ; T0iD 0iM [ i i I"
Ὅ; TI"
Ὅ; T0iE 0iP [ i i I" ὐ; TI" ὐ; T000iQ [ i i I" ὑ; TI" ὑ; TiY 0iY iR [ i i I"
ὒ; TI"
ὒ; T000iS [ i i I"
ὓ; TI"
ὓ; Ti[ 0i[ iT [ i i I"
ὔ; TI"
ὔ; T000iU [ i i I"
ὕ; TI"
ὕ; Ti] 0i] iV [ i i I"
ὖ; TI"
ὖ; T000iW [ i i I"
ὗ; TI"
ὗ; Ti_ 0i_ iY [ i i I" Ὑ; TI" Ὑ; T0iQ 0i[ [ i i I"
Ὓ; TI"
Ὓ; T0iS 0i] [ i i I"
Ὕ; TI"
Ὕ; T0iU 0i_ [ i i I"
Ὗ; TI"
Ὗ; T0iW 0i` [ i i I" ὠ; TI" ὠ; Tih 0ih ia [ i i I" ὡ; TI" ὡ; Tii 0ii ib [ i i I"
ὢ; TI"
ὢ; Tij 0ij ic [ i i I"
ὣ; TI"
ὣ; Tik 0ik id [ i i I"
ὤ; TI"
ὤ; Til 0il ie [ i i I"
ὥ; TI"
ὥ; Tim 0im if [ i i I"
ὦ; TI"
ὦ; Tin 0in ig [ i i I"
ὧ; TI"
ὧ; Tio 0io ih [ i i I" Ὠ; TI" Ὠ; T0i` 0ii [ i i I" Ὡ; TI" Ὡ; T0ia 0ij [ i i I"
Ὢ; TI"
Ὢ; T0ib 0ik [ i i I"
Ὣ; TI"
Ὣ; T0ic 0il [ i i I"
Ὤ; TI"
Ὤ; T0id 0im [ i i I"
Ὥ; TI"
Ὥ; T0ie 0in [ i i I"
Ὦ; TI"
Ὦ; T0if 0io [ i i I"
Ὧ; TI"
Ὧ; T0ig 0ip [ i i I" ὰ; TI" ὰ; Ti 0i iq [ i iI"ά; TI"ά; Ti 0i ir [ i i I" ὲ; TI" ὲ; Ti 0i is [ i iI"έ; TI"έ; Ti 0i it [ i i I" ὴ; TI" ὴ; Ti 0i iu [ i iI"ή; TI"ή; Ti 0i iv [ i i I" ὶ; TI" ὶ; Ti 0i iw [ i iI"ί; TI"ί; Ti 0i ix [ i i I" ὸ; TI" ὸ; Ti 0i iy [ i iI"ό; TI"ό; Ti 0i iz [ i i I" ὺ; TI" ὺ; Ti 0i i{ [ i iI"ύ; TI"ύ; Ti 0i i| [ i i I" ὼ; TI" ὼ; Ti 0i i} [ i iI"ώ; TI"ώ; Ti 0i i [ i i I"
ᾀ; TI"
ᾀ; Ti 0i i [ i i I"
ᾁ; TI"
ᾁ; Ti 0i i [ i i I"
ᾂ; TI"
ᾂ; Ti 0i i [ i i I"
ᾃ; TI"
ᾃ; Ti 0i i [ i i I"
ᾄ; TI"
ᾄ; Ti 0i i [ i i I"
ᾅ; TI"
ᾅ; Ti 0i i [ i i I"
ᾆ; TI"
ᾆ; Ti 0i i [ i i I"
ᾇ; TI"
ᾇ; Ti 0i i [ i i I"
ᾈ; TI"
ᾈ; T0i 0i [ i i I"
ᾉ; TI"
ᾉ; T0i 0i [ i i I"
ᾊ; TI"
ᾊ; T0i 0i [ i i I"
ᾋ; TI"
ᾋ; T0i 0i [ i i I"
ᾌ; TI"
ᾌ; T0i 0i [ i i I"
ᾍ; TI"
ᾍ; T0i 0i [ i i I"
ᾎ; TI"
ᾎ; T0i 0i [ i i I"
ᾏ; TI"
ᾏ; T0i 0i [ i i I"
ᾐ; TI"
ᾐ; Ti 0i i [ i i I"
ᾑ; TI"
ᾑ; Ti 0i i [ i i I"
ᾒ; TI"
ᾒ; Ti 0i i [ i i I"
ᾓ; TI"
ᾓ; Ti 0i i [ i i I"
ᾔ; TI"
ᾔ; Ti 0i i [ i i I"
ᾕ; TI"
ᾕ; Ti 0i i [ i i I"
ᾖ; TI"
ᾖ; Ti 0i i [ i i I"
ᾗ; TI"
ᾗ; Ti 0i i [ i i I"
ᾘ; TI"
ᾘ; T0i 0i [ i i I"
ᾙ; TI"
ᾙ; T0i 0i [ i i I"
ᾚ; TI"
ᾚ; T0i 0i [ i i I"
ᾛ; TI"
ᾛ; T0i 0i [ i i I"
ᾜ; TI"
ᾜ; T0i 0i [ i i I"
ᾝ; TI"
ᾝ; T0i 0i [ i i I"
ᾞ; TI"
ᾞ; T0i 0i [ i i I"
ᾟ; TI"
ᾟ; T0i 0i [ i i I"
ᾠ; TI"
ᾠ; Ti 0i i [ i i I"
ᾡ; TI"
ᾡ; Ti 0i i [ i i I"
ᾢ; TI"
ᾢ; Ti 0i i [ i i I"
ᾣ; TI"
ᾣ; Ti 0i i [ i i I"
ᾤ; TI"
ᾤ; Ti 0i i [ i i I"
ᾥ; TI"
ᾥ; Ti 0i i [ i i I"
ᾦ; TI"
ᾦ; Ti 0i i [ i i I"
ᾧ; TI"
ᾧ; Ti 0i i [ i i I"
ᾨ; TI"
ᾨ; T0i 0i [ i i I"
ᾩ; TI"
ᾩ; T0i 0i [ i i I"
ᾪ; TI"
ᾪ; T0i 0i [ i i I"
ᾫ; TI"
ᾫ; T0i 0i [ i i I"
ᾬ; TI"
ᾬ; T0i 0i [ i i I"
ᾭ; TI"
ᾭ; T0i 0i [ i i I"
ᾮ; TI"
ᾮ; T0i 0i [ i i I"
ᾯ; TI"
ᾯ; T0i 0i [ i i I" ᾰ; TI" ᾰ; Ti 0i i [ i i I" ᾱ; TI" ᾱ; Ti 0i i [ i i I"
ᾲ; TI"
ᾲ; T000i [ i i I" ᾳ; TI" ᾳ; Ti 0i i [ i i I" ᾴ; TI" ᾴ; T000i [ i i I" ᾶ; TI" ᾶ; T000i [ i i I"
ᾷ; TI"
ᾷ; T000i [ i i I" Ᾰ; TI" Ᾰ; T0i 0i [ i i I" Ᾱ; TI" Ᾱ; T0i 0i [ i i I" Ὰ; TI" Ὰ; T0ip 0i [ i iI"Ά; TI"Ά; T0iq 0i [ i i I" ᾼ; TI" ᾼ; T0i 0i [ i i 0I" ̓; T000i [ i iI"ι; TI"ι; Ti0ii [ i i 0I" ̓; T000i [ i i 0I" ͂; T000i [ i i I" ῁; TI" ῁; T000i [ i i I"
ῂ; TI"
ῂ; T000i [ i i I" ῃ; TI" ῃ; Ti 0i i [ i i I" ῄ; TI" ῄ; T000i [ i i I" ῆ; TI" ῆ; T000i [ i i I"
ῇ; TI"
ῇ; T000i [ i i I" Ὲ; TI" Ὲ; T0ir 0i [ i iI"Έ; TI"Έ; T0is 0i [ i i I" Ὴ; TI" Ὴ; T0it 0i [ i iI"Ή; TI"Ή; T0iu 0i [ i i I" ῌ; TI" ῌ; T0i 0i [ i i I"
῍; TI"
῍; T000i [ i i I"
῎; TI"
῎; T000i [ i i I"
῏; TI"
῏; T000i [ i i I" ῐ; TI" ῐ; Ti 0i i [ i i I" ῑ; TI" ῑ; Ti 0i i [ i i I" ῒ; TI" ῒ; T000i [ i iI"ΐ; TI"ΐ; T000i [ i i I" ῖ; TI" ῖ; T000i [ i i I" ῗ; TI" ῗ; T000i [ i i I" Ῐ; TI" Ῐ; T0i 0i [ i i I" Ῑ; TI" Ῑ; T0i 0i [ i i I" Ὶ; TI" Ὶ; T0iv 0i [ i iI"Ί; TI"Ί; T0iw 0i [ i i I"
῝; TI"
῝; T000i [ i i I"
῞; TI"
῞; T000i [ i i I"
῟; TI"
῟; T000i [ i i I" ῠ; TI" ῠ; Ti 0i i [ i i I" ῡ; TI" ῡ; Ti 0i i [ i i I" ῢ; TI" ῢ; T000i [ i iI"ΰ; TI"ΰ; T000i [ i i I" ῤ; TI" ῤ; T000i [ i i I" ῥ; TI" ῥ; Ti 0i i [ i i I" ῦ; TI" ῦ; T000i [ i i I" ῧ; TI" ῧ; T000i [ i i I" Ῠ; TI" Ῠ; T0i 0i [ i i I" Ῡ; TI" Ῡ; T0i 0i [ i i I" Ὺ; TI" Ὺ; T0iz 0i [ i iI"Ύ; TI"Ύ; T0i{ 0i [ i i I" Ῥ; TI" Ῥ; T0i 0i [ i i I" ῭; TI" ῭; T000i [ i iI"΅; TI"΅; T000i [ i iI"`; TI"`; T000i [ i i I"
ῲ; TI"
ῲ; T000i [ i i I" ῳ; TI" ῳ; Ti 0i i [ i i I" ῴ; TI" ῴ; T000i [ i i I" ῶ; TI" ῶ; T000i [ i i I"
ῷ; TI"
ῷ; T000i [ i i I" Ὸ; TI" Ὸ; T0ix 0i [ i iI"Ό; TI"Ό; T0iy 0i [ i i I" Ὼ; TI" Ὼ; T0i| 0i [ i iI"Ώ; TI"Ώ; T0i} 0i [ i i I" ῼ; TI" ῼ; T0i 0i [ i iI"´; TI"´; T000i [ i i 0I" ̔; T000i [ i iI" ; TI" ; T000i [ i iI" ; TI" ; T000i [ i i 0I" ; T000i [ i i 0I" ; T000i [ i i 0I" ; T000i [ i i 0I" ; T000i [ i i 0I" ; T000i [ i i 0I" ; T000i [ i i 0I" ; T000i [ i i 0I" ; T000i
[ i i 0I" ; T000i [ i i 0I"‐; T000i [ i i 0I" ̳; T000i$ [ i i 0I".; T000i% [ i i 0I"..; T000i& [ i i 0I"...; T000i/ [ i i 0I" ; T000i3 [ i i 0I" ′′; T000i4 [ i i 0I"′′′; T000i6 [ i i 0I" ‵‵; T000i7 [ i i 0I"‵‵‵; T000i< [ i i 0I"!!; T000i> [ i i 0I" ̅; T000iH [ i i 0I"?!; T000iI [ i i 0I"!?; T000ip [ i i 0I"0; T000it [ i i 0I"4; T000iu [ i i 0I"5; T000iv [ i i 0I"6; T000iw [ i i 0I"7; T000ix [ i i 0I"8; T000iy [ i i 0I"9; T000iz [ i i 0I"+; T000i{ [ i i 0I"−; T000i| [ i i 0I"=; T000i} [ i i 0I"(; T000i~ [ i i 0I"); T000i [ i i 0I"n; T000i [ i i 0I"0; T000i [ i i 0I"1; T000i [ i i 0I"2; T000i [ i i 0I"3; T000i [ i i 0I"4; T000i [ i i 0I"5; T000i [ i i 0I"6; T000i [ i i 0I"7; T000i [ i i 0I"8; T000i [ i i 0I"9; T000i [ i i 0I"+; T000i [ i i 0I"−; T000i [ i i 0I"=; T000i [ i i 0I"(; T000i [ i i 0I"); T000i [ i i 0I"Rs; T000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i [ ii 00000i ![ i i 0I"a/c; T000i![ i i 0I"a/s; T000i![ i i 0I"C; T000i![ i i 0I"°C; T000i![ i i 0I"c/o; T000i![ i i 0I"c/u; T000i![ i i 0I"Ɛ; T000i ![ i i 0I"°F; T000i
![ i i 0I"g; T000i ![ i i 0I"H; T000i ![ i i 0I"H; T000i
![ i i 0I"H; T000i![ i i 0I"h; T000i![ i i 0I"ħ; T000i![ i i 0I"I; T000i![ i i 0I"I; T000i![ i i 0I"L; T000i![ i i 0I"l; T000i![ i i 0I"N; T000i![ i i 0I"No; T000i![ i i 0I"P; T000i![ i i 0I"Q; T000i![ i i 0I"R; T000i ![ i i 0I"R; T000i ![ i i 0I"R; T000i ![ i i 0I"SM; T000i!![ i i 0I"TEL; T000i"![ i i 0I"TM; T000i$![ i i 0I"Z; T000i&![ i iI"Ω; TI"Ω; T0i0i(![ i i 0I"Z; T000i*![ i iI"K; TI"K; T0ip0i+![ i iI"Å; TI"Å; T0i0i,![ i i 0I"B; T000i-![ i i 0I"C; T000i/![ i i 0I"e; T000i0![ i i 0I"E; T000i1![ i i 0I"F; T000i3![ i i 0I"M; T000i4![ i i 0I"o; T000i5![ i i 0I"א; T000i6![ i i 0I"ב; T000i7![ i i 0I"ג; T000i8![ i i 0I"ד; T000i9![ i i 0I"i; T000iS![ i i 0I"
1⁄3; T000iT![ i i 0I"
2⁄3; T000iU![ i i 0I"
1⁄5; T000iV![ i i 0I"
2⁄5; T000iW![ i i 0I"
3⁄5; T000iX![ i i 0I"
4⁄5; T000iY![ i i 0I"
1⁄6; T000iZ![ i i 0I"
5⁄6; T000i[![ i i 0I"
1⁄8; T000i\![ i i 0I"
3⁄8; T000i]![ i i 0I"
5⁄8; T000i^![ i i 0I"
7⁄8; T000i_![ i i 0I" 1⁄; T000i`![ i i 0I"I; T0ip!0ia![ i i 0I"II; T0iq!0ib![ i i 0I"III; T0ir!0ic![ i i 0I"IV; T0is!0id![ i i 0I"V; T0it!0ie![ i i 0I"VI; T0iu!0if![ i i 0I"VII; T0iv!0ig![ i i 0I" VIII; T0iw!0ih![ i i 0I"IX; T0ix!0ii![ i i 0I"X; T0iy!0ij![ i i 0I"XI; T0iz!0ik![ i i 0I"XII; T0i{!0il![ i i 0I"L; T0i|!0im![ i i 0I"C; T0i}!0in![ i i 0I"D; T0i~!0io![ i i 0I"M; T0i!0ip![ i i 0I"i; Ti`!0i`!iq![ i i 0I"ii; Tia!0ia!ir![ i i 0I"iii; Tib!0ib!is![ i i 0I"iv; Tic!0ic!it![ i i 0I"v; Tid!0id!iu![ i i 0I"vi; Tie!0ie!iv![ i i 0I"vii; Tif!0if!iw![ i i 0I" viii; Tig!0ig!ix![ i i 0I"ix; Tih!0ih!iy![ i i 0I"x; Tii!0ii!iz![ i i 0I"xi; Tij!0ij!i{![ i i 0I"xii; Tik!0ik!i|![ i i 0I"l; Til!0il!i}![ i i 0I"c; Tim!0im!i~![ i i 0I"d; Tin!0in!i![ i i 0I"m; Tio!0io!i![ i i I"
↚; TI"
↚; T000i![ i i I"
↛; TI"
↛; T000i![ i i I"
↮; TI"
↮; T000i![ i i I"
⇍; TI"
⇍; T000i![ i i I"
⇎; TI"
⇎; T000i![ i i I"
⇏; TI"
⇏; T000i"[ i i I"
∄; TI"
∄; T000i "[ i i I"
∉; TI"
∉; T000i "[ i i I"
∌; TI"
∌; T000i$"[ i i I"
∤; TI"
∤; T000i&"[ i i I"
∦; TI"
∦; T000i,"[ i i 0I" ∫∫; T000i-"[ i i 0I"∫∫∫; T000i/"[ i i 0I" ∮∮; T000i0"[ i i 0I"∮∮∮; T000iA"[ i i I"
≁; TI"
≁; T000iD"[ i i I"
≄; TI"
≄; T000iG"[ i i I"
≇; TI"
≇; T000iI"[ i i I"
≉; TI"
≉; T000i`"[ i i I"≠; TI"≠; T000ib"[ i i I"
≢; TI"
≢; T000im"[ i i I"
≭; TI"
≭; T000in"[ i i I"≮; TI"≮; T000io"[ i i I"≯; TI"≯; T000ip"[ i i I"
≰; TI"
≰; T000iq"[ i i I"
≱; TI"
≱; T000it"[ i i I"
≴; TI"
≴; T000iu"[ i i I"
≵; TI"
≵; T000ix"[ i i I"
≸; TI"
≸; T000iy"[ i i I"
≹; TI"
≹; T000i"[ i i I"
⊀; TI"
⊀; T000i"[ i i I"
⊁; TI"
⊁; T000i"[ i i I"
⊄; TI"
⊄; T000i"[ i i I"
⊅; TI"
⊅; T000i"[ i i I"
⊈; TI"
⊈; T000i"[ i i I"
⊉; TI"
⊉; T000i"[ i i I"
⊬; TI"
⊬; T000i"[ i i I"
⊭; TI"
⊭; T000i"[ i i I"
⊮; TI"
⊮; T000i"[ i i I"
⊯; TI"
⊯; T000i"[ i i I"
⋠; TI"
⋠; T000i"[ i i I"
⋡; TI"
⋡; T000i"[ i i I"
⋢; TI"
⋢; T000i"[ i i I"
⋣; TI"
⋣; T000i"[ i i I"
⋪; TI"
⋪; T000i"[ i i I"
⋫; TI"
⋫; T000i"[ i i I"
⋬; TI"
⋬; T000i"[ i i I"
⋭; TI"
⋭; T000i)#[ i iI"〈; TI"〈; T000i*#[ i iI"〉; TI"〉; T000i`$[ i i 0I"1; T000ia$[ i i 0I"2; T000ib$[ i i 0I"3; T000ic$[ i i 0I"4; T000id$[ i i 0I"5; T000ie$[ i i 0I"6; T000if$[ i i 0I"7; T000ig$[ i i 0I"8; T000ih$[ i i 0I"9; T000ii$[ i i 0I"10; T000ij$[ i i 0I"11; T000ik$[ i i 0I"12; T000il$[ i i 0I"13; T000im$[ i i 0I"14; T000in$[ i i 0I"15; T000io$[ i i 0I"16; T000ip$[ i i 0I"17; T000iq$[ i i 0I"18; T000ir$[ i i 0I"19; T000is$[ i i 0I"20; T000it$[ i i 0I"(1); T000iu$[ i i 0I"(2); T000iv$[ i i 0I"(3); T000iw$[ i i 0I"(4); T000ix$[ i i 0I"(5); T000iy$[ i i 0I"(6); T000iz$[ i i 0I"(7); T000i{$[ i i 0I"(8); T000i|$[ i i 0I"(9); T000i}$[ i i 0I" (10); T000i~$[ i i 0I" (11); T000i$[ i i 0I" (12); T000i$[ i i 0I" (13); T000i$[ i i 0I" (14); T000i$[ i i 0I" (15); T000i$[ i i 0I" (16); T000i$[ i i 0I" (17); T000i$[ i i 0I" (18); T000i$[ i i 0I" (19); T000i$[ i i 0I" (20); T000i$[ i i 0I"1.; T000i$[ i i 0I"2.; T000i$[ i i 0I"3.; T000i$[ i i 0I"4.; T000i$[ i i 0I"5.; T000i$[ i i 0I"6.; T000i$[ i i 0I"7.; T000i$[ i i 0I"8.; T000i$[ i i 0I"9.; T000i$[ i i 0I"10.; T000i$[ i i 0I"11.; T000i$[ i i 0I"12.; T000i$[ i i 0I"13.; T000i$[ i i 0I"14.; T000i$[ i i 0I"15.; T000i$[ i i 0I"16.; T000i$[ i i 0I"17.; T000i$[ i i 0I"18.; T000i$[ i i 0I"19.; T000i$[ i i 0I"20.; T000i$[ i i 0I"(a); T000i$[ i i 0I"(b); T000i$[ i i 0I"(c); T000i$[ i i 0I"(d); T000i$[ i i 0I"(e); T000i$[ i i 0I"(f); T000i$[ i i 0I"(g); T000i$[ i i 0I"(h); T000i$[ i i 0I"(i); T000i$[ i i 0I"(j); T000i$[ i i 0I"(k); T000i$[ i i 0I"(l); T000i$[ i i 0I"(m); T000i$[ i i 0I"(n); T000i$[ i i 0I"(o); T000i$[ i i 0I"(p); T000i$[ i i 0I"(q); T000i$[ i i 0I"(r); T000i$[ i i 0I"(s); T000i$[ i i 0I"(t); T000i$[ i i 0I"(u); T000i$[ i i 0I"(v); T000i$[ i i 0I"(w); T000i$[ i i 0I"(x); T000i$[ i i 0I"(y); T000i$[ i i 0I"(z); T000i$[ i i 0I"A; T0i$0i$[ i i 0I"B; T0i$0i$[ i i 0I"C; T0i$0i$[ i i 0I"D; T0i$0i$[ i i 0I"E; T0i$0i$[ i i 0I"F; T0i$0i$[ i i 0I"G; T0i$0i$[ i i 0I"H; T0i$0i$[ i i 0I"I; T0i$0i$[ i i 0I"J; T0i$0i$[ i i 0I"K; T0i$0i$[ i i 0I"L; T0i$0i$[ i i 0I"M; T0i$0i$[ i i 0I"N; T0i$0i$[ i i 0I"O; T0i$0i$[ i i 0I"P; T0i$0i$[ i i 0I"Q; T0i$0i$[ i i 0I"R; T0i$0i$[ i i 0I"S; T0i$0i$[ i i 0I"T; T0i$0i$[ i i 0I"U; T0i$0i$[ i i 0I"V; T0i$0i$[ i i 0I"W; T0i$0i$[ i i 0I"X; T0i$0i$[ i i 0I"Y; T0i$0i$[ i i 0I"Z; T0i$0i$[ i i 0I"a; Ti$0i$i$[ i i 0I"b; Ti$0i$i$[ i i 0I"c; Ti$0i$i$[ i i 0I"d; Ti$0i$i$[ i i 0I"e; Ti$0i$i$[ i i 0I"f; Ti$0i$i$[ i i 0I"g; Ti$0i$i$[ i i 0I"h; Ti$0i$i$[ i i 0I"i; Ti$0i$i$[ i i 0I"j; Ti$0i$i$[ i i 0I"k; Ti$0i$i$[ i i 0I"l; Ti$0i$i$[ i i 0I"m; Ti$0i$i$[ i i 0I"n; Ti$0i$i$[ i i 0I"o; Ti$0i$i$[ i i 0I"p; Ti$0i$i$[ i i 0I"q; Ti$0i$i$[ i i 0I"r; Ti$0i$i$[ i i 0I"s; Ti$0i$i$[ i i 0I"t; Ti$0i$i$[ i i 0I"u; Ti$0i$i$[ i i 0I"v; Ti$0i$i$[ i i 0I"w; Ti$0i$i$[ i i 0I"x; Ti$0i$i$[ i i 0I"y; Ti$0i$i$[ i i 0I"z; Ti$0i$i$[ i i 0I"0; T000i.[ i i 0I"母; T000i.[ i i 0I"龟; T000i /[ i i 0I"一; T000i/[ i i 0I"丨; T000i/[ i i 0I"丶; T000i/[ i i 0I"丿; T000i/[ i i 0I"乙; T000i/[ i i 0I"亅; T000i/[ i i 0I"二; T000i/[ i i 0I"亠; T000i/[ i i 0I"人; T000i /[ i i 0I"儿; T000i
/[ i i 0I"入; T000i /[ i i 0I"八; T000i /[ i i 0I"冂; T000i
/[ i i 0I"冖; T000i/[ i i 0I"冫; T000i/[ i i 0I"几; T000i/[ i i 0I"凵; T000i/[ i i 0I"刀; T000i/[ i i 0I"力; T000i/[ i i 0I"勹; T000i/[ i i 0I"匕; T000i/[ i i 0I"匚; T000i/[ i i 0I"匸; T000i/[ i i 0I"十; T000i/[ i i 0I"卜; T000i/[ i i 0I"卩; T000i/[ i i 0I"厂; T000i/[ i i 0I"厶; T000i /[ i i 0I"又; T000i /[ i i 0I"口; T000i /[ i i 0I"囗; T000i /[ i i 0I"土; T000i /[ i i 0I"士; T000i!/[ i i 0I"夂; T000i"/[ i i 0I"夊; T000i#/[ i i 0I"夕; T000i$/[ i i 0I"大; T000i%/[ i i 0I"女; T000i&/[ i i 0I"子; T000i'/[ i i 0I"宀; T000i(/[ i i 0I"寸; T000i)/[ i i 0I"小; T000i*/[ i i 0I"尢; T000i+/[ i i 0I"尸; T000i,/[ i i 0I"屮; T000i-/[ i i 0I"山; T000i./[ i i 0I"巛; T000i//[ i i 0I"工; T000i0/[ i i 0I"己; T000i1/[ i i 0I"巾; T000i2/[ i i 0I"干; T000i3/[ i i 0I"幺; T000i4/[ i i 0I"广; T000i5/[ i i 0I"廴; T000i6/[ i i 0I"廾; T000i7/[ i i 0I"弋; T000i8/[ i i 0I"弓; T000i9/[ i i 0I"彐; T000i:/[ i i 0I"彡; T000i;/[ i i 0I"彳; T000i/[ i i 0I"戶; T000i?/[ i i 0I"手; T000i@/[ i i 0I"支; T000iA/[ i i 0I"攴; T000iB/[ i i 0I"文; T000iC/[ i i 0I"斗; T000iD/[ i i 0I"斤; T000iE/[ i i 0I"方; T000iF/[ i i 0I"无; T000iG/[ i i 0I"日; T000iH/[ i i 0I"曰; T000iI/[ i i 0I"月; T000iJ/[ i i 0I"木; T000iK/[ i i 0I"欠; T000iL/[ i i 0I"止; T000iM/[ i i 0I"歹; T000iN/[ i i 0I"殳; T000iO/[ i i 0I"毋; T000iP/[ i i 0I"比; T000iQ/[ i i 0I"毛; T000iR/[ i i 0I"氏; T000iS/[ i i 0I"气; T000iT/[ i i 0I"水; T000iU/[ i i 0I"火; T000iV/[ i i 0I"爪; T000iW/[ i i 0I"父; T000iX/[ i i 0I"爻; T000iY/[ i i 0I"爿; T000iZ/[ i i 0I"片; T000i[/[ i i 0I"牙; T000i\/[ i i 0I"牛; T000i]/[ i i 0I"犬; T000i^/[ i i 0I"玄; T000i_/[ i i 0I"玉; T000i`/[ i i 0I"瓜; T000ia/[ i i 0I"瓦; T000ib/[ i i 0I"甘; T000ic/[ i i 0I"生; T000id/[ i i 0I"用; T000ie/[ i i 0I"田; T000if/[ i i 0I"疋; T000ig/[ i i 0I"疒; T000ih/[ i i 0I"癶; T000ii/[ i i 0I"白; T000ij/[ i i 0I"皮; T000ik/[ i i 0I"皿; T000il/[ i i 0I"目; T000im/[ i i 0I"矛; T000in/[ i i 0I"矢; T000io/[ i i 0I"石; T000ip/[ i i 0I"示; T000iq/[ i i 0I"禸; T000ir/[ i i 0I"禾; T000is/[ i i 0I"穴; T000it/[ i i 0I"立; T000iu/[ i i 0I"竹; T000iv/[ i i 0I"米; T000iw/[ i i 0I"糸; T000ix/[ i i 0I"缶; T000iy/[ i i 0I"网; T000iz/[ i i 0I"羊; T000i{/[ i i 0I"羽; T000i|/[ i i 0I"老; T000i}/[ i i 0I"而; T000i~/[ i i 0I"耒; T000i/[ i i 0I"耳; T000i/[ i i 0I"聿; T000i/[ i i 0I"肉; T000i/[ i i 0I"臣; T000i/[ i i 0I"自; T000i/[ i i 0I"至; T000i/[ i i 0I"臼; T000i/[ i i 0I"舌; T000i/[ i i 0I"舛; T000i/[ i i 0I"舟; T000i/[ i i 0I"艮; T000i/[ i i 0I"色; T000i/[ i i 0I"艸; T000i/[ i i 0I"虍; T000i/[ i i 0I"虫; T000i/[ i i 0I"血; T000i/[ i i 0I"行; T000i/[ i i 0I"衣; T000i/[ i i 0I"襾; T000i/[ i i 0I"見; T000i/[ i i 0I"角; T000i/[ i i 0I"言; T000i/[ i i 0I"谷; T000i/[ i i 0I"豆; T000i/[ i i 0I"豕; T000i/[ i i 0I"豸; T000i/[ i i 0I"貝; T000i/[ i i 0I"赤; T000i/[ i i 0I"走; T000i/[ i i 0I"足; T000i/[ i i 0I"身; T000i/[ i i 0I"車; T000i/[ i i 0I"辛; T000i/[ i i 0I"辰; T000i/[ i i 0I"辵; T000i/[ i i 0I"邑; T000i/[ i i 0I"酉; T000i/[ i i 0I"釆; T000i/[ i i 0I"里; T000i/[ i i 0I"金; T000i/[ i i 0I"長; T000i/[ i i 0I"門; T000i/[ i i 0I"阜; T000i/[ i i 0I"隶; T000i/[ i i 0I"隹; T000i/[ i i 0I"雨; T000i/[ i i 0I"靑; T000i/[ i i 0I"非; T000i/[ i i 0I"面; T000i/[ i i 0I"革; T000i/[ i i 0I"韋; T000i/[ i i 0I"韭; T000i/[ i i 0I"音; T000i/[ i i 0I"頁; T000i/[ i i 0I"風; T000i/[ i i 0I"飛; T000i/[ i i 0I"食; T000i/[ i i 0I"首; T000i/[ i i 0I"香; T000i/[ i i 0I"馬; T000i/[ i i 0I"骨; T000i/[ i i 0I"高; T000i/[ i i 0I"髟; T000i/[ i i 0I"鬥; T000i/[ i i 0I"鬯; T000i/[ i i 0I"鬲; T000i/[ i i 0I"鬼; T000i/[ i i 0I"魚; T000i/[ i i 0I"鳥; T000i/[ i i 0I"鹵; T000i/[ i i 0I"鹿; T000i/[ i i 0I"麥; T000i/[ i i 0I"麻; T000i/[ i i 0I"黃; T000i/[ i i 0I"黍; T000i/[ i i 0I"黑; T000i/[ i i 0I"黹; T000i/[ i i 0I"黽; T000i/[ i i 0I"鼎; T000i/[ i i 0I"鼓; T000i/[ i i 0I"鼠; T000i/[ i i 0I"鼻; T000i/[ i i 0I"齊; T000i/[ i i 0I"齒; T000i/[ i i 0I"龍; T000i/[ i i 0I"龜; T000i/[ i i 0I"龠; T000i 0[ i i 0I" ; T000i*0[ ii 00000i+0[ ii 00000i,0[ ii 00000i-0[ ii 00000i.0[ ii 00000i/0[ ii 00000i60[ i i 0I"〒; T000i80[ i i 0I"十; T000i90[ i i 0I"卄; T000i:0[ i i 0I"卅; T000iL0[ i i I" が; TI" が; T000iN0[ i i I" ぎ; TI" ぎ; T000iP0[ i i I" ぐ; TI" ぐ; T000iR0[ i i I" げ; TI" げ; T000iT0[ i i I" ご; TI" ご; T000iV0[ i i I" ざ; TI" ざ; T000iX0[ i i I" じ; TI" じ; T000iZ0[ i i I" ず; TI" ず; T000i\0[ i i I" ぜ; TI" ぜ; T000i^0[ i i I" ぞ; TI" ぞ; T000i`0[ i i I" だ; TI" だ; T000ib0[ i i I" ぢ; TI" ぢ; T000ie0[ i i I" づ; TI" づ; T000ig0[ i i I" で; TI" で; T000ii0[ i i I" ど; TI" ど; T000ip0[ i i I" ば; TI" ば; T000iq0[ i i I" ぱ; TI" ぱ; T000is0[ i i I" び; TI" び; T000it0[ i i I" ぴ; TI" ぴ; T000iv0[ i i I" ぶ; TI" ぶ; T000iw0[ i i I" ぷ; TI" ぷ; T000iy0[ i i I" べ; TI" べ; T000iz0[ i i I" ぺ; TI" ぺ; T000i|0[ i i I" ぼ; TI" ぼ; T000i}0[ i i I" ぽ; TI" ぽ; T000i0[ i i I" ゔ; TI" ゔ; T000i0[ i
i 00000i0[ i
i 00000i0[ i i 0I" ゙; T000i0[ i i 0I" ゚; T000i0[ i i I" ゞ; TI" ゞ; T000i0[ i i I" ガ; TI" ガ; T000i0[ i i I" ギ; TI" ギ; T000i0[ i i I" グ; TI" グ; T000i0[ i i I" ゲ; TI" ゲ; T000i0[ i i I" ゴ; TI" ゴ; T000i0[ i i I" ザ; TI" ザ; T000i0[ i i I" ジ; TI" ジ; T000i0[ i i I" ズ; TI" ズ; T000i0[ i i I" ゼ; TI" ゼ; T000i0[ i i I" ゾ; TI" ゾ; T000i0[ i i I" ダ; TI" ダ; T000i0[ i i I" ヂ; TI" ヂ; T000i0[ i i I" ヅ; TI" ヅ; T000i0[ i i I" デ; TI" デ; T000i0[ i i I" ド; TI" ド; T000i0[ i i I" バ; TI" バ; T000i0[ i i I" パ; TI" パ; T000i0[ i i I" ビ; TI" ビ; T000i0[ i i I" ピ; TI" ピ; T000i0[ i i I" ブ; TI" ブ; T000i0[ i i I" プ; TI" プ; T000i0[ i i I" ベ; TI" ベ; T000i0[ i i I" ペ; TI" ペ; T000i0[ i i I" ボ; TI" ボ; T000i0[ i i I" ポ; TI" ポ; T000i0[ i i I" ヴ; TI" ヴ; T000i0[ i i I" ヷ; TI" ヷ; T000i0[ i i I" ヸ; TI" ヸ; T000i0[ i i I" ヹ; TI" ヹ; T000i0[ i i I" ヺ; TI" ヺ; T000i0[ i i I" ヾ; TI" ヾ; T000i11[ i i 0I"ᄀ; T000i21[ i i 0I"ᄁ; T000i31[ i i 0I"ᆪ; T000i41[ i i 0I"ᄂ; T000i51[ i i 0I"ᆬ; T000i61[ i i 0I"ᆭ; T000i71[ i i 0I"ᄃ; T000i81[ i i 0I"ᄄ; T000i91[ i i 0I"ᄅ; T000i:1[ i i 0I"ᆰ; T000i;1[ i i 0I"ᆱ; T000i<1[ i i 0I"ᆲ; T000i=1[ i i 0I"ᆳ; T000i>1[ i i 0I"ᆴ; T000i?1[ i i 0I"ᆵ; T000i@1[ i i 0I"ᄚ; T000iA1[ i i 0I"ᄆ; T000iB1[ i i 0I"ᄇ; T000iC1[ i i 0I"ᄈ; T000iD1[ i i 0I"ᄡ; T000iE1[ i i 0I"ᄉ; T000iF1[ i i 0I"ᄊ; T000iG1[ i i 0I"ᄋ; T000iH1[ i i 0I"ᄌ; T000iI1[ i i 0I"ᄍ; T000iJ1[ i i 0I"ᄎ; T000iK1[ i i 0I"ᄏ; T000iL1[ i i 0I"ᄐ; T000iM1[ i i 0I"ᄑ; T000iN1[ i i 0I"ᄒ; T000iO1[ i i 0I"ᅡ; T000iP1[ i i 0I"ᅢ; T000iQ1[ i i 0I"ᅣ; T000iR1[ i i 0I"ᅤ; T000iS1[ i i 0I"ᅥ; T000iT1[ i i 0I"ᅦ; T000iU1[ i i 0I"ᅧ; T000iV1[ i i 0I"ᅨ; T000iW1[ i i 0I"ᅩ; T000iX1[ i i 0I"ᅪ; T000iY1[ i i 0I"ᅫ; T000iZ1[ i i 0I"ᅬ; T000i[1[ i i 0I"ᅭ; T000i\1[ i i 0I"ᅮ; T000i]1[ i i 0I"ᅯ; T000i^1[ i i 0I"ᅰ; T000i_1[ i i 0I"ᅱ; T000i`1[ i i 0I"ᅲ; T000ia1[ i i 0I"ᅳ; T000ib1[ i i 0I"ᅴ; T000ic1[ i i 0I"ᅵ; T000id1[ i i 0I"ᅠ; T000ie1[ i i 0I"ᄔ; T000if1[ i i 0I"ᄕ; T000ig1[ i i 0I"ᇇ; T000ih1[ i i 0I"ᇈ; T000ii1[ i i 0I"ᇌ; T000ij1[ i i 0I"ᇎ; T000ik1[ i i 0I"ᇓ; T000il1[ i i 0I"ᇗ; T000im1[ i i 0I"ᇙ; T000in1[ i i 0I"ᄜ; T000io1[ i i 0I"ᇝ; T000ip1[ i i 0I"ᇟ; T000iq1[ i i 0I"ᄝ; T000ir1[ i i 0I"ᄞ; T000is1[ i i 0I"ᄠ; T000it1[ i i 0I"ᄢ; T000iu1[ i i 0I"ᄣ; T000iv1[ i i 0I"ᄧ; T000iw1[ i i 0I"ᄩ; T000ix1[ i i 0I"ᄫ; T000iy1[ i i 0I"ᄬ; T000iz1[ i i 0I"ᄭ; T000i{1[ i i 0I"ᄮ; T000i|1[ i i 0I"ᄯ; T000i}1[ i i 0I"ᄲ; T000i~1[ i i 0I"ᄶ; T000i1[ i i 0I"ᅀ; T000i1[ i i 0I"ᅇ; T000i1[ i i 0I"ᅌ; T000i1[ i i 0I"ᇱ; T000i1[ i i 0I"ᇲ; T000i1[ i i 0I"ᅗ; T000i1[ i i 0I"ᅘ; T000i1[ i i 0I"ᅙ; T000i1[ i i 0I"ᆄ; T000i1[ i i 0I"ᆅ; T000i1[ i i 0I"ᆈ; T000i1[ i i 0I"ᆑ; T000i1[ i i 0I"ᆒ; T000i1[ i i 0I"ᆔ; T000i1[ i i 0I"ᆞ; T000i1[ i i 0I"ᆡ; T000i1[ i i 0I"一; T000i1[ i i 0I"二; T000i1[ i i 0I"三; T000i1[ i i 0I"四; T000i1[ i i 0I"上; T000i1[ i i 0I"中; T000i1[ i i 0I"下; T000i1[ i i 0I"甲; T000i1[ i i 0I"乙; T000i1[ i i 0I"丙; T000i1[ i i 0I"丁; T000i1[ i i 0I"天; T000i1[ i i 0I"地; T000i1[ i i 0I"人; T000i 2[ i i 0I"
(ᄀ); T000i2[ i i 0I"
(ᄂ); T000i2[ i i 0I"
(ᄃ); T000i2[ i i 0I"
(ᄅ); T000i2[ i i 0I"
(ᄆ); T000i2[ i i 0I"
(ᄇ); T000i2[ i i 0I"
(ᄉ); T000i2[ i i 0I"
(ᄋ); T000i2[ i i 0I"
(ᄌ); T000i 2[ i i 0I"
(ᄎ); T000i
2[ i i 0I"
(ᄏ); T000i 2[ i i 0I"
(ᄐ); T000i 2[ i i 0I"
(ᄑ); T000i
2[ i i 0I"
(ᄒ); T000i2[ i i 0I"
(가); T000i2[ i i 0I"
(나); T000i2[ i i 0I"
(다); T000i2[ i i 0I"
(라); T000i2[ i i 0I"
(마); T000i2[ i i 0I"
(바); T000i2[ i i 0I"
(사); T000i2[ i i 0I"
(아); T000i2[ i i 0I"
(자); T000i2[ i i 0I"
(차); T000i2[ i i 0I"
(카); T000i2[ i i 0I"
(타); T000i2[ i i 0I"
(파); T000i2[ i i 0I"
(하); T000i 2[ i i 0I"
(주); T000i 2[ i i 0I"
(一); T000i!2[ i i 0I"
(二); T000i"2[ i i 0I"
(三); T000i#2[ i i 0I"
(四); T000i$2[ i i 0I"
(五); T000i%2[ i i 0I"
(六); T000i&2[ i i 0I"
(七); T000i'2[ i i 0I"
(八); T000i(2[ i i 0I"
(九); T000i)2[ i i 0I"
(十); T000i*2[ i i 0I"
(月); T000i+2[ i i 0I"
(火); T000i,2[ i i 0I"
(水); T000i-2[ i i 0I"
(木); T000i.2[ i i 0I"
(金); T000i/2[ i i 0I"
(土); T000i02[ i i 0I"
(日); T000i12[ i i 0I"
(株); T000i22[ i i 0I"
(有); T000i32[ i i 0I"
(社); T000i42[ i i 0I"
(名); T000i52[ i i 0I"
(特); T000i62[ i i 0I"
(財); T000i72[ i i 0I"
(祝); T000i82[ i i 0I"
(労); T000i92[ i i 0I"
(代); T000i:2[ i i 0I"
(呼); T000i;2[ i i 0I"
(学); T000i<2[ i i 0I"
(監); T000i=2[ i i 0I"
(企); T000i>2[ i i 0I"
(資); T000i?2[ i i 0I"
(協); T000i@2[ i i 0I"
(祭); T000iA2[ i i 0I"
(休); T000iB2[ i i 0I"
(自); T000iC2[ i i 0I"
(至); T000i`2[ i i 0I"ᄀ; T000ia2[ i i 0I"ᄂ; T000ib2[ i i 0I"ᄃ; T000ic2[ i i 0I"ᄅ; T000id2[ i i 0I"ᄆ; T000ie2[ i i 0I"ᄇ; T000if2[ i i 0I"ᄉ; T000ig2[ i i 0I"ᄋ; T000ih2[ i i 0I"ᄌ; T000ii2[ i i 0I"ᄎ; T000ij2[ i i 0I"ᄏ; T000ik2[ i i 0I"ᄐ; T000il2[ i i 0I"ᄑ; T000im2[ i i 0I"ᄒ; T000in2[ i i 0I" 가; T000io2[ i i 0I" 나; T000ip2[ i i 0I" 다; T000iq2[ i i 0I" 라; T000ir2[ i i 0I" 마; T000is2[ i i 0I" 바; T000it2[ i i 0I" 사; T000iu2[ i i 0I" 아; T000iv2[ i i 0I" 자; T000iw2[ i i 0I" 차; T000ix2[ i i 0I" 카; T000iy2[ i i 0I" 타; T000iz2[ i i 0I" 파; T000i{2[ i i 0I" 하; T000i2[ i i 0I"一; T000i2[ i i 0I"二; T000i2[ i i 0I"三; T000i2[ i i 0I"四; T000i2[ i i 0I"五; T000i2[ i i 0I"六; T000i2[ i i 0I"七; T000i2[ i i 0I"八; T000i2[ i i 0I"九; T000i2[ i i 0I"十; T000i2[ i i 0I"月; T000i2[ i i 0I"火; T000i2[ i i 0I"水; T000i2[ i i 0I"木; T000i2[ i i 0I"金; T000i2[ i i 0I"土; T000i2[ i i 0I"日; T000i2[ i i 0I"株; T000i2[ i i 0I"有; T000i2[ i i 0I"社; T000i2[ i i 0I"名; T000i2[ i i 0I"特; T000i2[ i i 0I"財; T000i2[ i i 0I"祝; T000i2[ i i 0I"労; T000i2[ i i 0I"秘; T000i2[ i i 0I"男; T000i2[ i i 0I"女; T000i2[ i i 0I"適; T000i2[ i i 0I"優; T000i2[ i i 0I"印; T000i2[ i i 0I"注; T000i2[ i i 0I"項; T000i2[ i i 0I"休; T000i2[ i i 0I"写; T000i2[ i i 0I"正; T000i2[ i i 0I"上; T000i2[ i i 0I"中; T000i2[ i i 0I"下; T000i2[ i i 0I"左; T000i2[ i i 0I"右; T000i2[ i i 0I"医; T000i2[ i i 0I"宗; T000i2[ i i 0I"学; T000i2[ i i 0I"監; T000i2[ i i 0I"企; T000i2[ i i 0I"資; T000i2[ i i 0I"協; T000i2[ i i 0I"夜; T000i2[ i i 0I" 1月; T000i2[ i i 0I" 2月; T000i2[ i i 0I" 3月; T000i2[ i i 0I" 4月; T000i2[ i i 0I" 5月; T000i2[ i i 0I" 6月; T000i2[ i i 0I" 7月; T000i2[ i i 0I" 8月; T000i2[ i i 0I" 9月; T000i2[ i i 0I"
10月; T000i2[ i i 0I"
11月; T000i2[ i i 0I"
12月; T000i2[ i i 0I"ア; T000i2[ i i 0I"イ; T000i2[ i i 0I"ウ; T000i2[ i i 0I"エ; T000i2[ i i 0I"オ; T000i2[ i i 0I"カ; T000i2[ i i 0I"キ; T000i2[ i i 0I"ク; T000i2[ i i 0I"ケ; T000i2[ i i 0I"コ; T000i2[ i i 0I"サ; T000i2[ i i 0I"シ; T000i2[ i i 0I"ス; T000i2[ i i 0I"セ; T000i2[ i i 0I"ソ; T000i2[ i i 0I"タ; T000i2[ i i 0I"チ; T000i2[ i i 0I"ツ; T000i2[ i i 0I"テ; T000i2[ i i 0I"ト; T000i2[ i i 0I"ナ; T000i2[ i i 0I"ニ; T000i2[ i i 0I"ヌ; T000i2[ i i 0I"ネ; T000i2[ i i 0I"ノ; T000i2[ i i 0I"ハ; T000i2[ i i 0I"ヒ; T000i2[ i i 0I"フ; T000i2[ i i 0I"ヘ; T000i2[ i i 0I"ホ; T000i2[ i i 0I"マ; T000i2[ i i 0I"ミ; T000i2[ i i 0I"ム; T000i2[ i i 0I"メ; T000i2[ i i 0I"モ; T000i2[ i i 0I"ヤ; T000i2[ i i 0I"ユ; T000i2[ i i 0I"ヨ; T000i2[ i i 0I"ラ; T000i2[ i i 0I"リ; T000i2[ i i 0I"ル; T000i2[ i i 0I"レ; T000i2[ i i 0I"ロ; T000i2[ i i 0I"ワ; T000i2[ i i 0I"ヰ; T000i2[ i i 0I"ヱ; T000i2[ i i 0I"ヲ; T000i 3[ i i 0I"アパート; T000i3[ i i 0I"アルファ; T000i3[ i i 0I"アンペア; T000i3[ i i 0I"アール; T000i3[ i i 0I"イニング; T000i3[ i i 0I"インチ; T000i3[ i i 0I"ウォン; T000i3[ i i 0I"エスクード; T000i3[ i i 0I"エーカー; T000i 3[ i i 0I"オンス; T000i
3[ i i 0I"オーム; T000i 3[ i i 0I"カイリ; T000i 3[ i i 0I"カラット; T000i
3[ i i 0I"カロリー; T000i3[ i i 0I"ガロン; T000i3[ i i 0I"ガンマ; T000i3[ i i 0I" ギガ; T000i3[ i i 0I"ギニー; T000i3[ i i 0I"キュリー; T000i3[ i i 0I"ギルダー; T000i3[ i i 0I" キロ; T000i3[ i i 0I"キログラム; T000i3[ i i 0I"キロメートル; T000i3[ i i 0I"キロワット; T000i3[ i i 0I"グラム; T000i3[ i i 0I"グラムトン; T000i3[ i i 0I"クルゼイロ; T000i3[ i i 0I"クローネ; T000i 3[ i i 0I"ケース; T000i 3[ i i 0I"コルナ; T000i 3[ i i 0I"コーポ; T000i 3[ i i 0I"サイクル; T000i 3[ i i 0I"サンチーム; T000i!3[ i i 0I"シリング; T000i"3[ i i 0I"センチ; T000i#3[ i i 0I"セント; T000i$3[ i i 0I"ダース; T000i%3[ i i 0I" デシ; T000i&3[ i i 0I" ドル; T000i'3[ i i 0I" トン; T000i(3[ i i 0I" ナノ; T000i)3[ i i 0I"ノット; T000i*3[ i i 0I"ハイツ; T000i+3[ i i 0I"パーセント; T000i,3[ i i 0I"パーツ; T000i-3[ i i 0I"バーレル; T000i.3[ i i 0I"ピアストル; T000i/3[ i i 0I"ピクル; T000i03[ i i 0I" ピコ; T000i13[ i i 0I" ビル; T000i23[ i i 0I"ファラッド; T000i33[ i i 0I"フィート; T000i43[ i i 0I"ブッシェル; T000i53[ i i 0I"フラン; T000i63[ i i 0I"ヘクタール; T000i73[ i i 0I" ペソ; T000i83[ i i 0I"ペニヒ; T000i93[ i i 0I"ヘルツ; T000i:3[ i i 0I"ペンス; T000i;3[ i i 0I"ページ; T000i<3[ i i 0I"ベータ; T000i=3[ i i 0I"ポイント; T000i>3[ i i 0I"ボルト; T000i?3[ i i 0I" ホン; T000i@3[ i i 0I"ポンド; T000iA3[ i i 0I"ホール; T000iB3[ i i 0I"ホーン; T000iC3[ i i 0I"マイクロ; T000iD3[ i i 0I"マイル; T000iE3[ i i 0I"マッハ; T000iF3[ i i 0I"マルク; T000iG3[ i i 0I"マンション; T000iH3[ i i 0I"ミクロン; T000iI3[ i i 0I" ミリ; T000iJ3[ i i 0I"ミリバール; T000iK3[ i i 0I" メガ; T000iL3[ i i 0I"メガトン; T000iM3[ i i 0I"メートル; T000iN3[ i i 0I"ヤード; T000iO3[ i i 0I"ヤール; T000iP3[ i i 0I"ユアン; T000iQ3[ i i 0I"リットル; T000iR3[ i i 0I" リラ; T000iS3[ i i 0I"ルピー; T000iT3[ i i 0I"ルーブル; T000iU3[ i i 0I" レム; T000iV3[ i i 0I"レントゲン; T000iW3[ i i 0I"ワット; T000iX3[ i i 0I" 0点; T000iY3[ i i 0I" 1点; T000iZ3[ i i 0I" 2点; T000i[3[ i i 0I" 3点; T000i\3[ i i 0I" 4点; T000i]3[ i i 0I" 5点; T000i^3[ i i 0I" 6点; T000i_3[ i i 0I" 7点; T000i`3[ i i 0I" 8点; T000ia3[ i i 0I" 9点; T000ib3[ i i 0I"
10点; T000ic3[ i i 0I"
11点; T000id3[ i i 0I"
12点; T000ie3[ i i 0I"
13点; T000if3[ i i 0I"
14点; T000ig3[ i i 0I"
15点; T000ih3[ i i 0I"
16点; T000ii3[ i i 0I"
17点; T000ij3[ i i 0I"
18点; T000ik3[ i i 0I"
19点; T000il3[ i i 0I"
20点; T000im3[ i i 0I"
21点; T000in3[ i i 0I"
22点; T000io3[ i i 0I"
23点; T000ip3[ i i 0I"
24点; T000iq3[ i i 0I"hPa; T000ir3[ i i 0I"da; T000is3[ i i 0I"AU; T000it3[ i i 0I"bar; T000iu3[ i i 0I"oV; T000iv3[ i i 0I"pc; T000i{3[ i i 0I" 平成; T000i|3[ i i 0I" 昭和; T000i}3[ i i 0I" 大正; T000i~3[ i i 0I" 明治; T000i3[ i i 0I"株式会社; T000i3[ i i 0I"pA; T000i3[ i i 0I"nA; T000i3[ i i 0I"μA; T000i3[ i i 0I"mA; T000i3[ i i 0I"kA; T000i3[ i i 0I"KB; T000i3[ i i 0I"MB; T000i3[ i i 0I"GB; T000i3[ i i 0I"cal; T000i3[ i i 0I" kcal; T000i3[ i i 0I"pF; T000i3[ i i 0I"nF; T000i3[ i i 0I"μF; T000i3[ i i 0I"μg; T000i3[ i i 0I"mg; T000i3[ i i 0I"kg; T000i3[ i i 0I"Hz; T000i3[ i i 0I"kHz; T000i3[ i i 0I"MHz; T000i3[ i i 0I"GHz; T000i3[ i i 0I"THz; T000i3[ i i 0I"
μℓ; T000i3[ i i 0I" mℓ; T000i3[ i i 0I" dℓ; T000i3[ i i 0I" kℓ; T000i3[ i i 0I"fm; T000i3[ i i 0I"nm; T000i3[ i i 0I"μm; T000i3[ i i 0I"mm; T000i3[ i i 0I"cm; T000i3[ i i 0I"km; T000i3[ i i 0I" mm²; T000i3[ i i 0I" cm²; T000i3[ i i 0I"m²; T000i3[ i i 0I" km²; T000i3[ i i 0I" mm³; T000i3[ i i 0I" cm³; T000i3[ i i 0I"m³; T000i3[ i i 0I" km³; T000i3[ i i 0I"
m∕s; T000i3[ i i 0I" m∕s²; T000i3[ i i 0I"Pa; T000i3[ i i 0I"kPa; T000i3[ i i 0I"MPa; T000i3[ i i 0I"GPa; T000i3[ i i 0I"rad; T000i3[ i i 0I" rad∕s; T000i3[ i i 0I"rad∕s²; T000i3[ i i 0I"ps; T000i3[ i i 0I"ns; T000i3[ i i 0I"μs; T000i3[ i i 0I"ms; T000i3[ i i 0I"pV; T000i3[ i i 0I"nV; T000i3[ i i 0I"μV; T000i3[ i i 0I"mV; T000i3[ i i 0I"kV; T000i3[ i i 0I"MV; T000i3[ i i 0I"pW; T000i3[ i i 0I"nW; T000i3[ i i 0I"μW; T000i3[ i i 0I"mW; T000i3[ i i 0I"kW; T000i3[ i i 0I"MW; T000i3[ i i 0I"kΩ; T000i3[ i i 0I"MΩ; T000i3[ i i 0I" a.m.; T000i3[ i i 0I"Bq; T000i3[ i i 0I"cc; T000i3[ i i 0I"cd; T000i3[ i i 0I" C∕kg; T000i3[ i i 0I"Co.; T000i3[ i i 0I"dB; T000i3[ i i 0I"Gy; T000i3[ i i 0I"ha; T000i3[ i i 0I"HP; T000i3[ i i 0I"in; T000i3[ i i 0I"KK; T000i3[ i i 0I"KM; T000i3[ i i 0I"kt; T000i3[ i i 0I"lm; T000i3[ i i 0I"ln; T000i3[ i i 0I"log; T000i3[ i i 0I"lx; T000i3[ i i 0I"mb; T000i3[ i i 0I"mil; T000i3[ i i 0I"mol; T000i3[ i i 0I"PH; T000i3[ i i 0I" p.m.; T000i3[ i i 0I"PPM; T000i3[ i i 0I"PR; T000i3[ i i 0I"sr; T000i3[ i i 0I"Sv; T000i3[ i i 0I"Wb; T000i3[ i i 0I" 1日; T000i3[ i i 0I" 2日; T000i3[ i i 0I" 3日; T000i3[ i i 0I" 4日; T000i3[ i i 0I" 5日; T000i3[ i i 0I" 6日; T000i3[ i i 0I" 7日; T000i3[ i i 0I" 8日; T000i3[ i i 0I" 9日; T000i3[ i i 0I"
10日; T000i3[ i i 0I"
11日; T000i3[ i i 0I"
12日; T000i3[ i i 0I"
13日; T000i3[ i i 0I"
14日; T000i3[ i i 0I"
15日; T000i3[ i i 0I"
16日; T000i3[ i i 0I"
17日; T000i3[ i i 0I"
18日; T000i3[ i i 0I"
19日; T000i3[ i i 0I"
20日; T000i3[ i i 0I"
21日; T000i3[ i i 0I"
22日; T000i3[ i i 0I"
23日; T000i3[ i i 0I"
24日; T000i3[ i i 0I"
25日; T000i3[ i i 0I"
26日; T000i3[ i i 0I"
27日; T000i3[ i i 0I"
28日; T000i3[ i i 0I"
29日; T000i3[ i i 0I"
30日; T000i3[ i i 0I"
31日; T000i [ i iI"豈; TI"豈; T000i[ i iI"更; TI"更; T000i[ i iI"車; TI"車; T000i[ i iI"賈; TI"賈; T000i[ i iI"滑; TI"滑; T000i[ i iI"串; TI"串; T000i[ i iI"句; TI"句; T000i[ i iI"龜; TI"龜; T000i[ i iI"龜; TI"龜; T000i [ i iI"契; TI"契; T000i
[ i iI"金; TI"金; T000i [ i iI"喇; TI"喇; T000i [ i iI"奈; TI"奈; T000i
[ i iI"懶; TI"懶; T000i[ i iI"癩; TI"癩; T000i[ i iI"羅; TI"羅; T000i[ i iI"蘿; TI"蘿; T000i[ i iI"螺; TI"螺; T000i[ i iI"裸; TI"裸; T000i[ i iI"邏; TI"邏; T000i[ i iI"樂; TI"樂; T000i[ i iI"洛; TI"洛; T000i[ i iI"烙; TI"烙; T000i[ i iI"珞; TI"珞; T000i[ i iI"落; TI"落; T000i[ i iI"酪; TI"酪; T000i[ i iI"駱; TI"駱; T000i[ i iI"亂; TI"亂; T000i [ i iI"卵; TI"卵; T000i [ i iI"欄; TI"欄; T000i [ i iI"爛; TI"爛; T000i [ i iI"蘭; TI"蘭; T000i [ i iI"鸞; TI"鸞; T000i![ i iI"嵐; TI"嵐; T000i"[ i iI"濫; TI"濫; T000i#[ i iI"藍; TI"藍; T000i$[ i iI"襤; TI"襤; T000i%[ i iI"拉; TI"拉; T000i&[ i iI"臘; TI"臘; T000i'[ i iI"蠟; TI"蠟; T000i([ i iI"廊; TI"廊; T000i)[ i iI"朗; TI"朗; T000i*[ i iI"浪; TI"浪; T000i+[ i iI"狼; TI"狼; T000i,[ i iI"郎; TI"郎; T000i-[ i iI"來; TI"來; T000i.[ i iI"冷; TI"冷; T000i/[ i iI"勞; TI"勞; T000i0[ i iI"擄; TI"擄; T000i1[ i iI"櫓; TI"櫓; T000i2[ i iI"爐; TI"爐; T000i3[ i iI"盧; TI"盧; T000i4[ i iI"老; TI"老; T000i5[ i iI"蘆; TI"蘆; T000i6[ i iI"虜; TI"虜; T000i7[ i iI"路; TI"路; T000i8[ i iI"露; TI"露; T000i9[ i iI"魯; TI"魯; T000i:[ i iI"鷺; TI"鷺; T000i;[ i iI"碌; TI"碌; T000i<[ i iI"祿; TI"祿; T000i=[ i iI"綠; TI"綠; T000i>[ i iI"菉; TI"菉; T000i?[ i iI"錄; TI"錄; T000i@[ i iI"鹿; TI"鹿; T000iA[ i iI"論; TI"論; T000iB[ i iI"壟; TI"壟; T000iC[ i iI"弄; TI"弄; T000iD[ i iI"籠; TI"籠; T000iE[ i iI"聾; TI"聾; T000iF[ i iI"牢; TI"牢; T000iG[ i iI"磊; TI"磊; T000iH[ i iI"賂; TI"賂; T000iI[ i iI"雷; TI"雷; T000iJ[ i iI"壘; TI"壘; T000iK[ i iI"屢; TI"屢; T000iL[ i iI"樓; TI"樓; T000iM[ i iI"淚; TI"淚; T000iN[ i iI"漏; TI"漏; T000iO[ i iI"累; TI"累; T000iP[ i iI"縷; TI"縷; T000iQ[ i iI"電; TI"電; T000iR[ i iI"勒; TI"勒; T000iS[ i iI"肋; TI"肋; T000iT[ i iI"凜; TI"凜; T000iU[ i iI"凌; TI"凌; T000iV[ i iI"稜; TI"稜; T000iW[ i iI"綾; TI"綾; T000iX[ i iI"菱; TI"菱; T000iY[ i iI"陵; TI"陵; T000iZ[ i iI"讀; TI"讀; T000i[[ i iI"拏; TI"拏; T000i\[ i iI"樂; TI"樂; T000i][ i iI"諾; TI"諾; T000i^[ i iI"丹; TI"丹; T000i_[ i iI"寧; TI"寧; T000i`[ i iI"怒; TI"怒; T000ia[ i iI"率; TI"率; T000ib[ i iI"異; TI"異; T000ic[ i iI"北; TI"北; T000id[ i iI"磻; TI"磻; T000ie[ i iI"便; TI"便; T000if[ i iI"復; TI"復; T000ig[ i iI"不; TI"不; T000ih[ i iI"泌; TI"泌; T000ii[ i iI"數; TI"數; T000ij[ i iI"索; TI"索; T000ik[ i iI"參; TI"參; T000il[ i iI"塞; TI"塞; T000im[ i iI"省; TI"省; T000in[ i iI"葉; TI"葉; T000io[ i iI"說; TI"說; T000ip[ i iI"殺; TI"殺; T000iq[ i iI"辰; TI"辰; T000ir[ i iI"沈; TI"沈; T000is[ i iI"拾; TI"拾; T000it[ i iI"若; TI"若; T000iu[ i iI"掠; TI"掠; T000iv[ i iI"略; TI"略; T000iw[ i iI"亮; TI"亮; T000ix[ i iI"兩; TI"兩; T000iy[ i iI"凉; TI"凉; T000iz[ i iI"梁; TI"梁; T000i{[ i iI"糧; TI"糧; T000i|[ i iI"良; TI"良; T000i}[ i iI"諒; TI"諒; T000i~[ i iI"量; TI"量; T000i[ i iI"勵; TI"勵; T000i[ i iI"呂; TI"呂; T000i[ i iI"女; TI"女; T000i[ i iI"廬; TI"廬; T000i[ i iI"旅; TI"旅; T000i[ i iI"濾; TI"濾; T000i[ i iI"礪; TI"礪; T000i[ i iI"閭; TI"閭; T000i[ i iI"驪; TI"驪; T000i[ i iI"麗; TI"麗; T000i[ i iI"黎; TI"黎; T000i[ i iI"力; TI"力; T000i[ i iI"曆; TI"曆; T000i[ i iI"歷; TI"歷; T000i[ i iI"轢; TI"轢; T000i[ i iI"年; TI"年; T000i[ i iI"憐; TI"憐; T000i[ i iI"戀; TI"戀; T000i[ i iI"撚; TI"撚; T000i[ i iI"漣; TI"漣; T000i[ i iI"煉; TI"煉; T000i[ i iI"璉; TI"璉; T000i[ i iI"秊; TI"秊; T000i[ i iI"練; TI"練; T000i[ i iI"聯; TI"聯; T000i[ i iI"輦; TI"輦; T000i[ i iI"蓮; TI"蓮; T000i[ i iI"連; TI"連; T000i[ i iI"鍊; TI"鍊; T000i[ i iI"列; TI"列; T000i[ i iI"劣; TI"劣; T000i[ i iI"咽; TI"咽; T000i[ i iI"烈; TI"烈; T000i[ i iI"裂; TI"裂; T000i[ i iI"說; TI"說; T000i[ i iI"廉; TI"廉; T000i[ i iI"念; TI"念; T000i[ i iI"捻; TI"捻; T000i[ i iI"殮; TI"殮; T000i[ i iI"簾; TI"簾; T000i[ i iI"獵; TI"獵; T000i[ i iI"令; TI"令; T000i[ i iI"囹; TI"囹; T000i[ i iI"寧; TI"寧; T000i[ i iI"嶺; TI"嶺; T000i[ i iI"怜; TI"怜; T000i[ i iI"玲; TI"玲; T000i[ i iI"瑩; TI"瑩; T000i[ i iI"羚; TI"羚; T000i[ i iI"聆; TI"聆; T000i[ i iI"鈴; TI"鈴; T000i[ i iI"零; TI"零; T000i[ i iI"靈; TI"靈; T000i[ i iI"領; TI"領; T000i[ i iI"例; TI"例; T000i[ i iI"禮; TI"禮; T000i[ i iI"醴; TI"醴; T000i[ i iI"隸; TI"隸; T000i[ i iI"惡; TI"惡; T000i[ i iI"了; TI"了; T000i[ i iI"僚; TI"僚; T000i[ i iI"寮; TI"寮; T000i[ i iI"尿; TI"尿; T000i[ i iI"料; TI"料; T000i[ i iI"樂; TI"樂; T000i[ i iI"燎; TI"燎; T000i[ i iI"療; TI"療; T000i[ i iI"蓼; TI"蓼; T000i[ i iI"遼; TI"遼; T000i[ i iI"龍; TI"龍; T000i[ i iI"暈; TI"暈; T000i[ i iI"阮; TI"阮; T000i[ i iI"劉; TI"劉; T000i[ i iI"杻; TI"杻; T000i[ i iI"柳; TI"柳; T000i[ i iI"流; TI"流; T000i[ i iI"溜; TI"溜; T000i[ i iI"琉; TI"琉; T000i[ i iI"留; TI"留; T000i[ i iI"硫; TI"硫; T000i[ i iI"紐; TI"紐; T000i[ i iI"類; TI"類; T000i[ i iI"六; TI"六; T000i[ i iI"戮; TI"戮; T000i[ i iI"陸; TI"陸; T000i[ i iI"倫; TI"倫; T000i[ i iI"崙; TI"崙; T000i[ i iI"淪; TI"淪; T000i[ i iI"輪; TI"輪; T000i[ i iI"律; TI"律; T000i[ i iI"慄; TI"慄; T000i[ i iI"栗; TI"栗; T000i[ i iI"率; TI"率; T000i[ i iI"隆; TI"隆; T000i[ i iI"利; TI"利; T000i[ i iI"吏; TI"吏; T000i[ i iI"履; TI"履; T000i[ i iI"易; TI"易; T000i[ i iI"李; TI"李; T000i[ i iI"梨; TI"梨; T000i[ i iI"泥; TI"泥; T000i[ i iI"理; TI"理; T000i[ i iI"痢; TI"痢; T000i[ i iI"罹; TI"罹; T000i[ i iI"裏; TI"裏; T000i[ i iI"裡; TI"裡; T000i[ i iI"里; TI"里; T000i[ i iI"離; TI"離; T000i[ i iI"匿; TI"匿; T000i[ i iI"溺; TI"溺; T000i[ i iI"吝; TI"吝; T000i[ i iI"燐; TI"燐; T000i[ i iI"璘; TI"璘; T000i[ i iI"藺; TI"藺; T000i[ i iI"隣; TI"隣; T000i[ i iI"鱗; TI"鱗; T000i[ i iI"麟; TI"麟; T000i[ i iI"林; TI"林; T000i[ i iI"淋; TI"淋; T000i[ i iI"臨; TI"臨; T000i[ i iI"立; TI"立; T000i[ i iI"笠; TI"笠; T000i[ i iI"粒; TI"粒; T000i[ i iI"狀; TI"狀; T000i[ i iI"炙; TI"炙; T000i[ i iI"識; TI"識; T000i[ i iI"什; TI"什; T000i[ i iI"茶; TI"茶; T000i[ i iI"刺; TI"刺; T000i [ i iI"切; TI"切; T000i[ i iI"度; TI"度; T000i[ i iI"拓; TI"拓; T000i[ i iI"糖; TI"糖; T000i[ i iI"宅; TI"宅; T000i[ i iI"洞; TI"洞; T000i[ i iI"暴; TI"暴; T000i[ i iI"輻; TI"輻; T000i[ i iI"行; TI"行; T000i [ i iI"降; TI"降; T000i
[ i iI"見; TI"見; T000i [ i iI"廓; TI"廓; T000i [ i iI"兀; TI"兀; T000i
[ i iI"嗀; TI"嗀; T000i[ i iI"塚; TI"塚; T000i[ i iI"晴; TI"晴; T000i[ i iI"凞; TI"凞; T000i[ i iI"猪; TI"猪; T000i[ i iI"益; TI"益; T000i[ i iI"礼; TI"礼; T000i[ i iI"神; TI"神; T000i[ i iI"祥; TI"祥; T000i[ i iI"福; TI"福; T000i [ i iI"靖; TI"靖; T000i [ i iI"精; TI"精; T000i [ i iI"羽; TI"羽; T000i [ i iI"蘒; TI"蘒; T000i"[ i iI"諸; TI"諸; T000i%[ i iI"逸; TI"逸; T000i&[ i iI"都; TI"都; T000i*[ i iI"飯; TI"飯; T000i+[ i iI"飼; TI"飼; T000i,[ i iI"館; TI"館; T000i-[ i iI"鶴; TI"鶴; T000i [ i i 0I"ff; T000i[ i i 0I"fi; T000i[ i i 0I"fl; T000i[ i i 0I"ffi; T000i[ i i 0I"ffl; T000i[ i i 0I"ſt; T000i[ i i 0I"st; T000i[ i i 0I" մն; T000i[ i i 0I" մե; T000i[ i i 0I" մի; T000i[ i i 0I" վն; T000i[ i i 0I" մխ; T000i [ i i I" יִ; TI" יִ; T000i [ i i 00000i [ i iI" ײַ; TI" ײַ; T000i [ i i 0I"ע; T000i![ i i 0I"א; T000i"[ i i 0I"ד; T000i#[ i i 0I"ה; T000i$[ i i 0I"כ; T000i%[ i i 0I"ל; T000i&[ i i 0I"ם; T000i'[ i i 0I"ר; T000i([ i i 0I"ת; T000i)[ i i 0I"+; T000i*[ i iI" שׁ; TI" שׁ; T000i+[ i iI" שׂ; TI" שׂ; T000i,[ i iI"
שּׁ; TI"
שּׁ; T000i-[ i iI"
שּׂ; TI"
שּׂ; T000i.[ i iI" אַ; TI" אַ; T000i/[ i iI" אָ; TI" אָ; T000i0[ i iI" אּ; TI" אּ; T000i1[ i iI" בּ; TI" בּ; T000i2[ i iI" גּ; TI" גּ; T000i3[ i iI" דּ; TI" דּ; T000i4[ i iI" הּ; TI" הּ; T000i5[ i iI" וּ; TI" וּ; T000i6[ i iI" זּ; TI" זּ; T000i8[ i iI" טּ; TI" טּ; T000i9[ i iI" יּ; TI" יּ; T000i:[ i iI" ךּ; TI" ךּ; T000i;[ i iI" כּ; TI" כּ; T000i<[ i iI" לּ; TI" לּ; T000i>[ i iI" מּ; TI" מּ; T000i@[ i iI" נּ; TI" נּ; T000iA[ i iI" סּ; TI" סּ; T000iC[ i iI" ףּ; TI" ףּ; T000iD[ i iI" פּ; TI" פּ; T000iF[ i iI" צּ; TI" צּ; T000iG[ i iI" קּ; TI" קּ; T000iH[ i iI" רּ; TI" רּ; T000iI[ i iI" שּ; TI" שּ; T000iJ[ i iI" תּ; TI" תּ; T000iK[ i iI" וֹ; TI" וֹ; T000iL[ i iI" בֿ; TI" בֿ; T000iM[ i iI" כֿ; TI" כֿ; T000iN[ i iI" פֿ; TI" פֿ; T000iO[ i i 0I" אל; T000iP[ i i 0I"ٱ; T000iQ[ i i 0I"ٱ; T000iR[ i i 0I"ٻ; T000iS[ i i 0I"ٻ; T000iT[ i i 0I"ٻ; T000iU[ i i 0I"ٻ; T000iV[ i i 0I"پ; T000iW[ i i 0I"پ; T000iX[ i i 0I"پ; T000iY[ i i 0I"پ; T000iZ[ i i 0I"ڀ; T000i[[ i i 0I"ڀ; T000i\[ i i 0I"ڀ; T000i][ i i 0I"ڀ; T000i^[ i i 0I"ٺ; T000i_[ i i 0I"ٺ; T000i`[ i i 0I"ٺ; T000ia[ i i 0I"ٺ; T000ib[ i i 0I"ٿ; T000ic[ i i 0I"ٿ; T000id[ i i 0I"ٿ; T000ie[ i i 0I"ٿ; T000if[ i i 0I"ٹ; T000ig[ i i 0I"ٹ; T000ih[ i i 0I"ٹ; T000ii[ i i 0I"ٹ; T000ij[ i i 0I"ڤ; T000ik[ i i 0I"ڤ; T000il[ i i 0I"ڤ; T000im[ i i 0I"ڤ; T000in[ i i 0I"ڦ; T000io[ i i 0I"ڦ; T000ip[ i i 0I"ڦ; T000iq[ i i 0I"ڦ; T000ir[ i i 0I"ڄ; T000is[ i i 0I"ڄ; T000it[ i i 0I"ڄ; T000iu[ i i 0I"ڄ; T000iv[ i i 0I"ڃ; T000iw[ i i 0I"ڃ; T000ix[ i i 0I"ڃ; T000iy[ i i 0I"ڃ; T000iz[ i i 0I"چ; T000i{[ i i 0I"چ; T000i|[ i i 0I"چ; T000i}[ i i 0I"چ; T000i~[ i i 0I"ڇ; T000i[ i i 0I"ڇ; T000i[ i i 0I"ڇ; T000i[ i i 0I"ڇ; T000i[ i i 0I"ڍ; T000i[ i i 0I"ڍ; T000i[ i i 0I"ڌ; T000i[ i i 0I"ڌ; T000i[ i i 0I"ڎ; T000i[ i i 0I"ڎ; T000i[ i i 0I"ڈ; T000i[ i i 0I"ڈ; T000i[ i i 0I"ژ; T000i[ i i 0I"ژ; T000i[ i i 0I"ڑ; T000i[ i i 0I"ڑ; T000i[ i i 0I"ک; T000i[ i i 0I"ک; T000i[ i i 0I"ک; T000i[ i i 0I"ک; T000i[ i i 0I"گ; T000i[ i i 0I"گ; T000i[ i i 0I"گ; T000i[ i i 0I"گ; T000i[ i i 0I"ڳ; T000i[ i i 0I"ڳ; T000i[ i i 0I"ڳ; T000i[ i i 0I"ڳ; T000i[ i i 0I"ڱ; T000i[ i i 0I"ڱ; T000i[ i i 0I"ڱ; T000i[ i i 0I"ڱ; T000i[ i i 0I"ں; T000i[ i i 0I"ں; T000i[ i i 0I"ڻ; T000i[ i i 0I"ڻ; T000i[ i i 0I"ڻ; T000i[ i i 0I"ڻ; T000i[ i i 0I"ۀ; T000i[ i i 0I"ۀ; T000i[ i i 0I"ہ; T000i[ i i 0I"ہ; T000i[ i i 0I"ہ; T000i[ i i 0I"ہ; T000i[ i i 0I"ھ; T000i[ i i 0I"ھ; T000i[ i i 0I"ھ; T000i[ i i 0I"ھ; T000i[ i i 0I"ے; T000i[ i i 0I"ے; T000i[ i i 0I"ۓ; T000i[ i i 0I"ۓ; T000i[ i i 0I"ڭ; T000i[ i i 0I"ڭ; T000i[ i i 0I"ڭ; T000i[ i i 0I"ڭ; T000i[ i i 0I"ۇ; T000i[ i i 0I"ۇ; T000i[ i i 0I"ۆ; T000i[ i i 0I"ۆ; T000i[ i i 0I"ۈ; T000i[ i i 0I"ۈ; T000i[ i i 0I"ٷ; T000i[ i i 0I"ۋ; T000i[ i i 0I"ۋ; T000i[ i i 0I"ۅ; T000i[ i i 0I"ۅ; T000i[ i i 0I"ۉ; T000i[ i i 0I"ۉ; T000i[ i i 0I"ې; T000i[ i i 0I"ې; T000i[ i i 0I"ې; T000i[ i i 0I"ې; T000i[ i i 0I"ى; T000i[ i i 0I"ى; T000i[ i i 0I" ئا; T000i[ i i 0I" ئا; T000i[ i i 0I" ئە; T000i[ i i 0I" ئە; T000i[ i i 0I" ئو; T000i[ i i 0I" ئو; T000i[ i i 0I" ئۇ; T000i[ i i 0I" ئۇ; T000i[ i i 0I" ئۆ; T000i[ i i 0I" ئۆ; T000i[ i i 0I" ئۈ; T000i[ i i 0I" ئۈ; T000i[ i i 0I" ئې; T000i[ i i 0I" ئې; T000i[ i i 0I" ئې; T000i[ i i 0I" ئى; T000i[ i i 0I" ئى; T000i[ i i 0I" ئى; T000i[ i i 0I"ی; T000i[ i i 0I"ی; T000i[ i i 0I"ی; T000i[ i i 0I"ی; T000i [ i i 0I" ئج; T000i[ i i 0I" ئح; T000i[ i i 0I" ئم; T000i[ i i 0I" ئى; T000i[ i i 0I" ئي; T000i[ i i 0I" بج; T000i[ i i 0I" بح; T000i[ i i 0I" بخ; T000i[ i i 0I" بم; T000i [ i i 0I" بى; T000i
[ i i 0I" بي; T000i [ i i 0I" تج; T000i [ i i 0I" تح; T000i
[ i i 0I" تخ; T000i[ i i 0I" تم; T000i[ i i 0I" تى; T000i[ i i 0I" تي; T000i[ i i 0I" ثج; T000i[ i i 0I" ثم; T000i[ i i 0I" ثى; T000i[ i i 0I" ثي; T000i[ i i 0I" جح; T000i[ i i 0I" جم; T000i[ i i 0I" حج; T000i[ i i 0I" حم; T000i[ i i 0I" خج; T000i[ i i 0I" خح; T000i[ i i 0I" خم; T000i [ i i 0I" سج; T000i [ i i 0I" سح; T000i [ i i 0I" سخ; T000i [ i i 0I" سم; T000i [ i i 0I" صح; T000i![ i i 0I" صم; T000i"[ i i 0I" ضج; T000i#[ i i 0I" ضح; T000i$[ i i 0I" ضخ; T000i%[ i i 0I" ضم; T000i&[ i i 0I" طح; T000i'[ i i 0I" طم; T000i([ i i 0I" ظم; T000i)[ i i 0I" عج; T000i*[ i i 0I" عم; T000i+[ i i 0I" غج; T000i,[ i i 0I" غم; T000i-[ i i 0I" فج; T000i.[ i i 0I" فح; T000i/[ i i 0I" فخ; T000i0[ i i 0I" فم; T000i1[ i i 0I" فى; T000i2[ i i 0I" في; T000i3[ i i 0I" قح; T000i4[ i i 0I" قم; T000i5[ i i 0I" قى; T000i6[ i i 0I" قي; T000i7[ i i 0I" كا; T000i8[ i i 0I" كج; T000i9[ i i 0I" كح; T000i:[ i i 0I" كخ; T000i;[ i i 0I" كل; T000i<[ i i 0I" كم; T000i=[ i i 0I" كى; T000i>[ i i 0I" كي; T000i?[ i i 0I" لج; T000i@[ i i 0I" لح; T000iA[ i i 0I" لخ; T000iB[ i i 0I" لم; T000iC[ i i 0I" لى; T000iD[ i i 0I" لي; T000iE[ i i 0I" مج; T000iF[ i i 0I" مح; T000iG[ i i 0I" مخ; T000iH[ i i 0I" مم; T000iI[ i i 0I" مى; T000iJ[ i i 0I" مي; T000iK[ i i 0I" نج; T000iL[ i i 0I" نح; T000iM[ i i 0I" نخ; T000iN[ i i 0I" نم; T000iO[ i i 0I" نى; T000iP[ i i 0I" ني; T000iQ[ i i 0I" هج; T000iR[ i i 0I" هم; T000iS[ i i 0I" هى; T000iT[ i i 0I" هي; T000iU[ i i 0I" يج; T000iV[ i i 0I" يح; T000iW[ i i 0I" يخ; T000iX[ i i 0I" يم; T000iY[ i i 0I" يى; T000iZ[ i i 0I" يي; T000i[[ i i 0I" ذٰ; T000i\[ i i 0I" رٰ; T000i][ i i 0I" ىٰ; T000i^[ i i 0I"
ٌّ; T000i_[ i i 0I"
ٍّ; T000i`[ i i 0I"
َّ; T000ia[ i i 0I"
ُّ; T000ib[ i i 0I"
ِّ; T000ic[ i i 0I"
ّٰ; T000id[ i i 0I" ئر; T000ie[ i i 0I" ئز; T000if[ i i 0I" ئم; T000ig[ i i 0I" ئن; T000ih[ i i 0I" ئى; T000ii[ i i 0I" ئي; T000ij[ i i 0I" بر; T000ik[ i i 0I" بز; T000il[ i i 0I" بم; T000im[ i i 0I" بن; T000in[ i i 0I" بى; T000io[ i i 0I" بي; T000ip[ i i 0I" تر; T000iq[ i i 0I" تز; T000ir[ i i 0I" تم; T000is[ i i 0I" تن; T000it[ i i 0I" تى; T000iu[ i i 0I" تي; T000iv[ i i 0I" ثر; T000iw[ i i 0I" ثز; T000ix[ i i 0I" ثم; T000iy[ i i 0I" ثن; T000iz[ i i 0I" ثى; T000i{[ i i 0I" ثي; T000i|[ i i 0I" فى; T000i}[ i i 0I" في; T000i~[ i i 0I" قى; T000i[ i i 0I" قي; T000i[ i i 0I" كا; T000i[ i i 0I" كل; T000i[ i i 0I" كم; T000i[ i i 0I" كى; T000i[ i i 0I" كي; T000i[ i i 0I" لم; T000i[ i i 0I" لى; T000i[ i i 0I" لي; T000i[ i i 0I" ما; T000i[ i i 0I" مم; T000i[ i i 0I" نر; T000i[ i i 0I" نز; T000i[ i i 0I" نم; T000i[ i i 0I" نن; T000i[ i i 0I" نى; T000i[ i i 0I" ني; T000i[ i i 0I" ىٰ; T000i[ i i 0I" ير; T000i[ i i 0I" يز; T000i[ i i 0I" يم; T000i[ i i 0I" ين; T000i[ i i 0I" يى; T000i[ i i 0I" يي; T000i[ i i 0I" ئج; T000i[ i i 0I" ئح; T000i[ i i 0I" ئخ; T000i[ i i 0I" ئم; T000i[ i i 0I" ئه; T000i[ i i 0I" بج; T000i[ i i 0I" بح; T000i[ i i 0I" بخ; T000i[ i i 0I" بم; T000i[ i i 0I" به; T000i[ i i 0I" تج; T000i[ i i 0I" تح; T000i[ i i 0I" تخ; T000i[ i i 0I" تم; T000i[ i i 0I" ته; T000i[ i i 0I" ثم; T000i[ i i 0I" جح; T000i[ i i 0I" جم; T000i[ i i 0I" حج; T000i[ i i 0I" حم; T000i[ i i 0I" خج; T000i[ i i 0I" خم; T000i[ i i 0I" سج; T000i[ i i 0I" سح; T000i[ i i 0I" سخ; T000i[ i i 0I" سم; T000i[ i i 0I" صح; T000i[ i i 0I" صخ; T000i[ i i 0I" صم; T000i[ i i 0I" ضج; T000i[ i i 0I" ضح; T000i[ i i 0I" ضخ; T000i[ i i 0I" ضم; T000i[ i i 0I" طح; T000i[ i i 0I" ظم; T000i[ i i 0I" عج; T000i[ i i 0I" عم; T000i[ i i 0I" غج; T000i[ i i 0I" غم; T000i[ i i 0I" فج; T000i[ i i 0I" فح; T000i[ i i 0I" فخ; T000i[ i i 0I" فم; T000i[ i i 0I" قح; T000i[ i i 0I" قم; T000i[ i i 0I" كج; T000i[ i i 0I" كح; T000i[ i i 0I" كخ; T000i[ i i 0I" كل; T000i[ i i 0I" كم; T000i[ i i 0I" لج; T000i[ i i 0I" لح; T000i[ i i 0I" لخ; T000i[ i i 0I" لم; T000i[ i i 0I" له; T000i[ i i 0I" مج; T000i[ i i 0I" مح; T000i[ i i 0I" مخ; T000i[ i i 0I" مم; T000i[ i i 0I" نج; T000i[ i i 0I" نح; T000i[ i i 0I" نخ; T000i[ i i 0I" نم; T000i[ i i 0I" نه; T000i[ i i 0I" هج; T000i[ i i 0I" هم; T000i[ i i 0I" هٰ; T000i[ i i 0I" يج; T000i[ i i 0I" يح; T000i[ i i 0I" يخ; T000i[ i i 0I" يم; T000i[ i i 0I" يه; T000i[ i i 0I" ئم; T000i[ i i 0I" ئه; T000i[ i i 0I" بم; T000i[ i i 0I" به; T000i[ i i 0I" تم; T000i[ i i 0I" ته; T000i[ i i 0I" ثم; T000i[ i i 0I" ثه; T000i[ i i 0I" سم; T000i[ i i 0I" سه; T000i[ i i 0I" شم; T000i[ i i 0I" شه; T000i[ i i 0I" كل; T000i[ i i 0I" كم; T000i[ i i 0I" لم; T000i[ i i 0I" نم; T000i[ i i 0I" نه; T000i[ i i 0I" يم; T000i[ i i 0I" يه; T000i[ i i 0I" ـَّ; T000i[ i i 0I" ـُّ; T000i[ i i 0I" ـِّ; T000i[ i i 0I" طى; T000i[ i i 0I" طي; T000i[ i i 0I" عى; T000i[ i i 0I" عي; T000i[ i i 0I" غى; T000i[ i i 0I" غي; T000i[ i i 0I" سى; T000i[ i i 0I" سي; T000i[ i i 0I" شى; T000i[ i i 0I" شي; T000i[ i i 0I" حى; T000i [ i i 0I" حي; T000i[ i i 0I" جى; T000i[ i i 0I" جي; T000i[ i i 0I" خى; T000i[ i i 0I" خي; T000i[ i i 0I" صى; T000i[ i i 0I" صي; T000i[ i i 0I" ضى; T000i[ i i 0I" ضي; T000i [ i i 0I" شج; T000i
[ i i 0I" شح; T000i [ i i 0I" شخ; T000i [ i i 0I" شم; T000i
[ i i 0I" شر; T000i[ i i 0I" سر; T000i[ i i 0I" صر; T000i[ i i 0I" ضر; T000i[ i i 0I" طى; T000i[ i i 0I" طي; T000i[ i i 0I" عى; T000i[ i i 0I" عي; T000i[ i i 0I" غى; T000i[ i i 0I" غي; T000i[ i i 0I" سى; T000i[ i i 0I" سي; T000i[ i i 0I" شى; T000i[ i i 0I" شي; T000i[ i i 0I" حى; T000i [ i i 0I" حي; T000i [ i i 0I" جى; T000i [ i i 0I" جي; T000i [ i i 0I" خى; T000i [ i i 0I" خي; T000i![ i i 0I" صى; T000i"[ i i 0I" صي; T000i#[ i i 0I" ضى; T000i$[ i i 0I" ضي; T000i%[ i i 0I" شج; T000i&[ i i 0I" شح; T000i'[ i i 0I" شخ; T000i([ i i 0I" شم; T000i)[ i i 0I" شر; T000i*[ i i 0I" سر; T000i+[ i i 0I" صر; T000i,[ i i 0I" ضر; T000i-[ i i 0I" شج; T000i.[ i i 0I" شح; T000i/[ i i 0I" شخ; T000i0[ i i 0I" شم; T000i1[ i i 0I" سه; T000i2[ i i 0I" شه; T000i3[ i i 0I" طم; T000i4[ i i 0I" سج; T000i5[ i i 0I" سح; T000i6[ i i 0I" سخ; T000i7[ i i 0I" شج; T000i8[ i i 0I" شح; T000i9[ i i 0I" شخ; T000i:[ i i 0I" طم; T000i;[ i i 0I" ظم; T000i<[ i i 0I" اً; T000i=[ i i 0I" اً; T000iP[ i i 0I" تجم; T000iQ[ i i 0I" تحج; T000iR[ i i 0I" تحج; T000iS[ i i 0I" تحم; T000iT[ i i 0I" تخم; T000iU[ i i 0I" تمج; T000iV[ i i 0I" تمح; T000iW[ i i 0I" تمخ; T000iX[ i i 0I" جمح; T000iY[ i i 0I" جمح; T000iZ[ i i 0I" حمي; T000i[[ i i 0I" حمى; T000i\[ i i 0I" سحج; T000i][ i i 0I" سجح; T000i^[ i i 0I" سجى; T000i_[ i i 0I" سمح; T000i`[ i i 0I" سمح; T000ia[ i i 0I" سمج; T000ib[ i i 0I" سمم; T000ic[ i i 0I" سمم; T000id[ i i 0I" صحح; T000ie[ i i 0I" صحح; T000if[ i i 0I" صمم; T000ig[ i i 0I" شحم; T000ih[ i i 0I" شحم; T000ii[ i i 0I" شجي; T000ij[ i i 0I" شمخ; T000ik[ i i 0I" شمخ; T000il[ i i 0I" شمم; T000im[ i i 0I" شمم; T000in[ i i 0I" ضحى; T000io[ i i 0I" ضخم; T000ip[ i i 0I" ضخم; T000iq[ i i 0I" طمح; T000ir[ i i 0I" طمح; T000is[ i i 0I" طمم; T000it[ i i 0I" طمي; T000iu[ i i 0I" عجم; T000iv[ i i 0I" عمم; T000iw[ i i 0I" عمم; T000ix[ i i 0I" عمى; T000iy[ i i 0I" غمم; T000iz[ i i 0I" غمي; T000i{[ i i 0I" غمى; T000i|[ i i 0I" فخم; T000i}[ i i 0I" فخم; T000i~[ i i 0I" قمح; T000i[ i i 0I" قمم; T000i[ i i 0I" لحم; T000i[ i i 0I" لحي; T000i[ i i 0I" لحى; T000i[ i i 0I" لجج; T000i[ i i 0I" لجج; T000i[ i i 0I" لخم; T000i[ i i 0I" لخم; T000i[ i i 0I" لمح; T000i[ i i 0I" لمح; T000i[ i i 0I" محج; T000i[ i i 0I" محم; T000i[ i i 0I" محي; T000i[ i i 0I" مجح; T000i[ i i 0I" مجم; T000i[ i i 0I" مخج; T000i[ i i 0I" مخم; T000i[ i i 0I" مجخ; T000i[ i i 0I" همج; T000i[ i i 0I" همم; T000i[ i i 0I" نحم; T000i[ i i 0I" نحى; T000i[ i i 0I" نجم; T000i[ i i 0I" نجم; T000i[ i i 0I" نجى; T000i[ i i 0I" نمي; T000i[ i i 0I" نمى; T000i[ i i 0I" يمم; T000i[ i i 0I" يمم; T000i[ i i 0I" بخي; T000i[ i i 0I" تجي; T000i[ i i 0I" تجى; T000i[ i i 0I" تخي; T000i[ i i 0I" تخى; T000i[ i i 0I" تمي; T000i[ i i 0I" تمى; T000i[ i i 0I" جمي; T000i[ i i 0I" جحى; T000i[ i i 0I" جمى; T000i[ i i 0I" سخى; T000i[ i i 0I" صحي; T000i[ i i 0I" شحي; T000i[ i i 0I" ضحي; T000i[ i i 0I" لجي; T000i[ i i 0I" لمي; T000i[ i i 0I" يحي; T000i[ i i 0I" يجي; T000i[ i i 0I" يمي; T000i[ i i 0I" ممي; T000i[ i i 0I" قمي; T000i[ i i 0I" نحي; T000i[ i i 0I" قمح; T000i[ i i 0I" لحم; T000i[ i i 0I" عمي; T000i[ i i 0I" كمي; T000i[ i i 0I" نجح; T000i[ i i 0I" مخي; T000i[ i i 0I" لجم; T000i[ i i 0I" كمم; T000i[ i i 0I" لجم; T000i[ i i 0I" نجح; T000i[ i i 0I" جحي; T000i[ i i 0I" حجي; T000i[ i i 0I" مجي; T000i[ i i 0I" فمي; T000i[ i i 0I" بحي; T000i[ i i 0I" كمم; T000i[ i i 0I" عجم; T000i[ i i 0I" صمم; T000i[ i i 0I" سخي; T000i[ i i 0I" نجي; T000i[ i i 0I" صلے; T000i[ i i 0I" قلے; T000i[ i i 0I"
الله; T000i[ i i 0I"
اكبر; T000i[ i i 0I"
محمد; T000i[ i i 0I"
صلعم; T000i[ i i 0I"
رسول; T000i[ i i 0I"
عليه; T000i[ i i 0I"
وسلم; T000i[ i i 0I" صلى; T000i[ i i 0I"&صلى الله عليه وسلم; T000i[ i i 0I"جل جلاله; T000i [ ii 00000i![ ii 00000i"[ ii 00000i#[ ii 00000i0[ i i 0I"‥; T000i1[ i i 0I"—; T000i2[ i i 0I"–; T000i3[ i i 0I"_; T000i4[ i i 0I"_; T000i5[ i i 0I"(; T000i6[ i i 0I"); T000i7[ i i 0I"{; T000i8[ i i 0I"}; T000i9[ i i 0I"〔; T000i:[ i i 0I"〕; T000i;[ i i 0I"【; T000i<[ i i 0I"】; T000i=[ i i 0I"《; T000i>[ i i 0I"》; T000i?[ i i 0I"〈; T000i@[ i i 0I"〉; T000iA[ i i 0I"「; T000iB[ i i 0I"」; T000iC[ i i 0I"『; T000iD[ i i 0I"』; T000iI[ i i 0I"‾; T000iJ[ i i 0I"‾; T000iK[ i i 0I"‾; T000iL[ i i 0I"‾; T000iM[ i i 0I"_; T000iN[ i i 0I"_; T000iO[ i i 0I"_; T000iP[ i i 0I",; T000iQ[ i i 0I"、; T000iR[ i i 0I".; T000iT[ i i 0I";; T000iU[ i i 0I":; T000iV[ i i 0I"?; T000iW[ i i 0I"!; T000iX[ i i 0I"—; T000iY[ i i 0I"(; T000iZ[ i i 0I"); T000i[[ i i 0I"{; T000i\[ i i 0I"}; T000i][ i i 0I"〔; T000i^[ i i 0I"〕; T000i_[ i i 0I"#; T000i`[ i i 0I"&; T000ia[ i i 0I"*; T000ib[ i i 0I"+; T000ic[ i i 0I"-; T000id[ i i 0I"<; T000ie[ i i 0I">; T000if[ i i 0I"=; T000ih[ i i 0I"\; T000ii[ i i 0I"$; T000ij[ i i 0I"%; T000ik[ i i 0I"@; T000ip[ i i 0I" ً; T000iq[ i i 0I" ـً; T000ir[ i i 0I" ٌ; T000it[ i i 0I" ٍ; T000iv[ i i 0I" َ; T000iw[ i i 0I" ـَ; T000ix[ i i 0I" ُ; T000iy[ i i 0I" ـُ; T000iz[ i i 0I" ِ; T000i{[ i i 0I" ـِ; T000i|[ i i 0I" ّ; T000i}[ i i 0I" ـّ; T000i~[ i i 0I" ْ; T000i[ i i 0I" ـْ; T000i[ i i 0I"ء; T000i[ i i 0I"آ; T000i[ i i 0I"آ; T000i[ i i 0I"أ; T000i[ i i 0I"أ; T000i[ i i 0I"ؤ; T000i[ i i 0I"ؤ; T000i[ i i 0I"إ; T000i[ i i 0I"إ; T000i[ i i 0I"ئ; T000i[ i i 0I"ئ; T000i[ i i 0I"ئ; T000i[ i i 0I"ئ; T000i[ i i 0I"ا; T000i[ i i 0I"ا; T000i[ i i 0I"ب; T000i[ i i 0I"ب; T000i[ i i 0I"ب; T000i[ i i 0I"ب; T000i[ i i 0I"ة; T000i[ i i 0I"ة; T000i[ i i 0I"ت; T000i[ i i 0I"ت; T000i[ i i 0I"ت; T000i[ i i 0I"ت; T000i[ i i 0I"ث; T000i[ i i 0I"ث; T000i[ i i 0I"ث; T000i[ i i 0I"ث; T000i[ i i 0I"ج; T000i[ i i 0I"ج; T000i[ i i 0I"ج; T000i[ i i 0I"ج; T000i[ i i 0I"ح; T000i[ i i 0I"ح; T000i[ i i 0I"ح; T000i[ i i 0I"ح; T000i[ i i 0I"خ; T000i[ i i 0I"خ; T000i[ i i 0I"خ; T000i[ i i 0I"خ; T000i[ i i 0I"د; T000i[ i i 0I"د; T000i[ i i 0I"ذ; T000i[ i i 0I"ذ; T000i[ i i 0I"ر; T000i[ i i 0I"ر; T000i[ i i 0I"ز; T000i[ i i 0I"ز; T000i[ i i 0I"س; T000i[ i i 0I"س; T000i[ i i 0I"س; T000i[ i i 0I"س; T000i[ i i 0I"ش; T000i[ i i 0I"ش; T000i[ i i 0I"ش; T000i[ i i 0I"ش; T000i[ i i 0I"ص; T000i[ i i 0I"ص; T000i[ i i 0I"ص; T000i[ i i 0I"ص; T000i[ i i 0I"ض; T000i[ i i 0I"ض; T000i[ i i 0I"ض; T000i[ i i 0I"ض; T000i[ i i 0I"ط; T000i[ i i 0I"ط; T000i[ i i 0I"ط; T000i[ i i 0I"ط; T000i[ i i 0I"ظ; T000i[ i i 0I"ظ; T000i[ i i 0I"ظ; T000i[ i i 0I"ظ; T000i[ i i 0I"ع; T000i[ i i 0I"ع; T000i[ i i 0I"ع; T000i[ i i 0I"ع; T000i[ i i 0I"غ; T000i[ i i 0I"غ; T000i[ i i 0I"غ; T000i[ i i 0I"غ; T000i[ i i 0I"ف; T000i[ i i 0I"ف; T000i[ i i 0I"ف; T000i[ i i 0I"ف; T000i[ i i 0I"ق; T000i[ i i 0I"ق; T000i[ i i 0I"ق; T000i[ i i 0I"ق; T000i[ i i 0I"ك; T000i[ i i 0I"ك; T000i[ i i 0I"ك; T000i[ i i 0I"ك; T000i[ i i 0I"ل; T000i[ i i 0I"ل; T000i[ i i 0I"ل; T000i[ i i 0I"ل; T000i[ i i 0I"م; T000i[ i i 0I"م; T000i[ i i 0I"م; T000i[ i i 0I"م; T000i[ i i 0I"ن; T000i[ i i 0I"ن; T000i[ i i 0I"ن; T000i[ i i 0I"ن; T000i[ i i 0I"ه; T000i[ i i 0I"ه; T000i[ i i 0I"ه; T000i[ i i 0I"ه; T000i[ i i 0I"و; T000i[ i i 0I"و; T000i[ i i 0I"ى; T000i[ i i 0I"ى; T000i[ i i 0I"ي; T000i[ i i 0I"ي; T000i[ i i 0I"ي; T000i[ i i 0I"ي; T000i[ i i 0I" لآ; T000i[ i i 0I" لآ; T000i[ i i 0I" لأ; T000i[ i i 0I" لأ; T000i[ i i 0I" لإ; T000i[ i i 0I" لإ; T000i[ i i 0I" لا; T000i[ i i 0I" لا; T000i[ i i 0I"!; T000i[ i i 0I""; T000i[ i i 0I"#; T000i[ i i 0I"$; T000i[ i i 0I"%; T000i[ i i 0I"&; T000i[ i i 0I"'; T000i[ i i 0I"(; T000i [ i i 0I"); T000i
[ i i 0I"*; T000i [ i i 0I"+; T000i [ i i 0I",; T000i
[ i i 0I"-; T000i[ i i 0I".; T000i[ i i 0I"/; T000i[ i i 0I"0; T000i[ i i 0I"1; T000i[ i i 0I"2; T000i[ i i 0I"3; T000i[ i i 0I"4; T000i[ i i 0I"5; T000i[ i i 0I"6; T000i[ i i 0I"7; T000i[ i i 0I"8; T000i[ i i 0I"9; T000i[ i i 0I":; T000i[ i i 0I";; T000i [ i i 0I"<; T000i [ i i 0I"=; T000i [ i i 0I">; T000i [ i i 0I"?; T000i [ i i 0I"@; T000i![ i i 0I"A; T0iA0i"[ i i 0I"B; T0iB0i#[ i i 0I"C; T0iC0i$[ i i 0I"D; T0iD0i%[ i i 0I"E; T0iE0i&[ i i 0I"F; T0iF0i'[ i i 0I"G; T0iG0i([ i i 0I"H; T0iH0i)[ i i 0I"I; T0iI0i*[ i i 0I"J; T0iJ0i+[ i i 0I"K; T0iK0i,[ i i 0I"L; T0iL0i-[ i i 0I"M; T0iM0i.[ i i 0I"N; T0iN0i/[ i i 0I"O; T0iO0i0[ i i 0I"P; T0iP0i1[ i i 0I"Q; T0iQ0i2[ i i 0I"R; T0iR0i3[ i i 0I"S; T0iS0i4[ i i 0I"T; T0iT0i5[ i i 0I"U; T0iU0i6[ i i 0I"V; T0iV0i7[ i i 0I"W; T0iW0i8[ i i 0I"X; T0iX0i9[ i i 0I"Y; T0iY0i:[ i i 0I"Z; T0iZ0i;[ i i 0I"[; T000i<[ i i 0I"\; T000i=[ i i 0I"]; T000i>[ i i 0I"^; T000i?[ i i 0I"_; T000i@[ i i 0I"`; T000iA[ i i 0I"a; Ti!0i!iB[ i i 0I"b; Ti"0i"iC[ i i 0I"c; Ti#0i#iD[ i i 0I"d; Ti$0i$iE[ i i 0I"e; Ti%0i%iF[ i i 0I"f; Ti&0i&iG[ i i 0I"g; Ti'0i'iH[ i i 0I"h; Ti(0i(iI[ i i 0I"i; Ti)0i)iJ[ i i 0I"j; Ti*0i*iK[ i i 0I"k; Ti+0i+iL[ i i 0I"l; Ti,0i,iM[ i i 0I"m; Ti-0i-iN[ i i 0I"n; Ti.0i.iO[ i i 0I"o; Ti/0i/iP[ i i 0I"p; Ti00i0iQ[ i i 0I"q; Ti10i1iR[ i i 0I"r; Ti20i2iS[ i i 0I"s; Ti30i3iT[ i i 0I"t; Ti40i4iU[ i i 0I"u; Ti50i5iV[ i i 0I"v; Ti60i6iW[ i i 0I"w; Ti70i7iX[ i i 0I"x; Ti80i8iY[ i i 0I"y; Ti90i9iZ[ i i 0I"z; Ti:0i:i[[ i i 0I"{; T000i\[ i i 0I"|; T000i][ i i 0I"}; T000i^[ i i 0I"~; T000ia[ i i 0I"。; T000ib[ i i 0I"「; T000ic[ i i 0I"」; T000id[ i i 0I"、; T000ie[ i i 0I"・; T000if[ i i 0I"ヲ; T000ig[ i i 0I"ァ; T000ih[ i i 0I"ィ; T000ii[ i i 0I"ゥ; T000ij[ i i 0I"ェ; T000ik[ i i 0I"ォ; T000il[ i i 0I"ャ; T000im[ i i 0I"ュ; T000in[ i i 0I"ョ; T000io[ i i 0I"ッ; T000ip[ i i 0I"ー; T000iq[ i i 0I"ア; T000ir[ i i 0I"イ; T000is[ i i 0I"ウ; T000it[ i i 0I"エ; T000iu[ i i 0I"オ; T000iv[ i i 0I"カ; T000iw[ i i 0I"キ; T000ix[ i i 0I"ク; T000iy[ i i 0I"ケ; T000iz[ i i 0I"コ; T000i{[ i i 0I"サ; T000i|[ i i 0I"シ; T000i}[ i i 0I"ス; T000i~[ i i 0I"セ; T000i[ i i 0I"ソ; T000i[ i i 0I"タ; T000i[ i i 0I"チ; T000i[ i i 0I"ツ; T000i[ i i 0I"テ; T000i[ i i 0I"ト; T000i[ i i 0I"ナ; T000i[ i i 0I"ニ; T000i[ i i 0I"ヌ; T000i[ i i 0I"ネ; T000i[ i i 0I"ノ; T000i[ i i 0I"ハ; T000i[ i i 0I"ヒ; T000i[ i i 0I"フ; T000i[ i i 0I"ヘ; T000i[ i i 0I"ホ; T000i[ i i 0I"マ; T000i[ i i 0I"ミ; T000i[ i i 0I"ム; T000i[ i i 0I"メ; T000i[ i i 0I"モ; T000i[ i i 0I"ヤ; T000i[ i i 0I"ユ; T000i[ i i 0I"ヨ; T000i[ i i 0I"ラ; T000i[ i i 0I"リ; T000i[ i i 0I"ル; T000i[ i i 0I"レ; T000i[ i i 0I"ロ; T000i[ i i 0I"ワ; T000i[ i i 0I"ン; T000i[ i i 0I"゙; T000i[ i i 0I"゚; T000i[ i i 0I"ㅤ; T000i[ i i 0I"ㄱ; T000i[ i i 0I"ㄲ; T000i[ i i 0I"ㄳ; T000i[ i i 0I"ㄴ; T000i[ i i 0I"ㄵ; T000i[ i i 0I"ㄶ; T000i[ i i 0I"ㄷ; T000i[ i i 0I"ㄸ; T000i[ i i 0I"ㄹ; T000i[ i i 0I"ㄺ; T000i[ i i 0I"ㄻ; T000i[ i i 0I"ㄼ; T000i[ i i 0I"ㄽ; T000i[ i i 0I"ㄾ; T000i[ i i 0I"ㄿ; T000i[ i i 0I"ㅀ; T000i[ i i 0I"ㅁ; T000i[ i i 0I"ㅂ; T000i[ i i 0I"ㅃ; T000i[ i i 0I"ㅄ; T000i[ i i 0I"ㅅ; T000i[ i i 0I"ㅆ; T000i[ i i 0I"ㅇ; T000i[ i i 0I"ㅈ; T000i[ i i 0I"ㅉ; T000i[ i i 0I"ㅊ; T000i[ i i 0I"ㅋ; T000i[ i i 0I"ㅌ; T000i[ i i 0I"ㅍ; T000i[ i i 0I"ㅎ; T000i[ i i 0I"ㅏ; T000i[ i i 0I"ㅐ; T000i[ i i 0I"ㅑ; T000i[ i i 0I"ㅒ; T000i[ i i 0I"ㅓ; T000i[ i i 0I"ㅔ; T000i[ i i 0I"ㅕ; T000i[ i i 0I"ㅖ; T000i[ i i 0I"ㅗ; T000i[ i i 0I"ㅘ; T000i[ i i 0I"ㅙ; T000i[ i i 0I"ㅚ; T000i[ i i 0I"ㅛ; T000i[ i i 0I"ㅜ; T000i[ i i 0I"ㅝ; T000i[ i i 0I"ㅞ; T000i[ i i 0I"ㅟ; T000i[ i i 0I"ㅠ; T000i[ i i 0I"ㅡ; T000i[ i i 0I"ㅢ; T000i[ i i 0I"ㅣ; T000i[ i i 0I"¢; T000i[ i i 0I"£; T000i[ i i 0I"¬; T000i[ i i 0I"¯; T000i[ i i 0I"¦; T000i[ i i 0I"¥; T000i[ i i 0I"₩; T000i[ i i 0I"│; T000i[ i i 0I"←; T000i[ i i 0I"↑; T000i[ i i 0I"→; T000i[ i i 0I"↓; T000i[ i i 0I"■; T000i[ i i 0I"○; T000 addressable-2.7.0/Rakefile 0000644 0000041 0000041 00000002102 13534474053 015471 0 ustar www-data www-data # 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[
"lib/**/*", "spec/**/*", "vendor/**/*", "data/**/*",
"tasks/**/*",
"[A-Z]*", "Rakefile"
].exclude(/pkg/).exclude(/database\.yml/).
exclude(/Gemfile\.lock/).exclude(/[_\.]git$/)
task :default => "spec"
WINDOWS = (RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/) rescue false
SUDO = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
Dir['tasks/**/*.rake'].each { |rake| load rake }
addressable-2.7.0/lib/ 0000755 0000041 0000041 00000000000 13534474053 014577 5 ustar www-data www-data addressable-2.7.0/lib/addressable/ 0000755 0000041 0000041 00000000000 13534474053 017050 5 ustar www-data www-data addressable-2.7.0/lib/addressable/template.rb 0000644 0000041 0000041 00000107370 13534474053 021220 0 ustar www-data www-data # frozen_string_literal: true
# encoding:utf-8
#--
# 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 returend 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 String representation of the MatchData's state.
#
# @return [String] The MatchData's state, as a String.
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 Addressable::Template 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 String representation of the Template object's state.
#
# @return [String] The Template object's state, as a String.
def inspect
sprintf("#<%s:%#0x PATTERN:%s>",
self.class.to_s, self.object_id, self.pattern)
end
##
# Returns true 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]
# true if the Templates are equivalent, false
# 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 restore or
# match messages or both. The restore method should
# take two parameters: `[String] name` and `[String] value`.
# The restore method should reverse any transformations that
# have been performed on the value to ensure a valid URI.
# The match method should take a single
# parameter: `[String] name`. The match method should return
# a String containing a regular expression capture group for
# matching on that particular variable. The default value is `".*?"`.
# The match method has no effect on multivariate operator
# expansions.
#
# @return [Hash, NilClass]
# The Hash mapping that was extracted from the URI, or
# nil 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 restore or
# match messages or both. The restore method should
# take two parameters: `[String] name` and `[String] value`.
# The restore method should reverse any transformations that
# have been performed on the value to ensure a valid URI.
# The match method should take a single
# parameter: `[String] name`. The match method should return
# a String containing a regular expression capture group for
# matching on that particular variable. The default value is `".*?"`.
# The match method has no effect on multivariate operator
# expansions.
#
# @return [Hash, NilClass]
# The Hash mapping that was extracted from the URI, or
# nil 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)
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 validate or
# transform messages or both. Both the validate and
# transform methods should take two parameters: name and
# value. The validate method should return true
# or false; true if the value of the variable is valid,
# false otherwise. An InvalidTemplateValueError
# exception will be raised if the value is invalid. The transform
# method should return the transformed variable value as a String.
# If a transform 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 validate or
# transform messages or both. Both the validate and
# transform methods should take two parameters: name and
# value. The validate method should return true
# or false; true if the value of the variable is valid,
# false otherwise. An InvalidTemplateValueError
# exception will be raised if the value is invalid. The transform
# method should return the transformed variable value as a String.
# If a transform 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
##
# Generates a route result for a given set of parameters.
# Should only be used by rack-mount.
#
# @param params [Hash] The set of parameters used to expand the template.
# @param recall [Hash] Default parameters used to expand the template.
# @param options [Hash] Either a `:processor` or a `:parameterize` block.
#
# @api private
def generate(params={}, recall={}, options={})
merged = recall.merge(params)
if options[:processor]
processor = options[:processor]
elsif options[:parameterize]
# TODO: This is sending me into fits trying to shoe-horn this into
# the existing API. I think I've got this backwards and processors
# should be a set of 4 optional blocks named :validate, :transform,
# :match, and :restore. Having to use a singleton here is a huge
# code smell.
processor = Object.new
class <validate or
# transform messages or both. Both the validate and
# transform methods should take two parameters: name and
# value. The validate method should return true
# or false; true if the value of the variable is valid,
# false otherwise. An InvalidTemplateValueError exception
# will be raised if the value is invalid. The transform method
# should return the transformed variable value as a String. If a
# transform 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 validate or
# transform messages or both. Both the validate and
# transform methods should take two parameters: name and
# value. The validate method should return true
# or false; true if the value of the variable is valid,
# false otherwise. An InvalidTemplateValueError exception
# will be raised if the value is invalid. The transform method
# should return the transformed variable value as a String. If a
# transform 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 keys and values with IDNA#unicode_normalize_kc
#
# @return [Hash, Array, String] The normalized values
def normalize_value(value)
unless value.is_a?(Hash)
value = value.respond_to?(:to_ary) ? value.to_ary : value.to_str
end
# Handle unicode normalization
if value.kind_of?(Array)
value.map! { |val| Addressable::IDNA.unicode_normalize_kc(val) }
elsif value.kind_of?(Hash)
value = value.inject({}) { |acc, (k, v)|
acc[Addressable::IDNA.unicode_normalize_kc(k)] =
Addressable::IDNA.unicode_normalize_kc(v)
acc
}
else
value = Addressable::IDNA.unicode_normalize_kc(value)
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 Regexp that parses a template pattern.
#
# @param [String] pattern The URI template pattern.
# @param [#match] processor The template processor to use.
#
# @return [Regexp]
# A regular expression which may be used to parse a template pattern.
def parse_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 = "^#{regexp_string}$"
return expansions, Regexp.new(regexp_string)
end
end
end
addressable-2.7.0/lib/addressable/version.rb 0000644 0000041 0000041 00000001620 13534474053 021061 0 ustar www-data www-data # frozen_string_literal: true
# encoding:utf-8
#--
# 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 = 7
TINY = 0
STRING = [MAJOR, MINOR, TINY].join('.')
end
end
end
addressable-2.7.0/lib/addressable/uri.rb 0000644 0000041 0000041 00000244760 13534474053 020211 0 ustar www-data www-data # frozen_string_literal: true
# encoding:utf-8
#--
# 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
# RFC 3986,
# RFC 3987.
class URI
##
# Raised if something other than a uri is supplied.
class InvalidURIError < StandardError
end
##
# Container for the character classes specified in
# RFC 3986.
module CharacterClasses
ALPHA = "a-zA-Z"
DIGIT = "0-9"
GEN_DELIMS = "\\:\\/\\?\\#\\[\\]\\@"
SUB_DELIMS = "\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\="
RESERVED = GEN_DELIMS + SUB_DELIMS
UNRESERVED = ALPHA + DIGIT + "\\-\\.\\_\\~"
PCHAR = UNRESERVED + SUB_DELIMS + "\\:\\@"
SCHEME = ALPHA + DIGIT + "\\-\\+\\."
HOST = UNRESERVED + SUB_DELIMS + "\\[\\:\\]"
AUTHORITY = PCHAR
PATH = PCHAR + "\\/"
QUERY = PCHAR + "\\/\\?"
FRAGMENT = PCHAR + "\\/\\?"
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
}
##
# 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
# Addressable::URI.
#
# @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 if not 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]
end
if port == EMPTY_STR
port = nil
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
# Addressable::URI.
# @param [Hash] hints
# A Hash of hints to the heuristic parser.
# Defaults to {:scheme => "http"}.
#
# @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
if !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 Addressable::URI.parse. Handles all of the
# various Microsoft-specific formats for specifying paths.
#
# @param [String, Addressable::URI, #to_str] path
# Typically a String 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)
if !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)
# #=> #
def self.join(*uris)
uri_objects = uris.collect do |uri|
if !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
for uri in uri_objects
result.join!(uri)
end
return result
end
##
# Tables used to optimize encoding operations in `self.encode_component`
# and `self.normalize_component`
SEQUENCE_ENCODING_TABLE = Hash.new do |hash, sequence|
hash[sequence] = sequence.unpack("C*").map do |c|
format("%02x", c)
end.join
end
SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = Hash.new do |hash, sequence|
hash[sequence] = sequence.unpack("C*").map do |c|
format("%%%02X", c)
end.join
end
##
# 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 String
# is passed, the String must be formatted as a regular
# expression character class. (Do not include the surrounding square
# brackets.) For example, "b-zB-Z0-9" would cause
# everything but the letters 'b' through 'z' and the numbers '0' through
# '9' to be percent encoded. If a Regexp is passed, the
# value /[^b-zB-Z0-9]/ would have the same effect. A set of
# useful String values may be found in the
# Addressable::URI::CharacterClasses module. The default
# value is the reserved plus unreserved character classes specified in
# RFC 3986.
#
# @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
# character_class.
#
# @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=
CharacterClasses::RESERVED + CharacterClasses::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 |sequence|
SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE[sequence]
end
if upcase_encoded.length > 0
upcase_encoded_chars = upcase_encoded.chars.map do |char|
SEQUENCE_ENCODING_TABLE[char]
end
component = component.gsub(/%(#{upcase_encoded_chars.join('|')})/,
&:upcase)
end
return component
end
class << self
alias_method :encode_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 unencode_component
# 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 String or
# Addressable::URI. All other values are invalid. Defaults
# to String.
#
# @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 return_type
# 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
uri = uri.dup
# Seriously, only use UTF-8. I'm really not kidding!
uri.force_encoding("utf-8")
leave_encoded = leave_encoded.dup.force_encoding("utf-8")
result = uri.gsub(/%[0-9a-f]{2}/iu) do |sequence|
c = sequence[1..3].to_i(16).chr
c.force_encoding("utf-8")
leave_encoded.include?(c) ? sequence : c
end
result.force_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 String
# is passed, the String must be formatted as a regular
# expression character class. (Do not include the surrounding square
# brackets.) For example, "b-zB-Z0-9" would cause
# everything but the letters 'b' through 'z' and the numbers '0'
# through '9' to be percent encoded. If a Regexp is passed,
# the value /[^b-zB-Z0-9]/ would have the same effect. A
# set of useful String values may be found in the
# Addressable::URI::CharacterClasses module. The default
# value is the reserved plus unreserved character classes specified in
# RFC 3986.
#
# @param [String] leave_encoded
# When character_class is a String then
# leave_encoded 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=
CharacterClasses::RESERVED + CharacterClasses::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?('%')
"|%(?!#{leave_encoded.chars.map do |char|
seq = SEQUENCE_ENCODING_TABLE[char]
[seq.upcase, seq.downcase]
end.flatten.join('|')})"
end
character_class = /[^#{character_class}]#{leave_re}/
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(
Addressable::IDNA.unicode_normalize_kc(unencoded),
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 String or
# Addressable::URI. All other values are invalid. Defaults
# to String.
#
# @return [String, Addressable::URI]
# The encoded URI.
# The return type is determined by the return_type
# 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::CharacterClasses::SCHEME),
:authority => self.encode_component(uri_object.authority,
Addressable::URI::CharacterClasses::AUTHORITY),
:path => self.encode_component(uri_object.path,
Addressable::URI::CharacterClasses::PATH),
:query => self.encode_component(uri_object.query,
Addressable::URI::CharacterClasses::QUERY),
:fragment => self.encode_component(uri_object.fragment,
Addressable::URI::CharacterClasses::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 String or
# Addressable::URI. All other values are invalid. Defaults
# to String.
#
# @return [String, Addressable::URI]
# The encoded URI.
# The return type is determined by the return_type
# 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] =
Addressable::IDNA.unicode_normalize_kc(value.to_str)
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::CharacterClasses::SCHEME),
:user => self.encode_component(components[:user],
Addressable::URI::CharacterClasses::UNRESERVED),
:password => self.encode_component(components[:password],
Addressable::URI::CharacterClasses::UNRESERVED),
:host => components[:host],
:port => components[:port],
:path => self.encode_component(components[:path],
Addressable::URI::CharacterClasses::PATH),
:query => self.encode_component(components[:query],
Addressable::URI::CharacterClasses::QUERY),
:fragment => self.encode_component(components[:fragment],
Addressable::URI::CharacterClasses::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
# application/x-www-form-urlencoded 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 false.
#
# @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"),
CharacterClasses::UNRESERVED
).gsub("%20", "+"),
self.encode_component(
value.gsub(/(\r\n|\n|\r)/, "\r\n"),
CharacterClasses::UNRESERVED
).gsub("%20", "+")
]
end
return escaped_form_values.map do |(key, value)|
"#{key}=#{value}"
end.join("&")
end
##
# Decodes a String according to the rules for the
# application/x-www-form-urlencoded MIME type.
#
# @param [String, #to_str] encoded_value
# The form values to decode.
#
# @return [Array]
# The decoded values.
# This is not a Hash 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
self.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
self.to_s
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.
def scheme
return defined?(@scheme) ? @scheme : nil
end
##
# The scheme component for this URI, normalized.
#
# @return [String] The scheme component, normalized.
def normalized_scheme
return nil unless self.scheme
@normalized_scheme ||= begin
if self.scheme =~ /^\s*ssh\+svn\s*$/i
"svn+ssh".dup
else
Addressable::URI.normalize_component(
self.scheme.strip.downcase,
Addressable::URI::CharacterClasses::SCHEME
)
end
end
# All normalized values should be UTF-8
@normalized_scheme.force_encoding(Encoding::UTF_8) if @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
remove_instance_variable(:@normalized_scheme) if defined?(@normalized_scheme)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end
##
# The user component for this URI.
#
# @return [String] The user component.
def user
return defined?(@user) ? @user : nil
end
##
# The user component for this URI, normalized.
#
# @return [String] The user component, normalized.
def normalized_user
return nil unless self.user
return @normalized_user if defined?(@normalized_user)
@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::CharacterClasses::UNRESERVED
)
end
end
# All normalized values should be UTF-8
@normalized_user.force_encoding(Encoding::UTF_8) if @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 if @user.nil?
end
# Reset dependent values
remove_instance_variable(:@userinfo) if defined?(@userinfo)
remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_user) if defined?(@normalized_user)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end
##
# The password component for this URI.
#
# @return [String] The password component.
def password
return defined?(@password) ? @password : nil
end
##
# The password component for this URI, normalized.
#
# @return [String] The password component, normalized.
def normalized_password
return nil unless self.password
return @normalized_password if defined?(@normalized_password)
@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::CharacterClasses::UNRESERVED
)
end
end
# All normalized values should be UTF-8
if @normalized_password
@normalized_password.force_encoding(Encoding::UTF_8)
end
@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
@password ||= nil
@user ||= nil
if @password != nil
@user = EMPTY_STR if @user.nil?
end
# Reset dependent values
remove_instance_variable(:@userinfo) if defined?(@userinfo)
remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_password) if defined?(@normalized_password)
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 if defined?(@normalized_userinfo)
@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
if @normalized_userinfo
@normalized_userinfo.force_encoding(Encoding::UTF_8)
end
@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
remove_instance_variable(:@authority) if defined?(@authority)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end
##
# The host component for this URI.
#
# @return [String] The host component.
def host
return defined?(@host) ? @host : nil
end
##
# 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,
CharacterClasses::HOST)
result
else
EMPTY_STR.dup
end
end
# All normalized values should be UTF-8
@normalized_host.force_encoding(Encoding::UTF_8) if @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
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_host) if defined?(@normalized_host)
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
if @normalized_authority
@normalized_authority.force_encoding(Encoding::UTF_8)
end
@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 = defined?(new_password) ? new_password : nil
self.user = defined?(new_user) ? new_user : nil
self.host = defined?(new_host) ? new_host : nil
self.port = defined?(new_port) ? new_port : nil
# Reset dependent values
remove_instance_variable(:@userinfo) if defined?(@userinfo)
remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
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 = defined?(new_scheme) ? new_scheme : nil
self.host = defined?(new_host) ? new_host : nil
self.port = defined?(new_port) ? new_port : nil
self.userinfo = nil
# Reset dependent values
remove_instance_variable(:@userinfo) if defined?(@userinfo)
remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_authority) if defined?(@normalized_authority)
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:
# //:@:/
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.
def port
return defined?(@port) ? @port : nil
end
##
# The port component for this URI, normalized.
#
# @return [Integer] The port component, normalized.
def normalized_port
return nil unless self.port
return @normalized_port if defined?(@normalized_port)
@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
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_port) if defined?(@normalized_port)
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, "http://example.com/path?query" would have a
# site value of "http://example.com".
#
# @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, "http://example.com/path?query" would have a
# site value of "http://example.com".
#
# @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
@normalized_site.force_encoding(Encoding::UTF_8) if @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.
def path
return defined?(@path) ? @path : EMPTY_STR
end
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(delimeter, -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::CharacterClasses::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
@normalized_path.force_encoding(Encoding::UTF_8) if @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
remove_instance_variable(:@normalized_path) if defined?(@normalized_path)
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.
def query
return defined?(@query) ? @query : nil
end
##
# 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 if defined?(@normalized_query)
@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 = (self.query || "").split("&", -1)
pairs.delete_if(&:empty?) if flags.include?(:compacted)
pairs.sort! if flags.include?(:sorted)
component = pairs.map do |pair|
Addressable::URI.normalize_component(pair, modified_query_class, "+")
end.join("&")
component == "" ? nil : component
end
# All normalized values should be UTF-8
@normalized_query.force_encoding(Encoding::UTF_8) if @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
remove_instance_variable(:@normalized_query) if defined?(@normalized_query)
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)
# 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!
pair[1] = URI.unencode_component(pair[1].to_str.tr("+", " "))
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, CharacterClasses::UNRESERVED
)
if value == nil
buffer << "#{encoded_key}&"
elsif value.kind_of?(Array)
value.each do |sub_value|
encoded_value = URI.encode_component(
sub_value, CharacterClasses::UNRESERVED
)
buffer << "#{encoded_key}=#{encoded_value}&"
end
else
encoded_value = URI.encode_component(
value, CharacterClasses::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.
def fragment
return defined?(@fragment) ? @fragment : nil
end
##
# The fragment component for this URI, normalized.
#
# @return [String] The fragment component, normalized.
def normalized_fragment
return nil unless self.fragment
return @normalized_fragment if defined?(@normalized_fragment)
@normalized_fragment ||= begin
component = Addressable::URI.normalize_component(
self.fragment,
Addressable::URI::CharacterClasses::FRAGMENT
)
component == "" ? nil : component
end
# All normalized values should be UTF-8
if @normalized_fragment
@normalized_fragment.force_encoding(Encoding::UTF_8)
end
@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
remove_instance_variable(:@normalized_fragment) if defined?(@normalized_fragment)
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]
# true if the scheme indicates an IP-based protocol.
# false 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]
# true if the URI is relative. false
# otherwise.
def relative?
return self.scheme.nil?
end
##
# Determines if the URI is absolute.
#
# @return [TrueClass, FalseClass]
# true if the URI is absolute. false
# 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 join.
#
# @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 Hash of components.
# This method has different behavior from join. Any
# components present in the hash 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)
if !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 merge.
#
# @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 route_to.
#
# @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 route_from.
#
# @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 RFC 3986,
# 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 true if the URI objects are equal. This method
# normalizes both URIs before doing the comparison, and allows comparison
# against Strings.
#
# @param [Object] uri The URI to compare.
#
# @return [TrueClass, FalseClass]
# true if the URIs are equivalent, false
# 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 true 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]
# true if the URIs are equivalent, false
# otherwise.
def ==(uri)
return false unless uri.kind_of?(URI)
return self.normalize.to_s == uri.normalize.to_s
end
##
# Returns true 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]
# true if the URIs are equivalent, false
# 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")
# #=> #
# uri.omit(:scheme, :authority)
# #=> #
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 true if empty, false otherwise.
def empty?
return self.to_s.empty?
end
##
# Converts the URI to a String.
#
# @return [String] The URI's String 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 Strings. Allow implicit conversion.
alias_method :to_str, :to_s
##
# Returns a Hash of the URI components.
#
# @return [Hash] The URI as a Hash 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 String representation of the URI object's state.
#
# @return [String] The URI object's state, as a String.
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
return 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 nil if path.nil?
normalized_path = path.dup
begin
mod = nil
mod ||= normalized_path.gsub!(RULE_2A, SLASH)
pair = normalized_path.match(RULE_2B_2C)
parent, current = pair[1], pair[2] if pair
if pair && ((parent != SELF_REF && parent != PARENT) ||
(current != SELF_REF && current != PARENT))
mod ||= normalized_path.gsub!(
Regexp.new(
"/#{Regexp.escape(parent.to_s)}/\\.\\./|" +
"(/#{Regexp.escape(current.to_s)}/\\.\\.$)"
), 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)
end until mod.nil?
return 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 self with.
#
# @return [Addressable::URI] self.
def replace_self(uri)
# Reset dependent values
instance_variables.each do |var|
if instance_variable_defined?(var) && var != :@validation_deferred
remove_instance_variable(var)
end
end
@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] 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
remove_instance_variable(:@uri_string) if defined?(@uri_string)
remove_instance_variable(:@hash) if defined?(@hash)
end
end
end
addressable-2.7.0/lib/addressable/idna/ 0000755 0000041 0000041 00000000000 13534474053 017763 5 ustar www-data www-data addressable-2.7.0/lib/addressable/idna/pure.rb 0000644 0000041 0000041 00000047733 13534474053 021301 0 ustar www-data www-data # frozen_string_literal: true
# encoding:utf-8
#--
# 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
if input.respond_to?(:force_encoding)
input.force_encoding(Encoding::ASCII_8BIT)
end
if input =~ UTF8_REGEX && input =~ UTF8_REGEX_MULTIBYTE
parts = unicode_downcase(input).split('.')
parts.map! do |part|
if part.respond_to?(:force_encoding)
part.force_encoding(Encoding::ASCII_8BIT)
end
if part =~ UTF8_REGEX && part =~ UTF8_REGEX_MULTIBYTE
ACE_PREFIX + punycode_encode(unicode_normalize_kc(part))
else
part
end
end
parts.join('.')
else
input
end
end
# Converts from an ASCII domain name to a Unicode internationalized
# domain name as described in RFC 3490.
def self.to_unicode(input)
input = input.to_s unless input.is_a?(String)
parts = input.split('.')
parts.map! do |part|
if part =~ /^#{ACE_PREFIX}(.+)/
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
# Unicode normalization form KC.
def self.unicode_normalize_kc(input)
input = input.to_s unless input.is_a?(String)
unpacked = input.unpack("U*")
unpacked =
unicode_compose(unicode_sort_canonical(unicode_decompose(unpacked)))
return unpacked.pack("U*")
end
##
# Unicode aware downcase method.
#
# @api private
# @param [String] input
# The input string.
# @return [String] The downcased result.
def self.unicode_downcase(input)
input = input.to_s unless input.is_a?(String)
unpacked = input.unpack("U*")
unpacked.map! { |codepoint| lookup_unicode_lowercase(codepoint) }
return unpacked.pack("U*")
end
private_class_method :unicode_downcase
def self.unicode_compose(unpacked)
unpacked_result = []
length = unpacked.length
return unpacked if length == 0
starter = unpacked[0]
starter_cc = lookup_unicode_combining_class(starter)
starter_cc = 256 if starter_cc != 0
for i in 1...length
ch = unpacked[i]
if (starter_cc == 0 &&
(composite = unicode_compose_pair(starter, ch)) != nil)
starter = composite
else
unpacked_result << starter
starter = ch
end
end
unpacked_result << starter
return unpacked_result
end
private_class_method :unicode_compose
def self.unicode_compose_pair(ch_one, ch_two)
if ch_one >= HANGUL_LBASE && ch_one < HANGUL_LBASE + HANGUL_LCOUNT &&
ch_two >= HANGUL_VBASE && ch_two < HANGUL_VBASE + HANGUL_VCOUNT
# Hangul L + V
return HANGUL_SBASE + (
(ch_one - HANGUL_LBASE) * HANGUL_VCOUNT + (ch_two - HANGUL_VBASE)
) * HANGUL_TCOUNT
elsif ch_one >= HANGUL_SBASE &&
ch_one < HANGUL_SBASE + HANGUL_SCOUNT &&
(ch_one - HANGUL_SBASE) % HANGUL_TCOUNT == 0 &&
ch_two >= HANGUL_TBASE && ch_two < HANGUL_TBASE + HANGUL_TCOUNT
# Hangul LV + T
return ch_one + (ch_two - HANGUL_TBASE)
end
p = []
ucs4_to_utf8 = lambda do |ch|
if ch < 128
p << ch
elsif ch < 2048
p << (ch >> 6 | 192)
p << (ch & 63 | 128)
elsif ch < 0x10000
p << (ch >> 12 | 224)
p << (ch >> 6 & 63 | 128)
p << (ch & 63 | 128)
elsif ch < 0x200000
p << (ch >> 18 | 240)
p << (ch >> 12 & 63 | 128)
p << (ch >> 6 & 63 | 128)
p << (ch & 63 | 128)
elsif ch < 0x4000000
p << (ch >> 24 | 248)
p << (ch >> 18 & 63 | 128)
p << (ch >> 12 & 63 | 128)
p << (ch >> 6 & 63 | 128)
p << (ch & 63 | 128)
elsif ch < 0x80000000
p << (ch >> 30 | 252)
p << (ch >> 24 & 63 | 128)
p << (ch >> 18 & 63 | 128)
p << (ch >> 12 & 63 | 128)
p << (ch >> 6 & 63 | 128)
p << (ch & 63 | 128)
end
end
ucs4_to_utf8.call(ch_one)
ucs4_to_utf8.call(ch_two)
return lookup_unicode_composition(p)
end
private_class_method :unicode_compose_pair
def self.unicode_sort_canonical(unpacked)
unpacked = unpacked.dup
i = 1
length = unpacked.length
return unpacked if length < 2
while i < length
last = unpacked[i-1]
ch = unpacked[i]
last_cc = lookup_unicode_combining_class(last)
cc = lookup_unicode_combining_class(ch)
if cc != 0 && last_cc != 0 && last_cc > cc
unpacked[i] = last
unpacked[i-1] = ch
i -= 1 if i > 1
else
i += 1
end
end
return unpacked
end
private_class_method :unicode_sort_canonical
def self.unicode_decompose(unpacked)
unpacked_result = []
for cp in unpacked
if cp >= HANGUL_SBASE && cp < HANGUL_SBASE + HANGUL_SCOUNT
l, v, t = unicode_decompose_hangul(cp)
unpacked_result << l
unpacked_result << v if v
unpacked_result << t if t
else
dc = lookup_unicode_compatibility(cp)
unless dc
unpacked_result << cp
else
unpacked_result.concat(unicode_decompose(dc.unpack("U*")))
end
end
end
return unpacked_result
end
private_class_method :unicode_decompose
def self.unicode_decompose_hangul(codepoint)
sindex = codepoint - HANGUL_SBASE;
if sindex < 0 || sindex >= HANGUL_SCOUNT
l = codepoint
v = t = nil
return l, v, t
end
l = HANGUL_LBASE + sindex / HANGUL_NCOUNT
v = HANGUL_VBASE + (sindex % HANGUL_NCOUNT) / HANGUL_TCOUNT
t = HANGUL_TBASE + sindex % HANGUL_TCOUNT
if t == HANGUL_TBASE
t = nil
end
return l, v, t
end
private_class_method :unicode_decompose_hangul
def self.lookup_unicode_combining_class(codepoint)
codepoint_data = UNICODE_DATA[codepoint]
(codepoint_data ?
(codepoint_data[UNICODE_DATA_COMBINING_CLASS] || 0) :
0)
end
private_class_method :lookup_unicode_combining_class
def self.lookup_unicode_compatibility(codepoint)
codepoint_data = UNICODE_DATA[codepoint]
(codepoint_data ?
codepoint_data[UNICODE_DATA_COMPATIBILITY] : nil)
end
private_class_method :lookup_unicode_compatibility
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
def self.lookup_unicode_composition(unpacked)
return COMPOSITION_TABLE[unpacked]
end
private_class_method :lookup_unicode_composition
HANGUL_SBASE = 0xac00
HANGUL_LBASE = 0x1100
HANGUL_LCOUNT = 19
HANGUL_VBASE = 0x1161
HANGUL_VCOUNT = 21
HANGUL_TBASE = 0x11a7
HANGUL_TCOUNT = 28
HANGUL_NCOUNT = HANGUL_VCOUNT * HANGUL_TCOUNT # 588
HANGUL_SCOUNT = HANGUL_LCOUNT * HANGUL_NCOUNT # 11172
UNICODE_DATA_COMBINING_CLASS = 0
UNICODE_DATA_EXCLUSION = 1
UNICODE_DATA_CANONICAL = 2
UNICODE_DATA_COMPATIBILITY = 3
UNICODE_DATA_UPPERCASE = 4
UNICODE_DATA_LOWERCASE = 5
UNICODE_DATA_TITLECASE = 6
begin
if defined?(FakeFS)
fakefs_state = FakeFS.activated?
FakeFS.deactivate!
end
# This is a sparse Unicode table. Codepoints without entries are
# assumed to have the value: [0, 0, nil, nil, nil, nil, nil]
UNICODE_DATA = File.open(UNICODE_TABLE, "rb") do |file|
Marshal.load(file.read)
end
ensure
if defined?(FakeFS)
FakeFS.activate! if fakefs_state
end
end
COMPOSITION_TABLE = {}
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
# state to , 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
addressable-2.7.0/lib/addressable/idna/native.rb 0000644 0000041 0000041 00000003111 13534474053 021572 0 ustar www-data www-data # frozen_string_literal: true
# encoding:utf-8
#--
# 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
def self.unicode_normalize_kc(value)
IDN::Stringprep.nfkc_normalize(value.to_s)
end
def self.to_ascii(value)
value.to_s.split('.', -1).map do |segment|
if segment.size > 0 && 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
addressable-2.7.0/lib/addressable/idna.rb 0000644 0000041 0000041 00000001515 13534474053 020312 0 ustar www-data www-data # frozen_string_literal: true
# encoding:utf-8
#--
# 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
addressable-2.7.0/lib/addressable.rb 0000644 0000041 0000041 00000000130 13534474053 017367 0 ustar www-data www-data # frozen_string_literal: true
require 'addressable/uri'
require 'addressable/template'
addressable-2.7.0/Gemfile 0000644 0000041 0000041 00000001401 13534474053 015320 0 ustar www-data www-data source 'https://rubygems.org'
gemspec
group :test do
gem 'rspec', '~> 3.8'
gem 'rspec-its', '~> 1.3'
end
group :development do
gem 'launchy', '~> 2.4', '>= 2.4.3'
gem 'redcarpet', :platform => :mri_19
gem 'yard'
end
group :test, :development do
gem 'rake', '> 10.0', '< 12'
gem 'simplecov', :require => false
gem 'coveralls', :require => false, :platforms => [
:ruby_20, :ruby_21, :ruby_22, :ruby_23
]
# Used to test compatibility.
gem 'rack-mount', git: 'https://github.com/sporkmonger/rack-mount.git', require: 'rack/mount'
if RUBY_VERSION.start_with?('2.0', '2.1')
gem 'rack', '< 2', :require => false
else
gem 'rack', :require => false
end
end
gem 'idn-ruby', :platform => [:mri_20, :mri_21, :mri_22, :mri_23, :mri_24]
addressable-2.7.0/LICENSE.txt 0000644 0000041 0000041 00000025143 13534474053 015661 0 ustar www-data www-data
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.