ruby-wisp-source 0.7.0

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

@@ -0,0 +1,106 @@
+"use strict";
+
+var reducible = require("../reducible")
+
+var reduce = require("../reduce")
+var end = require("../end")
+var reduced = require("../reduced")
+
+exports["test reducible"] = function(assert) {
+  var actual = []
+  var fixture = reducible(function(next, result) {
+    result = next(1, result)
+    result = next(2, result)
+    next(end, result)
+  })
+
+  reduce(fixture, function(value, result) {
+    actual.push(value, result)
+    return result + value
+  }, 0)
+
+  assert.deepEqual(actual, [1, 0, 2, 1, end, 3], "reducible works")
+}
+
+exports["test error force ends reducibles"] = function(assert) {
+  var actual = []
+  var boom = Error("boom!!")
+  var fixture = reducible(function(next, result) {
+    result = next(1, result)
+    next(boom, result)
+    next(2)
+    next(Error("BraxxxX"))
+    next(3)
+    next(end)
+    next(4)
+  })
+
+  reduce(fixture, function(value, result) {
+    actual.push(value, result)
+    return result + value
+  }, 0)
+
+  assert.deepEqual(actual, [1, 0, boom, 1], "error ends reducible")
+}
+
+exports["test end force end reducibles"] = function(assert) {
+  var actual = []
+  var fixture = reducible(function(next, result) {
+    result = next(1, result)
+    next(end, result)
+    next(2)
+    next(3)
+    next(Error("Boom!!"))
+    next(4)
+    next(end)
+    next(5)
+  })
+
+  reduce(fixture, function(value, result) {
+    actual.push(value, result)
+    return result + value
+  }, 0)
+
+  assert.deepEqual(actual, [1, 0, end, 1], "end force ends reducible")
+}
+
+exports["test exceptions force end reducibles"] = function(assert) {
+  var actual = []
+  var boom = Error("Boom!!")
+  var fixture = reducible(function(next, result) {
+    result = next(1, result)
+    result = next(2, result)
+    result = next(3, result)
+    result = next(4, result)
+    next(end, result)
+  })
+
+  reduce(fixture, function(value, result) {
+    if (value === 3) throw boom
+    actual.push(value, result)
+    return result + value
+  }, 0)
+
+  assert.deepEqual(actual, [1, 0, 2, 1, boom, 3],
+                   "exception force ends reducible")
+}
+
+exports["test exceptions in reducible force end"] = function(assert) {
+  var actual = []
+  var boom = Error("Boom!!")
+  var fixture = reducible(function(next, result) {
+    result = next(1, result)
+    throw boom
+  })
+
+  reduce(fixture, function(value, result) {
+    actual.push(value, result)
+    return result + value
+  }, 0)
+
+  assert.deepEqual(actual, [1, 0, boom, 1],
+                   "exceptions in reducible force end")
+}
+
+if (require.main === module)
+  require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "reducers",
+  "id": "reducers",
+  "version": "3.0.0-alpha",
+  "description": "Library for higher-order manipulation of collections",
+  "keywords": [
+    "reducers",
+    "reducible",
+    "reduce",
+    "data",
+    "sequence",
+    "stream",
+    "collection",
+    "transformation",
+    "composable",
+    "async",
+    "signal",
+    "manipulation"
+  ],
+  "author": {
+    "name": "Irakli Gozalishvili",
+    "email": "rfobic@gmail.com",
+    "url": "http://jeditoolkit.com"
+  },
+  "homepage": "https://github.com/Gozala/reducers",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gozala/reducers.git",
+    "web": "https://github.com/Gozala/reducers"
+  },
+  "bugs": {
+    "url": "http://github.com/Gozala/reducers/issues/"
+  },
+  "dependencies": {
+    "reducible": "~1.x.0"
+  },
+  "devDependencies": {
+    "test": "~0.5.2",
+    "repl-utils": "~2.0.1",
+    "benchmark": ">=0.3.0",
+    "phantomify": "~0.x.0"
+  },
+  "scripts": {
+    "test": "npm run test-node && npm run test-browser",
+    "test-browser": "node ./node_modules/phantomify/bin/cmd.js ./test/index.js",
+    "test-node": "node ./test/index.js",
+    "repl": "node node_modules/repl-utils",
+    "benchmark": "node test/benchmark.js"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/Gozala/reducers/License.md"
+    }
+  ],
+  "readme": "# reducers\n\n[![Build Status](https://secure.travis-ci.org/Gozala/reducers.png)](http://travis-ci.org/Gozala/reducers)\n\nLibrary for higher-order manipulation of collections, based upon [reduce][].\n\n## Rationale\n\nMost functional languages (including beloved JS) typically come with some\ncollection transformation functions like [filter][] and [map][] that take a\nlogical collections and return transformed version of it. Unfortunately they\ntend to [complect][], by implying mechanism, order, laziness and\nrepresentation. This library is an attempt to provide simple solution for\nsome of the hard problems by decomplecting and building upon simple premise -\nminimum definition of collection is something that is reducible.\n\nMore specifically library defines super-generalized and minimal abstraction for\ncollections - a collection is some set of things that, when given a function to\napply to its contents, can do so and give you the result, i.e. a collection is\n(at minimum) **reducible**. In other words, you can call `reduce` on it.\n\nA very minimal abstraction for collection is more powerful than it may seem at\nfirst!\n\n## Basics\n\nDemonstration of features of this library requires some basic understanding of\nthe abstraction above. So let's take a more practical look at the idea. Let's\nsay we have a `reduce` function with *(very familiar)* API:\n\n```js\nreduce(source, f, initial) // => accumulated result\n```\n\nIt takes reducing function, a reducible `source` and `initial` value to\naccumulate reductions upon. In return it outputs an accumulated result.\nReducing functions performing accumulation have a following shape:\n\n```js\nf(result, value) // => new result\n```\n\nA reducing function is simply a binary function, akin to the one you might pass\nto reduce. While the two arguments might be treated symmetrically by the\nfunction, there is an implied semantic that distinguishes the arguments:\nthe first argument is a `result` or accumulator that is being built up by the\nreduction, while the second is some new input `value` from the source being\nreduced.\n\n## Transformations\n\nAll of the collection operations can be expressed in terms of transformations.\nBy the definition all transformations will produce **reducible** collections\nthat can be reduced via `reduce` function defined above:\n\n```js\nmap(source, JSON.parse) // => reducible collection\nfilter(numbers, isEven) // => reducible collection\n```\n\nIn order to explain transformations we'll need a primitive API for producing\n**reducible** collections. Let's define one in form of `reducible` function\nthat takes `accumulator` function and returns something that can be reduced\nvia `reduce` function:\n\n\n```js\nreducible(accumulator) // => reducible\n```\n\nArgument it takes, `accumulator` is a function that performs has following shape:\n\n```js\naccumulate(next, initial) // => accumulated result\n```\n\nAnd when invoked it performs reductions via `next` reducing function starting\nfrom `initial` result.\n\n\nNow consider following implementation of `map` & `filter` transformation\nfunctions:\n\n```js\nfunction map(f, source) {\n  return reducible(function accumulator(next, initial) {\n    return reduce(source, function reducer(result, input) {\n      return next(result, f(input))\n    }, initial)\n  })\n}\n\nfunction filter(predicate, source) {\n  return reducible(function accumulator(next, initial) {\n    return reduce(source, function reducer(result, input) {\n      return predicate(input) ? next(result, input) : result\n    }, initial)\n  })\n}\n```\n\nThere are a few things to note here:\n\n  - Type of the source is irrelevant as long as it is reducible and there for\n    can be reduced via `reduce` function.\n  - Transformations do not traverse collections, instead they compose results\n    that can be reduced by a receiver of the result later.\n  - Transformations do not imply timing in which `reducer` in invoked with an\n    each `input` of the `source`, there for `source` can be asynchronous.\n  - Filtering can *skip* inputs by simply returning the incoming result.\n\n\n## Features\n\n### Laziness\n\nLibrary consists of transformation functions which, as seen above, when called\ndo nothing except the creation of a recipe for a new collection, a recipe that\nis itself reducible. No work is done yet to the contained elements and no\nconcrete collection is produced. All the transformations defer actual work\nto a point where result of transformations pipeline is being reduced.\n\nThe beautiful thing is that this mechanism also works for all other traditional\ntransformations `take`, `drop`, `merge` etc. Note the fact that `filter` is\n(potentially) contractive, and flatten is (potentially) expansive per step -\nthe mechanism is general and not limited to 1:1 transformations.\n\n### Uniformity\n\nTransformation functions are absolutely agnostic of the actual type of the\n`source`, as they just describe transformations and leave it up to `source`\nto do a reduction when result is consumed.\n\nLibrary takes a advantage of this feature and takes it even step further by\ntreating every possible value as a reducible collection. Non collection values\nlike numbers, booleans, objects etc. are treated as collection of single item,\nitem being a value. Also `null` and `undefined` are considered as empty\ncollections.\n\nThis means that library can be used on any data type and more importantly\ntransformations between different data types & compose naturally, which is\ngreat, let's you define logic in terms of abstractions instead of specific\ntypes.\n\n### Composability\n\nAll the transformations are fully composable as a matter of fact transformation\npipelines produce compositions equivalent of a function compositions created by\na [compose][]. Also type agnostic nature of the transformation functions enables\ncompositions between different types of data.\n\n### Performance\n\nSince transformations doesn't do the work, but merely create a recipe, there is\nno per-step allocation overhead, so it's faster. Also note that transformations\nare composed by curring transformation functions and all the actual work happens\nin a pipe line at the end when result is consumed, which means that no\nintermediate collections are produced, unlike it's a case with arrays etc..\n\nThink [monad][] & [category theory][] if you fancy that.\n\nIt can even [outperform arrays][benchmarks] when used wisely, although it's not\nthe point & arrays are not the primary use case.\n\n### Asynchronicity\n\nAs it was already pointed out transformation functions do not imply any timing\nof individual value delivery, which means they can be used on asynchronous\ndata structures like [node streams][stream-reduce] or [FRP][] events & signals.\n\nThis feature is extremely powerful as it allows structuring complex asynchronous\nprograms in simple intuitive code without a [callback hell][] and manual error\npropagation. _See [lstree][] for examples_.\n\nEven better actually exact same code can be used with both synchronous and\nasynchronous data structures. For example exact same code in [fs-reduce][]\ncan be forced to do blocking IO by via `options.sync` option.\n\n### Extensibility\n\nSince transformations are `source` type agnostic it's highly extensible. In\nfact implementation is based of polymorphic [method][] dispatch library and\nenables one to add support for new data types without any changes to this\nlibrary or data types / classes them self. This feature is used by\n[stream-reduce][] library to add support for node streams. There are more\nexamples of this feature in [callback-reduce][], [dom-reduce][],\n[http-reduce][]...\n\nVery likely all data types like `signal` provided by this library will be move\nout into own libraries too.\n\n### Automatic disposal\n\nReducible data structures feature auto cleanup of the resources at the end of\nconsumption. For example [dom-reduce][] and [fs-reduce][] use this feature to\nremove event listeners / close file descriptors once input is consumed and to\nset you free from clean up constraints. This means you spend more time on\nactual problems rather and less on plumbing.\n\n### Infinity\n\nInfinite data structures can be trivially represented via reducibles since\nnothing implies the end. In fact [dom-reduce][] uses this feature to represent\nuser events in form of reducibles that pretty much can be infinite.\n\nThat being said reducibles are not the best abstraction for the some types of\ninfinite data structures specially ones that rather better be polled instead.\n\n## F.A.Q.\n\n\n##### 1. Q: Can this handle \"back pressure\" ?  \n   \n**A:** Short answer is **Yes**.\n\nSee [IO Coordination] for more detailed answer\n\n\n\n\n## Install\n\n    npm install reducers\n\n## Prior art\n\n- [Clojure reducers][]\n- [Haskell Enumerator/Iteratee][]\n\n[Clojure reducers]:http://clojure.com/blog/2012/05/15/anatomy-of-reducer.html\n[Haskell Enumerator/Iteratee]:http://www.haskell.org/haskellwiki/Enumerator_and_iteratee\n\n[reduce]:http://en.wikipedia.org/wiki/Reduce_%28higher-order_function%29\n[map reduce]:http://en.wikipedia.org/wiki/MapReduce\n[map]:https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/map\n[filter]:https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/filter\n[Uniformity]:http://en.wikipedia.org/wiki/Uniformity_%28complexity%29#Uniformity\n[complect]:http://www.infoq.com/presentations/Simple-Made-Easy\n[compose]:http://underscorejs.org/#compose\n[monad]:http://en.wikipedia.org/wiki/Monad_%28category_theory%29\n[Category theory]:http://en.wikipedia.org/wiki/Category_theory]\n[benchmarks]:http://jsperf.com/reducibles/4\n[stream-reduce]:https://github.com/Gozala/stream-reduce\n[FRP]:http://en.wikipedia.org/wiki/Functional_reactive_programming\n[method]:https://github.com/Gozala/method\n[callback-reduce]:https://github.com/Gozala/callback-reduce\n[dom-reduce]:https://github.com/Gozala/dom-reduce\n[http-reduce]:https://github.com/Gozala/http-reduce\n[callback hell]:http://callbackhell.com/\n[fs-reduce]:https://github.com/Gozala/fs-reduce\n[lstree]:https://github.com/Gozala/callback-reduce\n\n[IO Coordination]:https://github.com/Gozala/reducers/wiki/IO-Coordination\n",
+  "readmeFilename": "Readme.md",
+  "_id": "reducers@3.0.0-alpha",
+  "_from": "reducers"
+}

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/reducer.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var reduce = require("reducible/reduce")
+var reducible = require("reducible/reducible")
+var isError = require("reducible/is-error")
+var end = require("reducible/end")
+
+
+function reducer(process) {
+  /**
+  Convenience function to simplify definitions of transformation function, to
+  avoid manual definition of `reducible` results and currying transformation
+  function. It creates typical transformation function with a following
+  signature:
+
+      transform(source, options)
+
+  From a pure data `process` function that is called on each value for a
+  collection with following arguments:
+
+    1. `options` - Options passed to the resulting transformation function
+       most commonly that's a function like in `map(source, f)`.
+    2. `next` - Function which needs to be invoked with transformed value,
+       or simply not called to skip the value.
+    3. `value` - Last value emitted by a collection being reduced.
+    4. `result` - Accumulate value.
+
+  Function is supposed to return new, accumulated `result`. It may either
+  pass mapped transformed `value` and `result` to the `next` continuation
+  or skip it.
+
+  For example see `map` and `filter` functions.
+  **/
+  return function reducer(source, options) {
+    // When return transformation function is called with a source and
+    // `options`
+    return reducible(function reduceReducer(next, initial) {
+      // When actual result is 
+      reduce(source, function reduceReducerSource(value, result) {
+        // If value is `end` of source or an error just propagate through,
+        // otherwise call `process` with all the curried `options` and `next`
+        // continuation function.
+        return value === end ? next(value, result) :
+               isError(value) ? next(value, result) :
+               process(options, next, value, result)
+      })
+    })
+  }
+}
+
+module.exports = reducer

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

