narf 0.5.1

data/scripts/uri/http.rb

@@ -0,0 +1,76 @@
+#
+# $Id: http.rb,v 1.1.1.1 2002/11/29 04:34:25 patsplat Exp $
+#
+# Copyright (c) 2001 akira yamada <akira@ruby-lang.org>
+# You can redistribute it and/or modify it under the same term as Ruby.
+#
+
+require 'uri/generic'
+
+module URI
+
+=begin
+
+== URI::HTTP
+
+=== Super Class
+
+((<URI::Generic>))
+
+=end
+
+  # RFC1738 section 3.3.
+  class HTTP < Generic
+    DEFAULT_PORT = 80
+
+    COMPONENT = [
+      :scheme, 
+      :userinfo, :host, :port, 
+      :path, 
+      :query, 
+      :fragment
+    ].freeze
+
+=begin
+
+=== Class Methods
+
+--- URI::HTTP::build
+    Create a new URI::HTTP object from components of URI::HTTP with
+    check.  It is scheme, userinfo, host, port, path, query and
+    fragment. It provided by an Array of a Hash.
+
+--- URI::HTTP::new
+    Create a new URI::HTTP object from ``generic'' components with no
+    check.
+
+=end
+
+    def self.build(args)
+      tmp = Util::make_components_hash(self, args)
+      return super(tmp)
+    end
+
+    def initialize(*arg)
+      super(*arg)
+    end
+
+=begin
+
+=== Instance Methods
+
+--- URI::HTTP#request_uri
+
+=end
+    def request_uri
+      r = path_query
+      if r[0] != ?/
+	r = '/' + r
+      end
+
+      r
+    end
+  end # HTTP
+
+  @@schemes['HTTP'] = HTTP
+end # URI

data/scripts/uri/https.rb

@@ -0,0 +1,26 @@
+#
+# $Id: https.rb,v 1.1.1.1 2002/11/29 04:34:25 patsplat Exp $
+#
+# Copyright (c) 2001 akira yamada <akira@ruby-lang.org>
+# You can redistribute it and/or modify it under the same term as Ruby.
+#
+
+require 'uri/http'
+
+module URI
+
+=begin
+
+== URI::HTTPS
+
+=== Super Class
+
+((<URI::HTTP>))
+
+=end
+
+  class HTTPS < HTTP
+    DEFAULT_PORT = 443
+  end
+  @@schemes['HTTPS'] = HTTPS
+end # URI

data/scripts/uri/ldap.rb

@@ -0,0 +1,238 @@
+#
+# $Id: ldap.rb,v 1.1.1.1 2002/11/29 04:34:25 patsplat Exp $
+#
+
+require 'uri/generic'
+
+module URI
+
+=begin
+
+== URI::LDAP
+
+URI::LDAP is copyrighted free software by Takaaki Tateishi and akira yamada.
+
+  Copyright (c) 2001 Takaaki Tateishi <ttate@jaist.ac.jp> and 
+  akira yamada <akira@ruby-lang.org>.
+  You can redistribute it and/or modify it under the same term as Ruby.
+
+=== Super Class
+
+((<URI::Generic>))
+
+=end
+
+  # LDAP URI SCHEMA (described in RFC2255)
+  # ldap://<host>/<dn>[?<attrs>[?<scope>[?<filter>[?<extensions>]]]]
+  class LDAP < Generic
+
+    DEFAULT_PORT = 389
+    
+    COMPONENT = [
+      :scheme,
+      :host, :port,
+      :dn,
+      :attributes,
+      :scope,
+      :filter,
+      :extensions,
+    ].freeze
+
+    SCOPE = [
+      SCOPE_ONE = 'one',
+      SCOPE_SUB = 'sub',
+      SCOPE_BASE = 'base',
+    ].freeze
+
+=begin
+
+=== Class Methods
+
+--- URI::LDAP::build
+
+--- URI::LDAP::new
+
+=end
+
+    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
+
+    def initialize(*arg)
+      super(*arg)
+
+      if @fragment
+	raise InvalidURIError, 'bad LDAP URL'
+      end
+
+      parse_dn
+      parse_query
+    end
+
+    def parse_dn
+      @dn = @path[1..-1]
+    end
+    private :parse_dn
+
+    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
+
+    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
+
+=begin
+
+=== Instance Methods
+
+--- URI::LDAP#dn
+
+--- URI::LDAP#dn=(v)
+
+=end
+
+    def dn
+      @dn
+    end
+
+    def set_dn(val)
+      @dn = val
+      build_path_query
+    end
+    protected :set_dn
+
+    def dn=(val)
+      set_dn(val)
+    end
+
+=begin
+
+--- URI::LDAP#attributes
+
+--- URI::LDAP#attributes=(v)
+
+=end
+
+    def attributes
+      @attributes
+    end
+
+    def set_attributes(val)
+      @attributes = val
+      build_path_query
+    end
+    protected :set_attributes
+
+    def attributes=(val)
+      set_attributes(val)
+    end
+
+=begin
+
+--- URI::LDAP#scope
+
+--- URI::LDAP#scope=(v)
+
+=end
+
+    def scope
+      @scope
+    end
+
+    def set_scope(val)
+      @scope = val
+      build_path_query
+    end
+    protected :set_scope
+
+    def scope=(val)
+      set_scope(val)
+    end
+
+=begin
+
+--- URI::LDAP#filter
+
+--- URI::LDAP#filter=(v)
+
+=end
+
+    def filter
+      @filter
+    end
+
+    def set_filter(val)
+      @filter = val
+      build_path_query
+    end
+    protected :set_filter
+
+    def filter=(val)
+      set_filter(val)
+    end
+
+=begin
+
+--- URI::LDAP#extensions
+
+--- URI::LDAP#extensions=(v)
+
+=end
+
+    def extensions
+      @extensions
+    end
+
+    def set_extensions(val)
+      @extensions = val
+      build_path_query
+    end
+    protected :set_extensions
+
+    def extensions=(val)
+      set_extensions(val)
+    end
+  end
+
+  def hierarchical?
+    false
+  end
+
+  @@schemes['LDAP'] = LDAP
+end

