ruby-wisp-source 0.7.0

data/vendor/interactivate/node_modules/interactivate/interactivate.js

@@ -0,0 +1,187 @@
+"use strict";
+
+var diff = require("diffpatcher/diff")
+var patch = require("diffpatcher/patch")
+var output = require("./output")
+var makeOutput = output.makeOutput
+var writeOutput = output.write
+
+
+var Out = "out@interactivate"
+var In = "in@interactivate"
+var Reciever = "receiver@interactivate"
+
+function makeOptionGetter(name) {
+  return function getOption(editor) {
+    return editor.getOption(name)
+  }
+}
+
+var getRenderRate = makeOptionGetter("interactiveSpeed")
+var getSectionSeparator = makeOptionGetter("interactiveSeparator")
+
+
+var slicer = Array.prototype.slice
+function throttle(f, delay) {
+  /**
+  Creates function that calls throttles calls to given `f` such that,
+  it's only called if no further calls are made with in the time
+  frame (in miliseconds) returned by given `delay.apply(this, arguments)`
+  function.
+  **/
+  var id = 0
+  return function throttled() {
+    clearTimeout(id, throttled)
+    var ms = delay.apply(this, arguments) || 0
+    id = setTimeout.apply(this, [f, ms].concat(slicer.call(arguments)))
+  }
+}
+
+
+
+function calculate(editor) {
+  var state = editor[In]
+  var input = editor.getValue()
+  var separator = getSectionSeparator(editor)
+  var sections = input.split(separator)
+  var activeLine = editor.getCursor().line
+
+  sections.pop() // last section does not has execution marker so skip it.
+
+  var change = Object.keys(sections).reduce(function(result, index) {
+    var input = sections[index]
+    var line = result.line + input.split("\n").length - 1
+    result.line = line
+    var delta = {input: input.trim(), line: line, visible: activeLine !== line}
+    result.state[index] = state[index] ? patch(state[index], delta) :
+                          delta
+
+    return result
+  }, { line: 0, state: {} })
+
+  return diff(editor[In], change.state)
+}
+
+
+function send(packet) {
+  var event = document.createEvent("CustomEvent")
+  event.initCustomEvent("server", false, true, packet)
+  window.dispatchEvent(event)
+}
+
+
+function recieve(editor, event) {
+  var packet = event.detail
+  var delta = {}
+  delta[packet.from] = {pending: null,
+                        result: packet.message}
+  write(editor, delta)
+}
+
+function print(editor) {
+  if (!editor.getOption("interactivate")) throw editor.constructor.Pass
+  editor.operation(function() {
+    var cursor = editor.getCursor()
+    editor.replaceSelection("\n// =>\n")
+    editor.setCursor({ line: cursor.line + 2, ch: 0 })
+  })
+}
+
+
+function getMarkerFor(editor, view) {
+  var markers = editor.getAllMarks()
+  var count = markers.length
+  while (count) {
+    count = count - 1
+    var marker = markers[count]
+    if (marker.replacedWith === view) return marker
+  }
+  return null
+}
+
+
+function write(editor, changes) {
+  var doc = editor.getDoc()
+  Object.keys(changes).sort().reduce(function(_, id) {
+    if (!editor[Out][id]) editor[Out][id] = makeOutput(id)
+
+    var output = editor[Out][id]
+    var change = changes[id]
+    if (change === null) editor[Out][id] = null
+
+    writeOutput(output, editor, change)
+  }, null)
+  editor[In] = patch(editor[In], changes)
+}
+
+function post(changes) {
+  Object.keys(changes).reduce(function(_, id) {
+    var change = changes[id]
+    if (change && change.input) {
+      send({ to: id, source: change.input })
+    }
+  }, null)
+}
+
+// Function finds modified sections and queues up messegase to an
+// eval host. In adition it also renders output views (if they
+// do not exist yet) where eval results are written.
+var renderOutput = throttle(function render(editor) {
+  var delta = calculate(editor)
+  var changes = Object.keys(delta).reduce(function(changes, id) {
+    var change = delta[id]
+    // Only mark change pending if there is some input to be evaled.
+    if (change && change.input) change.pending = true
+    return changes
+  }, delta)
+
+  write(editor, changes)
+  post(changes)
+}, getRenderRate)
+
+var hideOutput = throttle(function render(editor) {
+  var line = editor.getCursor().line
+  var state = editor[In]
+  var changes = Object.keys(state).reduce(function(delta, id) {
+    var value = state[id]
+    if (value.line === line) delta[id] = {visible: false}
+    else if (!value.visible) delta[id] = {visible: true, line: value.line}
+
+    return delta
+  }, [])
+
+  if (changes.length) write(editor, changes)
+}, function() { return 200 })
+
+
+function tooglePlugin(editor, value) {
+  if (value) {
+    editor[Reciever] = recieve.bind(recieve, editor)
+    editor[In] = {}
+    editor[Out] = {}
+    editor.on("change", renderOutput)
+    editor.on("cursorActivity", hideOutput)
+    window.addEventListener("client", editor[Reciever], false)
+  } else {
+    editor.off("change", renderOutput)
+    editor.off("cursorActivity", hideOutput)
+    window.removeEventListener("client", editor[Reciever], false)
+    editor[Reciever] = null
+    editor[In] = null
+    editor[Out] = null
+  }
+}
+
+function install(CodeMirror) {
+  // Fix constructor property so that it could be accessed from the
+  // instance.
+  CodeMirror.prototype.constructor = CodeMirror;
+  CodeMirror.defaults.interactiveSpeed = 300
+  CodeMirror.defaults.interactiveSeparator = /^\/\/ \=\>[^\n]*$/m
+  CodeMirror.keyMap.macDefault["Cmd-Enter"] = print
+  CodeMirror.keyMap.pcDefault["Ctrl-Enter"] = print
+
+  CodeMirror.defineOption("interactivate", false, tooglePlugin)
+}
+
+module.exports = install

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

