Class: URI::RFC2396_Parser (Ruby 2.2.2)
Description: Class : URI::RFC2396_Parser - Ruby 2.2.2

- Home
- Core 2.2.2
- Std-lib 2.2.2
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- uri/rfc2396_parser.rb

### Parent

Object

### Methods

- ::new
- #escape
- #extract
- #inspect
- #join
- #make_regexp
- #parse
- #split
- #unescape

### Included Modules

- URI::RFC2396_REGEXP

### Class/Module Index

Quicksearch

- Kernel
- URI
- URI::BadURIError
- URI::Error
- URI::Escape
- URI::FTP
- URI::Generic
- URI::HTTP
- URI::HTTPS
- URI::InvalidComponentError
- URI::InvalidURIError
- URI::LDAP
- URI::LDAPS
- URI::MailTo
- URI::REGEXP
- URI::RFC2396_Parser
- URI::RFC2396_REGEXP
- URI::RFC2396_REGEXP::PATTERN

No matching classes.

# URI::RFC2396_Parser

class that Parses String's into URI's

It contains a Hash set of patterns and Regexp's that match and validate.

### Attributes

pattern[R]

The Hash of patterns.

see also URI::Parser.initialize_pattern

regexp[R]

The Hash of Regexp

see also URI::Parser.initialize_regexp

### Public Class Methods

new(opts = {}) click to toggle source

## Synopsis¶ ↑

    URI::Parser.new([opts])

## Args¶ ↑

The constructor accepts a hash as options for parser. Keys of options are pattern names of URI components and values of options are pattern strings. The constructor generates set of regexps for parsing URIs.

You can use the following keys:

    * :ESCAPED (URI::PATTERN::ESCAPED in default)
    * :UNRESERVED (URI::PATTERN::UNRESERVED in default)
    * :DOMLABEL (URI::PATTERN::DOMLABEL in default)
    * :TOPLABEL (URI::PATTERN::TOPLABEL in default)
    * :HOSTNAME (URI::PATTERN::HOSTNAME in default)

## Examples¶ ↑

    p = URI::Parser.new(:ESCAPED => "(?:%[a-fA-F0-9]{2}|%u[a-fA-F0-9]{4})")
    u = p.parse("http://example.jp/%uABCD") #=> #<URI::HTTP:0xb78cf4f8 URL:http://example.jp/%uABCD>
    URI.parse(u.to_s) #=> raises URI::InvalidURIError

    s = "http://example.com/ABCD"
    u1 = p.parse(s) #=> #<URI::HTTP:0xb78c3220 URL:http://example.com/ABCD>
    u2 = URI.parse(s) #=> #<URI::HTTP:0xb78b6d54 URL:http://example.com/ABCD>
    u1 == u2 #=> true
    u1.eql?(u2) #=> false

                   # File uri/rfc2396_parser.rb, line 99
    def initialize(opts = {})
      @pattern = initialize_pattern(opts)
      @pattern.each_value(&:freeze)
      @pattern.freeze

      @regexp = initialize_regexp(@pattern)
      @regexp.each_value(&:freeze)
      @regexp.freeze
    end

### Public Instance Methods

escape( str ) click to toggle source
escape( str, unsafe )

## Args¶ ↑

`str`

  String to make safe

`unsafe`

  Regexp to apply. Defaults to self.regexp

## Description¶ ↑

constructs a safe String from `str`, removing unsafe characters, replacing them with codes.

                   # File uri/rfc2396_parser.rb, line 299
    def escape(str, unsafe = @regexp[:UNSAFE])
      unless unsafe.kind_of?(Regexp)
        # perhaps unsafe is String object
        unsafe = Regexp.new("[#{Regexp.quote(unsafe)}]", false)
      end
      str.gsub(unsafe) do
        us = $&
        tmp = ''
        us.each_byte do |uc|
          tmp << sprintf('%%%02X', uc)
        end
        tmp
      end.force_encoding(Encoding::US_ASCII)
    end

extract( str ) click to toggle source
extract( str, schemes )
extract( str, schemes ) {|item| block }

## Args¶ ↑

`str`

  String to search

`schemes`

  Patterns to apply to `str`

## Description¶ ↑

Attempts to parse and merge a set of URIs If no `block` given , then returns the result, else it calls `block` for each element in result.

see also URI::Parser.make_regexp

                   # File uri/rfc2396_parser.rb, line 261
    def extract(str, schemes = nil)
      if block_given?
        str.scan(make_regexp(schemes)) { yield $& }
        nil
      else
        result = []
        str.scan(make_regexp(schemes)) { result.push $& }
        result
      end
    end

inspect() click to toggle source

                   # File uri/rfc2396_parser.rb, line 335
    def inspect
      @@to_s.bind(self).call
    end

join(*uris) click to toggle source

## Args¶ ↑

`uris`

  an Array of Strings

## Description¶ ↑

Attempts to parse and merge a set of URIs

                   # File uri/rfc2396_parser.rb, line 235
    def join(*uris)
      uris[0] = convert_to_uri(uris[0])
      uris.inject :merge
    end

make_regexp(schemes = nil) click to toggle source

returns Regexp that is default self.regexp, unless `schemes` is provided. Then it is a Regexp.union with self.pattern

                   # File uri/rfc2396_parser.rb, line 274
    def make_regexp(schemes = nil)
      unless schemes
        @regexp[:ABS_URI_REF]
      else
        /(?=#{Regexp.union(*schemes)}:)#{@pattern[:X_ABS_URI]}/x
      end
    end

parse(uri) click to toggle source

## Args¶ ↑

`uri`

  String

## Description¶ ↑

parses `uri` and constructs either matching URI scheme object (FTP, HTTP, HTTPS, LDAP, LDAPS, or MailTo) or URI::Generic

## Usage¶ ↑

    p = URI::Parser.new
    p.parse("ldap://ldap.example.com/dc=example?user=john")
    #=> #<URI::LDAP:0x00000000b9e7e8 URL:ldap://ldap.example.com/dc=example?user=john>

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

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

split(uri) click to toggle source

Returns a split URI against regexp

                   # File uri/rfc2396_parser.rb, line 120
    def split(uri)
      case uri
      when ''
        # null uri

      when @regexp[: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 @regexp[: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

unescape( str ) click to toggle source
unescape( str, unsafe )

## Args¶ ↑

`str`

  String to remove escapes from

`unsafe`

  Regexp to apply. Defaults to self.regexp

## Description¶ ↑

Removes escapes from `str`

                   # File uri/rfc2396_parser.rb, line 330
    def unescape(str, escaped = @regexp[:ESCAPED])
      str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(str.encoding)
    end