class Bundler::URI::Generic

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

Constants

COMPONENT

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

DEFAULT_PORT

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

Attributes

fragment[R]

Returns the fragment component of the Bundler::URI.

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

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:foo@example.org").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"
opaque[R]

Returns the opaque part of the Bundler::URI.

Bundler::URI("mailto:foo@example.org").opaque #=> "foo@example.org"
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.)

path[R]

Returns the path component of the Bundler::URI.

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

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
query[R]

Returns the query component of the Bundler::URI.

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

Returns the scheme component of the Bundler::URI.

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

Public Class Methods

build(args) click to toggle source

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.

# File bundler/vendor/uri/lib/uri/generic.rb, line 116
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) click to toggle source

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.

# File bundler/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() click to toggle source

Components of the Bundler::URI in the order.

# File bundler/vendor/uri/lib/uri/generic.rb, line 57
def self.component
  self::COMPONENT
end
default_port() click to toggle source

Returns default port.

# File bundler/vendor/uri/lib/uri/generic.rb, line 32
def self.default_port
  self::DEFAULT_PORT
end
new(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser = DEFAULT_PARSER, arg_check = false) click to toggle source

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.

# File bundler/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

Public Instance Methods

+(oth)
Alias for: merge
-(oth)
Alias for: route_from
==(oth) click to toggle source

Compares two URIs.

# File bundler/vendor/uri/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()
Alias for: absolute?
absolute?() click to toggle source

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

# File bundler/vendor/uri/lib/uri/generic.rb, line 972
def absolute?
  if @scheme
    true
  else
    false
  end
end
Also aliased as: absolute
coerce(oth) click to toggle source

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>]
Calls superclass method
# File bundler/vendor/uri/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() click to toggle source

Components of the Bundler::URI in the order.

# File bundler/vendor/uri/lib/uri/generic.rb, line 313
def component
  self.class.component
end
decoded_password() click to toggle source

Returns the password component after Bundler::URI decoding.

# File bundler/vendor/uri/lib/uri/generic.rb, line 583
def decoded_password
  Bundler::URI.decode_uri_component(@password) if @password
end
decoded_user() click to toggle source

Returns the user component after Bundler::URI decoding.

# File bundler/vendor/uri/lib/uri/generic.rb, line 578
def decoded_user
  Bundler::URI.decode_uri_component(@user) if @user
end
default_port() click to toggle source

Returns default port.

# File bundler/vendor/uri/lib/uri/generic.rb, line 39
def default_port
  self.class.default_port
end
eql?(oth) click to toggle source
# File bundler/vendor/uri/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(env=ENV) click to toggle source

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.

# File bundler/vendor/uri/lib/uri/generic.rb, line 1499
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'
    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 Bundler::URI::Generic.use_proxy?(self.hostname, addr, self.port, no_proxy)
  end
  Bundler::URI.parse(proxy_uri)
end
fragment=(v) click to toggle source

Checks the fragment v component against the Bundler::URI::Parser Regexp for :FRAGMENT.

Args

v

String

Description

Public setter for the fragment component v (with validation).

Usage

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

uri = Bundler::URI.parse("http://my.example.com/?id=25#time=1305212049")
uri.fragment = "time=1305212086"
uri.to_s  #=> "http://my.example.com/?id=25#time=1305212086"
# File bundler/vendor/uri/lib/uri/generic.rb, line 929
def fragment=(v)
  return @fragment = nil unless v

  x = v.to_str
  v = x.dup if x.equal? v
  v.encode!(Encoding::UTF_8) rescue nil
  v.delete!("\t\r\n")
  v.force_encoding(Encoding::ASCII_8BIT)
  v.gsub!(/(?!%\h\h|[!-~])./n){'%%%02X' % $&.ord}
  v.force_encoding(Encoding::US_ASCII)
  @fragment = v
end
hash() click to toggle source
# File bundler/vendor/uri/lib/uri/generic.rb, line 1391
def hash
  self.component_ary.hash
end
hierarchical?() click to toggle source

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:joe@example.com")
uri.hierarchical?
#=> false
# File bundler/vendor/uri/lib/uri/generic.rb, line 961
def hierarchical?
  if @path
    true
  else
    false
  end
