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.



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

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"



280
281
282
 
# File 'lib/uri/generic.rb', line 280

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"



240
241
242
 
# File 'lib/uri/generic.rb', line 240

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)



274
275
276
 
# File 'lib/uri/generic.rb', line 274

def opaque
  @opaque
end

#path ⇒ Object

returns the path component of the URI.

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



258
259
260
 
# File 'lib/uri/generic.rb', line 258

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"



248
249
250
 
# File 'lib/uri/generic.rb', line 248

def port
  @port
end

#query ⇒ Object

returns the query component of the URI.

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



264
265
266
 
# File 'lib/uri/generic.rb', line 264

def query
  @query
end

#scheme ⇒ Object

returns the scheme component of the URI.

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



218
219
220
 
# File 'lib/uri/generic.rb', line 218

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.



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

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.



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

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.



54
55
56
 
# File 'lib/uri/generic.rb', line 54

def self.component
  self::COMPONENT
end

.default_port ⇒ Object

Returns default port



29
30
31
 
# File 'lib/uri/generic.rb', line 29

def self.default_port
  self::DEFAULT_PORT
end

.use_registry ⇒ Object

:nodoc:



60
61
62
 
# File 'lib/uri/generic.rb', line 60

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

Instance Method Details

#==(oth) ⇒ Object

Compares to URI’s



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

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) 


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

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



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

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.



309
310
311
 
# File 'lib/uri/generic.rb', line 309

def component
  self.class.component
end

#default_port ⇒ Object

Returns default port



36
37
38
 
# File 'lib/uri/generic.rb', line 36

def default_port
  self.class.default_port
end

#eql?(oth) ⇒ Boolean

Returns:

  • (Boolean) 


1393
1394
1395
1396
1397
 
# File 'lib/uri/generic.rb', line 1393

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:



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

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 



1389
1390
1391
 
# File 'lib/uri/generic.rb', line 1389

def hash
  self.component_ary.hash
end

#hierarchical? ⇒ Boolean

Checks if URI has a path

Returns:

  • (Boolean) 


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

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]”



648
649
650
651
 
# File 'lib/uri/generic.rb', line 648

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.



666
667
668
669
 
# File 'lib/uri/generic.rb', line 666

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

#inspect ⇒ Object 



1448
1449
1450
 
# File 'lib/uri/generic.rb', line 1448

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>



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

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>



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

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

#normalize ⇒ Object

Returns normalized URI



1317
1318
1319
1320
1321
 
# File 'lib/uri/generic.rb', line 1317

def normalize
  uri = dup
  uri.normalize!
  uri
end

#normalize! ⇒ Object

Destructive version of #normalize



1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
 
# File 'lib/uri/generic.rb', line 1326

def normalize!
  if path && 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.



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

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

#password ⇒ Object

returns the password component



575
576
577
 
# File 'lib/uri/generic.rb', line 575

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



500
501
502
503
504
 
# File 'lib/uri/generic.rb', line 500

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

#registry ⇒ Object

:nodoc:



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

def registry # :nodoc:
  nil
end

#registry=(v) ⇒ Object

Raises:



742
743
744
 
# File 'lib/uri/generic.rb', line 742

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

#relative? ⇒ Boolean

Checks if URI is relative

Returns:

  • (Boolean) 


970
971
972
 
# File 'lib/uri/generic.rb', line 970

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>



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

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>



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

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"]



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

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



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
1369
1370
1371
1372
1373
1374
1375
1376
 
# File 'lib/uri/generic.rb', line 1341

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

  if @opaque
    str << @opaque
  else
    if @host
      str << '//'.freeze
    end
    if self.userinfo
      str << self.userinfo
      str << '@'.freeze
    end
    if @host
      str << @host
    end
    if @port && @port != self.default_port
      str << ':'.freeze
      str << @port.to_s
    end
    str << @path
    if @query
      str << '?'.freeze
      str << @query
    end
  end
  if @fragment
    str << '#'.freeze
    str << @fragment
  end
  str
end

#user ⇒ Object

returns the user component



570
571
572
 
# File 'lib/uri/generic.rb', line 570

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



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’



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

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’



439
440
441
442
443
444
445
446
 
# File 'lib/uri/generic.rb', line 439

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