conjur-asset-ui 1.3.0

data/vendor/prelude-ls/src/List.ls

@@ -0,0 +1,299 @@
+each = (f, xs) -->
+  for x in xs then f x
+  xs
+
+map = (f, xs) -->
+  [f x for x in xs]
+
+compact = (xs) -->
+  [x for x in xs when x]
+
+filter = (f, xs) -->
+  [x for x in xs when f x]
+
+reject = (f, xs) -->
+  [x for x in xs when not f x]
+
+partition = (f, xs) -->
+  passed = []
+  failed = []
+  for x in xs
+    (if f x then passed else failed).push x
+  [passed, failed]
+
+find = (f, xs) -->
+  for x in xs when f x then return x
+  void
+
+head = first = (xs) ->
+  return void unless xs.length
+  xs.0
+
+tail = (xs) ->
+  return void unless xs.length
+  xs.slice 1
+
+last = (xs) ->
+  return void unless xs.length
+  xs[*-1]
+
+initial = (xs) ->
+  len = xs.length
+  return void unless len
+  xs.slice 0, len - 1
+
+empty = (xs) ->
+  not xs.length
+
+reverse = (xs) ->
+  xs.concat!.reverse!
+
+unique = (xs) ->
+  result = []
+  for x in xs when x not in result
+    result.push x
+  result
+
+fold = foldl = (f, memo, xs) -->
+  for x in xs then memo = f memo, x
+  memo
+
+fold1 = foldl1 = (f, xs) -->
+  fold f, xs.0, xs.slice 1
+
+foldr = (f, memo, xs) -->
+  fold f, memo, (xs.concat!.reverse!)
+
+foldr1 = (f, xs) -->
+  ys = xs.concat!.reverse!
+  fold f, ys.0, ys.slice 1
+
+unfoldr = (f, b) -->
+  result = []
+  x = b
+  while (f x)?
+    result.push that.0
+    x = that.1
+  result
+
+concat = (xss) ->
+  [].concat.apply [], xss
+
+concat-map = (f, xs) -->
+  [].concat.apply [], [f x for x in xs]
+
+flatten = (xs) -->
+  [].concat.apply [], [(if typeof! x is 'Array' then flatten x else x) for x in xs]
+
+difference = (xs, ...yss) ->
+  results = []
+  :outer for x in xs
+    for ys in yss
+      continue outer if x in ys
+    results.push x
+  results
+
+intersection = (xs, ...yss) ->
+  results = []
+  :outer for x in xs
+    for ys in yss
+      continue outer unless x in ys
+    results.push x
+  results
+
+union = (...xss) ->
+  results = []
+  for xs in xss
+    for x in xs
+      results.push x unless x in results
+  results
+
+count-by = (f, xs) -->
+  results = {}
+  for x in xs
+    key = f x
+    if key of results
+      results[key] += 1
+    else
+      results[key] = 1
+  results
+
+group-by = (f, xs) -->
+  results = {}
+  for x in xs
+    key = f x
+    if key of results
+      results[key].push x
+    else
+      results[key] = [x]
+  results
+
+and-list = (xs) ->
+  for x in xs when not x
+    return false
+  true
+
+or-list = (xs) ->
+  for x in xs when x
+    return true
+  false
+
+any = (f, xs) -->
+  for x in xs when f x
+    return true
+  false
+
+all = (f, xs) -->
+  for x in xs when not f x
+    return false
+  true
+
+sort = (xs) ->
+  xs.concat!.sort (x, y) ->
+    if x > y
+      1
+    else if x < y
+      -1
+    else
+      0
+
+sort-with = (f, xs) -->
+  return [] unless xs.length
+  xs.concat!.sort f
+
+sort-by = (f, xs) -->
+  return [] unless xs.length
+  xs.concat!.sort (x, y) ->
+    if (f x) > (f y)
+      1
+    else if (f x) < (f y)
+      -1
+    else
+      0
+
+sum = (xs) ->
+  result = 0
+  for x in xs
+    result += x
+  result
+
+product = (xs) ->
+  result = 1
+  for x in xs
+    result *= x
+  result
+
+mean = average = (xs) ->
+  sum = 0
+  len = xs.length
+  for i til len
+    sum += xs[i]
+  sum / len
+
+maximum = (xs) ->
+  max = xs.0
+  for x in xs.slice 1 when x > max
+    max = x
+  max
+
+minimum = (xs) ->
+  min = xs.0
+  for x in xs.slice 1 when x < min
+    min = x
+  min
+
+scan = scanl = (f, memo, xs) -->
+  last = memo
+  [memo] ++ [last = f last, x for x in xs]
+
+scan1 = scanl1 = (f, xs) -->
+  return void unless xs.length
+  scan f, xs.0, xs.slice 1
+
+scanr = (f, memo, xs) -->
+  xs = xs.concat!.reverse!
+  (scan f, memo, xs).reverse!
+
+scanr1 = (f, xs) -->
+  return void unless xs.length
+  xs = xs.concat!.reverse!
+  (scan f, xs.0, xs.slice 1).reverse!
+
+slice = (x, y, xs) -->
+  xs.slice x, y
+
+take = (n, xs) -->
+  if n <= 0
+    xs.slice 0, 0
+  else if not xs.length
+    xs
+  else
+    xs.slice 0, n
+
+drop = (n, xs) -->
+  if n <= 0 or not xs.length
+    xs
+  else
+    xs.slice n
+
+split-at = (n, xs) --> [(take n, xs), (drop n, xs)]
+
+take-while = (p, xs) -->
+  len = xs.length
+  return xs unless len
+  i = 0
+  while i < len and p xs[i]
+    i += 1
+  xs.slice 0 i
+
+drop-while = (p, xs) -->
+  len = xs.length
+  return xs unless len
+  i = 0
+  while i < len and p xs[i]
+    i += 1
+  xs.slice i
+
+span = (p, xs) --> [(take-while p, xs), (drop-while p, xs)]
+
+break-list = (p, xs) --> span (not) << p, xs
+
+zip = (xs, ys) -->
+  result = []
+  len = ys.length
+  for x, i in xs
+    break if i is len
+    result.push [x, ys[i]]
+  result
+
+zip-with = (f, xs, ys) -->
+  result = []
+  len = ys.length
+  for x, i in xs
+    break if i is len
+    result.push f x, ys[i]
+  result
+
+zip-all = (...xss) ->
+  min-length = 9e9
+  for xs in xss
+    min-length <?= xs.length
+  [[xs[i] for xs in xss] for i til min-length]
+
+zip-all-with = (f, ...xss) ->
+  min-length = 9e9
+  for xs in xss
+    min-length <?= xs.length
+  [f.apply(null, [xs[i] for xs in xss]) for i til min-length]
+
+module.exports = {
+  each, map, filter, compact, reject, partition, find,
+  head, first, tail, last, initial, empty,
+  reverse, difference, intersection, union, count-by, group-by,
+  fold, fold1, foldl, foldl1, foldr, foldr1, unfoldr, and-list, or-list,
+  any, all, unique, sort, sort-with, sort-by, sum, product, mean, average,
+  concat, concat-map, flatten,
+  maximum, minimum, scan, scan1, scanl, scanl1, scanr, scanr1,
+  slice, take, drop, split-at, take-while, drop-while, span, break-list,
+  zip, zip-with, zip-all, zip-all-with,
+}

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