end
host=(v) click to toggle source

Args

v

String

Description

Public setter for the host component v (with validation).

See also Bundler::URI::Generic.check_host.

Usage

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

uri = Bundler::URI.parse("http://my.example.com")
uri.host = "foo.com"
uri.to_s  #=> "http://foo.com"
# File bundler/vendor/uri/lib/uri/generic.rb, line 639
def host=(v)
  check_host(v)
  set_host(v)
  v
end
hostname() click to toggle source

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]"
# File bundler/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) click to toggle source

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.

# File bundler/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() click to toggle source
# File bundler/vendor/uri/lib/uri/generic.rb, line 1450
def inspect
  "#<#{self.class} #{self}>"
end
merge(oth) click to toggle source

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"
# File bundler/vendor/uri/lib/uri/generic.rb, line 1109
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
Also aliased as: +
merge!(oth) click to toggle source

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"
# File bundler/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() click to toggle source

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 “/”.

# File bundler/vendor/uri/lib/uri/generic.rb, line 1319
def normalize
  uri = dup
  uri.normalize!
  uri
end
normalize!() click to toggle source

Destructive version of normalize.

# File bundler/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
opaque=(v) click to toggle source

Args

v

String

Description

Public setter for the opaque component v (with validation).

See also Bundler::URI::Generic.check_opaque.

# File bundler/vendor/uri/lib/uri/generic.rb, line 901
def opaque=(v)
  check_opaque(v)
  set_opaque(v)
  v
end
parser() click to toggle source

Returns the parser to be used.

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

# File bundler/vendor/uri/lib/uri/generic.rb, line 289
def parser
  if !defined?(@parser) || !@parser
    DEFAULT_PARSER
  else
    @parser || DEFAULT_PARSER
  end
end
password() click to toggle source

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

# File bundler/vendor/uri/lib/uri/generic.rb, line 573
def password
  @password
end
password=(password) click to toggle source

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:S3nsit1ve@my.example.com")
uri.password = "V3ry_S3nsit1ve"
uri.to_s  #=> "http://john:V3ry_S3nsit1ve@my.example.com"
# File bundler/vendor/uri/lib/uri/generic.rb, line 498
def password=(password)
  check_password(password)
  set_password(password)
  # returns password
end
path=(v) click to toggle source

Args

v

String

Description

Public setter for the path component v (with validation).

See also Bundler::URI::Generic.check_path.

Usage

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

uri = Bundler::URI.parse("http://my.example.com/pub/files")
uri.path = "/faq/"
uri.to_s  #=> "http://my.example.com/faq/"
# File bundler/vendor/uri/lib/uri/generic.rb, line 815
def path=(v)
  check_path(v)
  set_path(v)
  v
end
port=(v) click to toggle source

Args

v

String

Description

Public setter for the port component v (with validation).

See also Bundler::URI::Generic.check_port.

Usage

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

uri = Bundler::URI.parse("http://my.example.com")
uri.port = 8080
uri.to_s  #=> "http://my.example.com:8080"
# File bundler/vendor/uri/lib/uri/generic.rb, line 729
def port=(v)
  check_port(v)
  set_port(v)
  port
end
query=(v) click to toggle source

Args

v

String

Description

Public setter for the query component v.

Usage

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

