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

uri/common.rb

Author:Akira Yamada <akira@ruby-lang.org>
Revision:$Id: common.rb,v 1.11.2.2 2004/03/24 12:20:32 gsinclair Exp $
License:You can redistribute it and/or modify it under the same term as Ruby.

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

Public Class methods

extract(str, schemes = nil) {|$&| ...}

Synopsis

  URI::extract(str[, schemes][,&blk])

Args

str:String to extract URIs from.
schemes:Limit URI matching to a specific schemes.

Description

Extracts URIs from a string. If block given, iterates through all matched URIs. Returns nil if block given or array with matches.

Usage

  require "uri"

  URI.extract("text here http://foo.bar.org/bla and here mailto:test@ruby.com and here also.")
  # => ["http://foo.bar.com/foobar", "mailto:foo@bar.com"]

[Source]

# File uri/common.rb, line 547
  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
join(*str)

Synopsis

  URI::join(str[, str, ...])

Args

str:String(s) to work with

Description

Joins URIs.

Usage

  require 'uri'

  p URI.join("http:/localhost/","main.rbx")
  # => #<URI::HTTP:0x2022ac02 URL:http:/localhost/main.php>

[Source]

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

Synopsis

  URI::parse(uri_str)

Args

uri_str:String with URI.

Description

Creates one of the URI’s subclasses instance from the string.

Raises

URI::InvalidURIError 

  Raised if URI given is not a correct one.

Usage

  require 'uri'

  uri = URI.parse("http://www.ruby-lang.org/")
  p uri
  # => #<URI::HTTP:0x202281be URL:http://www.ruby-lang.org/>
  p uri.scheme
  # => "http"
  p uri.host
  # => "www.ruby-lang.org"

[Source]

# File uri/common.rb, line 479
  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
regexp(schemes = nil)

Synopsis

  URI::regexp([match_schemes])

Args

match_schemes:Array of schemes. If given, resulting regexp matches to URIs whose scheme is one of the match_schemes.

Description

Returns a Regexp object which matches to URI-like strings. The Regexp object returned by this method includes arbitrary number of capture group (parentheses). Never rely on it’s number.

Usage

  require 'uri'

  # extract first URI from html_string
  html_string.slice(URI.regexp)

  # remove ftp URIs
  html_string.sub(URI.regexp(['ftp'])

  # You should not rely on the number of parentheses
  html_string.scan(URI.regexp) do |*matches|
    p $&
  end

[Source]

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

Synopsis

  URI::split(uri)

Args

uri:String with URI.

Description

Splits the string on following parts and returns array with result: 

  * Scheme
  * Userinfo
  * Host
  * Port
  * Registry
  * Path
  * Opaque
  * Query
  * Fragment

Usage

  require 'uri'

  p URI.split("http://www.ruby-lang.org/")
  # => ["http", nil, "www.ruby-lang.org", nil, nil, "/", nil, nil, nil]

[Source]

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

Public Instance methods

hierarchical?()

[Source]

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

[Validate]