ruby-wisp-source 0.7.0

data/vendor/node_modules/browserify/bin/cmd.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+var browserify = require('../');
+var fs = require('fs');
+var path = require('path');
+var JSONStream = require('JSONStream');
+var spawn = require('child_process').spawn;
+var parseShell = require('shell-quote').parse;
+var duplexer = require('duplexer');
+var through = require('through');
+
+var argv = require('optimist')
+    .boolean(['deps','pack','ig','dg', 'im', 'd','list'])
+    .string(['s'])
+    .alias('insert-globals', 'ig')
+    .alias('detect-globals', 'dg')
+    .alias('ignore-missing', 'im')
+    .alias('debug', 'd')
+    .alias('standalone', 's')
+    .alias('ig', 'fast')
+    .alias('noparse', 'noParse')
+    .default('ig', false)
+    .default('im', false)
+    .default('dg', true) 
+    .default('d', false) 
+    .argv
+;
+
+if ((argv._[0] === 'help' && argv._[1]) === 'advanced'
+|| (argv.h || argv.help) === 'advanced') {
+    return fs.createReadStream(__dirname + '/advanced.txt')
+        .pipe(process.stdout)
+        .on('close', function () { process.exit(1) })
+    ;
+}
+if (argv._[0] === 'help' || argv.h || argv.help || process.argv.length <= 2) {
+    return fs.createReadStream(__dirname + '/usage.txt')
+        .pipe(process.stdout)
+        .on('close', function () { process.exit(1) })
+    ;
+}
+if (argv.v || argv.version) {
+    return console.log(require('../package.json').version);
+}
+
+var entries = argv._.concat(argv.e).concat(argv.entry)
+.filter(Boolean).map(function(entry) {
+    return path.resolve(process.cwd(), entry);
+});
+
+var b = browserify({
+    noParse: [].concat(argv.noparse).filter(Boolean),
+    entries: entries
+});
+
+b.on('error', function (err) {
+    console.error(String(err));
+    process.exit(1);
+});
+
+[].concat(argv.i).concat(argv.ignore).filter(Boolean)
+    .forEach(function (i) { b.ignore(i) })
+;
+
+[].concat(argv.r).concat(argv.require).filter(Boolean)
+    .forEach(function (r) {
+        var xs = r.split(':');
+        b.require(xs[0], { expose: xs.length === 1 ? xs[0] : xs[1] })
+    })
+;
+
+// resolve any external files and add them to the bundle as externals
+[].concat(argv.x).concat(argv.external).filter(Boolean)
+    .forEach(function (x) { b.external(path.resolve(process.cwd(), x)) })
+;
+
+[].concat(argv.t).concat(argv.transform).filter(Boolean)
+    .forEach(function (t) { b.transform(t) })
+;
+
+[].concat(argv.c).concat(argv.command).filter(Boolean)
+    .forEach(function (c) {
+        var cmd = parseShell(c);
+        b.transform(function (file) {
+            var env = Object.keys(process.env).reduce(function (acc, key) {
+                acc[key] = process.env[key];
+                return acc;
+            }, {});
+            env.FILENAME = file;
+            var ps = spawn(cmd[0], cmd.slice(1), { env: env });
+            var error = '';
+            ps.stderr.on('data', function (buf) { error += buf });
+            
+            ps.on('exit', function (code) {
+                if (code === 0) return;
+                console.error([
+                    'error running source transform command: ' + c,
+                    error.split('\n').join('\n  '),
+                    ''
+                ].join('\n'));
+                process.exit(1);
+            });
+            return duplexer(ps.stdin, ps.stdout);
+        });
+    })
+;
+
+if (argv.pack) {
+    process.stdin.pipe(b.pack()).pipe(process.stdout);
+    process.stdin.resume();
+    return;
+}
+
+if (argv.deps) {
+    var stringify = JSONStream.stringify();
+    b.deps().pipe(stringify).pipe(process.stdout);
+    return;
+}
+
+if (argv.list) {
+    b.deps().pipe(through(function (dep) {
+        this.queue(dep.id + '\n');
+    })).pipe(process.stdout);
+    return;
+}
+
+if (argv.standalone === true) {
+    console.error('--standalone requires an export name argument');
+    process.exit(1);
+}
+
+var bundle = b.bundle({
+    detectGlobals: argv['detect-globals'] !== false && argv.dg !== false,
+    insertGlobals: argv['insert-globals'] || argv.ig,
+    ignoreMissing: argv['ignore-missing'] || argv.im,
+    debug: argv['debug'] || argv.d,
+    standalone: argv['standalone'] || argv.s
+});
+
+bundle.on('error', function (err) {
+    console.error(String(err));
+    process.exit(1);
+});
+
+var outfile = argv.o || argv.outfile;
+if (outfile) {
+    bundle.pipe(fs.createWriteStream(outfile));
+}
+else {
+    bundle.pipe(process.stdout);
+}