@@ -0,0 +1,10 @@
+# Changes
+
+## 1.0.0 / 2012-11-09
+
+  - Test integration for browsers.
+  - New method library.
+
+## 0.0.1 / 2012-10-22
+
+  - Initial release

data/vendor/interactivate/node_modules/interactivate/node_modules/diffpatcher/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/interactivate/node_modules/interactivate/node_modules/diffpatcher/Readme.md

@@ -0,0 +1,68 @@
+# diffpatcher
+
+[![Build Status](https://secure.travis-ci.org/Gozala/diffpatcher.png)](http://travis-ci.org/Gozala/diffpatcher)
+
+Diffpatcher is a small library that lets you treat hashes as if they were
+git repositories.
+
+## diff
+
+Diff function that takes two hashes and returns delta hash.
+
+```js
+var diff = require("diffpatcher/diff")
+
+diff({ a: { b: 1 }, c: { d: 2 } },      // hash#1
+     { a: { e: 3 }, c: { d: 4 } })      // hash#2
+
+// => {                                 // delta
+//      a: {
+//        b: null,        // -
+//        e: 3            // +
+//      },
+//      c: {
+//        d: 4            // ±
+//      }
+//    }
+```
+
+As you can see from the example above `delta` makes no real distinction between
+proprety upadate and property addition. Try to think of additions as an update
+from `undefined` to whatever it's being updated to.
+
+## patch
+
+Patch fuction takes a `hash` and a `delta` and returns a new `hash` which is
+just like orginial but with delta applied to it. Let's apply delta from the
+previous example to the first hash from the same example
+
+
+```js
+var patch = require("diffpatcher/patch")
+
+patch({ a: { b: 1 }, c: { d: 2 } },     // hash#1
+      {                                 // delta
+        a: {
+          b: null,        // -
+          e: 3            // +
+        },
+        c: {
+          d: 4            // ±
+        }
+      })
+
+// => { a: { e: 3 }, c: { d: 4 } }      // hash#2
+```
+
+That's about it really, just diffing hashes and applying thes diffs on them.
+
+
+### rebase
+
+And as Linus mentioned everything in git can be expressed with `rebase`, that
+also pretty much the case for `diffpatcher`. `rebase` takes `target` hash,
+and rebases `parent` onto it with `diff` applied.
+
+## Install
+
+    npm install diffpatcher

data/vendor/interactivate/node_modules/interactivate/node_modules/diffpatcher/diff.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var method = require("method")
+
+// Method is designed to work with data structures representing application
+// state. Calling it with a state should return object representing `delta`
+// that has being applied to a previous state to get to a current state.
+//
+// Example
+//
+// diff(state) // => { "item-id-1": { title: "some title" } "item-id-2": null }
+var diff = method("diff")
+
+// diff between `null` / `undefined` to any hash is a hash itself.
+diff.define(null, function(from, to) { return to })
+diff.define(undefined, function(from, to) { return to })
+diff.define(Object, function(from, to) {
+  return calculate(from, to || {}) || {}
+})
+
+function calculate(from, to) {
+  var diff = {}
+  var changes = 0
+  Object.keys(from).forEach(function(key) {
+    changes = changes + 1
+    if (!(key in to) && from[key] != null) diff[key] = null
+    else changes = changes - 1
+  })
+  Object.keys(to).forEach(function(key) {
+    changes = changes + 1
+    var previous = from[key]
+    var current = to[key]
+    if (previous === current) return (changes = changes - 1)
+    if (typeof(current) !== "object") return diff[key] = current
+    if (typeof(previous) !== "object") return diff[key] = current
+    var delta = calculate(previous, current)
+    if (delta) diff[key] = delta
+    else changes = changes - 1
+  })
+  return changes ? diff : null
+}
+
+diff.calculate = calculate
+
+module.exports = diff

data/vendor/interactivate/node_modules/interactivate/node_modules/diffpatcher/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+exports.diff = require("./diff")
+exports.patch = require("./patch")
+exports.rebase = require("./rebase")

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

@@ -0,0 +1,53 @@
+{
+  "name": "diffpatcher",
+  "id": "diffpatcher",
+  "version": "1.0.0",
+  "description": "Utilities for diff-ing & patch-ing hashes",
+  "keywords": [
+    "diff",
+    "patch",
+    "rebase",
+    "hash",
+    "changes",
+    "versions"
+  ],
+  "author": {
+    "name": "Irakli Gozalishvili",
+    "email": "rfobic@gmail.com",
+    "url": "http://jeditoolkit.com"
+  },
+  "homepage": "https://github.com/Gozala/diffpatcher",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gozala/diffpatcher.git",
+    "web": "https://github.com/Gozala/diffpatcher"
+  },
+  "bugs": {
+    "url": "http://github.com/Gozala/diffpatcher/issues/"
+  },
+  "devDependencies": {
+    "test": "~0.x.0",
+    "repl-utils": "~1.0.0",
+    "phantomify": "~0.1.0"
+  },
+  "main": "./index.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",
+    "repl": "node node_modules/repl-utils"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/Gozala/diffpatcher/License.md"
+    }
+  ],
+  "dependencies": {
+    "method": "~1.0.0"
+  },
+  "readme": "# diffpatcher\n\n[![Build Status](https://secure.travis-ci.org/Gozala/diffpatcher.png)](http://travis-ci.org/Gozala/diffpatcher)\n\nDiffpatcher is a small library that lets you treat hashes as if they were\ngit repositories.\n\n## diff\n\nDiff function that takes two hashes and returns delta hash.\n\n```js\nvar diff = require(\"diffpatcher/diff\")\n\ndiff({ a: { b: 1 }, c: { d: 2 } },      // hash#1\n     { a: { e: 3 }, c: { d: 4 } })      // hash#2\n\n// => {                                 // delta\n//      a: {\n//        b: null,        // -\n//        e: 3            // +\n//      },\n//      c: {\n//        d: 4            // ±\n//      }\n//    }\n```\n\nAs you can see from the example above `delta` makes no real distinction between\nproprety upadate and property addition. Try to think of additions as an update\nfrom `undefined` to whatever it's being updated to.\n\n## patch\n\nPatch fuction takes a `hash` and a `delta` and returns a new `hash` which is\njust like orginial but with delta applied to it. Let's apply delta from the\nprevious example to the first hash from the same example\n\n\n```js\nvar patch = require(\"diffpatcher/patch\")\n\npatch({ a: { b: 1 }, c: { d: 2 } },     // hash#1\n      {                                 // delta\n        a: {\n          b: null,        // -\n          e: 3            // +\n        },\n        c: {\n          d: 4            // ±\n        }\n      })\n\n// => { a: { e: 3 }, c: { d: 4 } }      // hash#2\n```\n\nThat's about it really, just diffing hashes and applying thes diffs on them.\n\n\n### rebase\n\nAnd as Linus mentioned everything in git can be expressed with `rebase`, that\nalso pretty much the case for `diffpatcher`. `rebase` takes `target` hash,\nand rebases `parent` onto it with `diff` applied.\n\n## Install\n\n    npm install diffpatcher\n",
+  "readmeFilename": "Readme.md",
+  "_id": "diffpatcher@1.0.0",
+  "_from": "diffpatcher"
+}

