opal 0.3.15 → 0.3.16

data/runtime/stdlib/uri/http.rb

@@ -1,106 +0,0 @@
-# = uri/http.rb
-#
-# Author:: Akira Yamada <akira@ruby-lang.org>
-# License:: You can redistribute it and/or modify it under the same term as Ruby.
-# Revision:: $Id$
-#
-# See URI for general documentation
-#
-
-require 'uri/generic'
-
-module URI
-
-  #
-  # The syntax of HTTP URIs is defined in RFC1738 section 3.3.
-  #
-  # Note that the Ruby URI library allows HTTP URLs containing usernames and
-  # passwords. This is not legal as per the RFC, but used to be
-  # supported in Internet Explorer 5 and 6, before the MS04-004 security
-  # update. See <URL:http://support.microsoft.com/kb/834489>.
-  #
-  class HTTP < Generic
-    # A Default port of 80 for URI::HTTP
-    DEFAULT_PORT = 80
-
-    # An Array of the available components for URI::HTTP
-    COMPONENT = [
-      :scheme,
-      :userinfo, :host, :port,
-      :path,
-      :query,
-      :fragment
-    ].freeze
-
-    #
-    # == Description
-    #
-    # Create a new URI::HTTP object from components, with syntax checking.
-    #
-    # The components accepted are userinfo, host, port, path, query and
-    # fragment.
-    #
-    # The components should be provided either as an Array, or as a Hash
-    # with keys formed by preceding the component names with a colon.
-    #
-    # If an Array is used, the components must be passed in the order
-    # [userinfo, host, port, path, query, fragment].
-    #
-    # Example:
-    #
-    #     newuri = URI::HTTP.build({:host => 'www.example.com',
-    #       :path> => '/foo/bar'})
-    #
-    #     newuri = URI::HTTP.build([nil, "www.example.com", nil, "/path",
-    #       "query", 'fragment'])
-    #
-    # Currently, if passed userinfo components this method generates
-    # invalid HTTP URIs as per RFC 1738.
-    #
-    def self.build(args)
-      tmp = Util::make_components_hash(self, args)
-      return super(tmp)
-    end
-
-    #
-    # == Description
-    #
-    # Create a new URI::HTTP object from generic URI components as per
-    # RFC 2396. No HTTP-specific syntax checking (as per RFC 1738) is
-    # performed.
-    #
-    # Arguments are +scheme+, +userinfo+, +host+, +port+, +registry+, +path+,
-    # +opaque+, +query+ and +fragment+, in that order.
-    #
-    # Example:
-    #
-    #     uri = URI::HTTP.new('http', nil, "www.example.com", nil, "/path",
-    #       "query", 'fragment')
-    #
-    #
-    # See also URI::Generic.new
-    #
-    def initialize(*arg)
-      super(*arg)
-    end
-
-    #
-    # == Description
-    #
-    # Returns the full path for an HTTP request, as required by Net::HTTP::Get.
-    #
-    # If the URI contains a query, the full path is URI#path + '?' + URI#query.
-    # Otherwise, the path is simply URI#path.
-    #
-    def request_uri
-      r = path_query
-      if r && r[0] != ?/
-        r = '/' + r
-      end
-
-      r
-    end
-  end
-
-  @@schemes['HTTP'] = HTTP
-end

data/runtime/stdlib/uri/https.rb

@@ -1,22 +0,0 @@
-# = uri/https.rb
-#
-# Author:: Akira Yamada <akira@ruby-lang.org>
-# License:: You can redistribute it and/or modify it under the same term as Ruby.
-# Revision:: $Id$
-#
-# See URI for general documentation
-#
-
-require 'uri/http'
-
-module URI
-
-  # The default port for HTTPS URIs is 443, and the scheme is 'https:' rather
-  # than 'http:'. Other than that, HTTPS URIs are identical to HTTP URIs;
-  # see URI::HTTP.
-  class HTTPS < HTTP
-    # A Default port of 443 for URI::HTTPS
-    DEFAULT_PORT = 443
-  end
-  @@schemes['HTTPS'] = HTTPS
-end

