sprockets-browserify 0.1.2 → 0.2.0

data/node_modules/browserify/node_modules/browser-resolve/test/core.js

@@ -0,0 +1,28 @@
+// test loading core modules
+var assert = require('assert');
+var resolve = require('../');
+
+test('events', function(done) {
+    resolve('events', {}, function(err, path) {
+        assert.ifError(err);
+        assert.equal(path, require.resolve('../builtin/events'));
+        done();
+    });
+});
+
+test('http', function(done) {
+    resolve('http', {}, function(err, path) {
+        assert.ifError(err);
+        assert.equal(path, require.resolve('http-browserify'));
+        done();
+    });
+});
+
+test('dgram', function(done) {
+    resolve('dgram', {}, function(err, path) {
+        assert.ifError(err);
+        assert.equal(path, require.resolve('../builtin/dgram'));
+        done();
+    });
+});
+

data/node_modules/browserify/node_modules/browser-resolve/test/false.js

@@ -0,0 +1,24 @@
+var assert = require('assert');
+var path = require('path');
+var resolve = require('../');
+
+var fixtures_dir = __dirname + '/fixtures';
+
+test('false file', function(done) {
+    var parent_file = fixtures_dir + '/node_modules/false/index.js';
+    resolve('./fake.js', { filename: parent_file }, function(err, p) {
+        assert.ifError(err);
+        assert.equal(p, path.normalize(__dirname + '/../empty.js'));
+        done();
+    });
+});
+
+test('false module', function(done) {
+    var parent_file = fixtures_dir + '/node_modules/false/index.js';
+    resolve('ignore-me', { filename: parent_file }, function(err, p) {
+        assert.ifError(err);
+        assert.equal(p, path.normalize(__dirname + '/../empty.js'));
+        done();
+    });
+});
+

data/node_modules/browserify/node_modules/concat-stream/index.js

@@ -0,0 +1,50 @@
+var stream = require('stream')
+var util = require('util')
+
+function ConcatStream(cb) {
+  stream.Stream.call(this)
+  this.writable = true
+  if (cb) this.cb = cb
+  this.body = []
+  this.on('error', function(err) {
+    if (this.cb) this.cb(err)
+  })
+}
+
+util.inherits(ConcatStream, stream.Stream)
+
+ConcatStream.prototype.write = function(chunk) {
+  this.body.push(chunk)
+}
+
+ConcatStream.prototype.destroy = function() {}
+
+ConcatStream.prototype.arrayConcat = function(arrs) {
+  if (arrs.length === 0) return []
+  if (arrs.length === 1) return arrs[0]
+  return arrs.reduce(function (a, b) { return a.concat(b) })
+}
+
+ConcatStream.prototype.isArray = function(arr) {
+  return Array.isArray(arr)
+}
+
+ConcatStream.prototype.getBody = function () {
+  if (this.body.length === 0) return
+  if (typeof(this.body[0]) === "string") return this.body.join('')
+  if (this.isArray(this.body[0])) return this.arrayConcat(this.body)
+  if (typeof(Buffer) !== "undefined" && Buffer.isBuffer(this.body[0])) {
+    return Buffer.concat(this.body)
+  }
+  return this.body
+}
+
+ConcatStream.prototype.end = function() {
+  if (this.cb) this.cb(false, this.getBody())
+}
+
+module.exports = function(cb) {
+  return new ConcatStream(cb)
+}
+
+module.exports.ConcatStream = ConcatStream

data/node_modules/browserify/node_modules/concat-stream/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "concat-stream",
+  "description": "writable stream that concatenates strings or data and calls a callback with the result",
+  "tags": [
+    "stream",
+    "simple",
+    "util",
+    "utility"
+  ],
+  "version": "0.1.1",
+  "author": {
+    "name": "Max Ogden",
+    "email": "max@maxogden.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/maxogden/node-concat-stream.git"
+  },
+  "bugs": {
+    "url": "http://github.com/maxogden/node-concat-stream/issues"
+  },
+  "engines": [
+    "node >= 0.8.0"
+  ],
+  "readme": "# concat-stream\n\n    npm install concat-stream\n\nthen\n\n    var concat = require('concat-stream')\n    var fs = require('fs')\n    \n    var read = fs.createReadStream('readme.md')\n    var write = concat(function(err, data) {})\n    \n    read.pipe(write)\n    \nworks with arrays too!\n\n    var write = concat(function(err, data) {})\n    write.write([1,2,3])\n    write.write([4,5,6])\n    write.end()\n    // data will be [1,2,3,4,5,6] in the above callback\n\nworks with buffers too! can't believe the deals!\n\n    var write = concat(function(err, data) {})\n    write.write(new Buffer('hello '))\n    write.write(new Buffer('world'))\n    write.end()\n    // data will be a buffer that toString()s to 'hello world' in the above callback\n    \nMIT LICENSE\n",
+  "readmeFilename": "readme.md",
+  "_id": "concat-stream@0.1.1",
+  "_from": "concat-stream@~0.1.1"
+}

