Changed session store from function map to protocol/types

@@ -1,7 +1,7 @@
 (ns ring.middleware.session
   "Session manipulation."
   (:use ring.middleware.cookies
-        ring.middleware.session.memory))
+        [ring.middleware.session store memory]))
 
 (defn wrap-session
   "Reads in the current HTTP session map, and adds it to the :session key on
@@ -34,14 +34,14 @@
       (wrap-cookies
         (fn [request]
           (let [sess-key (get-in request [:cookies cookie-name :value])
-                session  ((store :read) sess-key)
+                session  (read-session store sess-key)
                 request  (assoc request :session session)
                 response (handler request)
                 sess-key* (if (contains? response :session)
                             (if (response :session)
-                              ((store :write) sess-key (response :session))
+                              (write-session store sess-key (response :session))
                               (if sess-key
-                                ((store :delete) sess-key))))
+                                (delete-session store sess-key))))
                 response (dissoc response :session)
                 cookie   {cookie-name (merge cookie-attrs
                                              (response :session-cookie-attrs)

@@ -1,6 +1,7 @@
 (ns ring.middleware.session.cookie
   "Encrypted cookie session storage."
-  (:use [clojure.contrib.def :only (defvar-)])
+  (:use [clojure.contrib.def :only (defvar-)]
+        ring.middleware.session.store)
   (:require (ring.util [codec :as codec]))
   (:import java.security.SecureRandom
            (javax.crypto Cipher Mac)
@@ -77,17 +78,17 @@
     (if (= mac (hmac key data))
       (read-string (decrypt key data)))))
 
+(deftype CookieStore [secret-key]
+  SessionStore
+  (read-session [_ data]
+    (or (if data (unseal secret-key data)) {}))
+  (write-session [_ _ data]
+    (seal secret-key data))
+  (delete-session [_ _]
+    (seal secret-key {})))
+
 (defn cookie-store
   "Creates an encrypted cookie storage engine."
-  ([]
-    (cookie-store {}))
+  ([] (cookie-store {}))
   ([options]
-    (let [secret-key (get-secret-key options)]
-      {:read (fn [session-data]
-               (if session-data
-                 (or (unseal secret-key session-data) {})
-                 {}))
-       :write (fn [_ session]
-                (seal secret-key session))
-       :delete (fn [_]
-                 (seal secret-key {}))})))
+    (CookieStore. (get-secret-key options))))

@@ -1,17 +1,21 @@
 (ns ring.middleware.session.memory
   "In-memory session storage."
+  (:use ring.middleware.session.store)
   (:import java.util.UUID))
 
+(deftype MemoryStore [session-map]
+  SessionStore
+  (read-session [_ key]
+    (@session-map key {}))
+  (write-session [_ key data]
+    (let [key (or key (str (UUID/randomUUID)))]
+      (swap! session-map assoc key data)
+      key))
+  (delete-session [_ key]
+    (swap! session-map dissoc key)
+    nil))
+
 (defn memory-store
   "Creates an in-memory session storage engine."
   []
-  (let [session-map (atom {})]
-    {:read (fn [session-key]
-             (@session-map session-key {}))
-     :write (fn [session-key session]
-              (let [session-key (or session-key (str (UUID/randomUUID)))]
-                (swap! session-map assoc session-key session)
-                session-key))
-     :delete (fn [session-key]
-               (swap! session-map dissoc session-key)
-               nil)}))
+  (MemoryStore. (atom {})))

@@ -0,0 +1,7 @@
+(ns ring.middleware.session.store
+  "Common session store objects and functions.")
+
+(defprotocol SessionStore
+  (read-session [store key] "Read a session map from the store.")
+  (write-session [store key data] "Write a session map to the store.")
+  (delete-session [store key] "Delete a session map from the store."))

@@ -1,33 +1,33 @@
 (ns ring.middleware.session.cookie-test
   (:use clojure.test
-        ring.middleware.session.cookie))
+        [ring.middleware.session store cookie]))
 
 (deftest cookie-session-read-not-exist
   (let [store (cookie-store)]
-    (is ((:read store) "non-existent")
+    (is (read-session store "non-existent")
         {})))
 
 (deftest cookie-session-create
   (let [store    (cookie-store)
-        sess-key ((:write store) nil {:foo "bar"})]
+        sess-key (write-session store nil {:foo "bar"})]
     (is (not (nil? sess-key)))
-    (is (= ((:read store) sess-key)
+    (is (= (read-session store sess-key)
            {:foo "bar"}))))
 
 (deftest cookie-session-update
   (let [store     (cookie-store)
-        sess-key  ((:write store) nil {:foo "bar"})
-        sess-key* ((:write store) sess-key {:bar "baz"})]
+        sess-key  (write-session store nil {:foo "bar"})
+        sess-key* (write-session store sess-key {:bar "baz"})]
     (is (not (nil? sess-key*)))
     (is (not= sess-key sess-key*))
-    (is (= ((:read store) sess-key*)
+    (is (= (read-session store sess-key*)
            {:bar "baz"}))))
 
 (deftest cookie-session-delete
   (let [store     (cookie-store)
-        sess-key  ((:write store) nil {:foo "bar"})
-        sess-key* ((:delete store) sess-key)]
+        sess-key  (write-session store nil {:foo "bar"})
+        sess-key* (delete-session store sess-key)]
     (is (not (nil? sess-key*)))
     (is (not= sess-key sess-key*))
-    (is (= ((:read store) sess-key*)
+    (is (= (read-session store sess-key*)
            {}))))

@@ -1,30 +1,30 @@
 (ns ring.middleware.session.memory-test
   (:use clojure.test
-        ring.middleware.session.memory))
+        [ring.middleware.session store memory]))
 
 (deftest memory-session-read-not-exist
   (let [store (memory-store)]
-    (is ((:read store) "non-existent")
+    (is (read-session store "non-existent")
         {})))
 
 (deftest memory-session-create
   (let [store    (memory-store)
-        sess-key ((:write store) nil {:foo "bar"})]
+        sess-key (write-session store nil {:foo "bar"})]
     (is (not (nil? sess-key)))
-    (is (= ((:read store) sess-key)
+    (is (= (read-session store sess-key)
            {:foo "bar"}))))
 
 (deftest memory-session-update
   (let [store     (memory-store)
-        sess-key  ((:write store) nil {:foo "bar"})
-        sess-key* ((:write store) sess-key {:bar "baz"})]
+        sess-key  (write-session store nil {:foo "bar"})
+        sess-key* (write-session store sess-key {:bar "baz"})]
     (is (= sess-key sess-key*))
-    (is (= ((:read store) sess-key)
+    (is (= (read-session store sess-key)
            {:bar "baz"}))))
 
 (deftest memory-session-delete
   (let [store    (memory-store)
-        sess-key ((:write store) nil {:foo "bar"})]
-    (is (nil? ((:delete store) sess-key)))
-    (is (= ((:read store) sess-key)
+        sess-key (write-session store nil {:foo "bar"})]
+    (is (nil? (delete-session store sess-key)))
+    (is (= (read-session store sess-key)
            {}))))

@@ -1,7 +1,14 @@
 (ns ring.middleware.session-test
   (:use clojure.test
         clojure.contrib.mock.test-adapter
-        ring.middleware.session))
+        ring.middleware.session
+        ring.middleware.session.store))
+
+(defn- make-store [reader writer deleter]
+  (reify SessionStore
+    (read-session [_ k] (reader k))
+    (write-session [_ k s] (writer k s))
+    (delete-session [_ k] (deleter k))))
 
 (declare reader writer deleter)
 
@@ -11,7 +18,7 @@
                      (returns {:bar "foo"})))
            writer  (times never)
            deleter (times never)]
-    (let [store   {:read reader, :write writer, :delete deleter}
+    (let [store   (make-store reader writer deleter)
           handler (fn [req]
                     (is (= (req :session) {:bar "foo"}))
                     {})
@@ -22,7 +29,7 @@
   (expect [reader  (times 1 (returns {}))
            writer  (times 1 (has-args [nil? (partial = {:foo "bar"})]))
            deleter (times never)]
-    (let [store   {:read reader, :write writer, :delete deleter}
+    (let [store   (make-store reader writer deleter)
           handler (constantly {:session {:foo "bar"}})
           handler (wrap-session handler {:store store})]
       (handler {:cookies {}}))))
@@ -31,41 +38,45 @@
   (expect [reader  (times 1 (returns {}))
            writer  (times never)
            deleter (times 1 (has-args [(partial = "test")]))]
-    (let [store   {:read reader, :write writer, :delete deleter}
+    (let [store   (make-store reader writer deleter)
           handler (constantly {:session nil})
           handler (wrap-session handler {:store store})]
       (handler {:cookies {"ring-session" {:value "test"}}}))))
 
 (deftest session-write-outputs-cookie
-  (let [store {:read  (constantly {})
-               :write (constantly "foo:bar")}
+  (let [store (make-store (constantly {})
+                          (constantly "foo:bar")
+                          (constantly nil))
         handler (constantly {:session {:foo "bar"}})
         handler (wrap-session handler {:store store})
         response (handler {:cookies {}})]
     (is (= (get-in response [:headers "Set-Cookie"])
            ["ring-session=foo%3Abar;Path=/"]))))
 
 (deftest session-delete-outputs-cookie
-  (let [store {:read   (constantly {:foo "bar"})
-               :delete (constantly "deleted")}
+  (let [store (make-store (constantly {:foo "bar"})
+                          (constantly nil)
+                          (constantly "deleted"))
         handler (constantly {:session nil})
         handler (wrap-session handler {:store store})
         response (handler {:cookies {"ring-session" {:value "foo:bar"}}})]
     (is (= (get-in response [:headers "Set-Cookie"])
            ["ring-session=deleted;Path=/"]))))
 
 (deftest session-cookie-has-attributes
-  (let [store {:read (constantly {})
-	       :write (constantly "foo:bar")}
+  (let [store (make-store (constantly {})
+                          (constantly "foo:bar")
+                          (constantly nil))
 	handler (constantly {:session {:foo "bar"}})
 	handler (wrap-session handler {:store store :cookie-attrs {:max-age 5}})
 	response (handler {:cookies {}})]
     (is (= (get-in response [:headers "Set-Cookie"])
 	   ["ring-session=foo%3Abar;Path=/;Max-Age=5"]))))
 
 (deftest session-does-not-clobber-response-cookies
-  (let [store {:read (constantly {})
-	       :write (constantly "foo:bar")}
+  (let [store (make-store (constantly {})
+                          (constantly "foo:bar")
+                          (constantly nil))
 	handler (constantly {:session {:foo "bar"}
 			     :cookies {"cookie2" "value2"}})
 	handler (wrap-session handler {:store store :cookie-attrs {:max-age 5}})
@@ -74,17 +85,19 @@
 	   ["ring-session=foo%3Abar;Path=/;Max-Age=5" "cookie2=value2"]))))
 
 (deftest session-root-can-be-set
-  (let [store {:read (constantly {})
-	       :write (constantly "foo:bar")}
+  (let [store (make-store (constantly {})
+                          (constantly "foo:bar")
+                          (constantly nil))
 	handler (constantly {:session {:foo "bar"}})
 	handler (wrap-session handler {:store store, :root "/foo"})
 	response (handler {:cookies {}})]
     (is (= (get-in response [:headers "Set-Cookie"])
 	   ["ring-session=foo%3Abar;Path=/foo"]))))
 
 (deftest session-attrs-can-be-set-per-request
-  (let [store {:read (constantly {})
-	       :write (constantly "foo:bar")}
+  (let [store (make-store (constantly {})
+                          (constantly "foo:bar")
+                          (constantly nil))
 	handler (constantly {:session {:foo "bar"}
                              :session-cookie-attrs {:max-age 5}})
 	handler (wrap-session handler {:store store})