data/runtime/stdlib/uri/ldap.rb

@@ -1,260 +0,0 @@
-# = uri/ldap.rb
-#
-# Author::
-#  Takaaki Tateishi <ttate@jaist.ac.jp>
-#  Akira Yamada <akira@ruby-lang.org>
-# License::
-#   URI::LDAP is copyrighted free software by Takaaki Tateishi and Akira Yamada.
-#   You can redistribute it and/or modify it under the same term as Ruby.
-# Revision:: $Id$
-#
-# See URI for general documentation
-#
-
-require 'uri/generic'
-
-module URI
-
-  #
-  # LDAP URI SCHEMA (described in RFC2255)
-  # ldap://<host>/<dn>[?<attrs>[?<scope>[?<filter>[?<extensions>]]]]
-  #
-  class LDAP < Generic
-
-    # A Default port of 389 for URI::LDAP
-    DEFAULT_PORT = 389
-
-    # An Array of the available components for URI::LDAP
-    COMPONENT = [
-      :scheme,
-      :host, :port,
-      :dn,
-      :attributes,
-      :scope,
-      :filter,
-      :extensions,
-    ].freeze
-
-    # Scopes available for the starting point.
-    #
-    # * SCOPE_BASE - the Base DN
-    # * SCOPE_ONE  - one level under the Base DN, not including the base DN and
-    #                not including any entries under this.
-    # * SCOPE_SUB  - subtress, all entries at all levels
-    #
-    SCOPE = [
-      SCOPE_ONE = 'one',
-      SCOPE_SUB = 'sub',
-      SCOPE_BASE = 'base',
-    ].freeze
-
-    #
-    # == Description
-    #
-    # Create a new URI::LDAP object from components, with syntax checking.
-    #
-    # The components accepted are host, port, dn, attributes,
-    # scope, filter, and extensions.
-    #
-    # The components should be provided either as an Array, or as a Hash
-    # with keys formed by preceding the component names with a colon.
-    #
-    # If an Array is used, the components must be passed in the order
-    # [host, port, dn, attributes, scope, filter, extensions].
-    #
-    # Example:
-    #
-    #     newuri = URI::LDAP.build({:host => 'ldap.example.com',
-    #       :dn> => '/dc=example'})
-    #
-    #     newuri = URI::LDAP.build(["ldap.example.com", nil,
-    #       "/dc=example;dc=com", "query", nil, nil, nil])
-    #
-    def self.build(args)
-      tmp = Util::make_components_hash(self, args)
-
-      if tmp[:dn]
-        tmp[:path] = tmp[:dn]
-      end
-
-      query = []
-      [:extensions, :filter, :scope, :attributes].collect do |x|
-        next if !tmp[x] && query.size == 0
-        query.unshift(tmp[x])
-      end
-
-      tmp[:query] = query.join('?')
-
-      return super(tmp)
-    end
-
-    #
-    # == Description
-    #
-    # Create a new URI::LDAP object from generic URI components as per
-    # RFC 2396. No LDAP-specific syntax checking is performed.
-    #
-    # Arguments are +scheme+, +userinfo+, +host+, +port+, +registry+, +path+,
-    # +opaque+, +query+ and +fragment+, in that order.
-    #
-    # Example:
-    #
-    #     uri = URI::LDAP.new("ldap", nil, "ldap.example.com", nil,
-    #       "/dc=example;dc=com", "query", nil, nil, nil, nil)
-    #
-    #
-    # See also URI::Generic.new
-    #
-    def initialize(*arg)
-      super(*arg)
-
-      if @fragment
-        raise InvalidURIError, 'bad LDAP URL'
-      end
-
-      parse_dn
-      parse_query
-    end
-
-    # private method to cleanup +dn+ from using the +path+ component attribute
-    def parse_dn
-      @dn = @path[1..-1]
-    end
-    private :parse_dn
-
-    # private method to cleanup +attributes+, +scope+, +filter+ and +extensions+,
-    # from using the +query+ component attribute
-    def parse_query
-      @attributes = nil
-      @scope      = nil
-      @filter     = nil
-      @extensions = nil
-
-      if @query
-        attrs, scope, filter, extensions = @query.split('?')
-
-        @attributes = attrs if attrs && attrs.size > 0
-        @scope      = scope if scope && scope.size > 0
-        @filter     = filter if filter && filter.size > 0
-        @extensions = extensions if extensions && extensions.size > 0
-      end
-    end
-    private :parse_query
-
-    # private method to assemble +query+ from +attributes+, +scope+, +filter+ and +extensions+.
-    def build_path_query
-      @path = '/' + @dn
-
-      query = []
-      [@extensions, @filter, @scope, @attributes].each do |x|
-        next if !x && query.size == 0
-        query.unshift(x)
-      end
-      @query = query.join('?')
-    end
-    private :build_path_query
-
-    # returns dn.
-    def dn
-      @dn
-    end
-
-    # private setter for dn +val+
-    def set_dn(val)
-      @dn = val
-      build_path_query
-      @dn
-    end
-    protected :set_dn
-
-    # setter for dn +val+
-    def dn=(val)
-      set_dn(val)
-      val
-    end
-
-    # returns attributes.
-    def attributes
-      @attributes
-    end
-
-    # private setter for attributes +val+
-    def set_attributes(val)
-      @attributes = val
-      build_path_query
-      @attributes
-    end
-    protected :set_attributes
-
-    # setter for attributes +val+
-    def attributes=(val)
-      set_attributes(val)
-      val
-    end
-
-    # returns scope.
-    def scope
-      @scope
-    end
-
-    # private setter for scope +val+
-    def set_scope(val)
-      @scope = val
-      build_path_query
-      @scope
-    end
-    protected :set_scope
-
-    # setter for scope +val+
-    def scope=(val)
-      set_scope(val)
-      val
-    end
-
-    # returns filter.
-    def filter
-      @filter
-    end
-
-    # private setter for filter +val+
-    def set_filter(val)
-      @filter = val
-      build_path_query
-      @filter
-    end
-    protected :set_filter
-
-    # setter for filter +val+
-    def filter=(val)
-      set_filter(val)
-      val
-    end
-
-    # returns extensions.
-    def extensions
-      @extensions
-    end
-
-    # private setter for extensions +val+
-    def set_extensions(val)
-      @extensions = val
-      build_path_query
-      @extensions
-    end
-    protected :set_extensions
-
-    # setter for extensions +val+
-    def extensions=(val)
-      set_extensions(val)
-      val
-    end
-
-    # Checks if URI has a path
-    # For URI::LDAP this will return +false+
-    def hierarchical?
-      false
-    end
-  end
-
-  @@schemes['LDAP'] = LDAP
-end

