ruby-wisp-source 0.7.0

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

@@ -0,0 +1,33 @@
+"use strict";
+
+// Consumption
+exports.fold = require("./fold")
+
+// Transformation
+exports.filter = require("./filter")
+exports.map = require("./map")
+exports.reductions = require("./reductions")
+
+// Combining streams
+exports.concat = require("./concat")
+exports.merge = require("./merge")
+
+// Error handling
+exports.capture = require("./capture")
+exports.delay = require("./delay")
+
+// Size changes
+exports.dropWhile = require("./drop-while")
+exports.drop = require("./drop")
+exports.takeWhile = require("./take-while")
+exports.take = require("./take")
+
+// Multiplexing / sharing transformations
+exports.hub = require("./hub")
+
+// Development / debug
+exports.print = require("./debug/print")
+exports.into = require("./into")
+
+// Transformation helper
+exports.reducer = require("./reducer")

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

@@ -0,0 +1,16 @@
+"use strict";
+
+var fold = require("./fold")
+
+function into(source, buffer) {
+  /**
+  Adds items of given `reducible` into
+  given `array` or a new empty one if omitted.
+  **/
+  return fold(source, function foldInto(value, result) {
+    result.push(value)
+    return result
+  }, buffer || [])
+}
+
+module.exports = into

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

@@ -0,0 +1,19 @@
+"use strict";
+
+var reducer = require("./reducer")
+
+var map = reducer(function map(f, next, value, result) {
+  /**
+  Returns transformed version of given `source` where each item of it
+  is mapped using `f`.
+
+  ## Example
+
+  var data = [{ name: "foo" }, { name: "bar" }]
+  var names = map(data, function(value) { return value.name })
+  print(names) // => < "foo" "bar" >
+  **/
+  next(f(value), result)
+})
+
+module.exports = map

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

@@ -0,0 +1,50 @@
+"use strict";
+
+var reduce = require("reducible/reduce")
+var reducible = require("reducible/reducible")
+var end = require("reducible/end")
+var isError = require("reducible/is-error")
+
+function merge(source) {
+  /**
+  Merges given collection of collections to a collection with items of
+  all nested collections. Note that items in the resulting collection
+  are ordered by the time rather then index, in other words if item from
+  the second nested collection is deliver earlier then the item
+  from first nested collection it will in appear earlier in the resulting
+  collection.
+
+  print(merge([ [1, 2], [3, 4] ]))  // => < 1 2 3 4 >
+  **/
+  return reducible(function accumulateMerged(next, initial) {
+    var state = initial
+    var open = 1
+
+    function forward(value) {
+      if (value === end) {
+        open = open - 1
+        if (open === 0) return next(end)
+      } else {
+        state = next(value, state)
+      }
+      return state
+    }
+
+
+    reduce(source, function accumulateMergeSource(nested) {
+      // If there is an error or end of `source` collection just pass it
+      // to `forward` it will take care of detecting weather it's error
+      // or `end`. In later case it will also figure out if it's `end` of
+      // result to and act appropriately.
+      if (nested === end) return forward(end)
+      if (isError(nested)) return forward(nested)
+      // If `nested` item is not end nor error just `accumulate` it via
+      // `forward` that keeps track of all collections that are bing forwarded
+      // to it.
+      open = open + 1
+      reduce(nested, forward, null)
+    }, initial)
+  })
+}
+
+module.exports = merge

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/node_modules/reducible/History.md

@@ -0,0 +1,20 @@
+# Changes
+
+## 1.0.5 / 2012-12-18
+
+  - Change implementation detail of [reducible][], such that no exceptions
+    are thrown, since exceptions makes debugging a lot harder when
+    "pause on exceptions" is enabled.
+
+## 1.0.1 / 2012-11-23
+
+  - Add test for [reducible][] tests.
+  - Reducible now catches exceptions thrown by [reducible][] definitions.
+    Now it's guaranteed that reducing reducible never throws.
+
+## 1.0.0 / 2012-11-23
+
+  - Fork out definition of reducible abstraction from [reducers][]
+
+[reducers]:https://github.com/Gozala/reducers
+[reducible]:./reducible.js

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/node_modules/reducible/License.md

@@ -0,0 +1,18 @@
+Copyright 2012 Irakli Gozalishvili. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/node_modules/reducible/Readme.md