data/vendor/node_modules/browserify/bin/usage.txt

@@ -0,0 +1,32 @@
+Usage: browserify [entry files] {OPTIONS}
+
+Standard Options:
+
+    --outfile, -o  Write the browserify bundle to this file.
+                   If unspecified, browserify prints to stdout.
+
+    --require, -r  A module name or file to bundle.require()
+                   Optionally use a colon separator to set the target.
+
+      --entry, -e  An entry point of your app
+  
+     --ignore, -i  Omit a file from the output bundle.
+
+   --external, -x  Reference a file from another bundle.
+  
+  --transform, -t  Use a transform module on top-level files.
+ 
+    --command, -c  Use a transform command on top-level files.
+   
+  --standalone -s  Generate a UMD bundle for the supplied export name.
+                   This bundle works with other module systems and sets the name
+                   given as a window global if no module system is found.
+  
+       --debug -d  Enable source maps that allow you to debug your files
+                   separately.
+
+       --help, -h  Show this message
+
+For advanced options, type `browserify help advanced`.
+
+Specify a parameter.

data/vendor/node_modules/browserify/example/api/browser/bar.js

@@ -0,0 +1 @@
+module.exports = function (n) { return n * 3 };

data/vendor/node_modules/browserify/example/api/browser/foo.js

@@ -0,0 +1,5 @@
+var bar = require('./bar');
+
+module.exports = function (n) {
+    return n * bar(n);
+};

data/vendor/node_modules/browserify/example/api/browser/main.js

@@ -0,0 +1,2 @@
+var foo = require('./foo');
+console.log(foo(5));

data/vendor/node_modules/browserify/example/api/build.js

@@ -0,0 +1,4 @@
+var browserify = require('browserify');
+var b = browserify();
+b.add('./browser/main.js');
+b.bundle().pipe(process.stdout);

data/vendor/node_modules/browserify/example/multiple_bundles/beep.js

@@ -0,0 +1,2 @@
+var robot = require('./robot');
+console.log(robot('beep'));

data/vendor/node_modules/browserify/example/multiple_bundles/boop.js

@@ -0,0 +1,2 @@
+var robot = require('./robot');
+console.log(robot('boop'));

data/vendor/node_modules/browserify/example/multiple_bundles/build.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+browserify -r ./robot.js > static/common.js
+browserify -i ./robot.js beep.js > static/beep.js
+browserify -i ./robot.js boop.js > static/boop.js

data/vendor/node_modules/browserify/example/multiple_bundles/robot.js

@@ -0,0 +1 @@
+module.exports = function (s) { return s.toUpperCase() + '!' };

data/vendor/node_modules/browserify/example/multiple_bundles/static/beep.html

@@ -0,0 +1,2 @@
+<script src="common.js"></script>
+<script src="beep.js"></script>

data/vendor/node_modules/browserify/example/multiple_bundles/static/beep.js

@@ -0,0 +1,6 @@
+;(function(p,c,e){function r(n){if(!c[n]){if(!p[n])return;c[n]={exports:{}};p[n][0](function(x){return r(p[n][1][x])},c[n],c[n].exports);}return c[n].exports}for(var i=0;i<e.length;i++)r(e[i]);return r})({0:[function(require,module,exports){var robot = require('./robot');
+console.log(robot('beep'));
+
+},{"./robot":1}],1:[function(require,module,exports){module.exports = function (s) { return s.toUpperCase() + '!' };
+
+},{}]},{},[0]);

data/vendor/node_modules/browserify/example/multiple_bundles/static/boop.html

@@ -0,0 +1,2 @@
+<script src="common.js"></script>
+<script src="boop.js"></script>

data/vendor/node_modules/browserify/example/multiple_bundles/static/boop.js

@@ -0,0 +1,6 @@
+;(function(p,c,e){function r(n){if(!c[n]){if(!p[n])return;c[n]={exports:{}};p[n][0](function(x){return r(p[n][1][x])},c[n],c[n].exports);}return c[n].exports}for(var i=0;i<e.length;i++)r(e[i]);return r})({0:[function(require,module,exports){var robot = require('./robot');
+console.log(robot('boop'));
+
+},{"./robot":1}],1:[function(require,module,exports){module.exports = function (s) { return s.toUpperCase() + '!' };
+
+},{}]},{},[0]);

