nydp 0.1.2 → 0.1.3

data/lib/lisp/tests/collect-tests.nydp

@@ -0,0 +1,28 @@
+(examples-for collect
+  ("returns all matching items in a list"
+   (collect (fn (x) (eq? (len x) 2))
+            (list "foo" "bar" "xx" "pp"))
+   ("xx" "pp"))
+
+  ("returns nil when nothing matches"
+   (collect (fn (x) (eq? (len x) 20))
+            (list "foo" "bar" "xx" "pp"))
+   nil)
+
+  ;; kind of pointless
+  ("returns list of nils if nil is the matching item"
+   (collect no (list "foo" "bar" nil "pp" nil))
+   (nil nil))
+
+  ("returns item if it's an atom and matches"
+   (collect (fn (x) (eq? (len x) 2)) "zz")
+   "zz")
+
+  ("preserves structure of improper list"
+   (collect (fn (x) (eq? (len x) 2)) '("aa" "bbb" "cc" "ddd" . "ee"))
+   ("aa" "cc" . "ee"))
+
+  ("returns nil if it's an atom and doesn't match"
+   (collect (fn (x) (eq? (len x) 20))
+            "zz")
+   nil))

data/lib/lisp/tests/cons-examples.nydp

@@ -0,0 +1,8 @@
+(examples-for cons
+  ("cons creates a list"
+   (cons 'a '(b c))
+   (a b c))
+
+  ("cons conses two strings"
+   (cons "a" "b")
+   ("a" . "b")))

data/lib/lisp/tests/curry-tests.nydp

@@ -1,24 +1,23 @@
 (def chicken-korma (a b c d e)
   (list a b c d e))
 
-(register-test
- '(suite "Curry Tests"
-         ("zero-params"
-          (let ck0 (curry chicken-korma)
-            (ck0 1 2 3 4 5))
-          (1 2 3 4 5))
+(examples-for curry
+  ("zero-params"
+   (let ck0 (curry chicken-korma)
+     (ck0 1 2 3 4 5))
+   (1 2 3 4 5))
 
-         ("one param"
-          (let ck0 (curry chicken-korma 'x)
-            (ck0 1 2 3 4))
-          (x 1 2 3 4))
+  ("one param"
+   (let ck0 (curry chicken-korma 'x)
+     (ck0 1 2 3 4))
+   (x 1 2 3 4))
 
-         ("two params"
-          (let ck0 (curry chicken-korma 'x 'y)
-            (ck0 1 2 3))
-          (x y 1 2 3))
+  ("two params"
+   (let ck0 (curry chicken-korma 'x 'y)
+     (ck0 1 2 3))
+   (x y 1 2 3))
 
-         ("three params"
-          (let ck0 (curry chicken-korma 'x 'y 'z)
-            (ck0 1 2))
-          (x y z 1 2))))
+  ("three params"
+   (let ck0 (curry chicken-korma 'x 'y 'z)
+     (ck0 1 2))
+   (x y z 1 2)))

data/lib/lisp/tests/detect-examples.nydp

@@ -0,0 +1,24 @@
+(examples-for detect
+  ("returns first matching item in a list"
+   (detect (fn (x) (eq? (len x) 2))
+           (list "foo" "bar" "xx" "pp"))
+   "xx")
+
+  ("returns nil when nothing matches"
+   (detect (fn (x) (eq? (len x) 20))
+           (list "foo" "bar" "xx" "pp"))
+   nil)
+
+  ;; kind of pointless
+  ("returns nil if nil is the matching item"
+   (detect no (list "foo" "bar" nil "pp"))
+   nil)
+
+  ("returns item if it's an atom and matches"
+   (detect (fn (x) (eq? (len x) 2)) "zz")
+   "zz")
+
+  ("returns nil if it's an atom and doesn't match"
+   (detect (fn (x) (eq? (len x) 20))
+           "zz")
+   nil))

data/lib/lisp/tests/dot-syntax-examples.nydp

@@ -0,0 +1,40 @@
+(examples-for dox-syntax
+  ("hash-lookup"
+   (pre-compile 'a.b.c)
+   (hash-get (hash-get a 'b) 'c))
+
+  ("hash-lookup with dollar-syntax for function call"
+   (pre-compile '$a.b.c)
+   (hash-get (hash-get (a) 'b) 'c))
+
+  ("hash-lookup with embedded dollar-syntax for function call"
+   (pre-compile 'a.$b.c)
+   (hash-get (hash-get a (b)) 'c))
+
+  ("hash-lookup with embedded unquote"
+   (pre-compile 'a.,b.c)
+   (hash-get (hash-get a b) 'c))
+
+  ("hash assignment"
+   (pre-compile '(= a.b 42))
+   (hash-set a 'b 42))
+
+  ("hash assignment with unquote"
+   (pre-compile '(= a.,b 42))
+   (hash-set a b 42))
+
+  ("recursive hash assignment"
+   (pre-compile '(= a.b.c.d 42))
+   (hash-set (hash-get (hash-get a 'b) 'c) 'd 42))
+
+  ("recursive hash assignment with embedded unquote"
+   (pre-compile '(= a.b.,c.d 42))
+   (hash-set (hash-get (hash-get a 'b) c) 'd 42))
+
+  ("recursive hash assignment with prefix dollar-syntax"
+   (pre-compile '(= $a.b.,c.d 42))
+   (hash-set (hash-get (hash-get (a) 'b) c) 'd 42))
+
+  ("recursive hash assignment with embedded dollar-syntax"
+   (pre-compile '(= a.$b.,c.d 42))
+   (hash-set (hash-get (hash-get a (b)) c) 'd 42)))

data/lib/lisp/tests/dox-tests.nydp

@@ -1,53 +1,51 @@
 (mac this-is-a-well-documented-macro (a b c)
-  ; documentation for me!
+                                        ; documentation for me!
   `(foo ,a ,b ,c))
 
 (mac this-is-an-undocumented-macro (a b c)
   `(baz ,a ,b ,c))
 
 (def this-is-a-well-documented-def (a b c)
-  ; documentation for me!
+                                        ; documentation for me!
   (foo a b c))
 
 (def this-is-an-undocumented-def (a b c)
   (baz a b c))
 
-(register-test
- '(suite "Documentation Tests"
-         (suite "comment detection"
-                ("identify comment"
-                 (isa-comment? '(comment "yes, it is"))
-                 t)
-
-                ("identify non-comment"
-                 (isa-comment? "not this time")
-                 nil))
-
-         (suite "gather comments from 'body argument"
-                ("no comment"
-                 (dox-gather-comments '((this) (that)))
-                 (nil ((this) (that))))
-
-                ("one comment"
-                 (dox-gather-comments '((comment "hello") (this) (that)))
-                 (("hello") ((this) (that))))
-
-                ("more comments"
-                 (dox-gather-comments '((comment "hello")
-                                        (comment "more details")
-                                        (comment "very rigourous")
-                                        (this)
-                                        (that)))
-                 (("hello" "more details" "very rigourous") ((this) (that)))))
-
-         (suite "dox-show-info"
-                ("shows each item"
-                 (dox-show-info "bingo"
-                                'def
-                                '("there was a farmer had a dog" "and Bingo was his name-o")
-                                '(count)
-                                '(def bingo (count) (times count (bark))))
-                 "Function : bingo
+(examples-for isa-comment?
+  ("identifies a comment"
+   (isa-comment? '(comment "yes, it is"))
+   t)
+
+  ("identifies a non-comment"
+   (isa-comment? "not this time")
+   nil))
+
+(examples-for dox-gather-comments
+  ("find no comments"
+   (dox-gather-comments '((this) (that)))
+   (nil ((this) (that))))
+
+  ("finds one comment"
+   (dox-gather-comments '((comment "hello") (this) (that)))
+   (("hello") ((this) (that))))
+
+  ("finds more comments"
+   (dox-gather-comments '((comment "hello")
+                          (comment "more details")
+                          (comment "very rigourous")
+                          (this)
+                          (that)))
+   (("hello" "more details" "very rigourous") ((this) (that)))))
+
+(examples-for dox-show-info
+  ("shows each item"
+   (dox-show-info "bingo"
+                  'def
+                  '("there was a farmer had a dog" "and Bingo was his name-o")
+                  '(count)
+                  '(def bingo (count) (times count (bark))))
+   "Function : bingo
 
 args : (count)
 
@@ -56,68 +54,86 @@ and Bingo was his name-o
 
 source
 ======
-(def bingo (count)
+\(def bingo (count)
     (times count (bark)))
 "))
 
-         (suite "mac"
-                ("a documented macro"
-                 (dox-lookup 'this-is-a-well-documented-macro)
-                 ((this-is-a-well-documented-macro
-                   mac
-                   ("documentation for me!")
-                   (a b c)
-                   (mac this-is-a-well-documented-macro (a b c)
-                     `(foo ,a ,b ,c)))))
-
-                ("arg list"
-                 (dox-arg-names 'this-is-a-well-documented-macro)
-                 (a b c))
-
-                ("src"
-                 (dox-src 'this-is-a-well-documented-macro)
-                 (mac this-is-a-well-documented-macro (a b c) (quasiquote (foo (unquote a) (unquote b) (unquote c)))))
-
-                ("is a def"
-                 (dox-what-is? 'this-is-a-well-documented-macro)
-                 mac)
-
-                ("an undocumented macro"
-                 (dox-lookup 'this-is-an-undocumented-macro)
-                 ((this-is-an-undocumented-macro
-                   mac
-                   nil
-                   (a b c)
-                   (mac this-is-an-undocumented-macro (a b c)
-                     `(baz ,a ,b ,c)))))
-
-         (suite "def"
-                ("a documented def"
-                 (dox-lookup 'this-is-a-well-documented-def)
-                 ((this-is-a-well-documented-def
-                   def
-                   ("documentation for me!")
-                   (a b c)
-                   (def this-is-a-well-documented-def (a b c)
-                     (foo a b c)))))
-
-                ("arg list"
-                 (dox-arg-names 'this-is-a-well-documented-def)
-                 (a b c))
-
-                ("is a def"
-                 (dox-what-is? 'this-is-a-well-documented-def)
-                 def)
-
-                ("src"
-                 (dox-src 'this-is-a-well-documented-def)
-                 (def this-is-a-well-documented-def (a b c) (foo a b c)))
-
-                ("an undocumented def"
-                 (dox-lookup 'this-is-an-undocumented-def)
-                 ((this-is-an-undocumented-def
-                   def
-                   nil
-                   (a b c)
-                   (def this-is-an-undocumented-def (a b c)
-                     (baz a b c)))))))))
+(examples-for dox-lookup
+  ("finds info for a documented macro"
+   (dox-lookup 'this-is-a-well-documented-macro)
+   ((this-is-a-well-documented-macro
+     mac
+     ("documentation for me!")
+     (a b c)
+     (mac this-is-a-well-documented-macro (a b c)
+       `(foo ,a ,b ,c)))))
+
+  ("finds info for an undocumented macro"
+   (dox-lookup 'this-is-an-undocumented-macro)
+   ((this-is-an-undocumented-macro
+     mac
+     nil
+     (a b c)
+     (mac this-is-an-undocumented-macro (a b c)
+       `(baz ,a ,b ,c)))))
+
+  ("finds info for a documented def"
+   (dox-lookup 'this-is-a-well-documented-def)
+   ((this-is-a-well-documented-def
+     def
+     ("documentation for me!")
+     (a b c)
+     (def this-is-a-well-documented-def (a b c)
+       (foo a b c)))))
+
+  ("finds info for an undocumented def"
+   (dox-lookup 'this-is-an-undocumented-def)
+   ((this-is-an-undocumented-def
+     def
+     nil
+     (a b c)
+     (def this-is-an-undocumented-def (a b c)
+       (baz a b c))))))
+
+(examples-for dox-arg-names
+  ("macro"
+   (dox-arg-names 'this-is-a-well-documented-macro)
+   (a b c))
+
+  ("function def"
+   (dox-arg-names 'this-is-a-well-documented-def)
+   (a b c)))
+
+(examples-for dox-src
+  ("mac src"
+   (dox-src 'this-is-a-well-documented-macro)
+   (mac this-is-a-well-documented-macro (a b c) (quasiquote (foo (unquote a) (unquote b) (unquote c)))))
+
+  ("def src"
+   (dox-src 'this-is-a-well-documented-def)
+   (def this-is-a-well-documented-def (a b c) (foo a b c))))
+
+
+(examples-for dox-what-is?
+  ("for mac"
+   (dox-what-is? 'this-is-a-well-documented-macro)
+   mac)
+
+  ("is a def"
+   (dox-what-is? 'this-is-a-well-documented-def)
+   def))
+
+(examples-for dox-show-one-example
+  ("produces a string representation of a given example"
+   (dox-show-one-example 'foo '("this is an example of an example"
+                                (foo bar yadda 1 2 3)
+                                720))
+   "foo this is an example of an example
+
+running  :
+(foo bar yadda 1 2 3)
+
+produces : 720
+
+--------------------------------
+"))

data/lib/lisp/tests/dynamic-scope-test.nydp

@@ -1,14 +1,14 @@
 (dynamic foodynamic)
 
 (def listfoody ()
-     (list (foodynamic)
-           (+ 6 (foodynamic))
-           (+ 10 (foodynamic))))
+  (list (foodynamic)
+        (+ 6 (foodynamic))
+        (+ 10 (foodynamic))))
 
-(register-test '(suite "dynamic scoping"
-       ("relies on thread-locals"
-        (list
-         (w/foodynamic 101 (listfoody))
-         (w/foodynamic 0   (listfoody))
-         (w/foodynamic 666 (listfoody)))
-        ((101 107 111) (0 6 10) (666 672 676)))))
+(examples-for dynamic
+  ("relies on thread-locals"
+   (list
+    (w/foodynamic 101 (listfoody))
+    (w/foodynamic 0   (listfoody))
+    (w/foodynamic 666 (listfoody)))
+   ((101 107 111) (0 6 10) (666 672 676))))

data/lib/lisp/tests/each-tests.nydp

@@ -1,5 +1,4 @@
-(register-test
- '(suite "'each Tests"
-         ("iterates over each item in list"
-          (let acc 0 (each x '(1 2 3 4) (assign acc (+ x acc))) acc)
-          10)))
+(examples-for each
+  ("iterates over each item in list"
+   (let acc 0 (each x '(1 2 3 4) (assign acc (+ x acc))) acc)
+   10))

data/lib/lisp/tests/error-tests.nydp

@@ -1,22 +1,23 @@
-(register-test '(suite "Error Tests"
-  ("'ensuring gets called on the way out"
+(examples-for ensure
+  ("always gets called on the way out"
    (let x 10
-        (ensure (assign x (+ x 11))
-                (assign x (+ x 22)))
-        x)
-   43)
+     (ensure (assign x (+ x 11))
+             (assign x (+ x 22)))
+     x)
+   43))
 
-  ("'on-err handles errors"
+(examples-for on-err
+  ("'handles errors"
    (let x nil
-        (on-err (= x "impossible")
-                (= x (nil nil nil)))
-        x)
+     (on-err (= x "impossible")
+             (= x (nil nil nil)))
+     x)
    "impossible")
 
-  ("'on-err handles errors but any ensuring clause gets called first"
+  ("handles errors but any ensuring clause gets called first"
    (with (x nil y nil)
-        (on-err (= x 'impossible)
-                (ensure (assign y 'ensure-clause)
-                        (nil nil nil)))
-        (list x y))
-   (impossible ensure-clause))))
+         (on-err (= x 'impossible)
+                 (ensure (assign y 'ensure-clause)
+                         (nil nil nil)))
+         (list x y))
+   (impossible ensure-clause)))