URI::Generic ^(Class)

In:

Parent:

Object

Base class for all URI classes.

Constants

 nil
 [
       :scheme, 
       :userinfo, :host, :port, :registry, 
       :path, :opaque, 
       :query, 
       :fragment
 false

Attributes

 fragment
 host
 opaque
 path
 port
 query
 registry
 scheme

Included Modules

URI REGEXP

Public Class methods

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

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.

# 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

Components of the URI in the order.

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

Returns default port

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

# 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

DOC: FIXME!

# 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

Compares to URI’s

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

absolute()

Alias for absolute?

Checks if URI is an absolute one

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

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

      return oth, self
    end

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

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

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

hierarchical?()

Checks if URI has a path

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

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

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

Args

oth: URI or String

Description

Merges two URI’s.

Usage

  require 'uri'

  uri = URI.parse("http://my.rubysite.com")
  p uri.merge("/main.rbx?page=1")
  # =>  #<URI::HTTP:0x2021f3b0 URL:http://my.rubysite.com/main.rbx?page=1>

# File uri/generic.rb, line 728
    def merge(oth)
      base, rel = merge0(oth)
      if base == rel
        return base
      end

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

      # RFC2396, Section 5.2, 2)

      if 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))
      else
        # RFC2396, Section 5.2, 4)

        base.set_path(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

Args

oth: URI or String

Description

Destructive form of merge

Usage

  require 'uri'

  uri = URI.parse("http://my.rubysite.com")
  uri.merge!("/main.rbx?page=1")
  p uri
  # =>  #<URI::HTTP:0x2021f3b0 URL:http://my.rubysite.com/main.rbx?page=1>

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

Returns normalized URI

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

Destructive version of normalize

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

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

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

password=(password)

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

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

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

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

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

Checks if URI is relative

# File uri/generic.rb, line 613
    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.rubysite.com/main.rbx?page=1')
  p uri.route_from('http://my.rubysite.com')
  #=> #<URI::Generic:0x20218858 URL:/main.rbx?page=1>

# File uri/generic.rb, line 914
    def route_from(oth)
      # you can modify `rel', but can not `oth'.

      oth, rel = route_from0(oth)
      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 to oth from self

Usage

  require 'uri'

  uri = URI.parse('http://my.rubysite.com')
  p uri.route_to('http://my.rubysite.com/main.rbx?page=1')
  #=> #<URI::Generic:0x2020c2f6 URL:/main.rbx?page=1>

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

# 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.rubysite.com/test.rbx')
  p uri.select(:userinfo, :host, :path)
  # => ["myuser:mypass", "my.rubysite.com", "/test.rbx"]

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

Constructs String from URI

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

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

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

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

userinfo=(userinfo)

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

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