ruby-wisp-source 0.7.0

data/vendor/node_modules/browserify/node_modules/through/test/end.js

@@ -0,0 +1,26 @@
+var test = require('tape')
+var through = require('../')
+
+// must emit end before close.
+
+test('end before close', function (assert) {
+  var ts = through()
+  var ended = false, closed = false
+
+  ts.on('end', function () {
+    assert.ok(!closed)
+    ended = true
+  })
+  ts.on('close', function () {
+    assert.ok(ended)
+    closed = true
+  })
+
+  ts.write(1)
+  ts.write(2)
+  ts.write(3)
+  ts.end()
+  assert.ok(ended)
+  assert.ok(closed)
+  assert.end()
+})

data/vendor/node_modules/browserify/node_modules/through/test/index.js

@@ -0,0 +1,114 @@
+
+var test = require('tape')
+var spec = require('stream-spec')
+var through = require('../')
+
+/*
+  I'm using these two functions, and not streams and pipe
+  so there is less to break. if this test fails it must be
+  the implementation of _through_
+*/
+
+function write(array, stream) {
+  array = array.slice()
+  function next() {
+    while(array.length)
+      if(stream.write(array.shift()) === false)
+        return stream.once('drain', next)
+    
+    stream.end()
+  }
+
+  next()
+}
+
+function read(stream, callback) {
+  var actual = []
+  stream.on('data', function (data) {
+    actual.push(data)
+  })
+  stream.once('end', function () {
+    callback(null, actual)
+  })
+  stream.once('error', function (err) {
+    callback(err)
+  })
+}
+
+test('simple defaults', function(assert) {
+
+  var l = 1000
+    , expected = []
+
+  while(l--) expected.push(l * Math.random())
+
+  var t = through()
+    spec(t)
+      .through()
+      .pausable()
+      .validateOnExit()
+
+  read(t, function (err, actual) {
+    assert.ifError(err)
+    assert.deepEqual(actual, expected)
+    assert.end()
+  })
+
+  write(expected, t)
+});
+
+test('simple functions', function(assert) {
+
+  var l = 1000
+    , expected = [] 
+
+  while(l--) expected.push(l * Math.random())
+
+  var t = through(function (data) {
+      this.emit('data', data*2)
+    }) 
+    spec(t)
+      .through()
+      .pausable()
+      .validateOnExit()
+
+  read(t, function (err, actual) {
+    assert.ifError(err)
+    assert.deepEqual(actual, expected.map(function (data) {
+      return data*2
+    }))
+    assert.end()
+  })
+
+  write(expected, t)
+})
+
+test('pauses', function(assert) {
+
+  var l = 1000
+    , expected = [] 
+
+  while(l--) expected.push(l) //Math.random())
+
+  var t = through()    
+    spec(t)
+      .through()
+      .pausable()
+      .validateOnExit()
+
+  t.on('data', function () {
+    if(Math.random() > 0.1) return
+    t.pause()
+    process.nextTick(function () {
+      t.resume()
+    })
+  })
+
+  read(t, function (err, actual) {
+    assert.ifError(err)
+    assert.deepEqual(actual, expected)
+    assert.end()
+  })
+
+  write(expected, t)
+})

data/vendor/node_modules/browserify/node_modules/umd/README.md

