rufus-verbs 0.2 → 0.3

data/README.txt

@@ -21,14 +21,16 @@ currently :
 * proxy-aware (HTTP_PROXY env var or :proxy option)
 * conditional GET (via ConditionalEndPoint class)
 * request body built via a block (post and put)
+* cookie-aware (if :cookies option is explicitely set to true)
+* http digest authentication (rfc 2617) (auth ok, auth-int not tested)
 
 maybe later :
 
 * retry on failure
-* greediness (automatic parsing for content like JSON or YAML)
-* http digest authentication
 * cache awareness
+* greediness (automatic parsing for content like JSON or YAML)
 * head, options
+* persistent cookie jar
 
 
 == getting it
@@ -105,12 +107,29 @@ A ConditionalEndPoint is an EndPoint that will use conditional GETs whenever pos
         # first call will retrieve the representation completely
 
     res = ep.get :id => 1
-        # the server (provided that it supports conditional GET) only 
+        # the server (provided that it supports conditional GETs) only 
         # returned a 304 answer, the response is returned from the
         # ConditionalEndPoint cache
 
 More about conditional GETs at http://ruturajv.wordpress.com/2005/12/27/conditional-get-request/
 
+Cookies may be activated for an endpoint in this way :
+
+    ep = EndPoint.new :cookies => true
+
+    res = ep.get "http://resta.farian.zion/tools/3"
+    res = ep.post("http://resta.farian.zion/tools") { "hammer" }
+
+Digest authentication and basic authentication are available at request or endpoint level :
+
+    ep = EndPoint.new :http_basic_authentication => [ "toto", "secretpass" ]
+
+    ep = EndPoint.new :digest_authentication => [ "toto", "secretpass" ]
+
+    res = get "http://server/doc0", :hba => [ "toto", "secretpass" ]
+
+    res = get "http://server/doc1", :digest_authentication => [ "toto", "secretpass" ]
+
 The tests may provide good intel as on 'rufus-verbs' usage as well : http://rufus.rubyforge.org/svn/trunk/verbs/test/
 
 
