example of ring, compojure and hiccup

live.clj

(use 'ring.util.response
     'ring.adapter.jetty)


;;;;; handler
(defn hello-handler [req] 
  (-> 
   (response "Hello")
   (content-type "text/html")))

(hello-handler {:uri "/index"})

(def s (run-jetty hello-handler {:port 8080 :join? false}))
(.stop s)
;;(.start s)
;;http://localhost:8080/


(-> "a b c d" 
           .toUpperCase 
           (.replace "A" "X") 
           (.split " ") 
           first)

(defn wrap-do-nothing [handler]
  (fn [req] 
    (handler req)))

(wrap-do-nothing hello-handler)

((wrap-do-nothing hello-handler) {:uri "index"})


;(run-jetty (wrap-do-nothing hello-handler) {:port 3001 })
(def s (run-jetty (wrap-do-nothing hello-handler) {:port 8080 :join? false}))

(defn wrap-add-header [handler]
  (fn [request]
      (let [resp (handler request)
            headers (:headers resp)]
        (assoc resp :headers 
               (assoc headers "X-Test" "My server!")))))

(defn name-handler [{params :params}]
 (response (str "Hello " (get params "name"))))
 
(def s (run-jetty name-handler {:port 8080 :join? false}))
;; http://localhost:8080/?name=tzach
(.stop s)

(use 'ring.middleware.params)
(def s (run-jetty (wrap-params name-handler) {:port 8080 :join? false}))
(.stop s)


(defn name-handler2 [{params :params}]
 (response (str "Hello " (:name params))))

(source wrap-keyword-params)

(use 'ring.middleware.keyword-params)
(def s (run-jetty 
        (-> name-handler2
            wrap-keyword-params
            wrap-params)
        {:port 8080 :join? false}))


;;;;; routing
(not-found "Page not found")

(defn route-handler [req]
  (case (:uri req)
    "/haifa" (response "hello Haifa")
    "/yagur" (response "hello Yagur")
    (not-found "Page not found")))

(route-handler {:uri "/haifa"})

(use 'compojure.core)

(def haifa-route
  (GET "/haifa" request "hello Haifa"))

(haifa-route {:uri "/haifa" :request-method :get})
;; {:status 200, :headers {"Content-Type" "text/html; charset=utf-8"}, :body "hello Haifa"}

(haifa-route {:uri "/ibm" :request-method :get})
;; nil


(def all-routes
  (routes
   (GET "/haifa" _ "hello Haifa")
   (GET "/yagur" _ "hello Yagur")))

(all-routes {:uri "/haifa" :request-method :get})
;; {:status 200, :headers {"Content-Type" "text/html; charset=utf-8"}, :body "hello Haifa"}
(all-routes {:uri "/yagur" :request-method :get})
;; {:status 200, :headers {"Content-Type" "text/html; charset=utf-8"}, :body "blue"}
(all-routes {:uri "/tel aviv" :request-method :get})
;; nil

(defroutes all-routes
  (GET "/haifa" _ "hello Haifa")
  (GET "/yagur" _ "hello Yagur"))


(require '[compojure.route :as route])

(defroutes all-routes
   (GET "/haifa" _ "hello Haifa")
   (GET "/yagur" _ "hello Yagur")
   (route/not-found "sorry, no page found"))

(all-routes {:uri "/tel aviv" :request-method :get})
;; {:status 404, :headers {"Content-Type" "text/html; charset=utf-8"}, :body "sorry, no page found"}


;; Deconstruction
(require '[clojure.string :as str])

(defroutes all-routes
  (GET "/:location" [location]
       (str "hello " (str/capitalize location)))
  (route/not-found "sorry, no page found"))

(all-routes {:uri "/haifa" :request-method :get})

(defroutes all-routes
  (GET "/:location" [location]
       (str "hello " (str/capitalize location)))
  (GET "/:location/rev" [location]
       (str "hello " (->> location
                         reverse
                         (reduce str)
                         str/capitalize)))
  (route/not-found "sorry, no page found"))

(all-routes {:uri "/haifa/rev" :request-method :get})
;;{:status 200, :headers {"Content-Type" "text/html; charset=utf-8"}, :body "hello Afiah"}


(defroutes all-routes
  (context "/:location" [location]
           (GET "/" []
                (str "hello " (str/capitalize location)))
           (GET "/rev" []
                (str "hello " (->> location
                                   reverse
                                   (reduce str)
                                   str/capitalize))))
  (route/not-found "sorry, no page found"))


(all-routes {:uri "/haifa/rev" :request-method :get})

;;;;; Hiccup
(use 'hiccup.core)

; literals:
(html "Hello, world!")
(html 1)

(html [:p "Hello, world!"])
(html [:h1 "Hello," " world!"]
      [:p "Greetings from your computer!"])

(html [:div {:class "grid_8 alpha"}
          [:p "Trendy grid system time"]])

; => "<div class=\"grid_8 alpha\">
;<p>Trendy grid system time</p></div>"
 
; the same html using the CSS like shortcuts:
(html [:div.grid_8.alpha
       [:p "Trendy grid system time"]])

(html (interpose " " (range 5)))
    ; => "0 1 2 3 4"
     
(html [:ul (map (fn [name] [:li name])
                ["Croaker" "Raven" "Murgen" "One-Eye"])])
                                        ; "<ul><li>Croaker</li><li>Raven</li><li>Murgen</li><li>One-Eye</li></ul">

(use 'hiccup.page 'hiccup.form 'hiccup.element)
(defn example-elements []
  (html5
   [:header "elements"]
   [:body
    (ordered-list (map #(* 2 %) (range 1 6)))
    (unordered-list (map #(* 3 %) (range 1 3)))
    [:p (link-to "/index" "back")]
    [:p (link-to "http://google.com" "Google")]]
    ))

(example-elements)

(def s (run-jetty (fn [_] (response (example-elements))) {:port 8080 :join? false}))
(.stop s)

(defn example-form []
  (html5
   [:header "form element"]
   [:body
   [:p (label "check" "check") (check-box "check" true) (check-box "check" false) ]
   [:p (drop-down "drop" ["tzach" "yossi"] )]
   [:p (drop-down "drop" (range 1 5))]
   [:p
    (label "radio"  "radio")
    (radio-button 1 false 1)
    (radio-button 1 true 2)]
   [:p (text-area "test" "I'm a political text")]]
   ))

(def s (run-jetty (fn [_] (response (example-form))) {:port 8080 :join? false}))
(.stop s)