ruby-wisp-source 0.7.0

data/vendor/interactivate/node_modules/interactivate/node_modules/method/test/browser.js

@@ -0,0 +1,18 @@
+"use strict";
+
+exports["test common"] = require("./common")
+
+var Method = require("../core")
+
+exports["test host objects"] = function(assert) {
+  var isElement = Method("is-element")
+  isElement.define(function() { return false })
+
+  isElement.define(Element, function() { return true })
+
+  assert.notDeepEqual(typeof(Element.prototype[isElement]), "number",
+                     "Host object's prototype is extended with a number value")
+
+  assert.ok(!isElement({}), "object is not an Element")
+  assert.ok(document.createElement("div"), "Element is an element")
+}

data/vendor/interactivate/node_modules/interactivate/node_modules/method/test/common-index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require("test").run(require("./index"))

data/vendor/interactivate/node_modules/interactivate/node_modules/method/test/common.js

@@ -0,0 +1,270 @@
+"use strict";
+
+var Method = require("../core")
+
+function type(value) {
+  return Object.prototype.toString.call(value).
+    split(" ").
+    pop().
+    split("]").
+    shift().
+    toLowerCase()
+}
+
+var values = [
+  null,                   // 0
+  undefined,              // 1
+  Infinity,               // 2
+  NaN,                    // 3
+  5,                      // 4
+  {},                     // 5
+  Object.create({}),      // 6
+  Object.create(null),    // 7
+  [],                     // 8
+  /foo/,                  // 9
+  new Date(),             // 10
+  Function,               // 11
+  function() {},          // 12
+  true,                   // 13
+  false,                  // 14
+  "string"                // 15
+]
+
+function True() { return true }
+function False() { return false }
+
+var trues = values.map(True)
+var falses = values.map(False)
+
+exports["test throws if not implemented"] = function(assert) {
+  var method = Method("nope#1")
+
+  assert.throws(function() {
+    method({})
+  }, /not implement/i, "method throws if not implemented")
+
+  assert.throws(function() {
+    method(null)
+  }, /not implement/i, "method throws on null")
+}
+
+exports["test all types inherit from default"] = function(assert) {
+  var isImplemented = Method("isImplemented#2")
+  isImplemented.define(function() { return true })
+
+  values.forEach(function(value) {
+    assert.ok(isImplemented(value),
+              type(value) + " inherits deafult implementation")
+  })
+}
+
+exports["test default can be implemented later"] = function(assert) {
+  var isImplemented = Method("isImplemented#3")
+  isImplemented.define(function() {
+    return true
+  })
+
+  values.forEach(function(value) {
+    assert.ok(isImplemented(value),
+              type(value) + " inherits deafult implementation")
+  })
+}
+
+exports["test dispatch not-implemented"] = function(assert) {
+  var isDefault = Method("isDefault#4")
+  values.forEach(function(value) {
+    assert.throws(function() {
+      isDefault(value)
+    }, /not implement/, type(value) + " throws if not implemented")
+  })
+}
+
+exports["test dispatch default"] = function(assert) {
+  var isDefault = Method("isDefault#5")
+
+  // Implement default
+  isDefault.define(True)
+  assert.deepEqual(values.map(isDefault), trues,
+                   "all implementation inherit from default")
+
+}
+
+exports["test dispatch null"] = function(assert) {
+  var isNull = Method("isNull#6")
+
+  // Implement default
+  isNull.define(False)
+  isNull.define(null, True)
+  assert.deepEqual(values.map(isNull),
+                   [ true ].
+                   concat(falses.slice(1)),
+                   "only null gets methods defined for null")
+}
+
+exports["test dispatch undefined"] = function(assert) {
+  var isUndefined = Method("isUndefined#7")
+
+  // Implement default
+  isUndefined.define(False)
+  isUndefined.define(undefined, True)
+  assert.deepEqual(values.map(isUndefined),
+                   [ false, true ].
+                   concat(falses.slice(2)),
+                   "only undefined gets methods defined for undefined")
+}
+
+exports["test dispatch object"] = function(assert) {
+  var isObject = Method("isObject#8")
+
+  // Implement default
+  isObject.define(False)
+  isObject.define(Object, True)
+  assert.deepEqual(values.map(isObject),
+                   [ false, false, false, false, false ].
+                   concat(trues.slice(5, 13)).
+                   concat([false, false, false]),
+                   "all values except primitives inherit Object methods")
+
+}
+
+exports["test dispatch number"] = function(assert) {
+  var isNumber = Method("isNumber#9")
+  isNumber.define(False)
+  isNumber.define(Number, True)
+
+  assert.deepEqual(values.map(isNumber),
+                  falses.slice(0, 2).
+                  concat(true, true, true).
+                  concat(falses.slice(5)),
+                  "all numbers inherit from Number method")
+}
+
+exports["test dispatch string"] = function(assert) {
+  var isString = Method("isString#10")
+  isString.define(False)
+  isString.define(String, True)
+
+  assert.deepEqual(values.map(isString),
+                  falses.slice(0, 15).
+                  concat(true),
+                  "all strings inherit from String method")
+}
+
+exports["test dispatch function"] = function(assert) {
+  var isFunction = Method("isFunction#11")
+  isFunction.define(False)
+  isFunction.define(Function, True)
+
+  assert.deepEqual(values.map(isFunction),
+                  falses.slice(0, 11).
+                  concat(true, true).
+                  concat(falses.slice(13)),
+                  "all functions inherit from Function method")
+}
+
+exports["test dispatch date"] = function(assert) {
+  var isDate = Method("isDate#12")
+  isDate.define(False)
+  isDate.define(Date, True)
+
+  assert.deepEqual(values.map(isDate),
+                  falses.slice(0, 10).
+                  concat(true).
+                  concat(falses.slice(11)),
+                  "all dates inherit from Date method")
+}
+
+exports["test dispatch RegExp"] = function(assert) {
+  var isRegExp = Method("isRegExp#13")
+  isRegExp.define(False)
+  isRegExp.define(RegExp, True)
+
+  assert.deepEqual(values.map(isRegExp),
+                  falses.slice(0, 9).
+                  concat(true).
+                  concat(falses.slice(10)),
+                  "all regexps inherit from RegExp method")
+}
+
+exports["test redefine for descendant"] = function(assert) {
+  var isFoo = Method("isFoo#14")
+  var ancestor = {}
+  isFoo.implement(ancestor, function() { return true })
+  var descendant = Object.create(ancestor)
+  isFoo.implement(descendant, function() { return false })
+
+  assert.ok(isFoo(ancestor), "defined on ancestor")
+  assert.ok(!isFoo(descendant), "overrided for descendant")
+}
+
+exports["test on custom types"] = function(assert) {
+  function Bar() {}
+  var isBar = Method("isBar#15")
+
+  isBar.define(function() { return false })
+  isBar.define(Bar, function() { return true })
+
+  assert.ok(!isBar({}), "object is get's default implementation")
+  assert.ok(isBar(new Bar()), "Foo type objects get own implementation")
+
+  var isObject = Method("isObject#15")
+  isObject.define(function() { return false })
+  isObject.define(Object, function() { return true })
+
+  assert.ok(isObject(new Bar()), "foo inherits implementation from object")
+
+
+  isObject.define(Bar, function() { return false })
+
+  assert.ok(!isObject(new Bar()),
+            "implementation inherited form object can be overrided")
+}
+
+
+exports["test error types"] = function(assert) {
+  var isError = Method("isError#16")
+  isError.define(function() { return false })
+  isError.define(Error, function() { return true })
+
+  assert.ok(isError(Error("boom")), "error is error")
+  assert.ok(isError(TypeError("boom")), "type error is an error")
+  assert.ok(isError(EvalError("boom")), "eval error is an error")
+  assert.ok(isError(RangeError("boom")), "range error is an error")
+  assert.ok(isError(ReferenceError("boom")), "reference error is an error")
+  assert.ok(isError(SyntaxError("boom")), "syntax error is an error")
+  assert.ok(isError(URIError("boom")), "URI error is an error")
+}
+
+exports["test override define polymorphic method"] = function(assert) {
+  var define = Method.define
+  var implement = Method.implement
+
+  var fn = Method("fn#17")
+  var methods = {}
+  implement(define, fn, function(method, label, implementation) {
+    methods[label] = implementation
+  })
+
+  function foo() {}
+
+  define(fn, "foo-case", foo)
+
+  assert.equal(methods["foo-case"], foo, "define set property")
+}
+
+exports["test override define via method API"] = function(assert) {
+  var define = Method.define
+  var implement = Method.implement
+
+  var fn = Method("fn#18")
+  var methods = {}
+  define.implement(fn, function(method, label, implementation) {
+    methods[label] = implementation
+  })
+
+  function foo() {}
+
+  define(fn, "foo-case", foo)
+
+  assert.equal(methods["foo-case"], foo, "define set property")
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./common")

data/vendor/interactivate/node_modules/interactivate/node_modules/method/test/phantom-index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require("test").run(require("./browser"))

data/vendor/interactivate/node_modules/interactivate/node_modules/method/test/tap-index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require("retape")(require("./index"))

data/vendor/interactivate/node_modules/interactivate/node_modules/method/test/testling-index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require("retape")(require("./browser"))

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

@@ -0,0 +1,139 @@
+# Changes
+
+## 3.0.0 / 2013-01-19
+
+  - Change fold such that errors that reach it are thrown.
+  - remove dependency on [eventual](https://github.com/Gozala/eventual) &
+    [watchables](https://github.com/Gozala/watchables)
+
+## 2.0.0 / 2012-11-23
+
+  - Factor out [reducible][https://github.com/Gozala/reducible] abstraction
+    into own package, that way we can avoid most of the API breaks.
+  - Remove most of the non-essential / not commonly used APIs.
+  - Remove **reduce** function in favor of [fold](./fold.js) with a more
+    useful API.
+
+## 1.0.3 / 2012-11-10
+
+  - Update dependencies
+
+## 1.0.2 / 2012-11-09
+
+  - Improve definition for `arguments` object.
+
+## 1.0.1 / 2012-11-06
+
+  - Define API for [lazy](./lazy.js) creation of reducibles.
+  - Improvements for [print][] function so that it could handle objects with
+    circular references.
+  - Fix [reduce][] so that errors thrown by handler are captured and cause
+    rejections in returned promise.
+
+## 1.0.0 / 2012-11-02
+
+  - Add integration for browser based testing using [phantomify][].
+  - Removed lots of low level APIs like `transform`, `trasformer`, `convert`
+    in favor of enhanced `reducible` that also takes care of collection
+    normalizations.
+  - Errors no longer require boxing, instances of `Error`-s are treated as
+    exceptions in a collection. Such collections are considered as broken &
+    after error no values will be dispatched. Also [emit](./emit.js)-ing
+    errors on [signal](./signal.js) / [channel](./channel.js) marks them
+    as broken.
+  - [End](./end.js) of stream no longer requires boxing, it's just a special
+    data value that indicates end of stream. Anything followed in a collection
+    passed that is ignored, also reducible's will ignore any subsequent values
+    and will return [reduced](./reduced.js) result to signal they've done
+    consuming.
+  - Adding missing test cases.
+  - Improvement to a `print` function that now also works in the browser.
+  - New low level utility function [reducer](./reducer.js) that is just a sugar
+    over [reducible](./reducible.js) that takes care of the boilerplate code
+    for stateless transformation functions.
+  - New [normalize](./normalize.js) utility function that can be used to wrap
+    collections that are not guaranteed to comply to API contracts. Resulting
+    collection is guaranteed to end or error only once and always pass in
+    accumulated value returned in a last iteration.
+
+## 0.2.1 / 2012-10-30
+
+  - Fix bug in [hub](./hub.js) implementation that was not multiplexing on
+    values that have derived from it like [channel](./channel.js) for example.
+
+## 0.2.0 / 2012-10-28
+
+  - Break API change for [signal](./signal.js) / [channel](./channel.js).
+    They no longer throw exceptions on attempts to close or emit more data
+    instead they return `accumulated` boxed value to signal they're closed.
+  - Implement [pipe](./pipe.js) that can be used to pipe input right to an
+    output (signal / channel / whatever implements [emit](./emit.js)).
+
+## 0.1.6 / 2012-10-26
+
+  - Add a lot more tests.
+  - Create index with all end user functions.
+  - Fix subtle bug in `hub` implementation.
+  - Fix bug in `delay` implementation.
+
+## 0.1.5 / 2012-10-25
+
+  - Fix bug in implementation of `capture` that caused multiple ends.
+  - Implement `delay` utility module.
+  - Fix flatten that in edge cases leaked end of stream before it actually ended.
+  - Implement lot's of new tests.
+
+## 0.1.4 / 2012-10-24
+
+  - Add transformation support for primitive types.
+
+## 0.1.3 / 2012-10-24
+
+  - Removed JSHint comments.
+  - Remove experimental modules.
+  - Implement `zip` function.
+  - Remove dependency on zip package.
+
+## 0.1.2 / 2012-10-24
+
+  - Make `reduce` API on eventuals equivalent of API on values they resolve to.
+
+## 0.1.1 / 2012-10-23
+
+  - Define implementation of `accumulate` for eventual data types.
+
+## 0.1.0 / 2012-10-21
+
+  - Refactor reducers into idiomatic node structure of function per module.
+  - Document each individual function.
+
+## 0.0.3 / 2012-10-15
+
+  - Implement client http API for reducers.
+  - Implement clojure like `reductions` function.
+  - Implement experimental `adjust` function.
+  - Implement `concat` for parallel data structures.
+  - Update to eventuals@0.3.0
+
+## 0.0.2 / 2012-07-23
+
+  - Rename channel abstraction to signal and define alternative
+    channel abstraction
+  - Implement lazy stream abstraction.
+  - Extend `accumulate` with a default implementation for all values.
+  - Define experimental `Binoid` type.
+  - Define `sequential` decorator.
+  - Implement error handling for reducers.
+  - Implement `capture` function for error handling.
+  - Implement `hub` function for sharing sequences across multiple consumers.
+  - Make core independent of `promise` abstraction.
+  - Implement `list` type.
+
+## 0.0.1 / 2012-05-19
+
+  - Initial release
+
+
+[phantomify]:https://github.com/Gozala/phantomify
+[print]:./debug/print.js
+[reduce]:./reduce.js

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

@@ -0,0 +1,19 @@
+
+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.