uniform_resource_identifier 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Ryan Scott Lewis 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/uniform_resource_identifier.rb

@@ -0,0 +1,214 @@
+require 'uniform_resource_identifier/authority'
+require 'uniform_resource_identifier/relative'
+
+class UniformResourceIdentifier
+  extend Parsable
+  
+  def initialize(uri=nil)
+    if uri.respond_to?(:to_str)
+      parsed_uri = Parser.parse(uri)
+      
+      @protocol = parsed_uri[:protocol]
+      
+      @authority = Authority.new(
+        :user_info => {
+          :username => parsed_uri[:username],
+          :password => parsed_uri[:password]
+        },
+        :host => parsed_uri[:host],
+        :port => parsed_uri[:port]
+      )
+      
+      @relative = Relative.new(
+        :path => {
+          :directory => parsed_uri[:directory],
+          :file => parsed_uri[:file]
+        },
+        :query => parsed_uri[:query],
+        :anchor => parsed_uri[:anchor]
+      )
+    elsif uri.respond_to?(:to_hash)
+      uri = uri.to_hash.symbolize_keys
+      
+      @protocol = uri[:protocol].to_s if uri.has_key?(:protocol)
+      @authority = Authority.parse(uri[:authority]) if uri.has_key?(:authority)
+      @relative = Relative.parse(uri[:relative]) if uri.has_key?(:relative)
+    else
+      raise(TypeError, "uri must either be a String or a Hash") unless uri.nil?
+    end
+  end
+  
+  def to_s
+    protocol = "#{@protocol}://" unless @protocol.nil?
+    "#{protocol}#{@authority}#{@relative}"
+  end
+  
+  def to_h
+    {
+      :protocol => @protocol,
+      :authority => @authority.nil? ? nil : @authority.to_h,
+      :relative => @relative.nil? ? nil : @relative.to_h
+    }
+  end
+  
+  # ======================================================================= #
+  # = Attributes                                                          = #
+  # ======================================================================= #
+  
+  attr_reader :protocol
+  
+  def protocol=(protocol)
+    @protocol = protocol.nil? ? nil : protocol.to_s
+  end
+  
+  alias_method :scheme, :protocol
+  alias_method :scheme=, :protocol=
+  
+  def authority
+    @authority ||= Authority.new
+  end
+  
+  def authority=(authority)
+    @authority = Authority.parse(authority)
+  end
+  
+  def relative
+    @relative ||= Relative.new
+  end
+  
+  def relative=(relative)
+    @relative = Relative.parse(relative)
+  end
+  
+  # ======================================================================= #
+  # = Delegates                                                           = #
+  # ======================================================================= #
+  
+  def user_info
+    self.authority.user_info
+  end
+  
+  def user_info=(user_info)
+    self.authority.user_info = user_info
+  end
+  
+  def username
+    self.authority.user_info.username
+  end
+  
+  def username=(username)
+    self.authority.user_info.username = username
+  end
+  
+  def password
+    self.authority.user_info.password
+  end
+  
+  def password=(password)
+    self.authority.user_info.password = password
+  end
+  
+  def host
+    self.authority.host
+  end
+  
+  def host=(host)
+    self.authority.host = host
+  end
+  
+  def subdomain
+    self.authority.host.subdomain
+  end
+  
+  def subdomain=(subdomain)
+    self.authority.host.subdomain = subdomain
+  end
+  
+  def domain
+    self.authority.host.domain ||= Domain.new
+  end
+  
+  def domain=(domain)
+    self.authority.host.domain = Domain.parse(domain)
+  end
+  
+  def sld
+    self.authority.host.domain.sld
+  end
+  
+  def sld=(sld)
+    self.authority.host.domain.sld = sld
+  end
+  
+  def tld
+    self.authority.host.domain.tld
+  end
+  
+  def tld=(sld)
+    self.authority.host.domain.tld = tld
+  end
+  
+  def port
+    self.authority.port
+  end
+  
+  def port=(port)
+    self.authority.port = port
+  end
+  
+  def path
+    self.relative.path
+  end
+  
+  def path=(path)
+    self.relative.path = path
+  end
+  
+  def directory
+    self.relative.path.directory
+  end
+  
+  def directory=(directory)
+    self.relative.path.directory = directory
+  end
+  
+  def file
+    self.relative.path.file
+  end
+  
+  def file=(file)
+    self.relative.path.file = file
+  end
+  
+  def query
+    self.relative.query
+  end
+  
+  def query=(query)
+    self.relative.query = query
+  end
+  
+  def anchor
+    self.relative.anchor
+  end
+  
+  def anchor=(anchor)
+    self.relative.anchor = anchor
+  end
+  
+  # ======================================================================= #
+  # = Extras                                                              = #
+  # ======================================================================= #
+  
+  def relative?
+    self.host.nil?
+  end
+  
+  def absolute?
+    !relative?
+  end
+  
+  def localhost?
+    !!(self.host =~ /^localhost$/i)
+  end
+end