@@ -0,0 +1,46 @@
+<img src="http://i.imgur.com/ypw29XY.png" align="right"/>
+# umd
+
+Universal Module Definition for use in automated build systems
+
+## Source Format
+
+In order for the UMD wrapper to work the source code for your module should `return` the export, e.g.
+
+```javascript
+function method() {
+  //code
+}
+method.helper = function () {
+  //code
+}
+return method;
+```
+
+For examples, see the examples directory.  The CommonJS module format is also supported by passing true as the second argument to methods.
+
+## API
+
+### umd(name, [commonJS = false], [source])
+
+  The `name` should the the name of the module.  Use a string like name, all lower case with hyphens instead of spaces.
+
+  If CommonJS is `true` then it will accept CommonJS source instead of source code which `return`s the module.
+
+  If `source` is provided and is a string, then it is wrapped in umd and returned as a string.  If it is not provided, a duplex stream is returned which wraps the modules (see examples/build.js).
+
+  Both commonJS and source are optional and can be provided in either order.
+
+### umd.prelude(module, [commonJS = false])
+
+  return the text which will be inserted before a module.
+
+### umd.postlude(module, [commonJS = false])
+
+  return the text which will be inserted after a module.
+
+## License
+
+  MIT
+
+![viewcount](https://viewcount.jepso.com/count/ForbesLindesay/umd.png)

data/vendor/node_modules/browserify/node_modules/umd/index.js

@@ -0,0 +1,63 @@
+var through = require('through');
+var rfile = require('rfile');
+var templateSTR = rfile('./template.js');
+var uglify = require('uglify-js');
+function template(moduleName, cjs) {
+  var str = uglify.minify(
+    templateSTR
+      .replace(/\{\{name\}\}/g, moduleName.toLowerCase())
+      .replace(/\{\{pascalcase\}\}/g, pascalCase(moduleName))
+      .replace(/\{\{camelcase\}\}/g, camelCase(moduleName)),
+    {fromString: true}).code
+    .split('source()')
+  str[0] = str[0].trim();
+  //make sure these are undefined so as to not get confused if modules have inner UMD systems
+  str[0] += 'var define,ses,bootstrap,module,exports;';
+  if (cjs) str[0] += 'module={exports:(exports={})};';
+  str[0] += '\n';
+  if (cjs) str[1] = 'return module.exports;' + str[1];
+  str[1] = '\n' + str[1];
+  return str;
+}
+
+exports = module.exports = function (name, cjs, src) {
+  if (typeof cjs === 'string') {
+    var tmp = cjs;
+    cjs = src;
+    src = tmp;
+  }
+  if (src) {
+    return exports.prelude(name, cjs) + src + exports.postlude(name, cjs);
+  } else {
+    var strm = through(write, end);
+    var first = true;
+    function write(chunk) {
+      if (first) strm.queue(exports.prelude(name, cjs));
+      first = false;
+      strm.queue(chunk);
+    }
+    function end() {
+      if (first) strm.queue(exports.prelude(name, cjs));
+      strm.queue(exports.postlude(name, cjs));
+      strm.queue(null);
+    }
+    return strm;
+  }
+};
+
+exports.prelude = function (moduleName, cjs) {
+  return template(moduleName, cjs)[0];
+};
+exports.postlude = function (moduleName, cjs) {
+  return template(moduleName, cjs)[1];
+};
+
+
+
+function pascalCase(name) {
+  return camelCase(name).replace(/^[a-z]/, function (char) { return char.toUpperCase(); });
+}
+function camelCase(name) {
+  name = name.replace(/\-([a-z])/g, function (_, char) { return char.toUpperCase(); });
+  return name.replace(/[^a-zA-Z0-9]+/g, '');
+}

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/README.md

@@ -0,0 +1,81 @@
+# rfile
+
+[![Build Status](https://secure.travis-ci.org/ForbesLindesay/rfile.png)](http://travis-ci.org/ForbesLindesay/rfile)
+[![Dependency Status](https://gemnasium.com/ForbesLindesay/rfile.png)](https://gemnasium.com/ForbesLindesay/rfile)
+
+require a plain text or binary file in node.js
+
+## Installation
+
+    $ npm install rfile
+
+## Usage
+
+```javascript
+var rfile = require('rfile');
+
+var text = rfile('./my-text-file.txt');
+var mochaReadme = rfile('mocha/readme.md');
+var mochaSource = rfile('mocha');
+var image = rfile('image.png', {binary: true});
+```
+
+## API
+
+### rfile(pkg, options)
+
+  Uses `rfile.resolve` (see below) to look up your file `pkg`.  This means it supports all the same options as `rfile.resolve`.  Having found the file, it does the following:
+
+```javascript
+return options.binary ? read(path) : fixup(read(path).toString());
+```
+
+  `options.binary` defaults to `false` and `fixup` removes the UTF-8 BOM if present and removes any `\r` characters (added to newlines on windows only).
+
+### rfile.resolve(pkg, options)
+
+  Internally, [resolve](https://npmjs.org/package/resolve) is used to lookup your package, so it supports all the same options as that.  In addition t defaults `basedir` to the directory of the function which called `rfile` or `rfile.resolve`.
+
+  The additional option `exclude` is useful if you wanted to create a wrapper arround this.  It specifies the filenames not to consider for `basedir` paths.  For example, you could create a module called `ruglify` for requiring and minifying JavaScript in one go.
+
+  ruglify.js
+```javascript
+var rfile = require('rfile');
+var uglify require('uglify-js').minify;
+
+module.exports = ruglify;
+function ruglify(path, options) {
+  return minify(rfile.resolve(path, {exclude: [__filename]}), options).code;
+}
+```
+
+#### From `resolve`
+
+ - opts.basedir - directory to begin resolving from (defaults to `__dirname` of the calling module for `rfile`)
+ - opts.extensions - array of file extensions to search in order (defaults to `['.js', '.json']` for `rfile`)
+ - opts.readFile - how to read files asynchronously
+ - opts.isFile - function to asynchronously test whether a file exists
+ - opts.packageFilter - transform the parsed package.json contents before looking at the "main" field (useful for browserify etc.)
+ - opts.paths - require.paths array to use if nothing is found on the normal node_modules recursive walk (probably don't use this)
+
+## Notes
+
+One of the interesting features of this is that it respects the `main` field of package.json files.  Say you had a module called `foo`, you could have a package.json like:
+
+```json
+{
+  "name": "foo",
+  "version": "1.0.0",
+  "main": "./foo"
+}
+```
+
+You might then have a `foo.js` file, containing the JavaScript code of the module, and a `foo.css` file containing the stylesheet for the module when used in the browser.  Using `rfile` you could load the css by simply calling:
+
+```javascript
+rfile('foo', {extensions: ['.css']});
+```
+
+## License
+
+  MIT

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/index.js

@@ -0,0 +1,39 @@
+var callsite = require('callsite');
+var resolve = require('resolve');
+var dirname = require('path').dirname;
+var read = require('fs').readFileSync;
+
+exports = module.exports = req;
+exports.resolve = res;
+
+function req(pkg, options) {
+  options = options || {};
+  var path = res(pkg, options);
+  return options.binary ? read(path) : fixup(read(path));
+}
+
+function res(pkg, options) {
+  options = options || {};
+  options.basedir = options.basedir || directory(options.exclude);
+  options.extensions = options.extensions || ['.js', '.json'];
+  return resolve.sync(pkg, options);
+}
+
+function directory(exclude) {
+  var stack = callsite();
+  for (var i = 0; i < stack.length; i++) {
+    var filename = stack[i].getFileName();
+    if (filename !== __filename && (!exclude || (exclude.indexOf(filename) === -1)))
+      return dirname(filename);
+  }
+  throw new Error('Could not resolve directory');
+}
+
+function fixup(str) {
+  return stripBOM(str.toString()).replace(/\r/g, '');
+}
+function stripBOM(str){
+  return 0xFEFF == str.charCodeAt(0)
+    ? str.substring(1)
+    : str;
+}

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/callsite/History.md

@@ -0,0 +1,10 @@
+
+1.0.0 / 2013-01-24 
+==================
+
+  * remove lame magical getters
+
+0.0.1 / 2010-01-03
+==================
+
+  * Initial release

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/callsite/Makefile

@@ -0,0 +1,6 @@
+
+test:
+	@./node_modules/.bin/mocha \
+		--require should
+
+.PHONY: test

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/callsite/Readme.md

@@ -0,0 +1,44 @@
+# callstack
+
+  Access to v8's "raw" `CallSite`s.
+
+## Installation
+
+    $ npm install callsite
+
+## Example
+
+```js
+var stack = require('callsite');
+
+foo();
+
+function foo() {
+  bar();
+}
+
+function bar() {
+  baz();
+}
+
+function baz() {
+  console.log();
+  stack().forEach(function(site){
+    console.log('  \033[36m%s\033[90m in %s:%d\033[0m'
+      , site.getFunctionName() || 'anonymous'
+      , site.getFileName()
+      , site.getLineNumber());
+  });
+  console.log();
+}
+```
+
+## Why?
+
+  Because you can do weird, stupid, clever, wacky things such as:
+
+  - [better-assert](https://github.com/visionmedia/better-assert)
+
+## License
+
+  MIT

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/callsite/index.js

@@ -0,0 +1,10 @@
+
+module.exports = function(){
+  var orig = Error.prepareStackTrace;
+  Error.prepareStackTrace = function(_, stack){ return stack; };
+  var err = new Error;
+  Error.captureStackTrace(err, arguments.callee);
+  var stack = err.stack;
+  Error.prepareStackTrace = orig;
+  return stack;
+};

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/callsite/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "callsite",
+  "version": "1.0.0",
+  "description": "access to v8's CallSites",
+  "keywords": [
+    "stack",
+    "trace",
+    "line"
+  ],
+  "author": {
+    "name": "TJ Holowaychuk",
+    "email": "tj@vision-media.ca"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "mocha": "*",
+    "should": "*"
+  },
+  "main": "index",
+  "engines": {
+    "node": "*"
+  },
+  "readme": "# callstack\n\n  Access to v8's \"raw\" `CallSite`s.\n\n## Installation\n\n    $ npm install callsite\n\n## Example\n\n```js\nvar stack = require('callsite');\n\nfoo();\n\nfunction foo() {\n  bar();\n}\n\nfunction bar() {\n  baz();\n}\n\nfunction baz() {\n  console.log();\n  stack().forEach(function(site){\n    console.log('  \\033[36m%s\\033[90m in %s:%d\\033[0m'\n      , site.getFunctionName() || 'anonymous'\n      , site.getFileName()\n      , site.getLineNumber());\n  });\n  console.log();\n}\n```\n\n## Why?\n\n  Because you can do weird, stupid, clever, wacky things such as:\n\n  - [better-assert](https://github.com/visionmedia/better-assert)\n\n## License\n\n  MIT\n",
+  "readmeFilename": "Readme.md",
+  "_id": "callsite@1.0.0",
+  "dist": {
+    "shasum": "280398e5d664bd74038b6f0905153e6e8af1bc20"
+  },
+  "_from": "callsite@~1.0.0",
+  "_resolved": "https://registry.npmjs.org/callsite/-/callsite-1.0.0.tgz"
+}

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/resolve/LICENSE

@@ -0,0 +1,18 @@
+This software is released under the MIT license:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/resolve/example/async.js

@@ -0,0 +1,5 @@
+var resolve = require('../');
+resolve('tap', { basedir: __dirname }, function (err, res) {
+    if (err) console.error(err)
+    else console.log(res)
+});

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/resolve/example/sync.js

@@ -0,0 +1,3 @@
+var resolve = require('../');
+var res = resolve.sync('tap', { basedir: __dirname });
+console.log(res);

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/resolve/index.js

@@ -0,0 +1,5 @@
+var core = require('./lib/core');
+exports = module.exports = require('./lib/async');
+exports.core = core;
+exports.isCore = function (x) { return core[x] };
+exports.sync = require('./lib/sync');

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/resolve/lib/async.js

@@ -0,0 +1,131 @@
+var core = require('./core');
+var fs = require('fs');
+var path = require('path');
+
+module.exports = function resolve (x, opts, cb) {
+    if (core[x]) return cb(null, x);
+    
+    if (typeof opts === 'function') {
+        cb = opts;
+        opts = {};
+    }
+    if (!opts) opts = {};
+    
+    var isFile = opts.isFile || function (file, cb) {
+        fs.stat(file, function (err, stat) {
+            if (err && err.code === 'ENOENT') cb(null, false)
+            else if (err) cb(err)
+            else cb(null, stat.isFile() || stat.isFIFO())
+        });
+    };
+    var readFile = opts.readFile || fs.readFile;
+    
+    var extensions = opts.extensions || [ '.js' ];
+    var y = opts.basedir
+        || path.dirname(require.cache[__filename].parent.filename)
+    ;
+    
+    opts.paths = opts.paths || [];
+    
+    if (x.match(/^(?:\.\.?\/|\/|([A-Za-z]:)?\\)/)) {
+        loadAsFile(path.resolve(y, x), function (err, m) {
+            if (err) cb(err)
+            else if (m) cb(null, m)
+            else loadAsDirectory(path.resolve(y, x), function (err, d) {
+                if (err) cb(err)
+                else if (d) cb(null, d)
+                else cb(new Error("Cannot find module '" + x + "'"))
+            })
+        });
+    }
+    else loadNodeModules(x, y, function (err, n) {
+        if (err) cb(err)
+        else if (n) cb(null, n)
+        else cb(new Error("Cannot find module '" + x + "'"))
+    });
+    
+    function loadAsFile (x, cb) {
+        (function load (exts) {
+            if (exts.length === 0) return cb(null, undefined);
+            var file = x + exts[0];
+            
+            isFile(file, function (err, ex) {
+                if (err) cb(err)
+                else if (ex) cb(null, file)
+                else load(exts.slice(1))
+            });
+        })([''].concat(extensions));
+    }
+    
+    function loadAsDirectory (x, cb) {
+        var pkgfile = path.join(x, '/package.json');
+        isFile(pkgfile, function (err, ex) {
+            if (err) return cb(err);
+            if (!ex) return loadAsFile(path.join(x, '/index'), cb);
+            
+            readFile(pkgfile, function (err, body) {
+                if (err) return cb(err);
+                try {
+                    var pkg = JSON.parse(body);
+                }
+                catch (err) {}
+                
+                if (opts.packageFilter) {
+                    pkg = opts.packageFilter(pkg, x);
+                }
+                
+                if (pkg.main) {
+                    loadAsFile(path.resolve(x, pkg.main), function (err, m) {
+                        if (err) return cb(err);
+                        if (m) return cb(null, m);
+                        var dir = path.resolve(x, pkg.main);
+                        loadAsDirectory(dir, function (err, n) {
+                            if (err) return cb(err);
+                            if (n) return cb(null, n);
+                            loadAsFile(path.join(x, '/index'), cb);
+                        });
+                    });
+                    return;
+                }
+                
+                loadAsFile(path.join(x, '/index'), cb);
+            });
+        });
+    }
+    
+    function loadNodeModules (x, start, cb) {
+        (function process (dirs) {
+            if (dirs.length === 0) return cb(null, undefined);
+            var dir = dirs[0];
+            
+            loadAsFile(path.join(dir, '/', x), function (err, m) {
+                if (err) return cb(err);
+                if (m) return cb(null, m);
+                loadAsDirectory(path.join(dir, '/', x), function (err, n) {
+                    if (err) return cb(err);
+                    if (n) return cb(null, n);
+                    process(dirs.slice(1));
+                });
+            });
+        })(nodeModulesPaths(start));
+    }
+    
+    function nodeModulesPaths (start, cb) {
+        var splitRe = process.platform === 'win32' ? /[\/\\]/ : /\/+/;
+        var parts = start.split(splitRe);
+        
+        var dirs = [];
+        for (var i = parts.length - 1; i >= 0; i--) {
+            if (parts[i] === 'node_modules') continue;
+            var dir = path.join(
+                path.join.apply(path, parts.slice(0, i + 1)),
+                'node_modules'
+            );
+            if (!parts[0].match(/([A-Za-z]:)/)) {
+                dir = '/' + dir;    
+            }
+            dirs.push(dir);
+        }
+        return dirs.concat(opts.paths);
+    }
+};

data/vendor/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/resolve/lib/core.js

@@ -0,0 +1,4 @@
+module.exports = require('./core.json').reduce(function (acc, x) {
+    acc[x] = true;
+    return acc;
+}, {});