data/scripts/uri/mailto.rb

@@ -0,0 +1,260 @@
+#
+# $Id: mailto.rb,v 1.1.1.1 2002/11/29 04:34:25 patsplat Exp $
+#
+# Copyright (c) 2001 akira yamada <akira@ruby-lang.org>
+# You can redistribute it and/or modify it under the same term as Ruby.
+#
+
+require 'uri/generic'
+
+module URI
+
+=begin
+
+== URI::MailTo
+
+=== Super Class
+
+((<URI::Generic>))
+
+=end
+
+  # RFC2368, The mailto URL scheme
+  class MailTo < Generic
+    include REGEXP
+
+    DEFAULT_PORT = nil
+
+    COMPONENT = [
+      :scheme,
+      :to, :headers
+    ].freeze
+
+    #  "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_REGEXP = "(?:[^?=&]*=[^?=&]*)".freeze
+    # headers    =  "?" header *( "&" header )
+    # to         =  #mailbox
+    # mailtoURL  =  "mailto:" [ to ] [ headers ]
+    MAILBOX_REGEXP = "(?:[^(),%?=&]|#{PATTERN::ESCAPED})".freeze
+    MAILTO_REGEXP = Regexp.new("
+      \\A
+      (#{MAILBOX_REGEXP}*?)                         (?# 1: to)
+      (?:
+        \\?
+        (#{HEADER_REGEXP}(?:\\&#{HEADER_REGEXP})*)  (?# 2: headers)
+      )?
+      \\z
+    ", Regexp::EXTENDED, 'N').freeze
+
+=begin
+
+=== Class Methods
+
+--- URI::MailTo::build
+    Create a new URI::MailTo object from components of URI::MailTo
+    with check.  It is to and headers. It provided by an Array of a
+    Hash. You can provide headers as an String like
+    "subject=subscribe&cc=addr" or an Array like [["subject",
+    "subscribe"], ["cc", "addr"]]
+
+--- URI::MailTo::new
+    Create a new URI::MailTo object from ``generic'' components with
+    no check. Because, this method is usually called from URI::parse
+    and the method checks validity of each components.
+
+=end
+
+    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
+
+    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
+      elsif arg[-1]
+	raise InvalidComponentError,
+	  "unrecognised opaque part for mailtoURL: #{@opaque}"
+      end
+    end
+    attr_reader :to
+    attr_reader :headers
+
+=begin
+
+=== Instance Methods
+
+--- URI::MailTo#to
+
+--- URI::MailTo#to=(v)
+
+=end
+
+    #
+    # methods for to
+    #
+
+    def check_to(v)
+      return true unless v
+      return true if v.size == 0
+
+      if OPAQUE !~ v || /\A#{MAILBOX_REGEXP}*\z/o !~ v
+	raise InvalidComponentError,
+	  "bad component(expected opaque component): #{v}"
+      end
+
+      return true
+    end
+    private :check_to
+
+    def set_to(v)
+      @to = v
+    end
+    protected :set_to
+
+    def to=(v)
+      check_to(v)
+      set_to(v)
+    end
+
+=begin
+
+--- URI::MailTo#headers
+
+--- URI::MailTo#headers=(v)
+
+=end
+
+    #
+    # methods for headers
+    #
+
+    def check_headers(v)
+      return true unless v
+      return true if v.size == 0
+
+      if OPAQUE !~ v || 
+	  /\A(#{HEADER_REGEXP}(?:\&#{HEADER_REGEXP})*)\z/o !~ v
+	raise InvalidComponentError,
+	  "bad component(expected opaque component): #{v}"
+      end
+
+      return true
+    end
+    private :check_headers
+
+    def set_headers(v)
+      @headers = []
+      if v
+	v.scan(HEADER_REGEXP) do |x|
+	  @headers << x.split(/=/o, 2)
+	end
+      end
+    end
+    protected :set_headers
+
+    def headers=(v)
+      check_headers(v)
+      set_headers(v)
+    end
+
+    def to_str
+      @scheme + ':' + 
+	if @to 
+	  @to
+	else
+	  ''
+	end + 
+	if @headers.size > 0
+	  '?' + @headers.collect{|x| x.join('=')}.join('&')
+	else
+	  ''
+	end
+    end
+
+=begin
+
+--- URI::MailTo#to_mailtext
+
+=end
+    def to_mailtext
+      to = URI::unescape(@to)
+      head = ''
+      body = ''
+      @headers.each do |x|
+	case x[0]
+	when 'body'
+	  body = URI::unescape(x[1])
+	when 'to'
+	  to << ', ' + URI::unescape(x[1])
+	else
+	  head << URI::unescape(x[0]).capitalize + ': ' +
+	    URI::unescape(x[1])  + "\n"
+	end
+      end
+
+      return "To: #{to}
+#{head}
+#{body}
+"
+    end
+    alias to_rfc822text to_mailtext
+  end # MailTo
+
+  @@schemes['MAILTO'] = MailTo
+end # URI