data/vendor/interactivate/node_modules/interactivate/node_modules/diffpatcher/patch.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var method = require("method")
+var rebase = require("./rebase")
+
+// Method is designed to work with data structures representing application
+// state. Calling it with a state and delta should return object representing
+// new state, with changes in `delta` being applied to previous.
+//
+// ## Example
+//
+// patch(state, {
+//   "item-id-1": { completed: false }, // update
+//   "item-id-2": null                  // delete
+// })
+var patch = method("patch")
+patch.define(Object, function patch(hash, delta) {
+  return rebase({}, hash, delta)
+})
+
+module.exports = patch

data/vendor/interactivate/node_modules/interactivate/node_modules/diffpatcher/rebase.js

@@ -0,0 +1,33 @@
+"use strict";
+
+function rebase(result, parent, delta) {
+  Object.keys(parent).forEach(function(key) {
+    // If `parent[key]` is `null` it means attribute was deleted in previous
+    // update. We skip such properties as there is no use in keeping them
+    // around. If `delta[key]` is `null` we skip these properties too as
+    // the have being deleted.
+    if (!(parent[key] == null || (key in delta && delta[key] == null)))
+      result[key] = parent[key]
+  }, result)
+  Object.keys(delta).forEach(function(key) {
+    if (key in parent) {
+      var current = delta[key]
+      var previous = parent[key]
+      if (current === previous) current = current
+      // If `delta[key]` is `null` it's delete so we just skip property.
+      else if (current == null) current = current
+      // If value is of primitive type (function or regexps should not
+      // even be here) we just update in place.
+      else if (typeof(current) !== "object") result[key] = current
+      // If previous value associated with this key was primitive
+      // and it's mapped to non primitive
+      else if (typeof(previous) !== "object") result[key] = current
+      else result[key] = rebase({}, previous, current)
+    } else {
+      result[key] = delta[key]
+    }
+  })
+  return result
+}
+
+module.exports = rebase

