addressable 2.3.8 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42b16f73eeb6e9fe31be8acca16028ec89e5a083
-  data.tar.gz: 988538325db6737260f2ac394e84d349fdbe2f79
+  metadata.gz: 77783a5c4c07f7a0862f0efaeb2619a278e32391
+  data.tar.gz: 8edbb65fa242ce03cf2403c192d2358da64a095b
 SHA512:
-  metadata.gz: be930a660ee582f6d780ab759085489652f9c5a68d51177247b1aff10e06df0e95a2d149f0c37206e1d5e4b2dc63fca24b6e46aaed3082c26e3b2ee9e3c718d8
-  data.tar.gz: 03eba1032a368e484693085431a5890cbec4c09290c69d06b71a5c59d088bd1be11632d9d32581f2f20d37939b466bcbc98dcfc1a870f086feb6267a8755eacf
+  metadata.gz: b3345827151e1d04e5c532cca1e8e63337b0ce9d9f0e276861ed6be95b114827f68d5f74e5bea857db1faaf7a70a928159436f5e51cbbecc4a6db64145d28ea2
+  data.tar.gz: 86e4d5c946972502c8ac79bf2582d0d6894db23fa2e285c69b8dae0d1e16fcad447e7f8f393eeb9e9891f0a30e0971f864449b6dfaf4104bee080cfb3dfe4af4

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 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

data/Gemfile

@@ -2,26 +2,26 @@ source 'https://rubygems.org'
 
 gemspec
 
+gem 'rake', '~> 10.4', '>= 10.4.2'
+
+group :test do
+  gem 'rspec', '~> 3.0'
+  gem 'rspec-its', '~> 1.1'
+end
+
 group :development do
-  gem 'yard'
+  gem 'launchy', '~> 2.4', '>= 2.4.3'
   gem 'redcarpet', :platform => :mri_19
-  gem 'rubyforge'
+  gem 'yard'
 end
 
 group :test, :development do
+  gem 'simplecov', :require => false
   gem 'coveralls', :require => false, :platforms => [
     :ruby_19, :ruby_20, :ruby_21, :rbx, :jruby
   ]
+  # Used to test compatibility.
+  gem 'rack-mount', git: 'https://github.com/sporkmonger/rack-mount.git', require: 'rack/mount'
 end
 
-gem 'idn', :platform => :mri_18
-gem 'idn-ruby', :platform => :mri_19
-
-platforms :ruby_18 do
-  gem 'mime-types', '~> 1.25'
-  gem 'rest-client', '~> 1.6.8'
-end
-
-platforms :rbx do
-  gem 'rubysl-openssl', '2.2.1'
-end
+gem 'idn-ruby', :platform => [:mri_19, :mri_20, :mri_21, :mri_22]

data/README.md

@@ -1,7 +1,7 @@
 # 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-2015 Bob Aman</dd>
   <dt>License</dt><dd>Apache 2.0</dd>
@@ -68,7 +68,7 @@ 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"
 
@@ -100,6 +100,6 @@ idn gem:
 
 ```console
 $ sudo apt-get install idn # Debian/Ubuntu
-$ sudo brew install libidn # OS X
-$ sudo gem install idn-ruby
+$ brew install libidn # OS X
+$ gem install idn-ruby
 ```

data/Rakefile

@@ -19,11 +19,11 @@ 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

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

data/lib/addressable.rb

@@ -0,0 +1,2 @@
+require 'addressable/uri'
+require 'addressable/template'

data/lib/addressable/idna/pure.rb

@@ -93,7 +93,7 @@ module Addressable
       input = input.to_s unless input.is_a?(String)
       parts = input.split('.')
       parts.map! do |part|