data/lib/uniform_resource_identifier/authority.rb

@@ -0,0 +1,121 @@
+require 'uniform_resource_identifier/parsable'
+require 'uniform_resource_identifier/parser'
+require 'uniform_resource_identifier/host'
+require 'uniform_resource_identifier/user_info'
+require 'active_support/core_ext/hash'
+
+class UniformResourceIdentifier
+  class Authority
+    extend Parsable
+    
+    def initialize(authority=nil)
+      if authority.respond_to?(:to_str)
+        authority = Parser.parse(authority)
+        
+        @user_info = UserInfo.parse(authority[:user_info]) if authority.has_key?(:user_info)
+        @host = Host.parse(authority[:host]) if authority.has_key?(:host)
+        @port = authority[:port].to_i if authority.has_key?(:port)
+      elsif authority.respond_to?(:to_hash)
+        authority = authority.to_hash.symbolize_keys
+        
+        @user_info = UserInfo.parse(authority[:user_info]) if authority.has_key?(:user_info)
+        @host = Host.parse(authority[:host]) if authority.has_key?(:host)
+        @port = authority[:port].to_i if authority.has_key?(:port)
+      else
+        raise(TypeError, "authority must either be a String or a Hash") unless authority.nil?
+      end
+    end
+    
+    def to_s
+      user_info = "#{@user_info}@" unless @user_info.nil?
+      port = ":#{@port}" unless @port.nil?
+      "#{user_info}#{@host}#{port}"
+    end
+    
+    def to_h
+      {
+        :user_info => user_info.nil? ? nil : @user_info.to_h,
+        :host      => host.nil? ? nil : @host.to_h,
+        :port      => @port
+      }
+    end
+    
+    # ======================================================================= #
+    # = Attributes                                                          = #
+    # ======================================================================= #
+    
+    def user_info
+      @user_info ||= UserInfo.new
+    end
+    
+    def user_info=(user_info)
+      @user_info = UserInfo.parse(user_info)
+    end
+    
+    def host
+      @host ||= Host.new
+    end
+    
+    def host=(host)
+      @host = Host.parse(user_info)
+    end
+    
+    attr_reader :port
+    
+    def port=(port)
+      @port = port.to_i
+    end
+    
+    # ======================================================================= #
+    # = Delegates                                                           = #
+    # ======================================================================= #
+    
+    def username
+      self.user_info.username
+    end
+    
+    def username=(username)
+      self.user_info.username = username
+    end
+    
+    def password
+      self.user_info.password
+    end
+    
+    def password=(password)
+      self.user_info.password = password
+    end
+    
+    def subdomain
+      self.host.subdomain
+    end
+    
+    def subdomain=(subdomain)
+      self.host.subdomain = subdomain
+    end
+    
+    def domain
+      self.host.domain ||= Domain.new
+    end
+    
+    def domain=(domain)
+      self.host.domain = Domain.parse(domain)
+    end
+    
+    def sld
+      self.host.domain.sld
+    end
+    
+    def sld=(sld)
+      self.host.domain.sld = sld
+    end
+    
+    def tld
+      self.host.domain.tld
+    end
+    
+    def tld=(sld)
+      self.host.domain.tld = tld
+    end
+  end
+end

data/lib/uniform_resource_identifier/domain.rb