data/node_modules/browserify/node_modules/concat-stream/test.js

@@ -0,0 +1,34 @@
+var spawn = require('child_process').spawn
+var concat = require('./')
+
+// real world example
+var cmd = spawn('ls')
+cmd.stdout.pipe(
+  concat(function(err, out) {
+    console.log('`ls`', err, out.toString())
+  })
+)
+
+// array stream
+var arrays = concat(function(err, out) {
+  console.log('arrays', err, out)
+})
+arrays.write([1,2,3])
+arrays.write([4,5,6])
+arrays.end()
+
+// buffer stream
+var buffers = concat(function(err, out) {
+  console.log('buffers', err, out.toString())
+})
+buffers.write(new Buffer('pizza Array is not a ', 'utf8'))
+buffers.write(new Buffer('stringy cat'))
+buffers.end()
+
+// string stream
+var strings = concat(function(err, out) {
+  console.log('strings', err, out)
+})
+strings.write("nacho ")
+strings.write("dogs")
+strings.end()

data/node_modules/browserify/node_modules/duplexer/Makefile

@@ -0,0 +1,4 @@
+test:
+	node test.js
+
+.PHONY: test

data/node_modules/browserify/node_modules/duplexer/README.md

@@ -0,0 +1,36 @@
+# duplexer [![build status][1]][2]
+
+Creates a duplex stream
+
+Taken from [event-stream][3]
+
+## duplex (writeStream, readStream)
+
+Takes a writable stream and a readable stream and makes them appear as a readable writable stream.
+
+It is assumed that the two streams are connected to each other in some way.
+
+## Example
+
+    var grep = cp.exec('grep Stream')
+
+    duplex(grep.stdin, grep.stdout)
+
+## Installation
+
+`npm install duplexer`
+
+## Tests
+
+`make test`
+
+## Contributors
+
+ - Dominictarr
+ - Raynos
+
+## MIT Licenced
+
+  [1]: https://secure.travis-ci.org/Raynos/duplexer.png
+  [2]: http://travis-ci.org/Raynos/duplexer
+  [3]: https://github.com/dominictarr/event-stream#duplex-writestream-readstream

data/node_modules/browserify/node_modules/duplexer/index.js

@@ -0,0 +1,77 @@
+var Stream = require("stream")
+    , writeMethods = ["write", "end", "destroy"]
+    , readMethods = ["resume", "pause"]
+    , readEvents = ["data", "close"]
+    , slice = Array.prototype.slice
+
+module.exports = duplex
+
+function duplex(writer, reader) {
+    var stream = new Stream()
+        , ended = false
+
+    writeMethods.forEach(proxyWriter)
+
+    readMethods.forEach(proxyReader)
+
+    readEvents.forEach(proxyStream)
+
+    reader.on("end", handleEnd)
+
+    writer.on("drain", function() {
+      stream.emit("drain")
+    })
+
+    writer.on("error", reemit)
+    reader.on("error", reemit)
+
+    stream.writable = writer.writable
+    stream.readable = reader.readable
+
+    return stream
+
+    function proxyWriter(methodName) {
+        stream[methodName] = method
+
+        function method() {
+            return writer[methodName].apply(writer, arguments)
+        }
+    }
+
+    function proxyReader(methodName) {
+        stream[methodName] = method
+
+        function method() {
+            stream.emit(methodName)
+            var func = reader[methodName]
+            if (func) {
+                return func.apply(reader, arguments)
+            }
+            reader.emit(methodName)
+        }
+    }
+
+    function proxyStream(methodName) {
+        reader.on(methodName, reemit)
+
+        function reemit() {
+            var args = slice.call(arguments)
+            args.unshift(methodName)
+            stream.emit.apply(stream, args)
+        }
+    }
+
+    function handleEnd() {
+        if (ended) {
+            return
+        }
+        ended = true
+        var args = slice.call(arguments)
+        args.unshift("end")
+        stream.emit.apply(stream, args)
+    }
+
+    function reemit(err) {
+        stream.emit("error", err)
+    }
+}