-        if part =~ /^#{ACE_PREFIX}/
+        if part =~ /^#{ACE_PREFIX}(.+)/
           punycode_decode(part[/^#{ACE_PREFIX}(.+)/, 1])
         else
           part
@@ -175,7 +175,6 @@ module Addressable
 
       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
@@ -488,7 +487,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."

data/lib/addressable/template.rb

@@ -234,7 +234,18 @@ module Addressable
       if !pattern.respond_to?(:to_str)
         raise TypeError, "Can't convert #{pattern.class} into String."
       end
-      @pattern = pattern.to_str.freeze
+      @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
 
     ##
@@ -592,6 +603,7 @@ module Addressable
       @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
@@ -603,9 +615,75 @@ module Addressable
         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 <<processor
+          attr_accessor :block
+          def transform(name, value)
+            block.call(name, value)
+          end
+        end
+        processor.block = options[:parameterize]
+      else
+        processor = nil
+      end
+      result = self.expand(merged, processor)
+      result.to_s if result
+    end
+
   private
     def ordered_variable_defaults
-      @ordered_variable_defaults ||= (
+      @ordered_variable_defaults ||= begin
         expansions, _ = parse_template_pattern(pattern)
         expansions.map do |capture|
           _, _, varlist = *capture.match(EXPRESSION)
@@ -613,7 +691,7 @@ module Addressable
             varspec[VARSPEC, 1]
           end
         end.flatten
-      )
+      end
     end
 
 
@@ -642,19 +720,54 @@ module Addressable
     # @return [String] The expanded expression
     def transform_partial_capture(mapping, capture, processor = nil)
       _, operator, varlist = *capture.match(EXPRESSION)
-      is_first = true
-      varlist.split(',').inject('') do |acc, varspec|
-        _, name, _ = *varspec.match(VARSPEC)
-        value = mapping[name]
-        if value
-          operator = '&' if !is_first && operator == '?'
-          acc << transform_capture(mapping, "{#{operator}#{varspec}}", processor)
-        else
-          operator = '&' if !is_first && operator == '?'
-          acc << "{#{operator}#{varspec}}"
+
+      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
+        }
+
+        vars = [first_to_expand] + vars.reject {|varspec| varspec == first_to_expand}  if first_to_expand
+      end
+
+      vars
+        .zip(operator_sequence(operator).take(vars.length))
+        .reduce("") do |acc, (varspec, op)|
+          _, name, _ =  *varspec.match(VARSPEC)
+
+          acc << if mapping.key? name
+                   transform_capture(mapping, "{#{op}#{varspec}}", processor)
+                 else
+                   "{#{op}#{varspec}}"
+                 end
+      end
+    end
+
+    ##
+    # Creates a lazy Enumerator of the operators that should be used to expand
+    # variables in a varlist starting with `operator`. For example, an operator
+    # `"?"` results in the sequence `"?","&","&"...`
+    #
+    # @param [String] operator from which to generate a sequence
+    #
+    # @return [Enumerator] sequence of operators
+    def operator_sequence(operator)
+      rest_operator = if "?" == operator
+                        "&"
+                      else
+                        operator
+                      end
+      head_operator = operator
+
+      Enumerator.new do |y|
+        y << head_operator.to_s
+        while true
+          y << rest_operator.to_s
         end
-        is_first = false
-        acc
       end
     end
 
@@ -899,7 +1012,7 @@ module Addressable
 
           result = processor && processor.respond_to?(:match) ? processor.match(name) : nil
           if result
-            "(#{ result })"
+            "(?<#{name}>#{ result })"
           else
             group = case operator
             when '+'
@@ -920,9 +1033,9 @@ module Addressable
               "#{ UNRESERVED }*?"
             end
             if modifier == '*'
-              "(#{group}(?:#{joiner}?#{group})*)?"
+              "(?<#{name}>#{group}(?:#{joiner}?#{group})*)?"
             else
-              "(#{group})?"
+              "(?<#{name}>#{group})?"
             end
           end
         end.join("#{joiner}?")

data/lib/addressable/uri.rb

@@ -19,10 +19,6 @@
 require "addressable/version"
 require "addressable/idna"
 
-if RUBY_VERSION =~ /^1.8/
-  warn('Support for Ruby 1.8.x in Addressable is deprecated.')
-end
-
 ##
 # Addressable is a library for processing links and URIs.
 module Addressable
@@ -48,6 +44,7 @@ module Addressable
       UNRESERVED = ALPHA + DIGIT + "\\-\\.\\_\\~"
       PCHAR = UNRESERVED + SUB_DELIMS + "\\:\\@"
       SCHEME = ALPHA + DIGIT + "\\-\\+\\."
+      HOST = ALPHA + DIGIT + "\\-\\.\\[\\:\\]"
       AUTHORITY = PCHAR
       PATH = PCHAR + "\\/"
       QUERY = PCHAR + "\\/\\?"
@@ -724,9 +721,9 @@ module Addressable
           ).gsub("%20", "+")
         ]
       end
