nydp 0.4.2 → 0.5.1

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/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 })
@@ -29,7 +52,8 @@
 
   ("returns date operations"
    (sort:hash-keys (date 2015 11 18))
-   (beginning_of_month
+   (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/settings-examples.nydp

@@ -1,3 +1,6 @@
+(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)
@@ -17,8 +20,21 @@
 
   ("wraps arg in a fn expression if it is a hash"
    (settings/fn '{ a 1 b 2 })
-   (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"))

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

@@ -1,3 +1,51 @@
+(examples-for string-eval-fn
+  ("returns a function to eval a user-supplied string"
+   (let s "hello \~|u|, \~x + \~y is \~(+ x y), thank you!"
+     (let f (string-eval-fn s '(u x y))
+       (f "world" 37 5)))
+   "hello world, 37 + 5 is 42, thank you!"))
+
+(examples-for string/eval-with-args
+  ("evals a user-supplied string"
+   (let s "hello \~|u|, \~x + \~y is \~(+ x y), thank heavens!"
+     (string/eval-with-args s '(u x y) "world" 36 6))
+   "hello world, 36 + 6 is 42, thank heavens!")
+
+  ("reports errors"
+   (on-err errors
+           (let s "hello \~|u|, \~x + \~y is \~(+ x y), thank heavens!"
+             (string/eval-with-args s '(a b c) "world" 36 6)))
+   ("error evaluating \"hello \~|u|, \~x + \~y is \~(+ x y), thank heavens!\"
+with arg names (a b c)
+and args (\"world\" 36 6)"
+    "unbound symbol: y")))
+
+(examples-for string/pad-left
+  ("does not change a string whose length is greater than the given length"
+   (string/pad-left "Toronto" 3 "X")
+   "Toronto")
+
+  ("adds left padding to a string such that the result is the given length"
+   (string/pad-left "toto" 8 "X")
+   "XXXXtoto")
+
+  ("accepts multi-character padding"
+   (string/pad-left "toto" 12 "XYZ")
+   "XYZXYZXYtoto"))
+
+(examples-for string/pad-right
+  ("does not change a string whose length is greater than the given length"
+   (string/pad-right "Toronto" 3 "X")
+   "Toronto")
+
+  ("adds right padding to a string such that the result is the given length"
+   (string/pad-right "toto" 8 "X")
+   "totoXXXX")
+
+  ("accepts multi-character padding"
+   (string/pad-right "toto" 12 "XYZ")
+   "totoXYZXYZXY"))
+
 (examples-for string-split
   ("splits a string using given expression"
    (string-split "a and b and c and d" " and ")
@@ -7,6 +55,10 @@
    (collect !empty? (string-split "word"))
    ("w" "o" "r" "d"))
 
+  ("splits on regexp"
+   (string-split "hello, darkness ; my old friend\nI've come : to talk - with you again..." (regexp "\[\\n;:\\-,\]"))
+   ("hello" " darkness " " my old friend" "I've come " " to talk " " with you again..."))
+
   ("returns empty leading, internal, and trailing segments"
    (string-split "and" "and")
    ("" ""))
@@ -20,8 +72,22 @@
    (string-replace "and" "or" "a and b and c and d")
    "a or b or c or d")
 
+  ("replaces with hash lookup"
+   (string-replace
+     "['<>&\"]"
+     { "'" "&#39;"
+       "<" "&lt;"
+       ">" "&gt;"
+       "\"" "&quot;" }
+     "it's >such< a \"lovely\" day")
+   "it&#39;s &gt;such&lt; a &quot;lovely&quot; day")
+
   ("replace with regexp"
    (string-replace "and|or" "x" "a and b or c and d")
+   "a x b x c x d")
+
+  ("replace with literal regexp"
+   (string-replace (regexp "and|or") "x" "a and b or c and d")
    "a x b x c x d"))
 
 (examples-for string-truncate
@@ -90,4 +156,7 @@
 (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"      ))
+  ("removes leading and trailing whitespace"  (string-strip "\n\nme\n\n") "me"      )
+  ("ignores leading and trailing whitespace for intenal lines"
+   (string-strip "\n\n  me  \n\n  you  \n\n\t them \t\n\n")
+   "me  \n\n  you  \n\n\t them"      ))