data/node_modules/browserify/node_modules/duplexer/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "duplexer",
+  "version": "0.0.4",
+  "description": "Creates a duplex stream",
+  "keywords": [],
+  "author": {
+    "name": "Raynos",
+    "email": "raynos2@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Raynos/duplexer.git"
+  },
+  "main": "index",
+  "homepage": "https://github.com/Raynos/duplexer",
+  "contributors": [
+    {
+      "name": "Jake Verbaten"
+    }
+  ],
+  "bugs": {
+    "url": "https://github.com/Raynos/duplexer/issues",
+    "email": "raynos2@gmail.com"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "through": "~0.1.4"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/Raynos/duplexer/raw/master/LICENSE"
+    }
+  ],
+  "scripts": {
+    "test": "make test"
+  },
+  "readme": "# duplexer [![build status][1]][2]\n\nCreates a duplex stream\n\nTaken from [event-stream][3]\n\n## duplex (writeStream, readStream)\n\nTakes a writable stream and a readable stream and makes them appear as a readable writable stream.\n\nIt is assumed that the two streams are connected to each other in some way.\n\n## Example\n\n    var grep = cp.exec('grep Stream')\n\n    duplex(grep.stdin, grep.stdout)\n\n## Installation\n\n`npm install duplexer`\n\n## Tests\n\n`make test`\n\n## Contributors\n\n - Dominictarr\n - Raynos\n\n## MIT Licenced\n\n  [1]: https://secure.travis-ci.org/Raynos/duplexer.png\n  [2]: http://travis-ci.org/Raynos/duplexer\n  [3]: https://github.com/dominictarr/event-stream#duplex-writestream-readstream",
+  "readmeFilename": "README.md",
+  "_id": "duplexer@0.0.4",
+  "_from": "duplexer@~0.0.2"
+}

data/node_modules/browserify/node_modules/duplexer/test.js

@@ -0,0 +1,27 @@
+var duplex = require("./index")
+    , assert = require("assert")
+    , through = require("through")
+
+var readable = through()
+    , writable = through(write)
+    , written = 0
+    , data = 0
+
+var stream = duplex(writable, readable)
+
+function write() {
+    written++
+}
+
+stream.on("data", ondata)
+
+function ondata() {
+    data++
+}
+
+stream.write()
+readable.emit("data")
+
+assert.equal(written, 1)
+assert.equal(data, 1)
+console.log("DONE")

data/node_modules/browserify/node_modules/inherits/README.md

@@ -0,0 +1,51 @@
+A dead simple way to do inheritance in JS.
+
+    var inherits = require("inherits")
+
+    function Animal () {
+      this.alive = true
+    }
+    Animal.prototype.say = function (what) {
+      console.log(what)
+    }
+
+    inherits(Dog, Animal)
+    function Dog () {
+      Dog.super.apply(this)
+    }
+    Dog.prototype.sniff = function () {
+      this.say("sniff sniff")
+    }
+    Dog.prototype.bark = function () {
+      this.say("woof woof")
+    }
+
+    inherits(Chihuahua, Dog)
+    function Chihuahua () {
+      Chihuahua.super.apply(this)
+    }
+    Chihuahua.prototype.bark = function () {
+      this.say("yip yip")
+    }
+
+    // also works
+    function Cat () {
+      Cat.super.apply(this)
+    }
+    Cat.prototype.hiss = function () {
+      this.say("CHSKKSS!!")
+    }
+    inherits(Cat, Animal, {
+      meow: function () { this.say("miao miao") }
+    })
+    Cat.prototype.purr = function () {
+      this.say("purr purr")
+    }
+
+
+    var c = new Chihuahua
+    assert(c instanceof Chihuahua)
+    assert(c instanceof Dog)
+    assert(c instanceof Animal)
+
+The actual function is laughably small.  10-lines small.

