ruby-wisp-source 0.7.0

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/test/hub.js

@@ -0,0 +1,222 @@
+"use strict";
+
+var test = require("./util/test")
+var event = require("./util/event")
+
+var take = require("../take")
+var fold = require("../fold")
+var expand = require("../expand")
+var into = require("../into")
+var hub = require("../hub")
+var concat = require("../concat")
+var delay = require("../delay")
+var merge = require("../merge")
+var capture = require("../capture")
+var map = require("../map")
+var end = require("reducible/end")
+
+function lazy(f) { return expand(1, f) }
+
+exports["test hub open / close propagate"] = test(function(assert) {
+  var c = event()
+  var h = hub(c)
+
+  assert.ok(!c.isOpen, "event is not open")
+  assert.ok(!c.isEnded, "event is not ended")
+
+  var actual = into(h)
+
+  assert.ok(c.isOpen, "event is open after reduce is called")
+  assert.ok(!c.isEnded, "event is not closed until close is called")
+
+  c.send(1)
+  c.send(2)
+  c.send(3)
+  c.send(end)
+
+  assert.ok(c.isEnded, "event ended")
+
+  assert(actual, [1, 2, 3], "all value were propagated")
+})
+
+exports["test multiple subscribtion"] = test(function(assert) {
+  var c = event()
+  var h = hub(c)
+  var p1 = into(h)
+
+  var p2 = into(h)
+
+
+  c.send(1)
+
+  var p3 = into(h)
+
+  c.send(2)
+  c.send(3)
+
+  var p4 = into(h)
+
+  c.send(end)
+
+  var actual = concat("p1", p1, "p2", p2, "p3", p3, "p4", p4)
+
+  assert(actual, [
+    "p1", 1, 2, 3,
+    "p2", 1, 2, 3,
+    "p3", 2, 3,
+    "p4"
+  ], "reduce accumulates values send after reduce is called")
+})
+
+exports["test source is closed on end"] = test(function(assert) {
+  var c = event()
+  var h = hub(c)
+  var t = take(h, 2)
+
+  var actual = into(t)
+
+  c.send(1)
+  c.send(2)
+
+  assert.ok(c.isReduced, "event is closed once consumer is done")
+
+  assert(actual, [ 1, 2 ], "value propagated")
+})
+
+exports["test source is closed on last end"] = test(function(assert) {
+  var c = event()
+  var h = hub(c)
+  var t1 = take(h, 1)
+  var t2 = take(h, 2)
+  var t3 = take(h, 3)
+
+  var p1 = into(t1)
+
+  var p2 = into(t2)
+
+  c.send(1)
+
+  var p3 = into(t3)
+
+  c.send(2)
+  c.send(3)
+  c.send(4)
+
+  assert.ok(c.isReduced, "event reduced")
+
+  var actual = concat("#1", p1, "#2", p2, "#3", p3)
+  assert(actual, [
+    "#1", 1,
+    "#2", 1, 2,
+    "#3", 2, 3, 4
+  ], "take picks items from where reduce accumulates")
+})
+
+exports["test hub with non signals"] = function(assert) {
+  assert.equal(hub(null), null, "null is considered to be a hub")
+  assert.equal(hub(), undefined, "undefined is considered to be a hub")
+
+
+  var h = hub([ 1, 2, 3 ])
+  var p1 = into(h)
+  var p2 = into(h)
+
+  assert.deepEqual(p1, [ 1, 2, 3 ], "first reduce got all items")
+  assert.deepEqual(p2, [ 1, 2, 3 ], "second reduce got all items")
+}
+
+exports["test hub with sync steam"] = test(function(assert) {
+  var source = hub([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 ])
+
+  var s1_3 = take(source, 3)
+  var s4_8 = take(source, 5)
+  var s9_$ = source
+
+  var actual = concat(s1_3, [ "-" ], s4_8, [ "-" ], s9_$)
+
+  assert(actual, [ 1, 2, 3, "-", 4, 5, 6, 7, 8, "-", 9, 10, 11, 12, 13, 14 ],
+         "hub took items in parts")
+})
+
+exports["test hub with async stream"] = test(function(assert) {
+  var source = hub(delay([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 ]))
+
+  var actual = concat(take(source, 3),
+                      "-",
+                      lazy(function() {
+                        return merge([take(source, 5), take(source, 8)])
+                      }),
+                      "-",
+                      lazy(function() {
+                        return source
+                      }),
+                      "-",
+                      lazy(function() {
+                        return source
+                      }))
+
+  assert(actual, [
+    1, 2, 3, "-",
+    4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 11, "-",
+    12, 13, 14, "-"
+  ], "reads in the same turn share head")
+})
+
+exports["test hub with broken stream"] = test(function(assert) {
+  var boom = Error("boom!")
+  var source = hub(concat(delay([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 ]),
+                   boom))
+
+  var transformed = concat(take(source, 3),
+                      "-",
+                      lazy(function() {
+                        return merge([take(source, 5), take(source, 8)])
+                      }),
+                      "-",
+                      lazy(function() {
+                        return source
+                      }),
+                      "-",
+                      lazy(function() {
+                        return source
+                      }))
+  var actual = capture(transformed, function(error) {
+    return error.message
+  })
+
+
+  assert(actual, [
+    1, 2, 3, "-",
+    4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 11, "-",
+    12, 13, 14,
+    boom.message
+  ], "reads in the same turn share head")
+
+})
+
+exports["test map hub"] = test(function(assert) {
+  var called = 0
+  var c = event()
+  var h1 = hub(c)
+  var m = map(h1, function(x) {
+    called = called + 1
+    return x
+  })
+  var h2 = hub(m)
+
+  var actual = concat(into(h2),
+                      into(h2),
+                      "x",
+                      lazy(function() { return called }))
+
+  c.send(1)
+  c.send(2)
+  c.send(3)
+  c.send(end)
+
+  assert(actual, [ 1, 2, 3, 1, 2, 3, "x", 3 ],
+         "hub dispatches on consumers")
+})
+
+if (require.main === module)
+  require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/test/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+exports["test filter"] = require("./filter")
+exports["test map"] = require("./map")
+exports["test take"] = require("./take")
+exports["test take while"] = require("./take-while")
+exports["test drop"] = require("./drop")
+exports["test drop while"] = require("./drop-while")
+exports["test into"] = require("./into")
+exports["test concat"] = require("./concat")
+exports["test merge"] = require("./merge")
+
+exports["test capture"] = require("./capture")
+
+exports["test hub"] = require("./hub")
+
+exports["test delay"] = require("./delay")
+exports["test reductions"] = require("./reductions")
+exports["test fold"] = require("./fold")
+
+exports["test errors"] = require("./errors")
+
+require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/test/into.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var into = require("../into")
+
+exports["test into"] = function(assert) {
+  var source = [ 1, 2, 3 ]
+  assert.deepEqual(into(source), [ 1, 2, 3 ],
+                   "returns identical")
+  assert.notEqual(into(source), source,
+                  "but different one")
+}
+
+exports["test into buffer"] = function(assert) {
+  var buffer = [ 0 ]
+  assert.equal(into([ 1, 2, 3 ], buffer), buffer,
+               "reduces into buffer if provided")
+  assert.deepEqual(buffer, [ 0, 1, 2, 3 ],
+                   "pre-existing items in buffer are kept")
+}
+
+if (module == require.main)
+  require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/test/map.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var test = require("./util/test")
+var delay = require("../delay")
+var concat = require("../concat")
+var capture = require("../capture")
+var map = require("../map")
+var into = require("../into")
+
+exports["test map sequence"] = function(assert) {
+  var called = 0
+  var source = [ 1, 2, 3 ]
+  var actual = map(source, function(item) {
+    called = called + 1
+    return item + 10
+  })
+
+  assert.equal(called, 0, "map does not invokes until result is reduced")
+  assert.deepEqual(into(actual), [ 11, 12, 13 ], "values are mapped")
+  assert.equal(called, 3, "mapper called once per item")
+}
+
+exports["test map value"] = function(assert) {
+  var called = 0
+  var actual = map(7, function(item) {
+    called = called + 1
+    return item + 10
+  })
+
+  assert.equal(called, 0, "map does not invokes until result is reduced")
+  assert.deepEqual(into(actual), [ 17 ], "values is mapped")
+  assert.equal(called, 1, "mapper called once per item")
+}
+
+exports["test map empty"] = test(function(assert) {
+  var actual = map([], function(element) {
+    throw Error("map fn was executed")
+  })
+
+  assert(actual, [], "mapping empty is empty")
+})
+
+
+exports["test number map"] = test(function(assert) {
+  var numbers = [1, 2, 3, 4]
+  var actual = map(numbers, function(number) { return number * 2 })
+
+  assert(actual, [2, 4, 6, 8], "numbers are doubled")
+})
+
+exports["test map with async stream"] = test(function(assert) {
+  var source = delay([5, 4, 3, 2, 1])
+  var actual = map(source, function(x) { return x + 1 })
+  assert(actual, [6, 5, 4, 3, 2], "async number stream is incermented")
+})
+
+exports["test map broken stream"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var source = concat([3, 2, 1], boom)
+  var mapped = map(delay(source), function(x) { return x * x })
+  var actual = capture(mapped, function(error) { return error.message })
+
+  assert(actual, [9, 4, 1, boom.message], "errors propagate")
+})
+
+if (require.main === module)
+  require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/test/merge.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var test = require("./util/test")
+
+var concat = require("../concat")
+var into = require("../into")
+var delay = require("../delay")
+var capture = require("../capture")
+var map = require("../map")
+var expand = require("../expand")
+var take = require("../take")
+var merge = require("../merge")
+var into = require("../into")
+
+exports["test merge"] = function(assert) {
+  var source = [ [ 1 ], [ 2, 3 ], [ 4, 5, 6 ] ]
+  var actual = merge(source)
+
+  assert.deepEqual(into(actual),
+                   [ 1, 2, 3, 4, 5, 6 ],
+                   "merge reducers")
+  assert.deepEqual(into(actual),
+                   [ 1, 2, 3, 4, 5, 6 ],
+                   "can be re-reduced")
+  assert.deepEqual(source, [ [ 1 ], [ 2, 3 ], [ 4, 5, 6 ] ],
+                   "no changes to a source")
+}
+
+exports["test merge stream of empty streams"] = test(function(assert) {
+  var actual = merge([[], []])
+
+  assert(actual, [], "merge of empty streams is empty")
+})
+
+exports["test merge empty & non-empty"] = test(function(assert) {
+  var actual = merge([[], [1, 2], []])
+
+  assert(actual, [1, 2], "merge with empties is non-empty")
+})
+
+exports["test merge flattened"] = test(function(assert) {
+  var stream = merge([[1, 2], ["a", "b"]])
+  var actual = merge([[">"], stream, []])
+
+  assert(actual, [">", 1, 2, "a", "b"], "flattening flattened works")
+})
+
+exports["test merge sync & async streams"] = test(function(assert) {
+  var async = delay([3, 2, 1])
+  var actual = merge([async, ["|"], async, ["a", "b"], []])
+
+  assert(actual, ["|", "a", "b", 3, 3, 2, 2, 1, 1], "orders by time")
+})
+
+exports["test merge with broken stream"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var async = delay(concat([3, 2, 1], boom))
+  var flattened = merge([[">"], async, [1, 2]])
+  var actual = capture(flattened, function(error) {
+    return error.message
+  })
+
+  assert(actual, [">", 1, 2, 3, 2, 1, boom.message], "errors propagate")
+})
+
+exports["test merge async stream of streams"] = test(function(assert) {
+  var async = delay([3, 2, 1])
+  var actual = merge([[], [1, 2], async, ["a", "b"], async])
+
+  assert(actual, [1, 2, "a", "b", 3, 3, 2, 2, 1, 1], "mixed stream works")
+})
+
+
+if (module == require.main)
+  require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/test/reductions.js

