# 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

split(uri)

[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

parse(uri)

[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

join(*str)

[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

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

[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

regexp(schemes = nil)

[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

hierarchical?()

[Source]

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

[Validate]