JavaScript read-stream fromArray Examples

Example #1

File: simple.js Project: Raynos/mongo-stream

function testUpdateAndFindAndX() {
    from([{ $set: { foo: "bar" } }])
        .pipe(TempData.update({ hello: "world" }, { safe: true }))
        .pipe(map(function (item) {
            console.log("update result", item)
            assert.equal(item, 1)
            return { $set: { foo2: "bar2" } }
        }))
        .pipe(TempData.findAndModify({ hello: "world" }, [], {
            safe: true
            , upsert: true
            , new: true
        }))
        .pipe(map(function (result) {
            console.log("findAndModify result", result)
            assert.equal(result.foo2, "bar2")
            return { hello: "world" }
        }))
        .pipe(TempData.findAndRemove([], { safe: true }))
        .pipe(map(function (result) {
            console.log("findAndRemove result", result)
            assert.equal(result.foo, "bar")

            testMapReduce()
        }))
}

Example #2

File: test.js Project: Raynos/chain-stream

test("concat with streams", function (t) {
    s()
        .concat(fromArray([4, 5, 6]))
        .toArray(function (list) {
            t.deepEqual(list, six)
            t.end()
        })
})

Example #3

File: index.js Project: Raynos/chain-stream

function chain(stream) {
    if (Array.isArray(stream)) {
        stream = fromArray(stream)
    }

    forEach(chain, addMethod, stream)

    return stream
}

Example #4

File: simple.js Project: Raynos/mongo-stream

function testRemoveAndSave() {
    from([{ hello: "world" }])
        .pipe(TempData.remove({ save: true }))
        .pipe(map(function (item) {
            console.log("removed correctly", item)
            assert.equal(item, 1)
            return { hello: "world" }
        }))
        .pipe(TempData.save({ safe: true}))
        .pipe(to([], function (results) {
            console.log("saved correctly", results)
            assert.equal(results[0].hello, "world")

            testCountAndFindOne()
        }))
}

Example #5

File: simple.js Project: Raynos/mongo-stream

function testInsertAndFind() {
    from(data)
        .pipe(TempData.insert({ safe: true }))
        .pipe(to([], function readList(list) {
            console.log("inserted correctly", list)

            var findStream = TempData.find({ hello: "world" })

            findStream.pipe(to([], function readResult(list2) {
                console.log("found correctly", list2)
                assert.equal(list2[0].hello, "world")

                testRemoveAndSave()
            }))
        }))
}

Example #6

File: simple.js Project: Raynos/lazy-filter-stream

var from = require("read-stream").fromArray
    , to = require("write-stream").toArray
    , filter = require("..")
    , assert = require("assert")

// filter(stream, iterator)
var odds = filter(from([1,2,3,4,5]), function (value) {
    return value % 2
})

odds.pipe(to([], function (list) {
    // the odd values
    assert.deepEqual(list, [1, 3, 5])
    console.log("list", list)
}))

Example #7

File: simple.js Project: HaimLeibovitch/ubinary

var proxy = require("..")
    , from = require("read-stream").fromArray
    , to = require("write-stream").toArray

var source = map(from([1,2,3]), function (chunk) {
    return chunk * 2
})

console.log("one", source.read())
console.log("two", source.read())
console.log("three", source.read())
console.log("four", source.read())

from([1,2,3]).pipe(map(to([], function (list) {
    console.log("writable list", list)
}), function (chunk) {
    return chunk * 3
}))

var mapped = map(from([1,2,3]), function (chunk) {
        return chunk * 2
    })
    , doubleMapped = map(mapped, function (chunk) {
        return chunk * 3
    })
    , asyncMapped = mapAsync(from([1,2,3]), function (chunk, callback) {
        setTimeout(function () {
            callback(null, chunk * 4)
        }, 1000)
    })

Example #8

File: test.js Project: Raynos/chain-stream

 .map(function (value) {
     return fromArray([value, value * 2])
 })

Example #9

File: simple.js Project: Raynos/transform-stream

var from = require("read-stream").fromArray
    , to = require("write-stream").toArray

    , transform = require("..")

from([1,2,3])
    .pipe(transform(function (item, finish) {
        setTimeout(function() {
            finish(null, item * 2)
        }, 1000)
    }))
    .pipe(transform(function (item, next, finish) {
        setTimeout(function () {
            next(item * 2)
        }, 500)

        setTimeout(function () {
            next(item * 3)
        }, 1000)

        setTimeout(function () {
            finish()
        }, 1500)
    }))
    .pipe(transform(function (item) {
        return item * 2
    }))
    .pipe(transform(function (item, finish) {
        console.log("runs in serial")

        setTimeout(function () {