shopping_list: Rewrite, with better api & features

I explicitely spelled out the notion that you always have a grouping
method (for all articles) and a sorting method (within those groups).
You can now combine them as you wish with a nice combinator function.
Another features is that you can reverse both methods independently via
flags which is a nice thing.

Sorting/displaying prices and weights correctly is also handled, but I
am not yet sure whether I like the implementation. Another alternative
would be to keep all conversion out of the core api, but then the
rendering code would have to know about the current grouping method, so
there are advantages to it. This would be a great topic to talk about,
but then so many topics are when you're new to a language.

One thing that is missing as I am not sure whether I want that feature
is to sort groups individually. Technically it would be simple, but
would probably be confusing in a ui if the sorting method is not obvious.

All in all, it took me far longer than I expected, in part because I
realized so late that you would need two algorithms (group & sort). The
other part is that I hadn't really thought about handling units and how
to compare them. I solved it with a `defrecord` for now, but that is
probably going to change.

clj/shopping_list/shopping_list.clj

@@ -1,88 +0,0 @@
(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/core.clj

@@ -0,0 +1,80 @@
(ns shopping-list.core)
(defn map-map [f m]
  (into (empty m) (map (fn [[key val]]
                  [key (f val)])
                m)))
(defn sort-map
  ([m] (sort-map compare m))
  ([c m] (apply sorted-map-by c (reduce #(into %1 %2) (seq m)))))
(def default
  {:group (constantly :all-articles)
   :sort  :name})
(def category
  {:group :category
   :sort  :category})
(defn categorize-number [categories n]
  (last (filter #(< % n) (concat [0] categories [Double/POSITIVE_INFINITY]))))
(defrecord PriceInEuros [price-in-cents]
  Comparable
  (compareTo [this other-price]
             (compare price-in-cents (:price-in-cents other-price)))
  Object
  (toString [this]
            (if (< price-in-cents 100)
                   (str price-in-cents "ct")
                   (str (float (/ price-in-cents 100)) "€"))))
(defn pretty-price [price-in-cents] (str (PriceInEuros. price-in-cents)))
(def price
  {:group (comp #(PriceInEuros. %) #(categorize-number [50 100 250 500 1000] %) :price)
   :sort  :price})
(defrecord MetricWeight [weight-in-grams]
  Comparable
  (compareTo [this other-weight]
             (compare weight-in-grams (:weight-in-grams other-weight)))
  Object
  (toString [this]
            (if (< weight-in-grams 1000)
              (str weight-in-grams "g")
              (str (float (/ weight-in-grams 1000)) "kg"))))
(defn pretty-weight [price-in-grams] (str (MetricWeight. price-in-grams)))
(def weight
  {:group (comp #(MetricWeight. %) #(categorize-number [100 250 500 1000 2500 5000] %) :weight)
   :sort  :weight})
(def alphabet
  {:group (comp first :name)
   :sort  :name})
(defn ungroup [grouped-articles]
  (flatten (vals grouped-articles)))
(defn regroup [{:keys [group sort reverse-group reverse-sort]} grouped-articles]
  (let [articles   (ungroup grouped-articles)
        compare-fn (fn [reverse?] (if reverse? (comp - compare) compare))]
    (map-map #(sort-by sort (compare-fn reverse-sort) %)
             (sort-map (compare-fn reverse-group) (group-by group articles)))))
(defn combine [{group :group} {sort :sort}]
  {:group group
   :sort  sort})
(def example-articles
  (regroup default
    {:all-articles
       [{:name "spinach", :price 310, :weight 500, :category "vegetables"}
        {:name "apple", :price 230, :weight 1340, :category "vegetables"}
        {:name "onion bread", :price 179, :weight 1100, :category "baked goods"}
        {:name "soy pudding", :price 199, :weight 500, :category "sweeties"}
        {:name "gum hearts", :price 249, :weight 400, :category "sweeties"}]}))
(regroup (assoc alphabet :reverse-group false :reverse-sort true) example-articles)
(map str (keys (regroup price example-articles)))

clj/shopping_list/shopping_list/server.clj

@@ -1,5 +1,5 @@
(ns shopping-list.server
  (:require [shopping-list :as sl])
  (:require [shopping-list.core :as sl])
  (:use ring.util.response)
  (:use compojure.core)
  (:require [compojure.route :as route])
@@ -13,7 +13,7 @@
     [:ul
      (for [item group-items]
        (let [{:keys [name price weight category]} item]
          [:li (str name)]))]]))
          [:li (str name " (" (sl/pretty-price price) ", " (sl/pretty-weight weight) ", " category ")")]))]]))
(defn index []
  (html
@@ -23,7 +23,7 @@
     [: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)))]]]))
      (render-groups (sl/regroup (sl/combine sl/category sl/weight) sl/example-articles))]]]))
(defroutes shopping-list
  (GET "/" [] (index))