@@ -145,12 +164,19 @@ by default, a request returns a Net::HTTPResponse instance, with :body => true,
 * <b>:cache_size</b> (integer, ConditionalEndPoint only)
 by default, a ConditionalEndPoint will cache 147 results (and it'll start discarded the least recently used cached responses). This option is used to set this cache's size.
 
+* <b>:cookies</b> (boolean/integer, E)
+when not set or set to false, rufus-verbs won't care about cookies. If set to true or an integer value, set-cookie requests by the servers will be honoured. The integer value will be interpreted as the size of the 'cookie jar', the default size being 77. The least recently used cookies will be discarded.
+The cookie jar implementation is not persistent.
+
 * <b>:d</b> (string, R)
 the short variant of :data
 
 * <b>:data</b> (string, R)
 the data (request body) for a put or a post.
 
+* <b>:digest_authentication</b> (pair of strings, RE)
+the pair username/password to be used for digest authentication.
+
 * <b>:dry_run</b> (boolean, RE) 
 when <tt>:dry_run => true</tt>, the request will be prepared but not executed and will be returned instead of the HTTP response (used for testing)
 
@@ -163,13 +189,13 @@ the short version of :form_data
 * <b>:form_data</b>
 this option expects a hash. The (post or put) request body will then be built with this hash.
 
-* <b>:hba</b> (pair, RE) 
+* <b>:hba</b> (pair of strings, RE) 
 short for :http_basic_authentication
 
 * <b>:host</b> (string, RE)
 the host or IP address for the request
 
-* <b>:http_basic_authentication</b> (pair, RE)
+* <b>:http_basic_authentication</b> (pair of strings, RE)
 will activate HTTP basic authentication, takes a pair (array) argument [ user, pass ]
 
 * <b>:id</b> (string, R)
@@ -205,6 +231,9 @@ the resource (or the middle) of a full resource path (see :base)
 * <b>:scheme</b> (string, R)
 'http' or 'https'
 
+* <b>:ssl_verify_peer</b> (boolean, RE)
+by default, rufus-verbs doesn't verify ssl certificates. With this option set to true, it will.
+
 * <b>:u</b> (uri, string, RE)
 the short version of :uri
 
@@ -222,9 +251,10 @@ the gem rufus-lru[http://rufus.rubyforge.org/rufus-lru]
 
 == mailing list
 
-On the OpenWFEru-user list[http://groups.google.com/group/openwferu-users] for now :
+On the Rufus-Ruby list[http://groups.google.com/group/rufus-ruby] :
+
+    http://groups.google.com/group/rufus-ruby
 
-    http://groups.google.com/group/openwferu-users
 
 == issue tracker
 

data/lib/rufus/verbs/conditional.rb

@@ -32,6 +32,10 @@
 # 2008/01/16
 #
 
+require 'rubygems'
+require 'rufus/lru'
+
+
 module Rufus::Verbs
 
     #
@@ -61,13 +65,6 @@ module Rufus::Verbs
 
             cs = opts[:cache_size] || 147
 
-            require 'rubygems'
-            begin
-                require 'rufus/lru'
-            rescue LoadError
-                raise "gem 'rufus-lru' is missing, please install it."
-            end
-
             @cache = LruHash.new cs
         end
 

data/lib/rufus/verbs/cookies.rb

@@ -0,0 +1,320 @@
+#
+#--
+# Copyright (c) 2008, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# (MIT license)
+#++
+#
+
+#
+# John Mettraux
+#
+# Made in Japan
+#
+# 2008/01/19
+#
+
+require 'webrick/cookie'
+
+require 'rubygems'
+require 'rufus/lru'
+
+
+module Rufus
+module Verbs
+
+    #
+    # Cookies related methods
+    #
+    # http://www.ietf.org/rfc/rfc2109.txt
+    #
+    module CookieMixin
+
+        protected
+
+            #
+            # Prepares the instance variable @cookies for storing
+            # cooking for this endpoint.
+            #
+            # Reads the :cookies endpoint option for determining the
+            # size of the cookie jar (77 by default).
+            #
+            def prepare_cookie_jar
+
+                o = @opts[:cookies]
+
+                return unless o and o != false
+
+                s = o.to_s.to_i
+                s = 77 if s < 1
+
+                @cookies = CookieJar.new s
+            end
+
+            #
+            # Parses the HTTP response for a potential 'Set-Cookie' header,
+            # parses and returns it as a hash.
+            #
+            def parse_cookies (response)
+
+                c = response['Set-Cookie']
+                return nil unless c
+                Cookie.parse_set_cookies c
+            end
+
+            #
+            # (This method will have no effect if the EndPoint is not
+            # tracking cookies)
+            #
+            # Registers a potential cookie set by the server.
+            #
+            def register_cookies (response, opts)
+
+                return unless @cookies
+
+                cs = parse_cookies response
+
+                return unless cs
+
+                # "The origin server effectively ends a session by
+                #  sending the client a Set-Cookie header with Max-Age=0"
+
+                cs.each do |c|
+
+                    host = opts[:host]
+                    path = opts[:path]
+                    cpath = c.path || "/"
+
+                    next unless cookie_acceptable?(opts, c)
+
+                    domain = c.domain || host
+
+                    if c.max_age == 0
+                        @cookies.remove_cookie domain, path, c
+                    else
+                        @cookies.add_cookie domain, path, c
+                    end
+                end
+            end
+
+            #
+            # Checks if the cookie is acceptable in the context of 
+            # the request that sent it.
+            #
+            def cookie_acceptable? (opts, cookie)
+
+                # reject if :
+                #
+                # * The value for the Path attribute is not a prefix of the 
+                #   request-URI.
+                # * The value for the Domain attribute contains no embedded dots
+                #   or does not start with a dot.
+                # * The value for the request-host does not domain-match the 
+                #   Domain attribute.
+                # * The request-host is a FQDN (not IP address) and has the form
+                #   HD, where D is the value of the Domain attribute, and H is a
+                #   string that contains one or more dots.
+
+                cdomain = cookie.domain
+
+                if cdomain
+
+                    return false unless cdomain.index '.'
+                    return false if cdomain[0, 1] != '.'
+
+                    h, d = split_host(opts[:host])
+                    return false if d != cdomain
+                end
+
+                path = opts[:path]
+                cpath = cookie.path || "/"
+
+                return false if path[0..cpath.length-1] != cpath
+
+                true
+            end
+
+            # 
+            # Places the 'Cookie' header in the request if appropriate.
+            #
+            # (This method will have no effect if the EndPoint is not
+            # tracking cookies)
+            #
+            def mention_cookies (request, opts)
+
+                return unless @cookies
+
+                cs = @cookies.fetch_cookies opts[:host], opts[:path]
+
+                request['Cookie'] = cs.collect { |c| c.to_header_s }.join(",")
+            end
+    end
+
+    #
+    # An extension of the cookie implementation found in WEBrick.
+    #
+    # Unmodified for now.
+    #
+    class Cookie < WEBrick::Cookie
+
+        def to_header_s
+
+            ret = ""
+            ret << @name << "=" << @value
+            ret << "; " << "$Version=" << @version.to_s if @version > 0
+            ret << "; " << "$Domain="  << @domain  if @domain
+            ret << "; " << "$Port="    << @port if @port
+            ret << "; " << "$Path="    << @path if @path
+            ret
+        end
+    end
+
+    #
+    # Cookies are stored by domain, they via this CookieKey which gathers
+    # path and name of the cookie.
+    #
+    class CookieKey
+
+        attr_reader :name, :path
+
+        def initialize (path, cookie)
+
+            @name = cookie.name
+            @path = path || cookie.path
+        end
+
+        #
+        # longer paths first
+        #
+        def <=> (other)
+
+            -1 * (@path <=> other.path)
+        end
+
+        def hash
+            "#{@name}|#{@path}".hash
+        end
+
+        def == (other)
+            (@path == other.path and @name == other.name)
+        end
+
+        alias eql? ==
+    end
+
+    #
+    # A few methods about hostnames.
+    #
+    # (in a mixin... could be helpful somewhere else later)
+    #
+    module HostMixin
+
+        #
+        # Matching a classical IP address (not a v6 though).
+        # Should be sufficient for now.
+        #
+        IP_REGEX = /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+
+        #
+        # Returns a pair host/domain, note that the domain starts with a dot.
+        #
+        #     split_host('localhost') --> [ 'localhost', nil ]
+        #     split_host('benz.car.co.nz') --> [ 'benz', '.car.co.nz' ]
+        #     split_host('127.0.0.1') --> [ '127.0.0.1', nil ]
+        #     split_host('::1') --> [ '::1', nil ] 
+        #
+        def split_host (host)
+
+            return [ host, nil ] if IP_REGEX.match host
+            i = host.index('.')
+            return [ host, nil ] unless i
+            [ host[0..i-1], host[i..-1] ]
+        end
+    end
+
+    #
+    # The container for cookies. Features methods for storing and retrieving
+    # cookies easily.
+    #
+    class CookieJar
+        include HostMixin
+
+        def initialize (jar_size)
+
+            @per_domain = LruHash.new jar_size
+        end
+
+        #
+        # Returns the count of cookies currently stored in this jar.
+        #
+        def size
+
+            @per_domain.keys.inject(0) { |i, d| i + @per_domain[d].size }
+        end
+
+        def add_cookie (domain, path, cookie)
+
+            (@per_domain[domain] ||= {})[CookieKey.new(path, cookie)] = cookie
+        end
+
+        def remove_cookie (domain, path, cookie)
+
+            (d = @per_domain[domain])
+            return unless d
+            d.delete CookieKey.new(path, cookie)
+        end
+
+        #
+        # Retrieves the cookies that matches the combination host/path.
+        # If the retrieved cookie is expired, will remove it from the jar
+        # and return nil.
+        #
+        def fetch_cookies (host, path)
+
+            c = do_fetch(@per_domain[host], path)
+
+            h, d = split_host host
+            c += do_fetch(@per_domain[d], path) if d
+
+            c
+        end
+
+        private
+
+            #
+            # Returns all the cookies that match a domain (host) and a path.
+            #
+            def do_fetch (dh, path)
+
+                return [] unless dh
+
+                keys = dh.keys.sort.find_all do |k|
+                    path[0..k.path.length-1] == k.path
+                end
+                keys.inject([]) do |r, k|
+                    r << dh[k]
+                    r
+                end
+            end
+    end
+end
+end
+

data/lib/rufus/verbs/digest.rb

@@ -0,0 +1,261 @@
+#
+#--
+# Copyright (c) 2008, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# (MIT license)
+#++
+#
+
+#
+# John Mettraux
+#
+# Made in Japan
+#
+# 2008/01/21
+#
+
+require 'digest/md5'
+
+
+module Rufus
+module Verbs
+
+    #
+    # Specified by http://www.ietf.org/rfc/rfc2617.txt
+    # Inspired by http://segment7.net/projects/ruby/snippets/digest_auth.rb
+    #
+    # The EndPoint classes mixes this in to support digest authentication.
+    #
+    module DigestAuthMixin
+
+        #
+        # Makes sure digest_auth is on
+        #
+        def digest_auth (req, opts)
+
+            #return if no_digest_auth
+                # already done in add_authentication()
+
+            @cnonce ||= generate_cnonce
+            @nonce_count ||= 0
+
+            mention_digest_auth(req, opts) \
+                and return
+
+            mention_digest_auth(req, opts) \
+                if request_challenge(req, opts)
+        end
+
+        #
+        # Sets the 'Authorization' header with the appropriate info.
+        #
+        def mention_digest_auth (req, opts)
+
+            return false unless @challenge
+
+            req['Authorization'] = generate_header req, opts
+
+            true
+        end
+
+        #
+        # Interprets the information in the response's 'Authorization-Info'
+        # header.
+        #
+        def check_authentication_info (res, opts)
+
+            return if no_digest_auth
+                # not using digest authentication
+
+            return unless @challenge
+                # not yet authenticated
+
+            authinfo = AuthInfo.new res
+            @challenge.nonce = authinfo.nextnonce
+        end
+
+        protected
+
+            #
+            # Returns true if :digest_authentication is set at endpoint
+            # or request level.
+            #
+            def no_digest_auth
+
+                (not o(opts, :digest_authentication))
+            end
+
+            #
+            # To be enhanced.
+            #
+            # (For example http://www.intertwingly.net/blog/1585.html)
+            #
+            def generate_cnonce
+
+                Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535)))
+            end
+
+            def request_challenge (req, opts)
+
+                op = opts.dup
+
+                op[:digest_authentication] = false
+                    # preventing an infinite loop
+
+                method = req.class.const_get(:METHOD).downcase.to_sym
+                #method = :get
+
+                res = request(method, op)
+
+                return false if res.code.to_i != 401
+
+                @challenge = Challenge.new res
+
+                true
+            end
+
+            #
+            # Generates an MD5 digest of the arguments (joined by ":").
+            #
+            def h (*args)
+
+                Digest::MD5.hexdigest(args.join(":"))
+            end
+
+            #
+            # Generates the Authentication header that will be returned
+            # to the server.
+            #
+            def generate_header (req, opts)
+
+                @nonce_count += 1
+
+                user, pass = o(opts, :digest_authentication)
+                realm = @challenge.realm || ""
+                method = req.class.const_get(:METHOD)
+                path = opts[:path]
+
+                a1 = if @challenge.algorithm == 'MD5-sess'
+                    h(h(user, realm, pass), @challenge.nonce, @cnonce)
+                else
+                    h(user, realm, pass)
+                end
+
+                a2, qop = if @challenge.qop.include?("auth-int")
+                    [ h(method, path, h(req.body)), "auth-int" ]
+                else
+                    [ h(method, path), "auth" ]
+                end
+
+                nc = ('%08x' % @nonce_count)
+
+                digest = h(
+                    #a1, @challenge.nonce, nc, @cnonce, @challenge.qop, a2)
+                    a1, @challenge.nonce, nc, @cnonce, "auth", a2)
+
+                header = ""
+                header << "Digest username=\"#{user}\", "
+                header << "realm=\"#{realm}\", "
+                header << "qop=\"#{qop}\", "
+                header << "uri=\"#{path}\", "
+                header << "nonce=\"#{@challenge.nonce}\", "
+                #header << "nc=##{nc}, "
+                header << "nc=#{nc}, "
+                header << "cnonce=\"#{@cnonce}\", "
+                header << "algorithm=\"#{@challenge.algorithm}\", "
+                #header << "algorithm=\"MD5-sess\", "
+                header << "response=\"#{digest}\", "
+                header << "opaque=\"#{@challenge.opaque}\""
+
+                header
+            end
+
+            #
+            # A common parent class for Challenge and AuthInfo.
+            # Their header parsing code is here.
+            #
+            class ServerReply
+
+                def initialize (res)
+
+                    s = res[header_name]
+                    return nil unless s
+
+                    s = s[7..-1] if s[0, 6] == "Digest"
+
+                    s = s.split ","
+
+                    s.each do |e|
+
+                        k, v = parse_entry e
+
+                        if k == 'stale'
+                            @stale = (v.downcase == 'true') 
+                        elsif k == 'nc'
+                            @nc = v.to_i
+                        elsif k == 'qop'
+                            @qop = v.split ","
+                        else
+                            instance_variable_set "@#{k}".to_sym, v
+                        end
+                    end
+                end
+
+                protected
+
+                    def parse_entry (e)
+
+                        k, v = e.split "=", 2
+                        v = v[1..-2] if v[0, 1] == '"'
+                        [ k.strip, v.strip ]
+                    end
+            end
+
+            #
+            # Used when parsing a 'www-authenticate' header challenge.
+            #
+            class Challenge < ServerReply
+
+                attr_accessor \
+                    :opaque, :algorithm, :qop, :stale, :nonce, :realm, :charset
+
+                def header_name
+                    'www-authenticate'
+                end
+            end
+
+            #
+            # Used when parsing a 'authentication-info' header info.
+            #
+            class AuthInfo < ServerReply
+
+                attr_accessor \
+                    :cnonce, :rspauth, :nextnonce, :qop, :nc
+
+                def header_name
+                    'authentication-info'
+                end
+            end
+    end
+
+end
+end
+

data/lib/rufus/verbs/endpoint.rb

@@ -37,11 +37,14 @@ require 'yaml' # for StringIO (at least for now)
 require 'net/http'
 require 'zlib'
 
+require 'rufus/verbs/version'
+require 'rufus/verbs/cookies'
+require 'rufus/verbs/digest'
+
 
 module Rufus
 module Verbs
 
-    VERSION = "0.2"
     USER_AGENT = "Ruby rufus-verbs #{VERSION}"
 
     #
@@ -64,6 +67,9 @@ module Verbs
     #
     class EndPoint
 
+        include CookieMixin
+        include DigestAuthMixin
+
         #
         # The endpoint initialization opts (Hash instance)
         #
@@ -81,6 +87,8 @@ module Verbs
             @opts[:user_agent] ||= USER_AGENT
 
             @opts[:proxy] ||= ENV['HTTP_PROXY']
+
+            prepare_cookie_jar
         end
 
         def get (*args)
@@ -127,6 +135,8 @@ module Verbs
         #
         def request (method, args, &block)
 
+            # prepare request
+
             opts = EndPoint.extract_opts args
 
             compute_target opts
@@ -139,8 +149,14 @@ module Verbs
 
             add_conditional_headers(req, opts) if method == :get
 
+            mention_cookies(req, opts)
+                # if the :cookies option is disabled (the default)
+                # will have no effect
+
             return req if o(opts, :dry_run) == true
 
+            # trigger request
+
             http = prepare_http opts
 
             res = nil
@@ -149,8 +165,18 @@ module Verbs
                 res = http.request req
             end
 
+            # handle response
+
+            register_cookies res, opts
+                # if the :cookies option is disabled (the default)
+                # will have no effect
+
             return res if o(opts, :raw_response)
 
+            check_authentication_info res, opts
+                # used in case of :digest_authentication
+                # will have no effect else
+
             res = handle_response method, res, opts
 
             return res.body if o(opts, :body)
@@ -187,8 +213,8 @@ module Verbs
             def o (opts, key)
 
                 keys = Array key
-                keys.each { |k| (v = opts[k] and return v) }
-                keys.each { |k| (v = @opts[k] and return v) }
+                keys.each { |k| (v = opts[k]; return v if v != nil) }
+                keys.each { |k| (v = @opts[k]; return v if v != nil) }
                 nil
             end
 
@@ -284,15 +310,21 @@ module Verbs
             #
             def add_authentication (req, opts)
 
-                a = opts[:http_basic_authentication]
+                b = o(opts, :http_basic_authentication)
+                d = o(opts, :digest_authentication)
+                o = o(opts, :auth)
+
+                if b and b != false
+
+                    req.basic_auth b[0], b[1]
 
-                if a
+                elsif d and d != false
 
-                    req.basic_auth a[0], a[1]
+                    digest_auth req, opts
 
-                elsif opts[:auth]
+                elsif o and o != false
 
-                    opts[:auth].call req
+                    o.call req
                 end
             end
 

data/lib/rufus/verbs/version.rb

@@ -0,0 +1,45 @@
+#
+#--
+# Copyright (c) 2008, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# (MIT license)
+#++
+#
+
+#
+# John Mettraux
+#
+# Made in Japan
+#
+# 2008/01/21
+#
+
+
+module Rufus
+module Verbs
+
+    #
+    # The version of this rufus-verbs [gem]
+    #
+    VERSION = '0.3'
+end
+end
+

data/test/{auth_test.rb → auth0_test.rb}

@@ -13,7 +13,7 @@ require 'testbase'
 require 'rufus/verbs'
 
 
-class AuthTest < Test::Unit::TestCase
+class Auth0Test < Test::Unit::TestCase
     include TestBaseMixin
 
     include Rufus::Verbs
@@ -23,7 +23,7 @@ class AuthTest < Test::Unit::TestCase
     #
     def setup
 
-        @server = ItemServer.new :auth => true
+        @server = ItemServer.new :auth => :basic
         @server.start
     end
 

data/test/auth1_test.rb

@@ -0,0 +1,68 @@
+
+#
+# Testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Sun Jan 13 12:33:03 JST 2008
+#
+
+require 'test/unit'
+require 'testbase'
+
+require 'rufus/verbs'
+
+
+class Auth1Test < Test::Unit::TestCase
+    include TestBaseMixin
+
+    include Rufus::Verbs
+
+    #
+    # Using an items server with the authentication on.
+    #
+    def setup
+
+        @server = ItemServer.new :auth => :digest
+        @server.start
+    end
+
+
+    def test_0
+
+        #res = get :uri => "http://localhost:7777/items"
+        #assert_equal 200, res.code.to_i
+        #assert_equal "{}", res.body.strip
+        #res = expect 401, nil, get(:uri => "http://localhost:7777/items")
+        #p res['www-authenticate']
+
+        #$DEBUG = true
+
+        ep = EndPoint.new :digest_authentication => [ "test", "pass" ]
+
+        expect 200, {}, ep.get("http://localhost:7777/items")
+        assert_equal 2, $dcount
+
+        expect 200, {}, ep.get("http://localhost:7777/items")
+        assert_equal 3, $dcount
+
+        expect 201, nil, ep.post("http://localhost:7777/items/1") { "hammer" }
+        assert_equal 4, $dcount
+
+        expect 200, { 1 => "hammer" }, ep.get("http://localhost:7777/items")
+        assert_equal 5, $dcount
+
+        expect 401, nil, get(:uri => "http://localhost:7777/items")
+        assert_equal 6, $dcount
+
+        expect 401, nil, get(
+            :uri => "http://localhost:7777/items", 
+            :http_basic_authentication => [ "toto", "toto" ])
+        assert_equal 7, $dcount
+
+        expect 200, { 1 => "hammer" }, get(
+            :uri => "http://localhost:7777/items", 
+            :digest_authentication => [ "test", "pass" ])
+        assert_equal 9, $dcount
+    end
+end

data/test/cookie0_test.rb

@@ -0,0 +1,122 @@
+
+#
+# Testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Sat Jan 19 18:22:48 JST 2008
+#
+
+require 'test/unit'
+#require 'testbase'
+
+require 'rufus/verbs'
+require 'rufus/verbs/cookies'
+
+
+class Cookie0Test < Test::Unit::TestCase
+    #include TestBaseMixin
+
+    include Rufus::Verbs::CookieMixin
+    include Rufus::Verbs::HostMixin
+
+    #
+    # testing split_host(s)
+    #
+    def test_0
+
+        assert_equal [ 'localhost', nil ], split_host('localhost')
+        assert_equal [ 'benz', '.car.co.nz' ], split_host('benz.car.co.nz')
+        assert_equal [ '127.0.0.1', nil ], split_host('127.0.0.1')
+        assert_equal [ '::1', nil ], split_host('::1')
+    end
+
+    #
+    # testing the CookieJar
+    #
+    def test_1
+
+        cookie0 = TestCookie.new
+        cookie1 = TestCookie.new
+
+        jar = Rufus::Verbs::CookieJar.new 77
+        assert_equal 0, jar.size
+
+        jar.add_cookie(".rubyforge.org", "/", cookie0)
+        assert_equal 1, jar.size
+        assert_equal [ cookie0 ], jar.fetch_cookies("rufus.rubyforge.org", "/main")
+
+        jar.add_cookie("rufus.rubyforge.org", "/sub", cookie1)
+        assert_equal 2, jar.size
+        assert_equal [ cookie1, cookie0 ], jar.fetch_cookies("rufus.rubyforge.org", "/sub/0")
+        assert_equal [ cookie0 ], jar.fetch_cookies("rufus.rubyforge.org", "/main")
+        assert_equal [ cookie0 ], jar.fetch_cookies("rufus.rubyforge.org", "/")
+
+        jar.remove_cookie("rufus.rubyforge.org", "/sub", cookie1)
+        assert_equal 1, jar.size
+    end
+
+    #
+    # testing cookie_acceptable?(opts, cookie)
+    #
+    def test_2
+
+        jar = Rufus::Verbs::CookieJar.new 77
+
+        opts = { :host => 'rufus.rubyforge.org', :path => '/' }
+        c = TestCookie.new '.rubyforge.org', '/'
+        assert cookie_acceptable?(opts, c)
+
+        # * The value for the Domain attribute contains no embedded dots
+        #   or does not start with a dot.
+
+        opts = { :host => 'rufus.rubyforge.org', :path => '/' }
+        c = TestCookie.new 'rufus.rubyforge.org', '/'
+        assert ! cookie_acceptable?(opts, c)
+
+        opts = { :host => 'rufus.rubyforge.org', :path => '/' }
+        c = TestCookie.new 'org', '/'
+        assert ! cookie_acceptable?(opts, c)
+
+        # * The value for the Path attribute is not a prefix of the 
+        #   request-URI.
+
+        opts = { :host => 'rufus.rubyforge.org', :path => '/this' }
+        c = TestCookie.new '.rubyforge.org', '/that'
+        assert ! cookie_acceptable?(opts, c)
+
+        # * The value for the request-host does not domain-match the 
+        #   Domain attribute.
+
+        opts = { :host => 'rufus.rubyforg.org', :path => '/' }
+        c = TestCookie.new '.rubyforge.org', '/'
+        assert ! cookie_acceptable?(opts, c)
+
+        # * The request-host is a FQDN (not IP address) and has the form
+        #   HD, where D is the value of the Domain attribute, and H is a
+        #   string that contains one or more dots.
+        
+        # implicit...
+    end
+
+    #def test_webrick_cookie
+    #    require 'webrick/cookie'
+    #    cookie = "PREF=ID=18da97219de4985:TM=12007507:LM=12007507:S=Guc1JcA15ySZYl2n; expires=Mon, 18-Jan-2010 09:30:37 GMT; path=/; domain=.google.com"
+    #    p WEBrick::Cookie.parse_set_cookie(cookie)
+    #    p Rufus::Verbs::Cookie.parse_set_cookie(cookie)
+    #end
+
+    protected
+
+        class TestCookie
+
+            attr_reader :domain, :path, :name
+
+            def initialize (domain=nil, path=nil, name='whatever')
+
+                @domain = domain
+                @path = path
+                @name = name
+            end
+        end
+end

data/test/cookie1_test.rb

@@ -0,0 +1,60 @@
+
+#
+# Testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Sun Jan 13 12:33:03 JST 2008
+#
+
+require 'test/unit'
+require 'testbase'
+
+require 'rufus/verbs'
+
+
+class Cookie1Test < Test::Unit::TestCase
+    include TestBaseMixin
+
+    include Rufus::Verbs
+
+
+    def test_0
+
+        ep = EndPoint.new :cookies => true
+        class << ep
+            attr_reader :cookies
+        end
+
+        assert_equal 0, ep.cookies.size
+
+        ep.get :uri => "http://localhost:7777/cookie"
+        assert_equal 1, ep.cookies.size
+
+        req = ep.get :uri => "http://localhost:7777/cookie", :dry_run => true
+        assert_match /^tcookie=\d*$/, req['Cookie']
+    end
+
+    def test_1
+
+        ep0 = EndPoint.new :cookies => true
+        ep1 = EndPoint.new :cookies => true
+
+        ep0.post("http://localhost:7777/cookie") { "smurf0" }
+        ep1.post("http://localhost:7777/cookie") { "smurf1" }
+
+        expect 200, [ 'smurf0' ], ep0.get("http://localhost:7777/cookie")
+        expect 200, [ 'smurf1' ], ep1.get("http://localhost:7777/cookie")
+    end
+
+    def test_2
+
+        ep = EndPoint.new :cookies => false # explicitely
+
+        res0 = ep.post("http://localhost:7777/cookie") { "smurf0" }
+        res1 = expect 200, [], ep.get("http://localhost:7777/cookie")
+
+        assert_not_equal res0['Set-Cookie'], res1['Set-Cookie']
+    end
+end
+

data/test/items.rb

@@ -11,6 +11,12 @@ require 'date'
 require 'webrick'
 
 
+$dcount = 0 # tracking the number of hits when doing digest auth
+
+
+#
+# the hash for the /items resource (collection)
+#
 class LastModifiedHash
 
     def initialize
@@ -52,8 +58,12 @@ end
 class ItemServlet < WEBrick::HTTPServlet::AbstractServlet
 
     @@items = {}
+
     @@lastmod = LastModifiedHash.new
 
+    @@authenticator = WEBrick::HTTPAuth::DigestAuth.new(
+        :UserDB => WEBrick::HTTPAuth::Htdigest.new('test/test.htdigest'),
+        :Realm => 'test_realm')
 
     def initialize (server, *options)
 
@@ -66,9 +76,17 @@ class ItemServlet < WEBrick::HTTPServlet::AbstractServlet
     #
     def service (req, res)
 
-        WEBrick::HTTPAuth.basic_auth(req, res, "items") do |u, p|
-            (u != nil and u == p)
-        end if @auth
+        if @auth == :basic
+
+            WEBrick::HTTPAuth.basic_auth(req, res, "items") do |u, p|
+                (u != nil and u == p)
+            end 
+
+        elsif @auth == :digest
+
+            $dcount += 1
+            @@authenticator.authenticate(req, res)
+        end
 
         super
     end
@@ -166,9 +184,9 @@ class ItemServlet < WEBrick::HTTPServlet::AbstractServlet
 
             return true unless since or match
 
-            puts
-            p [ since, match ]
-            puts
+            #puts
+            #p [ since, match ]
+            #puts
 
             (since or match)
         end
@@ -217,6 +235,42 @@ class ThingServlet < WEBrick::HTTPServlet::AbstractServlet
     end
 end
 
+#
+# testing Rufus::Verbs cookies...
+#
+class CookieServlet < WEBrick::HTTPServlet::AbstractServlet
+
+    @@sessions = {}
+
+    def do_GET (req, res)
+
+        res.body = get_session(req, res).inspect
+    end
+
+    def do_POST (req, res)
+
+        get_session(req, res) << req.body.strip
+        res.body = "ok."
+    end
+
+    protected
+
+        def get_session (req, res)
+
+            c = req.cookies.find { |c| c.name == 'tcookie' }
+
+            if c
+                @@sessions[c.value]
+            else
+                s = []
+                key = (Time.now.to_f * 100000).to_i.to_s
+                @@sessions[key] = s
+                res.cookies << WEBrick::Cookie.new('tcookie', key)
+                s
+            end
+        end
+end
+
 #
 # Serving items, a dummy resource...
 # Also serving things, which just redirect to items...
@@ -241,6 +295,7 @@ class ItemServer
 
         @server.mount "/items", ItemServlet
         @server.mount "/things", ThingServlet
+        @server.mount "/cookie", CookieServlet
 
         [ 'INT', 'TERM' ].each do |signal|
             trap(signal) { shutdown } 

data/test/test.htdigest

@@ -0,0 +1 @@
+test:test_realm:fbab5e064c6fa79c414735bcdcf2ce4a

data/test/test.rb

@@ -1,12 +1,18 @@
 
 require 'dryrun_test'
 require 'iconditional_test'
+
 require 'simple_test'
-require 'auth_test'
+
+require 'auth0_test'
+require 'auth1_test'
+
 require 'redir_test'
 require 'block_test'
 require 'https_test'
 require 'proxy_test'
 
 require 'conditional_test'
+require 'cookie0_test'
+require 'cookie1_test'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rufus-verbs
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: "0.3"
 platform: ruby
 authors: 
 - John Mettraux
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-18 00:00:00 +09:00
+date: 2008-01-23 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -25,11 +25,17 @@ files:
 - lib/rufus
 - lib/rufus/verbs
 - lib/rufus/verbs/conditional.rb
+- lib/rufus/verbs/cookies.rb
+- lib/rufus/verbs/digest.rb
 - lib/rufus/verbs/endpoint.rb
+- lib/rufus/verbs/version.rb
 - lib/rufus/verbs.rb
-- test/auth_test.rb
+- test/auth0_test.rb
+- test/auth1_test.rb
 - test/block_test.rb
 - test/conditional_test.rb
+- test/cookie0_test.rb
+- test/cookie1_test.rb
 - test/dryrun_test.rb
 - test/https_test.rb
 - test/iconditional_test.rb
@@ -37,6 +43,7 @@ files:
 - test/proxy_test.rb
 - test/redir_test.rb
 - test/simple_test.rb
+- test/test.htdigest
 - test/test.rb
 - test/testbase.rb
 - README.txt