uri = Bundler::URI.parse("http://my.example.com/?id=25")
uri.query = "id=1"
uri.to_s  #=> "http://my.example.com/?id=1"
# File bundler/vendor/uri/lib/uri/generic.rb, line 839
def query=(v)
  return @query = nil unless v
  raise InvalidURIError, "query conflicts with opaque" if @opaque

  x = v.to_str
  v = x.dup if x.equal? v
  v.encode!(Encoding::UTF_8) rescue nil
  v.delete!("\t\r\n")
  v.force_encoding(Encoding::ASCII_8BIT)
  raise InvalidURIError, "invalid percent escape: #{$1}" if /(%\H\H)/n.match(v)
  v.gsub!(/(?!%\h\h|[!$-&(-;=?-_a-~])./n.freeze){'%%%02X' % $&.ord}
  v.force_encoding(Encoding::US_ASCII)
  @query = v
end
registry=(v) click to toggle source
# File bundler/vendor/uri/lib/uri/generic.rb, line 745
def registry=(v)
  raise InvalidURIError, "can not set registry"
end
relative?() click to toggle source

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

# File bundler/vendor/uri/lib/uri/generic.rb, line 984
def relative?
  !absolute?
end
route_from(oth) click to toggle source

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>
# File bundler/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
Also aliased as: -
route_to(oth) click to toggle source

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>
# File bundler/vendor/uri/lib/uri/generic.rb, line 1302
def route_to(oth)
  parser.__send__(:convert_to_uri, oth).route_from(self)
end
scheme=(v) click to toggle source

Args

v

String

Description

Public setter for the scheme component v (with validation).

See also Bundler::URI::Generic.check_scheme.

Usage

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

uri = Bundler::URI.parse("http://my.example.com")
uri.scheme = "https"
uri.to_s  #=> "https://my.example.com"
# File bundler/vendor/uri/lib/uri/generic.rb, line 360
def scheme=(v)
  check_scheme(v)
  set_scheme(v)
  v
end
select(*components) click to toggle source

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:mypass@my.example.com/test.rbx')
uri.select(:userinfo, :host, :path)
# => ["myuser:mypass", "my.example.com", "/test.rbx"]
# File bundler/vendor/uri/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() click to toggle source

Constructs String from Bundler::URI.

# File bundler/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() click to toggle source

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

# File bundler/vendor/uri/lib/uri/generic.rb, line 568
def user
  @user
end
user=(user) click to toggle source

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:S3nsit1ve@my.example.com")
uri.user = "sam"
uri.to_s  #=> "http://sam:V3ry_S3nsit1ve@my.example.com"
# File bundler/vendor/uri/lib/uri/generic.rb, line 471
def user=(user)
  check_user(user)
  set_user(user)
  # returns user
end
userinfo() click to toggle source

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

# File bundler/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) click to toggle source

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

# File bundler/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

Protected Instance Methods

component_ary() click to toggle source

Returns an Array of the components defined from the COMPONENT Array.

# File bundler/vendor/uri/lib/uri/generic.rb, line 1415
def component_ary
  component.collect do |x|
    self.__send__(x)
  end
end
set_host(v) click to toggle source

Protected setter for the host component v.

See also Bundler::URI::Generic.host=.

# File bundler/vendor/uri/lib/uri/generic.rb, line 613
def set_host(v)
  @host = v
end
set_opaque(v) click to toggle source

Protected setter for the opaque component v.

See also Bundler::URI::Generic.opaque=.

# File bundler/vendor/uri/lib/uri/generic.rb, line 883
def set_opaque(v)
  @opaque = v
end
set_password(v) click to toggle source

Protected setter for the password component v.

See also Bundler::URI::Generic.password=.

# File bundler/vendor/uri/lib/uri/generic.rb, line 534
def set_password(v)
  @password = v
  # returns v
end
set_path(v) click to toggle source

Protected setter for the path component v.

See also Bundler::URI::Generic.path=.

# File bundler/vendor/uri/lib/uri/generic.rb, line 789
def set_path(v)
  @path = v
end
set_port(v) click to toggle source

Protected setter for the port component v.

See also Bundler::URI::Generic.port=.

# File bundler/vendor/uri/lib/uri/generic.rb, line 702
def set_port(v)
  v = v.empty? ? nil : v.to_i unless !v || v.kind_of?(Integer)
  @port = v
end
set_scheme(v) click to toggle source

Protected setter for the scheme component v.

See also Bundler::URI::Generic.scheme=.

# File bundler/vendor/uri/lib/uri/generic.rb, line 334
def set_scheme(v)
  @scheme = v&.downcase
end
set_user(v) click to toggle source

Protected setter for the user component v.

See also Bundler::URI::Generic.user=.

# File bundler/vendor/uri/lib/uri/generic.rb, line 524
def set_user(v)
  set_userinfo(v, @password)
  v
end
set_userinfo(user, password = nil) click to toggle source

Protected setter for the user component, and password if available (with validation).

See also Bundler::URI::Generic.userinfo=.

# File bundler/vendor/uri/lib/uri/generic.rb, line 509
def set_userinfo(user, password = nil)
  unless password
    user, password = split_userinfo(user)
  end
  @user     = user
  @password = password if password

  [@user, @password]
end

Private Instance Methods

check_host(v) click to toggle source

Checks the host v component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :HOST.

Can not have a registry or opaque component defined, with a host component defined.

# File bundler/vendor/uri/lib/uri/generic.rb, line 594
def check_host(v)
  return v unless v

  if @opaque
    raise InvalidURIError,
      "can not set host with registry or opaque"
  elsif parser.regexp[:HOST] !~ v
    raise InvalidComponentError,
      "bad component(expected host component): #{v}"
  end

  return true
end
check_opaque(v) click to toggle source

Checks the opaque v component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :OPAQUE.

Can not have a host, port, user, or path component defined, with an opaque component defined.

# File bundler/vendor/uri/lib/uri/generic.rb, line 861
def check_opaque(v)
  return v unless v

  # raise if both hier and opaque are not nil, because:
  # absoluteURI   = scheme ":" ( hier_part | opaque_part )
  # hier_part     = ( net_path | abs_path ) [ "?" query ]
  if @host || @port || @user || @path  # userinfo = @user + ':' + @password
    raise InvalidURIError,
      "can not set opaque with host, port, userinfo or path"
  elsif v && parser.regexp[:OPAQUE] !~ v
    raise InvalidComponentError,
      "bad component(expected opaque component): #{v}"
  end

  return true
end
check_password(v, user = @user) click to toggle source

Checks the password v component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :USERINFO.

Can not have a registry or opaque component defined, with a user component defined.

# File bundler/vendor/uri/lib/uri/generic.rb, line 417
def check_password(v, user = @user)
  if @opaque
    raise InvalidURIError,
      "can not set password with opaque"
  end
  return v unless v

  if !user
    raise InvalidURIError,
      "password component depends user component"
  end

  if parser.regexp[:USERINFO] !~ v
    raise InvalidComponentError,
      "bad password component"
  end

  return true
end
check_path(v) click to toggle source

Checks the path v component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :ABS_PATH and :REL_PATH.

Can not have a opaque component defined, with a path component defined.

# File bundler/vendor/uri/lib/uri/generic.rb, line 757
def check_path(v)
  # raise if both hier and opaque are not nil, because:
  # absoluteURI   = scheme ":" ( hier_part | opaque_part )
  # hier_part     = ( net_path | abs_path ) [ "?" query ]
  if v && @opaque
    raise InvalidURIError,
      "path conflicts with opaque"
  end

  # If scheme is ftp, path may be relative.
  # See RFC 1738 section 3.2.2, and RFC 2396.
  if @scheme && @scheme != "ftp"
    if v && v != '' && parser.regexp[:ABS_PATH] !~ v
      raise InvalidComponentError,
        "bad component(expected absolute path component): #{v}"
    end
  else
    if v && v != '' && parser.regexp[:ABS_PATH] !~ v &&
       parser.regexp[:REL_PATH] !~ v
      raise InvalidComponentError,
        "bad component(expected relative path component): #{v}"
    end
  end

  return true
end
check_port(v) click to toggle source

Checks the port v component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :PORT.

Can not have a registry or opaque component defined, with a port component defined.

# File bundler/vendor/uri/lib/uri/generic.rb, line 683
def check_port(v)
  return v unless v

  if @opaque
    raise InvalidURIError,
      "can not set port with registry or opaque"
  elsif !v.kind_of?(Integer) && parser.regexp[:PORT] !~ v
    raise InvalidComponentError,
      "bad component(expected port component): #{v.inspect}"
  end

  return true
end
check_scheme(v) click to toggle source

Checks the scheme v component against the Bundler::URI::Parser Regexp for :SCHEME.

# File bundler/vendor/uri/lib/uri/generic.rb, line 320
def check_scheme(v)
  if v && parser.regexp[:SCHEME] !~ v
    raise InvalidComponentError,
      "bad component(expected scheme component): #{v}"
  end

  return true
end
check_user(v) click to toggle source

Checks the user v component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :USERINFO.

Can not have a registry or opaque component defined, with a user component defined.

# File bundler/vendor/uri/lib/uri/generic.rb, line 393
def check_user(v)
  if @opaque
    raise InvalidURIError,
      "can not set user with opaque"
  end

  return v unless v

  if parser.regexp[:USERINFO] !~ v
    raise InvalidComponentError,
      "bad component(expected userinfo component or user component): #{v}"
  end

  return true
end
check_userinfo(user, password = nil) click to toggle source

Checks the user and password.

If password is not provided, then user is split, using Bundler::URI::Generic.split_userinfo, to pull user and +password.

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

# File bundler/vendor/uri/lib/uri/generic.rb, line 375
def check_userinfo(user, password = nil)
  if !password
    user, password = split_userinfo(user)
  end
  check_user(user)
  check_password(password, user)

  return true
end
escape_userpass(v) click to toggle source

Escapes ‘user:password’ v based on RFC 1738 section 3.1.

# File bundler/vendor/uri/lib/uri/generic.rb, line 551
def escape_userpass(v)
  parser.escape(v, /[@:\/]/o) # RFC 1738 section 3.1 #/
end
merge_path(base, rel) click to toggle source

Merges a base path base, with relative path rel, returns a modified base path.

# File bundler/vendor/uri/lib/uri/generic.rb, line 1000
def merge_path(base, rel)

  # RFC2396, Section 5.2, 5)
  # RFC2396, Section 5.2, 6)
  base_path = split_path(base)
  rel_path  = split_path(rel)

  # RFC2396, Section 5.2, 6), a)
  base_path << '' if base_path.last == '..'
  while i = base_path.index('..')
    base_path.slice!(i - 1, 2)
  end

  if (first = rel_path.first) and first.empty?
    base_path.clear
    rel_path.shift
  end

  # RFC2396, Section 5.2, 6), c)
  # RFC2396, Section 5.2, 6), d)
  rel_path.push('') if rel_path.last == '.' || rel_path.last == '..'
  rel_path.delete('.')

  # RFC2396, Section 5.2, 6), e)
  tmp = []
  rel_path.each do |x|
    if x == '..' &&
        !(tmp.empty? || tmp.last == '..')
      tmp.pop
    else
      tmp << x
    end
  end

  add_trailer_slash = !tmp.empty?
  if base_path.empty?
    base_path = [''] # keep '/' for root directory
  elsif add_trailer_slash
    base_path.pop
  end
  while x = tmp.shift
    if x == '..'
      # RFC2396, Section 4
      # a .. or . in an absolute path has no special meaning
      base_path.pop if base_path.size > 1
    else
      # if x == '..'
      #   valid absolute (but abnormal) path "/../..."
      # else
      #   valid absolute path
      # end
      base_path << x
      tmp.each {|t| base_path << t}
      add_trailer_slash = false
      break
    end
  end
  base_path.push('') if add_trailer_slash

  return base_path.join('/')
end
replace!(oth) click to toggle source

Replaces self by other Bundler::URI object.

# File bundler/vendor/uri/lib/uri/generic.rb, line 299
def replace!(oth)
  if self.class != oth.class
    raise ArgumentError, "expected #{self.class} object"
  end

  component.each do |c|
    self.__send__("#{c}=", oth.__send__(c))
  end
end
split_path(path) click to toggle source

Returns an Array of the path split on ‘/’.

# File bundler/vendor/uri/lib/uri/generic.rb, line 991
def split_path(path)
  path.split("/", -1)
end
split_userinfo(ui) click to toggle source

Returns the userinfo ui as [user, password] if properly formatted as ‘user:password’.

# File bundler/vendor/uri/lib/uri/generic.rb, line 542
def split_userinfo(ui)
  return nil, nil unless ui
  user, password = ui.split(':', 2)

  return user, password
end