sprockets-browserify 0.1.0

data/node_modules/browserify/builtins/util.js

@@ -0,0 +1,351 @@
+var events = require('events');
+
+exports.isArray = isArray;
+exports.isDate = function(obj){return Object.prototype.toString.call(obj) === '[object Date]'};
+exports.isRegExp = function(obj){return Object.prototype.toString.call(obj) === '[object RegExp]'};
+
+
+exports.print = function () {};
+exports.puts = function () {};
+exports.debug = function() {};
+
+exports.inspect = function(obj, showHidden, depth, colors) {
+  var seen = [];
+
+  var stylize = function(str, styleType) {
+    // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+    var styles =
+        { 'bold' : [1, 22],
+          'italic' : [3, 23],
+          'underline' : [4, 24],
+          'inverse' : [7, 27],
+          'white' : [37, 39],
+          'grey' : [90, 39],
+          'black' : [30, 39],
+          'blue' : [34, 39],
+          'cyan' : [36, 39],
+          'green' : [32, 39],
+          'magenta' : [35, 39],
+          'red' : [31, 39],
+          'yellow' : [33, 39] };
+
+    var style =
+        { 'special': 'cyan',
+          'number': 'blue',
+          'boolean': 'yellow',
+          'undefined': 'grey',
+          'null': 'bold',
+          'string': 'green',
+          'date': 'magenta',
+          // "name": intentionally not styling
+          'regexp': 'red' }[styleType];
+
+    if (style) {
+      return '\033[' + styles[style][0] + 'm' + str +
+             '\033[' + styles[style][1] + 'm';
+    } else {
+      return str;
+    }
+  };
+  if (! colors) {
+    stylize = function(str, styleType) { return str; };
+  }
+
+  function format(value, recurseTimes) {
+    // Provide a hook for user-specified inspect functions.
+    // Check that value is an object with an inspect function on it
+    if (value && typeof value.inspect === 'function' &&
+        // Filter out the util module, it's inspect function is special
+        value !== exports &&
+        // Also filter out any prototype objects using the circular check.
+        !(value.constructor && value.constructor.prototype === value)) {
+      return value.inspect(recurseTimes);
+    }
+
+    // Primitive types cannot have properties
+    switch (typeof value) {
+      case 'undefined':
+        return stylize('undefined', 'undefined');
+
+      case 'string':
+        var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+                                                 .replace(/'/g, "\\'")
+                                                 .replace(/\\"/g, '"') + '\'';
+        return stylize(simple, 'string');
+
+      case 'number':
+        return stylize('' + value, 'number');
+
+      case 'boolean':
+        return stylize('' + value, 'boolean');
+    }
+    // For some reason typeof null is "object", so special case here.
+    if (value === null) {
+      return stylize('null', 'null');
+    }
+
+    // Look up the keys of the object.
+    var visible_keys = Object_keys(value);
+    var keys = showHidden ? Object_getOwnPropertyNames(value) : visible_keys;
+
+    // Functions without properties can be shortcutted.
+    if (typeof value === 'function' && keys.length === 0) {
+      if (isRegExp(value)) {
+        return stylize('' + value, 'regexp');
+      } else {
+        var name = value.name ? ': ' + value.name : '';
+        return stylize('[Function' + name + ']', 'special');
+      }
+    }
+
+    // Dates without properties can be shortcutted
+    if (isDate(value) && keys.length === 0) {
+      return stylize(value.toUTCString(), 'date');
+    }
+
+    var base, type, braces;
+    // Determine the object type
+    if (isArray(value)) {
+      type = 'Array';
+      braces = ['[', ']'];
+    } else {
+      type = 'Object';
+      braces = ['{', '}'];
+    }
+
+    // Make functions say that they are functions
+    if (typeof value === 'function') {
+      var n = value.name ? ': ' + value.name : '';
+      base = (isRegExp(value)) ? ' ' + value : ' [Function' + n + ']';
+    } else {
+      base = '';
+    }
+
+    // Make dates with properties first say the date
+    if (isDate(value)) {
+      base = ' ' + value.toUTCString();
+    }
+
+    if (keys.length === 0) {
+      return braces[0] + base + braces[1];
+    }
+
+    if (recurseTimes < 0) {
+      if (isRegExp(value)) {
+        return stylize('' + value, 'regexp');
+      } else {
+        return stylize('[Object]', 'special');
+      }
+    }
+
+    seen.push(value);
+
+    var output = keys.map(function(key) {
+      var name, str;
+      if (value.__lookupGetter__) {
+        if (value.__lookupGetter__(key)) {
+          if (value.__lookupSetter__(key)) {
+            str = stylize('[Getter/Setter]', 'special');
+          } else {
+            str = stylize('[Getter]', 'special');
+          }
+        } else {
+          if (value.__lookupSetter__(key)) {
+            str = stylize('[Setter]', 'special');
+          }
+        }
+      }
+      if (visible_keys.indexOf(key) < 0) {
+        name = '[' + key + ']';
+      }
+      if (!str) {
+        if (seen.indexOf(value[key]) < 0) {
+          if (recurseTimes === null) {
+            str = format(value[key]);
+          } else {
+            str = format(value[key], recurseTimes - 1);
+          }
+          if (str.indexOf('\n') > -1) {
+            if (isArray(value)) {
+              str = str.split('\n').map(function(line) {
+                return '  ' + line;
+              }).join('\n').substr(2);
+            } else {
+              str = '\n' + str.split('\n').map(function(line) {
+                return '   ' + line;
+              }).join('\n');
+            }
+          }
+        } else {
+          str = stylize('[Circular]', 'special');
+        }
+      }
+      if (typeof name === 'undefined') {
+        if (type === 'Array' && key.match(/^\d+$/)) {
+          return str;
+        }
+        name = JSON.stringify('' + key);
+        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+          name = name.substr(1, name.length - 2);
+          name = stylize(name, 'name');
+        } else {
+          name = name.replace(/'/g, "\\'")
+                     .replace(/\\"/g, '"')
+                     .replace(/(^"|"$)/g, "'");
+          name = stylize(name, 'string');
+        }
+      }
+
+      return name + ': ' + str;
+    });
+
+    seen.pop();
+
+    var numLinesEst = 0;
+    var length = output.reduce(function(prev, cur) {
+      numLinesEst++;
+      if (cur.indexOf('\n') >= 0) numLinesEst++;
+      return prev + cur.length + 1;
+    }, 0);
+
+    if (length > 50) {
+      output = braces[0] +
+               (base === '' ? '' : base + '\n ') +
+               ' ' +
+               output.join(',\n  ') +
+               ' ' +
+               braces[1];
+
+    } else {
+      output = braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+    }
+
+    return output;
+  }
+  return format(obj, (typeof depth === 'undefined' ? 2 : depth));
+};
+
+
+function isArray(ar) {
+  return ar instanceof Array ||
+         Array.isArray(ar) ||
+         (ar && ar !== Object.prototype && isArray(ar.__proto__));
+}
+
+
+function isRegExp(re) {
+  return re instanceof RegExp ||
+    (typeof re === 'object' && Object.prototype.toString.call(re) === '[object RegExp]');
+}
+
+
+function isDate(d) {
+  if (d instanceof Date) return true;
+  if (typeof d !== 'object') return false;
+  var properties = Date.prototype && Object_getOwnPropertyNames(Date.prototype);
+  var proto = d.__proto__ && Object_getOwnPropertyNames(d.__proto__);
+  return JSON.stringify(proto) === JSON.stringify(properties);
+}
+
+function pad(n) {
+  return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+              'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()),
+              pad(d.getMinutes()),
+              pad(d.getSeconds())].join(':');
+  return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+exports.log = function (msg) {};
+
+exports.pump = null;
+
+var Object_keys = Object.keys || function (obj) {
+    var res = [];
+    for (var key in obj) res.push(key);
+    return res;
+};
+
+var Object_getOwnPropertyNames = Object.getOwnPropertyNames || function (obj) {
+    var res = [];
+    for (var key in obj) {
+        if (Object.hasOwnProperty.call(obj, key)) res.push(key);
+    }
+    return res;
+};
+
+var Object_create = Object.create || function (prototype, properties) {
+    // from es5-shim
+    var object;
+    if (prototype === null) {
+        object = { '__proto__' : null };
+    }
+    else {
+        if (typeof prototype !== 'object') {
+            throw new TypeError(
+                'typeof prototype[' + (typeof prototype) + '] != \'object\''
+            );
+        }
+        var Type = function () {};
+        Type.prototype = prototype;
+        object = new Type();
+        object.__proto__ = prototype;
+    }
+    if (typeof properties !== 'undefined' && Object.defineProperties) {
+        Object.defineProperties(object, properties);
+    }
+    return object;
+};
+
+exports.inherits = function(ctor, superCtor) {
+  ctor.super_ = superCtor;
+  ctor.prototype = Object_create(superCtor.prototype, {
+    constructor: {
+      value: ctor,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+};
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+  if (typeof f !== 'string') {
+    var objects = [];
+    for (var i = 0; i < arguments.length; i++) {
+      objects.push(exports.inspect(arguments[i]));
+    }
+    return objects.join(' ');
+  }
+
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  var str = String(f).replace(formatRegExp, function(x) {
+    if (x === '%%') return '%';
+    if (i >= len) return x;
+    switch (x) {
+      case '%s': return String(args[i++]);
+      case '%d': return Number(args[i++]);
+      case '%j': return JSON.stringify(args[i++]);
+      default:
+        return x;
+    }
+  });
+  for(var x = args[i]; i < len; x = args[++i]){
+    if (x === null || typeof x !== 'object') {
+      str += ' ' + x;
+    } else {
+      str += ' ' + exports.inspect(x);
+    }
+  }
+  return str;
+};

data/node_modules/browserify/doc/methods.markdown

@@ -0,0 +1,182 @@
+methods
+=======
+
+This section documents the browserify api.
+
+````javascript
+var browserify = require('browserify');
+````
+
+var b = browserify(opts={})
+---------------------------
+
+Return a new bundle object.
+
+`opts` may also contain these fields:
+
+* watch - set watches on files, see below
+* cache - turn on caching for AST traversals, see below
+* debug - turn on source mapping for debugging with `//@ sourceURL=...`
+in browsers that support it
+* exports - an array of the core items to export to the namespace. Available
+items: 'require', 'process'
+
+If `opts` is a string, it is interpreted as a file to call `.addEntry()` with.
+
+### watch :: Boolean or Object
+
+Set watches on files and automatically rebundle when a file changes.
+
+This option defaults to false. If `opts.watch` is set to true, default watch
+arguments are assumed or you can pass in an object to pass along as the second
+parameter to `fs.watchFile()`.
+
+### cache :: Boolean or String
+
+If `cache` is a boolean, turn on caching at
+`$HOME/.config/browserify/cache.json`.
+
+If `cache` is a string, turn on caching at the filename specified by `cache`.
+
+### bundle events
+
+`b` bundles will also emit events.
+
+#### 'syntaxError', err
+
+This event gets emitted when there is a syntax error somewhere in the build
+process. If you don't listen for this event, the error will be printed to
+stderr.
+
+#### 'bundle'
+
+In watch mode, this event is emitted when a new bundle has been generated.
+
+b.bundle()
+----------
+
+Return the bundled source as a string.
+
+By default, `require` is not exported to the environment if there are entry
+files in the bundle but you can override that with `opts.exports`.
+
+`process` is only exported to the environment when `opts.exports` contains the
+string `'process'`.
+
+b.require(file)
+---------------
+
+Require a file or files for inclusion in the bundle.
+
+If `file` is an array, require each element in it.
+
+If `file` is a non-array object, map an alias to a package name.
+For instance to be able to map `require('jquery')` to the jquery-browserify
+package, you can do:
+
+````javascript
+b.require({ jquery : 'jquery-browserify' })
+````
+
+and the same thing in middleware-form:
+
+````javascript
+browserify({ require : { jquery : 'jquery-browserify' } })
+````
+
+To mix alias objects with regular requires you could do:
+
+````javascript
+browserify({ require : [ 'seq', { jquery : 'jquery-browserify' }, 'traverse' ])
+````
+
+In practice you won't need to `b.require()` very many files since all the
+`require()`s are read from each file that you require and automatically
+included.
+
+b.ignore(file)
+--------------
+
+Omit a file or files from being included by the AST walk to hunt down
+`require()` statements.
+
+b.addEntry(file)
+----------------
+
+Append a file to the end of the bundle and execute it without having to
+`require()` it.
+
+Specifying an entry point will let you `require()` other modules without having
+to load the entry point in a `<script>` tag yourself.
+
+If entry is an Array, concatenate these files together and append to the end of
+the bundle.
+
+b.filter(fn)
+------------
+
+Transform the source using the filter function `fn(src)`. The return value of
+`fn` should be the new source.
+
+b.register(ext, fn)
+-------------------
+
+Register a handler to wrap extensions.
+
+Wrap every file matching the extension `ext` with the function `fn`.
+
+For every `file` included into the bundle `fn` gets called for matching file
+types as `fn.call(b, body, file)` for the bundle instance `b` and the file
+content string `body`. `fn` should return the new wrapped contents.
+
+If `ext` is unspecified, execute the wrapper for every file.
+
+If `ext` is 'post', execute the wrapper on the entire bundle.
+
+If `ext` is 'pre', call the wrapper function with the bundle object before the
+source is generated.
+
+If `ext` is 'path', execute the wrapper for every `file` before it is open,
+allowing the extension to change it. `fn` gets called as `fn.call(b, file)`
+for the bundle instance `b` and the file path `file`. `fn` should return the
+new path to the file.
+
+If `ext` is an object, pull the extension from `ext.extension` and the wrapper
+function `fn` from `ext.wrapper`. This makes it easy to write plugins like
+[fileify](https://github.com/substack/node-fileify).
+
+Coffee script support is just implemented internally as a `.register()`
+extension:
+
+````javascript
+b.register('.coffee', function (body) {
+    return coffee.compile(body);
+});
+````
+
+b.use(fn)
+---------
+
+Use a middleware plugin, `fn`. `fn` is called with the instance object `b`.
+
+b.prepend(content)
+------------------
+
+Prepend unwrapped content to the beginning of the bundle.
+
+b.append(content)
+-----------------
+
+Append unwrapped content to the end of the bundle.
+
+b.alias(to, from)
+-----------------
+
+Alias a package name from another package name.
+
+b.modified
+----------
+
+Contains a Date object with the time the bundle was last modified. This field is
+useful in conjunction with the `watch` field described in the `browserify()` to
+generate unique `<script>` `src` values to force script reloading.

data/node_modules/browserify/doc/recipes.markdown

@@ -0,0 +1,62 @@
+recipes
+=======
+
+Here are some recipe-style examples for getting started.
+
+use an npm module in the browser
+================================
+
+First install a module:
+
+```
+npm install traverse
+```
+
+Then write an `entry.js`:
+
+````javascript
+var traverse = require('traverse');
+var obj = traverse({ a : 3, b : [ 4, 5 ] }).map(function (x) {
+    if (typeof x === 'number') this.update(x * 100)
+});
+console.dir(obj);
+````
+
+now bundle it!
+
+```
+$ browserify entry.js -o bundle.js
+```
+
+then put it in your html
+
+``` html
+<script src="bundle.js"></script>
+```
+
+and the entry.js will just run and `require('traverse')` will just work™.
+
+convert a node module into a browser require-able standalone file
+-----------------------------------------------------------------
+
+Install the `traverse` package into `./node_modules`:
+
+```
+npm install traverse
+```
+
+Bundle everything up with browserify:
+
+```
+$ npm install -g browserify
+$ browserify -r traverse -o bundle.js
+```
+
+Look at the files! There is a new one: `bundle.js`. Now go into HTML land:
+
+``` html
+<script src="bundle.js"></script>
+<script>
+   var traverse = require('traverse');
+</script>
+```