@@ -0,0 +1,105 @@
+"use strict";
+
+var test = require("./util/test")
+var lazy = require("./util/lazy")
+var delay = require("../delay")
+var concat = require("../concat")
+var capture = require("../capture")
+var reductions = require("../reductions")
+
+exports["test reductions over empty"] = test(function(assert) {
+  var called = 0
+  var source = reductions([], function(state, x) {
+    called = called + 1
+    return state + x
+  })
+  var actual = concat(source,
+                      "x",
+                      lazy(function() { return called }))
+
+  assert(actual, ["x", 0], "reductions over empty is empty")
+})
+
+exports["test reductions over null"] = test(function(assert) {
+  var called = 0
+  var source = reductions(null, function(state, x) {
+    called = called + 1
+    return state + x
+  }, 0)
+  var actual = concat(source,
+                      "x",
+                      lazy(function() { return called }))
+
+  assert(actual, ["x", 0], "reductions over null is empty")
+})
+
+exports["test reductions over void"] = test(function(assert) {
+  var called = 0
+  var source = reductions(void(0), function(state, x) {
+    called = called + 1
+    return state + x
+  }, 0)
+  var actual = concat(source,
+                      "x",
+                      lazy(function() { return called }))
+
+  assert(actual, ["x", 0], "reductions over void is empty")
+})
+
+exports["test reductions over number"] = test(function(assert) {
+  var called = 0
+  var source = reductions(0, function(state, x) {
+    called = called + 1
+    return state + x
+  }, 0)
+  var actual = concat(source,
+                      "x",
+                      lazy(function() { return called }))
+
+  assert(actual, [0, "x", 1], "reductions over number")
+})
+
+
+exports["test reductions over sequnce"] = test(function(assert) {
+  var called = 0
+  var source = reductions([1, 1, 1, 1], function(state, x) {
+    called = called + 1
+    return state + x
+  }, 0)
+  var actual = concat(source,
+                      "x",
+                      lazy(function() { return called }))
+
+  assert(actual, [1, 2, 3, 4, "x", 4], "reductions over number")
+})
+
+exports["test reductions over async"] = test(function(assert) {
+  var called = 0
+  var source = reductions(delay([1, 1, 1, 1]), function(state, x) {
+    called = called + 1
+    return state + x
+  }, 0)
+  var actual = concat(source,
+                      "x",
+                      lazy(function() { return called }))
+
+  assert(actual, [1, 2, 3, 4, "x", 4], "reductions over number")
+})
+
+exports["test reductions over broken"] = test(function(assert) {
+  var called = 0
+  var boom = Error("boom")
+  var source = reductions(delay([1, 1, 1, 1, boom]), function(state, x) {
+    called = called + 1
+    return state + x
+  }, 0)
+  var recovered = capture(source, function(error) { return error.message })
+  var actual = concat(recovered,
+                      "x",
+                      lazy(function() { return called }))
+
+  assert(actual, [1, 2, 3, 4, boom.message, "x", 4], "reductions over broken")
+})
+
+if (require.main === module)
+  require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/test/take-while.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var test = require("./util/test")
+var lazy = require("./util/lazy")
+var concat = require("../concat")
+var delay = require("../delay")
+var capture = require("../capture")
+
+var takeWhile = require("../take-while")
+var into = require("../into")
+
+exports["test takeWhile"] = function(assert) {
+  var called = 0
+  var source = [ 1, 2, 3, 4 ]
+  var actual = takeWhile(source, function(item) {
+    called = called + 1
+    return item <= 2
+  })
+
+  assert.equal(called, 0, "takeWhile does not invokes until result is reduced")
+  assert.deepEqual(into(actual), [ 1, 2 ], "items were taken")
+  assert.equal(called, 3, "taker called until it returns false")
+  assert.deepEqual(into(actual), [ 1, 2 ], "can be re-reduced")
+}
+
+exports["test takeWhile none"] = function(assert) {
+  var called = 0
+  var source = [ 1, 2, 3, 4 ]
+  var actual = takeWhile(source, function(item) {
+    called = called + 1
+    return false
+  })
+
+  assert.equal(called, 0, "takeWhile does not invokes until result is reduced")
+  assert.deepEqual(into(actual), [], "0 items were taken")
+  assert.equal(called, 1, "taker called once")
+}
+
+exports["test takeWhile all"] = function(assert) {
+  var called = 0
+  var source = [ 1, 2, 3 ]
+  var actual = takeWhile(source, function(item) {
+    called = called + 1
+    return true
+  })
+
+  assert.equal(called, 0, "takeWhile does not invokes until result is reduced")
+  assert.deepEqual(into(actual), [ 1, 2, 3 ], "all items were taken")
+  assert.equal(called, 3, "taker called on each item")
+}
+
+exports["test take while on empty"] = test(function(assert) {
+  var called = 0
+  var source = takeWhile([], function(n) {
+    called = called + 1
+    return n <= 9
+  })
+
+  var actual = concat(source,
+                      "x",
+                      lazy(function() { return called }))
+
+  assert(actual, ["x", 0], "nothing to take from empty no calls to f")
+})
+
+exports["test take while"] = test(function(assert) {
+  var called = 0
+  var source = takeWhile([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], function(n) {
+    called = called + 1
+    return n <= 9
+  })
+
+  var actual = concat(source,
+                      "x",
+                      lazy(function() { return called }))
+
+
+  assert(actual, [1, 2, 3, 4, 5, 6, 7, 8, 9, "x", 10],
+         "called until returned false")
+})
+
+exports["test take while ends"] = test(function(assert) {
+  var called = 0
+  var source = takeWhile([1, 2, 3, 4, 5, 6, 7], function(n) {
+    called = called + 1
+    return n <= 9
+  })
+
+  var actual = concat(source,
+                      "x",
+                      lazy(function() { return called }))
+
+
+  assert(actual, [1, 2, 3, 4, 5, 6, 7, "x", 7],
+         "takes until exhasted")
+})
+
+exports["test take while on async stream"] = test(function(assert) {
+  var called = 0
+  var source =  delay([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
+  var taken = takeWhile(source, function(n) {
+    called = called + 1
+    return n <= 9
+  })
+  var actual = concat(taken,
+                      "x",
+                      lazy(function() { return called }))
+
+
+
+  assert(actual, [1, 2, 3, 4, 5, 6, 7, 8, 9, "x", 10],
+        "called until returned false")
+})
+
+exports["test error propagation in to take while"] = test(function(assert) {
+  var called = 0, boom = Error("boom!")
+  var source = concat([1, 2, 3, 4, 5], boom, [6, 7])
+  var taken = takeWhile(source, function(n) {
+    called = called + 1
+    return n <= 9
+  })
+  var recovered = capture(taken, function(error) {
+    return error.message
+  })
+  var actual = concat(recovered,
+                      "x",
+                      lazy(function() { return called }))
+
+  assert(actual, [1, 2, 3, 4, 5, boom.message, "x", 5], "called until error")
+})
+
+
+if (module == require.main)
+  require("test").run(exports)