Class: Bundler::URI::Generic

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

Overview

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

Direct Known Subclasses

FTP, File, HTTP, LDAP, MailTo

Constant Summary collapse

DEFAULT_PORT =

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

nil
COMPONENT =

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

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

:nodoc:

false

Constants included from Bundler::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 Bundler::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

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

parser

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

arg_check

Check arguments [false by default].

Description

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



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
215
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 170

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

#fragmentObject

Returns the fragment component of the Bundler::URI.

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


284
285
286
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 284

def fragment
  @fragment
end

#hostObject

Returns the host component of the Bundler::URI.

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

It returns nil if no host component exists.

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

The component does not contain the port number.

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

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


244
245
246
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 244

def host
  @host
end

#opaqueObject

Returns the opaque part of the Bundler::URI.

Bundler::URI("mailto:[email protected]").opaque #=> "[email protected]"
Bundler::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.)



278
279
280
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 278

def opaque
  @opaque
end

#pathObject

Returns the path component of the Bundler::URI.

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


261
262
263
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 261

def path
  @path
end

#portObject

Returns the port component of the Bundler::URI.

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


251
252
253
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 251

def port
  @port
end

#queryObject

Returns the query component of the Bundler::URI.

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


267
268
269
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 267

def query
  @query
end

#schemeObject

Returns the scheme component of the Bundler::URI.

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


222
223
224
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 222

def scheme
  @scheme
end

Class Method Details

.build(args) ⇒ Object

Synopsis

See ::new.

Description

Creates a new Bundler::URI::Generic instance from components of Bundler::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.



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

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



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

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

.componentObject

Components of the Bundler::URI in the order.



58
59
60
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 58

def self.component
  self::COMPONENT
end

.default_portObject

Returns default port.



33
34
35
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 33

def self.default_port
  self::DEFAULT_PORT
end

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

:nodoc:

Returns:

  • (Boolean)


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

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_registryObject

:nodoc:



64
65
66
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 64

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

Instance Method Details

#==(oth) ⇒ Object

Compares two URIs.



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

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

Returns:

  • (Boolean)


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

def absolute?
  if @scheme
    true
  else
    false
  end
end

#coerce(oth) ⇒ Object

Args

v

Bundler::URI or String

Description

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

Usage

require 'bundler/vendor/uri/lib/uri'

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


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

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

  return oth, self
end

#componentObject

Components of the Bundler::URI in the order.



314
315
316
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 314

def component
  self.class.component
end

#default_portObject

Returns default port.



40
41
42
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 40

def default_port
  self.class.default_port
end

#eql?(oth) ⇒ Boolean

Returns:

  • (Boolean)


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

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



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
1544
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 1490

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

#hashObject



1382
1383
1384
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 1382

def hash
  self.component_ary.hash
end

#hierarchical?Boolean

Returns true if Bundler::URI is hierarchical.

Description

Bundler::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 'bundler/vendor/uri/lib/uri'

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

Returns:

  • (Boolean)


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

def hierarchical?
  if @path
    true
  else
    false
  end
end

#hostnameObject

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

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

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


645
646
647
648
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 645

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

#hostname=(v) ⇒ Object

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

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

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



662
663
664
665
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 662

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

#inspectObject



1441
1442
1443
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 1441

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

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

Args

oth

Bundler::URI or String

Description

Merges two URIs.

Usage

require 'bundler/vendor/uri/lib/uri'

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


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
1142
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 1100

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

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

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

Bundler::URI or String

Description

Destructive form of #merge.

Usage

require 'bundler/vendor/uri/lib/uri'

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


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

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

#normalizeObject

Returns normalized Bundler::URI.

require 'bundler/vendor/uri/lib/uri'

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

Normalization here means:

  • scheme and host are converted to lowercase,

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



1310
1311
1312
1313
1314
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 1310

def normalize
  uri = dup
  uri.normalize!
  uri
end

#normalize!Object

Destructive version of #normalize.



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

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

#parserObject

Returns the parser to be used.

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



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

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

#passwordObject

Returns the password component.



574
575
576
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 574

def password
  @password
end

#password=(password) ⇒ Object

Args

v

String

Description

Public setter for the password component (with validation).

See also Bundler::URI::Generic.check_password.

Usage

require 'bundler/vendor/uri/lib/uri'

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


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

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

#registryObject

:nodoc:



253
254
255
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 253

def registry # :nodoc:
  nil
end

#registry=(v) ⇒ Object

Raises:



736
737
738
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 736

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

#relative?Boolean

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

Returns:

  • (Boolean)


975
976
977
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 975

def relative?
  !absolute?
end

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

Args

oth

Bundler::URI or String

Description

Calculates relative path from oth to self.

Usage

require 'bundler/vendor/uri/lib/uri'

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


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

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

Bundler::URI or String

Description

Calculates relative path to oth from self.

Usage

require 'bundler/vendor/uri/lib/uri'

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


1293
1294
1295
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 1293

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

#select(*components) ⇒ Object

Args

components

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

Description

Selects specified components from Bundler::URI.

Usage

require 'bundler/vendor/uri/lib/uri'

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


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

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_sObject

Constructs String from Bundler::URI.



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
1369
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 1334

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

#userObject

Returns the user component.



569
570
571
# File 'lib/bundler/vendor/uri/lib/uri/generic.rb', line 569

def user
  @user
end

#user=(user) ⇒ Object

Args

v

String

Description

Public setter for the user component (with validation).

See also Bundler::URI::Generic.check_user.

Usage

require 'bundler/vendor/uri/lib/uri'

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


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

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

#userinfoObject

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



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

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



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

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