addressable 2.3.6 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c062f20a75939191f680842716b9ce79816e8952
-  data.tar.gz: 4ff3027264ee6f61fe887f1035c4fa7c472f7c90
+SHA256:
+  metadata.gz: 03a21b1eab156a16e90bd7963af85980edfbddc8f3dbe052766303dba76cc000
+  data.tar.gz: 03eca5d86f4c70f9320000f36e3cff4fd8023342a4e0ac855d0ef1ec89ee6183
 SHA512:
-  metadata.gz: 26da95b6a6dd459054e700fa3ff906fbc5512dcc0ad2b3cb47e0b5a1a05d2722767605b8f62f044534425ffa4485a53e8132a816792136b37e80c3ff0c20bfbf
-  data.tar.gz: 9a0d4766e4faeb57353a6d14524e31610e77b84dd9dda33d51ba472db803197cc2989f3c6dc08623ebbc8e95850e331d8a065b9483483a8e78223c3887381283
+  metadata.gz: d504f9475ad823f5bb077b9c039a2c91c83e52c20896247a7289b61725c61b1ddefe8ae06155fb018fc67087cf04276081b42105a18394b45e2374ad0b2fadb0
+  data.tar.gz: b81766fbcb9335d5ca94403b62d3b2a6fae31b66cd3c05f48e1885eaf07883bfa1321b6930271fe1415135aec687af51312a26ce27bd4b83b2ac6424dec597c9

data/CHANGELOG.md

@@ -1,3 +1,79 @@
+# Addressable 2.8.0
+- fixes ReDoS vulnerability in Addressable::Template#match
+- no longer replaces `+` with spaces in queries for non-http(s) schemes
+- fixed encoding ipv6 literals
+- the `:compacted` flag for `normalized_query` now dedupes parameters
+- fix broken `escape_component` alias
+- dropping support for Ruby 2.0 and 2.1
+- adding Ruby 3.0 compatibility for development tasks
+- drop support for `rack-mount` and remove Addressable::Template#generate
+- performance improvements
+- switch CI/CD to GitHub Actions
+
+# Addressable 2.7.0
+- added `:compacted` flag to `normalized_query`
+- `heuristic_parse` handles `mailto:` more intuitively
+- dropped explicit support for JRuby 9.0.5.0
+- compatibility w/ public_suffix 4.x
+- performance improvements
+
+# Addressable 2.6.0
+- 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

data/Gemfile

@@ -1,28 +1,28 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
-group :development do
-  gem 'launchy'
-  gem 'yard'
-  gem 'redcarpet', :platform => :mri_19
-  gem 'rubyforge'
-end
+gemspec(path: __FILE__ == "(eval)" ? ".." : ".")
 
-group :test, :development do
-  gem 'rake', '>= 0.7.3'
-  gem 'rspec', '>= 2.9.0'
-  gem 'coveralls', :require => false
+group :test do
+  gem 'rspec', '~> 3.8'
+  gem 'rspec-its', '~> 1.3'
 end
 
-gem 'idn', :platform => :mri_18
-gem 'idn-ruby', :platform => :mri_19
+group :coverage do
+  gem "coveralls", "> 0.7", require: false, platforms: :mri
+  gem "simplecov", require: false
+end
 
-platforms :mri_18 do
-  gem 'mime-types', '~> 1.25'
+group :development do
+  gem 'launchy', '~> 2.4', '>= 2.4.3'
+  gem 'redcarpet', :platform => :mri_19
+  gem 'yard'
 end
 
-platforms :rbx do
-  gem 'rubysl', '~> 2.0'
-  gem 'rubinius-coverage'
+group :test, :development do
+  gem 'memory_profiler'
+  gem "rake", ">= 12.3.3"
 end
 
-gemspec
+gem "idn-ruby", platform: :mri

data/README.md

@@ -1,27 +1,29 @@
 # Addressable
 
 <dl>
-  <dt>Homepage</dt><dd><a href="http://addressable.rubyforge.org/">addressable.rubyforge.org</a></dd>
+  <dt>Homepage</dt><dd><a href="https://github.com/sporkmonger/addressable">github.com/sporkmonger/addressable</a></dd>
   <dt>Author</dt><dd><a href="mailto:bob@sporkmonger.com">Bob Aman</a></dd>
