Kata: String Calculator in Clojure

Last week we started working on the String Calculator kata at the Clojure Developers Barcelona meetup.

Finally, this week I found some time to finish it.

These are the tests using Midje:

	(ns string-calculator.core-test
	(:use midje.sweet)
	(:use [string-calculator.core]))
	(facts
	"about string-calculator"
	(fact
	"It returns 0 for an empty string"
	(add "") => 0)
	(fact
	"It returns the number itself when the string contains only a number"
	(add "1") => 1
	(add "2") => 2)
	(fact
	"It adds strings containing several numbers separated by commas"
	(add "1,2") => 3
	(add "1,2,3") => 6)
	(fact
	"It adds numbers separated by new lines and/or commas"
	(add "1\n2,3") => 6)
	(fact
	"It can also use any given delimiter"
	(add "//;\n1;2,3") => 6)
	(fact
	"It throws and exception when trying to add negative numbers"
	(add "1,-2,3,-4") => (throws Exception
	"Detected negative numbers: -2, -4"))
	(fact
	"It ignores any number greater than 1000"
	(add "4,5,1001,3") => 12)
	(fact
	"It can use delimiters of any length"
	(add "//[***]\n1***2***3") => 6)
	(fact
	"It can use multiple delimiters of any length"
	(add "//[***][%%]\n1***2%%3,4") => 10))

view raw string-calculator-tests.clj hosted with ❤ by GitHub

The resulting code which is divided in several name spaces.

The string-calculator.core name space:

	(ns string-calculator.core
	(:require [string-calculator.numbers-parser :as numbers-parser]
	[string-calculator.numbers-validation :as numbers-validation]
	[string-calculator.numbers-filter :as numbers-filter]))
	(def ^:private sum (partial apply +))
	(defn add [input-str]
	(-> input-str
	numbers-parser/parse
	numbers-validation/validate
	numbers-filter/remove-too-big-numbers
	sum))

view raw string-calculatorcore.clj hosted with ❤ by GitHub

The string-calculator.numbers-parser which is where most of the logic lives:

	(ns string-calculator.numbers-parser
	(:require [clojure.string :as string]))
	(def ^:private default-delimiters ["," "\n"])
	(def ^:private escaped-chars-by-metachar
	(let [esc-chars "()*&^%$#!"]
	(zipmap esc-chars
	(map #(str "\\" %) esc-chars))))
	(defn- escape-meta-characters [delimiters-str]
	(reduce str (map #(get escaped-chars-by-metachar % %)
	delimiters-str)))
	(defn- get-matches [pattern string]
	(mapcat (partial drop 1) (re-seq pattern string)))
	(defn- extract-delimiters [delimiters-str]
	(let [delimiters (get-matches #"\[(.*?)\]" delimiters-str)]
	(if (empty? delimiters)
	delimiters-str
	delimiters)))
	(defn- create-delimiters-pattern [delimiters-str]
	(->> delimiters-str
	extract-delimiters
	(concat default-delimiters)
	(string/join "|")
	escape-meta-characters
	re-pattern))
	(defn- numbers-and-delimiters-pattern [input]
	(let [delimiters-and-numbers (get-matches #"//(.+)\n(.*)" input)]
	[(or (second delimiters-and-numbers) input)
	(create-delimiters-pattern
	(or (first delimiters-and-numbers) ""))]))
	(defn- extract-nums-str [input-str]
	(apply string/split
	(numbers-and-delimiters-pattern input-str)))
	(defn parse [input-str]
	(if (string/blank? input-str)
	[0]
	(map #(Integer/parseInt %)
	(extract-nums-str input-str))))

view raw numbers_parser.clj hosted with ❤ by GitHub

The string-calculator.numbers-validation name space:

	(ns string-calculator.numbers-validation)
	(def ^:private any-negative?
	(partial not-every? #(>= % 0)))
	(defn- throw-negative-numbers-exception [numbers]
	(throw
	(Exception.
	(str "Detected negative numbers: "
	(clojure.string/join ", " (filter neg? numbers))))))
	(defn validate [numbers]
	(if (any-negative? numbers)
	(throw-negative-numbers-exception numbers)
	numbers))

view raw numbers_validation.clj hosted with ❤ by GitHub

Finally, the string-calculator.numbers-filter name space:

	(ns string-calculator.numbers-filter)
	(defn remove-too-big-numbers [numbers]
	(remove #(> % 1000) numbers))

view raw numbers_filter.clj hosted with ❤ by GitHub

I used a mix of TDD and REPL-driven development to code it.

To document the process I committed the code after every passing test and every refactoring.

This time I didn't commit the REPL history because I used Cursive and I didn't find how to save it. Apart from that, I really enjoyed the experience of using Cursive.

You can find the commits step by step here and the code in this repository in GitHub.