ruby-wisp-source 0.7.0

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/test/drop-while.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var test = require("./util/test")
+var lazy = require("./util/lazy")
+
+var concat = require("../concat")
+var dropWhile = require("../drop-while")
+var into = require("../into")
+var delay = require("../delay")
+var capture = require("../capture")
+
+
+exports["test drop while"] = function(assert) {
+  var called = 0
+  var source = [ 1, 2, 3, 4 ]
+  var actual = dropWhile(source, function(item) {
+    called = called + 1
+    return item <= 2
+  })
+
+  assert.equal(called, 0, "dropWhile does not invokes until result is reduced")
+  assert.deepEqual(into(actual), [ 3, 4 ], "items were dropped")
+  assert.equal(called, 3, "dropWhile called until it returns false")
+  assert.deepEqual(into(actual), [ 3, 4 ], "can be re-reduced")
+}
+
+exports["test drop while none"] = function(assert) {
+  var called = 0
+  var source = [ 1, 2, 3 ]
+  var actual = dropWhile(source, function(item) {
+    called = called + 1
+    return false
+  })
+
+  assert.equal(called, 0, "dropWhile does not invokes until result is reduced")
+  assert.deepEqual(into(actual), [ 1, 2, 3 ], "0 items were dropped")
+  assert.equal(called, 1, "dropper called only once")
+}
+
+exports["test drop while all"] = function(assert) {
+  var called = 0
+  var source = [ 1, 2, 3 ]
+  var actual = dropWhile(source, function(item) {
+    called = called + 1
+    return true
+  })
+
+  assert.equal(called, 0, "dropWhile does not invokes until result is reduced")
+  assert.deepEqual(into(actual), [], "all items were dropped")
+  assert.equal(called, 3, "dropper called on each item")
+}
+
+exports["test drop while on empty"] = test(function(assert) {
+  var called = 0
+  var dropped = dropWhile([], function(n) {
+    called = called + 1
+    return n <= 9
+  })
+
+  var actual = concat(dropped,
+                      lazy(function() { return called }))
+
+  assert(actual, [0], "nothing to drop")
+})
+
+exports["test drop.while"] = test(function(assert) {
+  var called = 0
+  var dropped = dropWhile([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], function(n) {
+    called = called + 1
+    return n <= 9
+  })
+  var actual = concat(dropped,
+                      lazy(function() { return called }))
+
+  assert(actual, [10, 11, 12, 10], "called until returned false")
+})
+
+exports["test drop.while end"] = test(function(assert) {
+  var called = 0
+  var dropped = dropWhile([1, 2, 3, 4, 5, 6, 7], function(n) {
+    called = called + 1
+    return n <= 9
+  })
+  var actual = concat(dropped,
+                      lazy(function() { return called }))
+
+  assert(actual, [7], "called until returned false")
+})
+
+exports["test drop while on async stream"] = test(function(assert) {
+  var called = 0
+  var stream = delay([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
+  var dropped = dropWhile(stream, function(n) {
+    called = called + 1
+    return n <= 9
+  })
+  var actual = concat(dropped,
+                      lazy(function() { return called }))
+
+  assert(actual, [10, 11, 12, 10], "called until returned false")
+})
+
+exports["test error propagation in drop.while"] = test(function(assert) {
+  var called = 0, boom = Error("boom!")
+  var stream = concat([1, 2, 3, 4, 5], boom, [6, 7])
+  var dropped = dropWhile(stream, function(n) {
+    called = called + 1
+    return n <= 3
+  })
+  var captured = capture(dropped, function(error) { return error.message })
+  var actual = concat(captured,
+                      lazy(function() { return called }))
+
+  assert(actual, [4, 5, boom.message, 4], "called until error ocurred")
+})
+
+if (require.main === module)
+  require("test").run(exports)

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/test/drop.js

@@ -0,0 +1,89 @@
+"use strict";
+
+var test = require("./util/test")
+var lazy = require("./util/lazy")
+
+var into = require("../into")
+var drop = require("../drop")
+var delay = require("../delay")
+var concat = require("../concat")
+var capture = require("../capture")
+
+
+exports["test drop"] = function(assert) {
+  var actual = drop([ 1, 2, 3, 4 ], 2)
+
+  assert.deepEqual(into(actual), [ 3, 4 ], "skipped two items")
+  assert.deepEqual(into(actual), [ 3, 4 ], "can be re-reduced same")
+}
+
+exports["test drop none"] = function(assert) {
+  var actual = drop([ 1, 2, 3, 4 ], 0)
+
+  assert.deepEqual(into(actual), [ 1, 2, 3, 4 ], "skips none on 0")
+}
+
+exports["test drop all"] = function(assert) {
+  var actual = drop([ 1, 2, 3, 4 ], 100)
+
+  assert.deepEqual(into(actual), [],
+                   "skips all if has less than requested")
+}
+
+exports["test drop empty"] = test(function(assert) {
+  var actual = drop([], 100)
+
+  assert(actual, [], "drop on empty is empty")
+})
+
+
+
+exports["test drop on sync stream"] = test(function(assert) {
+  var actual = drop([1, 2, 3, 4], 3)
+
+  assert(actual, [4], "dropped all except last")
+})
+
+exports["test drop falls back to 1"] = test(function(assert) {
+  var actual = drop([1, 2, 3, 4], Infinity)
+
+  assert(actual, [], "dropped every item")
+})
+
+exports["test drop can take 0"] = test(function(assert) {
+  var actual = drop([1, 2, 3, 4], 0)
+
+  assert(actual, [1, 2, 3, 4], "dropped none")
+})
+
+exports["test drop more than have"] = test(function(assert) {
+  var actual = drop([1, 2, 3, 4], 5)
+
+  assert(actual, [], "dropped more the contained")
+})
+
+exports["test drop of async stream"] = test(function(assert) {
+  var actual = drop(delay([5, 4, 3, 2, 1]), 2)
+
+  assert(actual, [3, 2, 1], "drop 2 from async")
+})
+
+exports["test drop on stream with error"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var dropped = drop(delay(concat([4, 3, 2, 1], boom)), 2)
+  var actual = capture(dropped, function(error) { return error.message })
+
+  assert(actual, [2, 1, boom.message], "dropped on broken stream")
+})
+
+exports["test drop on stream with error in head"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var dropped = drop(delay(concat(boom, [4, 3, 2, 1])), 2)
+  var actual = capture(dropped, function(error) { return error.message })
+
+  assert(actual, [boom.message], "attempt to drop on early errors")
+})
+
+
+if (require.main === module)
+  require("test").run(exports)

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/test/errors.js