data/vendor/node_modules/browserify/example/multiple_bundles/static/common.js

@@ -0,0 +1,3 @@
+require=(function(o,r){return function(n){var x=r(n);if(x!==undefined)return x;if(o)return o(n);throw new Error("Cannot find module '"+n+"'")}})(typeof require!=="undefined"&&require,(function(p,c,e){function r(n){if(!c[n]){if(!p[n])return;c[n]={exports:{}};p[n][0](function(x){return r(p[n][1][x])},c[n],c[n].exports);}return c[n].exports}for(var i=0;i<e.length;i++)r(e[i]);return r})({"./robot.js":[function(require,module,exports){module.exports = function (s) { return s.toUpperCase() + '!' };
+
+},{}]},{},[]));

data/vendor/node_modules/browserify/example/source_maps/build.js

@@ -0,0 +1,10 @@
+var browserify = require('../..'),
+    path = require('path'),
+    fs = require('fs'),
+    bundlePath = path.join(__dirname, 'js', 'build', 'bundle.js');
+
+browserify()
+    .require(require.resolve('./js/main.js'), { entry: true })
+    .bundle({ debug: true })
+    .on('error', function (err) { console.error(err); })
+    .pipe(fs.createWriteStream(bundlePath));

data/vendor/node_modules/browserify/example/source_maps/build.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+../../bin/cmd.js --debug -e ./js/main.js > js/build/bundle.js
+
+echo bundle was generated with source maps, you can now open index.html

data/vendor/node_modules/browserify/example/source_maps/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset=utf-8 />
+  <title></title>
+  <script type="text/javascript" src="./js/build/bundle.js"></script>
+</head>
+<body>
+  <p>Open your dev tools ;)</p>  
+</body>
+</html>

data/vendor/node_modules/browserify/example/source_maps/js/foo.js

@@ -0,0 +1,7 @@
+console.log('foo line 1');
+var bar = require('./wunder/bar');
+
+module.exports = function foo() {
+  console.log('hello from foo line 5');
+  bar();
+};

data/vendor/node_modules/browserify/example/source_maps/js/main.js

@@ -0,0 +1,4 @@
+console.log('main line 1');
+var foo = require('./foo.js');
+
+foo();

data/vendor/node_modules/browserify/example/source_maps/js/wunder/bar.js

@@ -0,0 +1,8 @@
+console.log('bar line 1');
+'use strict';
+
+// this is a meaningless comment to add some lines
+
+module.exports = function bar() {
+  console.log('hello from bar line 7');
+};

data/vendor/node_modules/browserify/index.js

