Class: Gem::URI::Generic

Inherits:
Object
  • Object
show all
Includes:
Gem::URI
Defined in:
lib/rubygems/vendor/uri/lib/uri/generic.rb

Overview

Base class for all Gem::URI classes. Implements generic Gem::URI syntax as per RFC 2396.

Direct Known Subclasses

FTP, File, HTTP, LDAP, MailTo, WS

Constant Summary collapse

DEFAULT_PORT =

A Default port of nil for Gem::URI::Generic.

nil
COMPONENT =

An Array of the available components for Gem::URI::Generic.

[
  :scheme,
  :userinfo, :host, :port, :registry,
  :path, :opaque,
  :query,
  :fragment
].freeze
USE_REGISTRY =

:nodoc:

false

Constants included from Gem::URI

DEFAULT_PARSER, Parser, REGEXP, RFC2396_PARSER, RFC3986_PARSER, TBLDECWWWCOMP_, TBLENCURICOMP_, TBLENCWWWCOMP_, VERSION, VERSION_CODE

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Gem::URI

decode_uri_component, decode_www_form, decode_www_form_component, encode_uri_component, encode_www_form, encode_www_form_component, extract, for, join, parse, regexp, register_scheme, scheme_list, split

Constructor Details

#initialize(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser = DEFAULT_PARSER, arg_check = false) ⇒ Generic

Args

scheme

Protocol scheme, i.e. ‘http’,‘ftp’,‘mailto’ and so on.

userinfo

User name and password, i.e. ‘sdmitry:bla’.

host

Server host name.

port

Server port.

registry

Registry of naming authorities.

path

Path on server.

opaque

Opaque part.

query

Query data.

fragment

Part of the Gem::URI after ‘#’ character.

parser

Parser for internal use [Gem::URI::DEFAULT_PARSER by default].

arg_check

Check arguments [false by default].

Description

Creates a new Gem::URI::Generic instance from “generic” components without check.



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 169

def initialize(scheme,
               userinfo, host, port, registry,
               path, opaque,
               query,
               fragment,
               parser = DEFAULT_PARSER,
               arg_check = false)
  @scheme = nil
  @user = nil
  @password = nil
  @host = nil
  @port = nil
  @path = nil
  @query = nil
  @opaque = nil
  @fragment = nil
  @parser = parser == DEFAULT_PARSER ? nil : parser

  if arg_check
    self.scheme = scheme
    self.userinfo = userinfo
    self.hostname = host
    self.port = port
    self.path = path
    self.query = query
    self.opaque = opaque
    self.fragment = fragment
  else
    self.set_scheme(scheme)
    self.set_userinfo(userinfo)
    self.set_host(host)
    self.set_port(port)
    self.set_path(path)
    self.query = query
    self.set_opaque(opaque)
    self.fragment=(fragment)
  end
  if registry
    raise InvalidURIError,
      "the scheme #{@scheme} does not accept registry part: #{registry} (or bad hostname?)"
  end

  @scheme&.freeze
  self.set_path('') if !@path && !@opaque # (see RFC2396 Section 5.2)
  self.set_port(self.default_port) if self.default_port && !@port
end

Instance Attribute Details

#fragment ⇒ Object

Returns the fragment component of the Gem::URI.

Gem::URI("http://foo/bar/baz?search=FooBar#ponies").fragment #=> "ponies"



283
284
285
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 283

def fragment
  @fragment
end

#host ⇒ Object

Returns the host component of the Gem::URI.

Gem::URI("http://foo/bar/baz").host #=> "foo"

It returns nil if no host component exists.

Gem::URI("mailto:[email protected]").host #=> nil

The component does not contain the port number.

Gem::URI("http://foo:8080/bar/baz").host #=> "foo"

Since IPv6 addresses are wrapped with brackets in URIs, this method returns IPv6 addresses wrapped with brackets. This form is not appropriate to pass to socket methods such as TCPSocket.open. If unwrapped host names are required, use the #hostname method.

