added string-to-rule function; rules are stored as binary strings

src/automata/core.cljs

@@ -1,18 +1,19 @@
 (ns automata.core
-  (:require [reagent.core :as reagent :refer [atom]]))
+  (:require [reagent.core :as reagent :refer [atom]]
+            [automata.rules]))
 
 (enable-console-print!)
 
-(println "This text is printed from src/automata/core.cljs. Go ahead and edit it and see reloading in action.")
-
 ;; define your app data so that it doesn't get over-written on reload
+(defonce app-state (atom {
+                          :text "Hello world!"
+                          :rule "01101110"
+                          }))
 
-(defonce app-state (atom {:text "Hello world!"}))
-
-(defn hello-world []
-  [:h1 (:text @app-state)])
+(defn App []
+  [:div "hi"])
 
-(reagent/render-component [hello-world]
+(reagent/render-component [App]
                           (. js/document (getElementById "app")))
 
 (defn on-js-reload []

src/automata/rules.cljs

@@ -1,19 +1,37 @@
+(ns automata.rules)
 
+(def rule-order [
+                 [true true true]
+                 [true true false]
+                 [true false true]
+                 [true false false]
+                 [false true true]
+                 [false true false]
+                 [false false true]
+                 [false false false]
+                 ])
 
-(defn temp-rule [one two three] true)
+(def preset-rules {
+                   :110 "01101110"
+                   })
+
+(def string-to-rule
+  (memoize (fn [binary-string]
+             (let [bools (map #(if (= % "1") true false) binary-string)
+                   cases (zipmap rule-order bools)]
+               (fn [one two three] (cases [one two three]))))))
 
 (defn proc
-  ([line]
+  ([line rule]
    (if (empty? line)
      []
-     (proc false (first line) (second line) (drop 2 line) [])))
-  ([one two three r acc]
-     (let [rule temp-rule]
-       (if (nil? two)
-         (conj acc (rule false one false))
-         (if (nil? three)
-           (conj acc (rule one two false))
-           (proc two three (first r) (rest r) (conj acc (rule one two three))))))))
+     (proc rule false (first line) (second line) (drop 2 line) [])))
+  ([rule one two three r acc]
+   (if (nil? two)
+     (conj acc (rule false one false))
+     (if (nil? three)
+       (conj acc (rule one two false))
+       (proc rule two three (first r) (rest r) (conj acc (rule one two three)))))))