snowball 0.1.21 → 0.1.22

data/node_modules/browserify/test/watch/a.js

@@ -0,0 +1 @@
+module.exports = 9520

data/node_modules/browserify/test/wrap.js

@@ -0,0 +1,43 @@
+var path = require('path');
+var browserify = require('../');
+var test = require('tap').test;
+
+function filter (x) {
+    var s = path.resolve(__dirname, 'wrap/');
+    return x.slice(0, s.length) === s;
+}
+
+test('wrap', function (t) {
+    t.plan(1);
+    var files = browserify({ require : __dirname + '/wrap/a.js' }).files;
+    
+    t.deepEqual(Object.keys(files).filter(filter).sort(), [
+        path.resolve(__dirname, 'wrap/a.js'),
+        path.resolve(__dirname, 'wrap/node_modules/b/main.js'),
+        path.resolve(__dirname, 'wrap/node_modules/b/package.json'),
+        path.resolve(__dirname, 'wrap/c.js'),
+        path.resolve(__dirname, 'wrap/x.js'),
+    ].sort());
+    t.end();
+});
+
+test('wrapArray', function (t) {
+    t.plan(1);
+    var files = browserify({
+        require : [
+            __dirname + '/wrap/a.js',
+            __dirname + '/wrap/skipme.js',
+        ]
+    }).files;
+    
+    t.deepEqual(Object.keys(files).filter(filter).sort(), [
+        path.resolve(__dirname, 'wrap/a.js'),
+        path.resolve(__dirname, 'wrap/node_modules/b/main.js'),
+        path.resolve(__dirname, 'wrap/node_modules/b/package.json'),
+        path.resolve(__dirname, 'wrap/c.js'),
+        path.resolve(__dirname, 'wrap/x.js'),
+        path.resolve(__dirname, 'wrap/skipme.js'),
+        path.resolve(__dirname, 'wrap/node_modules/skipmetoo/index.js'),
+    ].sort());
+    t.end();
+});

data/node_modules/browserify/test/wrap/a.js

@@ -0,0 +1,2 @@
+var b = require('b');
+var c = require('./c');

data/node_modules/browserify/test/wrap/c.js

@@ -0,0 +1 @@
+require('vm');

data/node_modules/browserify/test/wrap/node_modules/b/main.js

@@ -0,0 +1 @@
+require('../../x.js');

data/node_modules/browserify/test/wrap/node_modules/b/package.json

@@ -0,0 +1,3 @@
+{
+    "main" : "main.js"
+}

data/node_modules/browserify/test/wrap/node_modules/skipmetoo/index.js

@@ -0,0 +1 @@
+require('../../skipme');

data/node_modules/browserify/test/wrap/skipme.js

@@ -0,0 +1 @@
+require('skipmetoo');

data/node_modules/browserify/testling/README.markdown