@@ -0,0 +1,31 @@
+"use strict";
+
+var reduce = require("reducible/reduce")
+var reducible = require("reducible/reducible")
+var end = require("reducible/end")
+var isError = require("reducible/is-error")
+
+function reductions(source, f, initial) {
+  /**
+  Returns `reducible` collection of the intermediate values of the reduction
+  (as per reduce) of `source` by `f`, starting with `initial` value.
+
+  ## Example
+
+  var numbers = reductions([1, 1, 1, 1], function(accumulated, value) {
+    return accumulated + value
+  }, 0)
+  print(numbers) // => < 1 2 3 4 >
+  **/
+  return reducible(function reduceReductions(next, start) {
+    var state = initial
+    return reduce(source, function reduceReductionsSource(value, result) {
+      if (value === end) return next(end, result)
+      if (isError(value)) return next(value, result)
+      state = f(state, value)
+      return next(state, result)
+    }, start)
+  })
+}
+
+module.exports = reductions

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

@@ -0,0 +1,23 @@
+"use strict";
+
+var reducer = require("./reducer")
+var end = require("reducible/end")
+
+
+var takeWhile = reducer(function takeWhile(predicate, next, value, result) {
+  /**
+  Returns a sequence of successive items from `source` while `predicate(item)`
+  returns `true`. `predicate` must be free of side-effects.
+
+  ## Example
+
+  var digits = takeWhile([ 2, 7, 10, 23 ], function(x) { return x < 10 })
+  print(digits)   // => < 2 7 >
+  **/
+  return predicate(value) ? next(value, result) :
+         // Predicate returned `false` just pass `end`. Reducer will take
+         // care of returning `reduced(result)` back.
+         next(end)
+})
+
+module.exports = takeWhile