data/vendor/interactivate/node_modules/interactivate/node_modules/diffpatcher/test/diff.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var diff = require("../diff")
+
+exports["test diff from null"] = function(assert) {
+  var to = { a: 1, b: 2 }
+  assert.equal(diff(null, to), to, "diff null to x returns x")
+  assert.equal(diff(void(0), to), to, "diff undefined to x returns x")
+
+}
+
+exports["test diff to null"] = function(assert) {
+  var from = { a: 1, b: 2 }
+  assert.deepEqual(diff({ a: 1, b: 2 }, null),
+                   { a: null, b: null },
+                   "diff x null returns x with all properties nullified")
+}
+
+exports["test diff identical"] = function(assert) {
+  assert.deepEqual(diff({}, {}), {}, "diff on empty objects is {}")
+
+  assert.deepEqual(diff({ a: 1, b: 2 }, { a: 1, b: 2 }), {},
+                   "if properties match diff is {}")
+
+  assert.deepEqual(diff({ a: 1, b: { c: { d: 3, e: 4 } } },
+                        { a: 1, b: { c: { d: 3, e: 4 } } }), {},
+                   "diff between identical nested hashes is {}")
+
+}
+
+exports["test diff delete"] = function(assert) {
+  assert.deepEqual(diff({ a: 1, b: 2 }, { b: 2 }), { a: null },
+                   "missing property is deleted")
+  assert.deepEqual(diff({ a: 1, b: 2 }, { a: 2 }), { a: 2, b: null },
+                   "missing property is deleted another updated")
+  assert.deepEqual(diff({ a: 1, b: 2 }, {}), { a: null, b: null },
+                   "missing propertes are deleted")
+  assert.deepEqual(diff({ a: 1, b: { c: { d: 2 } } }, {}),
+                   { a: null, b: null },
+                   "missing deep propertes are deleted")
+  assert.deepEqual(diff({ a: 1, b: { c: { d: 2 } } }, { b: { c: {} } }),
+                   { a: null, b: { c: { d: null } } },
+                   "missing nested propertes are deleted")
+}
+
+exports["test add update"] = function(assert) {
+  assert.deepEqual(diff({ a: 1, b: 2 }, { b: 2, c: 3 }), { a: null, c: 3 },
+                   "delete and add")
+  assert.deepEqual(diff({ a: 1, b: 2 }, { a: 2, c: 3 }), { a: 2, b: null, c: 3 },
+                   "delete and adds")
+  assert.deepEqual(diff({}, { a: 1, b: 2 }), { a: 1, b: 2 },
+                   "diff on empty objcet returns equivalen of to")
+  assert.deepEqual(diff({ a: 1, b: { c: { d: 2 } } }, { d: 3 }),
+                   { a: null, b: null, d: 3 },
+                   "missing deep propertes are deleted")
+  assert.deepEqual(diff({ b: { c: {} }, d: null }, { a: 1, b: { c: { d: 2 } } }),
+                   { a: 1, b: { c: { d: 2 } } },
+                   "missing nested propertes are deleted")
+}
+
+if (require.main === module)
+  require("test").run(exports)

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