data/node_modules/browserify/node_modules/inherits/inherits.js

@@ -0,0 +1,29 @@
+module.exports = inherits
+
+function inherits (c, p, proto) {
+  proto = proto || {}
+  var e = {}
+  ;[c.prototype, proto].forEach(function (s) {
+    Object.getOwnPropertyNames(s).forEach(function (k) {
+      e[k] = Object.getOwnPropertyDescriptor(s, k)
+    })
+  })
+  c.prototype = Object.create(p.prototype, e)
+  c.super = p
+}
+
+//function Child () {
+//  Child.super.call(this)
+//  console.error([this
+//                ,this.constructor
+//                ,this.constructor === Child
+//                ,this.constructor.super === Parent
+//                ,Object.getPrototypeOf(this) === Child.prototype
+//                ,Object.getPrototypeOf(Object.getPrototypeOf(this))
+//                 === Parent.prototype
+//                ,this instanceof Child
+//                ,this instanceof Parent])
+//}
+//function Parent () {}
+//inherits(Child, Parent)
+//new Child

data/node_modules/browserify/node_modules/inherits/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "inherits",
+  "description": "A tiny simple way to do classic inheritance in js",
+  "version": "1.0.0",
+  "keywords": [
+    "inheritance",
+    "class",
+    "klass",
+    "oop",
+    "object-oriented"
+  ],
+  "main": "./inherits.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/isaacs/inherits"
+  },
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "readme": "A dead simple way to do inheritance in JS.\n\n    var inherits = require(\"inherits\")\n\n    function Animal () {\n      this.alive = true\n    }\n    Animal.prototype.say = function (what) {\n      console.log(what)\n    }\n\n    inherits(Dog, Animal)\n    function Dog () {\n      Dog.super.apply(this)\n    }\n    Dog.prototype.sniff = function () {\n      this.say(\"sniff sniff\")\n    }\n    Dog.prototype.bark = function () {\n      this.say(\"woof woof\")\n    }\n\n    inherits(Chihuahua, Dog)\n    function Chihuahua () {\n      Chihuahua.super.apply(this)\n    }\n    Chihuahua.prototype.bark = function () {\n      this.say(\"yip yip\")\n    }\n\n    // also works\n    function Cat () {\n      Cat.super.apply(this)\n    }\n    Cat.prototype.hiss = function () {\n      this.say(\"CHSKKSS!!\")\n    }\n    inherits(Cat, Animal, {\n      meow: function () { this.say(\"miao miao\") }\n    })\n    Cat.prototype.purr = function () {\n      this.say(\"purr purr\")\n    }\n\n\n    var c = new Chihuahua\n    assert(c instanceof Chihuahua)\n    assert(c instanceof Dog)\n    assert(c instanceof Animal)\n\nThe actual function is laughably small.  10-lines small.\n",
+  "readmeFilename": "README.md",
+  "_id": "inherits@1.0.0",
+  "_from": "inherits@~1.0.0"
+}

data/node_modules/browserify/node_modules/insert-module-globals/bench/results.txt

@@ -0,0 +1,18 @@
+$ git log|head -n1
+commit 8b66aec6f43c5099c72ab365a93da2a9e406824e
+
+with lexical-scope@0.0.4:
+
+$ time module-deps bench/jquery.js | bin/cmd.js >/dev/null
+
+real    0m7.380s
+user    0m7.504s
+sys     0m0.320s
+
+with lexical-scope@0.0.5:
+
+$ time module-deps bench/jquery.js | bin/cmd.js >/dev/null
+
+real    0m2.441s
+user    0m2.584s
+sys     0m0.176s

data/node_modules/browserify/node_modules/insert-module-globals/bench/run.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+time module-deps bench/jquery.js | bin/cmd.js >/dev/null

data/node_modules/browserify/node_modules/insert-module-globals/bin/cmd.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+var insert = require('../')(process.argv.slice(2));
+var JSONStream = require('JSONStream');
+
+var parse = JSONStream.parse([ true ]);
+var stringify = JSONStream.stringify();
+
+stringify.pipe(process.stdout);
+parse.pipe(insert).pipe(stringify);
+
+process.stdin.pipe(parse);
+process.stdin.resume();