@@ -0,0 +1,45 @@
+# reducible
+
+[![Build Status](https://secure.travis-ci.org/Gozala/reducible.png)](http://travis-ci.org/Gozala/reducible)
+
+Library defines higher-order abstraction for reducible data structures -
+collections based upon [reduce][].
+
+Most functional languages (including beloved JS) typically come with some
+collection transformation functions like [filter][] and [map][] that take a
+logical collections and return transformed version of it. Unfortunately they
+tend to [complect][], by implying mechanism, order, laziness and
+representation. This library is an attempt to provide simple solution for
+some of the hard problems by decomplecting and building upon simple premise -
+minimum definition of collection is something that is reducible.
+
+More specifically library defines super-generalized and minimal abstraction for
+collections - a collection is some set of things that, when given a function to
+apply to its contents, can do so and give you the result, i.e. a collection is
+(at minimum) **reducible**. In other words, you can call `reduce` on it.
+
+## reducers
+
+This library provides an abstraction for **reducible** data structures and
+implementation of internal [reduce][] for built-in data types. It can be used
+to implement to define abstraction for all other types. This is also foundation
+for [reducers][] - Library for higher-order manipulation of reducible
+collections.
+
+## Install
+
+    npm install reducible
+
+## Prior art
+
+- [Clojure reducers][]
+- [Haskell Enumerator/Iteratee][]
+
+[Clojure reducers]:http://clojure.com/blog/2012/05/15/anatomy-of-reducer.html
+[Haskell Enumerator/Iteratee]:http://www.haskell.org/haskellwiki/Enumerator_and_iteratee
+
+[reducers]:https://github.com/Gozala/reducers
+[reduce]:http://en.wikipedia.org/wiki/Reduce_%28higher-order_function%29
+[map]:https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/map
+[filter]:https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/filter
+[complect]:http://www.infoq.com/presentations/Simple-Made-Easy

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/node_modules/reducible/end.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = String("End of the collection")

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/node_modules/reducible/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+exports.reduce = require("./reduce")
+exports.reducible = require("./reducible")
+exports.end = require("./end")
+exports.reduced = require("./reduced")
+exports.isReduced = require("./is-reduced")
+exports.isError = require("./is-error")

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/node_modules/reducible/is-error.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var stringifier = Object.prototype.toString
+
+function isError(value) {
+  return stringifier.call(value) === "[object Error]"
+}
+
+module.exports = isError

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/node_modules/reducible/is-reduced.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var reduced = require("./reduced")
+
+function isReduced(value) {
+  return value && value.is === reduced
+}
+
+module.exports = isReduced

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

@@ -0,0 +1,57 @@
+{
+  "name": "reducible",
+  "id": "reducible",
+  "version": "1.0.6",
+  "description": "High-order abstraction for reducible data structures",
+  "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/reducible",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gozala/reducible.git",
+    "web": "https://github.com/Gozala/reducible"
+  },
+  "bugs": {
+    "url": "http://github.com/Gozala/reducible/issues/"
+  },
+  "devDependencies": {
+    "test": "~0.x.0",
+    "phantomify": "~0.x.0"
+  },
+  "main": "./reducible.js",
+  "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"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/Gozala/reducible/License.md"
+    }
+  ],
+  "dependencies": {
+    "method": "~2.0.x"
+  },
+  "readme": "# reducible\n\n[![Build Status](https://secure.travis-ci.org/Gozala/reducible.png)](http://travis-ci.org/Gozala/reducible)\n\nLibrary defines higher-order abstraction for reducible data structures -\ncollections based upon [reduce][].\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\n## reducers\n\nThis library provides an abstraction for **reducible** data structures and\nimplementation of internal [reduce][] for built-in data types. It can be used\nto implement to define abstraction for all other types. This is also foundation\nfor [reducers][] - Library for higher-order manipulation of reducible\ncollections.\n\n## Install\n\n    npm install reducible\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[reducers]:https://github.com/Gozala/reducers\n[reduce]:http://en.wikipedia.org/wiki/Reduce_%28higher-order_function%29\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[complect]:http://www.infoq.com/presentations/Simple-Made-Easy\n",
+  "readmeFilename": "Readme.md",
+  "_id": "reducible@1.0.6",
+  "_from": "reducible@~1.x.0"
+}

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/node_modules/reducible/reduce.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var method = require("method")
+
+var isReduced = require("./is-reduced")
+var isError = require("./is-error")
+var end = require("./end")
+
+var reduce = method("reduce@reducible")
+
+// Implementation of `reduce` for the empty collections, that immediately
+// signals reducer that it's ended.
+reduce.empty = function reduceEmpty(empty, next, initial) {
+  next(end, initial)
+}
+
+// Implementation of `reduce` for the singular values which are treated
+// as collections with a single element. Yields a value and signals the end.
+reduce.singular = function reduceSingular(value, next, initial) {
+  next(end, next(value, initial))
+}
+
+// Implementation of `reduce` for the array (and alike) values, such that it
+// will call accumulator function `next` each time with next item and
+// accumulated state until it's exhausted or `next` returns marked value
+// indicating that it's reduced. Either way signals `end` to an accumulator.
+reduce.indexed = function reduceIndexed(indexed, next, initial) {
+  var state = initial
+  var index = 0
+  var count = indexed.length
+  while (index < count) {
+    var value = indexed[index]
+    state = next(value, state)
+    index = index + 1
+    if (value === end) return end
+    if (isError(value)) return state
+    if (isReduced(state)) return state.value
+  }
+  next(end, state)
+}
+
+// Both `undefined` and `null` implement accumulate for empty sequences.
+reduce.define(void(0), reduce.empty)
+reduce.define(null, reduce.empty)
+
+// Array and arguments implement accumulate for indexed sequences.
+reduce.define(Array, reduce.indexed)
+
+function Arguments() { return arguments }
+Arguments.prototype = Arguments()
+reduce.define(Arguments, reduce.indexed)
+
+// All other built-in data types are treated as single value collections
+// by default. Of course individual types may choose to override that.
+reduce.define(reduce.singular)
+
+// Errors just yield that error.
+reduce.define(Error, function(error, next) { next(error) })
+module.exports = reduce