@@ -0,0 +1,222 @@
+"use strict";
+
+var test = require("./util/test")
+var event = require("./util/event")
+var fold = require("../fold")
+var map = require("../map")
+var capture = require("../capture")
+
+
+exports["test error in input"] = function(assert) {
+  var boom = Error("Boom")
+  var input = [1, 2, boom]
+  var delivered = []
+  assert.throws(function() {
+    fold(input, function(value) {
+      delivered.push(value)
+    })
+  }, "If errors reach fold they are thrown")
+
+  assert.deepEqual(delivered, [1, 2], "first two items were passed to fold")
+}
+
+exports["test transformation errors are thrown by fold"] = function(assert) {
+  var boom = Error("Boom")
+  var source = [1, 2, 3, 4]
+  var delivered = []
+  var input = map(source, function(value) {
+    if (value > 2) throw boom
+    return value
+  })
+
+  assert.throws(function() {
+    fold(input, function(value, result) {
+      delivered.push(value)
+    }, [])
+  }, "Transformation errors are thrown if they reach fold")
+
+  assert.deepEqual(delivered, [1, 2], "items yield before error reach fold")
+}
+
+exports["test error in transformation"] = function(assert) {
+  var captured = false
+  var boom = Error("Boom")
+  var source = [1, 2, 3, 4]
+  var input = map(source, function(value) {
+    if (value > 2) throw boom
+    return value
+  })
+  var fixed = capture(input, function(error) {
+    captured = true
+    assert.equal(error, boom, "Error was captured")
+    return ["interrupt"]
+  })
+
+  var result = fold(fixed, function(value, result) {
+    result.push(value)
+    return result
+  }, [])
+
+  assert.ok(capture, "error handler was invoked")
+  assert.deepEqual(result, [1, 2, "interrupt"], "recovered from error")
+}
+
+exports["test error in recovery code"] = function(assert) {
+  var boom = Error("Boom")
+  var brax = Error("BraxXXx")
+  var captured = false
+  var delivered = []
+
+  var source = [1, 2, 3, 4]
+  var input = map(source, function(value) {
+    if (value > 2) throw boom
+    return value
+  })
+  var fixed = capture(input, function(error) {
+    captured = true
+    assert.equal(error, boom, "Error was captured")
+    throw brax
+  })
+
+  assert.throws(function() {
+    fold(fixed, function(value, result) {
+      delivered.push(value)
+    }, [])
+  }, "Errors from recovery code are thrown if they reach fold")
+
+  assert.ok(capture, "Firs error was captured")
+  assert.deepEqual(delivered, [1, 2], "items yield before error reach fold")
+}
+
+exports["test error in the recovered stream"] = function(assert) {
+  var boom = Error("Boom")
+  var brax = Error("BraxXXx")
+
+  var captured = false
+  var delivered = []
+
+  var source = [1, 2, 3, 4]
+  var input = map(source, function(value) {
+    if (value > 2) throw boom
+    return value
+  })
+
+  var fixed = capture(input, function(error) {
+    captured = true
+    assert.equal(error, boom, "Error was captured")
+    return ["a", "b", brax, "c"]
+  })
+
+  assert.throws(function() {
+    fold(fixed, function(value, result) {
+      delivered.push(value)
+    }, [])
+  }, "Error in recovery collection are thrown if they reach fold")
+
+  assert.ok(capture, "Firs error was captured")
+  assert.deepEqual(delivered, [1, 2, "a", "b"],
+                   "items yield before error reach fold")
+}
+
+exports["test second recovery"] = function(assert) {
+  var boom = Error("Boom")
+  var brax = Error("BraxXXx")
+
+  var captured = false
+  var recaptured = false
+  var delivered = []
+
+  var source = [1, 2, 3, 4]
+  var input = map(source, function(value) {
+    if (value > 2) throw boom
+    return value
+  })
+
+  var fixed = capture(input, function(error) {
+    captured = true
+    assert.equal(error, boom, "Error was captured")
+    return ["a", "b", brax, "c"]
+  })
+
+  var mapped = map(fixed, function(x) { return x + "!" })
+
+  var final = capture(mapped, function(error) {
+    recaptured = true
+    assert.equal(error, brax, "Error was re-captured")
+    return "I give up"
+  })
+
+  var result = fold(final, function(value) {
+    delivered.push(value)
+  })
+
+  assert.ok(capture, "Firs error was captured")
+  assert.ok(recaptured, "Second error was captured")
+
+  assert.deepEqual(delivered, ["1!", "2!", "a!", "b!", "I give up"],
+                   "items yield before error reach fold")
+}
+
+exports["test error in fold"] = function(assert) {
+  var input = [1, 2, 3, 4]
+
+  assert.throws(function() {
+    fold(input, function(value) {
+      throw Error("Nope")
+    })
+  }, "Errors in fold are thrown")
+}
+
+
+exports["test intermidiate error in fold"] = function(assert) {
+  var input = [1, 2, 3, 4]
+  var delivered = []
+
+  assert.throws(function() {
+    fold(input, function(value) {
+      delivered.push(value)
+      if (delivered.length > 2) throw Error("Stop it already!")
+    })
+  }, "Occasional errors in fold are thrown out")
+
+  assert.deepEqual(delivered, [1, 2, 3], "items before error are accumulated")
+}
+
+exports["test error values are thrown if they reach fold"] = function(assert) {
+  var boom = Error("Boom")
+  var source = [1, 2, 3, 4]
+  var input = map(source, function(value) {
+    return value === 3 ? boom :
+           value
+  })
+  var delivered = []
+
+  assert.throws(function() {
+    fold(input, function(value) {
+      delivered.push(value)
+    })
+  }, "Error values passed to fold are thrown")
+
+  assert.deepEqual(delivered, [1, 2], "items till error value are accumulated")
+}
+
+exports["test errors propagate through folds"] = function(assert) {
+  var boom = Error("Boom")
+  var source = event()
+
+  var result = fold(source, function(value, result) {
+    result.push(value)
+    return result
+  }, [])
+
+  source.send(1)
+  assert.throws(function() {
+    source.send(boom)
+  }, "Error is thrown by fold if error reaches it")
+
+  assert.throws(function() {
+    fold(result, function() {
+      assert.fail(Error("Should not be called"))
+    })
+  }, "Error is thrown by folding an errored fold")
+}

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/test/filter.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var test = require("./util/test")
+var lazy = require("./util/lazy")
+
+var filter = require("../filter")
+var into = require("../into")
+var concat = require("../concat")
+var delay = require("../delay")
+var capture = require("../capture")
+
+
+exports["test filter"] = function(assert) {
+  var called = 0
+  var source = [ 1, 2, 3 ]
+  var actual = filter(source, function(item) {
+    called = called + 1
+    return item % 2
+  })
+
+  assert.equal(called, 0, "filter does not invokes until result is reduced")
+  assert.deepEqual(into(actual), [ 1, 3 ], "items were filtered")
+  assert.equal(called, 3, "filterer called once per item")
+}
+
+exports["test filter empty"] = test(function(assert) {
+  var called = 0
+  var filtered = filter([], function onEach(element) {
+    called = called + 1
+  })
+  var actual = concat(filtered,
+                      lazy(function() { return called }))
+
+  assert(actual, [0], "filter `f` was not executed")
+})
+
+exports["test filter numbers"] = test(function(assert) {
+  var called = 0
+  var filtered = filter([1, 2, 3, 4], function(n) {
+    called = called + 1
+    return n % 2
+  })
+  var actual = concat(filtered,
+                      lazy(function() { return called }))
+
+  assert(actual, [1, 3, 4], "filter `f` was called once per element")
+})
+
+exports["test filter async stream"] = test(function(assert) {
+  var called = 0
+  var filtered = filter(delay([5, 4, 3, 2, 1]), function(n) {
+    called = called + 1
+    return n % 2
+  })
+  var actual = concat(filtered,
+                      lazy(function() { return called }))
+
+  assert(actual, [5, 3, 1, 5], "predicate was called once per element")
+})
+
+exports["test errors propagate"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var filtered = filter(delay(concat([3, 2, 1], boom)), function(n) {
+    return n % 2
+  })
+  var actual = capture(filtered, function(e) { return e.message })
+
+  assert(actual, [3, 1, boom.message], "error do propagate")
+})
+
+if (require.main === module)
+  require("test").run(exports)

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/test/fold.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var fold = require("../fold")
+var reduced = require("reducible/reduced")
+var into = require("../into")
+
+
+exports["test reduce"] = function(assert) {
+  var result = fold([ 1, 2, 3 ], function(value, state) {
+    return state + value
+  }, 0)
+
+  assert.equal(result, 6, "value is accumulated")
+}
+
+exports["test reduced early"] = function(assert) {
+  var result = fold([ 1, 2, 3 ], function(value, state) {
+    return reduced("nope")
+  }, 0)
+
+  assert.equal(result, "nope", "early reduce value is accumulated")
+}
+
+exports["test fold errored"] = function(assert) {
+  var boom = Error("Boom!")
+  assert.throws(function() {
+    fold([ 1, 2, boom ], function(value, state) {
+      return state + value
+    }, 0)
+  }, /Boom!/, "fold throws any propagated errors")
+}
+
+exports["test fold late error"] = function(assert) {
+  var boom = Error("Boom!")
+  var result = fold([ 1, 2, boom ], function(value, state) {
+    return reduced("Wheuh")
+  }, 0)
+
+  assert.equal(result, "Wheuh", "late errors are irrelevant")
+}
+
+exports["test fold null"] = function(assert) {
+  var result = fold(null, function(value, state) {
+    return state + value
+  }, 0)
+
+  assert.equal(result, 0, "null reduces to initial")
+}
+
+exports["test fold void"] = function(assert) {
+  var result = fold(void(0), function(value, state) {
+    return state + value
+  }, 0)
+
+  assert.equal(result, 0, "void reduces to initial")
+}
+
+exports["test fold empty"] = function(assert) {
+  var result = fold([], function(value, state) {
+    return state + value
+  }, 0)
+
+  assert.equal(result, 0, "[] reduces to initial")
+}
+
+exports["test fold string"] = function(assert) {
+  var result = fold("world", function(value, state) {
+    return state + value
+  }, "hello ")
+
+  assert.equal(result, "hello world", "string is equivalent of array of itself")
+}
+
+exports["test fold number"] = function(assert) {
+  var result = fold(7, function(value, state) {
+    return state + value
+  }, 10)
+
+  assert.equal(result, 17, "number is equivalent of array of itself")
+}
+
+exports["test fold object"] = function(assert) {
+  var result = fold({}, function(value, state) {
+    return state + value
+  }, "hello ")
+
+  assert.equal(result, "hello " + {},
+               "object is equivalent of array of itself")
+}
+
+exports["test fold object"] = function(assert) {
+  var boom = Error("Boom!")
+  assert.throws(function() {
+    fold(boom, function(value, state) {
+      return state + value
+    }, "hello ")
+  }, /Boom!/, "fold throws errors")
+}
+
+exports["test reducer thorws"] = function(assert) {
+  var error = Error("I hate 2")
+  assert.throws(function() {
+    fold([ 1, 2, 3 ], function(value, state) {
+      if (value === 2) throw error
+      return state + value
+    }, 0)
+  }, /I hate 2/, "thrown errors propagate")
+}
+
+if (require.main === module)
+  require("test").run(exports)