Kata: Gilded Rose in Clojure (III) -> Updating conjured items by decoration

After the two previous posts (Clarifying conditional logic and Replacing conditional with polymorphism using multimethods), I had this version of the code:

	(ns gilded-rose.item-quality)
	(defn- update-quality [item value]
	(merge item {:quality value}))
	(defn- increase-quality [{:keys [quality] :as item} times]
	(update-quality item (min 50 (reduce + quality (repeat times 1)))))
	(defn- decrease-quality [{:keys [quality] :as item} times]
	(update-quality item (max 0 (reduce - quality (repeat times 1)))))
	(defn- set-quality-to-zero [{:keys [quality] :as item}]
	(update-quality item 0))
	(defn- after-selling-date? [{sell-in :sell-in}]
	(< sell-in 0))
	(defn- ten-or-more-days-to-selling-date? [{sell-in :sell-in}]
	(>= sell-in 10))
	(defn- between-days-to-selling-date? [lower higher {sell-in :sell-in}]
	(and (>= sell-in lower) (< sell-in higher)))
	(defn- update-regular-item-quality [item]
	(if (after-selling-date? item)
	(decrease-quality item 2)
	(decrease-quality item 1)))
	(defmulti update :name)
	(defmethod update :default [item]
	item)
	(defmethod update "Aged Brie" [item]
	(increase-quality item 1))
	(defmethod update "Backstage passes to a TAFKAL80ETC concert" [item]
	(cond
	(ten-or-more-days-to-selling-date? item) (increase-quality item 1)
	(between-days-to-selling-date? 5 10 item) (increase-quality item 2)
	(between-days-to-selling-date? 0 5 item) (increase-quality item 3)
	(after-selling-date? item) (set-quality-to-zero item)
	:else item))
	(defmethod update "+5 Dexterity Vest" [item]
	(update-regular-item-quality item))
	(defmethod update "Elixir of the Mongoose" [item]
	(update-regular-item-quality item))

view raw gilded-rose.item-quality.clj hosted with ❤ by GitHub