data/vendor/interactivate/node_modules/interactivate/node_modules/reducers/take.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var reducible = require("reducible/reducible")
+var reduce = require("reducible/reduce")
+var end = require("reducible/end")
+
+function take(source, n) {
+  /**
+  Returns sequence of first `n` items of the given `source`. If `source`
+  contains less items than `n` then that's how  much items return sequence
+  will contain.
+
+  ## Example
+
+  print(take([ 1, 2, 3, 4, 5 ], 2))   // => < 1 2 >
+  print(take([ 1, 2, 3 ], 5))         // => < 1 2 3 >
+  **/
+
+  // If take `0` then optimize by returning an empty if less then `0`
+  // then just return `source` back.
+  if (n === 0) return void(0)
+  if (n < 0) return source
+  return reducible(function reduceTake(next, initial) {
+    // Capture `n` into count, since modifying `n` directly will have side
+    // effects on subsequent calls.
+    var count = n
+    reduce(source, function reduceTakeSource(value, result) {
+      count = count - 1
+      result = next(value, result)
+
+      // If we have not taken `n` items yet just pass result back. Otherwise
+      // pass `end` of stream to a consumer. Note `reducible` will return
+      // `reduced(result)` back signaling source it should stop.
+      return count > 0 ? result :
+             next(end)
+    }, initial)
+  })
+}
+
+module.exports = take

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

