URI (Module)

In: uri.rb
uri/mailto.rb
uri/ldap.rb
uri/https.rb
uri/http.rb
uri/generic.rb
uri/ftp.rb
uri/common.rb

Methods

extract   hierarchical?   join   parse   regexp   split  

Constants

VERSION_CODE = '000911'.freeze
VERSION = VERSION_CODE.scan(/../).collect{|n| n.to_i}.join('.').freeze

Classes and Modules

Module URI::Escape
Module URI::REGEXP
  ::Module URI::REGEXP::PATTERN
Module URI::Util
Class URI::BadURIError
Class URI::Error
Class URI::FTP
Class URI::Generic
Class URI::HTTP
Class URI::HTTPS
Class URI::InvalidComponentError
Class URI::InvalidURIError
Class URI::LDAP
Class URI::MailTo

Included Modules

REGEXP

Public Class methods

[Source]

# File uri/common.rb, line 289
  def self.split(uri)
    case uri
    when ''
      # null uri


    when ABS_URI
      scheme, opaque, userinfo, host, port, 
        registry, path, query, fragment = $~[1..-1]

      # URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]


      # absoluteURI   = scheme ":" ( hier_part | opaque_part )

      # hier_part     = ( net_path | abs_path ) [ "?" query ]

      # opaque_part   = uric_no_slash *uric


      # abs_path      = "/"  path_segments

      # net_path      = "//" authority [ abs_path ]


      # authority     = server | reg_name

      # server        = [ [ userinfo "@" ] hostport ]


      if !scheme
        raise InvalidURIError, 
          "bad URI(absolute but no scheme): #{uri}"
      end
      if !opaque && (!path && (!host && !registry))
        raise InvalidURIError,
          "bad URI(absolute but no path): #{uri}" 
      end

    when REL_URI
      scheme = nil
      opaque = nil

      userinfo, host, port, registry, 
        rel_segment, abs_path, query, fragment = $~[1..-1]
      if rel_segment && abs_path
        path = rel_segment + abs_path
      elsif rel_segment
        path = rel_segment
      elsif abs_path
        path = abs_path
      end

      # URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]


      # relativeURI   = ( net_path | abs_path | rel_path ) [ "?" query ]


      # net_path      = "//" authority [ abs_path ]

      # abs_path      = "/"  path_segments

      # rel_path      = rel_segment [ abs_path ]


      # authority     = server | reg_name

      # server        = [ [ userinfo "@" ] hostport ]


    else
      raise InvalidURIError, "bad URI(is not URI?): #{uri}"
    end

    path = '' if !path && !opaque # (see RFC2396 Section 5.2)

    ret = [
      scheme, 
      userinfo, host, port,     # X

      registry,                 # X

      path,                     # Y

      opaque,                   # Y

      query,
      fragment
    ]
    return ret
  end

[Source]

# File uri/common.rb, line 366
  def self.parse(uri)
    scheme, userinfo, host, port, 
      registry, path, opaque, query, fragment = self.split(uri)

    if scheme && @@schemes.include?(scheme.upcase)
      @@schemes[scheme.upcase].new(scheme, userinfo, host, port, 
                                   registry, path, opaque, query, 
                                   fragment)
    else
      Generic.new(scheme, userinfo, host, port, 
                  registry, path, opaque, query, 
                  fragment)
    end
  end

[Source]

# File uri/common.rb, line 386
  def self.join(*str)
    u = self.parse(str[0])
    str[1 .. -1].each do |x|
      u = u.merge(x)
    end
    u
  end

[Source]

# File uri/common.rb, line 399
  def self.extract(str, schemes = nil, &block)
    if block_given?
      str.scan(regexp(schemes)) { yield $& }
      nil
    else
      result = []
      str.scan(regexp(schemes)) { result.push $& }
      result
    end
  end

[Source]

# File uri/common.rb, line 434
  def self.regexp(schemes = nil)
    unless schemes
      ABS_URI_REF
    else
      /(?=#{Regexp.union(*schemes)}:)#{PATTERN::X_ABS_URI}/xn
    end
  end

Public Instance methods

[Source]

# File uri/ldap.rb, line 243
  def hierarchical?
    false
  end

[Validate]