Merge branch 'laser'

project.clj

@@ -1,7 +1,7 @@
 (defproject refheap "1.4.0"
   :description "This is like, totally a pastebin, dude."
   :url "https://refheap.com"
-  :dependencies [[org.clojure/clojure "1.4.0"]
+  :dependencies [[org.clojure/clojure "1.5.0-RC16"]
                  [stencil "0.2.0"]
                  [compojure "1.1.3"]
                  [lib-noir "0.2.0"]
@@ -13,8 +13,7 @@
                  [me.raynes/conch "0.4.0"]
                  [commons-codec/commons-codec "1.6"]
                  [org.pegdown/pegdown "1.2.1"]
-                 [me.raynes/laser "0.1.5"]]
-  :plugins [[lein-ring "0.7.1"]]
-  :ring {:handler refheap.server/handler
-         :auto-reload? false})
+                 [me.raynes/laser "0.1.26"]]
+  :plugins [[lein-ring "0.8.2"]]
+  :ring {:handler refheap.server/handler})
 

src/refheap/utilities.clj

@@ -2,26 +2,6 @@
   (:require [refheap.models.paste :as paste]
             [clojure.string :refer [lower-case join]]))
 
-#_(defn regenerate
-  "Regenerates a paste's pygmentized text and preview text from
-  its raw-contents. This is useful for when a lexer fails (because
-  you typoed it in the language list) and you need to regenerate
-  after you've fixed it."
-  [id]
-  (let [paste (paste/get-paste id)
-        contents (:raw-contents paste)
-        lexer (-> paste
-                  :language
-                  paste/lookup-lexer
-                  second
-                  :short)]
-    (mongo/update!
-      :pastes
-      paste
-      (assoc paste
-             :contents (paste/pygmentize lexer contents)
-             :summary (paste/pygmentize lexer (paste/preview contents))))))
-
 (defn to-booleany
   "Convert numbers and various representations of 'true' and 'false'
    to their actual true or false counterparts."
@@ -44,4 +24,19 @@
    for passing to another programming language. Kind of like what
    pr-str does for strings but without the wrapper quotes."
   [s]
-  (join (map #(js-char-replacements % %) s)))
+  (join (map #(js-char-replacements % %) s)))
+
+(defn nil-comp
+  "Composes functions together just like `comp`, but stops and returns nil
+   if any of the functions in the composition return nil."
+  [& fns]
+  (let [fns (reverse fns)]
+    (fn [& args]
+      (let [[start & tail] fns]
+        (reduce
+         (fn [acc f]
+           (if (nil? acc)
+             (reduced nil)
+             (f acc)))
+         (apply start args)
+         tail)))))

src/refheap/views/about.clj

@@ -1,8 +1,6 @@
 (ns refheap.views.about
-  (:require [clojure.java.io :as io]
-            [refheap.views.common :refer [layout]]
+  (:require [refheap.views.common :refer [layout static]]
             [compojure.core :refer [defroutes GET]]))
 
 (defroutes about-routes
-  (GET "/about" []
-    (layout (slurp (io/resource "refheap/views/templates/about.mustache")))))
+  (GET "/about" [] (layout (static "refheap/views/templates/about.html"))))

src/refheap/views/api.clj

@@ -1,19 +1,24 @@
 (ns refheap.views.api
   (:require [noir.session :as session]
-            [stencil.core :as stencil]
+            [me.raynes.laser :as laser]
+            [clojure.java.io :refer [resource]]
             [refheap.models.api :as api]
             [refheap.models.paste :as paste]
             [refheap.models.users :as users]
             [compojure.core :refer [defroutes GET POST DELETE]]
-            [refheap.views.common :refer [layout]]))
+            [refheap.views.common :refer [layout static]]))
 
-(defn api-page []
-  (layout
-   (stencil/render-file
-    "refheap/views/templates/api"
-    {:logged (when-let [id (:id (session/get :user))]
-               {:token (api/get-token id)})})
-   {:file "refheap/views/templates/apihead"}))
+(let [nodes (laser/parse-fragment (resource "refheap/views/templates/api.html"))
+      api-head (static "refheap/views/templates/apihead.html")]
+  (defn api-page []
+    (layout
+     (if-let [id (:id (session/get :user))]
+       (laser/fragment nodes
+                       (laser/id= "tokentext") (laser/content (api/get-token id))
+                       (laser/id= "please-login") (laser/remove))
+       (laser/fragment nodes (laser/id= "token") (laser/remove)))
+     nil
+     api-head)))
 
 (defn generate-token []
   (when-let [id (:id (session/get :user))]

src/refheap/views/common.clj

@@ -1,38 +1,52 @@
 (ns refheap.views.common
   (:require [noir.session :as session]
-            [stencil.core :as stencil]
             [refheap.models.paste :as paste]
-            [clavatar.core :refer [gravatar]]))
+            [stencil.core :as stencil]
+            [clavatar.core :refer [gravatar]]
+            [me.raynes.laser :refer [defdocument defragment] :as l]
+            [clojure.java.io :refer [resource]]))
 
 (defn avatar [email size]
   (gravatar email :size size))
 
-(defn logged-in [username]
-  (stencil/render-file
-    "refheap/views/templates/loggedin"
-    {:user (when-let [user (or username
-                               (and (bound? #'session/*noir-session*)
-                                    (:username (session/get :user))))]
-             {:username user})}))
+(defn static [file]
+  (-> file resource slurp l/unescaped))
+
+(let [html (l/parse-fragment (resource "refheap/views/templates/loggedin.html"))
+      logged-out (static "refheap/views/templates/loggedout.html")]
+  (defn logged-in [username]
+    (let [user (or username
+                   (and (bound? #'session/*noir-session*)
+                        (:username (session/get :user))))]
+      (if user
+        (l/fragment html
+                    (l/id= "userbutton") (comp (l/attr :href (str "/users/" user))
+                                               (l/content user)))
+        logged-out))))
+
+(defragment head (resource "refheap/views/templates/head.html")
+  [title heads]
+  (l/id= "last-include") #(if heads [% heads] %)
+  (l/element= :title) (l/content (or title "Refheap")))
 
-(defn layout [body & [head]]
-  (stencil/render-file
-    "refheap/views/templates/common"
-    {:user (logged-in nil) 
-     :title (or (:title head) "RefHeap")
-     :content body
-     :head (when-let [head-file (:file head)]
-             (stencil/render-file head-file (dissoc head :file :title)))}))
+(defragment body (resource "refheap/views/templates/commonbody.html")
+  [contents]
+  (l/id= "useri") (l/content (logged-in nil))
+  (l/id= "container") (l/content contents))
 
-(defn body [contents]
-  (stencil/render-file
-   "refheap/views/templates/commonbody"
-   {:user (logged-in nil)
-    :content contents}))
+(let [html (l/parse (resource "refheap/views/templates/common.html"))]
+  (defn layout
+    ([content] (layout content "Refheap" nil))
+    ([content title] (layout content title nil))
+    ([content title heads]
+       (l/document
+        html
+        (l/element= :head) (l/content (head title heads)) 
+        (l/element= :body) (l/content (body content))))))
 
-(defn page-buttons [base n per page]
-  (stencil/render-file
-    "refheap/views/templates/pagination"
-    {:newer (when-not (= 1 page) {:base base, :page (dec page)})
-     :older (when-not (or (zero? n) (= page (paste/count-pages n per)))
-              {:base base, :page (inc page)})}))
+(defragment page-buttons (resource "refheap/views/templates/pagination.html")
+  [base n per page]
+  (l/id= "newer") #(when-not (= 1 page)
+                     (assoc-in % [:attrs :href] (str base "?page=" (dec page))))
+  (l/id= "older") #(when-not (or (zero? n) (= page (paste/count-pages n per)))
+                     (assoc-in % [:attrs :href] (str base "?page=" (inc page)))))

src/refheap/views/legal.clj

@@ -1,10 +1,7 @@
 (ns refheap.views.legal
-  (:require [clojure.java.io :as io]
-            [compojure.core :refer [defroutes GET]] 
-            [refheap.views.common :refer [layout]]))
+  (:require [compojure.core :refer [defroutes GET]] 
+            [refheap.views.common :refer [static layout]]))
 
 (defroutes legal-routes
-  (GET "/legal/tos" []
-    (layout (slurp (io/resource "refheap/views/templates/tos.mustache"))))
-  (GET "/legal/privacy" []
-    (layout (slurp (io/resource "refheap/views/templates/privacy.mustache")))))
+  (GET "/legal/tos" [] (layout (static "refheap/views/templates/tos.html")))
+  (GET "/legal/privacy" [] (layout (static "refheap/views/templates/privacy.html"))))

src/refheap/views/login.clj

@@ -4,14 +4,16 @@
             [noir.session :as session]
             [refheap.views.common :refer [body logged-in]]
             [compojure.core :refer [defroutes GET POST]]
-            [noir.response :refer [redirect json]]))
+            [noir.response :refer [redirect json]]
+            [clojure.java.io :refer [resource]]
+            [me.raynes.laser :as l]))
 
-(defn create-user-page [email]
-  (session/flash-put! :email email)
-  (stencil/render-file
-    "refheap/views/templates/createuser"
-    {:error (when-let [error (session/flash-get :error)]
-              {:message error})}))
+(let [html (-> "refheap/views/templates/createuser.html" resource l/parse-fragment)]
+  (defn create-user-page [email]
+    (session/flash-put! :email email)
+    (l/fragment html
+                (l/class= "error") #(when-let [error (session/flash-get :error)]
+                                      (l/on % (l/content error))))))
 
 (defn create-user [{:keys [name]}]
   (if-let [email (session/flash-get :email)]
@@ -27,8 +29,8 @@
   (when-let [{:keys [email]} (login/verify-assertion host assertion)]
     (json
      (if-let [username (login/user-exists email)]
-       {:login-html (logged-in username)}
-       {:chooselogin-html (body (create-user-page email))}))))
+       {:login-html (l/fragment-to-html (logged-in username))}
+       {:chooselogin-html (-> email create-user-page body l/fragment-to-html)}))))
 
 (defroutes login-routes
   (POST "/user/create" {:keys [params]}