@@ -0,0 +1,32 @@
+"use strict";
+
+var map = require("../map")
+var filter = require("../filter")
+var reduce = require("../reduce")
+var Benchmark = require("benchmark/benchmark")
+var suite = Benchmark.Suite()
+
+// Some helper functions we'll use
+function increment(x) { return x + 1 }
+function isOdd(n) { return n % 2 }
+function range(from, to) {
+  var items = []
+  while (from < to) items.push(from++)
+  return items
+}
+function sum(a, b) {
+  return a + b
+}
+
+var numbers = range(0, 100000)
+
+suite.add("standard array", function() {
+  numbers.filter(isOdd).map(increment).reduce(sum)
+}).add("reducers", function() {
+  reduce(sum, map(increment, filter(isOdd, numbers)))
+}).on("cycle", function(event) {
+  var bench = event.target
+  console.log(bench.name, bench.count)
+}).on("complete", function() {
+  console.log("Fastest is " + this.filter("fastest").pluck("name"))
+}).run({ "async": true })

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

@@ -0,0 +1,108 @@
+"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 lazy = require("./util/lazy")
+
+exports["test capture empty stream"] = test(function(assert) {
+  var called = 0
+  var captured = capture([], function final() {
+    called = called + 1
+  })
+  var actual = concat(captured, lazy(function() { return called }))
+
+
+  assert(actual, [0], "error handler was not called")
+})
+
+exports["test capture with a non-empty stream"] = test(function(assert) {
+  var actual = capture([1, 2], function() { return [3, 4] })
+
+  assert(actual, [1, 2], "error handler has is not called")
+})
+
+exports["test error recovery"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var actual = capture(boom, function catcher(e) {
+    return [ "catch", e.message ]
+  })
+
+  assert(actual, ["catch", boom.message ], "error handler is called")
+})
+
+exports["test errors can be ignored"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var brax = Error("brax")
+  var source = concat(["h", "i"], boom)
+  var captured = capture(source, function cacher(e) {
+    return [e.message, brax]
+  })
+  var actual = capture(captured, function(e) {
+    return e.message
+  })
+
+
+  assert(actual, ["h", "i", boom.message, brax.message],
+                  "recovery code still may leak errors")
+})
+
+
+exports["test capture error every time"] = test(function(assert) {
+  var boom = Error("Boom!!")
+  var calls = 0
+  var reason
+  var captured = capture(boom, function(error) {
+    calls = calls + 1
+    reason = error
+    return
+  })
+
+  var actual = concat(captured,
+                      lazy(function() { return calls }),
+                      lazy(function() { return reason.message }),
+                      captured,
+                      lazy(function() { return calls }),
+                      lazy(function() { return reason.message }))
+
+
+  assert(actual, [1, boom.message, 2, boom.message],
+         "error handler is called each time")
+})
+
+exports["test substitution is lazy"] = test(function(assert) {
+  var calls = 0
+  var boom = Error("boom")
+  var captured = capture([1, 2, 3, 4, boom], function(error) {
+    calls = calls + 1
+    return [5, 6, 7]
+  })
+
+  var actual = concat(take(captured, 1),
+                      lazy(function() { return calls }),
+                      captured,
+                      lazy(function() { return calls }))
+
+  assert(actual, [
+    1,
+    0,
+    1, 2, 3, 4, 5, 6, 7,
+    1
+  ], "error handlers only called if that associated section is read")
+})
+
+
+exports["test ignore error"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var actual = capture([1, 2, 3, boom], function() {})
+
+  assert(actual, [1, 2, 3], "if nothing returned stream is done")
+})
+
+if (require.main === module)
+  require("test").run(exports)

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

