conjur-asset-ui 1.3.0

data/vendor/prelude-ls/test/Num.ls

@@ -0,0 +1,258 @@
+{
+  max, min, negate, abs, signum, quot, rem, div, mod, recip,
+  pi, tau, exp, sqrt, ln, pow, sin, tan, cos, acos, asin, atan, atan2,
+  truncate, round, ceiling, floor, is-it-NaN, even, odd, gcd, lcm,
+} = require '..'
+{equal: eq, deep-equal: deep-eq, ok} = require 'assert'
+
+suite 'max' ->
+  test 'numbers' ->
+    eq 3, max 3 3
+    eq 3, max 2 3
+    eq 3, max 3 2
+
+  test 'characters' ->
+    eq \b, max \a \b
+
+  test 'curried' ->
+    f = max 2
+    eq 3, f 3
+
+suite 'min' ->
+  test 'numbers' ->
+    eq 0, min 9 0
+
+  test 'characters' ->
+    eq \a, min \a \b
+
+  test 'curried' ->
+    f = min 9
+    eq 0, f 0
+
+suite 'negate' ->
+  test 'zero' ->
+    eq 0, negate 0
+
+  test 'negative number' ->
+    eq -2, negate 2
+
+  test 'positive number' ->
+    eq 3, negate -3
+
+suite 'abs' ->
+  test 'zero' ->
+    eq 0, abs 0
+
+  test 'negative number' ->
+    eq 4 abs -4
+
+  test 'positive number' ->
+    eq 4 abs  4
+
+suite 'signum' ->
+  test 'zero' ->
+    eq 0  signum 0
+
+  test 'negative number' ->
+    eq -1 signum -5.3
+
+  test 'positive number' ->
+    eq 1  signum 8
+
+suite 'quot' ->
+  test 'simple' ->
+    eq -6, quot -20 3
+
+  test 'curried' ->
+    f = quot -20
+    eq -6, f 3
+
+suite 'rem' ->
+  test 'simple' ->
+    eq -2, rem -20 3
+
+  test 'curried' ->
+    f = rem -20
+    eq -2, f 3
+
+suite 'div' ->
+  test 'simple' ->
+    eq -7, div -20 3
+
+  test 'curried' ->
+    f = div -20
+    eq -7, f 3
+
+suite 'mod' ->
+  test 'simple' ->
+    eq 1, mod -20 3
+
+  test 'curried' ->
+    f = mod -20
+    eq 1, f 3
+
+suite 'recip' ->
+  test 'zero' ->
+    eq Infinity, recip 0
+
+  test 'larger than 1' ->
+    eq 0.5, recip 2
+
+  test 'between 0 and 1' ->
+    eq 2, recip 0.5
+
+suite 'pi' ->
+  test 'constant' ->
+    eq 3.141592653589793, pi
+
+suite 'tau' ->
+  test 'constant' ->
+    eq 6.283185307179586, tau
+
+suite 'exp' ->
+  test 'simple' ->
+    eq 2.718281828459045, exp 1
+
+suite 'sqrt' ->
+  test 'negative numbers' ->
+    ok is-it-NaN sqrt -1
+
+  test 'simple' ->
+    eq 2 sqrt 4
+
+suite 'ln' ->
+  test 'simple' ->
+    eq 0.6931471805599453, ln 2
+
+suite 'pow' ->
+  test 'simple' ->
+    eq 4, pow 2 2
+    eq 4, pow -2 2
+
+  test 'with negative numbers' ->
+    eq 0.25, pow 2 -2
+
+  test 'between one and zero' ->
+    eq 4, pow 16 0.5
+
+  test 'curried' ->
+    f = pow 2
+    eq 4, f 2
+
+suite 'sin' ->
+  test 'zero' ->
+    eq 0, sin 0
+
+  test 'one' ->
+    eq 0.8414709848078965, sin 1
+
+suite 'tan' ->
+  test 'zero' ->
+    eq 0, tan 0
+
+  test 'one' ->
+    eq 1.5574077246549023, tan 1
+
+suite 'cos' ->
+  test 'zero' ->
+    eq 1, cos 0
+
+  test 'one' ->
+    eq 0.5403023058681398, cos 1
+
+suite 'acos' ->
+  test 'number' ->
+    eq 1.4706289056333368, acos 0.1
+
+suite 'asin' ->
+  test 'number' ->
+    eq 1.5707963267948966, asin 1
+
+suite 'atan' ->
+  test 'number' ->
+    eq 0.7853981633974483, atan 1
+
+suite 'atan2' ->
+  test 'number' ->
+    eq 0.4636476090008061, atan2 1 2
+
+  test 'curried' ->
+    f = atan2 1
+    eq 0.4636476090008061, f 2
+
+suite 'truncate' ->
+  test 'zero' ->
+    eq 0, truncate 0
+
+  test 'positive number' ->
+    eq  1 truncate  1.5
+
+  test 'negative number' ->
+    eq -1 truncate -1.5
+
+suite 'round' ->
+  test 'up' ->
+    eq 1 round 0.6
+    eq 1 round 0.5
+
+  test 'down' ->
+    eq 0 round 0.4
+
+suite 'ceiling' ->
+  test 'zero' ->
+    eq 0, ceiling 0
+
+  test 'positive number' ->
+    eq 1, ceiling 0.1
+
+  test 'negative number' ->
+    eq 0, ceiling -0.9
+
+suite 'floor' ->
+  test 'zero' ->
+    eq 0, floor 0
+
+  test 'positive number' ->
+    eq 0, floor 0.9
+
+  test 'negative number' ->
+    eq -1, floor -0.1
+
+suite 'is-it-NaN' ->
+  test 'true' ->
+    ok is-it-NaN Math.sqrt -1
+
+  test 'false' ->
+    ok not is-it-NaN '0'
+
+suite 'even' ->
+  test 'true' ->
+    ok even 0
+    ok even -2
+
+  test 'false' ->
+    ok not even 7
+
+suite 'odd' ->
+  test 'true' ->
+    ok odd 3
+
+  test 'false' ->
+    ok not odd -4
+    ok not odd 0
+
+suite 'gcd' ->
+  test 'some numbers' ->
+    eq 6, gcd 12 18
+
+  test 'curried' ->
+    f = gcd 12
+    eq 6, f 18
+
+suite 'lcm' ->
+  test 'some numbers' ->
+    eq 36, lcm 12 18
+
+  test 'curried' ->
+    f = lcm 12
+    eq 36, f 18

