Class: URI::Generic

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

Overview

Base class for all URI classes. Implements generic 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 URI::Generic.

nil
COMPONENT =

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

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

:nodoc:

false

Constants included from URI

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from URI

decode_www_form, decode_www_form_component, encode_www_form, encode_www_form_component, extract, for, join, parse, regexp, 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 URI after ‘#’ character.

parser

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

arg_check

Check arguments [false by default].

Description

Creates a new 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/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 URI.

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



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

def fragment
  @fragment
end

#host ⇒ Object

Returns the host component of the URI.

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

It returns nil if no host component exists.

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

The component does not contain the port number.

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.

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



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

def host
  @host
end

#opaque ⇒ Object

Returns the opaque part of the URI.

URI("mailto:[email protected]").opaque #=> "[email protected]"
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/uri/generic.rb', line 277

def opaque
  @opaque
end

#path ⇒ Object

Returns the path component of the URI.

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



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

def path
  @path
end

#port ⇒ Object

Returns the port component of the URI.

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



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

def port
  @port
end

#query ⇒ Object

Returns the query component of the URI.

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



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

def query
  @query
end

#scheme ⇒ Object

Returns the scheme component of the URI.

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



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

def scheme
  @scheme
end

Class Method Details

.build(args) ⇒ Object

Synopsis

See ::new.

Description

Creates a new URI::Generic instance from components of 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/uri/generic.rb', line 116

def self.build(args)
  if args.kind_of?(Array) &&
      args.size == ::URI::Generic::COMPONENT.size
    tmp = args.dup
  elsif args.kind_of?(Hash)
    tmp = ::URI::Generic::COMPONENT.collect do |c|
      if args.include?(c)
        args[c]
      else
        nil
      end
    end
  else
    component = self.class.component rescue ::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 URI::Generic instance using URI::Generic::build. But, if exception URI::InvalidComponentError is raised, then it does URI::Escape.escape all 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/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 URI in the order.



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

def self.component
  self::COMPONENT
end

.default_port ⇒ Object

Returns default port.



32
33
34
 
# File '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) 


1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
 
# File 'lib/uri/generic.rb', line 1545

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/uri/generic.rb', line 63

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

Instance Method Details

#==(oth) ⇒ Object

Compares two URIs.



1373
1374
1375
1376
1377
1378
1379
 
# File 'lib/uri/generic.rb', line 1373

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 URI has a scheme (e.g. http:// or https://) specified.

Returns:

  • (Boolean) 


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

def absolute?
  if @scheme
    true
  else
    false
  end
end

#coerce(oth) ⇒ Object

Args

v

URI or String

Description

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

Usage

require 'uri'

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



1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
 
# File 'lib/uri/generic.rb', line 1463

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

  return oth, self
end

#component ⇒ Object

Components of the URI in the order.



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

def component
  self.class.component
end

#default_port ⇒ Object

Returns default port.



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

def default_port
  self.class.default_port
end

#eql?(oth) ⇒ Boolean

Returns:

  • (Boolean) 


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

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 URI. The proxy 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:



1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
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
 
# File 'lib/uri/generic.rb', line 1489

def find_proxy(env=ENV)
  raise BadURIError, "relative 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'
    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
  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 URI::Generic.use_proxy?(self.hostname, addr, self.port, no_proxy)
  end
  URI.parse(proxy_uri)
end

#hash ⇒ Object 



1381
1382
1383
 
# File 'lib/uri/generic.rb', line 1381

def hash
  self.component_ary.hash
end

#hierarchical? ⇒ Boolean

Returns true if URI is hierarchical.

Description

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 'uri'

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

Returns:

  • (Boolean) 


951
952
953
954
955
956
957
 
# File 'lib/uri/generic.rb', line 951

def hierarchical?
  if @path
    true
  else
    false
  end
end

#hostname ⇒ Object

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

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

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



644
645
646
647
 
# File 'lib/uri/generic.rb', line 644

def hostname
  v = self.host
  /\A\[(.*)\]\z/ =~ v ? $1 : v
end

#hostname=(v) ⇒ Object

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

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

uri = 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.



661
662
663
664
 
# File 'lib/uri/generic.rb', line 661

def hostname=(v)
  v = "[#{v}]" if /\A\[.*\]\z/ !~ v && /:/ =~ v
  self.host = v
end

#inspect ⇒ Object 



1440
1441
1442
 
# File 'lib/uri/generic.rb', line 1440

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

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

Args

oth

URI or String

Description

Merges two URIs.

Usage

require 'uri'

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



1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
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
 
# File 'lib/uri/generic.rb', line 1099

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

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

  unless self.absolute?
    raise BadURIError, "both 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

URI or String

Description

Destructive form of #merge.

Usage

require 'uri'

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



1071
1072
1073
1074
1075
1076
1077
1078
1079
 
# File 'lib/uri/generic.rb', line 1071

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

#normalize ⇒ Object

Returns normalized URI.

require 'uri'

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

Normalization here means:

  • scheme and host are converted to lowercase,

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



1309
1310
1311
1312
1313
 
# File 'lib/uri/generic.rb', line 1309

def normalize
  uri = dup
  uri.normalize!
  uri
end

#normalize! ⇒ Object

Destructive version of #normalize.



1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
 
# File 'lib/uri/generic.rb', line 1318

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 URI::Parser is defined, DEFAULT_PARSER is used.



289
290
291
292
293
294
295
 
# File '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.



573
574
575
 
# File '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 URI::Generic.check_password.

Usage

require 'uri'

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



498
499
500
501
502
 
# File '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/uri/generic.rb', line 252

def registry # :nodoc:
  nil
end

#registry=(v) ⇒ Object

Raises:



735
736
737
 
# File 'lib/uri/generic.rb', line 735

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

#relative? ⇒ Boolean

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

Returns:

  • (Boolean) 


974
975
976
 
# File 'lib/uri/generic.rb', line 974

def relative?
  !absolute?
end

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

Args

oth

URI or String

Description

Calculates relative path from oth to self.

Usage

require 'uri'

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



1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
 
# File 'lib/uri/generic.rb', line 1252

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

URI or String

Description

Calculates relative path to oth from self.

Usage

require 'uri'

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



1292
1293
1294
 
# File 'lib/uri/generic.rb', line 1292

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

#select(*components) ⇒ Object

Args

components

Multiple Symbol arguments defined in URI::HTTP.

Description

Selects specified components from URI.

Usage

require 'uri'

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



1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
 
# File 'lib/uri/generic.rb', line 1429

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

Constructs String from URI.



1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
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
 
# File 'lib/uri/generic.rb', line 1333

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.



568
569
570
 
# File '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 URI::Generic.check_user.

Usage

require 'uri'

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



471
472
473
474
475
 
# File '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/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/uri/generic.rb', line 441

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