Class | URI::Generic
In: | uri/generic.rb
Parent: | Object

Base class for all URI classes.

### Methods

+ - == absolute absolute? build build2 coerce component component default_port default_port eql? fragment= hash hierarchical? host= inspect merge merge! new normalize normalize! opaque= password password= path= port= query= registry= relative? route_from route_to scheme= select to_s use_registry user user= userinfo userinfo=

### Included Modules

URI REGEXP

### Constants

DEFAULT_PORT | = | nil
COMPONENT | = | [ :scheme, :userinfo, :host, :port, :registry, :path, :opaque, :query, :fragment
USE_REGISTRY | = | false

### Attributes

fragment | [R] |
host | [R] |
opaque | [R] |
path | [R] |
port | [R] |
query | [R] |
registry | [R] |
scheme | [R] |

### Public Class methods

build(args)

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

[Source]

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

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

build2(args)

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

[Source]

    # File uri/generic.rb, line 69
        def self.build2(args)
          begin
            return self.build(args)
          rescue InvalidComponentError
            if args.kind_of?(Array)
              return self.build(args.collect{|x|
                if x
                  URI.escape(x)
                else
                  x
                end
              })
            elsif args.kind_of?(Hash)
              tmp = {}
              args.each do |key, value|
                tmp[key] = if value
                    URI.escape(value)
                  else
                    value
                  end
              end
              return self.build(tmp)
            end
          end
        end

component()

Components of the URI in the order.

[Source]

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

default_port()

Returns default port

[Source]

    # File uri/generic.rb, line 25
        def self.default_port
          self::DEFAULT_PORT
        end

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

## 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`: | DOC: FIXME!
`path`: | Path on server
`opaque`: | DOC: FIXME!
`query`: | Query data
`fragment`: | A part of URI after ’#’ sign
`arg_check`: | Check arguments [false by default]

## Description

Creates a new URI::Generic instance from ``generic’’ components without check.

[Source]

    # File uri/generic.rb, line 155
        def initialize(scheme,
                       userinfo, host, port, registry,
                       path, opaque,
                       query,
                       fragment,
                       arg_check = false)
          @scheme = nil
          @user = nil
          @password = nil
          @host = nil
          @port = nil
          @path = nil
          @query = nil
          @opaque = nil
          @registry = nil
          @fragment = nil

          if arg_check
            self.scheme = scheme
            self.userinfo = userinfo
            self.host = host
            self.port = port
            self.path = path
            self.query = query
            self.opaque = opaque
            self.registry = registry
            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.set_query(query)
            self.set_opaque(opaque)
            self.set_registry(registry)
            self.set_fragment(fragment)
          end
          if @registry && !self.class.use_registry
            raise InvalidURIError,
              "the scheme #{@scheme} does not accept registry part: #{@registry} (or bad hostname?)"
          end

          @scheme.freeze if @scheme
          self.set_path('') if !@path && !@opaque # (see RFC2396 Section 5.2)
          self.set_port(self.default_port) if self.default_port && !@port
        end

use_registry()

DOC: FIXME!

[Source]

    # File uri/generic.rb, line 53
        def self.use_registry
          self::USE_REGISTRY
        end

### Public Instance methods

+(oth)

Alias for merge

-(oth)

Alias for route_from

==(oth)

Compares to URI’s

[Source]

    # File uri/generic.rb, line 1041
        def ==(oth)
          if self.class == oth.class
            self.normalize.component_ary == oth.normalize.component_ary
          else
            false
          end
        end

absolute()

Alias for absolute?

absolute?()

Checks if URI is an absolute one

[Source]

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

coerce(oth)

[Source]

    # File uri/generic.rb, line 1107
        def coerce(oth)
          case oth
          when String
            oth = URI.parse(oth)
          else
            super
          end

          return oth, self
        end

component()

[Source]

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

default_port()

[Source]

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

eql?(oth)

[Source]

    # File uri/generic.rb, line 1053
        def eql?(oth)
          self.component_ary.eql?(oth.component_ary)
        end

fragment=(v)

[Source]

    # File uri/generic.rb, line 574
        def fragment=(v)
          check_fragment(v)
          set_fragment(v)
          v
        end

hash()

[Source]

    # File uri/generic.rb, line 1049
        def hash
          self.component_ary.hash
        end

hierarchical?()

Checks if URI has a path

[Source]

    # File uri/generic.rb, line 583
        def hierarchical?
          if @path
            true
          else
            false
          end
        end

host=(v)

[Source]

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

inspect()

[Source]

    # File uri/generic.rb, line 1103
        def inspect
          sprintf("#<%s:%#0x URL:%s>", self.class.to_s, self.object_id, self.to_s)
        end

merge(oth)

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

[Source]

    # File uri/generic.rb, line 725
        def merge(oth)
          begin
            base, rel = merge0(oth)
          rescue
            raise $!.class, $!.message
          end

          if base == rel
            return base
          end

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

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

          base.set_query(nil)
          base.set_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.set_query(rel.query)       if rel.query
          base.set_fragment(rel.fragment) if rel.fragment

          return base
        end

merge!(oth)

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

[Source]

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

normalize()

Returns normalized URI

[Source]

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

normalize!()

Destructive version of normalize

[Source]

    # File uri/generic.rb, line 976
        def normalize!
          if path && path == ''
            set_path('/')
          end
          if host && host != host.downcase
            set_host(self.host.downcase)
          end
        end

opaque=(v)

[Source]

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

password()

[Source]

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

password=(password)

[Source]

    # File uri/generic.rb, line 315
        def password=(password)
          check_password(password)
          set_password(password)
          password
        end

path=(v)

[Source]

    # File uri/generic.rb, line 491
        def path=(v)
          check_path(v)
          set_path(v)
          v
        end

port=(v)

[Source]

    # File uri/generic.rb, line 426
        def port=(v)
          check_port(v)
          set_port(v)
          port
        end

query=(v)

[Source]

    # File uri/generic.rb, line 522
        def query=(v)
          check_query(v)
          set_query(v)
          v
        end

registry=(v)

[Source]

    # File uri/generic.rb, line 455
        def registry=(v)
          check_registry(v)
          set_registry(v)
          v
        end

relative?()

Checks if URI is relative

[Source]

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

route_from(oth)

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

[Source]

    # File uri/generic.rb, line 911
        def route_from(oth)
          # you can modify `rel', but can not `oth'.
          begin
            oth, rel = route_from0(oth)
          rescue
            raise $!.class, $!.message
          end
          if oth == rel
            return rel
          end

          rel.set_path(route_from_path(oth.path, self.path))
          if rel.path == './' && self.query
            # "./?foo" -> "?foo"
            rel.set_path('')
          end

          return rel
        end

route_to(oth)

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

[Source]

    # File uri/generic.rb, line 951
        def route_to(oth)
          case oth
          when Generic
          when String
            oth = URI.parse(oth)
          else
            raise ArgumentError,
              "bad argument(expected URI object or URI string)"
          end

          oth.route_from(self)
        end

scheme=(v)

[Source]

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

select(*components)

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

[Source]

    # File uri/generic.rb, line 1092
        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()

Constructs String from URI

[Source]

    # File uri/generic.rb, line 997
        def to_s
          str = ''
          if @scheme
            str << @scheme
            str << ':'
          end

          if @opaque
            str << @opaque

          else
            if @registry
              str << @registry
            else
              if @host
                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
            end

            str << path_query
          end

          if @fragment
            str << '#'
            str << @fragment
          end

          str
        end

user()

[Source]

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

user=(user)

[Source]

    # File uri/generic.rb, line 309
        def user=(user)
          check_user(user)
          set_user(user)
          user
        end

userinfo()

[Source]

    # File uri/generic.rb, line 357
        def userinfo
          if !@password
            @user
          else
            @user + ':' + @password
          end
        end

userinfo=(userinfo)

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

[Source]

    # File uri/generic.rb, line 300
        def userinfo=(userinfo)
          if userinfo.nil?
            return nil
          end
          check_userinfo(*userinfo)
          set_userinfo(*userinfo)
          userinfo
        end

[Validate]