RubyGems - snowball - Versions diffs - 0.1.21 → 0.1.22 - Mend

snowball 0.1.21 → 0.1.22

Files changed (589) hide show

data/node_modules/browserify/example/using-http/entry.js ADDED

@@ -0,0 +1,25 @@
+var http = require('http');
+$(function () {
+    var opts = {
+        host : window.location.hostname,
+        port : window.location.port,
+        path : '/count'
+    };
+    http.get(opts, function (res) {
+        res.on('data', function (buf) {
+            $('<div>')
+                .text(buf)
+                .appendTo($('#count'))
+            ;
+        });
+        res.on('end', function () {
+            $('<div>')
+                .text('__END__')
+                .appendTo($('#count'))
+            ;
+        });
+    });
+});

data/node_modules/browserify/example/using-http/index.html ADDED

@@ -0,0 +1,9 @@
+<html>
+  <head>
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
+    <script src="/bundle.js"></script>
+  </head>
+  <body>
+    <div id="count"></div>
+  </body>
+</html>

data/node_modules/browserify/example/using-http/server.js ADDED

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+var http = require('http');
+var ecstatic = require('ecstatic')(__dirname);
+var server = http.createServer(function (req, res) {
+    if (req.url === '/count') {
+        res.setHeader('content-type', 'multipart/octet-stream');
+        var n = 10;
+        var iv = setInterval(function () {
+            res.write(n + '\r\n');
+            if (--n === 0) {
+                clearInterval(iv);
+                res.end();
+            }
+        }, 250);
+    }
+    else ecstatic(req, res)
+});
+server.listen(8001);
+console.log([
+    'Listening on :8001',
+    '',
+    'To compile the build, do:',
+    '    browserify entry.js -o bundle.js'
+].join('\n'));

data/node_modules/browserify/index.js ADDED