@@ -0,0 +1,83 @@
+max = (>?)
+
+min = (<?)
+
+negate = (x) -> -x
+
+abs = Math.abs
+
+signum = (x) ->
+  if x < 0
+    -1
+  else if x > 0
+    1
+  else
+    0
+
+quot = (x, y) --> ~~(x / y)
+
+rem = (%)
+
+div = (x, y) --> Math.floor x / y
+
+mod = (%%)
+
+recip = (1 /)
+
+pi = Math.PI
+
+tau = pi * 2
+
+exp = Math.exp
+
+sqrt = Math.sqrt
+
+ln = Math.log
+
+pow = (^)
+
+sin = Math.sin
+
+tan = Math.tan
+
+cos = Math.cos
+
+asin = Math.asin
+
+acos = Math.acos
+
+atan = Math.atan
+
+atan2 = (x, y) --> Math.atan2 x, y
+
+truncate = (x) -> ~~x
+
+round = Math.round
+
+ceiling = Math.ceil
+
+floor = Math.floor
+
+is-it-NaN = (x) -> x isnt x
+
+even = (x) -> x % 2 == 0
+
+odd = (x) -> x % 2 != 0
+
+gcd = (x, y) -->
+  x = Math.abs x
+  y = Math.abs y
+  until y is 0
+    z = x % y
+    x = y
+    y = z
+  x
+
+lcm = (x, y) -->
+  Math.abs Math.floor (x / (gcd x, y) * y)
+
+module.exports = {
+  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,
+}

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

