pax_global_header00006660000000000000000000000064127543742770014534gustar00rootroot0000000000000052 comment=09243c8b8354420059c9bc935875e1896aa58c10 from2-2.3.0/000077500000000000000000000000001275437427700125635ustar00rootroot00000000000000from2-2.3.0/.travis.yml000066400000000000000000000001551275437427700146750ustar00rootroot00000000000000language: node_js before_install: - npm install -g npm node_js: - "0.8" - "0.10" - "0.12" - "iojs" from2-2.3.0/LICENSE.md000066400000000000000000000020751275437427700141730ustar00rootroot00000000000000## The MIT License (MIT) ## Copyright (c) 2014 Hugh Kennedy 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. from2-2.3.0/README.md000066400000000000000000000050451275437427700140460ustar00rootroot00000000000000# from2 [![Flattr this!](https://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=hughskennedy&url=http://github.com/hughsk/from2&title=from2&description=hughsk/from2%20on%20GitHub&language=en_GB&tags=flattr,github,javascript&category=software)[![experimental](http://hughsk.github.io/stability-badges/dist/experimental.svg)](http://github.com/hughsk/stability-badges) # `from2` is a high-level module for creating readable streams that properly handle backpressure. Convience wrapper for [readable-stream](http://github.com/isaacs/readable-stream)'s `ReadableStream` base class, with an API lifted from [from](http://github.com/dominictarr/from) and [through2](http://github.com/rvagg/through2). ## Usage ## [![from2](https://nodei.co/npm/from2.png?mini=true)](https://nodei.co/npm/from2) ### `stream = from2([opts], read)` ### Where `opts` are the options to pass on to the `ReadableStream` constructor, and `read(size, next)` is called when data is requested from the stream. * `size` is the recommended amount of data (in bytes) to retrieve. * `next(err)` should be called when you're ready to emit more data. For example, here's a readable stream that emits the contents of a given string: ``` javascript var from = require('from2') function fromString(string) { return from(function(size, next) { // if there's no more content // left in the string, close the stream. if (string.length <= 0) return next(null, null) // Pull in a new chunk of text, // removing it from the string. var chunk = string.slice(0, size) string = string.slice(size) // Emit "chunk" from the stream. next(null, chunk) }) } // pipe "hello world" out // to stdout. fromString('hello world').pipe(process.stdout) ``` ### `stream = from2.obj([opts], read)` ### Shorthand for `from2({ objectMode: true }, read)`. ### `createStream = from2.ctor([opts], read)` ### If you're creating similar streams in quick succession you can improve performance by generating a stream **constructor** that you can reuse instead of creating one-off streams on each call. Takes the same options as `from2`, instead returning a constructor which you can use to create new streams. ### See Also - [from2-array](https://github.com/binocarlos/from2-array) - Create a from2 stream based on an array of source values. - [from2-string](https://github.com/yoshuawuyts/from2-string) - Create a stream from a string. Sugary wrapper around from2. ## License ## MIT. See [LICENSE.md](http://github.com/hughsk/from2/blob/master/LICENSE.md) for details. from2-2.3.0/index.js000066400000000000000000000040261275437427700142320ustar00rootroot00000000000000var Readable = require('readable-stream').Readable var inherits = require('inherits') module.exports = from2 from2.ctor = ctor from2.obj = obj var Proto = ctor() function toFunction(list) { list = list.slice() return function (_, cb) { var err = null var item = list.length ? list.shift() : null if (item instanceof Error) { err = item item = null } cb(err, item) } } function from2(opts, read) { if (typeof opts !== 'object' || Array.isArray(opts)) { read = opts opts = {} } var rs = new Proto(opts) rs._from = Array.isArray(read) ? toFunction(read) : (read || noop) return rs } function ctor(opts, read) { if (typeof opts === 'function') { read = opts opts = {} } opts = defaults(opts) inherits(Class, Readable) function Class(override) { if (!(this instanceof Class)) return new Class(override) this._reading = false this._callback = check this.destroyed = false Readable.call(this, override || opts) var self = this var hwm = this._readableState.highWaterMark function check(err, data) { if (self.destroyed) return if (err) return self.destroy(err) if (data === null) return self.push(null) self._reading = false if (self.push(data)) self._read(hwm) } } Class.prototype._from = read || noop Class.prototype._read = function(size) { if (this._reading || this.destroyed) return this._reading = true this._from(size, this._callback) } Class.prototype.destroy = function(err) { if (this.destroyed) return this.destroyed = true var self = this process.nextTick(function() { if (err) self.emit('error', err) self.emit('close') }) } return Class } function obj(opts, read) { if (typeof opts === 'function' || Array.isArray(opts)) { read = opts opts = {} } opts = defaults(opts) opts.objectMode = true opts.highWaterMark = 16 return from2(opts, read) } function noop () {} function defaults(opts) { opts = opts || {} return opts } from2-2.3.0/package.json000066400000000000000000000014701275437427700150530ustar00rootroot00000000000000{ "name": "from2", "description": "Convenience wrapper for ReadableStream, with an API lifted from \"from\" and \"through2\"", "version": "2.3.0", "main": "index.js", "scripts": { "test": "node test" }, "dependencies": { "inherits": "^2.0.1", "readable-stream": "^2.0.0" }, "devDependencies": { "tape": "^4.0.0" }, "author": "Hugh Kennedy (http://hughsk.io/)", "contributors": [ "Mathias Buus " ], "license": "MIT", "repository": { "type": "git", "url": "git://github.com/hughsk/from2" }, "bugs": { "url": "https://github.com/hughsk/from2/issues" }, "homepage": "https://github.com/hughsk/from2", "keywords": [ "from", "stream", "readable", "pull", "convenience", "wrapper" ] } from2-2.3.0/test.js000066400000000000000000000051541275437427700141050ustar00rootroot00000000000000var test = require('tape') var path = require('path') var from = require('./') var fs = require('fs') var tmp = path.resolve( __dirname, 'tmp.txt' ) function fromString(string) { return from(function(size, next) { if (string.length <= 0) return next(null, null) var chunk = string.slice(0, size) string = string.slice(size) next(null, chunk) }) } test('from2', function(t) { var contents = fs.readFileSync(__filename, 'utf8') var stream = fromString(contents) stream .pipe(fs.createWriteStream(tmp)) .on('close', function() { t.equal(fs.readFileSync(tmp, 'utf8'), contents) fs.unlinkSync(tmp) t.end() }) }) test('old mode', function(t) { var contents = fs.readFileSync(__filename, 'utf8') var stream = fromString(contents) var buffer = '' stream.on('data', function(data) { buffer += data }).on('end', function() { t.equal(buffer, contents) t.end() }) }) test('destroy', function(t) { var stream = from(function(size, next) { process.nextTick(function() { next(null, 'no') }) }) stream.on('data', function(data) { t.ok(false) }).on('close', function() { t.ok(true) t.end() }) stream.destroy() }) test('arrays', function (t) { var input = ['a', 'b', 'c'] var stream = from(input) var output = [] stream.on('data', function (letter) { output.push(letter.toString()) }) stream.on('end', function () { t.deepEqual(input, output) t.end() }) }) test('obj arrays', function (t) { var input = [{foo:'a'}, {foo:'b'}, {foo:'c'}] var stream = from.obj(input) var output = [] stream.on('data', function (letter) { output.push(letter) }) stream.on('end', function () { t.deepEqual(input, output) t.end() }) }) test('arrays can emit errors', function (t) { var input = ['a', 'b', new Error('ooops'), 'c'] var stream = from(input) var output = [] stream.on('data', function (letter) { output.push(letter.toString()) }) stream.on('error', function(e){ t.deepEqual(['a', 'b'], output) t.equal('ooops', e.message) t.end() }) stream.on('end', function () { t.fail('the stream should have errored') }) }) test('obj arrays can emit errors', function (t) { var input = [{foo:'a'}, {foo:'b'}, new Error('ooops'), {foo:'c'}] var stream = from.obj(input) var output = [] stream.on('data', function (letter) { output.push(letter) }) stream.on('error', function(e){ t.deepEqual([{foo:'a'}, {foo:'b'}], output) t.equal('ooops', e.message) t.end() }) stream.on('end', function () { t.fail('the stream should have errored') }) })