@@ -0,0 +1,202 @@
+var path = require('path');
+var coffee = require('coffee-script');
+var EventEmitter = require('events').EventEmitter;
+var wrap = require('./lib/wrap');
+var watch = require('./lib/watch');
+function idFromPath (path) {
+    return path.replace(/\\/g, '/');
+}
+function isAbsolute (pathOrId) {
+    return path.normalize(pathOrId) === path.normalize(path.resolve(pathOrId));
+}
+function needsNodeModulesPrepended (id) {
+    return !/^[.\/]/.test(id) && !isAbsolute(id);
+}
+var exports = module.exports = function (entryFile, opts) {
+    if (!opts) opts = {};
+    if (Array.isArray(entryFile)) {
+        if (Array.isArray(opts.entry)) {
+            opts.entry.unshift.apply(opts.entry, entryFile);
+        }
+        else if (opts.entry) {
+            opts.entry = entryFile.concat(opts.entry);
+        }
+        else {
+            opts.entry = entryFile;
+        }
+    }
+    else if (typeof entryFile === 'object') {
+        opts = entryFile;
+    }
+    else if (typeof entryFile === 'string') {
+        if (Array.isArray(opts.entry)) {
+            opts.entry.unshift(entryFile);
+        }
+        else if (opts.entry) {
+            opts.entry = [ opts.entry, entryFile ];
+        }
+        else {
+            opts.entry = entryFile;
+        }
+    }
+    var opts_ = {
+        cache : opts.cache,
+        debug : opts.debug,
+        exports : opts.exports,
+    };
+    var w = wrap(opts_);
+    w.register('.coffee', function (body, file) {
+        try {
+            var res = coffee.compile(body, { filename : file });
+        }
+        catch (err) {
+            w.emit('syntaxError', err);
+        }
+        return res;
+    });
+    w.register('.json', function (body, file) {
+        return 'module.exports = ' + body + ';\n';
+    });
+    var listening = false;
+    w._cache = null;
+    var self = function (req, res, next) {
+        if (!listening && req.connection && req.connection.server) {
+            req.connection.server.on('close', function () {
+                self.end();
+            });
+        }
+        listening = true;
+        if (req.url.split('?')[0] === (opts.mount || '/browserify.js')) {
+            if (!w._cache) self.bundle();
+            res.statusCode = 200;
+            res.setHeader('last-modified', self.modified.toString());
+            res.setHeader('content-type', 'text/javascript');
+            res.end(w._cache);
+        }
+        else next()
+    };
+    if (opts.watch) watch(w, opts.watch);
+    if (opts.filter) {
+        w.register('post', function (body) {
+            return opts.filter(body);
+        });
+    }
+    w.ignore(opts.ignore || []);
+    if (opts.require) {
+        if (Array.isArray(opts.require)) {
+            opts.require.forEach(function (r) {
+                r = idFromPath(r);
+                var params = {};
+                if (needsNodeModulesPrepended(r)) {
+                    params.target = '/node_modules/' + r + '/index.js';
+                }
+                w.require(r, params);
+            });
+        }
+        else if (typeof opts.require === 'object') {
+            Object.keys(opts.require).forEach(function (key) {
+                opts.require[key] = idFromPath(opts.require[key]);
+                var params = {};
+                if (needsNodeModulesPrepended(opts.require[key])) {
+                    params.target = '/node_modules/'
+                        + opts.require[key] + '/index.js'
+                    ;
+                }
+                w.require(opts.require[key], params);
+                w.alias(key, opts.require[key]);
+            });
+        }
+        else {
+            opts.require = idFromPath(opts.require);
+            var params = {};
+            if (needsNodeModulesPrepended(opts.require)) {
+                params.target = '/node_modules/'
+                    + opts.require + '/index.js'
+                ;
+            }
+            w.require(opts.require, params);
+        }
+    }
+    if (opts.entry) {
+        if (Array.isArray(opts.entry)) {
+            opts.entry.forEach(function (e) {
+                w.addEntry(e);
+            });
+        }
+        else {
+            w.addEntry(opts.entry);
+        }
+    }
+    Object.keys(w).forEach(function (key) {
+        Object.defineProperty(self, key, {
+            set : function (value) { w[key] = value },
+            get : function () { return w[key] }
+        });
+    });
+    Object.keys(Object.getPrototypeOf(w)).forEach(function (key) {
+        self[key] = function () {
+            var s = w[key].apply(self, arguments)
+            if (s === self) { w._cache = null }
+            return s;
+        };
+    });
+    Object.keys(EventEmitter.prototype).forEach(function (key) {
+        if (typeof w[key] === 'function' && w[key].bind) {
+            self[key] = w[key].bind(w);
+        }
+        else {
+            self[key] = w[key];
+        }
+    });
+    var firstBundle = true;
+    self.modified = new Date;
+    self.bundle = function () {
+        if (w._cache) return w._cache;
+        var src = w.bundle.apply(w, arguments);
+        self.ok = Object.keys(w.errors).length === 0;
+        if (!firstBundle) {
+            self.modified = new Date;
+        }
+        firstBundle = false;
+        w._cache = src;
+        return src;
+    };
+    self.end = function () {
+        Object.keys(w.watches || {}).forEach(function (file) {
+            w.watches[file].close();
+        });
+    };
+    return self;
+};
+exports.bundle = function (opts) {
+    return exports(opts).bundle();
+};

data/node_modules/browserify/lib/watch.js ADDED

@@ -0,0 +1,75 @@
+var fs = require('fs');
+var path = require('path');
+var exists = fs.exists || path.exists;
+module.exports = function (w, opts) {
+    if (!w.watches) w.watches = [];
+    w.register(reg.bind(null, w, opts));
+};
+function reg (w, opts, body, file) {
+    // if already being watched
+    if (w.watches[file]) return body;
+    var type = w.files[file] ? 'files' : 'entries';
+    var watch = function () {
+        if (w.files[file] && w.files[file].synthetic) return;
+        if (typeof opts === 'object') {
+            w.watches[file] = fs.watch(file, opts, watcher);
+        }
+        else {
+            w.watches[file] = fs.watch(file, watcher);
+        }
+    };
+    var pending = null;
+    var bundle = function () {
+        if (pending) return;
+        pending = setTimeout(function () {
+            pending = null;
+            // modified
+            if (w[type][file]) {
+                w.reload(file);
+            }
+            else if (type === 'entries') {
+                w.addEntry(file);
+            }
+            else if (type === 'files') {
+                w.require(file);
+            }
+            w._cache = null;
+            w.emit('bundle');
+        }, 100);
+    };
+    var watcher = function (event, filename) {
+        exists(file, function (ex) {
+            if (!ex) {
+                // deleted
+                if (w.files[file]) {
+                    delete w.files[file];
+                }
+                else if (w.entries[file] !== undefined) {
+                    w.appends.splice(w.entries[file], 1);
+                }
+                w._cache = null;
+            }
+            else if (event === 'change') {
+                bundle();
+            }
+            else if (event === 'rename') {
+                w.watches[file].close();
+                process.nextTick(watch);
+                bundle();
+            }
+        });
+    };
+    w.watches[file] = true;
+    process.nextTick(watch);
+    return body;
+}