-      return (escaped_form_values.map do |(key, value)|
+      return escaped_form_values.map do |(key, value)|
         "#{key}=#{value}"
-      end).join("&")
+      end.join("&")
     end
 
     ##
@@ -835,7 +832,7 @@ module Addressable
     #
     # @return [String] The scheme component.
     def scheme
-      return instance_variable_defined?(:@scheme) ? @scheme : nil
+      return defined?(@scheme) ? @scheme : nil
     end
 
     ##
@@ -843,7 +840,8 @@ module Addressable
     #
     # @return [String] The scheme component, normalized.
     def normalized_scheme
-      self.scheme && @normalized_scheme ||= (begin
+      return nil unless self.scheme
+      @normalized_scheme ||= begin
         if self.scheme =~ /^\s*ssh\+svn\s*$/i
           "svn+ssh"
         else
@@ -852,7 +850,7 @@ module Addressable
             Addressable::URI::CharacterClasses::SCHEME
           )
         end
-      end)
+      end
     end
 
     ##
@@ -865,16 +863,15 @@ module Addressable
       elsif new_scheme
         new_scheme = new_scheme.to_str
       end
-      if new_scheme && new_scheme !~ /[a-z][a-z0-9\.\+\-]*/i
-        raise InvalidURIError, "Invalid scheme format."
+      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 dependant values
-      @normalized_scheme = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@normalized_scheme) if defined?(@normalized_scheme)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -885,7 +882,7 @@ module Addressable
     #
     # @return [String] The user component.
     def user
-      return instance_variable_defined?(:@user) ? @user : nil
+      return defined?(@user) ? @user : nil
     end
 
     ##
@@ -893,7 +890,9 @@ module Addressable
     #
     # @return [String] The user component, normalized.
     def normalized_user
-      self.user && @normalized_user ||= (begin
+      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
@@ -903,7 +902,7 @@ module Addressable
             Addressable::URI::CharacterClasses::UNRESERVED
           )
         end
-      end)
+      end
     end
 
     ##
@@ -921,13 +920,12 @@ module Addressable
         @user = EMPTY_STR if @user.nil?
       end
 
-      # Reset dependant values
-      @userinfo = nil
-      @normalized_userinfo = nil
-      @authority = nil
-      @normalized_user = nil
-      @uri_string = nil
-      @hash = 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_user) if defined?(@normalized_user)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -938,7 +936,7 @@ module Addressable
     #
     # @return [String] The password component.
     def password
-      return instance_variable_defined?(:@password) ? @password : nil
+      return defined?(@password) ? @password : nil
     end
 
     ##
@@ -946,7 +944,9 @@ module Addressable
     #
     # @return [String] The password component, normalized.
     def normalized_password
-      self.password && @normalized_password ||= (begin
+      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
@@ -956,7 +956,7 @@ module Addressable
             Addressable::URI::CharacterClasses::UNRESERVED
           )
         end
-      end)
+      end
     end
 
     ##
@@ -976,13 +976,12 @@ module Addressable
         @user = EMPTY_STR if @user.nil?
       end
 
-      # Reset dependant values
-      @userinfo = nil
-      @normalized_userinfo = nil
-      @authority = nil
-      @normalized_password = nil
-      @uri_string = nil
-      @hash = 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_password) if defined?(@normalized_password)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -996,13 +995,13 @@ module Addressable
     def userinfo
       current_user = self.user
       current_password = self.password