data/vendor/prelude-ls/test/Obj.ls

@@ -0,0 +1,145 @@
+{
+  id
+  Obj: {
+    values, keys,
+    pairs-to-obj, obj-to-pairs, lists-to-obj, obj-to-lists,
+    empty, each, map, filter, compact, reject, partition, find,
+  }
+} = require '..'
+{equal: eq, deep-equal: deep-eq, ok} = require 'assert'
+
+suite 'values' ->
+  test 'empty object as input' ->
+    deep-eq [], values {}
+
+  test 'object as input' ->
+    deep-eq [1 2 3], values sadf: 1, asdf: 2, fdas: 3
+
+suite 'keys' ->
+  test 'empty object as input' ->
+    deep-eq [], keys {}
+
+  test 'object as input' ->
+    deep-eq <[ sadf asdf fdas ]>, keys sadf: 1, asdf: 2, fdas: 3
+
+suite 'pairs-to-obj' ->
+  test 'empty list as input' ->
+    deep-eq {}, pairs-to-obj []
+
+  test 'pairs as input' ->
+    deep-eq {a: 'b', c: 'd', e: 1}, pairs-to-obj [['a' 'b'] ['c' 'd'] ['e' 1]]
+
+suite 'obj-to-pairs' ->
+  test 'empty object as input' ->
+    deep-eq [], obj-to-pairs {}
+
+  test 'object as input' ->
+    deep-eq [['a' 'b'] ['c' 'd'] ['e' 1]], obj-to-pairs {a: 'b', c: 'd', e: 1}
+
+suite 'lists-to-obj' ->
+  test 'empty lists as input' ->
+    deep-eq {}, lists-to-obj [] []
+
+  test 'two lists of the same length' ->
+    deep-eq  {a: 1, b: 2, c: 3}, lists-to-obj <[ a b c ]> [1 2 3]
+
+  test 'first list is shorter' ->
+    deep-eq  {a: 1, b: 2}, lists-to-obj <[ a b ]> [1 2 3]
+
+  test 'first list is longer' ->
+    deep-eq  {a: 1, b: 2, c: void}, lists-to-obj <[ a b c ]> [1 2]
+
+  test 'curried' ->
+    f = lists-to-obj <[ a b c ]>
+    deep-eq  {a: 1, b: 2, c: 3}, f [1 2 3]
+
+suite 'obj-to-lists' ->
+  test 'empty object as input' ->
+    deep-eq [[], []], obj-to-lists {}
+
+  test 'two lists of the same length' ->
+    deep-eq [<[ a b c ]>, [1 2 3]], obj-to-lists {a: 1, b: 2, c: 3}
+
+suite 'empty' ->
+  test 'empty object as input' ->
+    ok empty {}
+
+  test 'non-empty object as input' ->
+    ok not empty {x: 1}
+
+suite 'each' ->
+  test 'empty object as input' ->
+    deep-eq {}, each id, {}
+
+  test 'iterate over object values' ->
+    count = 4
+    each (-> count += it), {a: 1, b: 2, c: 3}
+    eq 10 count
+
+  test 'curried' ->
+    count = 4
+    f = each (-> count += it)
+    f {a: 1, b: 2, c: 3}
+    eq 10 count
+
+suite 'map' ->
+  test 'empty object as input' ->
+    deep-eq {}, map id, {}
+
+  test 'mapping over object' ->
+    deep-eq {a:2, b:4}, map (* 2), {a:1, b:2}
+
+  test 'curried' ->
+    f = map (* 2)
+    deep-eq {a:2, b:4}, f {a:1, b:2}
+
+suite 'compact' ->
+  test 'empty object as input' ->
+    deep-eq {}, compact {}
+
+  test 'compacting object' ->
+    deep-eq {b: 1, e: 'ha'}, compact {a: 0, b: 1, c: false, d: '', e: 'ha'}
+
+suite 'filter' ->
+  test 'empty object as input' ->
+    deep-eq {}, filter id, {}
+
+  test 'filtering object' ->
+    deep-eq {b: 2}, filter (== 2), {a:1, b:2}
+
+  test 'curried' ->
+    f = filter (== 2)
+    deep-eq {b: 2}, f {a:1, b:2}
+
+suite 'reject' ->
+  test 'empty object as input' ->
+    deep-eq {}, reject id, {}
+
+  test 'reject object' ->
+    deep-eq {a: 1}, reject (==2), {a:1, b:2}
+
+  test 'curried' ->
+    f = reject (== 2)
+    deep-eq {a: 1}, f {a:1, b:2}
+
+suite 'partition' ->
+  test 'empty object as input' ->
+    deep-eq [{}, {}], partition id, {}
+
+  test 'partition object' ->
+    deep-eq [{b: 2}, {a: 1, c: 3}], partition (==2), {a:1, b:2, c:3}
+
+  test 'curried' ->
+    f = partition (== 2)
+    deep-eq [{b: 2}, {a: 1, c: 3}], f {a:1, b:2, c:3}
+
+suite 'find' ->
+  test 'empty object as input' ->
+    eq void, find id, {}
+
+  test 'find from object' ->
+    eq 2, find (==2), {a:1, b:2}
+
+  test 'curried' ->
+    f = find (== 2)
+    eq 2, f {a:1, b:2}

