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, HTTP, LDAP, MailTo

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, HTML5ASCIIINCOMPAT, 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, join, parse, regexp, scheme_list, split

Methods included from Escape

#escape, #unescape

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

A part of URI after ‘#’ sign

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.



168
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
 
# File 'lib/uri/generic.rb', line 168

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 if @scheme
  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"



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

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.

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

The component doesn’t contains the port number.

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

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

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



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

def host
  @host
end

#opaque ⇒ Object

returns the opaque part of the URI.

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

Portion of the path that does make use of the slash ‘/’. The path typically refers to the absolute path and the opaque part.

(see RFC2396 Section 3 and 5.2)



276
277
278
 
# File 'lib/uri/generic.rb', line 276

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"



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

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



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

def self.component
  self::COMPONENT
end

.default_port ⇒ Object

Returns default port



31
32
33
 
# File 'lib/uri/generic.rb', line 31

def self.default_port
  self::DEFAULT_PORT
end

.use_registry ⇒ Object

:nodoc:



62
63
64
 
# File 'lib/uri/generic.rb', line 62

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

Instance Method Details

#==(oth) ⇒ Object

Compares to URI’s



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

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

Checks if URI is an absolute one

Returns:

  • (Boolean) 


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

def absolute?
  if @scheme
    true
  else
    false
  end
end

#coerce(oth) ⇒ Object

Args

v

URI or String

Description

attempt to parse other URI +oth+
return [parsed_oth, self]

Usage

require 'uri'

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



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

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.



311
312
313
 
# File 'lib/uri/generic.rb', line 311

def component
  self.class.component
end

#default_port ⇒ Object

Returns default port



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

def default_port
  self.class.default_port
end

#eql?(oth) ⇒ Boolean

Returns:

  • (Boolean) 


1395
1396
1397
1398
1399
 
# File 'lib/uri/generic.rb', line 1395

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

#find_proxy ⇒ 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.

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:



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
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
 
# File 'lib/uri/generic.rb', line 1497

def find_proxy
  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.'
      end
    end
  else
    proxy_uri = ENV[name] || ENV[name.upcase]
  end

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

  if self.hostname
    require 'socket'
    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]
    no_proxy.scan(/([^:,]*)(?::(\d+))?/) {|host, port|
      if /(\A|\.)#{Regexp.quote host}\z/i =~ self.host &&
        (!port || self.port == port.to_i)
        return nil
      end
    }
  end
  URI.parse(proxy_uri)
end

#hash ⇒ Object 



1391
1392
1393
 
# File 'lib/uri/generic.rb', line 1391

def hash
  self.component_ary.hash
end

#hierarchical? ⇒ Boolean

Checks if URI has a path

Returns:

  • (Boolean) 


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

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 same as URI::Generic#host except brackets for IPv6 (and future IP) addresses are removed.

u = URI(“http://[::1]/bar”) p u.hostname #=> “::1” p u.host #=> “[::1]”



650
651
652
653
 
# File 'lib/uri/generic.rb', line 650

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

#hostname=(v) ⇒ Object

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

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

u = URI(“foo/bar”) p u.to_s #=> “foo/bar” u.hostname = “::1” p u.to_s #=> “[::1]/bar”

If the argument seems IPv6 address, it is wrapped by brackets.



668
669
670
671
 
# File 'lib/uri/generic.rb', line 668

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

#inspect ⇒ Object 



1450
1451
1452
 
# File 'lib/uri/generic.rb', line 1450

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

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

Args

oth

URI or String

Description

Merges two URI’s.

Usage

require 'uri'

uri = URI.parse("http://my.example.com")
p uri.merge("/main.rbx?page=1")
# =>  #<URI::HTTP:0x2021f3b0 URL:http://my.example.com/main.rbx?page=1>



1098
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
 
# File 'lib/uri/generic.rb', line 1098

def merge(oth)
  begin
    base, rel = merge0(oth)
  rescue
    raise $!.class, $!.message
  end

  if base == rel
    return base
  end

  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")
p uri
# =>  #<URI::HTTP:0x2021f3b0 URL:http://my.example.com/main.rbx?page=1>



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

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

#normalize ⇒ Object

Returns normalized URI



1319
1320
1321
1322
1323
 
# File '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/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 URI::Parser is defined, then DEFAULT_PARSER is used.



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

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

#password ⇒ Object

returns the password component



577
578
579
 
# File 'lib/uri/generic.rb', line 577

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"
# =>  "V3ry_S3nsit1ve"
uri
#=> #<URI::HTTP:0x00000000881d90 URL:http://john:[email protected]>



502
503
504
505
506
 
# File 'lib/uri/generic.rb', line 502

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:



744
745
746
 
# File 'lib/uri/generic.rb', line 744

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

#relative? ⇒ Boolean

Checks if URI is relative

Returns:

  • (Boolean) 


972
973
974
 
# File 'lib/uri/generic.rb', line 972

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')
p uri.route_from('http://my.example.com')
#=> #<URI::Generic:0x20218858 URL:/main.rbx?page=1>



1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
 
# File 'lib/uri/generic.rb', line 1272

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')
p uri.route_to('http://my.example.com/main.rbx?page=1')
#=> #<URI::Generic:0x2020c2f6 URL:/main.rbx?page=1>



1312
1313
1314
 
# File 'lib/uri/generic.rb', line 1312

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')
p uri.select(:userinfo, :host, :path)
# => ["myuser:mypass", "my.example.com", "/test.rbx"]



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

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



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

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

  if @opaque
    str << @opaque
  else
    if @host
      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



572
573
574
 
# File 'lib/uri/generic.rb', line 572

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"
# =>  "sam"
uri
#=> #<URI::HTTP:0x00000000881d90 URL:http://sam:[email protected]>



473
474
475
476
477
 
# File 'lib/uri/generic.rb', line 473

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

#userinfo ⇒ Object

returns the userinfo, either as ‘user’ or ‘user:password’



561
562
563
564
565
566
567
568
569
 
# File 'lib/uri/generic.rb', line 561

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