@@ -0,0 +1,50 @@
+require 'uniform_resource_identifier/parsable'
+require 'active_support/core_ext/hash'
+require 'public_suffix_service'
+
+class UniformResourceIdentifier
+  class Domain
+    extend Parsable
+    
+    def initialize(domain)
+      if domain.respond_to?(:to_str) 
+        begin
+          pss = PublicSuffixService.parse(domain)
+          
+          @sld, @tld = pss.sld, pss.tld
+        rescue PublicSuffixService::DomainInvalid
+          # We couldn't parse your tld (public suffix) =(
+          @tld = domain
+        end
+      elsif domain.respond_to?(:to_hash)
+        domain.to_hash.symbolize_keys
+        @sld, @tld = domain.values_at(:sld, :tld)
+      else
+        raise(TypeError, "domain must either be a String or a Hash") unless domain.nil?
+      end
+    end
+    
+    def to_s
+      sld = "#{@sld}." unless @sld.nil?
+      "#{sld}#{@tld}"
+    end
+    
+    def to_h
+      { :sld => @sld, :tld => @tld }
+    end
+    # ======================================================================= #
+    # = Attributes                                                          = #
+    # ======================================================================= #
+    
+    attr_reader :sld
+    attr_reader :tld
+    
+    def sld=(sld)
+      @sld = sld.nil? ? nil : sld.to_s
+    end
+    
+    def tld=(tld)
+      @tld = tld.nil? ? nil : tld.to_s
+    end
+  end
+end

data/lib/uniform_resource_identifier/host.rb

@@ -0,0 +1,81 @@
+require 'uniform_resource_identifier/parsable'
+require 'uniform_resource_identifier/domain'
+require 'active_support/core_ext/hash'
+require 'public_suffix_service'
+
+class UniformResourceIdentifier
+  class Host
+    extend Parsable
+    
+    def initialize(host=nil)
+      if host.respond_to?(:to_str) 
+        begin
+          pss = PublicSuffixService.parse(host)
+          
+          @subdomain = pss.trd
+          @domain = Domain.new(:sld => pss.sld, :tld => pss.tld)
+        rescue PublicSuffixService::DomainInvalid
+          # We couldn't parse your tld (public suffix) =(
+          @domain = Domain.new(:sld => nil, :tld => host) # TODO: is this proper? see Domain#to_s
+        end
+      elsif host.respond_to?(:to_hash)
+        host = host.to_hash.symbolize_keys
+        
+        @subdomain = host[:subdomain]
+        @domain = Domain.new(host[:domain])
+      else
+        raise(TypeError, "host must either be a String or a Hash") unless host.nil?
+      end
+    end
+    
+    def to_s
+      subdomain = "#{@subdomain}." unless @subdomain.nil?
+      "#{subdomain}#{@domain}"
+    end
+    
+    def to_h
+      {
+        :subdomain => @subdomain,
+        :domain    => @domain.nil? ? nil : @domain.to_h
+      }
+    end
+    
+    # ======================================================================= #
+    # = Attributes                                                          = #
+    # ======================================================================= #
+    
+    attr_reader :subdomain
+    
+    def subdomain=(subdomain)
+      @subdomain = subdomain.nil? ? subdomain : subdomain.to_s
+    end
+    
+    def domain
+      @domain ||= Domain.new
+    end
+    
+    def domain=(domain)
+      @domain = Domain.parse(domain)
+    end
+    
+    # ======================================================================= #
+    # = Delegates                                                           = #
+    # ======================================================================= #
+    
+    def sld
+      self.domain.sld
+    end
+    
+    def sld=(sld)
+      self.domain.sld = sld
+    end
+    
+    def tld
+      self.domain.tld
+    end
+    
+    def tld=(sld)
+      self.domain.tld = tld
+    end
+  end
+end

data/lib/uniform_resource_identifier/parsable.rb

@@ -0,0 +1,7 @@
+class UniformResourceIdentifier
+  module Parsable
+    def parse(input)
+      input.is_a?(self) ? input : new(input)
+    end
+  end
+end

data/lib/uniform_resource_identifier/parser.rb

@@ -0,0 +1,22 @@
+class UniformResourceIdentifier
+  module Parser
+    STRICT = /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/
+    LOOSE  = /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+    
+    # Simply returns a Hash containing the captures
+    # mode can either be :strict or :loose
+    def self.parse(uri, mode=:loose)
+      raise(ArgumentError, "mode must either be :loose or :strict") unless [:loose, :strict].include?(mode)
+      
+      regexp = mode == :loose ? LOOSE : STRICT
+      match  = uri.match(regexp)
+      keys   = [:protocol, :authority, :user_info, :username, :password, :host,
+                :port, :relative, :path, :directory, :file, :query, :anchor]
+      
+      keys.each.with_index.inject({}) do |memo, (key, index)|
+        memo[key] = match.captures[index]
+        memo
+      end
+    end
+  end
+end

data/lib/uniform_resource_identifier/path.rb