data/vendor/prelude-ls/test/Prelude.ls

@@ -0,0 +1,49 @@
+{id, is-type, replicate} = require '..'
+{equal: eq, deep-equal: deep-eq, ok} = require 'assert'
+
+suite 'id' ->
+  test 'number' ->
+    eq 5, id 5
+
+  test 'object is the same' ->
+    obj = {}
+    eq obj, id obj
+
+suite 'is-type' ->
+  test 'literals' ->
+    ok is-type 'Undefined' void
+    ok is-type 'Boolean' true
+    ok is-type 'Number' 1
+    ok is-type 'Number' 1.2
+    ok is-type 'String' 'asdfa'
+    ok is-type 'Object' {}
+    ok is-type 'Array' []
+
+    ok not is-type 'Boolean' 1
+
+  test 'constructors' ->
+    ok is-type 'Date' new Date
+
+  test 'classes' ->
+    class A
+
+    ok is-type 'Object' new A
+
+  test 'curried' ->
+    f = is-type 'Boolean'
+    ok f true
+
+suite 'replicate' ->
+  test 'zero as input' ->
+    deep-eq [], replicate 0 0
+    deep-eq [], replicate 0 'a'
+
+  test 'number as input' ->
+    deep-eq [3,3,3,3], replicate 4 3
+
+  test 'string as input' ->
+    deep-eq <[ a a a a ]>, replicate 4 'a'
+
+  test 'curried' ->
+    f = replicate 4
+    deep-eq [3,3,3,3], f 3

