Another intermediate version.

src/beanstalk/core.clj

@@ -1,18 +1,22 @@
 (ns beanstalk.core
 
+  (use clojure.contrib.condition)
   (use clojure.java.io)
   (import [java.io BufferedReader]))
 
 ;
-;  (use 'clojure.java.io)
-;  (import '[java.io BufferedReader])
+  (use clojure.contrib.condition)
+  (use 'clojure.java.io)
+  (import '[java.io BufferedReader])
 
 (def *debug* false)
 (def *crlf* (str \return \newline))
 
 (defprotocol BeanstalkObject
   (close [this] "Close the connection")
   (stats [this] "stats command")
+  (write [this msg] "Write to the socket using the writer")
+  (read [this] "Read from the socket using the reader")
   ;(put [this pri del ttr length data] "put command")
   ;(use [this tube] "use command")
   ;(reserve [this] "reserve command")
@@ -21,91 +25,70 @@
 (defrecord Beanstalk [socket reader writer]
   BeanstalkObject
     (close [this] (.close socket))
+    (write [this msg] (stream-write writer (beanstalk-cmd msg)))
+    (read [this] (stream-read reader))
     (stats [this] (do 
-                    (Beanstalk-write writer (beanstalk-cmd "stats"))
-                    (Beanstalk-read reader)    ; ok
-                    (Beanstalk-read reader)))) ; payload
+                    (.write this (beanstalk-cmd :stats))
+                    (.read this)    ; ok
+                    (.read this)))) ; payload
 
-(cmd-reply-case (Beanstalk-write writer (beanstalk-cmd "stats"))
-  ; this should translate into a case
-  (:ok (Beanstalk))
- )
 
-;(defstruct Beanstalk :socket :reader :writer)
-;(def bsock (accessor Beanstalk :socket))
-;(def breader (accessor Beanstalk :reader))
-;(def bwriter (accessor Beanstalk :writer))
 
-;(defn conn-new 
-;  ([port] (java.net.Socket. "localhost" port))
-;  ([host port] (java.net.Socket. host port)))
+;(cmd-reply-case (stream-write writer (beanstalk-cmd "stats"))
+;  (:ok (stream-read reader)))
+
+; cmd = "stats", symbol = :ok, fn = (stream-read reader)
+;(cmd-reply-case writer cmd
+;  (symbol fn))
+
+; translates to
+(defmacro cmd-reply-case [req clauses]
+  `(let [reply# ~req]
+     (condp = (:response reply#)
+       ~@clauses
+       (raise :message (str "Unexpected response from sever: " response)))))
+
+(macroexpand `(cmd-reply-case (stream-write writer (beanstalk-cmd :stats))
+  (:ok (stream-read reader))))
+
+;(let [reply (stream-write writer (beanstalk-cmd (name cmd)))]
+;  (cond = (:response reply)
+;    :ok fn
+;    (raise :message (str "Unexpected response from sever: " response)))
+;  )
 
 (defn Beanstalk-create [host port]
   (let [s (java.net.Socket. "localhost" port)]
     (Beanstalk. s (reader s) (writer s))))
 
-;(defn- beanstalk-create [host port]
-;  (let [s (java.net.Socket. "localhost" port)]
-;    (struct-map Beanstalk
-;                :socket s
-;                :reader (reader s)
-;                :writer (writer s)
-;                )))
 
 (defn beanstalk-cmd [s & args]
     (if (nil? args)
-      (str s \return \newline)
-      (str s " " (.concat (str (reduce #(str %1 " " %2) args)) 
+      (str (name s) \return \newline)
+      (str (name s) " " (.concat (str (reduce #(str %1 " " %2) args)) 
                           (str \return \newline)))))
 
 ; type conversion might be (Ingeger. var)
 (defn parse-reply [reply]
   (let [parts (split reply #"\s+")
-        response (keyword (lower-case (first parts)))
+        response (keyword (clojure.string/lower-case (first parts)))
         data (reduce #(str %1 " " %2) (rest parts))]
     {:response response :data data}))
 
 ; keep
-;(defn Beanstalk
-;  ([port] (Beanstalk-create "localhost" port))
-;  ([host port] (Beanstalk-create host port))
-;  ([] (Beanstalk-create "localhost" 11300)))
+(defn Beanstalk
+  ([port] (Beanstalk-create "localhost" port))
+  ([host port] (Beanstalk-create host port))
+  ([] (Beanstalk-create "localhost" 11300)))
 
-;(defn beanstalk
-;  ([port] (beanstalk-create "localhost" port))
-;  ([host port] (beanstalk-create host port))
-;  ([] (beanstalk-create "localhost" 11300)))
 
-;(defn beanstalk-close [B]
-;  (.close (:socket B)))
+(defn stream-write [w msg]
+    (do (. w write msg) (. w flush)))
 
-(defn Beanstalk-write [w msg]
-    (do (. w write (beanstalk-cmd msg)) (. w flush)))
-
-;(defn beanstalk-write [b msg]
-;  (let [w (bwriter b)]
-;    (do (. w write (beanstalk-cmd msg)) (. w flush))) b)
-
-(defn Beanstalk-read [r]
+(defn stream-read [r]
   (binding [*in* r]
     (read-line)))
 
-;(defn beanstalk-read [b]
-;  (binding [*in* (breader b)]
-;    (read-line)))
-
-; handly reply gracefully
-;(defn reply)
-;
-;; what about retry?
-;(defn put [b pri del ttr bytes data]
-;  (if (reply (beanstalk-write (beanstalk-write b (beanstalk-cmd "put" pri del ttr bytes)) data))
-;    b
-;    false))
-
-;(def b (beanstalk 11300))
-;(beanstalk-write b "stats") 
-;(beanstalk-read b) 
 
 (def B (Beanstalk-create "localhost" 11300))
 (.stats B)