Add a few type hints to avoid reflection

@@ -7,3 +7,5 @@ pom.xml
 autodoc
 .lein-failures
 doc
+.lein-deps-sum
+.lein-env

@@ -1,3 +1,20 @@
+## 1.1.0 (2012-04-23)
+
+* Support for SSL client certificates in Jetty adapter
+* Jetty adapter dependency upgraded to 7.6.1
+* wrap-cookies support for Joda-Time objects in expires and max-age attributes
+* Added wrap-head middleware
+* wrap-file middleware has option to follow symlinks
+* Added form-encode and form-decode to ring.util.codec
+* Fixed url-encode and url-decode to handle "+" correctly
+* Added ring.util.io namespace
+* Deprecated ring.util.test namespace
+* Hiccup ring-devel dependency upgraded to 1.0.0
+* Added more functions to ring.util.response
+* Default number of Jetty adapter threads is now 50
+* Support for KeyStore instances in Jetty adapter
+* Jetty configurator option now always applied last
+
 ## 1.0.2 (2012-01-25)
 
 * Updated clj-stacktrace to 0.2.4 to fix swank-clojure issue

@@ -1,119 +1,5 @@
-# Ring
+## Ring has moved to: <https://github.com/ring-clojure/ring>
 
-Ring is a Clojure web applications library inspired by Python's WSGI and Ruby's Rack. By abstracting the details of HTTP into a simple, unified API, Ring allows web applications to be constructed of modular components that can be shared among a variety of applications, web servers, and web frameworks.
-
-The `SPEC` file at the root of this distribution for provides a complete description of the Ring interface.
-
-## Synopsis
-
-"Hello World" in Ring:
-
-    (use 'ring.adapter.jetty)
-
-    (defn app [req]
-      {:status  200
-       :headers {"Content-Type" "text/html"}
-       :body    "Hello World from Ring"})
-
-    (run-jetty app {:port 8080})
-
-Adding simple middleware:
-
-    (defn wrap-upcase [app]
-      (fn [req]
-        (let [orig-resp (app req)]
-          (assoc orig-resp :body (.toUpperCase (:body orig-resp))))))
-
-    (def upcase-app (wrap-upcase app))
-
-    (run-jetty upcase-app {:port 8080})
-
-## Quick Start
-
-To see some working examples, first pull in Ring's dependencies using [Leiningen](http://github.com/technomancy/leiningen):
-
-    $ lein deps
-
-To see a live "Hello World" Ring app, run:
-
-    $ java -cp "lib/*" clojure.main example/hello_world.clj
-
-Now visit `http://localhost:8080/` in your browser; the Ring app will respond to your request with a simple HTML page indicating the time of day.
-
-To see a more sophisticated Ring app, run:
-
-    $ java -cp "lib/*" clojure.main example/wrapping.clj
-
-* If you request `http://localhost:8080/` in your browser the `ring.handler.dump` handler will respond with an HTML page representing the request map that it received (see the `SPEC` for details on the request map).
-* If you request `http://localhost:8080/clojure.png`, the `ring.middleware.file` middleware will detect that there is a `clojure.png` file in the app's `public` directory and return that image as a response.
-* If you request `http://localhost:8080/error`, the app will produce an error that will be caught by the `ring.middleware.stacktrace` middleware, which will in turn return a readable stacktrace as the HTML response.
-
-
-## Documentation
-
-* [Ring namespace and function docs](http://mmcgrana.github.com/ring/)
-
-## Available Libraries
-
-### ring-core
-
-* `ring.middleware.file`: Serve static files out of a public directory.
-* `ring.middleware.resource`: Serve static classpath resources.
-* `ring.middleware.file-info`: Augment response headers with info about File responses.
-* `ring.middleware.content-type`: Augment response headers with a content-type based on the file extension.
-* `ring.middleware.params`: Parse query and form params.
-* `ring.middleware.multipart-params`: Parse multipart params.
-* `ring.middleware.keyword-params`: Convert string param keys to keywords.
-* `ring.middleware.nested-params`: Convert a flat map of parameters into a nested map of parameters.
-* `ring.middleware.cookies`: Manage browser cookies.
-* `ring.middleware.session`: Manage user sessions. Memory and cookie session stores are available by default.
-* `ring.middleware.flash`: Adds flash message support to sessions.
-* `ring.util.response`: Generate Ring responses.
-* `ring.util.codec`: Encode and decode string data.
-* `ring.util.mime-type`: Guess the mime-type from a file extension.
-
-### ring-devel
-
-* `ring.handler.dump`: Dumps request maps as HTML responses for debugging.
-* `ring.middleware.lint`: Lint requests and responses to ensure compliance with the Ring spec.
-* `ring.middleware.reload`: Automatically reload modified namespaces before each request.
-* `ring.middleware.stacktrace`: Catch exceptions and displays readable stacktraces for debugging.
-
-### ring-servlet
-
-* `ring.util.servlet`: Utilities for interfacing with Java Servlets.
-
-###  ring-jetty-adapter
-
-* `ring.adapter.jetty`: Adapter for the Jetty webserver.
-
-## Leiningen Usage
-
-To include one of the above libraries in your Leiningen project, for example `ring-core`, add the following to your `:dependencies`:
-
-    [ring/ring-core "1.0.2"]
-
-To include all of them, add:
-
-    [ring "1.0.2"]
-
-## Development
-
-Ring is being actively developed; you can track its progress on the [GitHub page](http://github.com/mmcgrana/ring) page and on the [Google Group](http://groups.google.com/group/ring-clojure).
-
-To submit a patch, please post your corresponding GitHub branch to the Ring Google Group. This allows your changes to be seen and discussed by all Ring developers. If you are attempting something substantial, consider posting to the Google Group first with your idea.
-
-To run the Ring unit tests, first navigate to the appropriate project and then:
-
-    $ lein deps
-    $ lein test
-
-## Thanks
-
-This project borrows heavily from Ruby's Rack and Python's WSGI; thanks to those communities for their work.
-
-## License
-
-Copyright (c) 2009-2011 Mark McGranaghan and released under an MIT license.
-
-Clojure logo by Tom Hickey.
+Ring has been moved to dedicated GitHub organization. This repository
+will no longer be updated, so please update your bookmarks and
+GitHub watches.

@@ -1,4 +1,4 @@
-=== Ring Spec (1.0)
+=== Ring Spec (1.1)
 Ring is defined in terms of handlers, middleware, adapters, requests maps, and 
 response maps, each of which are described below.
 
@@ -76,6 +76,10 @@ corresponding values:
   (Optional, String)
   The name of the character encoding used in the request body, if known.
 
+:ssl-client-cert
+  (Optional, X509Certificate)
+  The SSL client certificate, if supplied.
+
 :headers
   (Required, IPersistentMap)
   A Clojure map of downcased header name Strings to corresponding header value 

@@ -1,16 +0,0 @@
-; A very simple Ring application.
-
-(ns ring.example.hello-world
-  (:use ring.adapter.jetty)
-  (:import java.util.Date java.text.SimpleDateFormat))
-
-(defn app
-  [req]
-  {:status  200
-   :headers {"Content-Type" "text/html"}
-   :body    (str "<h3>Hello World from Ring</h3>"
-                 "<p>The current time is "
-                 (.format (SimpleDateFormat. "HH:mm:ss") (Date.))
-                 ".</p>")})
-
-(run-jetty app {:port 8080})

@@ -1,21 +0,0 @@
-; An example of inserting the linter between each component to ensure 
-; compliance to the Ring spec.
-
-(ns ring.example.linted
-  (:use (ring.handler dump)
-        (ring.middleware stacktrace file file-info reload lint)
-        (ring.adapter jetty)))
-
-(def app
-  (-> handle-dump
-    wrap-lint
-    wrap-stacktrace
-    wrap-lint
-    wrap-file-info
-    wrap-lint
-    (wrap-file "example/public")
-    wrap-lint
-    (wrap-reload '(ring.handler.dump))
-    wrap-lint))
-
-(run-jetty app {:port 8080})

@@ -1,23 +0,0 @@
-; A example of modular construction of Ring apps.
-
-(ns ring.example.wrapping
-  (:use ring.handler.dump
-        ring.middleware.stacktrace
-        ring.middleware.file-info
-        ring.middleware.file
-        ring.adapter.jetty))
-
-(defn wrap-error [app]
-  (fn [req]
-    (if (= "/error" (:uri req))
-      (throw (Exception. "Demonstrating ring.middleware.stacktrace"))
-      (app req))))
-
-(def app
-  (-> handle-dump
-    wrap-error
-    (wrap-file "example/public")
-    wrap-file-info
-    wrap-stacktrace))
-
-(run-jetty app {:port 8080})

@@ -1,14 +1,14 @@
-(defproject ring "1.0.2"
+(defproject ring "1.1.0"
   :description "A Clojure web applications library."
   :url "http://github.com/mmcgrana/ring"
   :dependencies
-    [[ring/ring-core "1.0.2"]
-     [ring/ring-devel "1.0.2"]
-     [ring/ring-jetty-adapter "1.0.2"]
-     [ring/ring-servlet "1.0.2"]]
-  :dev-dependencies
-    [[lein-sub "0.1.1"]
-     [codox "0.3.0"]]
+    [[ring/ring-core "1.1.0"]
+     [ring/ring-devel "1.1.0"]
+     [ring/ring-jetty-adapter "1.1.0"]
+     [ring/ring-servlet "1.1.0"]]
+  :plugins
+    [[lein-sub "0.2.0"]
+     [codox "0.6.1"]]
   :sub
     ["ring-core"
      "ring-devel"

@@ -1,9 +1,11 @@
-(defproject ring/ring-core "1.0.2"
+(defproject ring/ring-core "1.1.0"
   :description "Ring core libraries."
   :url "http://github.com/mmcgrana/ring"
   :dependencies [[org.clojure/clojure "1.2.1"]
-                 [commons-codec "1.4"]
-                 [commons-io "1.4"]
+                 [commons-codec "1.6"]
+                 [commons-io "2.1"]
                  [commons-fileupload "1.2.1"]
-                 [javax.servlet/servlet-api "2.5"]]
-  :dev-dependencies [[org.clojure/clojure-contrib "1.2.0"]])
+                 [javax.servlet/servlet-api "2.5"]
+                 [clj-time "0.3.7"]]
+  :profiles
+  {:dev {:dependencies [[org.clojure/clojure-contrib "1.2.0"]]}})

@@ -1,6 +1,9 @@
 (ns ring.middleware.cookies
   "Cookie manipulation."
-  (:require [ring.util.codec :as codec]))
+  (:require [ring.util.codec :as codec])
+  (:use [clj-time.core :only (in-secs)]
+        [clj-time.format :only (formatters unparse)])
+  (:import (org.joda.time Interval DateTime)))
 
 (def ^{:private true
        :doc "HTTP token: 1*<any CHAR except CTLs or tspecials>. See RFC2068"}
@@ -45,11 +48,12 @@
 (defn- normalize-quoted-strs
   "Turn quoted strings into normal Clojure strings using read-string."
   [cookies]
-  (for [[name value] cookies]
-    (let [value (codec/url-decode value)]
-      (if (.startsWith ^String value "\"")
-        [name (read-string value)]
-        [name value]))))
+  (remove nil?
+    (for [[name value] cookies]
+      (if-let [value (codec/form-decode-str value)]
+        (if (.startsWith ^String value "\"")
+          [name (read-string value)]
+          [name value])))))
 
 (defn- get-cookie
   "Get a single cookie from a sequence of cookie-values"
@@ -84,13 +88,17 @@
 (defn- write-value
   "Write the main cookie value."
   [key value]
-  (str (name key) "=" (codec/url-encode value)))
+  (codec/form-encode {key value}))
 
 (defn- valid-attr?
   "Is the attribute valid?"
   [[key value]]
   (and (contains? set-cookie-attrs key)
-       (not (.contains (str value) ";"))))
+       (not (.contains (str value) ";"))
+       (case key
+         :max-age (or (instance? Interval value) (integer? value))
+         :expires (or (instance? DateTime value) (string? value))
+         true)))
 
 (defn- write-attr-map
   "Write a map of cookie attributes to a string."
@@ -99,9 +107,11 @@
   (for [[key value] attrs]
     (let [attr-name (name (set-cookie-attrs key))]
       (cond
-        (true? value)  (str ";" attr-name)
-        (false? value) ""
-        :else          (str ";" attr-name "=" value)))))
+       (instance? Interval value) (str ";" attr-name "=" (in-secs value))
+       (instance? DateTime value) (str ";" attr-name "=" (unparse (formatters :rfc822) value))
+       (true? value)  (str ";" attr-name)
+       (false? value) ""
+       :else (str ";" attr-name "=" value)))))
 
 (defn- write-cookies
   "Turn a map of cookies into a seq of strings for a Set-Cookie header."

@@ -20,7 +20,7 @@
   to the ring.util.response/file-response function."
   [app ^String root-path & [opts]]
   (ensure-dir root-path)
-  (let [opts (merge {:root root-path, :index-files? true} opts)]
+  (let [opts (merge {:root root-path, :index-files? true, :allow-symlinks? false} opts)]
     (fn [req]
       (if-not (= :get (:request-method req))
         (app req)

@@ -0,0 +1,14 @@
+(ns ring.middleware.head
+  "Middleware to simplify replying to HEAD requests.")
+
+(defn wrap-head
+  "Middleware that turns any HEAD request into a GET, and then sets the response
+  body to nil."
+  [handler]
+  (fn [request]
+    (if (= :head (:request-method request))
+      (-> request
+          (assoc :request-method :get)
+          (handler)
+          (assoc :body nil))
+      (handler request))))

@@ -1,6 +1,6 @@
 (ns ring.middleware.multipart-params
   "Parse multipart upload into params."
-  (:use [ring.middleware.params :only (assoc-param)])
+  (:use [ring.util.data :only (assoc-conj)])
   (:import [org.apache.commons.fileupload.util Streams]
            [org.apache.commons.fileupload
              RequestContext
@@ -54,7 +54,7 @@
   (->> (request-context request encoding)
        (file-item-seq)
        (map #(parse-file-item % store))
-       (reduce (fn [m [k v]] (assoc-param m k v)) {})))
+       (reduce (fn [m [k v]] (assoc-conj m k v)) {})))
 
 (defn- load-var
   "Returns the var named by the supplied symbol, or nil if not found. Attempts

@@ -1,31 +1,10 @@
 (ns ring.middleware.params
   "Parse form and query params."
-  (:require [ring.util.codec :as codec]
-            [clojure.string :as string]))
+  (:require [ring.util.codec :as codec]))
 
-(defn assoc-param
-  "Associate a key with a value. If the key already exists in the map,
-  create a vector of values."
-  [map key val]
-  (assoc map key
-    (if-let [cur (map key)]
-      (if (vector? cur)
-        (conj cur val)
-        [cur val])
-      val)))
-
-(defn- parse-params
-  "Parse parameters from a string into a map."
-  [^String param-string encoding]
-  (reduce
-    (fn [param-map encoded-param]
-      (if-let [[_ key val] (re-matches #"([^=]+)=(.*)" encoded-param)]
-        (assoc-param param-map
-          (codec/url-decode key encoding)
-          (codec/url-decode (or val "") encoding))
-         param-map))
-    {}
-    (string/split param-string #"&")))
+(defn- parse-params [params encoding]
+  (let [params (codec/form-decode params encoding)]
+    (if (map? params) params {})))
 
 (defn- assoc-query-params
   "Parse and assoc parameters from the query string with the request."

@@ -77,14 +77,11 @@
   (let [data (encrypt key (.getBytes (pr-str data)))]
     (str (codec/base64-encode data) "--" (hmac key data))))
 
-(defn- secure-compare [a b]
+(defn- secure-compare [^String a ^String b]
   (if (and a b (= (.length a) (.length b)))
-      (= 0
-         (reduce bit-or
-                 (map bit-xor
-                      (.getBytes a)
-                      (.getBytes b))))
-      false))
+    (zero? (reduce bit-or
+                   (map bit-xor (.getBytes a) (.getBytes b))))
+    false))
 
 (defn- unseal
   "Retrieve a sealed Clojure data structure from a string"

@@ -1,22 +1,54 @@
 (ns ring.util.codec
   "Encoding and decoding utilities."
+  (:use ring.util.data)
+  (:require [clojure.string :as str])
   (:import java.io.File
+           java.util.Map
            (java.net URLEncoder URLDecoder)
            org.apache.commons.codec.binary.Base64))
 
+(defn- double-escape [^String x]
+  (.replace x "\\" "\\\\"))
+
+(defn percent-encode
+  "Percent-encode every character in the given string using either the specified
+  encoding, or UTF-8 by default."
+  [unencoded & [encoding]]
+  (->> (.getBytes unencoded (or encoding "UTF-8"))
+       (map (partial format "%%%02X"))
+       (str/join)))
+
+(defn- parse-bytes [encoded-bytes]
+  (->> (re-seq #"%.." encoded-bytes)
+       (map #(subs % 1))
+       (map #(.byteValue (Integer/parseInt % 16)))
+       (byte-array)))
+
+(defn percent-decode
+  "Decode every percent-encoded character in the given string using the
+  specified encoding, or UTF-8 by default."
+  [encoded & [encoding]]
+  (str/replace encoded
+               #"(?:%..)+"
+               (fn [chars]
+                 (-> (parse-bytes chars)
+                     (String. (or encoding "UTF-8"))
+                     (double-escape)))))
+
 (defn url-encode
-  "Returns the form-url-encoded version of the given string, using either a
-  specified encoding or UTF-8 by default."
+  "Returns the url-encoded version of the given string, using either a specified
+  encoding or UTF-8 by default."
   [unencoded & [encoding]]
-  (URLEncoder/encode unencoded (or encoding "UTF-8")))
+  (str/replace
+    unencoded
+    #"[^A-Za-z0-9_~.+-]+"
+    #(double-escape (percent-encode % encoding))))
 
 (defn url-decode
-  "Returns the form-url-decoded version of the given string, using either a
-  specified encoding or UTF-8 by default."
+  "Returns the url-decoded version of the given string, using either a specified
+  encoding or UTF-8 by default. If the encoding is invalid, nil is returned."
   [encoded & [encoding]]
-  (try
-    (URLDecoder/decode encoded (or encoding "UTF-8"))
-    (catch Exception e nil)))
+  (percent-decode encoded encoding))
 
 (defn base64-encode
   "Encode an array of bytes into a base64 encoded string."
@@ -27,3 +59,55 @@
   "Decode a base64 encoded string into an array of bytes."
   [^String encoded]
   (Base64/decodeBase64 (.getBytes encoded)))
+
+(defprotocol FormEncodeable
+  (form-encode* [x encoding]))
+
+(extend-protocol FormEncodeable
+  String
+  (form-encode* [unencoded encoding]
+    (URLEncoder/encode unencoded encoding))
+  Map
+  (form-encode* [params encoding]
+    (letfn [(encode [x] (form-encode* x encoding))
+            (encode-param [[k v]] (str (encode (name k)) "=" (encode v)))]
+      (->> params
+           (mapcat
+            (fn [[k v]]
+              (if (or (seq? v) (sequential? v) )
+                (map #(encode-param [k %]) v)
+                [(encode-param [k v])])))
+           (str/join "&"))))
+  Object
+  (form-encode* [x encoding]
+    (form-encode* (str x) encoding)))
+
+(defn form-encode
+  "Encode the supplied value into www-form-urlencoded format, often used in
+  URL query strings and POST request bodies, using the specified encoding.
+  If the encoding is not specified, it defaults to UTF-8"
+  [x & [encoding]]
+  (form-encode* x (or encoding "UTF-8")))
+
+(defn form-decode-str
+  "Decode the supplied www-form-urlencoded string using the specified encoding,
+  or UTF-8 by default."
+  [^String encoded & [encoding]]
+  (try
+    (URLDecoder/decode encoded (or encoding "UTF-8"))
+    (catch Exception _ nil)))
+
+(defn form-decode
+  "Decode the supplied www-form-urlencoded string using the specified encoding,
+  or UTF-8 by default. If the encoded value is a string, a string is returned.
+  If the encoded value is a map of parameters, a map is returned."
+  [encoded & [encoding]]
+  (if-not (.contains encoded "=")
+    (form-decode-str encoded encoding)
+    (reduce
+     (fn [m param]
+       (if-let [[k v] (str/split param #"=" 2)]
+         (assoc-conj m (form-decode-str k encoding) (form-decode-str v encoding))
+         m))
+     {}
+     (str/split encoded #"&"))))

@@ -0,0 +1,13 @@
+(ns ring.util.data
+  "Miscellaneous functions for manipulating data structures.")
+
+(defn assoc-conj
+  "Associate a key with a value in a map. If the key already exists in the map,
+  a vector of values is associated with the key."
+  [map key val]
+  (assoc map key
+    (if-let [cur (get map key)]
+      (if (vector? cur)
+        (conj cur val)
+        [cur val])
+      val)))

@@ -0,0 +1,31 @@
+(ns ring.util.io
+  "Utility functions for I/O in Ring."
+  (:require [clojure.java.io :as io])
+  (:import [java.io PipedInputStream
+                    PipedOutputStream
+                    ByteArrayInputStream]))
+
+(defn piped-input-stream
+  "Create an input stream from a function that takes an output stream as its
+  argument. The function will be executed in a separate thread. The stream
+  will be automatically closed after the function finishes.
+
+  e.g. (piped-input-stream
+        (fn [ostream]
+          (spit ostream \"Hello\")))"
+  [func]
+  (let [input  (PipedInputStream.)
+        output (PipedOutputStream.)]
+    (.connect input output)
+    (future
+      (try
+        (func output)
+        (finally (.close output))))
+    input))
+
+(defn string-input-stream
+  "Returns a ByteArrayInputStream for the given String."
+  ([^String s]
+     (ByteArrayInputStream. (.getBytes s)))
+  ([^String s encoding]
+     (ByteArrayInputStream. (.getBytes s encoding))))

@@ -18,6 +18,13 @@
    :headers {"Location" url}
    :body    ""})
 
+(defn not-found
+  "Returns a 404 'not found' response."
+  [body]
+  {:status  404
+   :headers {}
+   :body    body})
+
 (defn response
   "Returns a skeletal Ring response with the given body, status of 200, and no
   headers."
@@ -32,6 +39,13 @@
   (.startsWith (.getCanonicalPath (File. root path))
                (.getCanonicalPath (File. root))))
 
+(defn- directory-transversal?
+  "Check if a path contains '..'."
+  [^String path]
+  (-> (str/split path #"/|\\")
+      (set)
+      (contains? "..")))
+
 (defn- find-index-file
   "Search the directory for an index file."
   [^File dir]
@@ -45,7 +59,9 @@
   explanation of options."
   [^String path opts]
   (if-let [^File file (if-let [^String root (:root opts)]
-                  (and (safe-path? root path) (File. root path))
+                        (if (or (safe-path? root path) 
+                                (and (:allow-symlinks? opts) (not (directory-transversal? path))))
+                          (File. root path))
                   (File. path))]
     (cond
       (.isDirectory file)
@@ -57,8 +73,9 @@
   "Returns a Ring response to serve a static file, or nil if an appropriate
   file does not exist.
   Options:
-    :root         - take the filepath relative to this root path
-    :index-files? - look for index.* files in directories, defaults to true"
+    :root            - take the filepath relative to this root path
+    :index-files?    - look for index.* files in directories, defaults to true
+    :allow-symlinks? - serve files through symbolic links, defaults to false"
   [filepath & [opts]]
   (if-let [file (get-file filepath opts)]
     (response file)))
@@ -115,3 +132,26 @@
   to the given content-type."
   [resp content-type]
   (header resp "Content-Type" content-type))
+
+(defn charset
+  "Returns an updated Ring response with the supplied charset added to the
+  Content-Type header."
+  [resp charset]
+  (update-in resp [:headers "Content-Type"]
+    (fn [content-type]
+      (-> (or content-type "text/plain")
+          (str/replace #";\s*charset=[^;]*" "")
+          (str "; charset=" charset)))))
+
+(defn set-cookie
+  "Sets a cookie on the response. Requires the handler to be wrapped in the
+  wrap-cookies middleware."
+  [resp name value & [opts]]
+  (assoc-in resp [:cookies name] (merge {:value value} opts)))
+
+(defn response?
+  "True if the supplied value is a valid response map."
+  [resp]
+  (and (map? resp)
+       (integer? (:status resp))
+       (map? (:headers resp))))

@@ -1,10 +1,8 @@
 (ns ring.util.test
   "Utilities for testing Ring components."
-  (:import java.io.ByteArrayInputStream))
+  (:require [ring.util.io :as io]))
 
-(defn string-input-stream
-  "Returns a ByteArrayInputStream for the given String."
-  ([^String s]
-     (ByteArrayInputStream. (.getBytes s)))
-  ([^String s encoding]
-     (ByteArrayInputStream. (.getBytes s encoding))))
+(def ^{:doc "Returns a ByteArrayInputStream for the given String."
+       :deprecated "1.1"}
+  string-input-stream
+  io/string-input-stream)

@@ -0,0 +1 @@
+../

@@ -1,6 +1,6 @@
 (ns ring.middleware.multipart-params.test.byte-array
   (:use clojure.test
-        ring.util.test
+        [ring.util.io :only (string-input-stream)]
         ring.middleware.multipart-params.byte-array))
 
 (deftest test-byte-array-store

@@ -1,6 +1,6 @@
 (ns ring.middleware.multipart-params.test.temp-file
   (:use clojure.test
-        ring.util.test
+        [ring.util.io :only (string-input-stream)]
         ring.middleware.multipart-params.temp-file))
 
 (deftest test-temp-file-store

@@ -1,6 +1,7 @@
 (ns ring.middleware.test.cookies
   (:use clojure.test
-        ring.middleware.cookies))
+        ring.middleware.cookies
+        [clj-time.core :only (interval date-time)]))
 
 (deftest wrap-cookies-basic-cookie
   (let [req  {:headers {"cookie" "a=b"}}
@@ -72,6 +73,11 @@
     (is (= {"Set-Cookie" (list "a=hello+world")}
            (:headers resp)))))
 
+(deftest wrap-cookies-invalid-url-encoded
+  (let [req  {:headers {"cookie" "a=%D"}}
+        resp ((wrap-cookies :cookies) req)]
+    (is (= {} resp))))
+
 (deftest wrap-cookies-keep-set-cookies-intact
   (let [handler (constantly {:headers {"Set-Cookie" (list "a=b")}
                              :cookies {:c "d"}})
@@ -83,3 +89,57 @@
   (let [response {:cookies {"a" {:value "foo" :invalid true}}}
         handler  (wrap-cookies (constantly response))]
     (is (thrown? AssertionError (handler {})))))
+
+(deftest wrap-cookies-accepts-max-age
+  (let [cookies {"a" {:value "b", :path "/",
+                      :secure true, :http-only true,
+                      :max-age 123}}
+        handler (constantly {:cookies cookies})
+        resp    ((wrap-cookies handler) {})]
+    (is (= {"Set-Cookie" (list "a=b;Path=/;Secure;HttpOnly;Max-Age=123")}
+           (:headers resp)))))
+
+(deftest wrap-cookies-accepts-expires
+  (let [cookies {"a" {:value "b", :path "/",
+                      :secure true, :http-only true,
+                      :expires "123"}}
+        handler (constantly {:cookies cookies})
+        resp    ((wrap-cookies handler) {})]
+    (is (= {"Set-Cookie" (list "a=b;Path=/;Secure;HttpOnly;Expires=123")}
+           (:headers resp)))))
+
+(deftest wrap-cookies-accepts-max-age-from-clj-time
+  (let [cookies {"a" {:value "b", :path "/",
+                      :secure true, :http-only true,
+                      :max-age (interval (date-time 2012)
+                                         (date-time 2015))}}
+        handler (constantly {:cookies cookies})
+        resp    ((wrap-cookies handler) {})
+        max-age 94694400]
+    (is (= {"Set-Cookie" (list (str "a=b;Path=/;Secure;HttpOnly;Max-Age=" max-age))}
+           (:headers resp)))))
+
+(deftest wrap-cookies-accepts-expires-from-clj-time
+  (let [cookies {"a" {:value "b", :path "/",
+                      :secure true, :http-only true,
+                      :expires (date-time 2015 12 31)}}
+        handler (constantly {:cookies cookies})
+        resp    ((wrap-cookies handler) {})
+        expires "Thu, 31 Dec 2015 00:00:00 +0000"]
+    (is (= {"Set-Cookie" (list (str "a=b;Path=/;Secure;HttpOnly;Expires=" expires))}
+           (:headers resp)))))
+
+(deftest wrap-cookies-throws-exception-when-not-using-intervals-correctly
+  (let [cookies {"a" {:value "b", :path "/",
+                      :secure true, :http-only true,
+                      :expires (interval (date-time 2012)
+                                         (date-time 2015))}}
+        handler (constantly {:cookies cookies})]
+    (is (thrown? AssertionError ((wrap-cookies handler) {})))))
+
+(deftest wrap-cookies-throws-exception-when-not-using-datetime-correctly
+  (let [cookies {"a" {:value "b", :path "/",
+                      :secure true, :http-only true,
+                      :max-age (date-time 2015 12 31)}}
+        handler (constantly {:cookies cookies})]
+    (is (thrown? AssertionError ((wrap-cookies handler) {})))))

@@ -0,0 +1,16 @@
+(ns ring.middleware.test.head
+  (:use clojure.test
+        ring.middleware.head))
+
+(defn- handler [req]
+  {:status 200
+   :headers {"X-method" (name (:request-method req))}
+   :body "Foobar"})
+
+(deftest test-wrap-head
+  (let [resp ((wrap-head handler) {:request-method :head})]
+    (is (nil? (:body resp)))
+    (is (= "get" (get-in resp [:headers "X-method"]))))
+  (let [resp ((wrap-head handler) {:request-method :post})]
+    (is (= (:body resp) "Foobar"))
+    (is (= "post" (get-in resp [:headers "X-method"])))))

@@ -1,7 +1,7 @@
 (ns ring.middleware.test.multipart-params
   (:use clojure.test
         ring.middleware.multipart-params
-        ring.util.test)
+        [ring.util.io :only (string-input-stream)])
   (:import java.io.InputStream))
 
 (defn string-store [item]

@@ -1,7 +1,7 @@
 (ns ring.middleware.test.params
   (:use clojure.test
-        ring.middleware.params)
-  (:require [ring.util.test :as tu]))
+        ring.middleware.params
+        [ring.util.io :only (string-input-stream)]))
 
 (def wrapped-echo (wrap-params identity))
 
@@ -15,23 +15,23 @@
 (deftest wrap-params-query-and-form-params
   (let [req  {:query-string "foo=bar"
               :content-type "application/x-www-form-urlencoded"
-              :body         (tu/string-input-stream "biz=bat%25")}
+              :body         (string-input-stream "biz=bat%25")}
         resp (wrapped-echo req)]
     (is (= {"foo" "bar"}  (:query-params resp)))
     (is (= {"biz" "bat%"} (:form-params resp)))
     (is (= {"foo" "bar" "biz" "bat%"} (:params resp)))))
 
 (deftest wrap-params-not-form-encoded
   (let [req  {:content-type "application/json"
-              :body         (tu/string-input-stream "{foo: \"bar\"}")}
+              :body         (string-input-stream "{foo: \"bar\"}")}
         resp (wrapped-echo req)]
     (is (empty? (:form-params resp)))
     (is (empty? (:params resp)))))
 
 (deftest wrap-params-always-assocs-maps
   (let [req  {:query-string ""
               :content-type "application/x-www-form-urlencoded"
-              :body         (tu/string-input-stream "")}
+              :body         (string-input-stream "")}
         resp (wrapped-echo req)]
     (is (= {} (:query-params resp)))
     (is (= {} (:form-params resp)))
@@ -40,7 +40,7 @@
 (deftest wrap-params-encoding
   (let [req  {:character-encoding "UTF-16"
               :content-type "application/x-www-form-urlencoded"
-              :body (tu/string-input-stream "hello=world" "UTF-16")}
+              :body (string-input-stream "hello=world" "UTF-16")}
         resp (wrapped-echo req)]
     (is (= (:params resp) {"hello" "world"}))
     (is (= (:form-params resp) {"hello" "world"}))))

@@ -1,6 +1,6 @@
 (ns ring.middleware.test.resource
   (:use clojure.test
-        ring.util.test
+        [ring.util.io :only (string-input-stream)]
         ring.middleware.resource))
 
 (defn test-handler [request]

@@ -3,17 +3,58 @@
         ring.util.codec)
   (:import java.util.Arrays))
 
+(deftest test-percent-encode
+  (is (= (percent-encode " ") "%20"))
+  (is (= (percent-encode "+") "%2B"))
+  (is (= (percent-encode "foo") "%66%6F%6F")))
+
+(deftest test-percent-decode
+  (is (= (percent-decode "%20") " "))
+  (is (= (percent-decode "foo%20bar") "foo bar"))
+  (is (= (percent-decode "foo%FE%FF%00%2Fbar" "UTF-16") "foo/bar")))
+
 (deftest test-url-encode
-  (is (= "foo%2Fbar" (url-encode "foo/bar")))
-  (is (= "foo%FE%FF%00%2Fbar") (url-encode "foo/bar" "UTF-16")))
+  (is (= (url-encode "foo/bar") "foo%2Fbar"))
+  (is (= (url-encode "foo/bar" "UTF-16") "foo%FE%FF%00%2Fbar"))
+  (is (= (url-encode "foo+bar") "foo+bar"))
+  (is (= (url-encode "foo bar") "foo%20bar")))
 
 (deftest test-url-decode
-  (testing "standard behavior"
-    (is (= "foo/bar" (url-decode "foo%2Fbar")))
-    (is (= "foo/bar" (url-decode "foo%FE%FF%00%2Fbar" "UTF-16"))))
-  (testing "returns nil when underlying Java methods throw an exception"
-    (is (nil? (url-decode "%")))))
+  (is (= (url-decode "foo%2Fbar") "foo/bar" ))
+  (is (= (url-decode "foo%FE%FF%00%2Fbar" "UTF-16") "foo/bar"))
+  (is (= (url-decode "%") "%")))
 
 (deftest test-base64-encoding
   (let [str-bytes (.getBytes "foo?/+" "UTF-8")]
     (is (Arrays/equals str-bytes (base64-decode (base64-encode str-bytes))))))
+
+(deftest test-form-encode
+  (testing "strings"
+    (are [x y] (= (form-encode x) y)
+      "foo bar" "foo+bar"
+      "foo+bar" "foo%2Bbar"
+      "foo/bar" "foo%2Fbar")
+    (is (= (form-encode "foo/bar" "UTF-16") "foo%FE%FF%00%2Fbar")))
+  (testing "maps"
+    (are [x y] (= (form-encode x) y)
+      {"a" "b"} "a=b"
+      {:a "b"}  "a=b"
+      {"a" 1}   "a=1"
+      {"a" "b" "c" "d"} "a=b&c=d"
+      {"a" "b c"}       "a=b+c")
+    (is (= (form-encode {"a" "foo/bar"} "UTF-16") "a=foo%FE%FF%00%2Fbar"))))
+
+(deftest test-form-decode-str
+  (is (= (form-decode-str "foo=bar+baz") "foo=bar baz"))
+  (is (nil? (form-decode-str "%D"))))
+
+(deftest test-form-decode
+  (are [x y] (= (form-decode x) y)
+    "foo"     "foo"
+    "a=b"     {"a" "b"}
+    "a=b&c=d" {"a" "b" "c" "d"}
+    "foo+bar" "foo bar"
+    "a=b+c"   {"a" "b c"}
+    "a=b%2Fc" {"a" "b/c"})
+  (is (= (form-decode "a=foo%FE%FF%00%2Fbar" "UTF-16")
+         {"a" "foo/bar"})))

@@ -0,0 +1,12 @@
+(ns ring.util.test.io
+  (:use clojure.test
+        ring.util.io)
+  (:require [clojure.java.io :as io]))
+
+(deftest test-piped-input-stream
+  (let [stream (piped-input-stream #(spit % "Hello World"))]
+    (is (= (slurp stream) "Hello World"))))
+
+(deftest test-string-input-stream
+  (let [stream (string-input-stream "Hello World")]
+    (is (= (slurp stream) "Hello World"))))

@@ -12,6 +12,10 @@
   (is (= {:status 303 :headers {"Location" "http://example.com"} :body ""}
          (redirect-after-post "http://example.com"))))
 
+(deftest test-not-found
+  (is (= {:status 404 :headers {} :body "Not found"}
+         (not-found "Not found"))))
+
 (deftest test-response
   (is (= {:status 200 :headers {} :body "foobar"}
          (response "foobar"))))
@@ -24,6 +28,28 @@
          (content-type {:status 200 :headers {"Content-Length" "10"}}
                        "text/html"))))
 
+(deftest test-charset
+  (testing "add charset"
+    (is (= (charset {:status 200 :headers {"Content-Type" "text/html"}} "UTF-8")
+           {:status 200 :headers {"Content-Type" "text/html; charset=UTF-8"}})))
+  (testing "replace existing charset"
+    (is (= (charset {:status 200 :headers {"Content-Type" "text/html; charset=UTF-16"}}
+                    "UTF-8")
+           {:status 200 :headers {"Content-Type" "text/html; charset=UTF-8"}})))
+  (testing "default content-type"
+    (is (= (charset {:status 200 :headers {}} "UTF-8")
+           {:status 200 :headers {"Content-Type" "text/plain; charset=UTF-8"}}))))
+
+(deftest test-header
+  (is (= {:status 200 :headers {"X-Foo" "Bar"}}
+         (header {:status 200 :headers {}} "X-Foo" "Bar"))))
+
+(deftest test-response?
+  (is (response? {:status 200, :headers {}}))
+  (is (response? {:status 200, :headers {}, :body "Foo"}))
+  (is (not (response? {})))
+  (is (not (response? {:users []}))))
+
 (defmacro with-classloader
   "Temporarily replaces the current context classloader with one that
    includes everything in dir"
@@ -77,3 +103,30 @@
              (.getAbsoluteFile (File. "test/ring/assets/hello world.txt"))))
       (is (= (slurp (:body resp))
              "Hello World\n")))))
+
+(deftest test-file-response
+  (testing "response map"
+    (let [resp (file-response "foo.html" {:root "test/ring/assets"})]
+      (is (= (resp :status) 200))
+      (is (= (resp :headers) {}))
+      (is (= (slurp (resp :body)) "foo"))))
+
+  (testing "file path cannot contain '..' "
+    (is (nil? (file-response "../../../project.clj" {:root "test/ring/assets"})))
+    (is (nil? (file-response "../../../project.clj" {:root "test/ring/assets/bars" :allow-symlinks? true}))))
+
+  (testing "file response optionally follows symlinks"
+    (let [resp (file-response "backlink/foo.html" {:root "test/ring/assets/bars" :allow-symlinks? true})]
+      (is (= (resp :status) 200))
+      (is (= (resp :headers) {}))
+      (is (= (slurp (resp :body)) "foo")))
+    
+    (is (nil? (file-response "backlink/foo.html" {:root "test/ring/assets/bars"})))))
+
+(deftest test-set-cookie
+  (is (= {:status 200 :headers {} :cookies {"Foo" {:value "Bar"}}}
+         (set-cookie {:status 200 :headers {}}
+                     "Foo" "Bar")))
+  (is (= {:status 200 :headers {} :cookies {"Foo" {:value "Bar" :http-only true}}}
+         (set-cookie {:status 200 :headers {}}
+                     "Foo" "Bar" {:http-only true}))))

@@ -1,7 +1,7 @@
-(defproject ring/ring-devel "1.0.2"
+(defproject ring/ring-devel "1.1.0"
   :description "Ring development and debugging libraries."
   :url "http://github.com/mmcgrana/ring"
-  :dependencies [[ring/ring-core "1.0.2"]
-                 [hiccup "0.3.7"]
+  :dependencies [[ring/ring-core "1.1.0"]
+                 [hiccup "1.0.0"]
                  [clj-stacktrace "0.2.4"]
                  [ns-tracker "0.1.1"]])

@@ -0,0 +1,36 @@
+/*
+Copyright (c) 2008, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 2.6.0
+*/
+html{color:#000;background:#FFF;}body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,code,form,fieldset,legend,input,textarea,p,blockquote,th,td{margin:0;padding:0;}table{border-collapse:collapse;border-spacing:0;}fieldset,img{border:0;}address,caption,cite,code,dfn,em,strong,th,var{font-style:normal;font-weight:normal;}li{list-style:none;}caption,th{text-align:left;}h1,h2,h3,h4,h5,h6{font-size:100%;font-weight:normal;}q:before,q:after{content:'';}abbr,acronym{border:0;font-variant:normal;}sup{vertical-align:text-top;}sub{vertical-align:text-bottom;}input,textarea,select{font-family:inherit;font-size:inherit;font-weight:inherit;}input,textarea,select{*font-size:100%;}legend{color:#000;}del,ins{text-decoration:none;}
+
+h3.info {
+ font-size: 1.6em; 
+ margin-left: 1em;
+ padding-top: .5em;
+ padding-bottom: .5em;
+}
+
+table.request {
+  font-size: 1.1em;
+  width: 800px;
+  margin-left: 1em;
+  margin-right: 1em;
+  background: lightgrey;
+}
+
+table.request tr {
+  line-height: 1.4em;
+}
+
+table.request td.key {
+  padding-left: .5em;
+  text-aligh: left;
+  width: 150px;
+}
+
+table.request td.val {
+  text-align: left;
+}

@@ -1,31 +1,36 @@
 (ns ring.handler.dump
   "Reflect Ring requests into responses for debugging."
   (:use hiccup.core
-        hiccup.page-helpers
+        hiccup.page
+        hiccup.def
         ring.util.response)
   (:require [clojure.set :as set]
-            [clojure.pprint :as pprint]))
+            [clojure.pprint :as pprint]
+            [clojure.java.io :as io]))
 
 (declare css)
 
 (def ring-keys
   '(:server-port :server-name :remote-addr :uri :query-string :scheme
     :request-method :content-type :content-length :character-encoding
-    :headers :body))
+    :ssl-client-cert :headers :body))
 
-(defhtml req-pair
-  [key req]
-  [:tr [:td.key  (h (str key))]
-       [:td.val  (h (pr-str (key req)))]])
+(defn- style-resource [path]
+  (html [:style {:type "text/css"} (slurp (io/resource path))]))
+
+(defn- req-pair [key req]
+  (html
+    [:tr
+      [:td.key  (h (str key))]
+      [:td.val  (h (pr-str (key req)))]]))
 
 (defhtml template
   [req]
   (doctype :xhtml-transitional)
   [:html {:xmlns "http://www.w3.org/1999/xhtml"}
     [:head
-      [:meta {:http-equiv "Content-Type" :content "text/html"}]
-      [:title "Ring: Request Dump"]]
-      [:style {:type "text/css"} css]
+      [:title "Ring: Request Dump"]
+      (style-resource "ring/css/dump.css")]
     [:body
       [:div#content
         [:h3.info "Ring Request Values"]
@@ -35,11 +40,11 @@
               (req-pair key req))]]
         (if-let [user-keys (set/difference (set (keys req)) (set ring-keys))]
           (html
-             [:br]
-             [:table.request.user
-               [:tbody [:tr
-                 (for [key (sort user-keys)]
-                   (req-pair key req))]]]))]]])
+            [:br]
+            [:table.request.user
+              [:tbody [:tr
+                (for [key (sort user-keys)]
+                  (req-pair key req))]]]))]]])
 
 (defn handle-dump
   "Returns a response tuple corresponding to an HTML dump of the request
@@ -48,43 +53,4 @@
   (pprint/pprint req)
   (println)
   (-> (response (template req))
-    (status 200)
-    (content-type "text/html")))
-
-(def ^{:private true} css "
-/*
-Copyright (c) 2008, Yahoo! Inc. All rights reserved.
-Code licensed under the BSD License:
-http://developer.yahoo.net/yui/license.txt
-version: 2.6.0
-*/
-html{color:#000;background:#FFF;}body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,code,form,fieldset,legend,input,textarea,p,blockquote,th,td{margin:0;padding:0;}table{border-collapse:collapse;border-spacing:0;}fieldset,img{border:0;}address,caption,cite,code,dfn,em,strong,th,var{font-style:normal;font-weight:normal;}li{list-style:none;}caption,th{text-align:left;}h1,h2,h3,h4,h5,h6{font-size:100%;font-weight:normal;}q:before,q:after{content:'';}abbr,acronym{border:0;font-variant:normal;}sup{vertical-align:text-top;}sub{vertical-align:text-bottom;}input,textarea,select{font-family:inherit;font-size:inherit;font-weight:inherit;}input,textarea,select{*font-size:100%;}legend{color:#000;}del,ins{text-decoration:none;}
-
-h3.info {
- font-size: 1.6em; 
- margin-left: 1em;
- padding-top: .5em;
- padding-bottom: .5em;
-}
-
-table.request {
-  font-size: 1.1em;
-  width: 800px;
-  margin-left: 1em;
-  margin-right: 1em;
-  background: lightgrey;
-}
-
-table.request tr {
-  line-height: 1.4em;
-}
-
-table.request td.key {
-  padding-left: .5em;
-  text-aligh: left;
-  width: 150px;
-}
-
-table.request td.val {
-  text-align: left;
-}")
+      (content-type "text/html")))

@@ -2,7 +2,7 @@
   "Catch exceptions and render web and log stacktraces for debugging."
   (:require [clojure.java.io :as io])
   (:use hiccup.core
-        hiccup.page-helpers
+        hiccup.page
         clj-stacktrace.core
         clj-stacktrace.repl
         ring.util.response))
@@ -37,7 +37,7 @@
     (html5
       [:head
         [:title "Ring: Stacktrace"]
-        (style-resource "css/stacktrace.css")]
+        (style-resource "ring/css/stacktrace.css")]
       [:body
         [:div#exception
           [:h3.info (h (str ex))]
@@ -87,6 +87,3 @@
   (-> handler
       wrap-stacktrace-log
       wrap-stacktrace-web))
-
-(def ^{:private true} css "
-")

@@ -1,12 +1,12 @@
 (ns ring.handler.test.dump
   (:use clojure.test
-        ring.handler.dump)
-  (:require [ring.util.test :as tu]))
+        [ring.util.io :only (string-input-stream)]
+        ring.handler.dump))
 
 (def post-req
   {:uri            "/foo/bar"
    :request-method :post
-   :body           (tu/string-input-stream "post body")})
+   :body           (string-input-stream "post body")})
 
 (def get-req
   {:uri            "/foo/bar"

@@ -1,7 +1,7 @@
 (ns ring.middleware.test.lint
   (:use clojure.test
+        [ring.util.io :only (string-input-stream)]
         ring.middleware.lint)
-  (:require [ring.util.test :as tu])
   (:import (java.io File InputStream)))
 
 (def valid-request
@@ -110,7 +110,7 @@
   [nil {:foo "bar"} {"bar" :foo} {"Bar" "foo"}])
 
 (lints-req :body
-  [nil (tu/string-input-stream "thebody")]
+  [nil (string-input-stream "thebody")]
   ["thebody" :thebody])
 
 
@@ -123,5 +123,5 @@
   [nil {:foo "bar"} {"foo" :bar} {"dir" 123}])
 
 (lints-resp :body
-  [nil "thebody" (list "foo" "bar") (tu/string-input-stream "thebody") (File. "test/ring/assets/foo.html")]
+  [nil "thebody" (list "foo" "bar") (string-input-stream "thebody") (File. "test/ring/assets/foo.html")]
   [123 :thebody])

@@ -1,8 +1,8 @@
-(defproject ring/ring-jetty-adapter "1.0.2"
+(defproject ring/ring-jetty-adapter "1.1.0"
   :description "Ring Jetty adapter."
   :url "http://github.com/mmcgrana/ring"
-  :dependencies [[ring/ring-core "1.0.2"]
-                 [ring/ring-servlet "1.0.2"]
-                 [org.mortbay.jetty/jetty "6.1.25"]
-                 [org.mortbay.jetty/jetty-util "6.1.25"]]
-  :dev-dependencies [[clj-http "0.1.3"]])
+  :dependencies [[ring/ring-core "1.1.0"]
+                 [ring/ring-servlet "1.1.0"]
+                 [org.eclipse.jetty/jetty-server "7.6.1.v20120215"]]
+  :profiles
+  {:dev {:dependencies [[clj-http "0.3.2"]]}})

@@ -1,49 +1,61 @@
 (ns ring.adapter.jetty
   "Adapter for the Jetty webserver."
-  (:import (org.mortbay.jetty.handler AbstractHandler)
-           (org.mortbay.jetty Server Request Response)
-           (org.mortbay.jetty.bio SocketConnector)
-           (org.mortbay.jetty.security SslSocketConnector)
+  (:import (org.eclipse.jetty.server Server Request)
+           (org.eclipse.jetty.server.handler AbstractHandler)
+           (org.eclipse.jetty.server.nio SelectChannelConnector)
+           (org.eclipse.jetty.server.ssl SslSelectChannelConnector)
+           (org.eclipse.jetty.util.thread QueuedThreadPool)
+           (org.eclipse.jetty.util.ssl SslContextFactory)
            (javax.servlet.http HttpServletRequest HttpServletResponse))
   (:require [ring.util.servlet :as servlet]))
 
 (defn- proxy-handler
   "Returns an Jetty Handler implementation for the given Ring handler."
   [handler]
   (proxy [AbstractHandler] []
-    (handle [target ^Request request response dispatch]
+    (handle [_ ^Request base-request request response]
       (let [request-map  (servlet/build-request-map request)
             response-map (handler request-map)]
         (when response-map
           (servlet/update-servlet-response response response-map)
-          (.setHandled request true))))))
+          (.setHandled base-request true))))))
 