data/vendor/prelude-ls/test/Str.ls

@@ -0,0 +1,208 @@
+{
+  id
+  Str: {
+    split, join, lines, unlines, words, unwords, chars, unchars, empty, reverse, repeat,
+    slice, take, drop, split-at, take-while, drop-while, span, break-str
+  }
+} = require '..'
+{equal: eq, deep-equal: deep-eq, ok} = require 'assert'
+
+suite 'split' ->
+  test 'empty string as input' ->
+    deep-eq [], split '' ''
+
+  test 'string of some length' ->
+    deep-eq <[ 1 2 3 ]>, split '|' '1|2|3'
+
+  test 'curried' ->
+    f = split '|'
+    deep-eq <[ 1 2 3 ]>, f '1|2|3'
+
+suite 'join' ->
+  test 'empty list as input' ->
+    eq '' join '', []
+
+  test 'list as input' ->
+    eq '1,2,3', join ',' [1 2 3]
+
+  test 'empty string as seperator' ->
+    eq '123', join '' [1 2 3]
+
+  test 'curried' ->
+    f = join ','
+    eq '1,2,3', f [1 2 3]
+
+suite 'lines' ->
+  test 'empty string as input' ->
+    deep-eq [], lines ''
+
+  test 'string as input' ->
+    deep-eq <[ one two three ]>, lines 'one\ntwo\nthree'
+
+suite 'unlines' ->
+  test 'empty array as input' ->
+    eq '', unlines []
+
+  test 'array as input' ->
+    eq 'one\ntwo\nthree', unlines [\one \two \three]
+
+suite 'words' ->
+  test 'empty string as input' ->
+    deep-eq [], words ''
+
+  test 'string as input' ->
+    deep-eq <[ what is this ]>, words 'what   is  this'
+
+suite 'unwords' ->
+  test 'empty array as input' ->
+    eq '', unwords []
+
+  test 'array as input' ->
+    eq 'what is this', unwords [\what \is \this]
+
+suite 'chars' ->
+  test 'empty string as input' ->
+    deep-eq [], chars ''
+
+  test 'string as input' ->
+    deep-eq <[ h e l l o ]>, chars 'hello'
+
+suite 'unchars' ->
+  test 'empty array as input' ->
+    eq '', unchars []
+
+  test 'array as input' ->
+    eq 'there', unchars ['t', 'h', 'e', 'r', 'e']
+
+suite 'empty' ->
+  test 'empty string as input' ->
+    ok empty ''
+
+  test 'string as input' ->
+    ok not empty 'a'
+
+suite 'reverse' ->
+  test 'empty string as input' ->
+    eq '', reverse ''
+
+  test 'a string' ->
+    eq 'cba', reverse 'abc'
+    eq 'olleh', reverse 'hello'
+
+suite 'repeat' ->
+  test 'zero times' ->
+    eq '' repeat 0 'hi'
+
+  test 'empty string as input' ->
+    eq '', repeat 2 ''
+
+  test 'a string several times' ->
+    eq 'aa', repeat 2 'a'
+    eq 'hihihi', repeat 3 'hi'
+
+  test 'curried' ->
+    f = repeat 2
+    eq 'aa', f 'a'
+
+suite 'slice' ->
+  test 'zero to zero' ->
+    eq '', slice 0 0 'hello'
+
+  test 'empty string as input' ->
+    eq '', slice  2 3 ''
+
+  test 'parts' ->
+    eq 'll', slice 2 4 'hello'
+
+  test 'curried' ->
+    f = slice 2
+    eq 'll', f 4 'hello'
+
+    g = slice 2 4
+    eq 'll', g 'hello'
+
+suite 'take' ->
+  test 'empty string as input' ->
+    eq '', take 3 ''
+
+  test 'zero on string' ->
+    eq '', take 0 'abcde'
+
+  test 'string' ->
+    eq 'ab', take 2 'abcde'
+
+  test 'curried' ->
+    f = take 2
+    eq 'ab', f 'abcde'
+
+suite 'drop' ->
+  test 'empty string as input' ->
+    eq '', drop 3 ''
+
+  test 'zero on string' ->
+    eq 'abcde', drop 0 'abcde'
+
+  test 'string' ->
+    eq 'cde', drop 2 'abcde'
+
+  test 'curried' ->
+    f = drop 2
+    eq 'cde', f 'abcde'
+
+suite 'split-at' ->
+  test 'empty string as input' ->
+    deep-eq ['', ''], split-at 3 ''
+
+  test 'zero on string' ->
+    deep-eq ['', 'abcde'], split-at 0 'abcde'
+
+  test 'string' ->
+    deep-eq ['ab', 'cde'], split-at 2 'abcde'
+
+  test 'curried' ->
+    f = split-at 2
+    deep-eq ['ab', 'cde'], f 'abcde'
+
+suite 'take-while' ->
+  test 'empty string as input' ->
+    eq '', take-while id, ''
+
+  test 'string' ->
+    eq 'mmmmm', take-while (is 'm'), 'mmmmmhmm'
+
+  test 'curried' ->
+    f = take-while (is 'm')
+    eq 'mmmmm', f 'mmmmmhmm'
+
+suite 'drop-while' ->
+  test 'empty string as input' ->
+    eq '', drop-while id, ''
+
+  test 'string' ->
+    eq 'hmm', drop-while (is \m), 'mmmmmhmm'
+
+  test 'curried' ->
+    f = drop-while (is \m)
+    eq 'hmm', f 'mmmmmhmm'
+
+suite 'span' ->
+  test 'empty string as input' ->
+    deep-eq ['', ''], span id, ''
+
+  test 'string' ->
+    deep-eq ['mmmmm', 'hmm'], span (is \m), 'mmmmmhmm'
+
+  test 'curried' ->
+    f = span (is \m)
+    deep-eq ['mmmmm', 'hmm'], f 'mmmmmhmm'
+
+suite 'break-str' ->
+  test 'empty string as input' ->
+    deep-eq ['', ''], break-str id, ''
+
+  test 'string' ->
+    deep-eq ['mmmmm', 'hmm'], break-str (is \h), 'mmmmmhmm'
+
+  test 'curried' ->
+    f = break-str (is \h)
+    deep-eq ['mmmmm', 'hmm'], f 'mmmmmhmm'

data/vendor/prelude-ls/test/browser.html

@@ -0,0 +1,5 @@
+<!doctype html>
+<script src="../browser/prelude-browser.js"></script>
+<script>
+  window.prelude = require('prelude-ls');
+</script>