Gem::URI("http://[::1]/bar/baz").host     #=> "[::1]"
Gem::URI("http://[::1]/bar/baz").hostname #=> "::1"



243
244
245
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 243

def host
  @host
end

#opaque ⇒ Object

Returns the opaque part of the Gem::URI.

Gem::URI("mailto:[email protected]").opaque #=> "[email protected]"
Gem::URI("http://foo/bar/baz").opaque     #=> nil

The portion of the path that does not make use of the slash ‘/’. The path typically refers to an absolute path or an opaque part. (See RFC2396 Section 3 and 5.2.)



277
278
279
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 277

def opaque
  @opaque
end

#path ⇒ Object

Returns the path component of the Gem::URI.

Gem::URI("http://foo/bar/baz").path #=> "/bar/baz"



260
261
262
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 260

def path
  @path
end

#port ⇒ Object

Returns the port component of the Gem::URI.

Gem::URI("http://foo/bar/baz").port      #=> 80
Gem::URI("http://foo:8080/bar/baz").port #=> 8080



250
251
252
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 250

def port
  @port
end

#query ⇒ Object

Returns the query component of the Gem::URI.

Gem::URI("http://foo/bar/baz?search=FooBar").query #=> "search=FooBar"



266
267
268
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 266

def query
  @query
end

#scheme ⇒ Object

Returns the scheme component of the Gem::URI.

Gem::URI("http://foo/bar/baz").scheme #=> "http"



221
222
223
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 221

def scheme
  @scheme
end

Class Method Details

.build(args) ⇒ Object

Synopsis

See ::new.

Description

Creates a new Gem::URI::Generic instance from components of Gem::URI::Generic with check. Components are: scheme, userinfo, host, port, registry, path, opaque, query, and fragment. You can provide arguments either by an Array or a Hash. See ::new for hash keys to use or for order of array items.



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 116

def self.build(args)
  if args.kind_of?(Array) &&
      args.size == ::Gem::URI::Generic::COMPONENT.size
    tmp = args.dup
  elsif args.kind_of?(Hash)
    tmp = ::Gem::URI::Generic::COMPONENT.collect do |c|
      if args.include?(c)
        args[c]
      else
        nil
      end
    end
  else
    component = self.class.component rescue ::Gem::URI::Generic::COMPONENT
    raise ArgumentError,
    "expected Array of or Hash of components of #{self.class} (#{component.join(', ')})"
  end

  tmp << nil
  tmp << true
  return self.new(*tmp)
end

.build2(args) ⇒ Object

Synopsis

See ::new.

Description

At first, tries to create a new Gem::URI::Generic instance using Gem::URI::Generic::build. But, if exception Gem::URI::InvalidComponentError is raised, then it does Gem::URI::Escape.escape all Gem::URI components and tries again.



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 78

def self.build2(args)
  begin
    return self.build(args)
  rescue InvalidComponentError
    if args.kind_of?(Array)
      return self.build(args.collect{|x|
        if x.is_a?(String)
          DEFAULT_PARSER.escape(x)
        else
          x
        end
      })
    elsif args.kind_of?(Hash)
      tmp = {}
      args.each do |key, value|
        tmp[key] = if value
            DEFAULT_PARSER.escape(value)
          else
            value
          end
      end
      return self.build(tmp)
    end
  end
end

.component ⇒ Object

Components of the Gem::URI in the order.



57
58
59
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 57

def self.component
  self::COMPONENT
end

.default_port ⇒ Object

Returns default port.



32
33
34
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 32

def self.default_port
  self::DEFAULT_PORT
end

.use_proxy?(hostname, addr, port, no_proxy) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1566

def self.use_proxy?(hostname, addr, port, no_proxy) # :nodoc:
  hostname = hostname.downcase
  dothostname = ".#{hostname}"
  no_proxy.scan(/([^:,\s]+)(?::(\d+))?/) {|p_host, p_port|
    if !p_port || port == p_port.to_i
      if p_host.start_with?('.')
        return false if hostname.end_with?(p_host.downcase)
      else
        return false if dothostname.end_with?(".#{p_host.downcase}")
      end
      if addr
        begin
          return false if IPAddr.new(p_host).include?(addr)
        rescue IPAddr::InvalidAddressError
          next
        end
      end
    end
  }
  true