-      (current_user || current_password) && @userinfo ||= (begin
+      (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
     end
 
     ##
@@ -1010,7 +1009,9 @@ module Addressable
     #
     # @return [String] The userinfo component, normalized.
     def normalized_userinfo
-      self.userinfo && @normalized_userinfo ||= (begin
+      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
@@ -1020,7 +1021,7 @@ module Addressable
         elsif current_user && !current_password
           "#{current_user}"
         end
-      end)
+      end
     end
 
     ##
@@ -1044,10 +1045,9 @@ module Addressable
       self.password = new_password
       self.user = new_user
 
-      # Reset dependant values
-      @authority = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@authority) if defined?(@authority)
+      remove_composite_values
 
       # Ensure we haven't created an invalid URI
       validate()
@@ -1058,7 +1058,7 @@ module Addressable
     #
     # @return [String] The host component.
     def host
-      return instance_variable_defined?(:@host) ? @host : nil
+      return defined?(@host) ? @host : nil
     end
 
     ##
@@ -1066,7 +1066,8 @@ module Addressable
     #
     # @return [String] The host component, normalized.
     def normalized_host
-      self.host && @normalized_host ||= (begin
+      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)
@@ -1075,11 +1076,14 @@ module Addressable
             # Single trailing dots are unnecessary.
             result = result[0...-1]
           end
+          result = Addressable::URI.normalize_component(
+            result,
+            CharacterClasses::HOST)
           result
         else
           EMPTY_STR
         end
-      end)
+      end
     end
 
     ##
@@ -1094,17 +1098,16 @@ module Addressable
 
       unreserved = CharacterClasses::UNRESERVED
       sub_delims = CharacterClasses::SUB_DELIMS