-  <dt>Copyright</dt><dd>Copyright © 2006-2013 Bob Aman</dd>
+  <dt>Copyright</dt><dd>Copyright © Bob Aman</dd>
   <dt>License</dt><dd>Apache 2.0</dd>
 </dl>
 
-[![Gem Version](https://badge.fury.io/rb/addressable.png)][gem]
-[![Build Status](https://secure.travis-ci.org/sporkmonger/addressable.png?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/sporkmonger/addressable.png?travis)][gemnasium]
-[![Coverage Status](https://coveralls.io/repos/sporkmonger/addressable/badge.png?branch=master)][coveralls]
+[![Gem Version](https://img.shields.io/gem/dt/addressable.svg)][gem]
+[![Build Status](https://github.com/sporkmonger/addressable/workflows/CI/badge.svg)][actions]
+[![Test Coverage Status](https://img.shields.io/coveralls/sporkmonger/addressable.svg)][coveralls]
+[![Documentation Coverage Status](https://inch-ci.org/github/sporkmonger/addressable.svg?branch=master)][inch]
 
 [gem]: https://rubygems.org/gems/addressable
-[travis]: http://travis-ci.org/sporkmonger/addressable
-[gemnasium]: https://gemnasium.com/sporkmonger/addressable
+[actions]: https://github.com/sporkmonger/addressable/actions
 [coveralls]: https://coveralls.io/r/sporkmonger/addressable
+[inch]: https://inch-ci.org/github/sporkmonger/addressable
 
 # Description
 
-Addressable is a replacement for the URI implementation that is part of
-Ruby's standard library. It more closely conforms to RFC 3986, RFC 3987, and
-RFC 6570 (level 4), providing support for IRIs and URI templates.
+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
 
@@ -56,7 +58,7 @@ For more details, see [RFC 6570](https://www.rfc-editor.org/rfc/rfc6570.txt).
 
 require "addressable/template"
 
-template = Addressable::Template.new("http://example.com/{?query*}/")
+template = Addressable::Template.new("http://example.com/{?query*}")
 template.expand({
   "query" => {
     'foo' => 'bar',
@@ -65,12 +67,12 @@ template.expand({
 })
 #=> #<Addressable::URI:0xc9d95c URI:http://example.com/?foo=bar&color=red>
 
-template = Addressable::Template.new("http://example.com/{?one,two,three}/")
+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}"
+  "http://{host}{/segments*}/{?one,two,bogus}{#fragment}"
 )
 uri = Addressable::URI.parse(
   "http://example.com/a/b/c/?one=1&two=2#foo"
@@ -89,14 +91,31 @@ template.extract(uri)
 # Install
 
 ```console
-$ sudo gem install addressable
+$ 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
-$ sudo brew install libidn # OS X
-$ sudo gem install idn-ruby
+$ sudo apt-get install libidn11-dev # Debian/Ubuntu
+$ brew install libidn # OS X
+$ gem install idn-ruby
+```
+
+# Semantic Versioning
+
+This project uses [Semantic Versioning](https://semver.org/). You can (and should) specify your
+dependency using a pessimistic version constraint covering the major and minor
+values:
+
+```ruby
+spec.add_dependency 'addressable', '~> 2.7'
+```
+
+If you need a specific bug fix, you can also specify minimum tiny versions
+without preventing updates to the latest minor release:
+
+```ruby
+spec.add_dependency 'addressable', '~> 2.3', '>= 2.3.7'
 ```

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'rake'
 
@@ -10,25 +12,20 @@ PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME       = "REL #{PKG_VERSION}"
 
-RUBY_FORGE_PROJECT = PKG_NAME
-RUBY_FORGE_USER    = "sporkmonger"
-RUBY_FORGE_PATH    = "/var/www/gforge-projects/#{RUBY_FORGE_PROJECT}"
-RUBY_FORGE_URL     = "http://#{RUBY_FORGE_PROJECT}.rubyforge.org/"
-
 PKG_SUMMARY        = "URI Implementation"
 PKG_DESCRIPTION    = <<-TEXT
-Addressable is a replacement for the URI implementation that is part of
-Ruby's standard library. It more closely conforms to the relevant RFCs and
-adds support for IRIs and URI templates.
+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/**/*", "website/**/*",
+    "tasks/**/*",
     "[A-Z]*", "Rakefile"
-].exclude(/database\.yml/).exclude(/Gemfile\.lock/).exclude(/[_\.]git$/)
+].exclude(/pkg/).exclude(/database\.yml/).
+  exclude(/Gemfile\.lock/).exclude(/[_\.]git$/)
 
-RCOV_ENABLED = (RUBY_PLATFORM != "java" && RUBY_VERSION =~ /^1\.8/)
 task :default => "spec"
 
 WINDOWS = (RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/) rescue false

data/addressable.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+# stub: addressable 2.8.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "addressable".freeze
+  s.version = "2.8.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 = "2021-07-03"
+  s.description = "Addressable is an alternative implementation to the URI implementation that is\npart of Ruby's standard library. It is flexible, offers heuristic parsing, and\nadditionally provides extensive support for IRIs and URI templates.\n".freeze
+  s.email = "bob@sporkmonger.com".freeze
+  s.extra_rdoc_files = ["README.md".freeze]
+  s.files = ["CHANGELOG.md".freeze, "Gemfile".freeze, "LICENSE.txt".freeze, "README.md".freeze, "Rakefile".freeze, "addressable.gemspec".freeze, "data/unicode.data".freeze, "lib/addressable.rb".freeze, "lib/addressable/idna.rb".freeze, "lib/addressable/idna/native.rb".freeze, "lib/addressable/idna/pure.rb".freeze, "lib/addressable/template.rb".freeze, "lib/addressable/uri.rb".freeze, "lib/addressable/version.rb".freeze, "spec/addressable/idna_spec.rb".freeze, "spec/addressable/net_http_compat_spec.rb".freeze, "spec/addressable/security_spec.rb".freeze, "spec/addressable/template_spec.rb".freeze, "spec/addressable/uri_spec.rb".freeze, "spec/spec_helper.rb".freeze, "tasks/clobber.rake".freeze, "tasks/gem.rake".freeze, "tasks/git.rake".freeze, "tasks/metrics.rake".freeze, "tasks/profile.rake".freeze, "tasks/rspec.rake".freeze, "tasks/yard.rake".freeze]
+  s.homepage = "https://github.com/sporkmonger/addressable".freeze
+  s.licenses = ["Apache-2.0".freeze]
+  s.rdoc_options = ["--main".freeze, "README.md".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.0".freeze)
+  s.rubygems_version = "3.0.3".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_runtime_dependency(%q<public_suffix>.freeze, [">= 2.0.2", "< 5.0"])
+      s.add_development_dependency(%q<bundler>.freeze, [">= 1.0", "< 3.0"])
+    else
+      s.add_dependency(%q<public_suffix>.freeze, [">= 2.0.2", "< 5.0"])
+      s.add_dependency(%q<bundler>.freeze, [">= 1.0", "< 3.0"])
+    end
+  else
+    s.add_dependency(%q<public_suffix>.freeze, [">= 2.0.2", "< 5.0"])
+    s.add_dependency(%q<bundler>.freeze, [">= 1.0", "< 3.0"])
+  end
+end

data/lib/addressable/idna/native.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
-# Copyright (C) 2006-2013 Bob Aman
+# 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.
@@ -21,23 +23,39 @@ require "idn"
 module Addressable
   module IDNA
     def self.punycode_encode(value)
-      IDN::Punycode.encode(value)
+      IDN::Punycode.encode(value.to_s)
     end
 
      def self.punycode_decode(value)
-       IDN::Punycode.decode(value)
+       IDN::Punycode.decode(value.to_s)
      end
 
     def self.unicode_normalize_kc(value)
-      IDN::Stringprep.nfkc_normalize(value)
+      IDN::Stringprep.nfkc_normalize(value.to_s)
     end
 
     def self.to_ascii(value)
-      IDN::Idna.toASCII(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)
-      IDN::Idna.toUnicode(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

data/lib/addressable/idna/pure.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
-# Copyright (C) 2006-2013 Bob Aman
+# 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.
@@ -64,6 +66,7 @@ module Addressable
     # 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)
@@ -89,10 +92,16 @@ module Addressable
     # Converts from an ASCII domain name to a Unicode internationalized
     # domain name as described in RFC 3490.
     def self.to_unicode(input)
+      input = input.to_s unless input.is_a?(String)
       parts = input.split('.')
       parts.map! do |part|
-        if part =~ /^#{ACE_PREFIX}/
-          punycode_decode(part[/^#{ACE_PREFIX}(.+)/, 1])
+        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
@@ -121,11 +130,12 @@ module Addressable
     #   The input string.
     # @return [String] The downcased result.
     def self.unicode_downcase(input)
+      input = input.to_s unless input.is_a?(String)
       unpacked = input.unpack("U*")
       unpacked.map! { |codepoint| lookup_unicode_lowercase(codepoint) }
       return unpacked.pack("U*")
     end
-    (class <<self; private :unicode_downcase; end)
+    private_class_method :unicode_downcase
 
     def self.unicode_compose(unpacked)
       unpacked_result = []
@@ -138,22 +148,19 @@ module Addressable
       starter_cc = 256 if starter_cc != 0
       for i in 1...length
         ch = unpacked[i]
-        cc = lookup_unicode_combining_class(ch)
 
         if (starter_cc == 0 &&
             (composite = unicode_compose_pair(starter, ch)) != nil)
           starter = composite
-          startercc = lookup_unicode_combining_class(composite)
         else
           unpacked_result << starter
           starter = ch
-          startercc = cc
         end
       end
       unpacked_result << starter
       return unpacked_result
     end
-    (class <<self; private :unicode_compose; end)
+    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 &&
@@ -171,44 +178,45 @@ module Addressable
       end
 
       p = []
-      ucs4_to_utf8 = lambda do |ch|
-        # For some reason, rcov likes to drop BUS errors here.
-        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)
+      ucs4_to_utf8(ch_one, p)
+      ucs4_to_utf8(ch_two, p)
 
       return lookup_unicode_composition(p)
     end
-    (class <<self; private :unicode_compose_pair; end)
+    private_class_method :unicode_compose_pair
+
+    def self.ucs4_to_utf8(char, buffer)
+      if char < 128
+        buffer << char
+      elsif char < 2048
+        buffer << (char >> 6 | 192)
+        buffer << (char & 63 | 128)
+      elsif char < 0x10000
+        buffer << (char >> 12 | 224)
+        buffer << (char >> 6 & 63 | 128)
+        buffer << (char & 63 | 128)
+      elsif char < 0x200000
+        buffer << (char >> 18 | 240)
+        buffer << (char >> 12 & 63 | 128)
+        buffer << (char >> 6 & 63 | 128)
+        buffer << (char & 63 | 128)
+      elsif char < 0x4000000
+        buffer << (char >> 24 | 248)
+        buffer << (char >> 18 & 63 | 128)
+        buffer << (char >> 12 & 63 | 128)
+        buffer << (char >> 6 & 63 | 128)
+        buffer << (char & 63 | 128)
+      elsif char < 0x80000000
+        buffer << (char >> 30 | 252)
+        buffer << (char >> 24 & 63 | 128)
+        buffer << (char >> 18 & 63 | 128)
+        buffer << (char >> 12 & 63 | 128)
+        buffer << (char >> 6 & 63 | 128)
+        buffer << (char & 63 | 128)
+      end
+    end
+    private_class_method :ucs4_to_utf8
 
     def self.unicode_sort_canonical(unpacked)
       unpacked = unpacked.dup
@@ -232,7 +240,7 @@ module Addressable
       end
       return unpacked
     end
-    (class <<self; private :unicode_sort_canonical; end)
+    private_class_method :unicode_sort_canonical
 
     def self.unicode_decompose(unpacked)
       unpacked_result = []
@@ -253,7 +261,7 @@ module Addressable
       end
       return unpacked_result
     end
-    (class <<self; private :unicode_decompose; end)
+    private_class_method :unicode_decompose
 
     def self.unicode_decompose_hangul(codepoint)
       sindex = codepoint - HANGUL_SBASE;
@@ -270,7 +278,7 @@ module Addressable
       end
       return l, v, t
     end
-    (class <<self; private :unicode_decompose_hangul; end)
+    private_class_method :unicode_decompose_hangul
 
     def self.lookup_unicode_combining_class(codepoint)
       codepoint_data = UNICODE_DATA[codepoint]
@@ -278,14 +286,14 @@ module Addressable
         (codepoint_data[UNICODE_DATA_COMBINING_CLASS] || 0) :
         0)
     end
-    (class <<self; private :lookup_unicode_combining_class; 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
-    (class <<self; private :lookup_unicode_compatibility; end)
+    private_class_method :lookup_unicode_compatibility
 
     def self.lookup_unicode_lowercase(codepoint)
       codepoint_data = UNICODE_DATA[codepoint]
@@ -293,12 +301,12 @@ module Addressable
         (codepoint_data[UNICODE_DATA_LOWERCASE] || codepoint) :
         codepoint)
     end
-    (class <<self; private :lookup_unicode_lowercase; end)
+    private_class_method :lookup_unicode_lowercase
 
     def self.lookup_unicode_composition(unpacked)
       return COMPOSITION_TABLE[unpacked]
     end
-    (class <<self; private :lookup_unicode_composition; end)
+    private_class_method :lookup_unicode_composition
 
     HANGUL_SBASE =  0xac00
     HANGUL_LBASE =  0x1100
@@ -335,7 +343,7 @@ module Addressable
     end
 
     COMPOSITION_TABLE = {}
-    for codepoint, data in UNICODE_DATA
+    UNICODE_DATA.each do |codepoint, data|
       canonical = data[UNICODE_DATA_CANONICAL]
       exclusion = data[UNICODE_DATA_EXCLUSION]
 
@@ -376,6 +384,7 @@ module Addressable
     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
@@ -484,7 +493,7 @@ module Addressable
       outlen.times do |j|
         c = output[j]
         unless c >= 0 && c <= 127
-          raise Exception, "Invalid output char."
+          raise StandardError, "Invalid output char."
         end
         unless PUNYCODE_PRINT_ASCII[c]
           raise PunycodeBadInput, "Input is invalid."
@@ -493,7 +502,7 @@ module Addressable
 
       output[0..outlen].map { |x| x.chr }.join("").sub(/\0+\z/, "")
     end
-    (class <<self; private :punycode_encode; end)
+    private_class_method :punycode_encode
 
     def self.punycode_decode(punycode)
       input = []
@@ -615,22 +624,22 @@ module Addressable
 
       output.pack("U*")
     end
-    (class <<self; private :punycode_decode; end)
+    private_class_method :punycode_decode
 
     def self.punycode_basic?(codepoint)
       codepoint < 0x80
     end
-    (class <<self; private :punycode_basic?; end)
+    private_class_method :punycode_basic?
 
     def self.punycode_delimiter?(codepoint)
       codepoint == PUNYCODE_DELIMITER
     end
-    (class <<self; private :punycode_delimiter?; end)
+    private_class_method :punycode_delimiter?
 
     def self.punycode_encode_digit(d)
       d + 22 + 75 * ((d < 26) ? 1 : 0)
     end
-    (class <<self; private :punycode_encode_digit; 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
@@ -646,7 +655,7 @@ module Addressable
         PUNYCODE_BASE
       end
     end
-    (class <<self; private :punycode_decode_digit; end)
+    private_class_method :punycode_decode_digit
 
     # Bias adaptation method
     def self.punycode_adapt(delta, numpoints, firsttime)
@@ -663,7 +672,7 @@ module Addressable
 
       k + (difference + 1) * delta / (delta + PUNYCODE_SKEW)
     end
-    (class <<self; private :punycode_adapt; end)
+    private_class_method :punycode_adapt
   end
   # :startdoc:
 end

data/lib/addressable/idna.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
-# Copyright (C) 2006-2013 Bob Aman
+# 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.