@@ -0,0 +1,61 @@
+values = (object) ->
+  [x for , x of object]
+
+keys = (object) ->
+  [x for x of object]
+
+pairs-to-obj= (object) ->
+  {[x.0, x.1] for x in object}
+
+obj-to-pairs = (object) ->
+  [[key, value] for key, value of object]
+
+lists-to-obj= (keys, values) -->
+  {[key, values[i]] for key, i in keys}
+
+obj-to-lists = (objectect) ->
+  keys = []
+  values = []
+  for key, value of objectect
+    keys.push key
+    values.push value
+  [keys, values]
+
+
+empty = (object) ->
+  for x of object then return false
+  true
+
+each = (f, object) -->
+  for , x of object then f x
+  object
+
+map = (f, object) -->
+  {[k, f x] for k, x of object}
+
+compact = (object) -->
+  {[k, x] for k, x of object when x}
+
+filter = (f, object) -->
+  {[k, x] for k, x of object when f x}
+
+reject = (f, object) -->
+  {[k, x] for k, x of object when not f x}
+
+partition = (f, object) -->
+  passed = {}
+  failed = {}
+  for k, x of object
+    (if f x then passed else failed)[k] = x
+  [passed, failed]
+
+find = (f, object) -->
+  for , x of object when f x then return x
+  void
+
+module.exports = {
+  values, keys,
+  pairs-to-obj, obj-to-pairs, lists-to-obj, obj-to-lists,
+
+  empty, each, map, filter, compact, reject, partition, find,
+}

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

@@ -0,0 +1,32 @@
+split = (sep, str) -->
+  str.split sep
+
+join = (sep, xs) -->
+  xs.join sep
+
+lines = (str) ->
+  return [] unless str.length
+  str.split '\n'
+
+unlines = (.join '\n')
+
+words = (str) ->
+  return [] unless str.length
+  str.split /[ ]+/
+
+unwords = (.join ' ')
+
+chars = (.split '')
+
+unchars = (.join '')
+
+reverse = (str) ->
+  str.split '' .reverse!.join ''
+
+repeat = (n, str) -->
+  out = [str for til n]
+  out.join ''
+
+module.exports = {
+  split, join, lines, unlines, words, unwords, chars, unchars, reverse, repeat,
+}

data/vendor/prelude-ls/src/index.ls

@@ -0,0 +1,56 @@
+require! [
+  './Func.js'
+  './List.js'
+  './Obj.js'
+  './Str.js'
+  './Num.js'
+]
+
+id = (x) -> x
+
+is-type = (type, x) --> typeof! x is type
+
+replicate = (n, x) -->
+  [x for til n]
+
+
+Str <<< List{
+  empty, slice, take, drop, split-at, take-while, drop-while, span, break-str: break-list
+}
+
+prelude = {
+  Func, List, Obj, Str, Num,
+  id, is-type
+  replicate,
+}
+prelude <<< List{
+  each, map, filter, compact, reject, partition, find,
+  head, first, tail, last, initial, empty,
+  reverse, difference, intersection, union, count-by, group-by,
+  fold, foldl, fold1, foldl1, foldr, foldr1, unfoldr, and-list, or-list,
+  any, all, unique, sort, sort-with, sort-by, sum, product, mean, average,
+  concat, concat-map, flatten,
+  maximum, minimum, scan, scanl, scan1, scanl1, scanr, scanr1,
+  slice, take, drop, split-at, take-while, drop-while, span, break-list,
+  zip, zip-with, zip-all, zip-all-with,
+}
+prelude <<< Func{
+  apply, curry, flip, fix,
+}
+prelude <<< Str{
+  split, join, lines, unlines, words, unwords, chars, unchars
+}
+# not importing all of Obj's functions
+prelude <<< Obj{
+  values, keys,
+  pairs-to-obj, obj-to-pairs, lists-to-obj, obj-to-lists,
+}
+prelude <<< Num{
+  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,
+}
+
+prelude.VERSION = '1.0.3'
+
+module.exports = prelude

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

@@ -0,0 +1,36 @@
+{apply, curry, flip, fix} = require '..' .Func
+{equal: eq, deep-equal: deep-eq, ok} = require 'assert'
+
+suite 'apply' ->
+  test 'empty list' ->
+    f = -> 1
+    eq 1, apply f, []
+
+  test 'a couple of args' ->
+    eq 5, apply (+), [2 3]
+
+  test 'curried' ->
+    f = apply (+)
+    eq 5, f [2 3]
+
+suite 'curry' ->
+  test 'simple function' ->
+    add = (x, y) -> x + y
+    add-curried = curry add
+    add-four = add-curried 4
+    eq 6 add-four 2
+
+suite 'flip' ->
+  test 'minus op' ->
+    eq 10, (flip (-)) 5 15
+
+suite 'fix' ->
+  test 'single arg' ->
+    eq 89, (fix (fib) -> (n) ->
+      | n <= 1      => 1
+      | otherwise   => fib(n-1) + fib(n-2))(10)
+
+  test 'multi-arg variation' ->
+    eq 89, (fix (fib) -> (n, minus=0) ->
+      | (n - minus) <= 1 => 1
+      | otherwise        => fib(n, minus+1) + fib(n, minus+2))(10)