-      if @host != nil && (@host =~ /[<>{}\/\?\#\@]/ ||
+      if !@host.nil? && (@host =~ /[<>{}\/\?\#\@"[[:space:]]]/ ||
           (@host[/^\[(.*)\]$/, 1] != nil && @host[/^\[(.*)\]$/, 1] !~
           Regexp.new("^[#{unreserved}#{sub_delims}:]*$")))
         raise InvalidURIError, "Invalid character in host: '#{@host.to_s}'"
       end
 
-      # Reset dependant values
-      @authority = nil
-      @normalized_host = nil
-      @uri_string = nil
-      @hash = 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()
@@ -1130,7 +1133,10 @@ module Addressable
     #
     # @param [String, #to_str] new_hostname The new hostname for this URI.
     def hostname=(new_hostname)
-      if new_hostname && !new_hostname.respond_to?(:to_str)
+      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
@@ -1144,7 +1150,7 @@ module Addressable
     #
     # @return [String] The authority component.
     def authority
-      self.host && @authority ||= (begin
+      self.host && @authority ||= begin
         authority = ""
         if self.userinfo != nil
           authority << "#{self.userinfo}@"
@@ -1154,7 +1160,7 @@ module Addressable
           authority << ":#{self.port}"
         end
         authority
-      end)
+      end
     end
 
     ##
@@ -1162,7 +1168,8 @@ module Addressable
     #
     # @return [String] The authority component, normalized.
     def normalized_authority
-      self.authority && @normalized_authority ||= (begin
+      return nil unless self.authority
+      @normalized_authority ||= begin
         authority = ""
         if self.normalized_userinfo != nil
           authority << "#{self.normalized_userinfo}@"
@@ -1172,7 +1179,7 @@ module Addressable
           authority << ":#{self.normalized_port}"
         end
         authority
-      end)
+      end
     end
 
     ##
@@ -1205,11 +1212,10 @@ module Addressable
       self.host = defined?(new_host) ? new_host : nil
       self.port = defined?(new_port) ? new_port : nil
 
-      # Reset dependant values
-      @userinfo = nil
-      @normalized_userinfo = nil
-      @uri_string = nil
-      @hash = 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()
@@ -1221,18 +1227,55 @@ module Addressable
     #
     # @return [String] The serialized origin.
     def origin
-      return (if self.scheme && self.authority
+      if self.scheme && self.authority
         if self.normalized_port
-          (
-            "#{self.normalized_scheme}://#{self.normalized_host}" +
-            ":#{self.normalized_port}"
-          )
+          "#{self.normalized_scheme}://#{self.normalized_host}" +
+          ":#{self.normalized_port}"
         else
           "#{self.normalized_scheme}://#{self.normalized_host}"
         end
       else
         "null"
-      end)
+      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
@@ -1256,7 +1299,7 @@ module Addressable
     #
     # @return [Integer] The port component.
     def port
-      return instance_variable_defined?(:@port) ? @port : nil
+      return defined?(@port) ? @port : nil
     end
 
     ##
@@ -1264,10 +1307,14 @@ module Addressable
     #
     # @return [Integer] The port component, normalized.
     def normalized_port
-      if URI.port_mapping[self.normalized_scheme] == self.port
-        nil
-      else
-        self.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
 
@@ -1279,6 +1326,11 @@ module Addressable
       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}"
@@ -1287,11 +1339,10 @@ module Addressable
       @port = new_port.to_s.to_i
       @port = nil if @port == 0
 
-      # Reset dependant values
-      @authority = nil
-      @normalized_port = nil
-      @uri_string = nil
-      @hash = nil
+      # 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()
@@ -1331,12 +1382,12 @@ module Addressable
     #
     # @return [String] The components that identify a site.
     def site
-      (self.scheme || self.authority) && @site ||= (begin
+      (self.scheme || self.authority) && @site ||= begin
         site_string = ""
         site_string << "#{self.scheme}:" if self.scheme != nil
         site_string << "//#{self.authority}" if self.authority != nil
         site_string
-      end)
+      end
     end
 
     ##
@@ -1349,7 +1400,8 @@ module Addressable
     #
     # @return [String] The normalized components that identify a site.
     def normalized_site
-      self.site && @normalized_site ||= (begin
+      return nil unless self.site
+      @normalized_site ||= begin
         site_string = ""
         if self.normalized_scheme != nil
           site_string << "#{self.normalized_scheme}:"
@@ -1358,7 +1410,7 @@ module Addressable
           site_string << "//#{self.normalized_authority}"
         end
         site_string
-      end)
+      end
     end
 
     ##
@@ -1388,7 +1440,7 @@ module Addressable
     #
     # @return [String] The path component.
     def path
-      return instance_variable_defined?(:@path) ? @path : EMPTY_STR
+      return defined?(@path) ? @path : EMPTY_STR
     end
 
     NORMPATH = /^(?!\/)[^\/:]*:.*$/
@@ -1397,7 +1449,7 @@ module Addressable
     #
     # @return [String] The path component, normalized.
     def normalized_path
-      @normalized_path ||= (begin
+      @normalized_path ||= begin
         path = self.path.to_s
         if self.scheme == nil && path =~ NORMPATH
           # Relative paths with colons in the first segment are ambiguous.
@@ -1405,12 +1457,12 @@ module Addressable
         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|
+        result = path.strip.split(SLASH, -1).map do |segment|
           Addressable::URI.normalize_component(
             segment,
             Addressable::URI::CharacterClasses::PCHAR
           )
-        end).join(SLASH)
+        end.join(SLASH)
 
         result = URI.normalize_path(result)
         if result.empty? &&
@@ -1418,7 +1470,7 @@ module Addressable
           result = SLASH
         end
         result
-      end)
+      end
     end
 
     ##
@@ -1434,10 +1486,9 @@ module Addressable
         @path = "/#{@path}"
       end
 
-      # Reset dependant values
-      @normalized_path = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@normalized_path) if defined?(@normalized_path)
+      remove_composite_values
     end
 
     ##
@@ -1464,7 +1515,7 @@ module Addressable
     #
     # @return [String] The query component.
     def query
