shopping_list: What, where and how much.

This version has the basic grouping (category, initial, price, weight)
in place but the frontend, the sorting and a storage backend are
lacking.

Dedicated to my little sister, thus intended to eventually demonstrate
at least the concepts to here and an exercise in creating beautiful
abstractions in a functional language.

At least one criterion is partly fulfilled: it's a simple solution and
so far it works well. It's almost like an algebra which is quite
pleasing.

Well now, have fun, take care an' good night.

clj/shopping_list/project.clj

@@ -0,0 +1,13 @@
(defproject shopping-list "0.0-SNAPSHOT"
  :description "A shopping list in Clojure & ClojureScript"
  :dependencies [[org.clojure/clojure "1.5.0"]
                 [ring "1.2.0-beta2"]
                 [compojure "1.1.5"]]
  :plugins [[lein-ring "0.8.3"]
            [lein-cljsbuild "0.3.0"]]
  :ring {:handler shopping-list.server/shopping-list}
  :cljsbuild {:builds [{:source-paths ["."]
                        :compiler {:output-to "js/shoppinglist.js"
                                   :optimizations :whitespace
                                   :pretty-print true}}]}
  :source-paths ["."])

clj/shopping_list/shopping_list.clj

@@ -0,0 +1,88 @@
(ns shopping-list
  (:use [clojure.core :as core])
  (:use [clojure.repl :as repl]))
(defn sort-map
  ([m] (sort-map compare m))
  ([c m] (apply sorted-map-by c (reduce #(into %1 %2) (seq m)))))
(def example-article
  (sort-map
    {:all-articles
       [{:name "spinach", :price 3.1, :weight 0.5, :category "vegetables"}
        {:name "apple", :price 2.3, :weight 1.34, :category "vegetables"}
        {:name "onion bread", :price 1.79, :weight 1.1, :category "baked goods"}
        {:name "soy pudding", :price 1.99, :weight 0.5, :category "sweeties"}
        {:name "gum hearts", :price 2.49, :weight 0.4, :category "sweeties"}]}))
(defn create []
  {:known_articles []
   :articles []
   :sort-method :default})
(defn mmap [f m]
  (into (sorted-map) (map (fn [[key val]]
                  [key (f val)])
                m)))
(defn sort-by [key-or-keyfn grouped-articles]
  (mmap #(core/sort-by key-or-keyfn %) grouped-articles))
(def sort-by-category
  (partial sort-by :category))
(sort-by-category {:expensive-things
                     [{:category "a" :n 1}, {:category "b" :n 2} {:category "c" :n 3}]
                   :cheap-things
                     [{:category "d" :n 4}, {:category "a" :n 5}]})
(defn regroup-by [key-or-keyfn grouped-articles]
  (sort-map
    (group-by key-or-keyfn (flatten (vals grouped-articles)))))
(defn first-char-of-name [article]
  (first (:name article)))
(def group-by-name
  (partial mmap #(group-by first-char-of-name)))
(def regroup-by-name
  (partial regroup-by first-char-of-name))
(def group-by-category
  (partial mmap #(group-by :category %)))
(def regroup-by-category
  (partial regroup-by :category))
(defn categorize-by-price [article]
  (let [price (:price article)]
    (condp >= price ; (> x price)
      0.5 "<0.5$"
      1 "<1$"
      2.5 "<2.5$"
      5 "<5$"
      10 "<10$"
      (Integer/MAX_VALUE) ">10$")))
(def group-by-price
  (partial mmap #(group-by categorize-by-price %)))
(def regroup-by-price
  (partial regroup-by categorize-by-price))
(defn categorize-by-weight [article]
  (let [weight (:weight article)]
    (condp >= weight
      0.1 "<100g"
      0.25 "<250g"
      0.5 "<500g"
      1 "<1kg"
      2.5 "<2.5kg"
      5 "<5kg"
      (Integer/MAX_VALUE) ">5kg")))
(def group-by-weight
  (partial mmap #(group-by categorize-by-weight %)))
(def regroup-by-weight
  (partial regroup-by categorize-by-weight))

clj/shopping_list/shopping_list/server.clj

@@ -0,0 +1,30 @@
(ns shopping-list.server
  (:require [shopping-list :as sl])
  (:use ring.util.response)
  (:use compojure.core)
  (:require [compojure.route :as route])
  (:use hiccup.core))
(defn render-groups [groups]
  (for [[group-name group-items] groups]
    [:div
     [:h2 (str group-name)]
     [:ul
      (for [item group-items]
        (let [{:keys [name price weight category]} item]
          [:li (str name)]))]]))
(defn index []
  (html
   [:html
    [:head [:title "BUY ALL THE THINGS"]]
    [:body
     [:div {:id "main"}
      [:h1 "Hi there"]
      [:p "Mhh yeah, what's up?"]
      (render-groups (sl/sort-map (comp identity compare) (sl/regroup-by-name sl/example-articles)))]]]))
(defroutes shopping-list
  (GET "/" [] (index))
  (route/not-found "<h1>oops. alternate reality monsters</h1>"))