data/runtime/stdlib/uri/ldaps.rb

@@ -1,20 +0,0 @@
-# = uri/ldap.rb
-#
-# License:: You can redistribute it and/or modify it under the same term as Ruby.
-#
-# See URI for general documentation
-#
-
-require 'uri/ldap'
-
-module URI
-
-  # The default port for LDAPS URIs is 636, and the scheme is 'ldaps:' rather
-  # than 'ldap:'. Other than that, LDAPS URIs are identical to LDAP URIs;
-  # see URI::LDAP.
-  class LDAPS < LDAP
-    # A Default port of 636 for URI::LDAPS
-    DEFAULT_PORT = 636
-  end
-  @@schemes['LDAPS'] = LDAPS
-end

data/runtime/stdlib/uri/mailto.rb

@@ -1,280 +0,0 @@
-# = uri/mailto.rb
-#
-# Author:: Akira Yamada <akira@ruby-lang.org>
-# License:: You can redistribute it and/or modify it under the same term as Ruby.
-# Revision:: $Id$
-#
-# See URI for general documentation
-#
-
-require 'uri/generic'
-
-module URI
-
-  #
-  # RFC2368, The mailto URL scheme
-  #
-  class MailTo < Generic
-    include REGEXP
-
-    # A Default port of nil for URI::MailTo
-    DEFAULT_PORT = nil
-
-    # An Array of the available components for URI::MailTo
-    COMPONENT = [ :scheme, :to, :headers ].freeze
-
-    # :stopdoc:
-    #  "hname" and "hvalue" are encodings of an RFC 822 header name and
-    #  value, respectively. As with "to", all URL reserved characters must
-    #  be encoded.
-    #
-    #  "#mailbox" is as specified in RFC 822 [RFC822]. This means that it
-    #  consists of zero or more comma-separated mail addresses, possibly
-    #  including "phrase" and "comment" components. Note that all URL
-    #  reserved characters in "to" must be encoded: in particular,
-    #  parentheses, commas, and the percent sign ("%"), which commonly occur
-    #  in the "mailbox" syntax.
-    #
-    #  Within mailto URLs, the characters "?", "=", "&" are reserved.
-
-    # hname      =  *urlc
-    # hvalue     =  *urlc
-    # header     =  hname "=" hvalue
-    HEADER_PATTERN = "(?:[^?=&]*=[^?=&]*)".freeze
-    HEADER_REGEXP  = Regexp.new(HEADER_PATTERN).freeze
-    # headers    =  "?" header *( "&" header )
-    # to         =  #mailbox
-    # mailtoURL  =  "mailto:" [ to ] [ headers ]
-    MAILBOX_PATTERN = "(?:#{PATTERN::ESCAPED}|[^(),%?=&])".freeze
-    MAILTO_REGEXP = Regexp.new(" # :nodoc:
-      \\A
-      (#{MAILBOX_PATTERN}*?)                          (?# 1: to)
-      (?:
-        \\?
-        (#{HEADER_PATTERN}(?:\\&#{HEADER_PATTERN})*)  (?# 2: headers)
-      )?
-      (?:
-        \\#
-        (#{PATTERN::FRAGMENT})                        (?# 3: fragment)
-      )?
-      \\z
-    ", Regexp::EXTENDED).freeze
-    # :startdoc:
-
-    #
-    # == Description
-    #
-    # Creates a new URI::MailTo object from components, with syntax checking.
-    #
-    # Components can be provided as an Array or Hash. If an Array is used,
-    # the components must be supplied as [to, headers].
-    #
-    # If a Hash is used, the keys are the component names preceded by colons.
-    #
-    # The headers can be supplied as a pre-encoded string, such as
-    # "subject=subscribe&cc=address", or as an Array of Arrays like
-    # [['subject', 'subscribe'], ['cc', 'address']]
-    #
-    # Examples:
-    #
-    #    require 'uri'
-    #
-    #    m1 = URI::MailTo.build(['joe@example.com', 'subject=Ruby'])
-    #    puts m1.to_s  ->  mailto:joe@example.com?subject=Ruby
-    #
-    #    m2 = URI::MailTo.build(['john@example.com', [['Subject', 'Ruby'], ['Cc', 'jack@example.com']]])
-    #    puts m2.to_s  ->  mailto:john@example.com?Subject=Ruby&Cc=jack@example.com
-    #
-    #    m3 = URI::MailTo.build({:to => 'listman@example.com', :headers => [['subject', 'subscribe']]})
-    #    puts m3.to_s  ->  mailto:listman@example.com?subject=subscribe
-    #
-    def self.build(args)
-      tmp = Util::make_components_hash(self, args)
-
-      if tmp[:to]
-        tmp[:opaque] = tmp[:to]
-      else
-        tmp[:opaque] = ''
-      end
-
-      if tmp[:headers]
-        tmp[:opaque] << '?'
-
-        if tmp[:headers].kind_of?(Array)
-          tmp[:opaque] << tmp[:headers].collect { |x|
-            if x.kind_of?(Array)
-              x[0] + '=' + x[1..-1].to_s
-            else
-              x.to_s
-            end
-          }.join('&')
-
-        elsif tmp[:headers].kind_of?(Hash)
-          tmp[:opaque] << tmp[:headers].collect { |h,v|
-            h + '=' + v
-          }.join('&')
-
-        else
-          tmp[:opaque] << tmp[:headers].to_s
-        end
-      end
-
-      return super(tmp)
-    end
-
-    #
-    # == Description
-    #
-    # Creates a new URI::MailTo object from generic URL components with
-    # no syntax checking.
-    #
-    # This method is usually called from URI::parse, which checks
-    # the validity of each component.
-    #
-    def initialize(*arg)
-      super(*arg)
-
-      @to = nil
-      @headers = []
-
-      if MAILTO_REGEXP =~ @opaque
-        if arg[-1]
-          self.to = $1
-          self.headers = $2
-        else
-          set_to($1)
-          set_headers($2)
-        end
-
-      else
-        raise InvalidComponentError,
-          "unrecognised opaque part for mailtoURL: #{@opaque}"
-      end
-    end
-
-    # The primary e-mail address of the URL, as a String
-    attr_reader :to
-
-    # E-mail headers set by the URL, as an Array of Arrays
-    attr_reader :headers
-
-    # check the to +v+ component against either
-    # * URI::Parser Regexp for :OPAQUE
-    # * MAILBOX_PATTERN
-    def check_to(v)
-      return true unless v
-      return true if v.size == 0
-
-      if parser.regexp[:OPAQUE] !~ v || /\A#{MAILBOX_PATTERN}*\z/o !~ v
-        raise InvalidComponentError,
-          "bad component(expected opaque component): #{v}"
-      end
-
-      return true
-    end
-    private :check_to
-
-    # private setter for to +v+
-    def set_to(v)
-      @to = v
-    end
-    protected :set_to
-
-    # setter for to +v+
-    def to=(v)
-      check_to(v)
-      set_to(v)
-      v
-    end
-
-    # check the headers +v+ component against either
-    # * URI::Parser Regexp for :OPAQUE
-    # * HEADER_PATTERN
-    def check_headers(v)
-      return true unless v
-      return true if v.size == 0
-
-      if parser.regexp[:OPAQUE] !~ v ||
-          /\A(#{HEADER_PATTERN}(?:\&#{HEADER_PATTERN})*)\z/o !~ v
-        raise InvalidComponentError,
-          "bad component(expected opaque component): #{v}"
-      end
-
-      return true
-    end
-    private :check_headers
-
-    # private setter for headers +v+
-    def set_headers(v)
-      @headers = []
-      if v
-        v.scan(HEADER_REGEXP) do |x|
-          @headers << x.split(/=/o, 2)
-        end
-      end
-    end
-    protected :set_headers
-
-    # setter for headers +v+
-    def headers=(v)
-      check_headers(v)
-      set_headers(v)
-      v
-    end
-
-    # Constructs String from URI
-    def to_s
-      @scheme + ':' +
-        if @to
-          @to
-        else
-          ''
-        end +
-        if @headers.size > 0
-          '?' + @headers.collect{|x| x.join('=')}.join('&')
-        else
-          ''
-        end +
-        if @fragment
-          '#' + @fragment
-        else
-          ''
-        end
-    end
-
-    # Returns the RFC822 e-mail text equivalent of the URL, as a String.
-    #
-    # Example:
-    #
-    #   require 'uri'
-    #
-    #   uri = URI.parse("mailto:ruby-list@ruby-lang.org?Subject=subscribe&cc=myaddr")
-    #   uri.to_mailtext
-    #   # => "To: ruby-list@ruby-lang.org\nSubject: subscribe\nCc: myaddr\n\n\n"
-    #
-    def to_mailtext
-      to = parser.unescape(@to)
-      head = ''
-      body = ''
-      @headers.each do |x|
-        case x[0]
-        when 'body'
-          body = parser.unescape(x[1])
-        when 'to'
-          to << ', ' + parser.unescape(x[1])
-        else
-          head << parser.unescape(x[0]).capitalize + ': ' +
-            parser.unescape(x[1])  + "\n"
-        end
-      end
-
-      return "To: #{to}
-#{head}
-#{body}
-"
-    end
-    alias to_rfc822text to_mailtext
-  end
-
-  @@schemes['MAILTO'] = MailTo
-end