(WIP) Push what i have so Alan can take over. Refs clojure#48

Author: brentonashworth

samples/twitterbuzz/index.html

@@ -72,6 +72,7 @@ <h2>Timeline</h2>
   <script type="text/javascript">
     goog.require('twitterbuzz.core');
     goog.require('twitterbuzz.timeline');
+    goog.require('twitterbuzz.leaderboard');
     goog.require('twitterbuzz.showgraph');
   </script>
 

samples/twitterbuzz/src/twitterbuzz/core.cljs

@@ -1,40 +1,92 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
 (ns twitterbuzz.core
   (:require [goog.net.Jsonp :as jsonp]
             [goog.Timer :as timer]
             [goog.events :as events]
             [goog.dom :as dom]))
 
+(def state (atom {:max-id 1
+                  :graph {}
+                  :new-tweets-listeners []
+                  :graph-update-listeners []
+                  :tweet-count 0}))
+
+(defn add-listener [k f]
+  (swap! state (fn [old] (assoc old k (conj (k old) f)))))
+
 (def twitter-uri (goog.Uri. "http://twitter.com/search.json"))
 
 (defn retrieve [payload callback]
   (.send (goog.net.Jsonp. twitter-uri)
          payload
          callback))
 
-(def state (atom {:max-id 1 :functions [] :tweet-count 0}))
-
 (defn send-tweets [fns tweets]
   (when (seq fns)
     (do ((first fns) tweets)
         (recur (rest fns) tweets))))
 
+(defn parse-mentions [tweet]
+  (map second (re-seq (re-pattern "@(\\w*)") (:text tweet))))
+
+(defn add-mentions
+  "Add the user to the mentions map for each user she mentions."
+  [graph user mentions]
+  (reduce (fn [acc next-mention]
+            (if-let [node (get graph next-mention)]
+              (let [mentions-map (get node :mentions {})]
+                (assoc-in acc [next-mention :mentions user] (inc (get mentions-map user 0))))
+              graph))
+          graph
+          mentions))
+
+(defn update-graph [graph tweet-maps]
+  (reduce (fn [acc tweet]
+            (let [user (:from_user tweet)
+                  mentions (parse-mentions tweet)]
+              (-> (if-let [existing-node (get acc user)]
+                    (assoc acc user
+                           (assoc existing-node :last-tweet (:text tweet)))
+                    (assoc acc user
+                           {:image-url (:profile_image_url tweet)
+                            :last-tweet (:text tweet)
+                            :mentions {}}))
+                  (add-mentions user mentions))))
+          graph
+          (map #(select-keys % [:text :from_user :profile_image_url]) tweet-maps)))
+
+(defn num-mentions [user]
+  (reduce + (vals (:mentions user))))
+
+(defn update-state [old-state max-id tweets]
+  (-> old-state
+      (assoc :max-id max-id)
+      (update-in [:tweet-count] #(+ % (count tweets)))
+      (assoc :graph (update-graph (:graph old-state) tweets))))
+
 (defn my-callback [json]
   (let [result-map (js->clj json :keywordize-keys true)
         new-max (:max_id result-map)
         old-max (:max-id @state) ;; the filter won't work if you inline this
         tweets (filter #(> (:id %) old-max)
                        (:results result-map))]
-    (do  (swap! state (fn [old] (-> old
-                                   (assoc :max-id new-max)
-                                   (assoc :tweet-count (+ (:tweet-count old) (count tweets)))
-                                   ;; this doesn't work
-                                   #_(update-in :tweet-count #(+ % (count tweets))))))
-         (send-tweets (:functions @state) tweets))))
+    (do  (swap! state update-state new-max tweets)
+         (send-tweets (:new-tweets-listeners @state) tweets)
+         (send-tweets (:graph-update-listeners @state) (:graph @state)))))
 
 (defn register
-  "Register fn to be called with new tweets."
-  [f]
-  (swap! state (fn [old] (assoc old :functions (conj (:functions old) f)))))
+  "Register a function to be called when new data arrives specifying
+  the event to receive updates for. Events can be :new-tweets or :graph-update."
+  [event f]
+  (cond (= event :new-tweets) (add-listener :new-tweets-listeners f)
+        (= event :graph-update) (add-listener :graph-update-listeners f)))
 
 (defn search-tag
   "Get the current tag value from the page."
@@ -54,3 +106,34 @@
         (events/listen timer goog.Timer/TICK listener))))
 
 (poll)
+
+(comment
+
+  (parse-mentions {:text "What's up @sue and @larry"})
+  
+  (add-mentions {} "jim" ["sue"])
+  (add-mentions {"sue" {}} "jim" ["sue"])
+  
+  (def tweets [{:profile_image_url "url1"
+                :from_user "jim"
+                :text "I like cookies!"}
+               {:profile_image_url "url2"
+                :from_user "sue"
+                :text "Me to @jim."}
+               {:profile_image_url "url3"
+                :from_user "bob"
+                :text "You shouldn't eat so many cookies @sue"}
+               {:profile_image_url "url4"
+                :from_user "sam"
+                :text "@bob that was a cruel thing to say to @sue."}])
+  
+  (def graph (update-graph {} tweets))
+  
+  (num-mentions (get graph "sue"))
+  (num-mentions (get graph "bob"))
+  (num-mentions (get graph "sam"))
+  
+  (take 1 (reverse (sort-by #(num-mentions (second %)) (seq graph))))
+  
+  )
+

samples/twitterbuzz/src/twitterbuzz/leaderboard.cljs

@@ -0,0 +1,42 @@
+(ns twitterbuzz.leaderboard
+  (:require [twitterbuzz.core :as buzz]
+            [goog.dom :as dom]))
+
+(defn dom-element [element attrs]
+  (dom/createDom element
+                 (.strobj (reduce (fn [m [k v]]
+                                    (assoc m k v))
+                                  {}
+                                  (map #(vector (name %1) %2) (keys attrs) (vals attrs))))))
+
+(defn add-leaderboard-node [node]
+  (let [user (first node)
+        user-info (second node)
+        parent (dom/getElement "leaderboard-content")
+        child (dom-element "div" {:class "tweet"})
+        user-e (dom-element "div" {:class "user-name"})
+        text (dom-element "div" {:class "tweet-text"})
+        pic (dom-element "img" {:src (:image-url user-info) :class "profile-pic"})
+        num-mentions (dom-element "div")]
+    (do (dom/setTextContent text (:last-tweet user-info))
+        (dom/setTextContent user-e user)
+        (dom/setTextContent num-mentions (str (buzz/num-mentions user-info)))
+        (dom/appendChild child pic)
+        (dom/appendChild child user-e)
+        (dom/appendChild child text)
+        (dom/appendChild child num-mentions)
+        (dom/appendChild parent child 0))))
+
+(defn clear-leaderboard []
+  (let [parent (dom/getElement "leaderboard-content")]
+    (do (dom/removeChildren parent))))
+
+(defn top-n [n nodes]
+  (reverse (sort-by #(buzz/num-mentions (second %)) nodes)))
+
+(defn update-leaderboard [graph]
+  (do (clear-leaderboard)
+      (doseq [next-node (top-n 10 (seq graph))]
+        (add-leaderboard-node next-node))))
+
+(buzz/register :graph-update update-leaderboard)

samples/twitterbuzz/src/twitterbuzz/timeline.cljs

@@ -39,4 +39,4 @@
             (do (add-timeline-tweet (first tweets))
                 (recur (rest tweets))))))))
 
-(core/register update-timeline)
+(core/register :new-tweets update-timeline)