Merge branch '0.3-beta'

Conflicts:
	project.clj
	ring-core/project.clj
	ring-devel/project.clj
	ring-httpcore-adapter/project.clj
	ring-jetty-adapter/project.clj
	ring-servlet/project.clj

@@ -1,12 +1,12 @@
-(defproject ring "0.2.6"
+(defproject ring "0.3.0-beta1"
   :description "A Clojure web applications library."
   :url "http://github.com/mmcgrana/ring"
   :dependencies
-    [[ring/ring-core "0.2.6"]
-     [ring/ring-devel "0.2.6"]
-     [ring/ring-httpcore-adapter "0.2.6"]
-     [ring/ring-jetty-adapter "0.2.6"]
-     [ring/ring-servlet "0.2.6"]]
+    [[ring/ring-core "0.3.0-beta1"]
+     [ring/ring-devel "0.3.0-beta1"]
+     [ring/ring-httpcore-adapter "0.3.0-beta1"]
+     [ring/ring-jetty-adapter "0.3.0-beta1"]
+     [ring/ring-servlet "0.3.0-beta1"]]
   :dev-dependencies
     [[autodoc "0.7.1"]
      [lein-clojars "0.6.0"]]

@@ -1,10 +1,11 @@
-(defproject ring/ring-core "0.2.6"
+(defproject ring/ring-core "0.3.0-beta1"
   :description "Ring core libraries."
   :url "http://github.com/mmcgrana/ring"
-  :dependencies [[org.clojure/clojure "1.1.0"]
-                 [org.clojure/clojure-contrib "1.1.0"]
+  :dependencies [[org.clojure/clojure "1.2.0"]
+                 [org.clojure/clojure-contrib "1.2.0"]
                  [commons-codec "1.4"]
                  [commons-io "1.4"]
                  [commons-fileupload "1.2.1"]
                  [javax.servlet/servlet-api "2.5"]]
-  :dev-dependencies [[lein-clojars "0.6.0"]])
+  :dev-dependencies [[lein-clojars "0.6.0"]
+                     [swank-clojure "1.2.1"]])

@@ -1,7 +1,6 @@
 (ns ring.middleware.cookies
   "Cookie manipulation."
   (:use [clojure.contrib.def :only (defvar-)]
-        [clojure.contrib.java-utils :only (as-str)]
         ring.util.codec))
 
 (defvar- re-token #"[!#$%&'*\-+.0-9A-Z\^_`a-z\|~]+"
@@ -40,7 +39,7 @@
   [cookies]
   (for [[name value] cookies]
     (let [value (url-decode value)]
-      (if (.startsWith #^String value "\"")
+      (if (.startsWith ^String value "\"")
         [name (read-string value)]
         [name value]))))
 
@@ -76,8 +75,8 @@
 
 (defn- write-value
   "Write the main cookie value."
-  [name value]
-  (str (as-str name) "=" (url-encode value)))
+  [key value]
+  (str (name key) "=" (url-encode value)))
 
 (defn- valid-attr?
   "Is the attribute valid?"
@@ -89,20 +88,20 @@
   [attrs]
   {:pre [(every? valid-attr? attrs)]}
   (for [[key value] attrs]
-    (let [name (set-cookie-attrs key)]
+    (let [attr-name (name (set-cookie-attrs key))]
       (cond
-        (true? value)  (str ";" (as-str name))
+        (true? value)  (str ";" attr-name)
         (false? value) ""
-        :else          (str ";" (as-str name) "=" value)))))
+        :else          (str ";" attr-name "=" value)))))
 
 (defn- write-cookies
   "Turn a map of cookies into a seq of strings for a Set-Cookie header."
   [cookies]
-  (for [[name value] cookies]
+  (for [[key value] cookies]
     (if (map? value)
-      (apply str (write-value name (:value value))
+      (apply str (write-value key (:value value))
                  (write-attr-map (dissoc value :value)))
-      (write-value name value))))
+      (write-value key value))))
 
 (defn- set-cookies
   "Add a Set-Cookie header to a response if there is a :cookies key."

@@ -2,21 +2,21 @@
   "Static file serving."
   (:use (clojure.contrib [def :only (defvar-)]
                          [except :only (throw-if-not)]))
-  (:require (ring.util [codec :as codec] [response :as response])
-            [clojure.contrib.java-utils :as ju])
+  (:require (ring.util [codec :as codec]
+                       [response :as response]))
   (:import java.io.File))
 
 (defn- ensure-dir
   "Ensures that a directory exists at the given path, throwing if one does not."
-  [#^String dir-path]
+  [^String dir-path]
   (let [dir (File. dir-path)]
     (throw-if-not (.exists dir) "Directory does not exist: %s" dir-path)))
 
 (defn wrap-file
   "Wrap an app such that the directory at the given root-path is checked for a
   static file with which to respond to the request, proxying the request to the
   wrapped app if such a file does not exist."
-  [app #^String root-path]
+  [app ^String root-path]
   (ensure-dir root-path)
   (fn [req]
     (if-not (= :get (:request-method req))

@@ -64,13 +64,13 @@
 
 (defn- get-extension
   "Returns the file extension of a file."
-  [#^File file]
+  [^File file]
   (second (re-find #"\.([^./\\]+)$" (.getPath file))))
 
 (defn- guess-mime-type
   "Returns a String corresponding to the guessed mime type for the given file,
   or application/octet-stream if a type cannot be guessed."
-  [#^File file mime-types]
+  [^File file mime-types]
   (get mime-types (get-extension file) "application/octet-stream"))
 
 (defn make-http-format
@@ -100,8 +100,8 @@
       (let [{:keys [headers body] :as response} (app req)]
         (if (instance? File body)
           (let [file-type   (guess-mime-type body mime-types)
-                file-length (.length #^File body)
-                lmodified   (Date. (.lastModified #^File body))
+                file-length (.length ^File body)
+                lmodified   (Date. (.lastModified ^File body))
                 response    (-> response
                               (content-type file-type)
                               (header "Last-Modified"

@@ -11,10 +11,10 @@
 (defn- multipart-form?
   "Does a request have a multipart form?"
   [request]
-  (if-let [#^String content-type (:content-type request)]
+  (if-let [^String content-type (:content-type request)]
     (.startsWith content-type "multipart/form-data")))
 
-(defvar- #^FileUpload file-upload
+(defvar- ^FileUpload file-upload
   (FileUpload.
     (doto (DiskFileItemFactory.)
       (.setSizeThreshold -1)
@@ -25,15 +25,15 @@
   "Create a RequestContext object from a request map."
   {:tag RequestContext}
   [request encoding]
-  (proxy [RequestContext] []
-    (getContentType []       (:content-type request))
-    (getContentLength []     (:content-length request))
-    (getCharacterEncoding [] encoding)
-    (getInputStream []       (:body request))))
+  (reify RequestContext
+    (getContentType [this]       (:content-type request))
+    (getContentLength [this]     (:content-length request))
+    (getCharacterEncoding [this] encoding)
+    (getInputStream [this]       (:body request))))
 
 (defn- file-map
   "Create a file map from a DiskFileItem."
-  [#^DiskFileItem item]
+  [^DiskFileItem item]
   (with-meta
     {:filename     (.getName item)
      :size         (.getSize item)
@@ -45,7 +45,7 @@
   "Parse a map of multipart parameters from the request."
   [request encoding]
   (reduce
-    (fn [param-map, #^DiskFileItem item]
+    (fn [param-map, ^DiskFileItem item]
       (assoc-param param-map
         (.getFieldName item)
         (if (.isFormField item)

@@ -1,7 +1,8 @@
 (ns ring.middleware.params
   "Parse form and query params."
-  (:require (clojure.contrib [str-utils :as str] [duck-streams :as duck])
-            (ring.util [codec :as codec])))
+  (:require [ring.util.codec :as codec]
+            [clojure.string :as string]
+            [clojure.contrib.io :as io]))
 
 (defn assoc-param
   "Associate a key with a value. If the key already exists in the map,
@@ -16,7 +17,7 @@
 
 (defn- parse-params
   "Parse parameters from a string into a map."
-  [#^String param-string encoding]
+  [^String param-string encoding]
   (reduce
     (fn [param-map encoded-param]
       (if-let [[_ key val] (re-matches #"([^=]+)=(.*)" encoded-param)]
@@ -25,7 +26,7 @@
           (codec/url-decode (or val "") encoding))
          param-map))
     {}
-    (str/re-split #"&" param-string)))
+    (string/split param-string #"&")))
 
 (defn- assoc-query-params
   "Parse and assoc parameters from the query string with the request."
@@ -39,15 +40,15 @@
 (defn- urlencoded-form?
   "Does a request have a urlencoded form?"
   [request]
-  (if-let [#^String type (:content-type request)]
+  (if-let [^String type (:content-type request)]
     (.startsWith type "application/x-www-form-urlencoded")))
 
 (defn- assoc-form-params
   "Parse and assoc parameters from the request body with the request."
   [request encoding]
   (merge-with merge request
     (if-let [body (and (urlencoded-form? request) (:body request))]
-      (let [params (parse-params (duck/slurp* body) encoding)]
+      (let [params (parse-params (io/slurp* body) encoding)]
         {:form-params params, :params params})
       {:form-params {}, :params {}})))
 

@@ -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)
@@ -59,7 +60,7 @@
   [options]
   (if-let [secret-key (:key options)]
     (if (string? secret-key)
-      (.getBytes #^String secret-key)
+      (.getBytes ^String secret-key)
       secret-key)
     (secure-random-bytes 16)))
 
@@ -71,23 +72,23 @@
 
 (defn- unseal
   "Retrieve a sealed Clojure data structure from a string"
-  [key #^String string]
+  [key ^String string]
   (let [[data mac] (.split string "--")
         data (codec/base64-decode data)]
     (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."))

@@ -12,7 +12,7 @@
   [app public-dir statics]
   (let [app-with-file (wrap-file app public-dir)]
     (fn [req]
-      (let [#^String uri (:uri req)]
+      (let [^String uri (:uri req)]
         (if (some #(.startsWith uri %) statics)
           (app-with-file req)
           (app req))))))

@@ -23,5 +23,5 @@
 
 (defn base64-decode
   "Decode a base64 encoded string into an array of bytes."
-  [#^String encoded]
+  [^String encoded]
   (Base64/decodeBase64 (.getBytes encoded)))

@@ -19,23 +19,23 @@
 
 (defn- safe-path?
   "Is a filepath safe for a particular root?"
-  [#^String root #^String path]
+  [^String root ^String path]
   (.startsWith (.getCanonicalPath (File. root path))
                (.getCanonicalPath (File. root))))
 
 (defn- find-index-file
   "Search the directory for an index file."
-  [#^File dir]
+  [^File dir]
   (first
     (filter
-      #(.startsWith (.toLowerCase (.getName #^File %)) "index.")
+      #(.startsWith (.toLowerCase (.getName ^File %)) "index.")
        (.listFiles dir))))
 
 (defn- get-file
   "Safely retrieve the correct file. See file-response for an
   explanation of options."
-  [#^String path opts]
-  (if-let [file (if-let [#^String root (:root opts)]
+  [^String path opts]
+  (if-let [file (if-let [^String root (:root opts)]
                   (and (safe-path? root path) (File. root path))
                   (File. path))]
     (cond

@@ -2,6 +2,6 @@
   "Utilities for testing Ring components."
   (:import (java.io ByteArrayInputStream)))
 
-(defn string-input-stream [#^String s]
+(defn string-input-stream [^String s]
   "Returns a ByteArrayInputStream for the given String."
   (ByteArrayInputStream. (.getBytes s)))

@@ -8,8 +8,8 @@
     (wrap-file (constantly :response) "not_here"))))
 
 (def public-dir "test/ring/assets")
-(def index-html (File. #^String public-dir "index.html"))
-(def foo-html   (File. #^String public-dir "foo.html"))
+(def index-html (File. ^String public-dir "index.html"))
+(def foo-html   (File. ^String public-dir "foo.html"))
 
 (def app (wrap-file (constantly :response) public-dir))
 

@@ -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})

@@ -1,7 +1,7 @@
-(defproject ring/ring-devel "0.2.6"
+(defproject ring/ring-devel "0.3.0-beta1"
   :description "Ring development and debugging libraries."
   :url "http://github.com/mmcgrana/ring"
-  :dependencies [[ring/ring-core "0.2.6"]
-                 [hiccup "0.2.6"]
-                 [clj-stacktrace "0.1.0"]]
+  :dependencies [[ring/ring-core "0.3.0-beta1"]
+                 [hiccup "0.3.0"]
+                 [clj-stacktrace "0.2.0"]]
   :dev-dependencies [[lein-clojars "0.6.0"]])

@@ -31,7 +31,7 @@
     ":server-name must be a String")
   (lint (:remote-addr req) string?
     ":remote-addr must be a String")
-  (lint (:uri req) #(and (string? %) (.startsWith #^String % "/"))
+  (lint (:uri req) #(and (string? %) (.startsWith ^String % "/"))
     ":uri must be a String starting with \"/\"")
   (lint (:query-string req) #(or (nil? %) (string? %))
     ":query-string must be nil or a non-blank String")
@@ -52,7 +52,7 @@
     (doseq [[hname hval] headers]
       (lint hname string?
          "header names must be Strings")
-      (lint hname #(= % (.toLowerCase #^String %))
+      (lint hname #(= % (.toLowerCase ^String %))
         "header names must be in lower case")
       (lint hval string?
         "header values must be strings")))

@@ -1,7 +1,7 @@
-(defproject ring/ring-httpcore-adapter "0.2.6"
+(defproject ring/ring-httpcore-adapter "0.3.0-beta1"
   :description "Ring HttpCore adapter."
   :url "http://github.com/mmcgrana/ring"
-  :dependencies [[ring/ring-core "0.2.6"]
+  :dependencies [[ring/ring-core "0.3.0-beta1"]
                  [org.apache.httpcomponents/httpcore "4.0.1"]
                  [org.apache.httpcomponents/httpcore-nio "4.0.1"]]
   :dev-dependencies [[lein-clojars "0.6.0"]])

@@ -26,28 +26,28 @@
              Executors Executor ThreadFactory))
   (:use [clojure.contrib.except :only (throwf)]))
 
-(defmacro #^{:private true} -?>
+(defmacro ^{:private true} -?>
  ([form] form)
  ([form next-form & forms]
    `(when-let [x# ~form] (-?> (-> x# ~next-form) ~@forms))))
 
-(defmacro #^{:private true} instance?-> [type x & forms]
+(defmacro ^{:private true} instance?-> [type x & forms]
   `(when (instance? ~type ~x) (-> ~(vary-meta x assoc :tag type) ~@forms)))
 
-(defn- charset [#^BasicHeader content-type-header]
+(defn- charset [^BasicHeader content-type-header]
   (-?> content-type-header .getElements
-    #^BasicHeaderElement first (.getParameterByName "charset") .getValue))
+    ^BasicHeaderElement first (.getParameterByName "charset") .getValue))
 
-(defn- lower-case [#^String s]
+(defn- lower-case [^String s]
   (.toLowerCase s java.util.Locale/ENGLISH))
 
 (defn- build-req-map
   "Augments the given request-prototype (a map) to represent the given HTTP
   request, to be passed as the Ring request to a handler."
-  [#^HttpRequest request request-prototype]
+  [^HttpRequest request request-prototype]
   (let [request-line (.getRequestLine request)
         headers (reduce
-                  (fn [header-map #^Header header]
+                  (fn [header-map ^Header header]
                     (assoc header-map
                       (-> header .getName lower-case)
                       (.getValue header)))
@@ -74,7 +74,7 @@
 (defn- apply-resp-map
   "Apply the given response map to the servlet response, therby completing
   the HTTP response."
-  [#^HttpResponse response {:keys [status headers body]}]
+  [^HttpResponse response {:keys [status headers body]}]
   ; Apply the status.
   (.setStatusCode response status)
   ; Apply the headers.
@@ -95,14 +95,14 @@
                (StringEntity. body)
              (seq? body)
                (EntityTemplate.
-                 (proxy [ContentProducer] []
-                   (writeTo [#^OutputStream s]
-                     (let [w (if charset
-                                (OutputStreamWriter. s #^String charset)
-                                (OutputStreamWriter. s))]
-                       (doseq [#^String chunk body]
-                         (.write w chunk))
-                       (.flush w)))))
+                 (reify ContentProducer 
+                        (writeTo [this ^OutputStream s]
+                                 (let [w (if charset
+                                           (OutputStreamWriter. s ^String charset)
+                                           (OutputStreamWriter. s))]
+                                   (doseq [^String chunk body]
+                                     (.write w chunk))
+                                   (.flush w)))))
              (instance? InputStream body)
                (InputStreamEntity. body
                  (let [l (or content-length -1)]
@@ -111,24 +111,24 @@
                (FileEntity. body content-type)
              :else
                (throwf "Unrecognized body: %s" body))]
-      (when-let [#^String type (headers "Content-Type")]
-        (.setContentType #^AbstractHttpEntity entity type))
+      (when-let [^String type (headers "Content-Type")]
+        (.setContentType ^AbstractHttpEntity entity type))
       (.setEntity response entity))))
 
 (defn- ring-handler
   "Returns an Handler implementation for the given Ring handler.
    The HttpContext must contains a map associated to \"ring.request-prototype\"."
   [handler]
-  (proxy [HttpRequestHandler] []
-    (handle [request response #^HttpContext context]
-      (let [req (build-req-map request
-                  (.getAttribute context "ring.request-prototype"))
-            resp (handler req)]
-        (apply-resp-map response resp)))))
+  (reify HttpRequestHandler 
+      (handle [this request response ^HttpContext context]
+        (let [req (build-req-map request
+                                 (.getAttribute context "ring.request-prototype"))
+              resp (handler req)]
+          (apply-resp-map response resp)))))
 
 (defn- handle-request
  "Handle the request, usually called from a worker thread."
- [#^HttpService httpservice #^HttpServerConnection conn request-prototype]
+ [^HttpService httpservice ^HttpServerConnection conn request-prototype]
   (let [context (doto (BasicHttpContext. nil)
                   (.setAttribute "ring.request-prototype" request-prototype))]
     (try
@@ -161,7 +161,7 @@
 
 (defn executor-execute
  "Executes (apply f args) using the specified Executor."
- [#^java.util.concurrent.Executor executor f & args]
+ [^java.util.concurrent.Executor executor f & args]
   (.execute executor #(apply f args)))
 
 (defn run-httpcore
@@ -176,10 +176,10 @@
  [handler {:keys [port server-name server-port execute]}]
   (let [execute (or execute (partial executor-execute
                               (Executors/newCachedThreadPool
-                                (proxy [ThreadFactory] []
-                                  (newThread [r]
-                                    (doto (Thread. #^Runnable r)
-                                      (.setDaemon true)))))))
+                                (reify ThreadFactory 
+                                       (newThread [this r]
+                                                  (doto (Thread. ^Runnable r)
+                                                    (.setDaemon true)))))))
         params (doto (BasicHttpParams.)
                  (.setIntParameter CoreConnectionPNames/SO_TIMEOUT 5000)
                  (.setIntParameter CoreConnectionPNames/SOCKET_BUFFER_SIZE (* 8 1024))

@@ -1,8 +1,8 @@
-(defproject ring/ring-jetty-adapter "0.2.6"
+(defproject ring/ring-jetty-adapter "0.3.0-beta1"
   :description "Ring Jetty adapter."
   :url "http://github.com/mmcgrana/ring"
-  :dependencies [[ring/ring-core "0.2.6"]
-                 [ring/ring-servlet "0.2.6"]
+  :dependencies [[ring/ring-core "0.3.0-beta1"]
+                 [ring/ring-servlet "0.3.0-beta1"]
                  [org.mortbay.jetty/jetty "6.1.14"]
                  [org.mortbay.jetty/jetty-util "6.1.14"]]
   :dev-dependencies [[lein-clojars "0.6.0"]])

@@ -8,20 +8,20 @@
   (:use (ring.util servlet)
         (clojure.contrib except)))
 
-(defn- proxy-handler
+(defn- reify-handler
   "Returns an Jetty Handler implementation for the given Ring handler."
   [handler]
-  (proxy [AbstractHandler] []
-    (handle [target #^Request request response dispatch]
-      (let [request-map  (build-request-map request)
-            response-map (handler request-map)]
-        (when response-map
-          (update-servlet-response response response-map)
-          (.setHandled request true))))))
+  (reify AbstractHandler 
+         (handle [this target ^Request request response dispatch]
+           (let [request-map  (build-request-map request)
+                 response-map (handler request-map)]
+             (when response-map
+               (update-servlet-response response response-map)
+               (.setHandled request true))))))
 
 (defn- add-ssl-connector!
   "Add an SslSocketConnector to a Jetty Server instance."
-  [#^Server server options]
+  [^Server server options]
   (let [ssl-connector (SslSocketConnector.)]
     (doto ssl-connector
       (.setPort        (options :ssl-port 443))
@@ -46,7 +46,7 @@
       (add-ssl-connector! server options))
     server))
 
-(defn #^Server run-jetty
+(defn ^Server run-jetty
   "Serve the given handler according to the options.
   Options:
     :configurator   - A function called with the Server instance.
@@ -60,12 +60,13 @@
     :truststore
     :trust-password"
   [handler options]
-  (let [#^Server s (create-server (dissoc options :configurator))]
+  (let [^Server s (create-server (dissoc options :configurator))]
     (when-let [configurator (:configurator options)]
       (configurator s))
     (doto s
-      (.setHandler (proxy-handler handler))
+      (.setHandler (reify-handler handler))
       (.start))
     (when (:join? options true)
       (.join s))
     s))
+

@@ -1,6 +1,7 @@
-(defproject ring/ring-servlet "0.2.6"
+(defproject ring/ring-servlet "0.3.0-beta1"
   :description "Ring servlet utilities."
   :url "http://github.com/mmcgrana/ring"
-  :dependencies [[ring/ring-core "0.2.6"]
+  :dependencies [[ring/ring-core "0.3.0-beta1"]
                  [javax.servlet/servlet-api "2.5"]]
-  :dev-dependencies [[lein-clojars "0.6.0"]])
+  :dev-dependencies [[lein-clojars "0.6.0"]
+                     [swank-clojure "1.2.1"]])

@@ -9,9 +9,9 @@
 
 (defn- get-headers
   "Creates a name/value map of all the request headers."
-  [#^HttpServletRequest request]
+  [^HttpServletRequest request]
   (reduce
-    (fn [headers, #^String name]
+    (fn [headers, ^String name]
       (assoc headers
         (.toLowerCase name)
         (.getHeader request name)))
@@ -20,13 +20,13 @@
 
 (defn- get-content-length
   "Returns the content length, or nil if there is no content."
-  [#^HttpServletRequest request]
+  [^HttpServletRequest request]
   (let [length (.getContentLength request)]
     (if (>= length 0) length)))
 
 (defn build-request-map
   "Create the request map from the HttpServletRequest object."
-  [#^HttpServletRequest request]
+  [^HttpServletRequest request]
   {:server-port        (.getServerPort request)
    :server-name        (.getServerName request)
    :remote-addr        (.getRemoteAddr request)
@@ -44,9 +44,9 @@
   "Associate servlet-specific keys with the request map for use with legacy
   systems."
   [request-map
-   #^HttpServlet servlet
-   #^HttpServletRequest request
-   #^HttpServletResponse response]
+   ^HttpServlet servlet
+   ^HttpServletRequest request
+   ^HttpServletResponse response]
   (merge request-map
     {:servlet          servlet
      :servlet-request  request
@@ -55,7 +55,7 @@
 
 (defn- set-headers
   "Update a HttpServletResponse with a map of headers."
-  [#^HttpServletResponse response, headers]
+  [^HttpServletResponse response, headers]
   (doseq [[key val-or-vals] headers]
     (if (string? val-or-vals)
       (.setHeader response key val-or-vals)
@@ -67,7 +67,7 @@
 
 (defn- set-body
   "Update a HttpServletResponse body with a String, ISeq, File or InputStream."
-  [#^HttpServletResponse response, body]
+  [^HttpServletResponse response, body]
   (cond
     (string? body)
       (with-open [writer (.getWriter response)]
@@ -78,13 +78,13 @@
           (.print writer (str chunk))
           (.flush writer)))
     (instance? InputStream body)
-    (let [#^InputStream b body]
+    (let [^InputStream b body]
       (with-open [out (.getOutputStream response)]
         (copy b out)
         (.close b)
         (.flush out)))
     (instance? File body)
-    (let [#^File f body]
+    (let [^File f body]
       (with-open [stream (FileInputStream. f)]
         (set-body response stream)))
     (nil? body)
@@ -94,7 +94,7 @@
 
 (defn update-servlet-response
   "Update the HttpServletResponse using a response map."
-  [#^HttpServletResponse response, {:keys [status headers body]}]
+  [^HttpServletResponse response, {:keys [status headers body]}]
   (when-not response
     (throw (Exception. "Null response given.")))
   (when status
@@ -107,9 +107,9 @@
   "Turns a handler into a function that takes the same arguments and has the
   same return value as the service method in the HttpServlet class."
   [handler]
-  (fn [#^HttpServlet servlet
-       #^HttpServletRequest request
-       #^HttpServletResponse response]
+  (fn [^HttpServlet servlet
+       ^HttpServletRequest request
+       ^HttpServletResponse response]
     (.setCharacterEncoding response "UTF-8")
     (let [request-map (-> request
                         (build-request-map)