sprockets-browserify 0.1.0

data/node_modules/through/readme.markdown

@@ -0,0 +1,43 @@
+#through
+
+[![build status](https://secure.travis-ci.org/dominictarr/through.png)](http://travis-ci.org/dominictarr/through)
+
+Easy way to create a `Stream` that is both `readable` and `writable`. 
+
+* Pass in optional `write` and `end` methods.
+* `through` takes care of pause/resume logic if you use `this.queue(data)` instead of `this.emit('data', data)`.
+* Use `this.pause()` and `this.resume()` to manage flow.
+* Check `this.paused` to see current flow state. (write always returns `!this.paused`).
+
+This function is the basis for most of the syncronous streams in 
+[event-stream](http://github.com/dominictarr/event-stream).
+
+``` js
+var through = require('through')
+
+through(function write(data) {
+    this.queue(data) //data *must* not be null
+  },
+  function end () { //optional
+    this.queue(null)
+  })
+```
+
+Or, can also be used _without_ buffering on pause, use `this.emit('data', data)`,
+and this.emit('end')
+
+``` js
+var through = require('through')
+
+through(function write(data) {
+    this.emit('data', data)
+    //this.pause() 
+  },
+  function end () { //optional
+    this.emit('end')
+  })
+```
+
+## License
+
+MIT / Apache2

data/node_modules/through/test/buffering.js

@@ -0,0 +1,71 @@
+var through = require('..')
+
+// must emit end before close.
+
+exports['buffering'] = function (t) {
+  var ts = through(function (data) {
+    this.queue(data)
+  }, function () {
+    this.queue(null)
+  })
+
+  var ended = false,  actual = []
+
+  ts.on('data', actual.push.bind(actual))
+  ts.on('end', function () {
+    ended = true
+  })
+
+  ts.write(1)
+  ts.write(2)
+  ts.write(3)
+  t.deepEqual(actual, [1, 2, 3])
+  ts.pause()
+  ts.write(4)
+  ts.write(5)
+  ts.write(6)
+  t.deepEqual(actual, [1, 2, 3])
+  ts.resume()
+  t.deepEqual(actual, [1, 2, 3, 4, 5, 6])
+  ts.pause()
+  ts.end()
+  t.ok(!ended)
+  ts.resume()
+  t.ok(ended)
+  t.end()
+
+}
+
+exports['buffering has data in queue, when ends'] = function (t) {
+
+  /*
+   * If stream ends while paused with data in the queue,
+   * stream should still emit end after all data is written
+   * on resume.
+   */
+
+  var ts = through(function (data) {
+    this.queue(data)
+  }, function () {
+    this.queue(null)
+  })
+
+  var ended = false,  actual = []
+
+  ts.on('data', actual.push.bind(actual))
+  ts.on('end', function () {
+    ended = true
+  })
+
+  ts.pause()
+  ts.write(1)
+  ts.write(2)
+  ts.write(3)
+  ts.end()
+  t.deepEqual(actual, [], 'no data written yet, still paused')
+  t.ok(!ended, 'end not emitted yet, still paused')
+  ts.resume()
+  t.deepEqual(actual, [1, 2, 3], 'resumed, all data should be delivered')
+  t.ok(ended, 'end should be emitted once all data was delivered')
+  t.end();
+}

data/node_modules/through/test/end.js

@@ -0,0 +1,27 @@
+var through = require('..')
+
+// must emit end before close.
+
+exports['end before close'] = function (t) {
+  var ts = through()
+  var ended = false, closed = false
+
+  ts.on('end', function () {
+    t.ok(!closed)
+    ended = true
+  })
+  ts.on('close', function () {
+    t.ok(ended)
+    closed = true
+  })
+
+  ts.write(1)
+  ts.write(2)
+  ts.write(3)
+  ts.end()
+  t.ok(ended)
+  t.ok(closed)
+
+  t.end()
+
+}

data/node_modules/through/test/index.js

@@ -0,0 +1,113 @@
+
+var spec = require('stream-spec')
+var through = require('..')
+var a = require('assertions')
+
+/*
+  I'm using these two functions, and not streams and pipe
+  so there is less to break. if this test fails it must be
+  the implementation of _through_
+*/
+
+function write(array, stream) {
+  array = array.slice()
+  function next() {
+    while(array.length)
+      if(stream.write(array.shift()) === false)
+        return stream.once('drain', next)
+    
+    stream.end()
+  }
+
+  next()
+}
+
+function read(stream, callback) {
+  var actual = []
+  stream.on('data', function (data) {
+    actual.push(data)
+  })
+  stream.once('end', function () {
+    callback(null, actual)
+  })
+  stream.once('error', function (err) {
+    callback(err)
+  })
+}
+
+exports['simple defaults'] = function (test) {
+
+  var l = 1000
+    , expected = [] 
+
+  while(l--) expected.push(l * Math.random())
+
+  var t = through()    
+    spec(t)
+      .through()
+      .pausable()
+      .validateOnExit()
+
+  read(t, function (err, actual) {
+    if(err) test.error(err) //fail
+    a.deepEqual(actual, expected)
+    test.done()
+  })
+
+  write(expected, t)
+}
+
+exports['simple functions'] = function (test) {
+
+  var l = 1000
+    , expected = [] 
+
+  while(l--) expected.push(l * Math.random())
+
+  var t = through(function (data) {
+      this.emit('data', data*2)
+    }) 
+    spec(t)
+      .through()
+      .pausable()
+      .validateOnExit()
+
+  read(t, function (err, actual) {
+    if(err) test.error(err) //fail
+    a.deepEqual(actual, expected.map(function (data) {
+      return data*2
+    }))
+    test.done()
+  })
+
+  write(expected, t)
+}
+exports['pauses'] = function (test) {
+
+  var l = 1000
+    , expected = [] 
+
+  while(l--) expected.push(l) //Math.random())
+
+  var t = through()    
+    spec(t)
+      .through()
+      .pausable()
+      .validateOnExit()
+
+  t.on('data', function () {
+    if(Math.random() > 0.1) return
+    t.pause()
+    process.nextTick(function () {
+      t.resume()
+    })
+  })
+
+  read(t, function (err, actual) {
+    if(err) test.error(err) //fail
+    a.deepEqual(actual, expected)
+    test.done()
+  })
+
+  write(expected, t)
+}

data/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "sprockets_browserify",
+  "version": "0.0.1",
+  "description": "Browserify support for Sprockets",
+  "dependencies": {
+    "browserify": "~1.18.0",
+    "module-deps": "~0.5.0",
+    "through": "~2.2.1",
+    "JSONStream": "~0.4.3"
+  }
+}