URI::Generic

Class

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

Constants

DEFAULT_PORT

A Default port of nil for URI::Generic

COMPONENT

An Array of the available components for URI::Generic

scheme

Read

returns the scheme component of the URI.

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

host

Read

returns the host component of the URI.

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

It returns nil if no host component.

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

port

Read

returns the port component of the URI.

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

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

path

Read

returns the path component of the URI.

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

query

Read

returns the query component of the URI.

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

opaque

Read

returns the opaque part of the URI.

URI("mailto:foo@example.org").opaque #=> "foo@example.org"

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

fragment

Read

returns the fragment component of the URI.

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

Class Methods

build(args)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 118
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

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.

build2(args)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 80
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

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.

component

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 58
def self.component
  self::COMPONENT
end

Components of the URI in the order.

default_port

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 33
def self.default_port
  self::DEFAULT_PORT
end

Returns default port

new(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser = DEFAULT_PARSER, arg_check = false)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/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

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.

Instance Methods

+(oth)

lib/uri/generic.rb View on GitHub

An alias for merge

-(oth)

lib/uri/generic.rb View on GitHub

An alias for route_from

==(oth)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/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

Compares two URIs

absolute

lib/uri/generic.rb View on GitHub

An alias for absolute?

absolute?

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 962
def absolute?
  if @scheme
    true
  else
    false
  end
end

Checks if URI is an absolute one