-(defn- add-ssl-connector!
-  "Add an SslSocketConnector to a Jetty Server instance."
-  [^Server server options]
-  (let [ssl-connector (SslSocketConnector.)]
-    (doto ssl-connector
-      (.setPort        (options :ssl-port 443))
-      (.setHost        (options :host))
-      (.setKeystore    (options :keystore))
-      (.setKeyPassword (options :key-password)))
+(defn- ssl-context-factory
+  "Creates a new SslContextFactory instance from a map of options."
+  [options]
+  (let [context (SslContextFactory.)]
+    (if (string? (options :keystore))
+      (.setKeyStorePath context (options :keystore))
+      (.setKeyStore context (options :keystore)))
+    (.setKeyStorePassword context (options :key-password))
     (when (options :truststore)
-      (.setTruststore ssl-connector (options :truststore)))
+      (.setTrustStore context (options :truststore)))
     (when (options :trust-password)
-      (.setTrustPassword ssl-connector (options :trust-password)))
-    (.addConnector server ssl-connector)))
+      (.setTrustPassword context (options :trust-password)))
+    (case (options :client-auth)
+      :need (.setNeedClientAuth context true)
+      :want (.setWantClientAuth context true)
+      nil)
+    context))
+
+(defn- ssl-connector
+  "Creates a SslSelectChannelConnector instance."
+  [options]
+  (doto (SslSelectChannelConnector. (ssl-context-factory options))
+    (.setPort (options :ssl-port 443))
+    (.setHost (options :host))))
 
 (defn- create-server
   "Construct a Jetty Server instance."
   [options]
-  (let [connector (doto (SocketConnector.)
+  (let [connector (doto (SelectChannelConnector.)
                     (.setPort (options :port 80))
                     (.setHost (options :host)))
         server    (doto (Server.)
                     (.addConnector connector)
                     (.setSendDateHeader true))]
     (when (or (options :ssl?) (options :ssl-port))
-      (add-ssl-connector! server options))
+      (.addConnector server (ssl-connector options)))
     server))
 
 (defn ^Server run-jetty
@@ -59,14 +71,18 @@
   :keystore     - the keystore to use for SSL connections
   :key-password - the password to the keystore
   :truststore   - a truststore to use for SSL connections
-  :trust-password - the password to the truststore"
+  :trust-password - the password to the truststore
+  :max-threads  - the maximum number of threads to use (default 50)
+  :client-auth  - SSL client certificate authenticate, may be set to :need,
+                  :want or :none (defaults to :none)"
   [handler options]
   (let [^Server s (create-server (dissoc options :configurator))]
+    (doto s
+      (.setHandler (proxy-handler handler))
+      (.setThreadPool (QueuedThreadPool. (options :max-threads 50))))
     (when-let [configurator (:configurator options)]
       (configurator s))
-    (doto s
-      (.addHandler (proxy-handler handler))
-      (.start))
+    (.start s)
     (when (:join? options true)
       (.join s))
     s))

@@ -1,20 +1,47 @@
 (ns ring.adapter.test.jetty
   (:use clojure.test
         ring.adapter.jetty)
-  (:require [clj-http.client :as http]))
+  (:require [clj-http.client :as http])
+  (:import (org.eclipse.jetty.util.thread QueuedThreadPool)
+           (org.eclipse.jetty.server Server Request)
+           (org.eclipse.jetty.server.handler AbstractHandler)))
 
 (defn- hello-world [request]
   {:status  200
    :headers {"Content-Type" "text/plain"}
    :body    "Hello World"})
 
-(deftest jetty-test
-  (let [server (run-jetty hello-world {:port 4347, :join? false})]
-    (try
-      (Thread/sleep 2000)
+(defmacro with-server [options & body]
+  `(let [server# (run-jetty hello-world ~(assoc options :join? false))]
+     (try
+       ~@body
+       (finally (.stop server#)))))
+
+(deftest test-run-jetty
+  (testing "HTTP server"
+    (with-server {:port 4347}
       (let [response (http/get "http://localhost:4347")]
         (is (= (:status response) 200))
         (is (.startsWith (get-in response [:headers "content-type"])
                          "text/plain"))
-        (is (= (:body response) "Hello World")))
-      (finally (.stop server)))))
+        (is (= (:body response) "Hello World")))))
+
+  (testing "HTTPS server"
+    (with-server {:port 4347
+                  :ssl-port 4348
+                  :keystore "test/keystore.jks"
+                  :key-password "password"}
+      (let [response (http/get "https://localhost:4348" {:insecure? true})]
+        (is (= (:status response) 200))
+        (is (= (:body response) "Hello World")))))
+
+  (testing "configurator set to run last"
+    (let [max-threads 20 
+          new-handler  (proxy [AbstractHandler] [] (handle [_ ^Request base-request request response]))
+          threadPool (QueuedThreadPool. ({} :max-threads max-threads))
+          configurator (fn [server] (.setThreadPool server threadPool) (.setHandler server new-handler))
+          server (run-jetty hello-world {:join? false :port 4347 :configurator configurator})]
+      (is (= (.getMaxThreads (.getThreadPool server)) max-threads))
+      (is (identical? new-handler (.getHandler server)))
+      (is (= 1 (count (.getHandlers server))))
+      (.stop server))))

@@ -1,5 +1,5 @@
-(defproject ring/ring-servlet "1.0.2"
+(defproject ring/ring-servlet "1.1.0"
   :description "Ring servlet utilities."
   :url "http://github.com/mmcgrana/ring"
-  :dependencies [[ring/ring-core "1.0.2"]
+  :dependencies [[ring/ring-core "1.1.0"]
                  [javax.servlet/servlet-api "2.5"]])

@@ -26,6 +26,11 @@
   (let [length (.getContentLength request)]
     (if (>= length 0) length)))
 
+(defn get-client-cert
+  "Returns the SSL client certificate of the reqest, if one exists."
+  [^HttpServletRequest request]
+  (first (.getAttribute request "javax.servlet.request.X509Certificate")))
+
 (defn build-request-map
   "Create the request map from the HttpServletRequest object."
   [^HttpServletRequest request]
@@ -40,6 +45,7 @@
    :content-type       (.getContentType request)
    :content-length     (get-content-length request)
    :character-encoding (.getCharacterEncoding request)
+   :ssl-client-cert    (get-client-cert request)
    :body               (.getInputStream request)})
 
 (defn merge-servlet-keys
@@ -60,7 +66,7 @@
   [^HttpServletResponse response, status]
   (.setStatus response status))
 
-(defn set-content-type [response content-type]
+(defn set-content-type [^HttpServletResponse response content-type]
   (.setContentType
    response
    (-> content-type
@@ -73,7 +79,7 @@
        (re-find #"charset=(.+);?")
        (second)))
 
-(defn- set-character-encoding [response content-type]
+(defn- set-character-encoding [^HttpServletResponse response content-type]
   (when-let [charset (get-charset content-type)]
     (.setCharacterEncoding response charset)))
 

@@ -9,20 +9,23 @@
       (nextElement [] (let [f (first @e)] (swap! e rest) f)))))
 
 (defn- servlet-request [request]
-  (proxy [javax.servlet.http.HttpServletRequest] []
-    (getServerPort [] (request :server-port))
-    (getServerName [] (request :server-name))
-    (getRemoteAddr [] (request :remote-addr))
-    (getRequestURI [] (request :uri))
-    (getQueryString [] (request :query-string))
-    (getScheme [] (name (request :scheme)))
-    (getMethod [] (-> request :request-method name .toUpperCase))
-    (getHeaderNames [] (enumeration (keys (request :headers))))
-    (getHeaders [name] (enumeration (get-in request [:headers name])))
-    (getContentType [] (request :content-type))
-    (getContentLength [] (or (request :content-length) -1))
-    (getCharacterEncoding [] (request :character-encoding))
-    (getInputStream [] (request :body))))
+  (let [attributes {"javax.servlet.request.X509Certificate"
+                    [(request :ssl-client-cert)]}]
+    (proxy [javax.servlet.http.HttpServletRequest] []
+      (getServerPort [] (request :server-port))
+      (getServerName [] (request :server-name))
+      (getRemoteAddr [] (request :remote-addr))
+      (getRequestURI [] (request :uri))
+      (getQueryString [] (request :query-string))
+      (getScheme [] (name (request :scheme)))
+      (getMethod [] (-> request :request-method name .toUpperCase))
+      (getHeaderNames [] (enumeration (keys (request :headers))))
+      (getHeaders [name] (enumeration (get-in request [:headers name])))
+      (getContentType [] (request :content-type))
+      (getContentLength [] (or (request :content-length) -1))
+      (getCharacterEncoding [] (request :character-encoding))
+      (getAttribute [k] (attributes k))
+      (getInputStream [] (request :body)))))
 
 (defn- servlet-response [response]
   (proxy [javax.servlet.http.HttpServletResponse] []
@@ -47,6 +50,7 @@
 
 (deftest servlet-test
   (let [body (proxy [javax.servlet.ServletInputStream] [])
+        cert (proxy [java.security.cert.X509Certificate] [])
         request {:server-port    8080
                  :server-name    "foobar"
                  :remote-addr    "127.0.0.1"
@@ -59,7 +63,8 @@
                  :content-type   "text/plain"
                  :content-length 10
                  :character-encoding "UTF-8"
-                 :body           body}
+                 :ssl-client-cert cert
+                 :body            body}
           response (atom {})]
     (testing "request"
       (letfn [(handler [r]
@@ -76,7 +81,8 @@
                  :content-type   "text/plain"
                  :content-length 10
                  :character-encoding "UTF-8"
-                 :body           body)
+                 :ssl-client-cert cert
+                 :body            body)
                {:status 200, :headers {}})]
         (run-servlet handler request response)))
     (testing "response"