nydp 0.4.0 → 0.4.6

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

@@ -18,7 +18,7 @@
   ("nonzero"       (present? "foo-bar")  t)
   ("zero"          (present? "")         nil)
   ("blank"         (present? "  ")       t)
-  ("nil is t"      (present? nil)        nil)
+  ("nil is nil"    (present? nil)        nil)
   ("sym is t"      (present? 'abc)       t)
   ("number is t"   (present? 234)        t)
 

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

@@ -20,10 +20,10 @@
                     (on-err (error "bar")
                             (on-err (error "toto")
                                     (error "primum errorum")))))
-    "\"foo\"
-\"bar\"
-\"toto\"
-\"primum errorum\"")
+    "foo
+bar
+toto
+primum errorum")
 
   ("handles errors but any ensuring clause gets called first"
    (with (x nil y nil)

data/lib/lisp/tests/filter-forms-examples.nydp

@@ -44,3 +44,33 @@
                                  (this)
                                  (that))))
    ((("hello") ("more details") ("very rigourous")) ((this) (that)))))
+
+(examples-for filter-comments
+  ("returns nil for nil"
+   (filter-comments nil nil)
+   nil)
+
+  ("returns atom for atom"
+   (filter-comments 12 nil)
+   12)
+
+  ("returns list for list"
+   (filter-comments '(a b c d) nil)
+   (a b c d))
+
+  ("returns list without comment for list with comment"
+   (filter-comments '(a b (comment "hahaha") c d) nil)
+   (a b c d))
+
+  ("returns nothing for comment"
+   (filter-comments '((comment "hahaha")) nil)
+   nil)
+
+  ("weeds out nested comments"
+   (filter-comments '(1 2 (3 4
+                             (comment "yoyo") 5
+                             (6 7 (comment "eight") 8 9)
+                             { 10 (comment "eleven") 11 12 13 }
+                             (comment "fourteen") 14) (comment "fifteen") 15
+                             (if 16 (comment "seventeen") 17 (comment "eighteen") 18 19)))
+   (1 2 (3 4 5 (6 7 8 9) (brace-list 10 11 12 13) 14) 15 (if 16 17 18 19))))

data/lib/lisp/tests/foundation-test.nydp

@@ -169,3 +169,15 @@
   ("argument default value is nil"
    ( (fn (x y z) (list x y (car z))) 'a 'b )
    (a b nil)))
+
+(examples-for do
+  ("executes its content"
+   (let premesolithic 3
+     (do
+       (assign premesolithic (* premesolithic 4))
+       (let jurassic 17
+         (do
+           (= jurassic (+ jurassic premesolithic))
+           (= premesolithic (+ jurassic premesolithic))
+           (* premesolithic 2)))))
+   82))

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

