opal 0.3.11 → 0.3.15

data/runtime/stdlib/uri/http.rb

@@ -0,0 +1,106 @@
+# = 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

@@ -0,0 +1,22 @@
+# = 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

@@ -0,0 +1,260 @@
+# = 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

@@ -0,0 +1,20 @@
+# = 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

@@ -0,0 +1,280 @@
+# = 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