Merging from the official book repository

Author: abedra

.gitignore

@@ -1,4 +1,3 @@
-
 /Programming-Clojure.iml
 /build.clj
 /hello.out

classes/examples/tasklist.class

@@ -0,0 +1 @@
+web: lein run

classes/examples/tasklist__init.class

@@ -0,0 +1,17 @@
+# clojurebreaker
+
+A website written in noir. 
+
+## Usage
+
+```bash
+lein deps
+lein run
+```
+
+## License
+
+Copyright (C) 2011 FIXME
+
+Distributed under the Eclipse Public License, the same as Clojure.
+

clojurebreaker/Procfile

@@ -0,0 +1,9 @@
+; START: clojurebreaker-project
+(defproject clojurebreaker "0.1.0-SNAPSHOT"
+            :description "Clojurebreaker game for Programming Clojure 2nd Edition"
+            :dependencies [[org.clojure/clojure "1.3.0"]
+                           [org.clojure/math.combinatorics "0.0.1"]
+                           [org.clojure/test.generative "0.1.3"]
+                           [noir "1.2.0"]]
+            :main clojurebreaker.server)
+; END: clojurebreaker-project

clojurebreaker/README.md

@@ -0,0 +1,57 @@
+html {
+	margin:0;
+	padding:0;
+	border:0;
+}
+
+body, div, span, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+a, abbr, acronym, address, code,
+del, dfn, em, img, q, dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, dialog, figure, footer, header,
+hgroup, nav, section {
+	margin: 0;
+	padding: 0;
+	border: 0;
+	font-weight: inherit;
+	font-style: inherit;
+	font-size: 100%;
+	font-family: inherit;
+	vertical-align: baseline;
+}
+
+article, aside, dialog, figure, footer, header,
+hgroup, nav, section {
+	display:block;
+}
+
+body {
+	line-height: 1.5;
+	background: white;
+}
+
+table {
+	border-collapse: separate;
+	border-spacing: 0;
+}
+
+caption, th, td {
+	text-align: left;
+	font-weight: normal;
+	float:none !important;
+}
+table, th, td {
+	vertical-align: middle;
+}
+
+blockquote:before, blockquote:after, q:before, q:after { content: ''; }
+blockquote, q { quotes: "" ""; }
+
+a img { border: none; }
+
+/*:focus { outline: 0; }*/
+
+
+

clojurebreaker/project.clj

@@ -0,0 +1,25 @@
+;; this file contains the intermediate steps in building the
+;; Clojurebreaker game. See the clojurebreaker/src directory for the
+;; completed code.
+
+; START:exact-matches-shell
+(defn exact-matches
+  "Given two collections, return the number of positions where
+   the collections contain equal items."
+  [c1 c2])
+; END:exact-matches-shell
+
+; START:integers-closed
+(defspec closed-under-addition
+  +'
+  [^long a ^long b]
+  (assert (integer? %)))
+; END:integers-closed
+
+; START:incorrect-spec
+(defspec incorrect-spec
+  +'
+  [^long a ^long b]
+  (assert (< a %))
+  (assert (< b %)))
+; END:incorrect-spec

clojurebreaker/resources/public/css/reset.css

