Import from ring-core project

Author: weavejester

.gitignore

@@ -0,0 +1,12 @@
+/target
+/lib
+/classes
+/checkouts
+pom.xml
+pom.xml.asc
+*.jar
+*.class
+.lein-deps-sum
+.lein-failures
+.lein-plugins
+.lein-repl-history

README.md

@@ -0,0 +1,13 @@
+# ring-codec
+
+A Clojure library designed to ... well, that part is up to you.
+
+## Usage
+
+FIXME
+
+## License
+
+Copyright © 2013 FIXME
+
+Distributed under the Eclipse Public License, the same as Clojure.

project.clj

@@ -0,0 +1,10 @@
+(defproject ring-codec "0.1.0-SNAPSHOT"
+  :description "Library for encoding and decoding data"
+  :url "http://example.com/FIXME"
+  :license {:name "The MIT License"
+            :url "http://opensource.org/licenses/MIT"}
+  :dependencies [[org.clojure/clojure "1.3.0"]
+                 [commons-codec "1.6"]]
+  :profiles
+  {:1.4 {:dependencies [[org.clojure/clojure "1.4.0"]]}
+   :1.5 {:dependencies [[org.clojure/clojure "1.5.0-RC1"]]}})

src/ring/util/codec.clj

@@ -0,0 +1,131 @@
+(ns ring.util.codec
+  "Functions for encoding and decoding data."
+  (:require [clojure.string :as str])
+  (:import java.io.File
+           java.util.Map
+           [java.net URLEncoder URLDecoder]
+           org.apache.commons.codec.binary.Base64))
+
+(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)))
+
+(defn- double-escape [^String x]
+  (.replace (.replace x "\\" "\\\\") "$" "\\$"))
+
+(def ^:private string-replace-bug?
+  (= "x" (str/replace "x" #"." (fn [x] "$0"))))
+
+(defmacro fix-string-replace-bug [x]
+  (if string-replace-bug?
+    `(double-escape ~x)
+    x))
+
+(defn percent-encode
+  "Percent-encode every character in the given string using either the specified
+  encoding, or UTF-8 by default."
+  [^String unencoded & [^String 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/valueOf % 16)))
+       (byte-array)))
+
+(defn percent-decode
+  "Decode every percent-encoded character in the given string using the
+  specified encoding, or UTF-8 by default."
+  [^String encoded & [^String encoding]]
+  (str/replace encoded
+               #"(?:%..)+"
+               (fn [chars]
+                 (-> ^bytes (parse-bytes chars)
+                     (String. (or encoding "UTF-8"))
+                     (fix-string-replace-bug)))))
+
+(defn url-encode
+  "Returns the url-encoded version of the given string, using either a specified
+  encoding or UTF-8 by default."
+  [unencoded & [encoding]]
+  (str/replace
+    unencoded
+    #"[^A-Za-z0-9_~.+-]+"
+    #(double-escape (percent-encode % encoding))))
+
+(defn ^String url-decode
+  "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]]
+  (percent-decode encoded encoding))
+
+(defn base64-encode
+  "Encode an array of bytes into a base64 encoded string."
+  [unencoded]
+  (String. (Base64/encodeBase64 unencoded)))
+
+(defn base64-decode
+  "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."
+  [^String 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 #"&"))))

test/ring/util/test/codec.clj

@@ -0,0 +1,61 @@
+(ns ring.util.test.codec
+  (:use clojure.test
+        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"))
+  (is (= (percent-decode "%24") "$")))
+
+(deftest test-url-encode
+  (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
+  (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"})))