nydp 0.4.1 → 0.5.0

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

@@ -26,6 +26,18 @@
            "zz")
    nil)
 
+  ("empty list"
+   (detect present? nil)
+   nil)
+
+  ("present? for list of empty things"
+   (detect present? (list "" nil {} ()))
+   nil)
+
+  ("present? for mostly empty things"
+   (detect present? (list "" nil 42 {} ()))
+   42)
+
   ("nil for nil"
    (detect nil nil)
    nil)

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

@@ -0,0 +1,24 @@
+(examples-for dp
+  ("returns nil for nil"
+   (dp)
+   nil)
+
+  ("returns nil when everything is empty"
+   (dp "" nil {} ())
+   nil)
+
+  ("returns the first item if not empty"
+   (dp 'a "" {} ())
+   a)
+
+  ("returns the second item if not empty"
+   (dp "" 'b "" {} ())
+   b)
+
+  ("returns the third item if not empty"
+   (dp "" {} 'c "" {} ())
+   c)
+
+  ("returns the last item if not empty"
+   (dp "" {} () 'd)
+   d))

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

@@ -2,3 +2,8 @@
   ("iterates over each item in list"
    (let acc 0 (each x '(1 2 3 4) (assign acc (+ x acc))) acc)
    10))
+
+(examples-for each-with-index
+  ("iterates over each item in list"
+   (returnlet acc nil (each-with-index i x '(a b c d) (push (list i x) acc)))
+   ( (3 d) (2 c) (1 b) (0 a) )))

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/explain-mac-examples.nydp

@@ -13,7 +13,7 @@
 
   ("expands thrice for n = 3"
    (explain-mac 3 '(afn (a) (let b (+ 2 a) (* b b))))
-   (with (self nil) (assign self (fn (a) (let b (+ 2 a) (* b b))))))
+   ((fun (self) (assign self (fn (a) (let b (+ 2 a) (* b b))))) nil))
 
   ("expands four times for n = 4"
    (explain-mac 4 '(afn (a) (let b (+ 2 a) (* b b))))

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

@@ -1,3 +1,18 @@
+(examples-for filter-remove
+  ("removes (memoise) from a list of forms"
+   (filter-remove 'memoise '((trace)
+                             ;; this is a comment
+                             (memoise)
+                             (let x a
+                               (+ x b)
+                               (bingo dingbat))))
+   (((memoise))
+    ((trace)
+     (comment "this is a comment")
+     (let x a
+       (+ x b)
+       (bingo dingbat))))))
+
 (examples-for filter-forms
   ("groups forms by their 'car if the 'car is a key in the given hash"
    (let ff (filter-forms { car nil comment nil mac nil }

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/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)) )
@@ -49,6 +70,10 @@
    (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 whose entire content is a single interpolation"
+   (parse-in-string (joinstr "" (list '~ "(hello world)")))
+   (hello world))
+
   ("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>"))

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
@@ -282,12 +279,18 @@ toto")
 
   ("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!\"")
+   "\"hello ~~|!x.y.foo&bar| and welcome to ~~%%(a b c d) and friends!\"")
 
   ("percent-syntax"
    (pp '(percent-syntax || (dot-syntax x y)))
    "%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

@@ -3,14 +3,30 @@
    (⋂ '(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)))