-      return instance_variable_defined?(:@query) ? @query : nil
+      return defined?(@query) ? @query : nil
     end
 
     ##
@@ -1472,15 +1523,19 @@ module Addressable
     #
     # @return [String] The query component, normalized.
     def normalized_query(*flags)
-      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.sort! if flags.include?(:sorted)
-      component = (pairs.map do |pair|
-        Addressable::URI.normalize_component(pair, modified_query_class, "+")
-      end).join("&")
-      component == "" ? nil : component
+      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.sort! if flags.include?(:sorted)
+        component = pairs.map do |pair|
+          Addressable::URI.normalize_component(pair, modified_query_class, "+")
+        end.join("&")
+        component == "" ? nil : component
+      end
     end
 
     ##
@@ -1493,10 +1548,9 @@ module Addressable
       end
       @query = new_query ? new_query.to_str : nil
 
-      # Reset dependant values
-      @normalized_query = nil
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_instance_variable(:@normalized_query) if defined?(@normalized_query)
+      remove_composite_values
     end
 
     ##
@@ -1525,9 +1579,9 @@ module Addressable
         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|
+      split_query = self.query.split("&").map do |pair|
         pair.split("=", 2) if pair && !pair.empty?
-      end).compact
+      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,
@@ -1647,9 +1701,8 @@ module Addressable
       self.path = path_component
       self.query = query_component
 
-      # Reset dependant values
-      @uri_string = nil
-      @hash = nil
+      # Reset dependent values
+      remove_composite_values
     end
 
     ##
@@ -1657,7 +1710,7 @@ module Addressable
     #
     # @return [String] The fragment component.
     def fragment
-      return instance_variable_defined?(:@fragment) ? @fragment : nil
+      return defined?(@fragment) ? @fragment : nil
     end
 
     ##
@@ -1665,13 +1718,15 @@ module Addressable
     #
     # @return [String] The fragment component, normalized.
     def normalized_fragment
-      self.fragment && @normalized_fragment ||= (begin
+      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)
+      end
     end
 
     ##
@@ -1684,10 +1739,9 @@ module Addressable
       end
       @fragment = new_fragment ? new_fragment.to_str : nil
 
-      # Reset dependant values
-      @normalized_fragment = nil
-      @uri_string = nil
-      @hash = 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()
@@ -2108,7 +2162,7 @@ module Addressable
     #
     # @return [Integer] A hash of the URI.
     def hash
-      return @hash ||= (self.to_s.hash * -1)
+      @hash ||= self.to_s.hash * -1
     end
 
     ##
@@ -2191,7 +2245,7 @@ module Addressable
         raise InvalidURIError,
           "Cannot assemble URI string with ambiguous path: '#{self.path}'"
       end
-      @uri_string ||= (begin
+      @uri_string ||= begin
         uri_string = ""
         uri_string << "#{self.scheme}:" if self.scheme != nil
         uri_string << "//#{self.authority}" if self.authority != nil
@@ -2202,7 +2256,7 @@ module Addressable
           uri_string.force_encoding(Encoding::UTF_8)
         end
         uri_string
-      end)
+      end
     end
 
     ##
@@ -2251,7 +2305,7 @@ module Addressable
       return nil
     end
 
-  private
+  protected
     SELF_REF = '.'
     PARENT = '..'
 
@@ -2328,9 +2382,9 @@ module Addressable
     #
     # @return [Addressable::URI] <code>self</code>.
     def replace_self(uri)
-      # Reset dependant values
+      # Reset dependent values
       instance_variables.each do |var|
-        instance_variable_set(var, nil)
+        remove_instance_variable(var) if instance_variable_defined?(var)
       end
 
       @scheme = uri.scheme
@@ -2345,7 +2399,7 @@ module Addressable
     end
 
     ##
-    # Splits path string with "/"(slash).
+    # Splits path string with "/" (slash).
     # It is considered that there is empty string after last slash when
     # path ends with slash.
     #
@@ -2357,5 +2411,14 @@ module Addressable
       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