# class URI::Generic

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

### Constants

COMPONENT

  An Array of the available components for URI::Generic

DEFAULT_PORT

  A Default port of nil for URI::Generic

### Attributes

fragment[R]

returns the fragment component of the URI.

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

host[R]

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 IO.open. If unwrapped host names are required, use “hostname” method.

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

opaque[R]

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

path[R]

returns the path component of the URI.

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

port[R]

returns the port component of the URI.

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

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

query[R]

returns the query component of the URI.

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

scheme[R]

returns the scheme component of the URI.

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

### Public Class Methods

build(args) click to toggle source

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

    # File lib/uri/generic.rb, line 117
    def self.build(args)
      if args.kind_of?(Array) &&
          args.size == ::URI::Generic::COMPONENT.size
        tmp = args.dup
      elsif args.kind_of?(Hash)
        tmp = ::URI::Generic::COMPONENT.collect do |c|
          if args.include?(c)
            args[c]
          else
            nil
          end
        end
      else
        component = self.class.component rescue ::URI::Generic::COMPONENT
        raise ArgumentError,
        "expected Array of or Hash of components of #{self.class} (#{component.join(', ')})"
      end

      tmp << nil
      tmp << true
      return self.new(*tmp)
    end

build2(args) click to toggle source

## Synopsis¶ ↑

See new

## Description¶ ↑

At first, tries to create a new URI::Generic instance using ::build. But, if exception URI::InvalidComponentError is raised, then it URI::Escape#escape all URI components and tries again.

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

component() click to toggle source

Components of the URI in the order.

    # File lib/uri/generic.rb, line 57
    def self.component
      self::COMPONENT
    end

default_port() click to toggle source

Returns default port

    # File 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`

  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.

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

Checks if URI is an absolute one

    # File lib/uri/generic.rb, line 961
    def absolute?
      if @scheme
        true
      else
        false
      end
    end

Also aliased as: absolute
coerce(oth) click to toggle source

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

Calls superclass method

    # File lib/uri/generic.rb, line 1463
    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 URI in the order.

    # File lib/uri/generic.rb, line 312
    def component
      self.class.component
    end

default_port() click to toggle source

Returns default port

    # File lib/uri/generic.rb, line 39
    def default_port
      self.class.default_port
    end

eql?(oth) click to toggle source

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

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

fragment=(v) click to toggle source

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>

    # File lib/uri/generic.rb, line 934
    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 lib/uri/generic.rb, line 1381
    def hash
      self.component_ary.hash
    end

hierarchical?() click to toggle source

Checks if URI has a path

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

## Usage¶ ↑

    require 'uri'

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

    # File lib/uri/generic.rb, line 636
    def host=(v)
      check_host(v)
      set_host(v)
      v
    end

hostname() click to toggle source

extract the host part of the URI and unwrap brackets for IPv6 addresses.

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

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

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

hostname=(v) click to toggle source

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

This method is same as #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.

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

inspect() click to toggle source

    # File lib/uri/generic.rb, line 1440
    def inspect
      "#<#{self.class} #{self}>"
    end

merge(oth) click to toggle source

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

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

Also aliased as: +
merge!(oth) click to toggle source

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

    # File lib/uri/generic.rb, line 1071
    def merge!(oth)
      t = merge(oth)
      if self == t
        nil
      else
        replace!(t)
        self
      end
    end

normalize() click to toggle source

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

    # File lib/uri/generic.rb, line 1309
    def normalize
      uri = dup
      uri.normalize!
      uri
    end

normalize!() click to toggle source

Destructive version of normalize

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

    # File lib/uri/generic.rb, line 904
    def opaque=(v)
      check_opaque(v)
      set_opaque(v)
      v
    end

parser() click to toggle source

returns the parser to be used.

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

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

    # File lib/uri/generic.rb, line 578
    def password
      @password
    end

password=(password) click to toggle source

## Args¶ ↑

`v`

  String

## Description¶ ↑

public setter for the `password` component. (with validation)

see also #check_password

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

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

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

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

## Usage¶ ↑

    require 'uri'

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

    # File 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 '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>

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

registry=(v) click to toggle source

    # File lib/uri/generic.rb, line 745
    def registry=(v)
      raise InvalidURIError, "can not set registry"
    end

relative?() click to toggle source

Checks if URI is relative

    # File lib/uri/generic.rb, line 973
    def relative?
      !absolute?
    end

route_from(oth) click to toggle source

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

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

  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>

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

## Usage¶ ↑

    require 'uri'

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

    # File lib/uri/generic.rb, line 361
    def scheme=(v)
      check_scheme(v)
      set_scheme(v)
      v
    end

select(*components) click to toggle source

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

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

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

    # File lib/uri/generic.rb, line 573
    def user
      @user
    end

user=(user) click to toggle source

## Args¶ ↑

`v`

  String

## Description¶ ↑

public setter for the `user` component. (with validation)

see also #check_user

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

    # File lib/uri/generic.rb, line 474
    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 lib/uri/generic.rb, line 562
    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 lib/uri/generic.rb, line 442
    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 lib/uri/generic.rb, line 1405
    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 #host=

    # File lib/uri/generic.rb, line 608
    def set_host(v)
      @host = v
    end

set_opaque(v) click to toggle source

protected setter for the opaque component `v`

see also #opaque=

    # File lib/uri/generic.rb, line 886
    def set_opaque(v)
      @opaque = v
    end

set_password(v) click to toggle source

protected setter for the password component `v`

see also #password=

    # File lib/uri/generic.rb, line 539
    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 #path=

    # File 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 #port=

    # File lib/uri/generic.rb, line 700
    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 #scheme=

    # File lib/uri/generic.rb, line 333
    def set_scheme(v)
      @scheme = v&.downcase
    end

set_user(v) click to toggle source

protected setter for the user component `v`

see also #user=

    # File lib/uri/generic.rb, line 529
    def set_user(v)
      set_userinfo(v, @password)
      v
    end

set_userinfo(user, password = nil) click to toggle source

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

see also #userinfo=

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

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.

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

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.

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

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.

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

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.

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

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.

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

check the scheme `v` component against the URI::Parser Regexp for :SCHEME

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

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.

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

check the `user` and `password`.

If `password` is not provided, then `user` is split, using #split_userinfo, to pull `user` and +password.

see also #check_user, #check_password

    # File lib/uri/generic.rb, line 376
    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 lib/uri/generic.rb, line 556
    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 lib/uri/generic.rb, line 989
    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

replace self by other URI object

    # File lib/uri/generic.rb, line 298
    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 lib/uri/generic.rb, line 980
    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 lib/uri/generic.rb, line 547
    def split_userinfo(ui)
      return nil, nil unless ui
      user, password = ui.split(':', 2)

      return user, password
    end