nydp 0.1.2 → 0.1.3

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

@@ -1,109 +1,67 @@
-(register-test '(suite "Parser tests"
-  (suite "brace-list"
-    ("parses an empty brace list"
-     (parse "{}")
-     ((brace-list)))
-
-    ("parses a single-item list"
-     (parse "{foo}")
-     ((brace-list foo)))
-
-    ("parses a list"
-     (parse "{foo bar 1 2 3}")
-     ((brace-list foo bar 1 2 3))))
-
-  (suite "prefix-list"
-    ("parse quasiquote"
-     (parse "`(1 2 3)")
-     ((quasiquote (1 2 3))))
-
-    ("parse unquote unquote-splicing"
-     (parse ",,@(1 2 3)")
-     ((unquote (unquote-splicing (1 2 3)))))
-
-    ("parse unquote"
-     (parse ",(1 2 3)")
-     ((unquote (1 2 3))))
-
-    ("parse custom prefix-lists"
-     (parse "x(1 2 3)")
-     ((prefix-list "x" (1 2 3))))
-
-    ("parse custom prefix-lists with a special-syntax prefix"
-     (parse "x.y(1 2 3)")
-     ((prefix-list "x.y" (1 2 3)))))
-
-  (suite "parse"
-    ("parses an empty symbol"
-     (parse "||")
-     (||) )
-
-    ("parses a colon-syntax symbol"
-     (parse "this:that")
-     ((colon-syntax this that)) )
-
-    ("parses a percent-syntax symbol"
-     (parse "this%that")
-     ((percent-syntax this that)) )
-
-    ("parses a percent-prefix-syntax symbol"
-     (parse "%this-and-that")
-     ((percent-syntax || this-and-that)) )
-
-    ("parses a dot-syntax symbol"
-     (parse "this.that.zozo")
-     ((dot-syntax this that zozo)) )
-
-    ("parses a mixed-syntax symbol"
-     (parse "this$that.zozo")
-     ((dot-syntax (dollar-syntax this that) zozo)))
-
-    ("parses a mixed-syntax prefix symbol"
-     (parse "$this.that.zozo")
-     ((dot-syntax (dollar-syntax || this) that zozo)))
-
-    ("parses a prefix dollar"
-     (parse "$this")
-     ((dollar-syntax || this)))
-
-    ("parses a prefix dollar-dot"
-     (parse "$.this")
-     ((dot-syntax (dollar-syntax || ||) this)))
-
-    ("parses an expression"
-     (parse "(foo bar \"hello, String\") 1 2 (3 t nil) nil")
-     ((foo bar "hello, String") 1 2 (3 t nil))))
-
-  (suite "parse-in-string"
-    ("parses a plain string"
-      (parse-in-string "hello, world, take me to your dealer")
-      "hello, world, take me to your dealer")
-
-    ("parses a plain string with interpolations"
-      (parse-in-string (joinstr "" (list "hello, " '~ "(world), take me to your " '~ "dealer please")))
-      (string-pieces "hello, " (world) ", take me to your " dealer " please"))
-
-    ("parses a plain string of html text with interpolations"
-      (parse-in-string "<div id='content_item_~~{id}'><label>~~{data-name-1}</label> ~~{data-text-1}</div>")
-      (string-pieces "<div id='content_item_" (brace-list id) "'><label>" (brace-list data-name-1) "</label> " (brace-list data-text-1) "</div>"))
-
-    ("ignores standalone interpolation symbol"
-      (parse-in-string (joinstr "" (list "hello " '~ " world")))
-      "hello \~ world")
-
-    ("ignores backslash-escaped interpolation symbol"
-      (len "hello \~world")
-      12)
-
-    ("ignores escaped interpolation symbol"
-      (parse-in-string (joinstr "" (list "hello " '~ '~ "world")))
-      "hello \~world")
-
-    ("really ignores standalone interpolation symbol"
-      (len (parse-in-string (joinstr "" (list "hello " '~ " world"))))
-      13)
-
-    ("reports parse errors gracefully"
-     (on-err "CAUGHT: ~err" (parse-in-string (joinstr "" "blah ~~(\"stri...")))
-     "CAUGHT: parse error: \"unterminated string\" in\n  blah ~~(\"stri..." )
-)))
+(examples-for parse
+  ("parses an empty brace list"     (parse "{}")               ((brace-list)))
+  ("parses a single-item list"      (parse "{foo}")            ((brace-list foo)))
+  ("parses a list"                  (parse "{foo bar 1 2 3}")  ((brace-list foo bar 1 2 3)))
+  ("parse quasiquote"               (parse "`(1 2 3)")         ((quasiquote (1 2 3))))
+  ("parse unquote unquote-splicing" (parse ",,@(1 2 3)")       ((unquote (unquote-splicing (1 2 3)))))
+  ("parse unquote"                  (parse ",(1 2 3)")         ((unquote (1 2 3))))
+  ("parse custom prefix-lists"      (parse "x(1 2 3)")         ((prefix-list "x" (1 2 3))))
+  ("parses an empty symbol"         (parse "||")               (||) )
+  ("parses a colon-syntax symbol"   (parse "this:that")        ((colon-syntax this that)) )
+  ("parses a percent-syntax symbol" (parse "this%that")        ((percent-syntax this that)) )
+  ("parses a prefix dollar"         (parse "$this")            ((dollar-syntax || this)))
+  ("parses a prefix dollar-dot"     (parse "$.this")           ((dot-syntax (dollar-syntax || ||) this)))
+
+  ("parse custom prefix-lists with a special-syntax prefix"
+   (parse "x.y(1 2 3)")
+   ((prefix-list "x.y" (1 2 3))))
+
+  ("parses a percent-prefix-syntax symbol"
+   (parse "%this-and-that")
+   ((percent-syntax || this-and-that)) )
+
+  ("parses a dot-syntax symbol"
+   (parse "this.that.zozo")
+   ((dot-syntax this that zozo)) )
+
+  ("parses a mixed-syntax symbol"
+   (parse "this$that.zozo")
+   ((dot-syntax (dollar-syntax this that) zozo)))
+
+  ("parses a mixed-syntax prefix symbol"
+   (parse "$this.that.zozo")
+   ((dot-syntax (dollar-syntax || this) that zozo)))
+
+
+  ("parses an expression"
+   (parse "(foo bar \"hello, String\") 1 2 (3 t nil) nil")
+   ((foo bar "hello, String") 1 2 (3 t nil))))
+
+(examples-for parse-in-string
+  ("parses a plain string"
+   (parse-in-string "hello, world, take me to your dealer")
+   "hello, world, take me to your dealer")
+
+  ("parses a plain string with interpolations"
+   (parse-in-string (joinstr "" (list "hello, " '~ "(world), take me to your " '~ "dealer please")))
+   (string-pieces "hello, " (world) ", take me to your " dealer " please"))
+
+  ("parses a plain string of html text with interpolations"
+   (parse-in-string "<div id='content_item_~~{id}'><label>~~{data-name-1}</label> ~~{data-text-1}</div>")
+   (string-pieces "<div id='content_item_" (brace-list id) "'><label>" (brace-list data-name-1) "</label> " (brace-list data-text-1) "</div>"))
+
+  ("ignores standalone interpolation symbol"
+   (parse-in-string (joinstr "" (list "hello " '~ " world")))
+   "hello \~ world")
+
+  ("ignores escaped interpolation symbol"
+   (parse-in-string (joinstr "" (list "hello " '~ '~ "world")))
+   "hello \~world")
+
+  ("really ignores standalone interpolation symbol"
+   (len (parse-in-string (joinstr "" (list "hello " '~ " world"))))
+   13)
+
+  ("reports parse errors gracefully"
+   (on-err "CAUGHT: ~err" (parse-in-string (joinstr "" "blah ~~(\"stri...")))
+   "CAUGHT: parse error: \"unterminated string\" in\n  blah ~~(\"stri..." ))

data/lib/lisp/tests/pretty-print-tests.nydp

@@ -1,20 +1,19 @@
-(register-test
- '(suite "Pretty Printing Tests"
-         ("a macro invocation"
-          (pp '(mac pp/def (name args . body) `(hash-set pp/special-forms ',name (fn ,args ,@body))))
-          "(mac pp/def (name args body)\n    `(hash-set pp/special-forms ',name (fn ,args ,@body)))")
+(examples-for pp
+  ("a macro invocation"
+   (pp '(mac pp/def (name args . body) `(hash-set pp/special-forms ',name (fn ,args ,@body))))
+   "(mac pp/def (name args body)\n    `(hash-set pp/special-forms ',name (fn ,args ,@body)))")
 
-         ("a 'def invocation"
-          (pp '(def pp (form) (pp/main form 0)))
-          "(def pp (form)\n    (pp/main form 0))")
+  ("a 'def invocation"
+   (pp '(def pp (form) (pp/main form 0)))
+   "(def pp (form)\n    (pp/main form 0))")
 
-         ("something with a plain string literal"
-          (pp '(def yoohoo (it) (wrangle "foobar" it)))
-          "(def yoohoo (it)\n    (wrangle \"foobar\" it))")
+  ("something with a plain string literal"
+   (pp '(def yoohoo (it) (wrangle "foobar" it)))
+   "(def yoohoo (it)\n    (wrangle \"foobar\" it))")
 
-         ("combined with dox system"
-          (pp:dox-src 'pp/find-breaks)
-          "(def pp/find-breaks (form)
+  ("combined with dox system"
+   (pp:dox-src 'pp/find-breaks)
+   "(def pp/find-breaks (form)
     (if (eq? 'if (car form))
       (let if-args (cdr form)
         (cons (list 'if (car if-args)) (map list (cdr if-args))))
@@ -22,10 +21,10 @@
         (pp/find-breaks/mac form)
         (list form))))")
 
-         ("special syntax"
-          (pp '(string-pieces "hello " (bang-syntax || (dot-syntax x y (ampersand-syntax foo bar))) " and welcome to " (prefix-list "%%" (a b c d)) " and friends!"))
-          "\"hello ~~!x.y.foo&bar and welcome to ~~%%(a b c d) and friends!\"")
+  ("special syntax"
+   (pp '(string-pieces "hello " (bang-syntax || (dot-syntax x y (ampersand-syntax foo bar))) " and welcome to " (prefix-list "%%" (a b c d)) " and friends!"))
+   "\"hello ~~!x.y.foo&bar and welcome to ~~%%(a b c d) and friends!\"")
 
-         ("brace list"
-          (pp '(&x {a 1 b "two" c 'three d ,four e (sub invocation) f {sub brace list} }))
-          "(&x {a 1 b \"two\" c 'three d ,four e (sub invocation) f {sub brace list}})")))
+  ("brace list"
+   (pp '(&x {a 1 b "two" c 'three d ,four e (sub invocation) f {sub brace list} }))
+   "(&x {a 1 b \"two\" c 'three d ,four e (sub invocation) f {sub brace list}})"))

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

@@ -0,0 +1,10 @@
+(examples-for quasiquote
+  ("same as quote for standalone item"             `a                                                     a)
+  ("same as quote for standalone list"             `(a b c)                                               (a b c))
+  ("substitutes single variables"                  (let b 10 `(a ,b c))                                   (a 10 c))
+  ("substitutes a list"                            (let b '(1 2 3) `(a ,@b c))                            (a 1 2 3 c))
+  ("substitutes a list at the end of a given list" (let b '(1 2 3) `(a ,b ,@b))                           (a (1 2 3) 1 2 3))
+  ("more complicated substitution example"         (with (d '(1 2 3) g '(x y z)) `(a (b c ,d (e f ,@g)))) (a (b c (1 2 3) (e f x y z))))
+  ("peeks inside nested quotes"                    `(a b '(c ,(+ 1 2)))                                   (a b '(c 3)))
+  ("handles nested unquote-splicing"               ``(a ,,@(list '+ 1 2) b)                               `((a ,(+ 1 2) b)))
+  ("returns nested quasiquotes"                    `(a b `(c d ,(+ 1 2) ,,(+ 3 4)))                       (a b `(c d ,(+ 1 2) ,7))))

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

@@ -0,0 +1,7 @@
+(examples-for rfnwith
+  ("generates a locally-scoped recursive function"
+   (rfnwith triangle (n 10)
+            (if (eq? n 0)
+                0
+                (+ n (triangle (- n 1)))))
+   55))

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

@@ -1,31 +1,60 @@
-(register-test
- '(suite "String Tests"
-         (suite "length"
-                ("nonzero"  (len "foo-bar")  7)
-                ("zero"     (len "")         0))
-
-         (suite "joinstr"
-                ("joins elements into a string"
-                 (joinstr "" '("foo" "bar" "bax"))
-                 "foobarbax")
-
-                ("joins separate elements into a string"
-                 (joinstr "/" "foo" "bar" "bax")
-                 "foo/bar/bax")
-
-                ("joins a single thing"
-                 (joinstr "/" "foo")
-                 "foo")
-
-                ("joins nested and separate elements into a string"
-                 (joinstr "/" "foo" "bar" '(twiddle diddle) "bax")
-                 "foo/bar/twiddle/diddle/bax")
-
-                ("joins elements into a string"
-                 (joinstr " - " '(1 2 3))
-                 "1 - 2 - 3"))
-
-         (suite "strip"
-                ("removes leading whitespace"               (string-strip "    hello!")  "hello!" )
-                ("removes trailing whitespace"              (string-strip "(world)   ") "(world)" )
-                ("removes leading and trailing whitespace"  (string-strip "\n\nme\n\n") "me"      ))))
+(examples-for string-split
+  ("splits a string using given expression"
+   (string-split "a and b and c and d" " and ")
+   ("a" "b" "c" "d")))
+
+(examples-for string-replace
+  ("replaces parts of a string with the given replacement"
+   (string-replace "and" "or" "a and b and c and d")
+   "a or b or c or d")
+
+  ("replace with regexp"
+   (string-replace "and|or" "x" "a and b or c and d")
+   "a x b x c x d"))
+
+(examples-for string-match
+  ("match with regexp"
+   (let m (string-match "a and b and c and d" "and")
+     (list m.match m.captures))
+   ("and" nil))
+
+  ("no match with regexp"
+   (let m (string-match "a and b and c and d" "not-in-string")
+     (list m.match m.captures))
+   (nil nil))
+
+  ("match with regexp and capturing groups"
+   (let m (string-match "  foo\b    bar" "(^\\s+)")
+     (list m.match m.captures))
+   ("  " ("  "))))
+
+(examples-for string-pieces
+  ("interpolates a string"
+   "foobar ~(+ 1 2) you know"
+   "foobar 3 you know"))
+
+(examples-for joinstr
+  ("joins elements into a string"
+   (joinstr "" '("foo" "bar" "bax"))
+   "foobarbax")
+
+  ("joins separate elements into a string"
+   (joinstr "/" "foo" "bar" "bax")
+   "foo/bar/bax")
+
+  ("joins a single thing"
+   (joinstr "/" "foo")
+   "foo")
+
+  ("joins nested and separate elements into a string"
+   (joinstr "/" "foo" "bar" '(twiddle diddle) "bax")
+   "foo/bar/twiddle/diddle/bax")
+
+  ("joins elements into a string"
+   (joinstr " - " '(1 2 3))
+   "1 - 2 - 3"))
+
+(examples-for string-strip
+  ("removes leading whitespace"               (string-strip "    hello!")  "hello!" )
+  ("removes trailing whitespace"              (string-strip "(world)   ") "(world)" )
+  ("removes leading and trailing whitespace"  (string-strip "\n\nme\n\n") "me"      ))

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

@@ -1,29 +1,27 @@
-(register-test
- '(suite "syntax tests"
-         (suite "colon-syntax"
-                ("expands to sequential function application"
-                 (pre-compile 'a:b)
-                 (fn args (a (apply b args))))
+(examples-for colon-syntax
+  ("expands to sequential function application"
+   (pre-compile 'a:b)
+   (fn args (a (apply b args))))
 
-                ("example with car:cdr"
-                 (car:cdr '(a b c))
-                 b)
+  ("example with car:cdr"
+   (car:cdr '(a b c))
+   b)
 
-                ("dislikes no-prefix"
-                 (on-err err (pre-compile '(:foo 1 2 3)))
-                 "(\"Irregular ': syntax: got (|| foo) : not prefix-syntax : in :foo\")"))
+  ("dislikes no-prefix"
+   (on-err err (pre-compile '(:foo 1 2 3)))
+   "(\"Irregular ': syntax: got (|| foo) : not prefix-syntax : in :foo\")"))
 
-         (suite "lambda shortcut"
-                ("one argument"
-                 (map λa(len a.name)
-                      (list { name "bob" } { name "willy" } { name "pteradactyl" }))
-                 (3 5 11))
+(examples-for prefix-list
+  ("one argument"
+   (map λa(len a.name)
+        (list { name "bob" } { name "willy" } { name "pteradactyl" }))
+   (3 5 11))
 
-                ("with two args"
-                 (reduce λxy(joinstr ":" x y)
-                         '(a b c d e f))
-                 "a:b:c:d:e:f")
+  ("with two args"
+   (reduce λxy(joinstr ":" x y)
+           '(a b c d e f))
+   "a:b:c:d:e:f")
 
-                ("with two args, to be sure"
-                 (λpq(+ p (* p q)) 3 5)
-                 18))))
+  ("with two args, to be sure"
+   (λpq(+ p (* p q)) 3 5)
+   18))

data/lib/lisp/tests/type-of-examples.nydp

@@ -0,0 +1,48 @@
+(examples-for type-of
+  ("returns pair for a cons cell"
+   (type-of (cons "a" "b"))
+   pair)
+
+  ("returns 'fn for builtin function"
+   (type-of car)
+   fn)
+
+  ("returns 'fn for nydp-defined function"
+   (type-of register-test)
+   fn)
+
+  ("returns 'fn for inline function"
+   (type-of (fn (x) (p x)))
+   fn)
+
+  ("returns 'string"
+   (type-of "foobar")
+   string)
+
+  ("returns 'hash for new hash"
+   (type-of (hash))
+   hash)
+
+  ("returns 'hash for hash literal"
+   (type-of { a 1 b 2})
+   hash)
+
+  ("returns 'number for an integer"
+   (type-of 42)
+   number)
+
+  ("returns 'number for a float"
+   (type-of 4.2)
+   number)
+
+  ("returns 'string for an interpolated string"
+   (type-of "foobar ~(+ 1 2)")
+   string)
+
+  ("t is Truth"
+   (type-of t)
+   truth)
+
+  ("nil is nil"
+   (type-of nil)
+   nil))

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

@@ -1,7 +1,6 @@
-(register-test '(suite "pair to-string"
+(examples-for to-string
   ("unquote"           (to-string '(unquote a))          ",a"           )
   ("quote"             (to-string '(quote a))            "'a"           )
   ("quasiquote"        (to-string '(quasiquote a))       "`a"           )
   ("unquote-splicing"  (to-string '(unquote-splicing a)) ",@a"          )
-  ("brace-list"        (to-string '(brace-list a b c d)) "{ a b c d }"  )
-))
+  ("brace-list"        (to-string '(brace-list a b c d)) "{ a b c d }"  ))