Apply whitespace-cleanup

Author: ernestas

src/hitchhiker/redis.clj

@@ -9,7 +9,7 @@
             [hitchhiker.tree.messaging :as msg]))
 
 ;;; Description of refcounting system in redis
-;;; 
+;;;
 ;;; The refcounting system allows any key in redis to be managed
 ;;; by refcounting. This refcounter doesn't do cycle protection, but
 ;;; weakrefs would be very simple to add.
@@ -276,19 +276,19 @@
           e ["" ":rc" ":rs" ":rl"]]
     (println (str k e) "=" (wcar {} ((if (= e ":rl")
                                        #(car/lrange % 0 -1)
-                                       car/get) (str k e))))) 
+                                       car/get) (str k e)))))
   (wcar {} (drop-ref "foo"))
 
   (wcar {} (create-refcounted "foo" 22))
 
   (wcar {} (car/flushall))
-  (count (wcar {} (car/keys "*")))    
+  (count (wcar {} (car/keys "*")))
   (count (msg/lookup-fwd-iter (create-tree-from-root-key @(:storage-addr (:tree my-tree))) -1))
   (count (msg/lookup-fwd-iter (create-tree-from-root-key @(:storage-addr (:tree my-tree-updated))) -1))
   (def my-tree (core/flush-tree
                  (time (reduce msg/insert
                                (core/b-tree (core/->Config 17 300 (- 300 17)))
-                               (range 50000))) 
+                               (range 50000)))
                  (->RedisBackend)
                  ))
   (def my-tree-updated (core/flush-tree

src/hitchhiker/tree/core.clj

@@ -29,7 +29,7 @@
   (underflow? [node] "Returns true if this node has too few elements")
   (merge-node [node other] "Combines this node with the other to form a bigger node. We assume they're siblings")
   (split-node [node] "Returns a Split object with the 2 nodes that we turned this into")
-  (lookup [node key] "Returns the child node which contains the given key")) 
+  (lookup [node key] "Returns the child node which contains the given key"))
 
 (defrecord Split [left right median])
 
@@ -357,7 +357,7 @@
               child (if (data-node? cur)
                       nil #_(nth-of-set (:children cur) index)
                       (-> (:children cur)
-                          ;;TODO what are the semantics for exceeding on the right? currently it's trunc to the last element 
+                          ;;TODO what are the semantics for exceeding on the right? currently it's trunc to the last element
                           (nth index (peek (:children cur)))
                           (resolve)))
               path' (conj path index child)]

src/hitchhiker/tree/messaging.clj

@@ -1,10 +1,10 @@
 (ns hitchhiker.tree.messaging
   (:refer-clojure :exclude [subvec])
   (:require [hitchhiker.tree.core :as core]
-            [clojure.pprint :as pp] 
+            [clojure.pprint :as pp]
             [clojure.core.rrb-vector :refer (catvec subvec)])
   (:import java.io.Writer
-           java.util.Collections)) 
+           java.util.Collections))
 
 ;; An operation is an object with a few functions
 ;; 1. It has a function that it applies to the tree to apply its effect
@@ -89,7 +89,7 @@
            ;         )
            (loop [[child & children] (:children tree)
                   rebuilt-children []
-                  msgs (vec (sort-by affects-key ;must be a stable sort 
+                  msgs (vec (sort-by affects-key ;must be a stable sort
                                      (concat (:op-buf tree) msgs)))]
              (let [took-msgs (into []
                                    (take-while #(>= 0 (core/compare
@@ -177,7 +177,7 @@
                             (drop-while #(>= 0 (core/compare (affects-key %)
                                                              left-sibs-min-last)))
                             identity)
-          data-node (peek path) 
+          data-node (peek path)
           my-last (core/last-key data-node)
           right-side-filter (if is-last?
                               identity

test/hitchhiker/redis_test.clj

@@ -99,7 +99,7 @@
       (println (->> (read-string (slurp "broken-data.edn"))
                     (map (fn [[op x]] [op (mod x 100000)]))
                     (take-last  125)
-                    first)) 
+                    first))
       (println (lookup-fwd-iter b-tree -1))
       (println (sort s))
       ))

test/hitchhiker/tree/core_test.clj

@@ -1,5 +1,5 @@
 (ns hitchhiker.tree.core-test
-  (:refer-clojure :exclude [compare resolve]) 
+  (:refer-clojure :exclude [compare resolve])
   (:require [clojure.test :refer :all]
             [hitchhiker.tree.core :refer :all]
             [clojure.test.check :as tc]
@@ -47,7 +47,7 @@
                 (let [sorted-set-order (into (sorted-set) v)
                       b-tree (reduce insert-helper (b-tree (->Config 3 3 2)) v)
                       b-tree-order (lookup-fwd-iter b-tree Integer/MIN_VALUE)]
-                  (= (seq sorted-set-order) (seq (map first b-tree-order)))))) 
+                  (= (seq sorted-set-order) (seq (map first b-tree-order))))))
 
 (defspec test-delete2
   1000

test/hitchhiker/tree/messaging_test.clj

@@ -30,7 +30,7 @@
                 (let [sorted-set-order (into (sorted-set) v)
                       b-tree (reduce insert (core/b-tree (core/->Config 3 3 2)) v)
                       b-tree-order (lookup-fwd-iter b-tree Integer/MIN_VALUE)]
-                  (= (seq sorted-set-order) b-tree-order)))) 
+                  (= (seq sorted-set-order) b-tree-order))))
 
 (defspec test-delete2
   1000
@@ -86,7 +86,7 @@
                :del (msg/delete %2 (second %1)))
           ]
       ;  (println ops)
-      (println killer-op) 
+      (println killer-op)
       (clojure.pprint/pprint b-tree)
       (println (lookup-fwd-iter b-tree -1))
       (println (sort s))
@@ -96,10 +96,10 @@
       (println (lookup-fwd-iter (f killer-op b-tree) -1))
       (println (sort (disj s (second killer-op))))
       (when killer-op-dos
-        (println killer-op-dos) 
+        (println killer-op-dos)
         (clojure.pprint/pprint (f killer-op-dos (f killer-op b-tree)))))
     )
-  
+
   (clojure.pprint/pprint cool-test-tree)
   (clojure.pprint/pprint (insert cool-test-tree 20))
   (clojure.pprint/pprint (msg/delete cool-test-tree 32))