@@ -0,0 +1,46 @@
+require 'uniform_resource_identifier/parsable'
+require 'uniform_resource_identifier/parser'
+require 'active_support/core_ext/hash'
+
+class UniformResourceIdentifier
+  class Path
+    extend Parsable
+    
+    def initialize(path)
+      if path.respond_to?(:to_str) 
+        parsed_uri = Parser.parse(path)
+        @directory, @file = parsed_uri.values_at(:directory, :file)
+      elsif path.respond_to?(:to_hash)
+        path.to_hash.symbolize_keys
+        @directory, @file = path.values_at(:directory, :file)
+      else
+        raise(TypeError, "path must either be a String or a Hash") unless path.nil?
+      end
+    end
+    
+    def to_s
+      "#{@directory}#{@file}"
+    end
+    
+    def to_h
+      {
+        :directory => @directory,
+        :file => @file
+      }
+    end
+    # ======================================================================= #
+    # = Attributes                                                          = #
+    # ======================================================================= #
+    
+    attr_reader :directory
+    attr_reader :file
+    
+    def directory=(directory)
+      @directory = directory.nil? ? nil : directory.to_s
+    end
+    
+    def file=(file)
+      @file = file.nil? ? nil : file.to_s
+    end
+  end
+end

data/lib/uniform_resource_identifier/query.rb

@@ -0,0 +1,28 @@
+require 'uniform_resource_identifier/parsable'
+require 'active_support/core_ext/object/to_query'
+require 'addressable/uri'
+
+class UniformResourceIdentifier
+  class Query
+    extend Parsable
+    
+    def initialize(query)
+      if query.respond_to?(:to_str)
+        query = "#{query =~ /^\?/ ? nil : '?'}#{query.to_str}" # Prepend a question mark if needed
+        @query = Addressable::URI.parse(query).query_values
+      elsif query.respond_to?(:to_hash)
+        @query = query.to_hash
+      else
+        raise(TypeError, "query must either be a String or a Hash") unless query.nil?
+      end
+    end
+    
+    def to_s
+      @query.to_query
+    end
+    
+    def to_h
+      @query
+    end
+  end
+end

data/lib/uniform_resource_identifier/relative.rb