end

.use_registry ⇒ Object

:nodoc:



63
64
65
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 63

def self.use_registry # :nodoc:
  self::USE_REGISTRY
end

Instance Method Details

#==(oth) ⇒ Object

Compares two URIs.



1384
1385
1386
1387
1388
1389
1390
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1384

def ==(oth)
  if self.class == oth.class
    self.normalize.component_ary == oth.normalize.component_ary
  else
    false
  end
end

#absolute? ⇒ Boolean Also known as: absolute

Returns true if Gem::URI has a scheme (e.g. http:// or https://) specified.

Returns:

  • (Boolean) 


972
973
974
975
976
977
978
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 972

def absolute?
  if @scheme
    true
  else
    false
  end
end

#coerce(oth) ⇒ Object

Args

v

Gem::URI or String

Description

Attempts to parse other Gem::URI oth, returns [parsed_oth, self].

Usage

require 'rubygems/vendor/uri/lib/uri'

uri = Gem::URI.parse("http://my.example.com")
uri.coerce("http://foo.com")
#=> [#<Gem::URI::HTTP http://foo.com>, #<Gem::URI::HTTP http://my.example.com>]



1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1474

def coerce(oth)
  case oth
  when String
    oth = parser.parse(oth)
  else
    super
  end

  return oth, self
end

#component ⇒ Object

Components of the Gem::URI in the order.



313
314
315
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 313

def component
  self.class.component
end

#decoded_password ⇒ Object

Returns the password component after Gem::URI decoding.



583
584
585
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 583

def decoded_password
  Gem::URI.decode_uri_component(@password) if @password
end

#decoded_user ⇒ Object

Returns the user component after Gem::URI decoding.



578
579
580
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 578

def decoded_user
  Gem::URI.decode_uri_component(@user) if @user
end

#default_port ⇒ Object

Returns default port.



39
40
41
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 39

def default_port
  self.class.default_port
end

#eql?(oth) ⇒ Boolean

Returns:

  • (Boolean) 


1396
1397
1398
1399
1400
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1396

def eql?(oth)
  self.class == oth.class &&
  parser == oth.parser &&
  self.component_ary.eql?(oth.component_ary)
end

#find_proxy(env = ENV) ⇒ Object

Returns a proxy Gem::URI. The proxy Gem::URI is obtained from environment variables such as http_proxy, ftp_proxy, no_proxy, etc. If there is no proper proxy, nil is returned.

If the optional parameter env is specified, it is used instead of ENV.

Note that capitalized variables (HTTP_PROXY, FTP_PROXY, NO_PROXY, etc.) are examined, too.

But http_proxy and HTTP_PROXY is treated specially under CGI environment. It’s because HTTP_PROXY may be set by Proxy: header. So HTTP_PROXY is not used. http_proxy is not used too if the variable is case insensitive. CGI_HTTP_PROXY can be used instead.

Raises:



1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1500

def find_proxy(env=ENV)
  raise BadURIError, "relative Gem::URI: #{self}" if self.relative?
  name = self.scheme.downcase + '_proxy'
  proxy_uri = nil
  if name == 'http_proxy' && env.include?('REQUEST_METHOD') # CGI?
    # HTTP_PROXY conflicts with *_proxy for proxy settings and
    # HTTP_* for header information in CGI.
    # So it should be careful to use it.
    pairs = env.reject {|k, v| /\Ahttp_proxy\z/i !~ k }
    case pairs.length
    when 0 # no proxy setting anyway.
      proxy_uri = nil
    when 1
      k, _ = pairs.shift
      if k == 'http_proxy' && env[k.upcase] == nil
        # http_proxy is safe to use because ENV is case sensitive.
        proxy_uri = env[name]
      else
        proxy_uri = nil
      end
    else # http_proxy is safe to use because ENV is case sensitive.
      proxy_uri = env.to_hash[name]
    end
    if !proxy_uri
      # Use CGI_HTTP_PROXY.  cf. libwww-perl.
      proxy_uri = env["CGI_#{name.upcase}"]
    end
  elsif name == 'http_proxy'
    if RUBY_ENGINE == 'jruby' && p_addr = ENV_JAVA['http.proxyHost']
      p_port = ENV_JAVA['http.proxyPort']
      if p_user = ENV_JAVA['http.proxyUser']
        p_pass = ENV_JAVA['http.proxyPass']
        proxy_uri = "http://#{p_user}:#{p_pass}@#{p_addr}:#{p_port}"
      else
        proxy_uri = "http://#{p_addr}:#{p_port}"
      end
    else
      unless proxy_uri = env[name]
        if proxy_uri = env[name.upcase]
          warn 'The environment variable HTTP_PROXY is discouraged.  Use http_proxy.', uplevel: 1
        end
      end
    end
  else
    proxy_uri = env[name] || env[name.upcase]
  end

  if proxy_uri.nil? || proxy_uri.empty?
    return nil
  end

  if self.hostname
    begin
      addr = IPSocket.getaddress(self.hostname)
      return nil if /\A127\.|\A::1\z/ =~ addr
    rescue SocketError
    end
  end

  name = 'no_proxy'
  if no_proxy = env[name] || env[name.upcase]
    return nil unless Gem::URI::Generic.use_proxy?(self.hostname, addr, self.port, no_proxy)
  end
  Gem::URI.parse(proxy_uri)
end

#hash ⇒ Object 



1392
1393
1394
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1392

def hash
  self.component_ary.hash
end

#hierarchical? ⇒ Boolean

Returns true if Gem::URI is hierarchical.

Description

Gem::URI has components listed in order of decreasing significance from left to right, see RFC3986 tools.ietf.org/html/rfc3986 1.2.3.

Usage

require 'rubygems/vendor/uri/lib/uri'

uri = Gem::URI.parse("http://my.example.com/")
uri.hierarchical?
#=> true
uri = Gem::URI.parse("mailto:[email protected]")
uri.hierarchical?
#=> false

Returns:

  • (Boolean) 


961
962
963
964
965
966
967
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 961

def hierarchical?
  if @path
    true
  else
    false
  end
end

#hostname ⇒ Object

Extract the host part of the Gem::URI and unwrap brackets for IPv6 addresses.

This method is the same as Gem::URI::Generic#host except brackets for IPv6 (and future IP) addresses are removed.

uri = Gem::URI("http://[::1]/bar")
uri.hostname      #=> "::1"
uri.host          #=> "[::1]"



654
655
656
657
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 654

def hostname
  v = self.host
  v&.start_with?('[') && v.end_with?(']') ? v[1..-2] : v
end

#hostname=(v) ⇒ Object

Sets the host part of the Gem::URI as the argument with brackets for IPv6 addresses.

This method is the same as Gem::URI::Generic#host= except the argument can be a bare IPv6 address.

uri = Gem::URI("http://foo/bar")
uri.hostname = "::1"
uri.to_s  #=> "http://[::1]/bar"

If the argument seems to be an IPv6 address, it is wrapped with brackets.



671
672
673
674
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 671

def hostname=(v)
  v = "[#{v}]" if !(v&.start_with?('[') && v&.end_with?(']')) && v&.index(':')
  self.host = v
end

#inspect ⇒ Object 



1451
1452
1453
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1451

def inspect
  "#<#{self.class} #{self}>"
end

#merge(oth) ⇒ Object Also known as: +

Args

oth

Gem::URI or String

Description

Merges two URIs.

Usage

require 'rubygems/vendor/uri/lib/uri'

uri = Gem::URI.parse("http://my.example.com")
uri.merge("/main.rbx?page=1")
# => "http://my.example.com/main.rbx?page=1"



1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1109

def merge(oth)
  rel = parser.__send__(:convert_to_uri, oth)

  if rel.absolute?
    #raise BadURIError, "both Gem::URI are absolute" if absolute?
    # hmm... should return oth for usability?
    return rel
  end

  unless self.absolute?
    raise BadURIError, "both Gem::URI are relative"
  end

  base = self.dup

  authority = rel.userinfo || rel.host || rel.port

  # RFC2396, Section 5.2, 2)
  if (rel.path.nil? || rel.path.empty?) && !authority && !rel.query
    base.fragment=(rel.fragment) if rel.fragment
    return base
  end

  base.query = nil
  base.fragment=(nil)

  # RFC2396, Section 5.2, 4)
  if !authority
    base.set_path(merge_path(base.path, rel.path)) if base.path && rel.path
  else
    # RFC2396, Section 5.2, 4)
    base.set_path(rel.path) if rel.path
  end

  # RFC2396, Section 5.2, 7)
  base.set_userinfo(rel.userinfo) if rel.userinfo
  base.set_host(rel.host)         if rel.host
  base.set_port(rel.port)         if rel.port
  base.query = rel.query       if rel.query
  base.fragment=(rel.fragment) if rel.fragment

  return base
end

#merge!(oth) ⇒ Object

Args

oth

Gem::URI or String

Description

Destructive form of #merge.

Usage

require 'rubygems/vendor/uri/lib/uri'

uri = Gem::URI.parse("http://my.example.com")
uri.merge!("/main.rbx?page=1")
uri.to_s  # => "http://my.example.com/main.rbx?page=1"



1081
1082
1083
1084
1085
1086
1087
1088
1089
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1081

def merge!(oth)
  t = merge(oth)
  if self == t
    nil
  else
    replace!(t)
    self
  end
end

#normalize ⇒ Object

Returns normalized Gem::URI.

require 'rubygems/vendor/uri/lib/uri'

Gem::URI("HTTP://my.EXAMPLE.com").normalize
#=> #<Gem::URI::HTTP http://my.example.com/>

Normalization here means:

  • scheme and host are converted to lowercase,

  • an empty path component is set to “/”.



1319
1320
1321
1322
1323
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1319

def normalize
  uri = dup
  uri.normalize!
  uri
end

#normalize! ⇒ Object

Destructive version of #normalize.



1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1328

def normalize!
  if path&.empty?
    set_path('/')
  end
  if scheme && scheme != scheme.downcase
    set_scheme(self.scheme.downcase)
  end
  if host && host != host.downcase
    set_host(self.host.downcase)
  end
end

#parser ⇒ Object

Returns the parser to be used.

Unless a Gem::URI::Parser is defined, DEFAULT_PARSER is used.



289
290
291
292
293
294
295
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 289

def parser
  if !defined?(@parser) || !@parser
    DEFAULT_PARSER
  else
    @parser || DEFAULT_PARSER
  end
end

#password ⇒ Object

Returns the password component (without Gem::URI decoding).



573
574
575
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 573

def password
  @password
end

#password=(password) ⇒ Object

Args

v

String

Description

Public setter for the password component (with validation).

See also Gem::URI::Generic.check_password.

Usage

require 'rubygems/vendor/uri/lib/uri'

uri = Gem::URI.parse("http://john:[email protected]")
uri.password = "V3ry_S3nsit1ve"
uri.to_s  #=> "http://john:[email protected]"



498
499
500
501
502
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 498

def password=(password)
  check_password(password)
  set_password(password)
  # returns password
end

#registry ⇒ Object

:nodoc:



252
253
254
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 252

def registry # :nodoc:
  nil
end

#registry=(v) ⇒ Object

Raises:



745
746
747
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 745

def registry=(v)
  raise InvalidURIError, "can not set registry"
end

#relative? ⇒ Boolean

Returns true if Gem::URI does not have a scheme (e.g. http:// or https://) specified.

Returns:

  • (Boolean) 


984
985
986
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 984

def relative?
  !absolute?
end

#route_from(oth) ⇒ Object Also known as: -

Args

oth

Gem::URI or String

Description

Calculates relative path from oth to self.

Usage

require 'rubygems/vendor/uri/lib/uri'

uri = Gem::URI.parse('http://my.example.com/main.rbx?page=1')
uri.route_from('http://my.example.com')
#=> #<Gem::URI::Generic /main.rbx?page=1>



1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1262

def route_from(oth)
  # you can modify `rel', but can not `oth'.
  begin
    oth, rel = route_from0(oth)
  rescue
    raise $!.class, $!.message
  end
  if oth == rel
    return rel
  end

  rel.set_path(route_from_path(oth.path, self.path))
  if rel.path == './' && self.query
    # "./?foo" -> "?foo"
    rel.set_path('')
  end

  return rel
end

#route_to(oth) ⇒ Object

Args

oth

Gem::URI or String

Description

Calculates relative path to oth from self.

Usage

require 'rubygems/vendor/uri/lib/uri'

uri = Gem::URI.parse('http://my.example.com')
uri.route_to('http://my.example.com/main.rbx?page=1')
#=> #<Gem::URI::Generic /main.rbx?page=1>



1302
1303
1304
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1302

def route_to(oth)
  parser.__send__(:convert_to_uri, oth).route_from(self)
end

#select(*components) ⇒ Object

Args

components

Multiple Symbol arguments defined in Gem::URI::HTTP.

Description

Selects specified components from Gem::URI.

Usage

require 'rubygems/vendor/uri/lib/uri'

uri = Gem::URI.parse('http://myuser:[email protected]/test.rbx')
uri.select(:userinfo, :host, :path)
# => ["myuser:mypass", "my.example.com", "/test.rbx"]



1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1440

def select(*components)
  components.collect do |c|
    if component.include?(c)
      self.__send__(c)
    else
      raise ArgumentError,
        "expected of components of #{self.class} (#{self.class.component.join(', ')})"
    end
  end
end

#to_s ⇒ Object Also known as: to_str

Constructs String from Gem::URI.



1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 1343

def to_s
  str = ''.dup
  if @scheme
    str << @scheme
    str << ':'
  end

  if @opaque
    str << @opaque
  else
    if @host || %w[file postgres].include?(@scheme)
      str << '//'
    end
    if self.userinfo
      str << self.userinfo
      str << '@'
    end
    if @host
      str << @host
    end
    if @port && @port != self.default_port
      str << ':'
      str << @port.to_s
    end
    str << @path
    if @query
      str << '?'
      str << @query
    end
  end
  if @fragment
    str << '#'
    str << @fragment
  end
  str
end

#user ⇒ Object

Returns the user component (without Gem::URI decoding).



568
569
570
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 568

def user
  @user
end

#user=(user) ⇒ Object

Args

v

String

Description

Public setter for the user component (with validation).

See also Gem::URI::Generic.check_user.

Usage

require 'rubygems/vendor/uri/lib/uri'

uri = Gem::URI.parse("http://john:[email protected]")
uri.user = "sam"
uri.to_s  #=> "http://sam:[email protected]"



471
472
473
474
475
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 471

def user=(user)
  check_user(user)
  set_user(user)
  # returns user
end

#userinfo ⇒ Object

Returns the userinfo, either as ‘user’ or ‘user:password’.



557
558
559
560
561
562
563
564
565
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 557

def userinfo
  if @user.nil?
    nil
  elsif @password.nil?
    @user
  else
    @user + ':' + @password
  end
end

#userinfo=(userinfo) ⇒ Object

Sets userinfo, argument is string like ‘name:pass’.



441
442
443
444
445
446
447
448
 
# File 'lib/rubygems/vendor/uri/lib/uri/generic.rb', line 441

def userinfo=(userinfo)
  if userinfo.nil?
    return nil
  end
  check_userinfo(*userinfo)
  set_userinfo(*userinfo)
  # returns userinfo
end