data/vendor/node_modules/wisp/interactivate/node_modules/interactivate/node_modules/reducers/node_modules/reducible/reduced.js

@@ -0,0 +1,15 @@
+"use strict";
+
+
+// Exported function can be used for boxing values. This boxing indicates
+// that consumer of sequence has finished consuming it, there for new values
+// should not be no longer pushed.
+function reduced(value) {
+  /**
+  Boxes given value and indicates to a source that it's already reduced and
+  no new values should be supplied
+  **/
+  return { value: value, is: reduced }
+}
+
+module.exports = reduced

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

@@ -0,0 +1,87 @@
+"use strict";
+
+var reduce = require("./reduce")
+var end = require("./end")
+var isError = require("./is-error")
+var isReduced = require("./is-reduced")
+var reduced = require("./reduced")
+
+function Reducible(reduce) {
+  /**
+  Reducible is a type of the data-structure that represents something
+  that can be reduced. Most of the time it's used to represent transformation
+  over other reducible by capturing it in a lexical scope.
+
+  Reducible has an attribute `reduce` pointing to a function that does
+  reduction.
+  **/
+
+  // JS engines optimize access to properties that are set in the constructor's
+  // so we set it here.
+  this.reduce = reduce
+}
+
+// Implementation of `accumulate` for reducible, which just delegates to it's
+// `reduce` attribute.
+reduce.define(Reducible, function reduceReducible(reducible, next, initial) {
+  var result
+  // State is intentionally accumulated in the outer variable, that way no
+  // matter if consumer is broken and passes in wrong accumulated state back
+  // this reducible will still accumulate result as intended.
+  var state = initial
+  try {
+    reducible.reduce(function forward(value) {
+      try {
+        // If reduction has already being completed return is set to
+        // an accumulated state boxed via `reduced`. It's set to state
+        // that is return to signal input that reduction is complete.
+        if (result) state = result
+        // if dispatched `value` is is special `end` of input one or an error
+        // just forward to reducer and store last state boxed as `reduced` into
+        // state. Later it will be assigned to result and returned to input
+        // to indicate end of reduction.
+        else if (value === end || isError(value)) {
+          next(value, state)
+          state = reduced(state)
+        }
+        // if non of above just accumulate new state by passing value and
+        // previously accumulate state to reducer.
+        else state = next(value, state)
+
+        // If state is boxed with `reduced` then accumulation is complete.
+        // Indicated explicitly by a reducer or by end / error of the input.
+        // Either way store it to the result in case broken input attempts to
+        // call forward again.
+        if (isReduced(state)) result = state
+
+        // return accumulated state back either way.
+        return state
+      }
+      // If error is thrown then forward it to the reducer such that consumer
+      // can apply recovery logic. Also store current `state` boxed with
+      // `reduced` to signal input that reduction is complete.
+      catch (error) {
+        next(error, state)
+        result = reduced(state)
+        return result
+      }
+    })
+  }
+  // It could be that attempt to reduce underlaying reducible throws, if that
+  // is the case still forward an `error` to a reducer and store reduced state
+  // into result, in case process of reduction started before exception and
+  // forward will still be called. Return result either way to signal
+  // completion.
+  catch(error) {
+    next(error, state)
+    result = reduced(state)
+    return result
+  }
+})
+
+function reducible(reduce) {
+  return new Reducible(reduce)
+}
+reducible.type = Reducible
+
+module.exports = reducible

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