@@ -0,0 +1,352 @@
+var crypto = require('crypto');
+var through = require('through');
+var duplexer = require('duplexer');
+var concatStream = require('concat-stream');
+var checkSyntax = require('syntax-error');
+
+var mdeps = require('module-deps');
+var browserPack = require('browser-pack');
+var browserResolve = require('browser-resolve');
+var insertGlobals = require('insert-module-globals');
+var umd = require('umd');
+
+var path = require('path');
+var inherits = require('inherits');
+var EventEmitter = require('events').EventEmitter;
+
+module.exports = function (opts) {
+    if (opts === undefined) opts = {};
+    if (typeof opts === 'string') opts = { entries: [ opts ] };
+    if (Array.isArray(opts)) opts = { entries: opts };
+    
+    var b = new Browserify(opts);
+    [].concat(opts.entries).filter(Boolean).forEach(b.add.bind(b));
+    return b;
+};
+
+function hash(what) {
+    return crypto.createHash('md5').update(what).digest('base64').slice(0, 6);
+}
+
+inherits(Browserify, EventEmitter);
+
+function Browserify (opts) {
+    var self = this;
+    
+    self.files = [];
+    self.exports = {};
+    self._pending = 0;
+    self._entries = [];
+    self._ignore = {};
+    self._external = {};
+    self._expose = {};
+    self._mapped = {};
+    self._transforms = [];
+    
+    self._noParse =[];
+    var noParse = [].concat(opts.noParse).filter(Boolean);
+    var cwd = process.cwd();
+    var top = { id: cwd, filename: cwd + '/_fake.js', paths: [] };
+    noParse.forEach(function (file) {
+        self._noParse.push(file, path.resolve(file));
+        self._pending ++;
+        self._resolve(file, top, function (err, r) {
+            if (r) self._noParse.push(r);
+            if (--self._pending === 0) self.emit('_ready');
+        });
+    });
+}
+
+Browserify.prototype.add = function (file) {
+    this.require(file, { entry: true });
+    return this;
+};
+
+Browserify.prototype.require = function (id, opts) {
+    var self = this;
+    if (opts === undefined) opts = { expose: id };
+    
+    self._pending ++;
+    
+    var basedir = opts.basedir || process.cwd();
+    var fromfile = basedir + '/_fake.js';
+    
+    var params = { filename: fromfile, packageFilter: packageFilter };
+    browserResolve(id, params, function (err, file) {
+        if (err) return self.emit('error', err);
+        if (!file) return self.emit('error', new Error(
+            'module ' + JSON.stringify(id) + ' not found in require()'
+        ));
+        
+        if (opts.expose) {
+            self.exports[file] = hash(file);
+            
+            if (typeof opts.expose === 'string') {
+                self._expose[file] = opts.expose;
+                self._mapped[opts.expose] = file;
+            }
+        }
+
+        if (opts.external) {
+            self._external[file] = true;
+        }
+        else {
+            self.files.push(file);
+        }
+        
+        if (opts.entry) self._entries.push(file);
+        
+        if (--self._pending === 0) self.emit('_ready');
+    });
+
+    return self;
+};
+
+// DEPRECATED
+Browserify.prototype.expose = function (name, file) {
+    this.exports[file] = name;
+    this.files.push(file);
+};
+
+Browserify.prototype.external = function (id, opts) {
+    opts = opts || {};
+    opts.external = true;
+    return this.require(id, opts);
+};
+
+Browserify.prototype.ignore = function (file) {
+    this._ignore[file] = true;
+    return this;
+};
+
+Browserify.prototype.bundle = function (opts, cb) {
+    var self = this;
+    if (typeof opts === 'function') {
+        cb = opts;
+        opts = {};
+    }
+    if (!opts) opts = {};
+    if (opts.insertGlobals === undefined) opts.insertGlobals = false;
+    if (opts.detectGlobals === undefined) opts.detectGlobals = true;
+    if (opts.ignoreMissing === undefined) opts.ignoreMissing = false;
+    if (opts.standalone === undefined) opts.standalone = false;
+    
+    opts.resolve = self._resolve.bind(self);
+    opts.transform = self._transforms;
+    opts.noParse = self._noParse;
+    opts.transformKey = [ 'browserify', 'transform' ];
+    
+    var parentFilter = opts.packageFilter;
+    opts.packageFilter = function (pkg) {
+        if (parentFilter) pkg = parentFilter(pkg);
+        return packageFilter(pkg);
+    };
+    
+    if (self._pending) {
+        var tr = through();
+        self.on('_ready', function () {
+            var b = self.bundle(opts, cb);
+            if (!cb) b.on('error', tr.emit.bind(tr, 'error'));
+            b.pipe(tr);
+        });
+        return tr;
+    }
+    
+    if (opts.standalone && self._entries.length !== 1) {
+        process.nextTick(function () {
+            p.emit('error', 'standalone only works with a single entry point');
+        });
+    }
+    
+    var d = self.deps(opts);
+    var g = opts.detectGlobals || opts.insertGlobals
+        ? insertGlobals(self.files, {
+            resolve: self._resolve.bind(self),
+            always: opts.insertGlobals
+        })
+        : through()
+    ;
+    var p = self.pack(opts.debug, opts.standalone);
+    if (cb) {
+        p.on('error', cb);
+        p.pipe(concatStream(cb));
+    }
+    
+    d.on('error', p.emit.bind(p, 'error'));
+    g.on('error', p.emit.bind(p, 'error'));
+    d.pipe(through(function (dep) {
+        if (self._noParse.indexOf(dep.id) >= 0) {
+            p.write(dep);
+        }
+        else this.queue(dep)
+    })).pipe(g).pipe(p);
+    
+    return p;
+};
+
+Browserify.prototype.transform = function (t) {
+    if (typeof t === 'string' && /^\./.test(t)) {
+        t = path.resolve(t);
+    }
+    this._transforms.push(t);
+    return this;
+};
+
+Browserify.prototype.deps = function (opts) {
+    var self = this;
+    if (self._pending) {
+        var tr = through();
+        self.on('_ready', function () {
+            self.deps(opts).pipe(tr);
+        });
+        return tr;
+    }
+    
+    var d = mdeps(self.files, opts);
+    var tr = d.pipe(through(write));
+    d.on('error', tr.emit.bind(tr, 'error'));
+    return tr;
+    
+    function write (row) {
+        if (row.id === emptyModulePath) {
+            row.source = '';
+        }
+        
+        if (self._expose[row.id]) {
+            this.queue({
+                exposed: self._expose[row.id],
+                deps: {},
+                source: 'module.exports=require(\'' + hash(row.id) + '\');'
+            });
+        }
+        
+        if (self.exports[row.id]) row.exposed = self.exports[row.id];
+
+        // skip adding this file if it is external
+        if (self._external[row.id]) {
+            return;
+        }
+       
+        if (/\.json$/.test(row.id)) {
+            row.source = 'module.exports=' + row.source;
+        }
+        
+        var ix = self._entries.indexOf(row.id);
+        row.entry = ix >= 0;
+        if (ix >= 0) row.order = ix;
+        this.queue(row);
+    }
+};
+
+Browserify.prototype.pack = function (debug, standalone) {
+    var self = this;
+    var packer = browserPack({ raw: true });
+    var ids = {};
+    var idIndex = 1;
+
+    var mainModule;
+
+    var input = through(function (row) {
+        var ix;
+
+        if (debug) { 
+            row.sourceRoot = 'file://localhost'; 
+            row.sourceFile = row.id;
+        }
+
+        if (row.exposed) {
+            ix = row.exposed;
+        }
+        else {
+            ix = ids[row.id] !== undefined ? ids[row.id] : idIndex++;
+        }
+        if (ids[row.id] === undefined) ids[row.id] = ix;
+        
+        if (/^#!/.test(row.source)) row.source = '//' + row.source;
+        var err = checkSyntax(row.source, row.id);
+        if (err) return this.emit('error', err);
+        
+        row.id = ix;
+        if (row.entry) mainModule = mainModule || ix;
+        row.deps = Object.keys(row.deps).reduce(function (acc, key) {
+            var file = row.deps[key];
+
+            // reference external and exposed files directly by hash
+            if (self._external[file] || self.exports[file]) {
+                acc[key] = hash(file);
+                return acc;
+            }
+
+            if (ids[file] === undefined) ids[file] = idIndex++;
+            acc[key] = ids[file];
+            return acc;
+        }, {});
+        
+        this.queue(row);
+    });
+    
+    var first = true;
+    var hasExports = Object.keys(self.exports).length;
+    var output = through(write, end);
+    
+    function writePrelude () {
+        if (!first) return;
+        if (standalone) {
+            return output.queue(umd.prelude(standalone) + 'return ');
+        }
+        if (!hasExports) return output.queue(';');
+        output.queue('require=');
+    }
+    
+    input.pipe(packer);
+    packer.pipe(output);
+    return duplexer(input, output);
+    
+    function write (buf) {
+        if (first) writePrelude();
+        first = false;
+        this.queue(buf);
+    }
+    
+    function end () {
+        if (first) writePrelude();
+        if (standalone) {
+            output.queue('(' + mainModule + ')' + umd.postlude(standalone));
+        }
+        this.queue('\n;');
+        this.queue(null);
+    }
+};
+
+var packageFilter = function (info) {
+    if (typeof info.browserify === 'string' && !info.browser) {
+        info.browser = info.browserify;
+        delete info.browserify;
+    }
+    return info;
+};
+
+var emptyModulePath = require.resolve('./_empty');
+Browserify.prototype._resolve = function (id, parent, cb) {
+    var self = this;
+    var result = function (file, x) {
+        if (self._pending === 0) {
+            self.emit('file', file, id, parent);
+        }
+        cb(null, file, x);
+    };
+    if (self._mapped[id]) return result(self._mapped[id]);
+    
+    return browserResolve(id, parent, function(err, file) {
+        if (err) return cb(err);
+        if (!file) return cb(new Error('module '
+            + JSON.stringify(id) + ' not found from '
+            + JSON.stringify(parent.filename)
+        ));
+        
+        if (self._ignore[file]) return cb(null, emptyModulePath);
+        if (self._external[file]) return result(file, true);
+        
+        result(file);
+    });
+};

data/vendor/node_modules/browserify/node_modules/JSONStream/LICENSE.APACHE2

@@ -0,0 +1,15 @@
+Apache License, Version 2.0
+
+Copyright (c) 2011 Dominic Tarr
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.