data/node_modules/browserify/lib/wrap.js ADDED

@@ -0,0 +1,580 @@
+var fs = require('fs');
+var path = require('path');
+var util = require('util');
+var EventEmitter = require('events').EventEmitter;
+var detective = require('detective');
+var deputy = require('deputy');
+var resolve = require('resolve');
+var wrappers = require('./wrappers');
+var commondir = require('commondir');
+var nub = require('nub');
+var checkSyntax = require('syntax-error');
+var existsSync = fs.existsSync || path.existsSync;
+var sep = path.sep || (process.platform === 'win32' ? '\\' : '/');
+module.exports = function (opts) {
+    return new Wrap(opts);
+};
+function idFromPath (path) {
+    return path.replace(/\\/g, '/');
+}
+function Wrap (opts) {
+    var home = process.env.HOME || process.env.USERPROFILE;
+    if (opts.cache === undefined && home !== undefined) {
+        opts.cache = true;
+    }
+    if (opts.cache) {
+        if (typeof opts.cache === 'boolean') {
+            var file = home + '/.config/browserify/cache.json';
+            this.detective = deputy(file);
+        }
+        else {
+            this.detective = deputy(opts.cache);
+        }
+    }
+    else {
+        this.detective = detective;
+    }
+    this.exports = opts.exports;
+    this.files = {};
+    this.filters = [];
+    this.pathFilters = [];
+    this.postFilters = [];
+    this.preFilters = [];
+    this.aliases = {};
+    this._checkedPackages = {};
+    this.errors = {};
+    this.ignoring = {};
+    this.extensions = [ '.js' ];
+    this.prepends = [ wrappers.prelude, wrappers.process ];
+    this.appends = []
+    this.entries = {};
+    this.debug = opts.debug;
+    this.require('path');
+    this.require('__browserify_process');
+}
+function resolveMod(from, to){
+    // not a real directory on the filesystem; just using the path
+    // module to get rid of the filename.
+    var targetDir = path.dirname(from);
+    // not a real filename; just using the path module to deal with
+    // relative paths.
+    var reqFilename = path.resolve(targetDir, to);
+    // get rid of drive letter on Windows; replace it with '/'
+    var reqFilenameWithoutDriveLetter = /^[a-zA-Z]:\\/.test(reqFilename) ?
+        '/' + reqFilename.substring(3) : reqFilename;
+    return reqFilenameWithoutDriveLetter;
+}
+util.inherits(Wrap, EventEmitter);
+Wrap.prototype.prepend = function (src) {
+    this.prepends.unshift(src);
+    return this;
+};
+Wrap.prototype.append = function (src) {
+    this.appends.push(src);
+    return this;
+};
+Wrap.prototype.ignore = function (files) {
+    if (!files) files = [];
+    if (!Array.isArray(files)) files = [ files ];
+    this.ignoring = files.reduce(function (acc,x) {
+        acc[x] = true;
+        return acc;
+    }, this.ignoring);
+    return this;
+};
+Wrap.prototype.use = function (fn) {
+    fn(this, this);
+    return this;
+};
+Wrap.prototype.register = function (ext, fn) {
+    if (typeof ext === 'object') {
+        fn = ext.wrapper;
+        ext = ext.extension;
+    }
+    if (ext === 'post') {
+        this.postFilters.push(fn);
+    }
+    else if (ext === 'pre') {
+        this.preFilters.push(fn);
+    }
+    else if (ext === 'path') {
+        this.pathFilters.push(fn);
+    }
+    else if (fn) {
+        this.extensions.push(ext);
+        this.filters.push(function (body, file) {
+            if (file.slice(-ext.length) === ext) {
+                return fn.call(this, body, file);
+            }
+            else return body;
+        });
+    }
+    else {
+        this.filters.push(ext);
+    }
+    return this;
+};
+Wrap.prototype.reload = function (file) {
+    var self = this;
+    delete self.errors[file];
+    if (self.files[file]) {
+        var f = self.files[file];
+        f.body = undefined;
+        delete self.files[file];
+        self.require(file, f);
+    }
+    else if (self.entries[file]) {
+        var e = self.entries[file];
+        e.body = undefined;
+        delete self.entries[file];
+        self.addEntry(file, e);
+    }
+    return self;
+};
+Wrap.prototype.readFile = function (file) {
+    var self = this;
+    self.pathFilters.forEach(function (fn) {
+        file = fn.call(self, file);
+    });
+    var body = fs.readFileSync(file, 'utf8').replace(/^#![^\n]*\n/, '');
+    self.filters.forEach(function (fn) {
+        body = fn.call(self, body, file);
+    });
+    var err = checkSyntax(body, file);
+    if (err) {
+        self.errors[file] = err;
+        process.nextTick(function () {
+            self.emit('syntaxError', err);
+        });
+        return undefined;
+    }
+    else {
+        delete self.errors[file];
+    }
+    return body;
+};
+Wrap.prototype.alias = function (to, from) {
+    this.aliases[to] = from;
+    return this;
+};
+Wrap.prototype.addEntry = function (file_, opts) {
+    var self = this;
+    if (!opts) opts = {};
+    var file = path.resolve(opts.dirname || process.cwd(), file_);
+    var entry = this.entries[file] = {};
+    // entry must be set before readFile for the watch
+    var body = entry.body = opts.body || self.readFile(file);
+    if (body === undefined) return self;
+    if (opts.target) entry.target = opts.target;
+    try {
+        var required = self.detective.find(body);
+    }
+    catch (err) {
+        process.nextTick(function () {
+            err.message = 'Error while loading entry file '
+                + JSON.stringify(file)
+                + ': ' + err.message
+            ;
+            self.emit('syntaxError', err);
+        });
+        return self;
+    }
+    if (required.expressions.length) {
+        console.error('Expressions in require() statements:');
+        required.expressions.forEach(function (ex) {
+            console.error('    require(' + ex + ')');
+        });
+    }
+    var dirname = path.dirname(file);
+    required.strings.forEach(function (req) {
+        var params = {
+            dirname : dirname,
+            fromFile : file,
+        };
+        if (opts.target && /^[.\/]/.test(req)) {
+            params.target = resolveMod(opts.target, req);
+        }
+        self.require(req, params);
+    });
+    return this;
+};
+Wrap.prototype.bundle = function () {
+    var self = this;
+    for (var i = 0; i < self.prepends.length; i++) {
+        var p = self.prepends[i];
+        if (p === wrappers.prelude) {
+            self.prepends[i] = p.replace(/\$extensions/, function () {
+                return JSON.stringify(self.extensions);
+            });
+            break;
+        }
+    }
+    this.preFilters.forEach((function (fn) {
+        fn.call(this, this);
+    }).bind(this));
+    (function () {
+        // hack to set -browserify module targets
+        var nm = path.resolve(__dirname, '../node_modules');
+        Object.keys(self.files).forEach(function (file) {
+            if (file.substring(0, nm.length) !== nm) return;
+            var relativeToNm = path.relative(nm, file);
+            var topDir = relativeToNm.split(sep)[0];
+            if (!/-browserify$/.test(topDir)) return;
+            self.files[file].target = path.join('/', 'node_modules', relativeToNm);
+        });
+    })();
+    var basedir = (function () {
+        var required = Object.keys(self.files)
+            .filter(function (x) {
+                return !self.files[x].target;
+            })
+        ;
+        var entries = Object.keys(self.entries)
+            .filter(function (x) { return !self.entries[x].target })
+        ;
+        var files = required.concat(entries)
+            .map(function (x) { return path.dirname(x) })
+        ;
+        if (files.length === 0) return '';
+        var dir = commondir(files) + '/';
+        return path.normalize(dir.replace(/\/node_modules\/$/, '/'));
+    })();
+    var removeLeading = function (s) {
+        if (s.slice(0, basedir.length) === basedir) {
+            return s.slice(basedir.length - 1);
+        }
+    };
+    var src = []
+        .concat(this.prepends)
+        .concat(Object.keys(self.files).map(function (file) {
+            var s = self.files[file];
+            var target = s.target || removeLeading(file);
+            if (self.ignoring[target]) return '';
+            return self.wrap(idFromPath(target), s.body)
+        }))
+        .concat(Object.keys(self.aliases).map(function (to) {
+            var from = self.aliases[to];
+            if (!to.match(/^(\.\.?)?\//)) {
+                to = '/node_modules/' + to;
+            }
+            return wrappers.alias
+                .replace(/\$from/, function () {
+                    return JSON.stringify(from);
+                })
+                .replace(/\$to/, function () {
+                    return JSON.stringify(to);
+                })
+            ;
+        }))
+        .concat(Object.keys(self.entries).map(function (file) {
+            var s = self.entries[file];
+            var target = s.target || removeLeading(file);
+            return self.wrapEntry(idFromPath(target), s.body);
+        }))
+        .concat(this.appends)
+        .join('\n')
+    ;
+    if (!self.exports) {
+        self.exports = Object.keys(self.entries).length ? [] : [ 'require' ];
+    }
+    if (self.exports === true) self.exports = [ 'require', 'process' ];
+    if (!Array.isArray(self.exports)) self.exports = [ self.exports ];
+    if (self.exports.indexOf('process') >= 0
+    && self.exports.indexOf('require') >= 0) {
+        src += 'var process = require("__browserify_process");\n'
+    }
+    else if (self.exports.indexOf('require') >= 0) {
+        // nop
+    }
+    else if (self.exports.indexOf('process') >= 0) {
+        src = 'var process = (function(){'
+            + src
+            + ';return require("__browserify_process")'
+            + '})();\n'
+        ;
+    }
+    else {
+        src = '(function(){' + src + '})();\n'
+    }
+    this.postFilters.forEach((function (fn) {
+        src = fn.call(this, src);
+    }).bind(this));
+    return src;
+};
+Wrap.prototype.wrap = function (target, body) {
+    var self = this;
+    return (self.debug ? wrappers.body_debug : wrappers.body)
+        .replace(/\$__filename/g, function () {
+            return JSON.stringify(target);
+        })
+        .replace(/\$body/, function () {
+            return self.debug
+                ? JSON.stringify(body + '\n//@ sourceURL=' + target)
+                : body
+            ;
+        })
+    ;
+};
+Wrap.prototype.wrapEntry = function (target, body) {
+    var self = this;
+    return (self.debug ? wrappers.entry_debug : wrappers.entry)
+        .replace(/\$__filename/g, function () {
+            return JSON.stringify(target)
+        })
+        .replace(/\$body/, function () {
+            return self.debug
+                ? JSON.stringify(body + '\n//@ sourceURL=' + target)
+                : body
+            ;
+        })
+    ;
+};
+Wrap.prototype.include = function (file, target, body, root) {
+    var synthetic = !file;
+    if (!file) file = Math.floor(Math.random() * Math.pow(2,32)).toString(16);
+    this.files[file] = {
+        body : body,
+        target : target,
+        synthetic : synthetic,
+        root : root
+    };
+    return this;
+};
+Wrap.prototype.require = function (mfile, opts) {
+    var self = this;
+    if (!opts) opts = {};
+    if (!opts.dirname) opts.dirname = process.cwd();
+    if (typeof mfile === 'object') {
+        throw new Error('require maps no longer supported');
+    }
+    if (self.has(mfile)) return self;
+    if (opts.target && self.has(opts.target)) return self;
+    if (self.ignoring[mfile]) return self;
+    if (self.aliases[mfile]) return self;
+    function moduleError (msg) {
+        return new Error(msg + ': ' + JSON.stringify(mfile)
+            + ' from directory ' + JSON.stringify(opts.dirname)
+            + (opts.fromFile ? ' while processing file ' + opts.fromFile : '')
+        );
+    }
+    var pkg = {};
+    if (mfile === '__browserify_process' || resolve.isCore(mfile)) {
+        opts.file = path.resolve(__dirname, '../builtins/' + mfile + '.js');
+        opts.target = opts.target || mfile;
+        if (!existsSync(opts.file)) {
+            try {
+                require.resolve(mfile + '-browserify');
+                opts.body = 'module.exports = require('
+                    + JSON.stringify(mfile + '-browserify')
+                + ')';
+            }
+            catch (err) {
+                throw moduleError('No wrapper for core module');
+            }
+        }
+    }
+    else if (self.has(mfile)) {
+        // package has already been included in some fashion, no need to resolve
+        return self;
+    }
+    else if (opts.body) {
+        opts.file = mfile;
+    }
+    else if (!opts.file) {
+        try {
+            var normPath
+                = path.normalize(path.resolve(mfile)) === path.normalize(mfile)
+                ? path.normalize(mfile) : mfile
+            ;
+            opts.file = self.resolver(normPath, opts.dirname);
+        }
+        catch (err) {
+            throw moduleError('Cannot find module');
+        }
+    }
+    if (self.has(opts.file)) return self;
+    var dirname = path.dirname(opts.file);
+    var pkgfile = path.join(dirname, 'package.json');
+    if (!mfile.match(/^(\.\.?)?\//)) {
+        try {
+            pkgfile = resolve.sync(path.join(mfile, 'package.json'), {
+                basedir : dirname
+            });
+        }
+        catch (err) {}
+    }
+    if (pkgfile && !self._checkedPackages[pkgfile]) {
+        self._checkedPackages[pkgfile] = true;
+        if (existsSync(pkgfile)) {
+            var pkgBody = fs.readFileSync(pkgfile, 'utf8');
+            try {
+                var npmpkg = JSON.parse(pkgBody);
+                if (npmpkg.main !== undefined) {
+                    pkg.main = npmpkg.main;
+                }
+                if (npmpkg.browserify !== undefined) {
+                    pkg.browserify = npmpkg.browserify;
+                }
+            }
+            catch (err) {
+                // ignore broken package.jsons just like node
+            }
+            self.files[pkgfile] = {
+                body : 'module.exports = ' + JSON.stringify(pkg),
+            };
+        }
+    }
+    var entry = self.files[opts.file] = {
+        target : opts.target
+    };
+    // entry must be set before readFile for the watch
+    var body = entry.body = opts.body || self.readFile(opts.file);
+    if (body === undefined) {
+        delete self.files[opts.file];
+        return self;
+    }
+    try {
+        var required = self.detective.find(body);
+    }
+    catch (err) {
+        process.nextTick(function () {
+            self.emit('syntaxError', err);
+        });
+        return self;
+    }
+    if (pkg.browserify && pkg.browserify.require) {
+        required.strings = required.strings.concat(
+            pkg.browserify.require
+        );
+    }
+    if (required.expressions.length) {
+        console.error('Expressions in require() statements:');
+        required.expressions.forEach(function (ex) {
+            console.error('    require(' + ex + ')');
+        });
+    }
+    nub(required.strings).forEach(function (req) {
+        var params = {
+            dirname : dirname,
+            fromFile : opts.file,
+        };
+        if (opts.target && /^[.\/]/.test(req)) {
+            params.target = idFromPath(resolveMod(opts.target, req));
+        }
+        self.require(req, params);
+    });
+    return self;
+};
+function isPrefixOf (x, y) {
+    return y.slice(0, x.length) === x;
+}
+Wrap.prototype.has = function (file) {
+    var self = this;
+    if (self.files[file]) return true;
+    var res = Object.keys(self.files).some(function (key) {
+        return self.files[key].target === file;
+    });
+    return res;
+};
+Wrap.prototype.resolver = function (file, basedir) {
+    return resolve.sync(file, {
+        basedir : basedir,
+        extensions : this.extensions,
+        packageFilter : function (pkg) {
+            var b = pkg.browserify;
+            if (b) {
+                if (typeof b === 'string') {
+                    pkg.main = b;
+                }
+                else if (typeof b === 'object' && b.main) {
+                    pkg.main = b.main;
+                }
+            }
+            return pkg
+        }
+    });
+}