@@ -0,0 +1,6 @@
+"use strict";
+
+exports["test reduce"] = require("./reduce")
+exports["test reducible"] = require("./reducible")
+
+require("test").run(exports)

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

@@ -0,0 +1,116 @@
+"use strict";
+
+var reduce = require("../reduce")
+var end = require("../end")
+var reduced = require("../reduced")
+
+exports["test reduce"] = function(assert) {
+  var actual = []
+  reduce([1, 2, 3], function(value, result) {
+    actual.push(value, result)
+    return value + result
+  }, 0)
+
+  assert.deepEqual(actual, [1, 0, 2, 1, 3, 3, end, 6],
+                   "reduce is passed all the values")
+}
+
+exports["test reduced early"] = function(assert) {
+  var actual = []
+  reduce([1, 2, 3], function(value, result) {
+    actual.push(value, result)
+    return reduced("nope")
+  }, 0)
+
+  assert.deepEqual(actual, [1, 0], "early reduce value is accumulated")
+}
+
+exports["test reduce errored"] = function(assert) {
+  var actual = []
+  var boom = Error("Boom!")
+  var result = reduce([1, 2, boom, 3, 4], function(value) {
+    actual.push(value)
+  }, 0)
+
+  assert.deepEqual(actual, [1, 2, boom], "errors end source and propagate")
+}
+
+exports["test reduce late error"] = function(assert) {
+  var actual = []
+  var boom = Error("Boom!")
+  var result = reduce([1, 2, boom, 4], function(value) {
+    actual.push(value)
+    return reduced("Wheuh")
+  }, 0)
+
+  assert.deepEqual(actual, [1], "late errors are irrelevant")
+}
+
+exports["test reduce null"] = function(assert) {
+  var actual = []
+  reduce(null, function(value) {
+    actual.push(value)
+  })
+
+  assert.deepEqual(actual, [end], "null reduces as empty")
+}
+
+exports["test reduce void"] = function(assert) {
+  var actual = []
+  reduce(void(0), function(value) {
+    actual.push(value)
+  })
+
+  assert.deepEqual(actual, [end], "void reduces as empty")
+}
+
+exports["test reduce empty"] = function(assert) {
+  var actual = []
+  reduce([], function(value) {
+    actual.push(value)
+  })
+
+  assert.deepEqual(actual, [end], "[] reduces as empty")
+}
+
+exports["test reduce string"] = function(assert) {
+  var actual = []
+  var result = reduce("world", function(value) {
+    actual.push(value)
+  })
+
+  assert.deepEqual(actual, ["world", end],
+                   "string is equivalent of collection of itself")
+}
+
+exports["test reduce number"] = function(assert) {
+  var actual = []
+  reduce(7, function(value) {
+    actual.push(value)
+  })
+
+  assert.deepEqual(actual, [7, end],
+                   "number is equivalent of collection of itself")
+}
+
+exports["test reduce object"] = function(assert) {
+  var actual = []
+  reduce({}, function(value) {
+    actual.push(value)
+  })
+
+  assert.deepEqual(actual, [{}, end], "object is collection of itself")
+}
+
+exports["test reduce error"] = function(assert) {
+  var actual = []
+  var boom = Error("Boom!")
+  reduce(boom, function(value) {
+    actual.push(boom)
+  })
+
+  assert.deepEqual(actual, [boom], "error is errored collection")
+}
+
+if (require.main === module)
+  require("test").run(exports)