Kata: Word wrap in Clojure

Last night I did the Word Wrap kata in Clojure.

It was proposed in the last Barcelona Software Craftsmanship coding dojo but I couldn't attend, so I did it at home.

These are the tests using Midje:

	(ns word-wrap.core-test
	(:use midje.sweet)
	(:use [word-wrap.core]))
	(facts
	"about wrapping words"
	(fact
	"a text that fits in the given columns number are not wrapped"
	(wrap "koko koko" 9) => "koko koko"
	(wrap "ko" 9) => "ko"
	(wrap "" 9) => "")
	(fact
	"a text without spaces that doesn't fit in the given columns number are wrapped"
	(wrap "kokokoko" 4) => "koko\nkoko")
	(fact
	"a text with spaces that doesn't fit in the given columns number are wrapped
	at the space that is closest to the maximum column"
	(wrap "koko koko" 7) => "koko\nkoko"
	(wrap "koko koko koko" 12) => "koko koko\nkoko"
	(wrap "koko koko koko koko koko koko" 12) => "koko koko\nkoko koko\nkoko koko"
	(wrap
	"This koko should be easy unless there are hidden, or not so hidden, obstacles. Let's start!"
	12) => "This koko\nshould be\neasy unless\nthere are\nhidden, or\nnot so\nhidden,\nobstacles.\nLet's start!")
	(fact
	"a text already splitted in lines gets each of its lines re-wrapped"
	(wrap
	"kokokoko\nkaka koko\nkoko koko"
	6) => "kokoko\nko\nkaka\nkoko\nkoko\nkoko"))

view raw word_wrap_tests.clj hosted with ❤ by GitHub

and this is the resulting code:

	(ns word-wrap.core
	(:require [clojure.string :as string]))
	(def ^:private to-trimmed-string
	(comp string/trim (partial apply str)))
	(def ^:private rest-of-line
	(comp to-trimmed-string (partial drop)))
	(defn- wrap-line-at [index line]
	(str (to-trimmed-string (take index line)) \newline))
	(defn- index-of-last-fitting-space [max-columns line]
	(.lastIndexOf (take max-columns line) \space))
	(def ^:private valid-index? pos?)
	(defn- compute-wrapping-index [line max-columns]
	(let [index (index-of-last-fitting-space max-columns line)]
	(if (valid-index? index)
	index
	max-columns)))
	(defn- fits? [line max-columns]
	(<= (count line) max-columns))
	(defn- line->wrapped-lines [wrapped-lines line max-columns]
	(if (fits? line max-columns)
	(conj wrapped-lines line)
	(let [index (compute-wrapping-index line max-columns)]
	(recur (conj wrapped-lines (wrap-line-at index line))
	(rest-of-line index line)
	max-columns))))
	(defn- wrap-line [line max-columns]
	(apply str (line->wrapped-lines [] line max-columns)))
	(defn- extract-lines [text]
	(string/split text #"\n"))
	(def ^:private join-lines (partial string/join \newline))
	(defn wrap [text max-columns]
	(->> text
	extract-lines
	(map #(wrap-line % max-columns))
	join-lines))

view raw word_wrap.clj hosted with ❤ by GitHub

As usual I used a mix of TDD and REPL-driven development committing after each green and each refactoring. I also committed the REPL history. See all the commits here to follow the process.

Once I got to a tail recursive solution, I tried to make it more readable by extracting some explanatory helpers and working in the naming of bindings, functions and function arguments.

You can find all the code in GitHub.