@@ -0,0 +1,86 @@
+require 'uniform_resource_identifier/parsable'
+require 'uniform_resource_identifier/parser'
+require 'uniform_resource_identifier/path'
+require 'uniform_resource_identifier/query'
+require 'active_support/core_ext/hash'
+
+class UniformResourceIdentifier
+  class Relative
+    extend Parsable
+    
+    def initialize(relative=nil)
+      if relative.respond_to?(:to_str)
+        parsed_uri = Parser.parse(relative)
+        # TODO
+      elsif relative.respond_to?(:to_hash)
+        relative = relative.to_hash.symbolize_keys
+        
+        @path = Path.parse(relative[:path]) if relative.has_key?(:path)
+        @query = Query.parse(relative[:query]) if relative.has_key?(:query)
+        @anchor = relative[:anchor].to_s.gsub(/^#/, '') if relative.has_key?(:anchor)
+      else
+        raise(TypeError, "relative must either be a String or a Hash") unless relative.nil?
+      end
+    end
+    
+    def to_s
+      query = "?#{@query}" unless @query.nil?
+      anchor = "##{@anchor}" unless @anchor.nil?
+      "#{@path}#{query}#{anchor}"
+    end
+    
+    def to_h
+      {
+        :path   => path.nil? ? nil : @path.to_h,
+        :query  => query.nil? ? nil : @query.to_h,
+        :anchor => @anchor
+      }
+    end
+    
+    # ======================================================================= #
+    # = Attributes                                                          = #
+    # ======================================================================= #
+    
+    def path
+      @path ||= Path.new
+    end
+    
+    def path=(path)
+      @path = Path.parse(path)
+    end
+    
+    def query
+      @query ||= Query.new
+    end
+    
+    def query=(query)
+      @query = Query.parse(query)
+    end
+    
+    attr_reader :anchor
+    
+    def anchor=(anchor)
+      @anchor = anchor.nil? ? nil : anchor.to_s
+    end
+    
+    # ======================================================================= #
+    # = Delegates                                                           = #
+    # ======================================================================= #
+    
+    def directory
+      self.path.directory
+    end
+    
+    def directory=(directory)
+      self.path.directory = directory
+    end
+    
+    def file
+      self.path.file
+    end
+    
+    def file=(file)
+      self.path.file = file
+    end
+  end
+end

data/lib/uniform_resource_identifier/rspec_matcher.rb

@@ -0,0 +1,114 @@
+RSpec::Matchers.define(:have_uri_specification) do |uri_specification|
+  match do |uri_string|
+    url = UniformResourceIdentifier.parse(uri_string)
+    
+    # ======================================================================= #
+    # = Protocol/Scheme                                                     = #
+    # ======================================================================= #
+    
+    url.protocol.class.should == String
+    url.protocol.to_s.should == uri_specification[:protocol]
+    url.scheme.class.should == String                      # Alias
+    url.scheme.to_s.should == uri_specification[:protocol] # Alias
+    
+    # ======================================================================= #
+    # = Authority                                                           = #
+    # ======================================================================= #
+    
+    url.authority.class.should == UniformResourceIdentifier::Authority
+    url.authority.to_s.should == uri_specification[:authority]
+    
+    url.authority.user_info.class.should == UniformResourceIdentifier::UserInfo
+    url.authority.user_info.to_s.should == uri_specification[:user_info]
+    url.user_info.class.should == UniformResourceIdentifier::UserInfo # Delegate
+    url.user_info.to_s.should == uri_specification[:user_info]        # Delegate
+    
+    url.authority.user_info.username.class.should == String
+    url.authority.user_info.username.to_s.should == uri_specification[:username]
+    url.user_info.username.class.should == String                      # Delegate
+    url.user_info.username.to_s.should == uri_specification[:username] # Delegate
+    url.username.class.should == String                                # Delegate
+    url.username.to_s.should == uri_specification[:username]           # Delegate
+    
+    url.authority.user_info.password.class.should == String
+    url.authority.user_info.password.to_s.should == uri_specification[:password]
+    url.user_info.password.class.should == String                      # Delegate
+    url.user_info.password.to_s.should == uri_specification[:password] # Delegate
+    url.password.class.should == String                                # Delegate
+    url.password.to_s.should == uri_specification[:password]           # Delegate
+    
+    url.authority.host.class.should == UniformResourceIdentifier::Host
+    url.authority.host.to_s.should == uri_specification[:host]
+    url.host.class.should == UniformResourceIdentifier::Host # Delegate
+    url.host.to_s.should == uri_specification[:host]         # Delegate
+    
+    url.authority.host.subdomain.class.should == String
+    url.authority.host.subdomain.to_s.should == uri_specification[:subdomain]
+    url.host.subdomain.class.should == String                       # Delegate
+    url.host.subdomain.to_s.should == uri_specification[:subdomain] # Delegate
+    url.subdomain.class.should == String                            # Delegate
+    url.subdomain.to_s.should == uri_specification[:subdomain]      # Delegate
+    
+    url.authority.host.domain.class.should == UniformResourceIdentifier::Domain
+    url.authority.host.domain.to_s.should == uri_specification[:domain]
+    url.host.domain.class.should == UniformResourceIdentifier::Domain # Delegate
+    url.host.domain.to_s.should == uri_specification[:domain]         # Delegate
+    url.domain.class.should == UniformResourceIdentifier::Domain      # Delegate
+    url.domain.to_s.should == uri_specification[:domain]              # Delegate
+    
+    url.authority.host.domain.sld.class.should == String
+    url.authority.host.sld.to_s.should == uri_specification[:sld]
+    url.host.sld.class.should == String                 # Delegate
+    url.host.sld.to_s.should == uri_specification[:sld] # Delegate
+    url.sld.class.should == String                      # Delegate
+    url.sld.to_s.should == uri_specification[:sld]      # Delegate
+    
+    url.authority.host.domain.tld.class.should == String
+    url.authority.host.tld.to_s.should == uri_specification[:tld]
+    url.host.tld.class.should == String                 # Delegate
+    url.host.tld.to_s.should == uri_specification[:tld] # Delegate
+    url.tld.class.should == String                      # Delegate
+    url.tld.to_s.should == uri_specification[:tld]      # Delegate
+    
+    url.authority.port.class.should == Fixnum
+    url.authority.port.to_s.should == uri_specification[:port]
+    url.port.class.should == Fixnum                  # Delegate
+    url.port.to_s.should == uri_specification[:port] # Delegate
+    
+    # ======================================================================= #
+    # = Relative                                                            = #
+    # ======================================================================= #
+    
+    url.relative.class.should == UniformResourceIdentifier::Relative
+    url.relative.to_s.should == uri_specification[:relative]
+    
+    url.relative.path.class.should == UniformResourceIdentifier::Path
+    url.relative.path.to_s.should == uri_specification[:path]
+    url.path.class.should == UniformResourceIdentifier::Path # Delegate
+    url.path.to_s.should == uri_specification[:path]         # Delegate
+    
+    url.relative.path.directory.class.should == String
+    url.relative.path.directory.to_s.should == uri_specification[:directory]
+    url.relative.directory.class.should == String                       # Delegate
+    url.relative.directory.to_s.should == uri_specification[:directory] # Delegate
+    url.directory.class.should == String                                # Delegate
+    url.directory.to_s.should == uri_specification[:directory]          # Delegate
+    
+    url.relative.path.file.class.should == String
+    url.relative.path.file.to_s.should == uri_specification[:file]
+    url.relative.file.class.should == String                       # Delegate
+    url.relative.file.to_s.should == uri_specification[:file]      # Delegate
+    url.file.class.should == String                                # Delegate
+    url.file.to_s.should == uri_specification[:file]               # Delegate
+    
+    url.relative.query.class.should == UniformResourceIdentifier::Query
+    url.relative.query.to_s.should == uri_specification[:query]
+    url.query.class.should == UniformResourceIdentifier::Query # Delegate
+    url.query.to_s.should == uri_specification[:query]         # Delegate
+    
+    url.relative.anchor.class.should == String
+    url.relative.anchor.to_s.should == uri_specification[:anchor]
+    url.anchor.class.should == String                    # Delegate
+    url.anchor.to_s.should == uri_specification[:anchor] # Delegate
+  end
+end

data/lib/uniform_resource_identifier/user_info.rb

@@ -0,0 +1,44 @@
+require 'uniform_resource_identifier/parsable'
+require 'active_support/core_ext/hash'
+
+class UniformResourceIdentifier
+  class UserInfo
+    extend Parsable
+    
+    def initialize(user_info=nil)
+      if user_info.respond_to?(:to_str) 
+        @username, @password = user_info.to_str.split(":")
+      elsif user_info.respond_to?(:to_hash)
+        user_info.to_hash.symbolize_keys
+        @username, @password = user_info.values_at(:username, :password)
+      else
+        raise(TypeError, "user_info must either be a String or a Hash") unless user_info.nil?
+      end
+    end
+    
+    def to_s
+      "#{@username}:#{@password}"
+    end
+    
+    def to_h
+      {
+        :username => @username,
+        :password => @password
+      }
+    end
+    # ======================================================================= #
+    # = Attributes                                                          = #
+    # ======================================================================= #
+    
+    attr_reader :username
+    attr_reader :password
+    
+    def username=(username)
+      @username = username.nil? ? username : username.to_s
+    end
+    
+    def password=(password)
+      @password = password.nil? ? password : password.to_s
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'uniform_resource_identifier'
+require 'uniform_resource_identifier/rspec_matcher'

data/spec/uniform_resource_identifier/parser_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe UniformResourceIdentifier::Parser do
+  subject { UniformResourceIdentifier::Parser }
+  
+  describe "#parse" do
+    it "should return a Hash containing the correct results" do
+      url = "http://usr:pwd@www.test.com:81/dir/dir.2/foo/bar/index.htm?q1=0&&test1&test2=value&arr[]=one&arr[]=two&hsh[foo]=bar&test3=val3#top"
+      
+      result_hash = {
+        :protocol  => "http",
+        :authority => "usr:pwd@www.test.com:81",
+        :user_info => "usr:pwd",
+        :username  => "usr",
+        :password  => "pwd",
+        :host      => "www.test.com",
+        :port      => "81",
+        :relative  => "/dir/dir.2/foo/bar/index.htm?q1=0&&test1&test2=value&arr[]=one&arr[]=two&hsh[foo]=bar&test3=val3#top",
+        :path      => "/dir/dir.2/foo/bar/index.htm",
+        :directory => "/dir/dir.2/foo/bar/",
+        :file      => "index.htm",
+        :query     => "q1=0&&test1&test2=value&arr[]=one&arr[]=two&hsh[foo]=bar&test3=val3",
+        :anchor    => "top"
+      }
+      
+      subject.parse(url, :loose).should == result_hash
+      subject.parse(url, :strict).should == result_hash
+    end
+  end
+end

data/spec/uniform_resource_identifier_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+# Example URIs:
+#   ftp://ftp.is.co.za/rfc/rfc1808.txt
+#   http://www.ietf.org/rfc/rfc2396.txt
+#   ldap://[2001:db8::7]/c=GB?objectClass?one
+#   mailto:John.Doe@example.com
+#   news:comp.infosystems.www.servers.unix
+#   tel:+1-816-555-1212
+#   telnet://192.0.2.16:80/
+#   urn:oasis:names:specification:docbook:dtd:xml:4.1.2
+#   http://www.foobar.com/test/bar?q=some+thing
+#   www.foobar.com/
+#   foobar.com/contact_us
+#   admin.foobar.com/task/123
+#   admin.testpage.com
+#   /about
+#   index.htm
+#   awesome-things.org/thing/42
+#   foo-bar.org/mist
+#   water.com
+#   https://www.water.org/ice
+#   http://example.org/absolute/URI/with/absolute/path/to/resource.txt
+#   ftp://example.org/resource.txt
+#   http://en.wikipedia.org/wiki/URI#Examples_of_URI_references
+#   http://example.org/absolute/URI/with/absolute/path/to/resource.txt
+#   //example.org/scheme-relative/URI/with/absolute/path/to/resource.txt
+#   /relative/URI/with/absolute/path/to/resource.txt
+#   relative/path/to/resource.txt
+#   ../../../resource.txt
+#   ./resource.txt#frag01
+#   resource.txt
+#   #frag01
+#   http://en.wikipedia.org/wiki/Uniform_Resource_Identifier
+#   http://the_english_dept.tripod.com/north.html
+
+describe UniformResourceIdentifier do
+  subject { UniformResourceIdentifier }
+  
+  let(:url) do
+    "http://usr:pwd@www.test.com:81/dir/dir.2/foo/bar/index.htm?q1=0&&test1&test2=value&arr[]=one&arr[]=two&hsh[foo]=bar&test3=val3#top"  
+  end
+  
+  describe "#parse" do
+    it "should correctly parse the given URL" do
+      url.should have_uri_specification(
+        :protocol  => "http",
+        :authority => "usr:pwd@www.test.com:81",
+        :user_info => "usr:pwd",
+        :username  => "usr",
+        :password  => "pwd",
+        :host      => "www.test.com",
+        :subdomain => "www",
+        :domain    => "test.com",
+        :sld       => "test",
+        :tld       => "com",
+        :port      => "81",
+        :relative  => "/dir/dir.2/foo/bar/index.htm?q1=0&test1=true&test2=value&arr[]=one&arr[]=two&hsh[foo]=bar&test3=val3#top",
+        :path      => "/dir/dir.2/foo/bar/index.htm",
+        :directory => "/dir/dir.2/foo/bar/",
+        :file      => "index.htm",
+        :query     => "q1=0&test1=true&test2=value&arr[]=one&arr[]=two&hsh[foo]=bar&test3=val3",
+        :anchor    => "top"
+      )
+    end
+  end
+  
+  describe "#to_s" do
+    it "should return the normalized URI" do
+      subject.parse(url).to_s.should == "http://usr:pwd@www.test.com:81/dir/dir.2/foo/bar/index.htm?q1=0&test1=true&test2=value&arr[]=one&arr[]=two&hsh[foo]=bar&test3=val3#top"
+    end
+  end
+  
+  describe "#to_h" do
+    it "should return the correct Hash result" do
+      subject.parse(url).to_h.should == {
+        :protocol =>"http",
+        :authority => {
+          :user_info => {
+            :username => "usr", 
+            :password => "pwd"
+          },
+          :host => {
+            :subdomain => "www", 
+            :domain => {
+              :sld => "test", 
+              :tld => "com"
+            }
+          },
+          :port => 81
+        }, 
+        :relative => {
+          :path => { 
+            :directory => "/dir/dir.2/foo/bar/", 
+            :file => "index.htm"
+          }, 
+          :query => { # TODO: Should the query_values be strings?
+            "q1" => "0", 
+            "test1" => true, 
+            "test2" => "value", 
+            "arr" => ["one", "two"], 
+            "hsh" => {
+              "foo" => "bar"
+            },
+            "test3" => "val3"
+          }, 
+          :anchor=>"top"
+        }
+      }
+    end
+  end
+  
+  describe "The example from the README" do
+    it "should be correct, to say the least." do
+      url = "foo://usr:pwd@www.example.co.uk:8042/over/there.htm?name=ferret#nose"
+      uri = UniformResourceIdentifier.parse(url)
+      
+      uri.protocol.should == "foo"
+      
+      uri.authority.to_s.should == "usr:pwd@www.example.co.uk:8042"
+      
+      uri.authority.user_info.to_s.should == "usr:pwd"
+      uri.user_info.to_s.should == "usr:pwd"
+      
+      uri.authority.user_info.username.should == "usr"
+      uri.authority.user_info.password.should == "pwd"
+      uri.user_info.username.should == "usr"
+      uri.user_info.password.should == "pwd"
+      uri.username.should == "usr"
+      uri.password.should == "pwd"
+      
+      uri.authority.host.to_s.should == "www.example.co.uk"
+      uri.host.to_s.should == "www.example.co.uk"
+      
+      uri.authority.host.subdomain.should == "www"
+      uri.authority.subdomain.should == "www"
+      uri.subdomain.should == "www"
+      
+      uri.authority.host.domain.to_s.should == "example.co.uk"
+      uri.authority.domain.to_s.should == "example.co.uk"
+      uri.domain.to_s.should == "example.co.uk"
+      
+      uri.authority.host.domain.sld.should == "example"
+      uri.authority.domain.sld.should == "example"
+      uri.domain.sld.should == "example"
+      uri.sld.should == "example"
+      
+      uri.authority.host.domain.tld.should == "co.uk"
+      uri.authority.domain.tld.should == "co.uk"
+      uri.domain.tld.should == "co.uk"
+      uri.tld.should == "co.uk"
+      
+      uri.authority.port.should == 8042
+      uri.port.should == 8042
+      
+      uri.relative.to_s.should == "/over/there.htm?name=ferret#nose"
+      
+      uri.relative.path.to_s.should == "/over/there.htm"
+      uri.path.to_s.should == "/over/there.htm"
+      
+      uri.relative.path.directory.to_s.should == "/over/"
+      uri.relative.directory.to_s.should == "/over/"
+      uri.directory.to_s.should == "/over/"
+      
+      uri.relative.path.file.to_s.should == "there.htm"
+      uri.relative.file.to_s.should == "there.htm"
+      uri.file.to_s.should == "there.htm"
+      
+      uri.relative.query.to_h.should == { "name" => "ferret" }
+      uri.relative.query.to_s.should == "name=ferret"
+      uri.query.to_h.should == { "name" => "ferret" }
+      uri.query.to_s.should == "name=ferret"
+      
+      uri.relative.anchor.should == "nose"
+      uri.anchor.should == "nose"
+    end
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: uniform_resource_identifier
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Scott Lewis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-31 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: public_suffix_service
+  requirement: &70216311725500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70216311725500
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: &70216311725020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70216311725020
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: &70216311724560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70216311724560
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70216311724100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70216311724100
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70216311723640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *70216311723640
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: &70216311723180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+  type: :development
+  prerelease: false
+  version_requirements: *70216311723180
+- !ruby/object:Gem::Dependency
+  name: watchr
+  requirement: &70216311722720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *70216311722720
+description: ! '`uniform_resource_identifier` splits URIs according to RFC 3986 using
+  regexp, attempts to check the public suffix using `public_suffix_service`, and serializes
+  the query string using `active_support` and `addressable`'
+email: c00lryguy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- VERSION
+files:
+- LICENSE
+- VERSION
+- lib/uniform_resource_identifier/authority.rb
+- lib/uniform_resource_identifier/domain.rb
+- lib/uniform_resource_identifier/host.rb
+- lib/uniform_resource_identifier/parsable.rb
+- lib/uniform_resource_identifier/parser.rb
+- lib/uniform_resource_identifier/path.rb
+- lib/uniform_resource_identifier/query.rb
+- lib/uniform_resource_identifier/relative.rb
+- lib/uniform_resource_identifier/rspec_matcher.rb
+- lib/uniform_resource_identifier/user_info.rb
+- lib/uniform_resource_identifier.rb
+- spec/spec_helper.rb
+- spec/uniform_resource_identifier/parser_spec.rb
+- spec/uniform_resource_identifier_spec.rb
+homepage: http://github.com/c00lryguy/uniform_resource_identifier
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A library to split URIs according to RFC 3986 as closely as possible.
+test_files:
+- spec/spec_helper.rb
+- spec/uniform_resource_identifier/parser_spec.rb
+- spec/uniform_resource_identifier_spec.rb