check_host(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 590
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 the host v component for RFC2396 compliance and against the URI::Parser Regexp for :HOST

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

check_opaque(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 865
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 the opaque v component for RFC2396 compliance and against the URI::Parser Regexp for :OPAQUE

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

check_password(v, user = @user)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 419
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 the password v component for RFC2396 compliance and against the URI::Parser Regexp for :USERINFO

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

check_path(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 758
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 the path v component for RFC2396 compliance and against the URI::Parser Regexp for :ABS_PATH and :REL_PATH

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

check_port(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 682
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 the port v component for RFC2396 compliance and against the URI::Parser Regexp for :PORT

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

check_scheme(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/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 the scheme v component against the URI::Parser Regexp for :SCHEME

check_user(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 395
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 the user v component for RFC2396 compliance and against the URI::Parser Regexp for :USERINFO

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

check_userinfo(user, password = nil)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 377
def check_userinfo(user, password = nil)
  if !password
    user, password = split_userinfo(user)
  end
  check_user(user)
  check_password(password, user)

  return true
end

check the user and password.

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

coerce(oth)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1464
def coerce(oth)
  case oth
  when String
    oth = parser.parse(oth)
  else
    super
  end

  return oth, self
end

Args

v: URI or String

Description

attempts to parse other URI oth, returns [parsed_oth, self]

Usage

require 'uri'

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

component

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 313
def component
  self.class.component
end

Components of the URI in the order.

component_ary

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1406
def component_ary
  component.collect do |x|
    self.send(x)
  end
end

returns an Array of the components defined from the COMPONENT Array

default_port

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 40
def default_port
  self.class.default_port
end

Returns default port

eql?(oth)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1386
def eql?(oth)
  self.class == oth.class &&
  parser == oth.parser &&
  self.component_ary.eql?(oth.component_ary)
end

No documentation available

escape_userpass(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 557
def escape_userpass(v)
  parser.escape(v, /[@:\/]/o) # RFC 1738 section 3.1 #/
end

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

find_proxy(env=ENV)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1490
def find_proxy(env=ENV)
  raise BadURIError, "relative URI: #{self}" if self.relative?
  name = self.scheme.downcase + '_proxy'
  proxy_uri = nil
  if name == 'http_proxy' && env.include?('REQUEST_METHOD') # CGI?
    # HTTP_PROXY conflicts with *_proxy for proxy settings and
    # HTTP_* for header information in CGI.
    # So it should be careful to use it.
    pairs = env.reject {|k, v| /\Ahttp_proxy\z/i !~ k }
    case pairs.length
    when 0 # no proxy setting anyway.
      proxy_uri = nil
    when 1
      k, _ = pairs.shift
      if k == 'http_proxy' && env[k.upcase] == nil
        # http_proxy is safe to use because ENV is case sensitive.
        proxy_uri = env[name]
      else
        proxy_uri = nil
      end
    else # http_proxy is safe to use because ENV is case sensitive.
      proxy_uri = env.to_hash[name]
    end
    if !proxy_uri
      # Use CGI_HTTP_PROXY.  cf. libwww-perl.
      proxy_uri = env["CGI_#{name.upcase}"]
    end
  elsif name == 'http_proxy'
    unless proxy_uri = env[name]
      if proxy_uri = env[name.upcase]
        warn 'The environment variable HTTP_PROXY is discouraged.  Use http_proxy.', uplevel: 1
      end
    end
  else
    proxy_uri = env[name] || env[name.upcase]
  end

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

  if self.hostname
    begin
      addr = IPSocket.getaddress(self.hostname)
      return nil if /\A127\.|\A::1\z/ =~ addr
    rescue SocketError
    end
  end

  name = 'no_proxy'
  if no_proxy = env[name] || env[name.upcase]
    return nil unless URI::Generic.use_proxy?(self.hostname, addr, self.port, no_proxy)
  end
  URI.parse(proxy_uri)
end

returns a proxy URI. The proxy URI is obtained from environment variables such as http_proxy, ftp_proxy, no_proxy, etc. If there is no proper proxy, nil is returned.

If the optional parameter, env, is specified, it is used instead of ENV.

Note that capitalized variables (HTTP_PROXY, FTP_PROXY, NO_PROXY, etc.) are examined too.

But http_proxy and HTTP_PROXY is treated specially under CGI environment. It’s because HTTP_PROXY may be set by Proxy: header. So HTTP_PROXY is not used. http_proxy is not used too if the variable is case insensitive. CGI_HTTP_PROXY can be used instead.

fragment=(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 935
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

check the fragment v component against the URI::Parser Regexp for :FRAGMENT

Args

v: String

Description

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

Usage

require 'uri'

uri = URI.parse("http://my.example.com/?id=25#time=1305212049")
uri.fragment = "time=1305212086"
# =>  "time=1305212086"
uri
#=> #<URI::HTTP:0x000000007a81f8 URL:http://my.example.com/?id=25#time=1305212086>

hash

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1382
def hash
  self.component_ary.hash
end

No documentation available

hierarchical?

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 951
def hierarchical?
  if @path
    true
  else
    false
  end
end

Checks if URI has a path

host=(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 637
def host=(v)
  check_host(v)
  set_host(v)
  v
end

Args

v: String

Description

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

Usage

require 'uri'

uri = URI.parse("http://my.example.com")
uri.host = "foo.com"
# =>  "foo.com"
uri
#=> #<URI::HTTP:0x000000008e89e8 URL:http://foo.com>

hostname

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 652
def hostname
  v = self.host
  /\A\[(.*)\]\z/ =~ v ? $1 : v
end

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

hostname=(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 670
def hostname=(v)
  v = "[#{v}]" if /\A\[.*\]\z/ !~ v && /:/ =~ v
  self.host = v
end

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("http://foo/bar")
p u.to_s                  #=> "http://foo/bar"
u.hostname = "::1"
p u.to_s                  #=> "http://[::1]/bar"

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

inspect

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1441
def inspect
  "#<#{self.class} #{self}>"
end

No documentation available

merge(oth)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1100
def merge(oth)
  rel = parser.send(:convert_to_uri, oth)

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

  unless self.absolute?
    raise BadURIError, "both URI are relative"
  end

  base = self.dup

  authority = rel.userinfo || rel.host || rel.port

  # RFC2396, Section 5.2, 2)
  if (rel.path.nil? || rel.path.empty?) && !authority && !rel.query
    base.fragment=(rel.fragment) if rel.fragment
    return base
  end

  base.query = nil
  base.fragment=(nil)

  # RFC2396, Section 5.2, 4)
  if !authority
    base.set_path(merge_path(base.path, rel.path)) if base.path && rel.path
  else
    # RFC2396, Section 5.2, 4)
    base.set_path(rel.path) if rel.path
  end

  # RFC2396, Section 5.2, 7)
  base.set_userinfo(rel.userinfo) if rel.userinfo
  base.set_host(rel.host)         if rel.host
  base.set_port(rel.port)         if rel.port
  base.query = rel.query       if rel.query
  base.fragment=(rel.fragment) if rel.fragment

  return base
end

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>

merge!(oth)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1072
def merge!(oth)
  t = merge(oth)
  if self == t
    nil
  else
    replace!(t)
    self
  end
end

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>

merge_path(base, rel)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 990
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

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

normalize

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1310
def normalize
  uri = dup
  uri.normalize!
  uri
end

Returns normalized URI.

require 'uri'

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

Normalization here means:

scheme and host are converted to lowercase,
an empty path component is set to “/”.

normalize!

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/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

Destructive version of normalize

opaque=(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 905
def opaque=(v)
  check_opaque(v)
  set_opaque(v)
  v
end

Args

v: String

Description

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

parser

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 290
def parser
  if !defined?(@parser) || !@parser
    DEFAULT_PARSER
  else
    @parser || DEFAULT_PARSER
  end
end

returns the parser to be used.

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

password

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 579
def password
  @password
end

returns the password component

password=(password)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 504
def password=(password)
  check_password(password)
  set_password(password)
  # returns password
end

Args

v: String

Description

public setter for the password component. (with validation)

Usage

require 'uri'

uri = URI.parse("http://john:S3nsit1ve@my.example.com")
uri.password = "V3ry_S3nsit1ve"
# =>  "V3ry_S3nsit1ve"
uri
#=> #<URI::HTTP:0x00000000881d90 URL:http://john:V3ry_S3nsit1ve@my.example.com>

path=(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 818
def path=(v)
  check_path(v)
  set_path(v)
  v
end

Args

v: String

Description

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

Usage

require 'uri'

uri = URI.parse("http://my.example.com/pub/files")
uri.path = "/faq/"
# =>  "/faq/"
uri
#=> #<URI::HTTP:0x000000008e89e8 URL:http://my.example.com/faq/>

port=(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 730
def port=(v)
  check_port(v)
  set_port(v)
  port
end

Args

v: String

Description

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

Usage

require 'uri'

uri = URI.parse("http://my.example.com")
uri.port = 8080
# =>  8080
uri
#=> #<URI::HTTP:0x000000008e89e8 URL:http://my.example.com:8080>

query=(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 844
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)
  v.gsub!(/(?!%\h\h|[!$-&(-;=?-_a-~])./n.freeze){'%%%02X' % $&.ord}
  v.force_encoding(Encoding::US_ASCII)
  @query = v
end

Args

v: String

Description

public setter for the query component v.

Usage

require 'uri'

uri = URI.parse("http://my.example.com/?id=25")
uri.query = "id=1"
# =>  "id=1"
uri
#=> #<URI::HTTP:0x000000008e89e8 URL:http://my.example.com/?id=1>

registry=(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 746
def registry=(v)
  raise InvalidURIError, "can not set registry"
end

No documentation available

relative?

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 974
def relative?
  !absolute?
end

Checks if URI is relative

replace!(oth)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/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

replace self by other URI object

route_from(oth)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/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

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>

route_to(oth)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 1293
def route_to(oth)
  parser.send(:convert_to_uri, oth).route_from(self)
end

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>

scheme=(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 362
def scheme=(v)
  check_scheme(v)
  set_scheme(v)
  v
end

Args

v: String

Description

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

Usage

require 'uri'

uri = URI.parse("http://my.example.com")
uri.scheme = "https"
# =>  "https"
uri
#=> #<URI::HTTP:0x000000008e89e8 URL:https://my.example.com>

select(*components)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/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

Args

components: Multiple Symbol arguments defined in URI::HTTP

Description

Selects specified components from URI

Usage

require 'uri'

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

set_host(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 609
def set_host(v)
  @host = v
end

protected setter for the host component v

set_opaque(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 887
def set_opaque(v)
  @opaque = v
end

protected setter for the opaque component v

set_password(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 540
def set_password(v)
  @password = v
  # returns v
end

protected setter for the password component v

set_path(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 790
def set_path(v)
  @path = v
end

protected setter for the path component v

set_port(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 701
def set_port(v)
  v = v.empty? ? nil : v.to_i unless !v || v.kind_of?(Integer)
  @port = v
end

protected setter for the port component v

set_scheme(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 334
def set_scheme(v)
  @scheme = v&.downcase
end

protected setter for the scheme component v

set_user(v)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 530
def set_user(v)
  set_userinfo(v, @password)
  v
end

protected setter for the user component v

set_userinfo(user, password = nil)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 515
def set_userinfo(user, password = nil)
  unless password
    user, password = split_userinfo(user)
  end
  @user     = user
  @password = password if password

  [@user, @password]
end

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

split_path(path)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 981
def split_path(path)
  path.split("/", -1)
end

returns an Array of the path split on ‘/’

split_userinfo(ui)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 548
def split_userinfo(ui)
  return nil, nil unless ui
  user, password = ui.split(':', 2)

  return user, password
end

returns the userinfo ui as user, password if properly formatted as ‘user:password’

to_s

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/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

Constructs String from URI

user

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 574
def user
  @user
end

returns the user component

user=(user)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 475
def user=(user)
  check_user(user)
  set_user(user)
  # returns user
end

Args

v: String

Description

public setter for the user component. (with validation)

Usage

require 'uri'

uri = URI.parse("http://john:S3nsit1ve@my.example.com")
uri.user = "sam"
# =>  "sam"
uri
#=> #<URI::HTTP:0x00000000881d90 URL:http://sam:V3ry_S3nsit1ve@my.example.com>

userinfo

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 563
def userinfo
  if @user.nil?
    nil
  elsif @password.nil?
    @user
  else
    @user + ':' + @password
  end
end

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

userinfo=(userinfo)

lib/uri/generic.rb View on GitHub

          
            # File tmp/rubies/ruby-2.5.9/lib/uri/generic.rb, line 443
def userinfo=(userinfo)
  if userinfo.nil?
    return nil
  end
  check_userinfo(*userinfo)
  set_userinfo(*userinfo)
  # returns userinfo
end

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