@@ -1,3 +1,20 @@
+(examples-for hash-replace-keys
+  ("changes strings to symbols"
+   (let h (hash-replace-keys λk(sym k) { "a" 1 "b" 2 "c" 3 })
+     (list (hash-keys h) (hash-values h)))
+   ((a b c) (1 2 3)))
+
+  ("appends a character to keys"
+   (let h (hash-replace-keys λk(string-pieces k "!") { "a" 1 "b" 2 "c" 3 })
+     (list (hash-keys h) (hash-values h)))
+   (("a!" "b!" "c!") (1 2 3))))
+
+(examples-for hash
+  ("builds a hash"
+   (let h (hash "a" 1 'b 2 '(x y) 3)
+     (list (hash-keys h) (hash-values h)))
+   (("a" b (x y)) (1 2 3))))
+
 (examples-for hash-values
   ("returns the list of values of the given hash"
    (hash-values { a 1 b 2 c 'c d "hello" })
@@ -10,6 +27,12 @@
   ("  t for a hash"    (hash? {a 1 b 2})       t  )
   ("nil for a symbol"  (hash? 'foo)            nil))
 
+(examples-for hash-slice
+  ("returns a new hash containing only the specified keys"
+   (let h (hash-slice { a 1 b 2 c 3 d 4 } '(a b e f))
+     (list (hash-keys h) (hash-values h)))
+   ((a b) (1 2))))
+
 (examples-for hash-merge
   ("merge with symbol keys"
    (let h (hash-merge { a 1 b 2 c 3 } { a 99 c 98 d 97 })
@@ -28,8 +51,9 @@
   ("returns nil for a symbol"  (hash-keys 'lipstick)  nil)
 
   ("returns date operations"
-   (hash-keys (date 2015 11 18))
-   (beginning_of_month
+   (sort:hash-keys (date 2015 11 18))
+   (age
+    beginning_of_month
     beginning_of_week
     beginning_of_year
     day

data/lib/lisp/tests/list-grep-examples.nydp

@@ -0,0 +1,40 @@
+(examples-for list/grep
+  ("it finds strings"
+   (list/grep
+    string?
+    (list 'foo "bar" '(a b "c d" e) { ignores "hash elements" }))
+   ("bar" "c d"))
+
+  ("it finds items whose car is carryon"
+   (list/grep
+    λf(caris 'carryon f)
+    '(foo
+      (carryon 1 2 3 42)
+      (bar (40 41 42 (carryon 43 (carryon 42) 41)))
+      42
+      99))
+   ((carryon 1 2 3 42)
+    (carryon 43 (carryon 42) 41)
+    (carryon 42)))
+
+  ("it finds items of length 3"
+   (list/grep
+    λf(eq? 3 (len f))
+    '(foo
+      (2 3 42)
+      (bar (40 41 42) (43 (x y z) 41))
+      42
+      99))
+   ((2 3 42)
+    (bar (40 41 42) (43 (x y z) 41))
+    (40 41 42)
+    (43 (x y z) 41)
+    (x y z)))
+
+  ("it finds code within interpolated strings"
+   (list/seek-cars 'include (parse-in-string "
+<div>~~(include \"empty-name.html\")</div>
+<div>~~(map λn(let name n (include \"show-name.html\")) {names})'</div>
+"))
+   ((include "empty-name.html")
+    (include "show-name.html"))))

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

@@ -1,3 +1,17 @@
+(examples-for list-single-element
+  ("returns nothing from an empty list"
+   (list-single-element nil)
+   nil)
+
+  ("returns first item from a list with one item"
+   (list-single-element '(x))
+   x)
+
+  ("returns nothing from a list with more than one item"
+   (list-single-element '(x y z))
+   nil))
+
+
 (examples-for iso
   ("(nil) is not the same as nil"
    (iso '(nil) nil)
@@ -37,7 +51,11 @@
    (g f (c d e) b a)))
 
 (examples-for flatten
-  ("'flatten returns a flat list of things"
+  ("removes empty lists and nil"
+   (flatten '(a b nil (c d () e nil) f ()))
+   (a b c d e f))
+
+  ("returns a flat list of things"
    (flatten '((poo (x) (* x x)) (1 2 3)))
    (poo x * x x 1 2 3)))
 
@@ -187,3 +205,42 @@
   ("finds value corresponding to given key"
    (alref 'c '((a b) (c d)))
    d))
+
+(examples-for list/fill
+  ("returns an overfull list unchanged"
+   (list/fill '(a b c) λ(just 'x) 2)
+   (a b c))
+
+  ("returns a full list unchanged"
+   (list/fill '(a b c) λ(just 'x) 3)
+   (a b c))
+
+  ("returns an unfull list with extra items"
+   (list/fill '(a b c) λ(just 'x) 4)
+   (a b c x))
+
+  ("returns an unfull list with extra items"
+   (let idx 0
+     (list/fill '(a b c) λ(++ idx) 10))
+   (a b c 1 2 3 4 5 6 7)))
+
+(examples-for list/last
+  ("returns the thing if it's nil"
+   (list/last nil)
+   nil)
+
+  ("returns the thing if it's not a pair"
+   (list/last 42)
+   42)
+
+  ("returns the cdr if it's not a pair"
+   (list/last '(x . y))
+   y)
+
+  ("returns the last item in the list"
+   (list/last '(x y z))
+   z)
+
+  ("returns nil if it's the last item in the list"
+   (list/last '(x y z nil))
+   nil))

data/lib/lisp/tests/map-hash-examples.nydp

@@ -0,0 +1,11 @@
+(examples-for map-hash
+  ("iterates over key-value pairs"
+   (map-hash (fn (k v i) "pos.~i : ~k is for ~v")
+             { a 42 b 729 c 1024 })
+   ("pos.0 : a is for 42" "pos.1 : b is for 729" "pos.2 : c is for 1024"))
+
+  ("sorts keys before iterating"
+   (map-hash (fn (k v i) "pos.~i : ~k is for ~v")
+             { "aa" 1 "bbb" 2 "c" 3 }
+             (fn (keys) (sort-by len keys)))
+   ("pos.0 : c is for 3" "pos.1 : aa is for 1" "pos.2 : bbb is for 2" )))

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

@@ -0,0 +1,10 @@
+(examples-for mapreduce
+  ("maps a function over a list and sums the result"
+   (mapreduce car + '((2 3) (5 7) (11 13)) 0)
+   18)
+
+  ("extracts an attribute and sums the result"
+   (mapreduce &age + (list { name "a" age 10 }
+                           { name "b" age  7 }
+                           { name "c" age 12 }) 0)
+   29))

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

@@ -0,0 +1,10 @@
+(examples-for module
+  ("it overrides external namespace internally"
+   (with (x (fn (n) "the old outside x ~n")
+          y (fn (n) "the old outside y ~n"))
+     (module foo
+       (def x (n) (* 2 n))
+       (def y (n) (+ 2 n))
+       (export bar (a b) (* (x a) (y b))))
+    (list (foo/bar 3 5) (x 43) (y 44)))
+   (42 "the old outside x 43" "the old outside y 44")))

data/lib/lisp/tests/multi-assign-examples.nydp

@@ -0,0 +1,6 @@
+(examples-for ampersand-syntax
+  ("assigns multiple values at once ; value of expr is last assigned value"
+   (with (a 1 b { foo 2 } c { d { e 3 } })
+         (let res (= a 10 b.foo 20 (&d.e c) 30)
+           (list a b.foo c.d.e res)))
+   (10 20 30 30)))

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

@@ -9,9 +9,14 @@
   ("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 combined percent-colon"  (parse "%this:%that")      ((colon-syntax (percent-syntax || this) (percent-syntax || that))) )
   ("parses a prefix dollar"         (parse "$this")            ((dollar-syntax || this)))
   ("parses a prefix dollar-dot"     (parse "$.this")           ((dot-syntax (dollar-syntax || ||) this)))
 
+  ("parses combined percent-colon-dot"
+   (parse "%this.foo:%that.bar")
+   ((colon-syntax (percent-syntax || (dot-syntax this foo)) (percent-syntax || (dot-syntax that bar)))) )
+
   ("parse custom prefix-lists with a special-syntax prefix"
    (parse "x.y(1 2 3)")
    ((prefix-list "x.y" (1 2 3))))
@@ -24,6 +29,22 @@
    (parse "%this.and.that")
    ((percent-syntax || (dot-syntax this and that))) )
 
+  ("parses a plain at-symbol"
+   (pre-compile (car (parse "@")))
+   @)
+
+  ("parses a plain at-prefix-syntax symbol"
+   (parse "@this")
+   ((at-syntax || this)))
+
+  ("parses an at-prefix-mixed-with-dot-syntax symbol"
+   (parse "@this.and.that")
+   ((dot-syntax (at-syntax || this) and that)))
+
+  ("at-prefix-mixed-with-dot-syntax expands to plain hash lookup: @this.and.that equivalent to @.this.and.that"
+   (pre-compile (car (parse "@this.and.that")))
+   (hash-get (hash-get (hash-get @ (quote this)) (quote and)) (quote that)))
+
   ("parses a dot-syntax symbol"
    (parse "this.that.zozo")
    ((dot-syntax this that zozo)) )

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

@@ -206,13 +206,12 @@ toto")
    (pp '(def yoohoo (it) (wrangle "foobar" it)))
    "(def yoohoo (it) (wrangle \"foobar\" it))")
 
-  ("a 'let form"
-   (pp '(let acc nil
-            (rfnwith flattenize (x things)
-                     (if (pair? x)
-                         (eachr flattenize x)
-                         (push x acc)))
-            acc))
+  ("something with a nil and t literal"
+   (pp '(def yoohoo (it) (wrangle nil t it)))
+   "(def yoohoo (it) (wrangle nil t it))")
+
+  ("a 'let form squished into one line"
+   (pp '(let acc nil (rfnwith flattenize (x things) (if (pair? x) (eachr flattenize x) (push x acc))) acc))
    "(let acc nil
      (rfnwith flattenize (x things)
               (if (pair? x)
@@ -221,13 +220,11 @@ toto")
      acc)")
 
 
-  ("a real-life example from utils"
+  ("a real-life example from utils with improper 'if formatting"
    (pp '(def flatten (things)
           (let acc nil
             (rfnwith flattenize (x things)
-                     (if (pair? x)
-                         (eachr flattenize x)
-                         (push x acc)))
+                     (if (pair? x) (eachr flattenize x) (push x acc)))
             acc)))
    "(def flatten (things)
      (let acc nil
@@ -289,5 +286,11 @@ toto")
    "%x.y")
 
   ("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 } })"))
+   (pp '(let hello {a 1 b "two" c 'three d ,four e (sub invocation) f {sub brace list here} }))
+"(let hello { a 1
+       b \"two\"
+       c 'three
+       d ,four
+       e (sub invocation)
+       f { sub brace
+         list here } })"))

data/lib/lisp/tests/set-difference-examples.nydp

@@ -0,0 +1,8 @@
+(examples-for -
+  ("returns elements of first that are not in second"
+   (- '(a b c e) '(a b d))
+   (c e))
+
+  ("returns all of first if second is nil"
+   (- '(a b c) nil)
+   (a b c)))

data/lib/lisp/tests/set-intersection-examples.nydp

@@ -0,0 +1,32 @@
+(examples-for ⋂
+  ("returns a single arg"
+   (⋂ '(a b c))
+   (a b c))
+
+  ("returns a single nil arg"
+   (⋂ nil)
+   nil)
+
+  ("returns intersection of two args"
+   (⋂ '(a b c) '(a b d))
+   (a b))
+
+  ("returns intersection of list and nil"
+   (⋂ '(a b c) nil)
+   nil)
+
+  ("returns intersection of nil and list"
+   (⋂ nil '(a b c))
+   nil)
+
+  ("returns intersection of three args"
+   (⋂ '(a b c d e) '(a b c d f) '(z b c d g))
+   (b c d))
+
+  ("returns intersection of list, nil, and another list"
+   (⋂ '(a b c d e) nil '(z b c d g))
+   nil)
+
+  ("returns intersection of four args"
+   (⋂ '(a b c d e) '(a b c d f) '(z b d c g) '(z y g c d))
+   (c d)))

data/lib/lisp/tests/set-union-examples.nydp

@@ -0,0 +1,24 @@
+(examples-for ⋃
+  ("returns a single arg"
+   (⋃ '(a b c))
+   (a b c))
+
+  ("returns union of two args"
+   (⋃ '(a b c) '(a b d))
+   (a b c d))
+
+  ("returns union of arg and nil"
+   (⋃ '(a b c) nil)
+   (a b c))
+
+  ("returns union of three args"
+   (⋃ '(a b c d e) '(a b c d f) '(z b c d g))
+   (a b c d e f z g))
+
+  ("returns union of arg nil arg"
+   (⋃ '(a b c d e) nil '(z b c d g))
+   (a b c d e z g))
+
+  ("returns union of four args"
+   (⋃ '(a b c d e) '(a b c d f) '(z b d c g) '(z y g c d))
+   (a b c d e f z g y)))

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

@@ -0,0 +1,40 @@
+(def-setting "testing.reset.string" "hello world")
+(def-setting "testing.reset.fn"     to-string)
+
+(examples-for settings/fn
+  ("returns arg if it is a sym"
+   (settings/fn 'foobar)
+   foobar)
+
+  ("returns fn wrapper for arg if it is a string"
+   (settings/fn "hello")
+   (k "hello"))
+
+  ("returns fn wrapper for arg if it is a number"
+   (settings/fn 42)
+   (k 42))
+
+  ("returns fn wrapper for arg if it is nil"
+   (settings/fn nil)
+   (k nil))
+
+  ("wraps arg in a fn expression if it is a hash"
+   (settings/fn '{ a 1 b 2 })
+   (k { a 1 b 2 }))
+
+  ("wraps arg in a fn expression if it is a complex expression"
+   (settings/fn '(let foo this that (rfnwith (complex stuff) (%td.tricky#syntax))))
+   (fn (_) (let foo this that (rfnwith (complex stuff) ((percent-syntax || (dot-syntax td tricky#syntax))))))))
+
+(examples-for reset-setting
+  ("restores a setting to its original value"
+   (do (set-setting "testing.reset.string" "goodbye, dear life")
+       (reset-setting "testing.reset.string")
+       (setting "testing.reset.string"))
+   "hello world")
+
+  ("restores a setting to its original function value"
+   (do (set-setting "testing.reset.fn" "goodbye, dear life")
+       (reset-setting "testing.reset.fn")
+       (setting "testing.reset.fn"))
+   "testing.reset.fn"))