that was being used from the gilded-rose.core name space:

	(ns gilded-rose.core
	(:require [gilded-rose.item-quality :refer [update]]))
	(defn- degradable-item? [{name :name}]
	(not= "Sulfuras, Hand of Ragnaros" name))
	(defn- age-one-day [{sell-in :sell-in :as item}]
	(merge item {:sell-in (dec sell-in)}))
	(def ^:private all-age-one-day
	(partial map #(if (degradable-item? %) (age-one-day %) %)))
	(defn update-quality [items]
	(map update (all-age-one-day items)))
	(defn item [item-name, sell-in, quality]
	{:name item-name, :sell-in sell-in, :quality quality})
	(defn update-current-inventory[]
	(let [inventory
	[(item "+5 Dexterity Vest" 10 20)
	(item "Aged Brie" 2 0)
	(item "Elixir of the Mongoose" 5 7)
	(item "Sulfuras, Hand of Ragnaros" 0 80)
	(item "Backstage passes to a TAFKAL80ETC concert" 15 20)]]
	(update-quality inventory)))

view raw gilded-rose.core.clj hosted with ❤ by GitHub

Then I started introducing the new conjured items functionality using TDD.

These are the new tests for conjured items:

	#...
	#...
	(facts
	"Conjured items"
	(fact
	"Quality decreases by two each day before sell date"
	(pass-days
	2
	[(item "Conjured Elixir of the Mongoose" 17 20)])
	=> [(item "Conjured Elixir of the Mongoose" 15 16)])
	(fact
	"Quality decreases by four each day after sell date"
	(pass-days
	2
	[(item "Conjured Elixir of the Mongoose" 0 20)])
	=> [(item "Conjured Elixir of the Mongoose" -2 12)])
	(fact
	"Quality can't be less than zero"
	(pass-days
	1
	[(item "Conjured Elixir of the Mongoose" 2 1)])
	=> [(item "Conjured Elixir of the Mongoose" 1 0)])
	(fact
	"Conjured Sulfuras is still immutable"
	(pass-days
	1
	[(item "Conjured Sulfuras, Hand of Ragnaros" 0 80)])
	=> [(item "Conjured Sulfuras, Hand of Ragnaros" 0 80)])
	(fact
	"Conjured Aged Brie quality increases by two eachs day before sell date"
	(pass-days
	2
	[(item "Conjured Aged Brie" 2, 0)])
	=> [(item "Conjured Aged Brie" 0 4)])
	(fact
	"Conjured Aged Brie quality also increases by two eachs day after sell date"
	(pass-days
	2
	[(item "Conjured Aged Brie" 0, 0)])
	=> [(item "Conjured Aged Brie" -2 4)])
	(fact
	"Quality can't be greater than 50"
	(pass-days
	100
	[(item "Conjured Aged Brie" 100, 0)])
	=> [(item "Conjured Aged Brie" 0 50)])
	(fact
	"Conjured Backstage Passes quality increases twice faster before sell date"
	(pass-days
	15
	[(item "Conjured Backstage passes to a TAFKAL80ETC concert" 15, 0)])
	=> [(item "Conjured Backstage passes to a TAFKAL80ETC concert" 0 50)])
	(fact
	"Conjured Backstage Passes quality is zero after sell date"
	(pass-days
	16
	[(item "Conjured Backstage passes to a TAFKAL80ETC concert" 15, 0)])
	=> [(item "Conjured Backstage passes to a TAFKAL80ETC concert" -1 0)])))

view raw conjured-items-tests.clj hosted with ❤ by GitHub

and these is the resulting code of the gilded-rose.item-quality name space:

	(ns gilded-rose.item-quality)
	(defn- update-quality [item value]
	(assoc item :quality value))
	(defn- increase-quality [{:keys [quality] :as item} times]
	(update-quality item (min 50 (reduce + quality (repeat times 1)))))
	(defn- decrease-quality [{:keys [quality] :as item} times]
	(update-quality item (max 0 (reduce - quality (repeat times 1)))))
	(defn- set-quality-to-zero [item]
	(update-quality item 0))
	(defn- after-selling-date? [{sell-in :sell-in}]
	(< sell-in 0))
	(defn- ten-or-more-days-to-selling-date? [{sell-in :sell-in}]
	(>= sell-in 10))
	(defn- between-days-to-selling-date? [lower higher {sell-in :sell-in}]
	(and (>= sell-in lower) (< sell-in higher)))
	(defn- type-of-item [{name :name}]
	(let [item-types-by-name
	{"Aged Brie" :aged-brie
	"Backstage passes to a TAFKAL80ETC concert" :backstage-pass
	"+5 Dexterity Vest" :regular-item
	"Elixir of the Mongoose" :regular-item}]
	(if (.contains name "Conjured")
	:conjured
	(item-types-by-name name))))
	(defmulti update type-of-item)
	(defmethod update :conjured [{name :name :as item}]
	(let
	[not-conjured-item-name (clojure.string/replace name #"Conjured " "")
	not-conjured-item (assoc item :name not-conjured-item-name)]
	(assoc (update (update not-conjured-item))
	:name name)))
	(defmethod update :default [item]
	item)
	(defmethod update :aged-brie [item]
	(increase-quality item 1))
	(defmethod update :backstage-pass [item]
	(cond
	(ten-or-more-days-to-selling-date? item) (increase-quality item 1)
	(between-days-to-selling-date? 5 10 item) (increase-quality item 2)
	(between-days-to-selling-date? 0 5 item) (increase-quality item 3)
	(after-selling-date? item) (set-quality-to-zero item)
	:else item))
	(defmethod update :regular-item [item]
	(if (after-selling-date? item)
	(decrease-quality item 2)
	(decrease-quality item 1)))

view raw gilded-rose.item-quality-with-cojured.clj hosted with ❤ by GitHub

Notice the change in the update multimethod dispatch function. Now instead of being :name as before, it's the function type-of-item that returns the dispatch value :conjured if the item is a conjured one (i. e., if its name contains "Conjured"), or the type of item corresponding to each item name otherwise (which it looks up in the item-types-by-name map).

I also added a defmethod for the :conjured dispatch values which decorates update by calling it twice passing the not conjured version of the item and modified the other defmethod functions to use the type of item instead of its name. This made possible a better way of removing the duplication for regular items than the previous update-regular-item-quality private function.

This simple decoration made all the tests shown before pass, except the "Conjured Sulfuras is still immutable" one. For this test to pass I had to modify the degradable-item? query in the gilded-rose.core name space:

	(ns gilded-rose.core
	(:require [gilded-rose.item-quality :refer [update]]))
	(defn- degradable-item? [{name :name}]
	(not (.contains name "Sulfuras, Hand of Ragnaros")))
	(defn- age-one-day [{sell-in :sell-in :as item}]
	(merge item {:sell-in (dec sell-in)}))
	(def ^:private all-age-one-day
	(partial map #(if (degradable-item? %) (age-one-day %) %)))
	(defn update-quality [items]
	(map update (all-age-one-day items)))
	(defn item [item-name, sell-in, quality]
	{:name item-name, :sell-in sell-in, :quality quality})
	(defn update-current-inventory[]
	(let [inventory
	[(item "+5 Dexterity Vest" 10 20)
	(item "Aged Brie" 2 0)
	(item "Elixir of the Mongoose" 5 7)
	(item "Sulfuras, Hand of Ragnaros" 0 80)
	(item "Backstage passes to a TAFKAL80ETC concert" 15 20)]]
	(update-quality inventory)))

view raw gilded-rose.core-with-cojured.clj hosted with ❤ by GitHub

That's all. You can follow the whole process I've just described having a look at the commits I did after every small refactoring (look at commits from Conjured items quality decreases by two each day before sell date on)

Starting from the polymorphic version of update, we had got through refactoring, made it easy to add the new conjured items functionality as a decoration of update.

Compare this Clojure version of Gilded Rose with the Java version I did some time ago.

This is the last post in this series about the Gilded Rose kata in Clojure:

1. Clarifying conditional logic
2. Replacing conditional with polymorphism using multimethods
3. Updating conjured items by decoration