sprockets-browserify 0.1.2 → 0.2.0

data/node_modules/browserify/node_modules/through/test/buffering.js

@@ -0,0 +1,71 @@
+var test = require('tape')
+var through = require('../')
+
+// must emit end before close.
+
+test('buffering', function(assert) {
+  var ts = through(function (data) {
+    this.queue(data)
+  }, function () {
+    this.queue(null)
+  })
+
+  var ended = false,  actual = []
+
+  ts.on('data', actual.push.bind(actual))
+  ts.on('end', function () {
+    ended = true
+  })
+
+  ts.write(1)
+  ts.write(2)
+  ts.write(3)
+  assert.deepEqual(actual, [1, 2, 3])
+  ts.pause()
+  ts.write(4)
+  ts.write(5)
+  ts.write(6)
+  assert.deepEqual(actual, [1, 2, 3])
+  ts.resume()
+  assert.deepEqual(actual, [1, 2, 3, 4, 5, 6])
+  ts.pause()
+  ts.end()
+  assert.ok(!ended)
+  ts.resume()
+  assert.ok(ended)
+  assert.end()
+})
+
+test('buffering has data in queue, when ends', function (assert) {
+
+  /*
+   * If stream ends while paused with data in the queue,
+   * stream should still emit end after all data is written
+   * on resume.
+   */
+
+  var ts = through(function (data) {
+    this.queue(data)
+  }, function () {
+    this.queue(null)
+  })
+
+  var ended = false,  actual = []
+
+  ts.on('data', actual.push.bind(actual))
+  ts.on('end', function () {
+    ended = true
+  })
+
+  ts.pause()
+  ts.write(1)
+  ts.write(2)
+  ts.write(3)
+  ts.end()
+  assert.deepEqual(actual, [], 'no data written yet, still paused')
+  assert.ok(!ended, 'end not emitted yet, still paused')
+  ts.resume()
+  assert.deepEqual(actual, [1, 2, 3], 'resumed, all data should be delivered')
+  assert.ok(ended, 'end should be emitted once all data was delivered')
+  assert.end();
+})

data/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/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/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/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/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/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/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/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/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/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/node_modules/browserify/node_modules/umd/node_modules/rfile/node_modules/callsite/package.json

@@ -0,0 +1,27 @@
+{
+  "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",
+  "_from": "callsite@~1.0.0"
+}

data/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/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/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/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');