Refactor templates: humps/hump variables

1 files changed, 69 insertions, 69 deletions

diff --git a/src/site.clj b/src/site.clj
index be3edd4..8e5082b 100755
--- a/src/site.clj
+++ b/src/site.clj
@@ -232,7 +232,7 @@
                        (catch Exception e (println e) [])))
                    3600
                    nil))
-(def num-frontpage-dumps 20)
+(def num-frontpage-humps 20)
   
 (defn front-page
   ([session]
@@ -246,12 +246,12 @@
          (cond (.before cur-date earliest-daily-hall) (redirect-to "/")
                (.after cur-date today)                (redirect-to "/")
                :else (let [st        (fetch-template "frontpage" session)
-                           dumps     (map process-message-for-output
+                           humps     (map process-message-for-output
                                           (if (:nick session)
                                             (fetch-redis-daily-hall cur-date 0 20 (:user_id session))
-                                            (take num-frontpage-dumps
+                                            (take num-frontpage-humps
                                                   (shuffle (poll frontpage-posts-agent)))))]
-                       (.setAttribute st "dumps" dumps)
+                       (.setAttribute st "humps" humps)
                        (if-not (.after next-date today)
                          (.setAttribute st "next_date"    (format-yyyymmdd next-date)))
                        (if-not (.before prev-date earliest-daily-hall)
@@ -496,35 +496,35 @@ WHERE  user_id IN
   ([session user-info date msg-id template]
      (let [st            (fetch-template template session)
            logger        (make-time-logger)
-           raw-dumps     (tags/fetch-dumps
+           raw-humps     (tags/fetch-dumps
                           :nick (:nick user-info)
                           :user-tag-id (:user_id session)
                           :msg-id msg-id
                           :date (if msg-id nil date)
                           :limit (inc *dumps-per-page*))
-           recips        (map :nick (get-recips-from-msgs raw-dumps))
-           back-dumps    (if (or date msg-id)
+           recips        (map :nick (get-recips-from-msgs raw-humps))
+           back-humps    (if (or date msg-id)
                            (tags/fetch-dumps
                             :nick (:nick user-info)
                             :msg-id msg-id
                             :date (if msg-id nil date)
                             :limit (inc *dumps-per-page*)
                             :direction :forward))
-           dumps         (map process-message-for-output (take *dumps-per-page* raw-dumps))]
+           humps         (map process-message-for-output (take *dumps-per-page* raw-humps))]
        (.setAttribute st "nick" (:nick user-info))
        (.setAttribute st "is_home" (= (:nick user-info) (:nick session)))
        (.setAttribute st "mini_profile" (build-mini-profile user-info))
-       (when (> (count dumps) 0)
-         (.setAttribute st "dumps" dumps))
+       (when (> (count humps) 0)
+         (.setAttribute st "humps" humps))
        (.setAttribute st "recips" (json-str recips))
        (.setAttribute st "prev"
-                      (if back-dumps
+                      (if back-humps
                         (cond
-                         (> (count back-dumps) *dumps-per-page*) (log-next-page-link (last back-dumps))
-                         (> (count back-dumps) 1) (format "/%s/log" (:nick user-info))
+                         (> (count back-humps) *dumps-per-page*) (log-next-page-link (last back-humps))
+                         (> (count back-humps) 1) (format "/%s/log" (:nick user-info))
                          :else nil)))
-       (if (> (count raw-dumps) *dumps-per-page*)
-         (.setAttribute st "next" (log-next-page-link (last raw-dumps))))
+       (if (> (count raw-humps) *dumps-per-page*)
+         (.setAttribute st "next" (log-next-page-link (last raw-humps))))
        (.setAttribute st "debug_log_items" (logger))
        (.toString st))))
 
@@ -540,13 +540,13 @@ WHERE  user_id IN
   (if-let [user-info (fetch-nick profile-nick)]
     (let [st            (fetch-template "popular" session)
 	  profile-nick  (:nick user-info)
-	  raw-dumps     (fetch-popular-dumps-redis profile-nick (:nick session))
-          raw-dumps     (filter #(> (:count %) 0) raw-dumps)
-          recips        (map :nick (get-recips-from-msgs raw-dumps))
-	  dumps         (map process-message-for-output raw-dumps)]
+	  raw-humps     (fetch-popular-dumps-redis profile-nick (:nick session))
+          raw-humps     (filter #(> (:count %) 0) raw-humps)
+          recips        (map :nick (get-recips-from-msgs raw-humps))
+	  humps         (map process-message-for-output raw-humps)]
       (.setAttribute st "nick" profile-nick)
       (.setAttribute st "mini_profile" (build-mini-profile user-info))
-      (.setAttribute st "dumps" dumps)
+      (.setAttribute st "humps" humps)
       (.setAttribute st "recips" (json-str recips))
       (.toString st))
     (resp-error "NO_USER")))
@@ -610,9 +610,9 @@ WHERE  user_id IN
   (if-let [message (fetch-public-message-by-id id-from-url (:nick session))]
     ; error if nick in url doesn't match the nick who posted the message from the id in url 
     ; this prevents people from scraping all the content by incrementing the id in the url
-    (if (= nick-from-url (:nick message))
-      (let [st (fetch-template "single_message" session)]
-        (.setAttribute st "dump" (process-message-for-output message))
+      (if (= nick-from-url (:nick message))
+        (let [st (fetch-template "single_message" session)]
+        (.setAttribute st "hump" (process-message-for-output message))
         (.setAttribute st "recips" (json-str (map :nick (get-recips (:content message)))))
         (.toString st))
       (resp-error "NO_MESSAGE"))
@@ -762,7 +762,7 @@ WHERE  user_id IN
     (.setAttribute st "recips" (json-str recips))
     (.setAttribute st "topic" topic)
     (if-not (empty? msgs)
-      (.setAttribute st "dumps" msgs))
+      (.setAttribute st "humps" msgs))
     (.toString st)))
 
 ;; Chat Log
@@ -772,24 +772,24 @@ WHERE  user_id IN
         st          (fetch-template "log" session)
         logger      (make-time-logger)
 				offset      (maybe-parse-int offset 0)
-        dump-offset (* offset *dumps-per-page*)
+        hump-offset (* offset *dumps-per-page*)
         image-only  (and (not (room :admin_only))
                          (not= (params :show) "all"))
-        raw-dumps   (logger tags/fetch-dumps-by-room
+        raw-humps   (logger tags/fetch-dumps-by-room
                             :room-id (room :room_id)
                             :image-only image-only
                             :amount (+ 1 *dumps-per-page*)
-                            :offset dump-offset)
-        dumps       (map tags/add-favorited-flag
-                         (take *dumps-per-page* raw-dumps)
+                            :offset hump-offset)
+        humps       (map tags/add-favorited-flag
+                         (take *dumps-per-page* raw-humps)
                          (repeat session))
-        dumps       (map tags/remove-tags-for-output dumps)
-        dumps       (logger doall (map process-message-for-output dumps))]
-    (if (> (count raw-dumps) *dumps-per-page*)
+        humps       (map tags/remove-tags-for-output humps)
+        humps       (logger doall (map process-message-for-output humps))]
+    (if (> (count raw-humps) *dumps-per-page*)
       (.setAttribute st "next" (inc offset)))
     (if (not= offset 0)
       (.setAttribute st "prev" (max (dec offset) 0)))
-    (.setAttribute st "dumps" dumps)
+    (.setAttribute st "humps" humps)
     (if (default-room? roomkey)
       (.setAttribute st "roomkey" "")
       (.setAttribute st "roomkey" (str roomkey ".")))
@@ -814,13 +814,13 @@ WHERE  user_id IN
 
 (defn hiscore-test [session params period]
   (let [st     (fetch-template "hiscore_test" session)
-        dumps  (tags/fetch-dumps-by-ids (redis-ids-test period))
-        dumps  (map tags/add-favorited-flag dumps (repeat session))
-        dumps  (map tags/add-fav-count dumps)
-        dumps  (reverse (sort-by :favcount dumps))
-        dumps  (map tags/remove-tags-for-output dumps)
-        dumps  (map process-message-for-output dumps)]
-    (.setAttribute st "dumps" dumps)
+        humps  (tags/fetch-dumps-by-ids (redis-ids-test period))
+        humps  (map tags/add-favorited-flag humps (repeat session))
+        humps  (map tags/add-fav-count humps)
+        humps  (reverse (sort-by :favcount humps))
+        humps  (map tags/remove-tags-for-output humps)
+        humps  (map process-message-for-output humps)]
+    (.setAttribute st "humps" humps)
     (.toString st)))
         
 ;; Altars
@@ -834,16 +834,16 @@ WHERE  user_id IN
         user-id    (if nick (user-id-from-nick nick) nil)
         template   (if user-id "altar_user_log" "altar_log")
         st         (fetch-template template session)
-        raw-dumps  (tags/fetch-altars :message-id id :amount (+ 1 *dumps-per-page*) :user-id user-id)
-        dumps      (map tags/add-favorited-flag (take *dumps-per-page* raw-dumps) (repeat session))
-        dumps      (map tags/remove-tags-for-output dumps)
-        dumps      (map process-message-for-output dumps)]
-    (.setAttribute st "dumps" dumps)
+        raw-humps  (tags/fetch-altars :message-id id :amount (+ 1 *dumps-per-page*) :user-id user-id)
+        humps      (map tags/add-favorited-flag (take *dumps-per-page* raw-humps) (repeat session))
+        humps      (map tags/remove-tags-for-output humps)
+        humps      (map process-message-for-output humps)]
+    (.setAttribute st "humps" humps)
     (.setAttribute st "nick" nick)
-    (if (> (count raw-dumps) *dumps-per-page*)
-      (.setAttribute st "next" ((last raw-dumps) :message_id)))
+    (if (> (count raw-humps) *dumps-per-page*)
+      (.setAttribute st "next" ((last raw-humps) :message_id)))
     (if id
-      (.setAttribute st "prev" ((first raw-dumps) :message_id)))
+      (.setAttribute st "prev" ((first raw-humps) :message_id)))
     (.toString st)))
 
 ;; Tags 
@@ -914,25 +914,25 @@ WHERE  user_id IN
                               :logger (make-time-logger)
                               :include-vip false]
   (let [st (fetch-template "tagged_dumps" session)
-	      offset (maybe-parse-int (params :offset) 0)
-        dump-offset (* offset *dumps-per-page*)
-        raw-dumps (logger tags/fetch-dumps-by-tag :tags tags 
+		      offset (maybe-parse-int (params :offset) 0)
+        hump-offset (* offset *dumps-per-page*)
+        raw-humps (logger tags/fetch-dumps-by-tag :tags tags 
                                                   :image-only false 
                                                   :amount (+ 1 *dumps-per-page*)
-                                                  :offset dump-offset
+                                                  :offset hump-offset
                                                   :message-user-id message-user-id
                                                   :tag-user-id tag-user-id
                                                   :include-vip include-vip)
-        dumps (map tags/add-favorited-flag (take *dumps-per-page* raw-dumps) (repeat session))
-        dumps (map tags/remove-tags-for-output dumps)
-        dumps (logger doall (map process-message-for-output dumps))]
-    (.setAttribute st "dumps" dumps)
+        humps (map tags/add-favorited-flag (take *dumps-per-page* raw-humps) (repeat session))
+        humps (map tags/remove-tags-for-output humps)
+        humps (logger doall (map process-message-for-output humps))]
+    (.setAttribute st "humps" humps)
     (.setAttribute st "infobar" info-bar)
     (.setAttribute st "page_title" page-title)
     (.setAttribute st "page_url" url)
     (if (not= offset 0)
       (.setAttribute st "prev" (format "/%s/%s" url (max 0 (dec offset)))))
-    (if (> (count raw-dumps) *dumps-per-page*)
+    (if (> (count raw-humps) *dumps-per-page*)
       (.setAttribute st "next" (format "/%s/%s" url (inc offset))))
     (.setAttribute st "debug_log_items" (logger))
     (.toString st)))
@@ -964,15 +964,15 @@ WHERE  user_id IN
 (defn favorites [session user-info date msg-id]
   (let [st            (fetch-template "tagged_dumps" session)
         logger        (make-time-logger)
-        raw-dumps     (tags/fetch-tagged-dumps
+        raw-humps     (tags/fetch-tagged-dumps
                        :nick (:nick user-info)
                        :user-tag-id (:user_id session)
                        :msg-id msg-id
                        :hide-vip (not (:is_admin session))
                        :date (if msg-id nil date)
                        :limit (inc *dumps-per-page*))
-        recips        (map :nick (get-recips-from-msgs raw-dumps))
-        back-dumps    (if (or date msg-id)
+        recips        (map :nick (get-recips-from-msgs raw-humps))
+        back-humps    (if (or date msg-id)
                         (tags/fetch-tagged-dumps
                          :nick (:nick user-info)
                          :msg-id msg-id
@@ -980,17 +980,17 @@ WHERE  user_id IN
                          :date (if msg-id nil date)
                          :limit (inc *dumps-per-page*)
                          :direction :forward))
-        dumps         (map process-message-for-output (butlast raw-dumps))]
+        humps         (map process-message-for-output (butlast raw-humps))]
     (.setAttribute st "prev"
-                   (if back-dumps
+                   (if back-humps
                      (cond
-                      (> (count back-dumps) *dumps-per-page*) (favorites-next-page-link (:nick user-info)
-                                                                                        (last back-dumps))
-                      (> (count back-dumps) 1) (format "/%s/favorites" (:nick user-info))
+                      (> (count back-humps) *dumps-per-page*) (favorites-next-page-link (:nick user-info)
+                                                                                        (last back-humps))
+                      (> (count back-humps) 1) (format "/%s/favorites" (:nick user-info))
                       :else nil)))
-    (if (> (count raw-dumps) *dumps-per-page*)
-      (.setAttribute st "next" (favorites-next-page-link (:nick user-info) (last raw-dumps))))
-    (.setAttribute st "dumps" dumps)
+    (if (> (count raw-humps) *dumps-per-page*)
+      (.setAttribute st "next" (favorites-next-page-link (:nick user-info) (last raw-humps))))
+    (.setAttribute st "humps" humps)
     (.setAttribute st "recips" (json-str recips))
     (.setAttribute st "infobar" (build-mini-profile user-info))
     (.setAttribute st "page_title" (format "%s'S FAVS" (:nick user-info)))
@@ -1218,7 +1218,7 @@ WHERE  user_id IN
 (defn hall-of-fame [session]
   (let [st    (fetch-template "fame" session)
         msgs  (fetch-redis-hall (:nick session))]
-    (.setAttribute st "dumps" (map process-message-for-output msgs))
+    (.setAttribute st "humps" (map process-message-for-output msgs))
     (.toString st)))
 
 ;; MGMT