sprockets-browserify 0.2.0 → 0.3.0

data/node_modules/browserify/node_modules/zlib-browserify/node_modules/tape/test/array.js

@@ -0,0 +1,68 @@
+var falafel = require('falafel');
+var tape = require('../');
+var tap = require('tap');
+
+tap.test('array test', function (tt) {
+    tt.plan(1);
+    
+    var test = tape.createHarness();
+    var tc = tap.createConsumer();
+    
+    var rows = [];
+    tc.on('data', function (r) { rows.push(r) });
+    tc.on('end', function () {
+        var rs = rows.map(function (r) {
+            if (r && typeof r === 'object') {
+                return { id : r.id, ok : r.ok, name : r.name.trim() };
+            }
+            else return r;
+        });
+        tt.same(rs, [
+            'TAP version 13',
+            'array',
+            { id: 1, ok: true, name: 'should be equivalent' },
+            { id: 2, ok: true, name: 'should be equivalent' },
+            { id: 3, ok: true, name: 'should be equivalent' },
+            { id: 4, ok: true, name: 'should be equivalent' },
+            { id: 5, ok: true, name: 'should be equivalent' },
+            'tests 5',
+            'pass  5',
+            'ok'
+        ]);
+    });
+    
+    test.stream.pipe(tc);
+    
+    test('array', function (t) {
+        t.plan(5);
+        
+        var src = '(' + function () {
+            var xs = [ 1, 2, [ 3, 4 ] ];
+            var ys = [ 5, 6 ];
+            g([ xs, ys ]);
+        } + ')()';
+        
+        var output = falafel(src, function (node) {
+            if (node.type === 'ArrayExpression') {
+                node.update('fn(' + node.source() + ')');
+            }
+        });
+        
+        var arrays = [
+            [ 3, 4 ],
+            [ 1, 2, [ 3, 4 ] ],
+            [ 5, 6 ],
+            [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
+        ];
+        
+        Function(['fn','g'], output)(
+            function (xs) {
+                t.same(arrays.shift(), xs);
+                return xs;
+            },
+            function (xs) {
+                t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
+            }
+        );
+    });
+});

data/node_modules/browserify/node_modules/zlib-browserify/node_modules/tape/test/child_ordering.js

@@ -0,0 +1,51 @@
+var test = require('../');
+
+var childRan = false;
+
+test('parent', function(t) {
+    t.test('child', function(t) {
+        childRan = true;
+        t.pass('child ran');
+        t.end();
+    });
+    t.end();
+});
+
+test('uncle', function(t) {
+    t.ok(childRan, 'Child should run before next top-level test');
+    t.end();
+});
+
+var grandParentRan = false;
+var parentRan = false;
+var grandChildRan = false;
+test('grandparent', function(t) {
+    grandParentRan = true;
+    t.test('parent', function(t) {
+        parentRan = true;
+        t.test('grandchild', function(t) {
+            grandChildRan = true;
+            t.pass('grand child ran');
+            t.end();
+        });
+        t.pass('parent ran');
+        t.end();
+    });
+    t.test('other parent', function(t) {
+        t.ok(parentRan, 'first parent runs before second parent');
+        t.ok(grandChildRan, 'grandchild runs before second parent');
+        t.end();
+    });
+    t.pass('grandparent ran');
+    t.end();
+});
+
+test('second grandparent', function(t) {
+    t.ok(grandParentRan, 'grandparent ran');
+    t.ok(parentRan, 'parent ran');
+    t.ok(grandChildRan, 'grandchild ran');
+    t.pass('other grandparent ran');
+    t.end();
+});
+
+// vim: set softtabstop=4 shiftwidth=4:

data/node_modules/browserify/node_modules/zlib-browserify/node_modules/tape/test/exit.js

@@ -0,0 +1,108 @@
+var tap = require('tap');
+var spawn = require('child_process').spawn;
+
+tap.test('exit ok', function (t) {
+    t.plan(2);
+    
+    var tc = tap.createConsumer();
+    
+    var rows = [];
+    tc.on('data', function (r) { rows.push(r) });
+    tc.on('end', function () {
+        var rs = rows.map(function (r) {
+            if (r && typeof r === 'object') {
+                return { id : r.id, ok : r.ok, name : r.name.trim() };
+            }
+            else return r;
+        });
+        t.same(rs, [
+            'TAP version 13',
+            'array',
+            { id: 1, ok: true, name: 'should be equivalent' },
+            { id: 2, ok: true, name: 'should be equivalent' },
+            { id: 3, ok: true, name: 'should be equivalent' },
+            { id: 4, ok: true, name: 'should be equivalent' },
+            { id: 5, ok: true, name: 'should be equivalent' },
+            'tests 5',
+            'pass  5',
+            'ok'
+        ]);
+    });
+    
+    var ps = spawn(process.execPath, [ __dirname + '/exit/ok.js' ]);
+    ps.stdout.pipe(tc);
+    ps.on('exit', function (code) {
+        t.equal(code, 0);
+    });
+});
+
+tap.test('exit fail', function (t) {
+    t.plan(2);
+    
+    var tc = tap.createConsumer();
+    
+    var rows = [];
+    tc.on('data', function (r) { rows.push(r) });
+    tc.on('end', function () {
+        var rs = rows.map(function (r) {
+            if (r && typeof r === 'object') {
+                return { id : r.id, ok : r.ok, name : r.name.trim() };
+            }
+            else return r;
+        });
+        t.same(rs, [
+            'TAP version 13',
+            'array',
+            { id: 1, ok: true, name: 'should be equivalent' },
+            { id: 2, ok: true, name: 'should be equivalent' },
+            { id: 3, ok: true, name: 'should be equivalent' },
+            { id: 4, ok: true, name: 'should be equivalent' },
+            { id: 5, ok: false, name: 'should be equivalent' },
+            'tests 5',
+            'pass  4',
+            'fail  1'
+        ]);
+    });
+    
+    var ps = spawn(process.execPath, [ __dirname + '/exit/fail.js' ]);
+    ps.stdout.pipe(tc);
+    ps.on('exit', function (code) {
+        t.notEqual(code, 0);
+    });
+});
+
+tap.test('too few exit', function (t) {
+    t.plan(2);
+    
+    var tc = tap.createConsumer();
+    
+    var rows = [];
+    tc.on('data', function (r) { rows.push(r) });
+    tc.on('end', function () {
+        var rs = rows.map(function (r) {
+            if (r && typeof r === 'object') {
+                return { id : r.id, ok : r.ok, name : r.name.trim() };
+            }
+            else return r;
+        });
+        t.same(rs, [
+            'TAP version 13',
+            'array',
+            { id: 1, ok: true, name: 'should be equivalent' },
+            { id: 2, ok: true, name: 'should be equivalent' },
+            { id: 3, ok: true, name: 'should be equivalent' },
+            { id: 4, ok: true, name: 'should be equivalent' },
+            { id: 5, ok: true, name: 'should be equivalent' },
+            { id: 6, ok: false, name: 'plan != count' },
+            'tests 6',
+            'pass  5',
+            'fail  1'
+        ]);
+    });
+    
+    var ps = spawn(process.execPath, [ __dirname + '/exit/too_few.js' ]);
+    ps.stdout.pipe(tc);
+    ps.on('exit', function (code) {
+        t.notEqual(code, 0);
+    });
+});

data/node_modules/browserify/node_modules/zlib-browserify/node_modules/tape/test/exit/fail.js

@@ -0,0 +1,35 @@
+var test = require('../../');
+var falafel = require('falafel');
+
+test('array', function (t) {
+    t.plan(5);
+    
+    var src = '(' + function () {
+        var xs = [ 1, 2, [ 3, 4 ] ];
+        var ys = [ 5, 6 ];
+        g([ xs, ys ]);
+    } + ')()';
+    
+    var output = falafel(src, function (node) {
+        if (node.type === 'ArrayExpression') {
+            node.update('fn(' + node.source() + ')');
+        }
+    });
+    
+    var arrays = [
+        [ 3, 4 ],
+        [ 1, 2, [ 3, 4 ] ],
+        [ 5, 6 ],
+        [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
+    ];
+    
+    Function(['fn','g'], output)(
+        function (xs) {
+            t.same(arrays.shift(), xs);
+            return xs;
+        },
+        function (xs) {
+            t.same(xs, [ [ 1, 2, [ 3, 4444 ] ], [ 5, 6 ] ]);
+        }
+    );
+});

data/node_modules/browserify/node_modules/zlib-browserify/node_modules/tape/test/exit/ok.js

@@ -0,0 +1,35 @@
+var falafel = require('falafel');
+var test = require('../../');
+
+test('array', function (t) {
+    t.plan(5);
+    
+    var src = '(' + function () {
+        var xs = [ 1, 2, [ 3, 4 ] ];
+        var ys = [ 5, 6 ];
+        g([ xs, ys ]);
+    } + ')()';
+    
+    var output = falafel(src, function (node) {
+        if (node.type === 'ArrayExpression') {
+            node.update('fn(' + node.source() + ')');
+        }
+    });
+    
+    var arrays = [
+        [ 3, 4 ],
+        [ 1, 2, [ 3, 4 ] ],
+        [ 5, 6 ],
+        [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
+    ];
+    
+    Function(['fn','g'], output)(
+        function (xs) {
+            t.same(arrays.shift(), xs);
+            return xs;
+        },
+        function (xs) {
+            t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
+        }
+    );
+});

data/node_modules/browserify/node_modules/zlib-browserify/node_modules/tape/test/exit/too_few.js

@@ -0,0 +1,35 @@
+var falafel = require('falafel');
+var test = require('../../');
+
+test('array', function (t) {
+    t.plan(6);
+    
+    var src = '(' + function () {
+        var xs = [ 1, 2, [ 3, 4 ] ];
+        var ys = [ 5, 6 ];
+        g([ xs, ys ]);
+    } + ')()';
+    
+    var output = falafel(src, function (node) {
+        if (node.type === 'ArrayExpression') {
+            node.update('fn(' + node.source() + ')');
+        }
+    });
+    
+    var arrays = [
+        [ 3, 4 ],
+        [ 1, 2, [ 3, 4 ] ],
+        [ 5, 6 ],
+        [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
+    ];
+    
+    Function(['fn','g'], output)(
+        function (xs) {
+            t.same(arrays.shift(), xs);
+            return xs;
+        },
+        function (xs) {
+            t.same(xs, [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ]);
+        }
+    );
+});

data/node_modules/browserify/node_modules/zlib-browserify/node_modules/tape/test/fail.js

@@ -0,0 +1,68 @@
+var falafel = require('falafel');
+var tape = require('../');
+var tap = require('tap');
+
+tap.test('array test', function (tt) {
+    tt.plan(1);
+    
+    var test = tape.createHarness({ exit : false });
+    var tc = tap.createConsumer();
+    
+    var rows = [];
+    tc.on('data', function (r) { rows.push(r) });
+    tc.on('end', function () {
+        var rs = rows.map(function (r) {
+            if (r && typeof r === 'object') {
+                return { id : r.id, ok : r.ok, name : r.name.trim() };
+            }
+            else return r;
+        });
+        tt.same(rs, [
+            'TAP version 13',
+            'array',
+            { id: 1, ok: true, name: 'should be equivalent' },
+            { id: 2, ok: true, name: 'should be equivalent' },
+            { id: 3, ok: true, name: 'should be equivalent' },
+            { id: 4, ok: true, name: 'should be equivalent' },
+            { id: 5, ok: false, name: 'should be equivalent' },
+            'tests 5',
+            'pass  4',
+            'fail  1'
+        ]);
+    });
+    
+    test.stream.pipe(tc);
+    
+    test('array', function (t) {
+        t.plan(5);
+        
+        var src = '(' + function () {
+            var xs = [ 1, 2, [ 3, 4 ] ];
+            var ys = [ 5, 6 ];
+            g([ xs, ys ]);
+        } + ')()';
+        
+        var output = falafel(src, function (node) {
+            if (node.type === 'ArrayExpression') {
+                node.update('fn(' + node.source() + ')');
+            }
+        });
+        
+        var arrays = [
+            [ 3, 4 ],
+            [ 1, 2, [ 3, 4 ] ],
+            [ 5, 6 ],
+            [ [ 1, 2, [ 3, 4 ] ], [ 5, 6 ] ],
+        ];
+        
+        Function(['fn','g'], output)(
+            function (xs) {
+                t.same(arrays.shift(), xs);
+                return xs;
+            },
+            function (xs) {
+                t.same(xs, [ [ 1, 2, [ 3, 4444 ] ], [ 5, 6 ] ]);
+            }
+        );
+    });
+});

data/node_modules/browserify/node_modules/zlib-browserify/node_modules/tape/test/harness.js

@@ -0,0 +1,88 @@
+var test = require('../');
+var harness = test.createHarness({ exit : false });
+
+// minimal write stream mockery
+var collector = {
+    written: [],
+    ended: false,
+    writable: true,
+    write: function (c) {
+        console.log('#> %s', c.replace(/\n$/, '').split(/\n/).join('\n#> '));
+        if (this.ended)
+            throw new Error('write after end');
+        this.written.push(c);
+        return true;
+    },
+    end: function (c) {
+        console.error('collector end');
+        if (this.ended)
+            throw new Error('end after end');
+        if (c)
+            this.write(c);
+        this.ended = true;
+    },
+    on: function () {},
+    emit: function () {},
+    removeListener: function () {}
+};
+
+var wanted =
+    [ 'TAP version 13',
+      '# harness test',
+      '# hello',
+      'ok 1 this is ok',
+      'not ok 2 this is not ok',
+      '  ---',
+      '    operator: fail',
+      '    expected:',
+      '    actual:',
+      '  ...',
+      '# sub harness test',
+      'ok 3 math still works',
+      'ok 4 except when it doesn\'t',
+      '# sub harness internal test',
+      'ok 5 gas',
+      'ok 6 lulz i am immature',
+      '',
+      '1..6',
+      '# tests 6',
+      '# pass  5',
+      '# fail  1',
+      '' ];
+
+harness.stream.pipe(collector);
+
+test('correct output', function (t) {
+    harness.stream.on('end', function () {
+        // accept trailing whitespace, or multiple lines on the same write(),
+        var found = collector.written.join('').split(/\n/).map(function (s) {
+            return s.replace(/\s+$/, '');
+        });
+        t.same(found, wanted, 'got expected output');
+        t.end();
+    });
+
+    harness('harness test', function (ht) {
+        // console.error('harness stream', harness.stream);
+        ht.comment('hello');
+        ht.pass('this is ok');
+        ht.fail('this is not ok');
+        ht.test('sub harness test', function (sht) {
+            sht.equal(4, 4, 'math still works');
+            sht.notEqual(0.1 + 0.1 + 0.1, 0.3, 'except when it doesn\'t');
+            sht.test('sub harness internal test', function (shit) {
+                console.error('sub harness internal test');
+                // shit.plan(2);
+                shit.pass('gas');
+                shit.pass('lulz i am immature');
+                shit.end();
+            });
+            sht.end();
+        });
+        ht.end();
+        console.error('called ht.end');
+    });
+});
+
+
+// vim: set softtabstop=4 shiftwidth=4: