Create compiler for strudel mini-notation

1 files changed, 159 insertions, 0 deletions

diff --git a/test/unheard/strudel/mini_notation_compiler_test.clj b/test/unheard/strudel/mini_notation_compiler_test.clj
new file mode 100644
index 0000000..04b6347
--- /dev/null
+++ b/test/unheard/strudel/mini_notation_compiler_test.clj
@@ -0,0 +1,159 @@
+(ns unheard.strudel.mini-notation-compiler-test
+  (:refer-clojure :exclude [compile])
+  (:require [clojure.test :refer [deftest is testing]]
+            [unheard.strudel.mini-notation-compiler :refer [compile]]))
+
+(deftest compile-tests
+  (testing "single atom"
+    (is (= :c
+           (compile "c"))))
+
+  (testing "rest literal"
+    (is (= :r
+           (compile "~"))))
+
+  (testing "simple sequence - space separated"
+    (is (= '(l :c :e :g)
+           (compile "c e g"))))
+
+  (testing "sequence with rest"
+    (is (= '(l :c :r :g)
+           (compile "c ~ g"))))
+
+  (testing "subdivision with brackets"
+    (is (= '(l :c (l :e :g) :b)
+           (compile "c [e g] b"))))
+
+  (testing "nested brackets"
+    (is (= '(l :a (l :b (l :c :d)))
+           (compile "a [b [c d]]"))))
+
+  (testing "angle brackets - alternation"
+    (is (= '(f :c :e :g :b)
+           (compile "<c e g b>"))))
+
+  (testing "parallel with commas"
+    (is (= '(p :c :e :g)
+           (compile "c,e,g"))))
+
+  (testing "parallel in sequence"
+    (is (= '(l (p :c :e :g) (p :d :f :a))
+           (compile "[c,e,g] [d,f,a]"))))
+
+  (testing "rate modifier - multiplication"
+    (is (= '(rate 2 :c)
+           (compile "c*2"))))
+
+  (testing "rate modifier - division"
+    (is (= '(rate (/ 1 2) :c)
+           (compile "c/2"))))
+
+  (testing "rate on group"
+    (is (= '(rate 2 (l :e :g))
+           (compile "[e g]*2"))))
+
+  (testing "rate on alternation"
+    (is (= '(rate 2 (f :c :e :g :b))
+           (compile "<c e g b>*2"))))
+
+  (testing "elongate modifier"
+    (is (= '(elongate 3 :c)
+           (compile "c@3"))))
+
+  (testing "elongate in sequence"
+    (is (= '(l (elongate 2 :a) :b :c)
+           (compile "a@2 b c"))))
+
+  (testing "replication modifier"
+    (is (= '(rep 3 :c)
+           (compile "c!3"))))
+
+  (testing "replication in sequence"
+    (is (= '(l (rep 2 :x) :y)
+           (compile "x!2 y"))))
+
+  (testing "multiple modifiers"
+    (is (= '(rate 2 (elongate 3 :c))
+           (compile "c@3*2"))))
+
+  (testing "complex nested structure"
+    (is (= '(l :c (f :e :g) :b :d)
+           (compile "c <e g> b d"))))
+
+  (testing "subdivision with parallel"
+    (is (= '(l :x (p :y :z) :w)
+           (compile "x [y,z] w"))))
+
+  (testing "strudel example from docs"
+    (is (= '(l :e5 (l :b4 :c5) :d5 (l :c5 :b4))
+           (compile "e5 [b4 c5] d5 [c5 b4]"))))
+
+  (testing "chord sequence"
+    (is (= '(rate 2 (f (p :g3 :b3 :e4) (p :a3 :c3 :e4)))
+           (compile "<[g3,b3,e4] [a3,c3,e4]>*2"))))
+
+  (testing "elongated chord"
+    (is (= '(rate 2 (f (elongate 2 (p :g3 :b3 :e4)) (p :a3 :c3 :e4)))
+           (compile "<[g3,b3,e4]@2 [a3,c3,e4]>*2"))))
+
+  (testing "replicated chord"
+    (is (= '(rate 2 (f (rep 2 (p :g3 :b3 :e4)) (p :a3 :c3 :e4)))
+           (compile "<[g3,b3,e4]!2 [a3,c3,e4]>*2"))))
+
+  (testing "rest in subdivision"
+    (is (= '(l :b4 (l :r :c5) :d5 :e5)
+           (compile "b4 [~ c5] d5 e5"))))
+
+  (testing "numbers as values"
+    (is (= '(l 1 2 3)
+           (compile "1 2 3"))))
+
+  (testing "rational number rate"
+    (is (= '(rate 3/2 :c)
+           (compile "c*3/2"))))
+
+  (testing "whitespace handling"
+    (is (= '(l :a :b :c)
+           (compile "  a   b   c  "))))
+
+  (testing "complex real-world pattern"
+    (is (= '(l (rate 2 (f :bd :sd)) (p :hat :hat :hat))
+           (compile "<bd sd>*2 [hat,hat,hat]"))))
+
+  (testing "newlines are converted to spaces"
+    (is (= '(f :a :b :c :d)
+           (compile "<a b\nc d>"))))
+
+  (testing "multi-line pattern with parallel"
+    (is (= '(f (l :a :b) (p :c :d))
+           (compile "<\n[a b]\n[c,d]\n>"))))
+
+  (testing "polymeter - comma in angle brackets zips elements"
+    (is (= '(f (p :a :c) (p :b :d))
+           (compile "<a b, c d>"))))
+
+  (testing "polymeter - three groups"
+    (is (= '(f (p :a :c :e) (p :b :d :f))
+           (compile "<a b, c d, e f>"))))
+
+  (testing "polymeter - unequal lengths pads with nils"
+    (is (= '(f (p :a :c) (p :b :d) :e)
+           (compile "<a b e, c d>"))))
+
+  (testing "polymeter - single element groups"
+    (is (= '(p :a :c)
+           (compile "<a, c>"))))
+
+  (testing "polymeter - with nested structures"
+    (is (= '(f (p (l :a :b) (l :e :f))
+               (p (l :c :d) (l :g :h)))
+           (compile "<[a b] [c d], [e f] [g h]>"))))
+
+  (testing "polymeter - with modifiers"
+    (is (= '(rate 2 (f (p :a :c) (p :b :d)))
+           (compile "<a b, c d>*2"))))
+
+  (testing "polymeter - melody and bass pattern"
+    (is (= '(f (p (l :e5 :b4) (rate 4 (l :e2 :e3)))
+               (p (l :a4 :c5) (rate 4 (l :a2 :a3))))
+           (compile "<[e5 b4] [a4 c5], [[e2 e3]*4] [[a2 a3]*4]>")))))