@@ -0,0 +1,70 @@
+(ns clojurebreaker.game
+  (:use clojure.pprint)
+  (:require [clojure.data :as data]
+            [clojure.math.combinatorics :as comb]
+            [clojure.java.io :as io]))
+
+;; START:exact-matches
+(defn exact-matches
+  "Given two collections, return the number of positions where
+   the collections contain equal items."
+  [c1 c2]
+  (let [[_ _ matches] (data/diff c1 c2)]
+    (count (remove nil? matches))))
+;; END:exact-matches
+
+;; START:unordered-matches
+(defn unordered-matches
+  "Given two collections, return a map where each key is an item
+   in both collections, and each value is the number of times the
+   value occurs in the collection with fewest occurrences."
+  [c1 c2]
+  (let [f1 (select-keys (frequencies c1) c2)
+        f2 (select-keys (frequencies c2) c1)]
+    (merge-with min f1 f2)))
+;; END:unordered-matches
+
+;; START:score
+(defn score
+  [c1 c2]
+  (let [exact (exact-matches c1 c2)
+        unordered (apply + (vals (unordered-matches c1 c2)))]
+    {:exact exact :unordered (- unordered exact)}))
+;; END: score
+
+;; START: generate-turn-inputs
+(defn generate-turn-inputs
+  "Generate all possible turn inputs for a clojurebreaker game
+   with colors and n columns"
+  [colors n]
+  (-> (comb/selections colors n)
+      (comb/selections 2)))
+;; END: generate-turn-inputs
+
+;; START: score-inputs
+(defn score-inputs
+  "Given a sequence of turn inputs, return a lazy sequence of
+   maps with :secret, :guess, and :score."
+  [inputs]
+  (map
+   (fn [[secret guess]]
+     {:secret (seq secret)
+      :guess (seq guess)
+      :score (score secret guess)})
+   inputs))
+;; END: score-inputs
+
+(->> (generate-turn-inputs [:r :g :b] 2)
+ (score-inputs))
+
+;; step 17 score-table
+#_(score-all-games [:R :G :B] 3)
+
+;; step 18 could check either the clj or the tabular form of score-all-games
+;; into source control and use it as a regression test
+;; (add clojure.java.io)
+(use 'clojure.pprint)
+(with-open [w (io/writer "scoring-table")]
+    (binding [*out* w]
+      (print-table (->> (generate-turn-inputs [:r :g :b :y] 4)
+                        (score-inputs)))))

clojurebreaker/scoring-table

@@ -0,0 +1,27 @@
+(ns clojurebreaker.models.game
+  (:require [clojure.data :as data]))
+
+(defn create []
+  (vec (repeatedly 4 (fn [] (rand-nth ["r" "g" "b" "y"])))))
+
+(defn exact-matches
+  "Given two collections, return the number of positions where
+   the collections contain equal items."
+  [c1 c2]
+  (let [[_ _ matches] (data/diff c1 c2)]
+    (count (remove nil? matches))))
+
+(defn unordered-matches
+  "Given two collections, return a map where each key is an item
+   in both collections, and each value is the number of times the
+   value occurs in the collection with fewest occurrences."
+  [c1 c2]
+  (let [f1 (select-keys (frequencies c1) c2)
+        f2 (select-keys (frequencies c2) c1)]
+    (merge-with min f1 f2)))
+
+(defn score
+  [c1 c2]
+  (let [exact (exact-matches c1 c2)
+        unordered (apply + (vals (unordered-matches c1 c2)))]
+    {:exact exact :unordered (- unordered exact)}))

clojurebreaker/snippets.clj

@@ -0,0 +1,11 @@
+(ns clojurebreaker.server
+  (:require [noir.server :as server]))
+
+(server/load-views "src/clojurebreaker/views/")
+
+(defn -main [& m]
+  (let [mode (keyword (or (first m) :dev))
+        port (Integer. (get (System/getenv) "PORT" "8080"))]
+    (server/start port {:mode mode
+                        :ns 'clojurebreaker})))
+

clojurebreaker/src/clojurebreaker/game.clj

@@ -0,0 +1,13 @@
+(ns clojurebreaker.views.common
+  (:use noir.core
+        hiccup.core
+        hiccup.page-helpers))
+
+(defpartial layout [& content]
+            (html5
+              [:head
+               [:title "Clojurebreaker"]
+               (include-css "/css/reset.css")]
+              [:body
+               [:div#wrapper
+                content]]))

clojurebreaker/src/clojurebreaker/models/game.clj

@@ -0,0 +1,43 @@
+(ns clojurebreaker.views.welcome
+  (:require [noir.session :as session]
+            [clojurebreaker.views.common :as common]
+            [clojurebreaker.models.game :as game])
+  (:use [noir.core :only (defpartial defpage render)]
+        [hiccup.form-helpers :only (form-to text-field submit-button)]))
+
+; START: clojurebreaker-partial
+(defpartial board [{:keys [one two three four exact unordered]}]
+  (when (and exact unordered)
+    [:div "Exact: " exact " Unordered: " unordered])
+  (form-to [:post "/guess"]
+           (text-field "one" one)
+           (text-field "two" two)
+           (text-field "three" three)
+           (text-field "four" four)
+           (submit-button "Guess")))
+; END: clojurebreaker-partial
+
+; START: clojurebreaker-page
+(defpage "/" {:as guesses} 
+  (when-not (session/get :game)
+    (session/put! :game (game/create)))
+  (common/layout (board (or guesses nil))))
+; END: clojurebreaker-page
+
+; START: clojurebreaker-post
+(defpage [:post "/guess"] {:keys [one two three four]}
+  (let [result (game/score (session/get :game) [one two three four])]
+    (if (= (:exact result) 4)
+      (do (session/remove! :game)
+          (common/layout
+           [:h2 "Congratulations, you have solved the puzzle!"]
+           (form-to [:get "/"]
+                    (submit-button "Start A New Game"))))
+      (do (session/flash-put! result)
+          (render "/" {:one one
+                       :two two
+                       :three three
+                       :four four
+                       :exact (:exact result)
+                       :unordered (:unordered result)})))))
+; END: clojurebreaker-post

clojurebreaker/src/clojurebreaker/server.clj

@@ -0,0 +1,43 @@
+;; START:invariants
+(ns clojurebreaker.game-test
+  (:use [clojure.test.generative :only (defspec) :as test])
+  (:require [clojure.test.generative.generators :as gen]
+            [clojurebreaker.game :as game]
+            [clojure.math.combinatorics :as comb]))
+
+(defn matches
+  "Given a score, returns total number of exact plus
+   unordered matches."
+  [score]
+  (+ (:exact score) (:unordered score)))
+
+(defn scoring-is-symmetric
+  [secret guess score]
+  (= score (game/score guess secret)))
+
+(defn scoring-is-bounded-by-number-of-pegs
+  [secret guess score]
+  (< 0 (matches score) (count secret)))
+(defn reordering-the-guess-does-not-change-matches
+  [secret guess score]
+  (= #{(matches score)}
+     (into #{} (map
+                #(matches (game/score secret %))
+                (comb/permutations guess)))))
+;; END:invariants
+
+;; START:random-secret
+(defn random-secret
+  []
+  (gen/vec #(gen/one-of :r :g :b :y) 4))
+;; END:random-secret
+
+;; START:score-invariants
+(defspec score-invariants
+  game/score
+  [^{:tag `random-secret} secret
+   ^{:tag `random-secret} guess]
+  (assert (scoring-is-symmetric secret guess %))
+  (assert (scoring-is-bounded-by-number-of-pegs secret guess %))
+  (assert (reordering-the-guess-does-not-change-matches secret guess %)))
+;; END:score-invariants