@@ -0,0 +1,16 @@
+"use strict";
+
+var diff = require("../diff")
+var patch = require("../patch")
+
+exports["test diff"] = require("./diff")
+exports["test patch"] = require("./patch")
+
+exports["test patch(a, diff(a, b)) => b"] = function(assert) {
+  var a = { a: { b: 1 }, c: { d: 2 } }
+  var b = { a: { e: 3 }, c: { d: 4 } }
+
+  assert.deepEqual(patch(a, diff(a, b)), b, "patch(a, diff(a, b)) => b")
+}
+
+require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/diffpatcher/test/patch.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var patch = require("../patch")
+
+exports["test patch delete"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, { a: null }), { b: 2 }, "null removes property")
+}
+
+exports["test patch delete with void"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, { a: void(0) }), { b: 2 },
+                   "void(0) removes property")
+}
+
+exports["test patch addition"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, { c: 3 }), { a: 1, b: 2, c: 3 },
+                   "new properties are added")
+}
+
+exports["test patch addition"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, { c: 3 }), { a: 1, b: 2, c: 3 },
+                   "new properties are added")
+}
+
+exports["test hash on itself"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, hash), hash,
+                   "applying hash to itself returns hash itself")
+}
+
+exports["test patch with empty delta"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, {}), hash,
+                   "applying empty delta results in no changes")
+}
+
+exports["test patch nested data"] = function(assert) {
+  assert.deepEqual(patch({ a: { b: 1 }, c: { d: 2 } },
+                         { a: { b: null, e: 3 }, c: { d: 4 } }),
+                   { a: { e: 3 }, c: { d: 4 } },
+                   "nested structures can also be patched")
+}
+
+if (require.main === module)
+  require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/dom-reduce/History.md

@@ -0,0 +1,15 @@
+# Changes
+
+## 1.0.0 / 2012-11-24
+
+ - Update to new `reducible` & `reducers` libraries
+
+## 0.1.0 / 2012-11-02
+
+  - Write introduction
+  - Hook with a test infrastructure
+  - Update for new reducers version.
+
+## 0.0.1 / 2012-10-21
+
+  - Initial release

data/vendor/interactivate/node_modules/interactivate/node_modules/dom-reduce/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/interactivate/node_modules/interactivate/node_modules/dom-reduce/Readme.md

@@ -0,0 +1,54 @@
+# dom-reduce
+
+[![Build Status](https://secure.travis-ci.org/Gozala/dom-reduce.png)](http://travis-ci.org/Gozala/dom-reduce)
+
+Small library for dealing with browser DOM events in a [reducible][reducers]
+style. This lets operate on user events as with regular collection data
+structures in composable manner.
+
+## Usage
+
+```js
+var open = require("dom-reduce/event")
+var map = require("reducers/map")
+var filter = require("reducers/filter")
+var fold = require("reducers/fold")
+var takeWhile = require("reducers/take-while")
+
+// Take stream of mouse move events.
+var moves = open(document.documentElement, "mousemove")
+// Map it to the axis positions
+var axis = map(moves, function(event) {
+  return { x: event.clientX, y: event.clientY }
+})
+// Filter down to the area we're interested in.
+var lineAxis = filter(axis, function(value) {
+  return value.x > 190 && value.x < 200
+})
+
+// Take positions only until mouse reaches the edge.
+// Note that when this contidion is met event listeners
+// will automatically be removed.
+var values = takeWhile(lineAxis, function(value) {
+  return value.y > 0
+})
+
+// Drow sowething in the given range.
+fold(lineAxis, function(position) {
+  draw(position)
+})
+```
+
+## Install
+
+    npm install dom-reduce
+
+## Develop
+
+Library is developed using awesome [browserify][]! [Phantomify][] is used
+for running test in a [PhantomJS][].
+
+[reducers]:https://github.com/Gozala/reducers
+[browserify]:https://github.com/substack/node-browserify
+[phantomify]:https://github.com/Gozala/phantomify
+[phantomjs]:https://github.com/ariya/phantomjs