uri-component 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in stringglob.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new
+

data/lib/uri/component/path.rb

@@ -0,0 +1,122 @@
+## Ruby URI::Component::Path: Class to handle a path component in an URI
+##
+## Author:: SATOH Fumiyasu
+## Copyright:: (c) 2007-2011 SATOH Fumiyasu @ OSS Technology, Corp.
+## License:: You can redistribute it and/or modify it under the same term as Ruby.
+##
+
+require 'uri'
+
+module URI
+  module Component
+    ## Handle a path component in an URI as an object
+    class Path
+      #:stopdoc:
+      ## Same as URI::UNSAFE, plus ';' (separator for path nodes)
+      ## and '?' (separator for path and query)
+      RE_UNSAFE = /
+        [^#{URI::REGEXP::PATTERN::UNRESERVED}#{URI::REGEXP::PATTERN::RESERVED}]|
+        [\/?]
+      /x
+      RE_COMPONENT = /^(?:#{URI::REGEXP::PATTERN::ABS_PATH})?$/
+      #:startdoc:
+
+      def self.mixin(klass) #:nodoc:
+	PathMixin.__send__(:append_features, klass)
+	PathMixin.__send__(:included, klass)
+      end
+
+      def initialize(path_str='')
+	unless path_str =~ RE_COMPONENT
+	  raise InvalidURIError, "bad Path component for URI: #{path_str}"
+	end
+
+	if path_str
+	  @nodes = path_str.split('/', -1).map do |node|
+	    URI.unescape(node)
+	  end
+	  @nodes.shift
+	else
+	  @nodes = []
+	end
+      end
+
+      def to_uri
+	return '' if @nodes.empty?
+	return '/' + @nodes.map do |node|
+	  URI.escape(node, RE_UNSAFE)
+	end.join('/')
+      end
+      alias to_s to_uri
+
+      def nodes
+	return @nodes
+      end
+
+      def nodes=(v)
+	@nodes = v
+      end
+
+      def normalize!
+	nodes = []
+	@nodes.each do |node|
+	  case node
+	  when ''
+	    next
+	  when '.'
+	    next
+	  when '..'
+	    nodes.pop
+	    next
+	  end
+	  nodes << node
+	end
+
+	@nodes = nodes
+      end
+    end
+
+    module PathMixin
+      def initialize_copy(uri)
+	if (path = uri.instance_variable_get('@path_component'))
+	  @path_component = path.dup
+	end
+
+	super(uri)
+      end
+
+      def path
+	return @path_component ? @path_component.to_uri : @path
+      end
+
+      def path=(path_str)
+	super(path_str)
+
+	parse_path!
+	return self.path
+      end
+
+      def path_component
+	parse_path! unless @path_component
+	return @path_component
+      end
+      alias path_c path_component
+
+      def path_query
+        str = self.path
+        if query = self.query
+          str += '?' + query
+        end
+        return str
+      end
+      private :path_query
+
+      protected
+
+      def parse_path!
+	@path_component = URI::Component::Path.new(@path)
+      end
+    end
+  end
+end
+

data/lib/uri/component/query.rb

@@ -0,0 +1,115 @@
+## Ruby URI::Component::Query: Class to handle a query component in an URI
+##
+## Author:: SATOH Fumiyasu
+## Copyright:: (c) 2007-2011 SATOH Fumiyasu @ OSS Technology, Corp.
+## License:: You can redistribute it and/or modify it under the same term as Ruby.
+##
+
+require 'uri'
+require 'cgi'
+
+module URI
+  module Component
+    ## Handle a query component in an URI as an object
+    class Query
+      #:stopdoc:
+      RE_COMPONENT = /^#{URI::REGEXP::PATTERN::QUERY}?$/
+      #:startdoc:
+
+      def self.mixin(klass) #:nodoc:
+	QueryMixin.__send__(:append_features, klass)
+	QueryMixin.__send__(:included, klass)
+      end
+
+      def initialize(query_str='')
+	unless query_str =~ RE_COMPONENT
+	  raise InvalidURIError, "bad Query component for URI: #{query_str}"
+	end
+
+	@params = {}
+	@params.default_proc = Proc.new {|hash, key|
+	  hash[key] = [] unless hash.key?(key)
+	}
+	@param_separator = '&'
+
+	query_str.split(/[&;]/).each do |param|
+	  next if param.empty?
+	  name, value = param.split('=', 2).map do |v|
+	    CGI.unescape(v)
+	  end
+	  @params[name] ||= []
+	  @params[name] << value ? value : nil
+	end
+      end
+
+      def params
+	return @params
+      end
+
+      def param_separator
+	return @param_separator
+      end
+
+      def param_separator=(v)
+	@param_separator = v
+      end
+
+      def to_uri(separator=@param_separator)
+	query = []
+
+	@params.each do |name, values|
+	  name = CGI.escape(name)
+	  values.each do |value|
+	    query << "#{name}#{'=' + CGI.escape(value.to_s) if value}"
+	  end
+	end
+
+	return query.join(separator)
+      end
+      alias to_s to_uri
+    end
+
+    module QueryMixin
+      def initialize_copy(uri)
+	if (query = uri.instance_variable_get('@query_component'))
+	  @query_component = query.dup
+	end
+
+	super(uri)
+      end
+
+      def query
+	return @query_component ? @query_component.to_uri : @query
+      end
+
+      def query=(query_str)
+	super(query_str)
+
+	parse_query!
+	return self.query
+      end
+
+      def query_component
+	parse_query! unless @query_component
+	return @query_component
+      end
+      alias query_c query_component
+
+      def path_query
+        str = self.path
+        if query = self.query
+          str += '?' + query
+        end
+        return str
+      end
+      private :path_query
+
+      protected
+
+      def parse_query!
+	@query_component = URI::Component::Query.new(@query)
+      end
+    end
+  end
+end
+

data/lib/uri/component/userinfo.rb

@@ -0,0 +1,156 @@
+## Ruby URI::Component::UserInfo: Class to handle an userinfo component in an URI
+##
+## Author:: SATOH Fumiyasu
+## Copyright:: (c) 2007-2011 SATOH Fumiyasu @ OSS Technology, Corp.
+## License:: You can redistribute it and/or modify it under the same term as Ruby.
+##
+
+require 'uri'
+
+module URI
+  module Component
+    ## Handle an userinfo component in an URI as an object
+    class UserInfo
+      #:stopdoc:
+      RE_UNSAFE = /[^#{URI::REGEXP::PATTERN::UNRESERVED}]/
+      ## Same as URI::USERINFO, except ';' and ':'
+      RE_PART = /(?:
+        [#{URI::REGEXP::PATTERN::UNRESERVED}&=+$,]|
+        #{URI::REGEXP::PATTERN::ESCAPED})*
+      /x
+      RE_COMPONENT = /^(?:(#{RE_PART});)?(#{RE_PART})(?::(#{RE_PART}))?$/
+      #:startdoc:
+
+      def self.mixin(klass) #:nodoc:
+	UserInfoMixin.__send__(:append_features, klass)
+	UserInfoMixin.__send__(:included, klass)
+      end
+
+      def self.escape(v)
+	return URI.escape(v, RE_UNSAFE)
+      end
+
+      def initialize(info_str=nil)
+	if info_str
+	  unless m = info_str.match(RE_COMPONENT)
+	    raise InvalidURIError, "bad UserInfo component for URI: #{info_str}"
+	  end
+	  @domain = m[1] ? URI.unescape(m[1]) : nil
+	  @user = URI.unescape(m[2])
+	  @password = m[3] ? URI.unescape(m[3]) : nil
+	else
+	  @domain = @user = @password = nil
+	end
+      end
+
+      def domain
+	return @domain
+      end
+
+      def domain=(v)
+	if v && !@user
+	  raise InvalidURIError, "domain component depends user component"
+	end
+	@domain = v
+      end
+
+      def user
+	return @user
+      end
+
+      def user=(v)
+	if !v
+	  @domain = @password = nil
+	end
+	@user = v
+      end
+
+      def password
+	return @password
+      end
+
+      def password=(v)
+	if v && !@user
+	  raise InvalidURIError, "password component depends user component"
+	end
+	@password = v
+      end
+
+      def to_uri
+	return nil unless @user
+
+	info_str = ''
+	info_str += self.class.escape(@domain) + ';' if @domain
+	info_str += @user ? self.class.escape(@user) : '';
+	info_str += ':' + self.class.escape(@password) if @password
+	return info_str
+      end
+      alias to_s to_uri
+    end
+
+    module UserInfoMixin
+      def initialize_copy(uri)
+	if (userinfo = uri.instance_variable_get('@userinfo_component'))
+	  @userinfo_component = userinfo.dup
+	end
+
+	super(uri)
+      end
+
+      def userinfo
+	@userinfo_component.to_uri
+      end
+
+      def userinfo=(info_str)
+	super(info_str)
+
+	parse_userinfo!
+	return self.userinfo
+      end
+
+      def user
+	user = @userinfo_component.user
+	return nil unless user
+
+	domain = @userinfo_component.domain
+	user_uri = domain ? URI::Component::UserInfo.escape(domain) + ';' : ''
+	user_uri += URI::Component::UserInfo.escape(user)
+	return user_uri
+      end
+
+      def user=(user_uri)
+	if user_uri
+	  m = user_uri.match(/^(?:(.*);)?(.*)$/)
+	  @userinfo_component.domain = m[1] ? URI.unescape(m[1]) : nil
+	  @userinfo_component.user = URI.unescape(m[2])
+	else
+	  @userinfo_component.user = nil
+	end
+      end
+
+      def password
+	pass = @userinfo_component.password
+	return pass ? URI::Component::UserInfo.escape(pass) : nil
+      end
+
+      def password=(pass_uri)
+	@userinfo_component.password = pass_uri ? URI.unescape(pass_uri) : nil
+      end
+
+      def userinfo_component
+	parse_userinfo! unless @userinfo_component
+	return @userinfo_component
+      end
+      alias userinfo_c userinfo_component
+
+      protected
+
+      def parse_userinfo!
+	info_str = @user
+	info_str += ':' + @password if @password
+	@userinfo_component = URI::Component::UserInfo.new(info_str)
+      end
+    end
+  end
+end
+

data/lib/uri/component/version.rb

@@ -0,0 +1,6 @@
+module URI
+  module Component
+    VERSION = "0.0.1" ## :nodoc:
+  end
+end
+

data/test/test_component_path.rb

@@ -0,0 +1,174 @@
+require 'test/unit'
+require 'uri/component/path'
+
+UCP = URI::Component::Path
+
+module URI
+module Component
+
+class TestPathClass < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_parse
+    p_uri = ''
+    p = UCP.new(p_uri)
+    assert_equal(p_uri, p.to_uri)
+    assert_empty(p.nodes)
+
+    p_uri = '/'
+    p = UCP.new(p_uri)
+    assert_equal(p_uri, p.to_uri)
+    assert_equal(1, p.nodes.size)
+    assert_equal('', p.nodes[0])
+
+    p_uri = '/foo'
+    p = UCP.new(p_uri)
+    assert_equal(p_uri, p.to_uri)
+    assert_equal(1, p.nodes.size)
+    assert_equal('foo', p.nodes[0])
+
+    p_uri = '/foo/'
+    p = UCP.new(p_uri)
+    assert_equal(p_uri, p.to_uri)
+    assert_equal(2, p.nodes.size)
+    assert_equal('foo', p.nodes[0])
+
+    p_uri = '/123%20abc'
+    p = UCP.new(p_uri)
+    assert_equal('/123%20abc', p.to_uri)
+    assert_equal(1, p.nodes.size)
+    assert_equal('123 abc', p.nodes[0])
+
+    p_uri = '/123+abc%2BABC'
+    p = UCP.new(p_uri)
+    assert_equal('/123+abc+ABC', p.to_uri)
+    assert_equal(1, p.nodes.size)
+    assert_equal('123+abc+ABC', p.nodes[0])
+
+    p_uri = '/foo-1/bar-abc%40xyz/baz-123%20%00%2B789%25ff'
+    p = UCP.new(p_uri)
+    assert_equal('/foo-1/bar-abc@xyz/baz-123%20%00+789%25ff', p.to_uri)
+    assert_equal(3, p.nodes.size)
+    assert_equal('foo-1', p.nodes[0])
+    assert_equal('bar-abc@xyz', p.nodes[1])
+    assert_equal("baz-123 \x00+789%ff", p.nodes[2])
+
+    p_uri = '/foo//bar'
+    p = UCP.new(p_uri)
+    assert_equal(p_uri, p.to_uri)
+    assert_equal(3, p.nodes.size)
+    assert_equal('foo', p.nodes[0])
+    assert_equal('', p.nodes[1])
+    assert_equal('bar', p.nodes[2])
+
+    %w(foo1 /foo?bar2 /foo\bar3).concat(['/foo bar4']).each do |path_str|
+      assert_raise(URI::InvalidURIError) do
+	UCP.new(path_str)
+	raise path_str
+      end
+    end
+  end
+
+  def test_set
+    p = UCP.new('')
+    assert_equal('', p.to_uri)
+
+    p = UCP.new('')
+    p.nodes << 'foo'
+    assert_equal('/foo', p.to_uri)
+
+    p = UCP.new('')
+    p.nodes << 'foo?bar'
+    assert_equal('/foo%3Fbar', p.to_uri)
+
+    p = UCP.new('')
+    p.nodes << 'foo/bar'
+    assert_equal('/foo%2Fbar', p.to_uri)
+
+    p = UCP.new('')
+    p.nodes << '123 abc'
+    assert_equal('/123%20abc', p.to_uri)
+
+    p = UCP.new('')
+    p.nodes << '123+abc'
+    assert_equal('/123+abc', p.to_uri)
+
+    p = UCP.new('')
+    p.nodes << 'abc@xyz'
+    p.nodes << "123 \x00+789%ff"
+    assert_equal('/abc@xyz/123%20%00+789%25ff', p.to_uri)
+  end
+
+  def test_normalize
+    p = UCP.new('/foo/')
+    p.normalize!
+    assert_equal('/foo', p.to_uri)
+
+    p = UCP.new('/foo/./bar')
+    p.normalize!
+    assert_equal('/foo/bar', p.to_uri)
+
+    p = UCP.new('/foo/./bar/baz/.')
+    p.normalize!
+    assert_equal('/foo/bar/baz', p.to_uri)
+
+    p = UCP.new('/foo/../bar')
+    p.normalize!
+    assert_equal('/bar', p.to_uri)
+
+    p = UCP.new('/foo/../../../bar')
+    p.normalize!
+    assert_equal('/bar', p.to_uri)
+
+    p = UCP.new('/foo/./../bar')
+    p.normalize!
+    assert_equal('/bar', p.to_uri)
+
+    p = UCP.new('/foo//bar')
+    p.normalize!
+    assert_equal('/foo/bar', p.to_uri)
+  end
+
+  def test_mixin
+    UCP.mixin(URI::HTTPS)
+
+    u_uri = 'https://example.jp/abc%40xyz/123+%00%2B789%25ff'
+    u_uri_x = u_uri.gsub('%40','@').gsub('%2B', '+')
+    u = URI.parse(u_uri)
+    p = u.path_component
+    assert_kind_of(URI::HTTPS, u)
+    assert_kind_of(UCP, p)
+    assert_equal(u_uri_x, u.to_s)
+    assert_equal('/abc@xyz/123+%00+789%25ff', u.path)
+    assert_equal('/abc@xyz/123+%00+789%25ff', p.to_s)
+
+    p.nodes << 'xxx'
+    assert_equal(u_uri_x + '/xxx', u.to_s)
+    assert_equal('/abc@xyz/123+%00+789%25ff/xxx', u.path)
+    assert_equal('/abc@xyz/123+%00+789%25ff/xxx', p.to_s)
+
+    u_uri.sub!(/^https:/, 'http:')
+    u_uri_x = u_uri.gsub('%40','@').gsub('%2B', '+')
+    u = URI.parse(u_uri)
+    assert_raise(NoMethodError) do
+      u.path_component
+    end
+
+    UCP.mixin(URI::HTTP)
+    u = URI.parse(u_uri)
+    p = u.path_component
+    assert_kind_of(URI::HTTP, u)
+    assert_kind_of(UCP, u.path_component)
+    assert_equal(u_uri_x, u.to_s)
+    assert_equal('/abc@xyz/123+%00+789%25ff', u.path)
+    assert_equal('/abc@xyz/123+%00+789%25ff', p.to_s)
+  end
+end
+
+end
+end
+

data/test/test_component_query.rb

@@ -0,0 +1,179 @@
+require 'test/unit'
+require 'uri/component/query'
+
+UCQ = URI::Component::Query
+
+module URI
+module Component
+
+class TestQueryClass < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_parse
+    q_uri = ''
+    q = UCQ.new(q_uri)
+    assert_equal(q_uri, q.to_uri)
+    assert_empty(q.params)
+
+    q_uri = 'foo=1'
+    q = UCQ.new(q_uri)
+    assert_equal(q_uri, q.to_uri)
+    assert_equal(1, q.params.size)
+    assert_equal(1, q.params['foo'].size)
+    assert_equal('1', q.params['foo'][0])
+
+    q_uri = 'foo'
+    q = UCQ.new(q_uri)
+    assert_equal(q_uri, q.to_uri)
+    assert_equal(1, q.params.size)
+    assert_equal(1, q.params['foo'].size)
+    assert_nil(q.params['foo'][0])
+
+    q_uri = 'foo=123%20abc'
+    q = UCQ.new(q_uri)
+    assert_equal(q_uri.gsub('%20', '+'), q.to_uri)
+    assert_equal(1, q.params.size)
+    assert_equal(1, q.params['foo'].size)
+    assert_equal('123 abc', q.params['foo'][0])
+
+    q_uri = 'foo=123+abc%2BABC'
+    q = UCQ.new(q_uri)
+    assert_equal(q_uri, q.to_uri)
+    assert_equal(1, q.params.size)
+    assert_equal(1, q.params['foo'].size)
+    assert_equal('123 abc+ABC', q.params['foo'][0])
+
+    q_uri = 'foo=1&bar=abc%40xyz&baz=123%20%00%2B789'
+    q = UCQ.new(q_uri)
+    assert_equal(q_uri.gsub('%20', '+'), q.to_uri)
+    assert_equal(3, q.params.size)
+    assert_equal(1, q.params['foo'].size)
+    assert_equal('1', q.params['foo'][0])
+    assert_equal(1, q.params['bar'].size)
+    assert_equal('abc@xyz', q.params['bar'][0])
+    assert_equal(1, q.params['baz'].size)
+    assert_equal("123 \x00+789", q.params['baz'][0])
+
+    q_uri = 'foo=1&bar=a&foo=2&bar=bb&bar=ccc'
+    q = UCQ.new(q_uri)
+    assert_equal('foo=1&foo=2&bar=a&bar=bb&bar=ccc', q.to_uri)
+    assert_equal(2, q.params.size)
+    assert_equal(2, q.params['foo'].size)
+    assert_equal('1', q.params['foo'][0])
+    assert_equal('2', q.params['foo'][1])
+    assert_equal(3, q.params['bar'].size)
+    assert_equal('a', q.params['bar'][0])
+    assert_equal('bb', q.params['bar'][1])
+    assert_equal('ccc', q.params['bar'][2])
+
+    q_uri = 'foo=1&foo&bar&baz=a'
+    q = UCQ.new(q_uri)
+    assert_equal(q_uri, q.to_uri)
+    assert_equal(3, q.params.size)
+    assert_equal(2, q.params['foo'].size)
+    assert_equal('1', q.params['foo'][0])
+    assert_nil(q.params['foo'][1])
+    assert_equal(1, q.params['bar'].size)
+    assert_nil(q.params['bar'][0])
+    assert_equal(1, q.params['baz'].size)
+    assert_equal('a', q.params['baz'][0])
+
+    q_uri = 'foo=1;bar=abc;baz=ABC'
+    q = UCQ.new(q_uri)
+    assert_equal(q_uri.gsub(';', '&'), q.to_uri)
+    assert_equal(q_uri, q.to_uri(';'))
+    assert_equal(3, q.params.size)
+    assert_equal(1, q.params['foo'].size)
+    assert_equal('1', q.params['foo'][0])
+    assert_equal(1, q.params['bar'].size)
+    assert_equal('abc', q.params['bar'][0])
+    assert_equal(1, q.params['baz'].size)
+    assert_equal('ABC', q.params['baz'][0])
+
+    assert_raise(URI::InvalidURIError) do
+      UCQ.new('foo bar')
+    end
+  end
+
+  def test_set
+    q = UCQ.new('')
+    q.params['foo'] = [1]
+    assert_equal('foo=1', q.to_uri)
+
+    q = UCQ.new('')
+    q.params['foo'] = [nil]
+    assert_equal('foo', q.to_uri)
+
+    q = UCQ.new('')
+    q.params['foo'] = ['123 abc']
+    assert_equal('foo=123+abc', q.to_uri)
+
+    q = UCQ.new('')
+    q.params['foo'] = ['123+abc']
+    assert_equal('foo=123%2Babc', q.to_uri)
+
+    q = UCQ.new('')
+    q.params['foo'] = [1]
+    q.params['bar'] = ['abc@xyz']
+    q.params['baz'] = ["123 \x00+789"]
+    assert_equal('foo=1&bar=abc%40xyz&baz=123+%00%2B789', q.to_uri)
+
+    q = UCQ.new('')
+    q.params['foo'] = [1, 2]
+    q.params['bar'] = ['a', 'bb', 'ccc']
+    assert_equal('foo=1&foo=2&bar=a&bar=bb&bar=ccc', q.to_uri)
+
+    q = UCQ.new('')
+    q.params['foo'] = [1, nil]
+    q.params['bar'] = [nil]
+    q.params['baz'] = ['a']
+    assert_equal('foo=1&foo&bar&baz=a', q.to_uri)
+
+    q = UCQ.new('')
+    q.params['foo'] = [1]
+    q.params['bar'] = ['abc']
+    q.params['baz'] = ['ABC']
+    assert_equal('foo=1;bar=abc;baz=ABC', q.to_uri(';'))
+  end
+
+  def test_mixin
+    UCQ.mixin(URI::HTTPS)
+
+    u_uri = 'https://example.jp/?foo=123%40example&bar=abc%20xyz'
+    u_uri_x = u_uri.gsub('+', '%2B').gsub('%20', '+')
+    u = URI.parse(u_uri)
+    q = u.query_component
+    assert_kind_of(UCQ, q)
+    assert_equal(u_uri_x, u.to_s)
+    assert_equal('foo=123%40example&bar=abc+xyz', u.query)
+    assert_equal('foo=123%40example&bar=abc+xyz', q.to_s)
+
+    q.params['baz'] = ['xxx']
+    assert_equal(u_uri_x + '&baz=xxx', u.to_s)
+    assert_equal('foo=123%40example&bar=abc+xyz&baz=xxx', u.query)
+    assert_equal('foo=123%40example&bar=abc+xyz&baz=xxx', q.to_s)
+
+    u_uri.sub!(/^https:/, 'http:')
+    u_uri_x = u_uri.gsub('+', '%2B').gsub('%20', '+')
+    u = URI.parse(u_uri)
+    assert_raise(NoMethodError) do
+      u.query_component
+    end
+
+    UCQ.mixin(URI::HTTP)
+    u = URI.parse(u_uri)
+    q = u.query_component
+    assert_kind_of(UCQ, q)
+    assert_equal(u_uri_x, u.to_s)
+    assert_equal('foo=123%40example&bar=abc+xyz', u.query)
+    assert_equal('foo=123%40example&bar=abc+xyz', q.to_s)
+  end
+end
+
+end
+end
+

data/test/test_component_userinfo.rb

@@ -0,0 +1,158 @@
+require 'test/unit'
+require 'uri/component/userinfo'
+
+UCUI = URI::Component::UserInfo
+
+module URI
+module Component
+
+class TestUserInfoClass < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_parse
+    i = UCUI.new()
+    assert_nil(i.to_uri)
+    assert_nil(i.domain)
+    assert_nil(i.user)
+    assert_nil(i.password)
+
+    i_uri = 'user%20name'
+    i = UCUI.new(i_uri)
+    assert_equal(i_uri, i.to_uri)
+    assert_nil(i.domain)
+    assert_equal('user name', i.user)
+    assert_nil(i.password)
+
+    i_uri = 'user%20name:p%40ssword'
+    i = UCUI.new(i_uri)
+    assert_equal(i_uri, i.to_uri)
+    assert_nil(i.domain)
+    assert_equal('user name', i.user)
+    assert_equal('p@ssword', i.password)
+
+    i_uri = 'domain%20name;user%20name'
+    i = UCUI.new(i_uri)
+    assert_equal(i_uri, i.to_uri)
+    assert_equal('domain name', i.domain)
+    assert_equal('user name', i.user)
+    assert_nil(i.password)
+
+    i_uri = 'domain%20name;user%20name:p%40ssword'
+    i = UCUI.new(i_uri)
+    assert_equal(i_uri, i.to_uri)
+    assert_equal('domain name', i.domain)
+    assert_equal('user name', i.user)
+    assert_equal('p@ssword', i.password)
+
+    %w(foo/bar1 foo@bar2 foo?bar3 foo:bar:baz4 foo;bar;baz5).each do |info_str|
+      assert_raise(URI::InvalidURIError) do
+	UCUI.new(info_str)
+	raise info_str
+      end
+    end
+  end
+
+  def test_modify
+    i = UCUI.new('domain%5Fname;user%20name:p%40ssword')
+
+    i.domain = 'domain2'
+    assert_equal('domain2', i.domain)
+    assert_equal('domain2;user%20name:p%40ssword', i.to_uri)
+    i.domain = nil
+    assert_nil(i.domain)
+    assert_equal('user%20name:p%40ssword', i.to_uri)
+
+    i.password = 'password2'
+    assert_equal('password2', i.password)
+    assert_equal('user%20name:password2', i.to_uri)
+    i.password = nil
+    assert_nil(i.password)
+    assert_equal('user%20name', i.to_uri)
+
+    i.domain = 'domain %20_3'
+    assert_equal('domain %20_3', i.domain)
+    assert_equal('domain%20%2520_3;user%20name', i.to_uri)
+
+    i.password = 'password %20_3'
+    assert_equal('password %20_3', i.password)
+    assert_equal('domain%20%2520_3;user%20name:password%20%2520_3', i.to_uri)
+
+    i.user = 'user2'
+    assert_equal('user2', i.user)
+    assert_equal('domain%20%2520_3;user2:password%20%2520_3', i.to_uri)
+    i.user = nil
+    assert_nil(i.user)
+    assert_nil(i.to_uri)
+
+    assert_raise(URI::InvalidURIError) do
+      i.domain = 'domain4'
+    end
+    assert_raise(URI::InvalidURIError) do
+      i.password = 'password4'
+    end
+
+    i.user = 'user %20_3'
+    assert_equal('user %20_3', i.user)
+    assert_equal('user%20%2520_3', i.to_uri)
+  end
+
+  def test_mixin
+    UCUI.mixin(URI::HTTPS)
+
+    u_uri = 'https://user%20name:p%40ssword@example.jp/'
+    u = URI.parse(u_uri)
+    i = u.userinfo_component
+    assert_kind_of(UCUI, i)
+    assert_equal('user%20name:p%40ssword', u.userinfo)
+    assert_equal('user%20name', u.user)
+    assert_equal('user name', i.user)
+    assert_equal('p%40ssword', u.password)
+    assert_equal('p@ssword', i.password)
+    assert_nil(i.domain)
+
+    u.user = 'user%2Fname'
+    assert_equal('user%2Fname:p%40ssword', u.userinfo)
+    assert_equal('user%2Fname', u.user)
+    assert_equal('user/name', i.user)
+    assert_nil(i.domain)
+
+    u.password = 'pass%2Fword'
+    assert_equal('user%2Fname:pass%2Fword', u.userinfo)
+    assert_equal('pass%2Fword', u.password)
+    assert_equal('pass/word', i.password)
+    assert_nil(i.domain)
+
+    u.user = 'domain;user%3Bname'
+    assert_equal('domain;user%3Bname:pass%2Fword', u.userinfo)
+    assert_equal('domain;user%3Bname', u.user)
+    assert_equal('domain', i.domain)
+    assert_equal('user;name', i.user)
+
+    assert_equal('https://domain;user%3Bname:pass%2Fword@example.jp/', u.to_s)
+
+    u_uri.sub!(/^https:/, 'http:')
+    u = URI.parse(u_uri)
+    assert_raise(NoMethodError) do
+      u.userinfo_component
+    end
+
+    UCUI.mixin(URI::HTTP)
+    u = URI.parse(u_uri)
+    i = u.userinfo_component
+    assert_kind_of(UCUI, i)
+    assert_equal('user%20name:p%40ssword', u.userinfo)
+    assert_equal('user%20name', u.user)
+    assert_equal('user name', i.user)
+    assert_equal('p%40ssword', u.password)
+    assert_equal('p@ssword', i.password)
+    assert_nil(i.domain)
+  end
+end
+
+end
+end
+

data/uri-compoment.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "uri/component/version"
+
+Gem::Specification.new do |s|
+  s.name        = "uri-component"
+  s.version     = URI::Component::VERSION
+  s.authors     = ["SATOH Fumiyasu"]
+  s.email       = ["fumiyas@osstech.co.jp"]
+  s.homepage    = "https://github.com/fumiyas/ruby-uri-component"
+  s.summary     = %q{URI::Component::* classes}
+  s.description = %q{Handle URI components as an object}
+
+  s.rubyforge_project = "uri-component"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end
+

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: uri-component
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- SATOH Fumiyasu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-04 00:00:00.000000000 Z
+dependencies: []
+description: Handle URI components as an object
+email:
+- fumiyas@osstech.co.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- lib/uri/component/path.rb
+- lib/uri/component/query.rb
+- lib/uri/component/userinfo.rb
+- lib/uri/component/version.rb
+- test/test_component_path.rb
+- test/test_component_query.rb
+- test/test_component_userinfo.rb
+- uri-compoment.gemspec
+homepage: https://github.com/fumiyas/ruby-uri-component
+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: uri-component
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: URI::Component::* classes
+test_files:
+- test/test_component_path.rb
+- test/test_component_query.rb
+- test/test_component_userinfo.rb