@@ -0,0 +1,29 @@
+browserify testling tests
+=========================
+
+Make a [browserling](http://browserling.com) account to run this test through
+[testling](http://testling.com).
+
+```
+$ ./test.sh
+testling user: substack@gmail.com
+Enter host password for user 'substack@gmail.com':
+Bundling...  done
+
+iexplore/7.0        0/0    0 % ok
+  Log: 15
+iexplore/8.0        0/0    0 % ok
+  Log: 16
+iexplore/9.0        0/0    0 % ok
+  Log: 1
+chrome/15.0         0/0    0 % ok
+  Log: 0
+firefox/7.0         0/0    0 % ok
+  Log: 1
+opera/11.5          0/0    0 % ok
+  Log: 0
+safari/5.1          0/0    0 % ok
+  Log: 3
+
+total               0/0    0 % ok
+```

data/node_modules/browserify/testling/test.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+echo -n 'testling user: '
+read user
+
+stty -echo
+echo -n 'password: '
+read pass
+stty echo
+
+function tick () {
+    cat <(echo 'process={};') ../builtins/__browserify_process.js tick.js \
+        | curl -sSNT- -u "$user:$pass" testling.com
+}
+
+function util () {
+    tar -cf- util.js ../builtins/util.js |
+        curl -sSNT- -u "$user:$pass" \
+        'http://testling.com/?main=util.js&noinstrument=builtins/util.js'
+}
+
+function timers () {
+    tar -cf- timers.js ../builtins/timers.js |
+        curl -sSNT- -u "$user:$pass" \
+        'http://testling.com/?main=timers.js'
+}
+
+if test -z "$1"; then
+    tick
+    util
+    timers
+elif test "$1" == 'tick'; then
+    tick
+elif test "$1" == 'util'; then
+    util
+elif test "$1" == 'timers'; then
+    timers
+fi

data/node_modules/browserify/testling/tick.js

@@ -0,0 +1,9 @@
+var test = require('testling');
+
+test('nextTick', function (t) {
+    var t0 = new Date;
+    process.nextTick(function () {
+        t.log(new Date - t0);
+        t.end();
+    });
+});

data/node_modules/browserify/testling/timers.js

@@ -0,0 +1,50 @@
+var test = require('testling');
+var timers = require('./builtins/timers');
+
+test('setTimeout / clearTimeout', function (t) {
+    t.plan(3);
+    var arg1 = {}
+    var arg2 = {}
+    var async = false
+
+    timers.setTimeout(function(param1, param2) {
+      t.deepEqual(param1, arg1, '1st argument was curried');
+      t.deepEqual(param2, arg2, '2nd argument was curried');
+      t.ok(async, 'setTimeout is async');
+      timers.clearTimeout(id);
+    }, 10, arg1, arg2);
+
+    var id = timers.setTimeout(function() {
+      t.fail('timer had to be cleared');
+    }, 50);
+
+    timers.setTimeout(function() {
+      t.end();
+    }, 100);
+
+    async = true;
+});
+
+test('setInterval / clearInterval', function (t) {
+    t.plan(6);
+    var arg1 = {};
+    var arg2 = {};
+    var called = 0;
+    var async = false;
+
+    var id = timers.setInterval(function(param1, param2) {
+      called = called + 1;
+      t.deepEqual(param1, arg1, '1st argument was curried');
+      t.deepEqual(param2, arg2, '2nd argument was curried');
+      t.ok(async, 'setInterval invokes internal async');
+
+      if (called > 2) t.fail('internal had to be cleared')
+
+      if (called === 2) {
+        timers.clearInterval(id);
+        t.end();
+      }
+    }, 5, arg1, arg2);
+
+    async = true;
+});

data/node_modules/browserify/testling/util.js

@@ -0,0 +1,24 @@
+var test = require('testling');
+var util = require('./builtins/util');
+var EventEmitter = require('events').EventEmitter;
+
+test('util.inspect', function (t) {
+    t.plan(1);
+    t.equal(util.inspect([1,2,3]), '[ 1, 2, 3 ]');
+    t.end();
+});
+
+test('util.inherits', function (t) {
+    t.plan(2);
+    
+    function Beep () {}
+    util.inherits(Beep, EventEmitter);
+    var beep = new Beep;
+    
+    t.ok(beep instanceof Beep, 'is a Beep');
+    t.ok(
+        (beep instanceof EventEmitter) || typeof beep.emit === 'function',
+        'is an EventEmitter'
+    );
+    t.end();
+});

data/node_modules/browserify/v2.markdown

@@ -0,0 +1,41 @@
+# browserify@2.0.0
+
+## rip out middleware
+
+out of scope, doesn't belong
+
+## rip out coffee-script
+
+use plugins for that instead
+
+## use [required](https://github.com/shtylman/node-required)
+
+to make json blobs
+
+## bundle json
+
+`browserify --bundle` to read json from stdin or implicitly by checking to see
+if browserify is not a tty
+
+bundling should be async
+
+## plugins
+
+Plugins should just be programs that read json on stdin and write json on
+stdout.
+
+Plugins and bundles should accept multiple json objects to make `--watch` mode
+work so json objects could be written continuously.
+   
+Newline separated json seems like a simple way to do this.
+
+Make this work:
+   
+```
+browserify main.js --json | plugin1 | plugin2 | browserify > bundle.js
+```
+
+## `> bundle.js` in `--watch` mode
+
+Research if `... | browserify > bundle.js` can be made to be compatible with
+`--watch` mode using unix fd hacks, otherwise just use `-o`.

data/node_modules/browserify/wrappers/alias.js

@@ -0,0 +1 @@
+require.alias($from, $to);

data/node_modules/browserify/wrappers/body.js

@@ -0,0 +1,2 @@
+require.define($__filename,function(require,module,exports,__dirname,__filename,process,global){$body
+});

data/node_modules/browserify/wrappers/body_debug.js

@@ -0,0 +1,2 @@
+require.define($__filename,Function(['require','module','exports','__dirname','__filename','process','global'],$body
+));

data/node_modules/browserify/wrappers/entry.js

@@ -0,0 +1,3 @@
+require.define($__filename,function(require,module,exports,__dirname,__filename,process,global){$body
+});
+require($__filename);

data/node_modules/browserify/wrappers/entry_debug.js

@@ -0,0 +1,3 @@
+require.define($__filename,Function(['require','module','exports','__dirname','__filename','process','global'],$body
+));
+require($__filename);

data/node_modules/browserify/wrappers/package.js

@@ -0,0 +1,3 @@
+require.modules[$__filename] = function () {
+    return $body;
+};

data/node_modules/browserify/wrappers/prelude.js

@@ -0,0 +1,196 @@
+var require = function (file, cwd) {
+    var resolved = require.resolve(file, cwd || '/');
+    var mod = require.modules[resolved];
+    if (!mod) throw new Error(
+        'Failed to resolve module ' + file + ', tried ' + resolved
+    );
+    var cached = require.cache[resolved];
+    var res = cached? cached.exports : mod();
+    return res;
+};
+
+require.paths = [];
+require.modules = {};
+require.cache = {};
+require.extensions = $extensions;
+
+require._core = {
+    'assert': true,
+    'events': true,
+    'fs': true,
+    'path': true,
+    'vm': true
+};
+
+require.resolve = (function () {
+    return function (x, cwd) {
+        if (!cwd) cwd = '/';
+        
+        if (require._core[x]) return x;
+        var path = require.modules.path();
+        cwd = path.resolve('/', cwd);
+        var y = cwd || '/';
+        
+        if (x.match(/^(?:\.\.?\/|\/)/)) {
+            var m = loadAsFileSync(path.resolve(y, x))
+                || loadAsDirectorySync(path.resolve(y, x));
+            if (m) return m;
+        }
+        
+        var n = loadNodeModulesSync(x, y);
+        if (n) return n;
+        
+        throw new Error("Cannot find module '" + x + "'");
+        
+        function loadAsFileSync (x) {
+            x = path.normalize(x);
+            if (require.modules[x]) {
+                return x;
+            }
+            
+            for (var i = 0; i < require.extensions.length; i++) {
+                var ext = require.extensions[i];
+                if (require.modules[x + ext]) return x + ext;
+            }
+        }
+        
+        function loadAsDirectorySync (x) {
+            x = x.replace(/\/+$/, '');
+            var pkgfile = path.normalize(x + '/package.json');
+            if (require.modules[pkgfile]) {
+                var pkg = require.modules[pkgfile]();
+                var b = pkg.browserify;
+                if (typeof b === 'object' && b.main) {
+                    var m = loadAsFileSync(path.resolve(x, b.main));
+                    if (m) return m;
+                }
+                else if (typeof b === 'string') {
+                    var m = loadAsFileSync(path.resolve(x, b));
+                    if (m) return m;
+                }
+                else if (pkg.main) {
+                    var m = loadAsFileSync(path.resolve(x, pkg.main));
+                    if (m) return m;
+                }
+            }
+            
+            return loadAsFileSync(x + '/index');
+        }
+        
+        function loadNodeModulesSync (x, start) {
+            var dirs = nodeModulesPathsSync(start);
+            for (var i = 0; i < dirs.length; i++) {
+                var dir = dirs[i];
+                var m = loadAsFileSync(dir + '/' + x);
+                if (m) return m;
+                var n = loadAsDirectorySync(dir + '/' + x);
+                if (n) return n;
+            }
+            
+            var m = loadAsFileSync(x);
+            if (m) return m;
+        }
+        
+        function nodeModulesPathsSync (start) {
+            var parts;
+            if (start === '/') parts = [ '' ];
+            else parts = path.normalize(start).split('/');
+            
+            var dirs = [];
+            for (var i = parts.length - 1; i >= 0; i--) {
+                if (parts[i] === 'node_modules') continue;
+                var dir = parts.slice(0, i + 1).join('/') + '/node_modules';
+                dirs.push(dir);
+            }
+            
+            return dirs;
+        }
+    };
+})();
+
+require.alias = function (from, to) {
+    var path = require.modules.path();
+    var res = null;
+    try {
+        res = require.resolve(from + '/package.json', '/');
+    }
+    catch (err) {
+        res = require.resolve(from, '/');
+    }
+    var basedir = path.dirname(res);
+    
+    var keys = (Object.keys || function (obj) {
+        var res = [];
+        for (var key in obj) res.push(key);
+        return res;
+    })(require.modules);
+    
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (key.slice(0, basedir.length + 1) === basedir + '/') {
+            var f = key.slice(basedir.length);
+            require.modules[to + f] = require.modules[basedir + f];
+        }
+        else if (key === basedir) {
+            require.modules[to] = require.modules[basedir];
+        }
+    }
+};
+
+(function () {
+    var process = {};
+    var global = typeof window !== 'undefined' ? window : {};
+    var definedProcess = false;
+    
+    require.define = function (filename, fn) {
+        if (!definedProcess && require.modules.__browserify_process) {
+            process = require.modules.__browserify_process();
+            definedProcess = true;
+        }
+        
+        var dirname = require._core[filename]
+            ? ''
+            : require.modules.path().dirname(filename)
+        ;
+        
+        var require_ = function (file) {
+            var requiredModule = require(file, dirname);
+            var cached = require.cache[require.resolve(file, dirname)];
+
+            if (cached && cached.parent === null) {
+                cached.parent = module_;
+            }
+
+            return requiredModule;
+        };
+        require_.resolve = function (name) {
+            return require.resolve(name, dirname);
+        };
+        require_.modules = require.modules;
+        require_.define = require.define;
+        require_.cache = require.cache;
+        var module_ = {
+            id : filename,
+            filename: filename,
+            exports : {},
+            loaded : false,
+            parent: null
+        };
+        
+        require.modules[filename] = function () {
+            require.cache[filename] = module_;
+            fn.call(
+                module_.exports,
+                require_,
+                module_,
+                module_.exports,
+                dirname,
+                filename,
+                process,
+                global
+            );
+            module_.loaded = true;
+            return module_.exports;
+        };
+    };
+})();