@@ -0,0 +1,104 @@
+"use strict";
+
+var test = require("./util/test")
+var concat = require("../concat")
+var into = require("../into")
+var delay = require("../delay")
+var capture = require("../capture")
+
+exports["test concat"] = function(assert) {
+  var actual = concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])
+
+  assert.deepEqual(into(actual),
+                   [ 1, 2, 3, 4, 5, 6 ],
+                   "reducers were joined")
+  assert.deepEqual(into(actual),
+                   [ 1, 2, 3, 4, 5, 6 ],
+                   "can be re-reduced")
+}
+
+exports["test concat empty streams"] = function(assert) {
+  var actual = concat([], [])
+
+  assert.deepEqual(into(actual), [], "concat on empty sequences is empty")
+}
+
+exports["test concat empty"] = function(assert) {
+  var actual = concat([1, 2], [])
+
+  assert.deepEqual(into(actual), [ 1, 2 ], "concat with empty returns same")
+}
+
+exports["test concat to empty"] = function(assert) {
+  var actual = concat([], [3, 4])
+
+  assert.deepEqual(into(actual), [ 3, 4 ], "concat to empty returns same")
+}
+
+exports["test concat many streams"] = function(assert) {
+  var actual = concat([1, 2], [], ["a", "b"], [])
+
+  assert.deepEqual(into(actual), [ 1, 2, "a", "b" ], "many concats work")
+}
+
+exports["test concat sync & async streams"] = test(function(assert) {
+  var async = delay([3, 2, 1])
+  var actual = concat(concat(async, []),
+                      async,
+                      ["a", "b"])
+
+  assert(actual, [3, 2, 1, 3, 2, 1, "a", "b"], "concat sync async works")
+})
+
+exports["test concat & reconcat"] = test(function(assert) {
+  var async = delay([2, 1])
+  var stream = concat(async, ["a", "b"])
+  var actual = concat(stream, ["||"], stream)
+
+  assert(actual, [2, 1, "a", "b", "||", 2, 1, "a", "b"], "concat reconcat")
+})
+
+exports["test map broken stream"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var async = delay(concat([3, 2, 1], boom))
+  var concated = concat([">"], async, [1, 2], async)
+  var actual = capture(concated, function(error) { return error.message })
+
+  assert(actual, [">", 3, 2, 1, boom.message], "test concat on broken stream")
+})
+
+exports["test concat error and sequence"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var concated = concat(boom, [ 1, 2, 3 ])
+  var actual = capture(concated, function(error) {
+    return error.message
+  })
+
+
+  assert(actual, [boom.message], "sequence has an error")
+})
+
+exports["test concat sequence & error"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var concated = concat([ 1, 2, 3 ], boom)
+  var actual = capture(concated, function(error) {
+    return error.message
+  })
+
+
+  assert(actual, [1, 2, 3, boom.message], "sequence has an error")
+})
+
+exports["test concat sequence & error & sequence"] = test(function(assert) {
+  var boom = Error("Boom!")
+  var concated = concat([ 1, 2, 3 ], boom, [ 4, 5, 6 ])
+  var actual = capture(concated, function(error) {
+    return error.message
+  })
+
+
+  assert(actual, [1, 2, 3, boom.message], "sequence has an error")
+})
+
+if (module == require.main)
+  require("test").run(exports)

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

@@ -0,0 +1,29 @@
+"use strict";
+
+var test = require("./util/test")
+var concat = require("../concat")
+var into = require("../into")
+var delay = require("../delay")
+var capture = require("../capture")
+var lazy = require("./util/lazy")
+
+exports["test delay empty"]  = test(function(assert) {
+  var async = false
+  var actual = concat(delay([]),
+                      lazy(function() { return async }))
+
+  assert(actual, [true], "delay makes things async")
+  async = true
+})
+
+exports["test sequence of numbers"] = test(function(assert) {
+  var async = false
+  var actual = concat(delay([1, 2, 3, 4]),
+                      lazy(function() { return async }))
+
+  assert(actual, [1, 2, 3, 4, true], "dealy made stream async")
+  async = true
+})
+
+if (module == require.main)
+  require("test").run(exports)