diff --git a/app.js b/app.js index fd5b032..6bd32f0 100644 --- a/app.js +++ b/app.js @@ -1,88 +1,81 @@ // Module dependencies +const fs = require('fs') -var fs = require('fs') - , path = require('path') - , util = require('util') +const SocketServer = require('./socket-server') - , MusicLibrary = require('./musiclibrary') - , SocketServer = require('./socket-server') +const express = require('express') - , express = require('express') - -var app = module.exports = express.createServer() - , io = require('socket.io').listen(app); +const app = module.exports = express.createServer() +const io = require('socket.io').listen(app) // Configuration -app.configure(function(){ - app.set('views', __dirname + '/views'); - app.set("view options", {layout: false}); +app.configure(function () { + app.set('views', __dirname + '/views') + app.set('view options', {layout: false}) - //html rendering + // html rendering app.register('.html', { - compile: function(str, options){ - return function(locals){ - return str; - }; + compile: function (str, options) { + return function (locals) { + return str + } } - }); + }) - app.use(express.bodyParser()); - app.use(express.methodOverride()); - app.use(app.router); + app.use(express.bodyParser()) + app.use(express.methodOverride()) + app.use(app.router) app.use(express.static(__dirname + '/public')) }) -app.configure('development', function(){ +app.configure('development', function () { app.use(express.errorHandler({ dumpExceptions: true, showStack: true })) }) -app.configure('production', function(){ +app.configure('production', function () { app.use(express.errorHandler()) }) // Routes -app.get('/', function(req, res){ +app.get('/', function (req, res) { res.render('index.html', { locals: { - title: 'Streamy client' + title: 'Streamy Client' } }) }) -//Serve streaming audio - audio src points here -app.get('/stream/:song', function(req, res) { - var songPath = socketServer.musicLibrary.songs[req.params.song] - - path.exists(songPath, function (exists) { - if(!exists) { - var msg = 'File `' + songPath + '` not found' - console.log('\nSTREAMY:', msg) +// Serve streaming audio - audio src points here +app.get('/stream/:song', function (req, res) { + const songPath = socketServer.musicLibrary.songs[req.params.song] + const msg = `File '${songPath || req.params.song}' not found` + if (!songPath) return res.end(msg) + fs.exists(songPath, function (exists) { + if (!exists) { + console.log(`\nSTREAMY: ${msg}`) res.writeHead(404) - res.end(msg) - return + return res.end(msg) } - //stream song to client + // stream song to client fs.stat(songPath, function (err, stats) { - if(err) { - console.log('\nSTREAMY: stat\'ing error:', err) - res.writeHead(500) - return + if (err) { + console.log(`\nSTREAMY: stat\'ing error: ${err}`) + return res.writeHead(500) } res.writeHead(200, { 'Content-Type': 'audio/mpeg', 'Content-Length': stats.size }) - var readStream = fs.createReadStream(songPath) + const readStream = fs.createReadStream(songPath) - util.pump(readStream, res) //pump song to client + readStream.pipe(res) // pump song to client }) }) }) -var PORT = 3000 +const PORT = 3000 || process.env.PORT -app.listen(PORT) -console.log("STREAMY: listening on port", PORT) +app.listen(PORT, console.log(`STREAMY: listening on port ${PORT}`)) -var socketServer = new SocketServer(io) \ No newline at end of file +const socketServer = new SocketServer(io) diff --git a/musiclibrary.js b/musiclibrary.js index f89a806..22d7c0a 100644 --- a/musiclibrary.js +++ b/musiclibrary.js @@ -1,10 +1,10 @@ -var EventEmitter = require('events').EventEmitter - , path = require('path') - , util = require('util') +const EventEmitter = require('events').EventEmitter +const path = require('path') +const util = require('util') - , findit = require('findit') +const findit = require('findit') -var FORMATS = ['.mp3', '.m4a'] //supported formats +const FORMATS = ['.mp3', '.m4a'] // supported formats module.exports = MusicLibrary @@ -21,8 +21,8 @@ module.exports = MusicLibrary function MusicLibrary (opts) { EventEmitter.call(this) - if(!opts) opts = {} - else if(typeof opts !== 'object') throw new Error('MusicLibrary opts must be of type object') + if (!opts) opts = {} + else if (typeof opts !== 'object') throw new Error('MusicLibrary opts must be of type object') this.opts = opts this.songs = {} @@ -32,14 +32,14 @@ function MusicLibrary (opts) { util.inherits(MusicLibrary, EventEmitter) MusicLibrary.prototype.populate = function () { - var self = this - , root = this.opts.root || path.join(__dirname, '/public/music') - , finder = findit.find(root) - + const self = this + const root = this.opts.root || path.join(__dirname, '/public/music') + const finder = findit.find(root) + // cache music library for socket connections - finder.on('file', function(fpath, stat) { + finder.on('file', function (fpath, stat) { var ext = path.extname(fpath) - if(FORMATS.indexOf(ext) !== -1 && stat.size) { + if (FORMATS.indexOf(ext) !== -1 && stat.size) { var songTitle = path.basename(fpath, ext) self.songs[songTitle] = fpath @@ -49,4 +49,4 @@ MusicLibrary.prototype.populate = function () { finder.on('end', function () { self.emit('ready') }) -} \ No newline at end of file +} diff --git a/public/javascripts/backbone.js b/public/javascripts/backbone.js index b2e4932..1e1ba37 100644 --- a/public/javascripts/backbone.js +++ b/public/javascripts/backbone.js @@ -4,53 +4,52 @@ // For all details and documentation: // http://documentcloud.github.com/backbone -(function(){ - +(function () { // Initial Setup // ------------- // Save a reference to the global object. - var root = this; + var root = this // Save the previous value of the `Backbone` variable. - var previousBackbone = root.Backbone; + var previousBackbone = root.Backbone // The top-level namespace. All public Backbone classes and modules will // be attached to this. Exported for both CommonJS and the browser. - var Backbone; + var Backbone if (typeof exports !== 'undefined') { - Backbone = exports; + Backbone = exports } else { - Backbone = root.Backbone = {}; + Backbone = root.Backbone = {} } // Current version of the library. Keep in sync with `package.json`. - Backbone.VERSION = '0.5.3'; + Backbone.VERSION = '0.5.3' // Require Underscore, if we're on the server, and it's not already present. - var _ = root._; - if (!_ && (typeof require !== 'undefined')) _ = require('underscore')._; + var _ = root._ + if (!_ && (typeof require !== 'undefined')) _ = require('underscore')._ // For Backbone's purposes, jQuery or Zepto owns the `$` variable. - var $ = root.jQuery || root.Zepto; + var $ = root.jQuery || root.Zepto // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable // to its previous owner. Returns a reference to this Backbone object. - Backbone.noConflict = function() { - root.Backbone = previousBackbone; - return this; - }; + Backbone.noConflict = function () { + root.Backbone = previousBackbone + return this + } // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option will // fake `"PUT"` and `"DELETE"` requests via the `_method` parameter and set a // `X-Http-Method-Override` header. - Backbone.emulateHTTP = false; + Backbone.emulateHTTP = false // Turn on `emulateJSON` to support legacy servers that can't deal with direct // `application/json` requests ... will encode the body as // `application/x-www-form-urlencoded` instead and will send the model in a // form param named `model`. - Backbone.emulateJSON = false; + Backbone.emulateJSON = false // Backbone.Events // ----------------- @@ -68,345 +67,344 @@ // Bind an event, specified by a string name, `ev`, to a `callback` function. // Passing `"all"` will bind the callback to all events fired. - bind : function(ev, callback, context) { - var calls = this._callbacks || (this._callbacks = {}); - var list = calls[ev] || (calls[ev] = []); - list.push([callback, context]); - return this; + bind: function (ev, callback, context) { + var calls = this._callbacks || (this._callbacks = {}) + var list = calls[ev] || (calls[ev] = []) + list.push([callback, context]) + return this }, // Remove one or many callbacks. If `callback` is null, removes all // callbacks for the event. If `ev` is null, removes all bound callbacks // for all events. - unbind : function(ev, callback) { - var calls; + unbind: function (ev, callback) { + var calls if (!ev) { - this._callbacks = {}; + this._callbacks = {} } else if (calls = this._callbacks) { if (!callback) { - calls[ev] = []; + calls[ev] = [] } else { - var list = calls[ev]; - if (!list) return this; + var list = calls[ev] + if (!list) return this for (var i = 0, l = list.length; i < l; i++) { if (list[i] && callback === list[i][0]) { - list[i] = null; - break; + list[i] = null + break } } } } - return this; + return this }, // Trigger an event, firing all bound callbacks. Callbacks are passed the // same arguments as `trigger` is, apart from the event name. // Listening for `"all"` passes the true event name as the first argument. - trigger : function(eventName) { - var list, calls, ev, callback, args; - var both = 2; - if (!(calls = this._callbacks)) return this; + trigger: function (eventName) { + var list, calls, ev, callback, args + var both = 2 + if (!(calls = this._callbacks)) return this while (both--) { - ev = both ? eventName : 'all'; + ev = both ? eventName : 'all' if (list = calls[ev]) { for (var i = 0, l = list.length; i < l; i++) { if (!(callback = list[i])) { - list.splice(i, 1); i--; l--; + list.splice(i, 1); i--; l-- } else { - args = both ? Array.prototype.slice.call(arguments, 1) : arguments; - callback[0].apply(callback[1] || this, args); + args = both ? Array.prototype.slice.call(arguments, 1) : arguments + callback[0].apply(callback[1] || this, args) } } } } - return this; + return this } - }; + } // Backbone.Model // -------------- // Create a new model, with defined attributes. A client id (`cid`) // is automatically generated and assigned for you. - Backbone.Model = function(attributes, options) { - var defaults; - attributes || (attributes = {}); + Backbone.Model = function (attributes, options) { + var defaults + attributes || (attributes = {}) if (defaults = this.defaults) { - if (_.isFunction(defaults)) defaults = defaults.call(this); - attributes = _.extend({}, defaults, attributes); + if (_.isFunction(defaults)) defaults = defaults.call(this) + attributes = _.extend({}, defaults, attributes) } - this.attributes = {}; - this._escapedAttributes = {}; - this.cid = _.uniqueId('c'); - this.set(attributes, {silent : true}); - this._changed = false; - this._previousAttributes = _.clone(this.attributes); - if (options && options.collection) this.collection = options.collection; - this.initialize(attributes, options); - }; + this.attributes = {} + this._escapedAttributes = {} + this.cid = _.uniqueId('c') + this.set(attributes, {silent: true}) + this._changed = false + this._previousAttributes = _.clone(this.attributes) + if (options && options.collection) this.collection = options.collection + this.initialize(attributes, options) + } // Attach all inheritable methods to the Model prototype. _.extend(Backbone.Model.prototype, Backbone.Events, { // A snapshot of the model's previous attributes, taken immediately // after the last `"change"` event was fired. - _previousAttributes : null, + _previousAttributes: null, // Has the item been changed since the last `"change"` event? - _changed : false, + _changed: false, // The default name for the JSON `id` attribute is `"id"`. MongoDB and // CouchDB users may want to set this to `"_id"`. - idAttribute : 'id', + idAttribute: 'id', // Initialize is an empty function by default. Override it with your own // initialization logic. - initialize : function(){}, + initialize: function () {}, // Return a copy of the model's `attributes` object. - toJSON : function() { - return _.clone(this.attributes); + toJSON: function () { + return _.clone(this.attributes) }, // Get the value of an attribute. - get : function(attr) { - return this.attributes[attr]; + get: function (attr) { + return this.attributes[attr] }, // Get the HTML-escaped value of an attribute. - escape : function(attr) { - var html; - if (html = this._escapedAttributes[attr]) return html; - var val = this.attributes[attr]; - return this._escapedAttributes[attr] = escapeHTML(val == null ? '' : '' + val); + escape: function (attr) { + var html + if (html = this._escapedAttributes[attr]) return html + var val = this.attributes[attr] + return this._escapedAttributes[attr] = escapeHTML(val == null ? '' : '' + val) }, // Returns `true` if the attribute contains a value that is not null // or undefined. - has : function(attr) { - return this.attributes[attr] != null; + has: function (attr) { + return this.attributes[attr] != null }, // Set a hash of model attributes on the object, firing `"change"` unless you // choose to silence it. - set : function(attrs, options) { - + set: function (attrs, options) { // Extract attributes and options. - options || (options = {}); - if (!attrs) return this; - if (attrs.attributes) attrs = attrs.attributes; - var now = this.attributes, escaped = this._escapedAttributes; + options || (options = {}) + if (!attrs) return this + if (attrs.attributes) attrs = attrs.attributes + var now = this.attributes, escaped = this._escapedAttributes // Run validation. - if (!options.silent && this.validate && !this._performValidation(attrs, options)) return false; + if (!options.silent && this.validate && !this._performValidation(attrs, options)) return false // Check for changes of `id`. - if (this.idAttribute in attrs) this.id = attrs[this.idAttribute]; + if (this.idAttribute in attrs) this.id = attrs[this.idAttribute] // We're about to start triggering change events. - var alreadyChanging = this._changing; - this._changing = true; + var alreadyChanging = this._changing + this._changing = true // Update attributes. for (var attr in attrs) { - var val = attrs[attr]; + var val = attrs[attr] if (!_.isEqual(now[attr], val)) { - now[attr] = val; - delete escaped[attr]; - this._changed = true; - if (!options.silent) this.trigger('change:' + attr, this, val, options); + now[attr] = val + delete escaped[attr] + this._changed = true + if (!options.silent) this.trigger('change:' + attr, this, val, options) } } // Fire the `"change"` event, if the model has been changed. - if (!alreadyChanging && !options.silent && this._changed) this.change(options); - this._changing = false; - return this; + if (!alreadyChanging && !options.silent && this._changed) this.change(options) + this._changing = false + return this }, // Remove an attribute from the model, firing `"change"` unless you choose // to silence it. `unset` is a noop if the attribute doesn't exist. - unset : function(attr, options) { - if (!(attr in this.attributes)) return this; - options || (options = {}); - var value = this.attributes[attr]; + unset: function (attr, options) { + if (!(attr in this.attributes)) return this + options || (options = {}) + var value = this.attributes[attr] // Run validation. - var validObj = {}; - validObj[attr] = void 0; - if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false; + var validObj = {} + validObj[attr] = void 0 + if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false // Remove the attribute. - delete this.attributes[attr]; - delete this._escapedAttributes[attr]; - if (attr == this.idAttribute) delete this.id; - this._changed = true; + delete this.attributes[attr] + delete this._escapedAttributes[attr] + if (attr == this.idAttribute) delete this.id + this._changed = true if (!options.silent) { - this.trigger('change:' + attr, this, void 0, options); - this.change(options); + this.trigger('change:' + attr, this, void 0, options) + this.change(options) } - return this; + return this }, // Clear all attributes on the model, firing `"change"` unless you choose // to silence it. - clear : function(options) { - options || (options = {}); - var attr; - var old = this.attributes; + clear: function (options) { + options || (options = {}) + var attr + var old = this.attributes // Run validation. - var validObj = {}; - for (attr in old) validObj[attr] = void 0; - if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false; + var validObj = {} + for (attr in old) validObj[attr] = void 0 + if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false - this.attributes = {}; - this._escapedAttributes = {}; - this._changed = true; + this.attributes = {} + this._escapedAttributes = {} + this._changed = true if (!options.silent) { for (attr in old) { - this.trigger('change:' + attr, this, void 0, options); + this.trigger('change:' + attr, this, void 0, options) } - this.change(options); + this.change(options) } - return this; + return this }, // Fetch the model from the server. If the server's representation of the // model differs from its current attributes, they will be overriden, // triggering a `"change"` event. - fetch : function(options) { - options || (options = {}); - var model = this; - var success = options.success; - options.success = function(resp, status, xhr) { - if (!model.set(model.parse(resp, xhr), options)) return false; - if (success) success(model, resp); - }; - options.error = wrapError(options.error, model, options); - return (this.sync || Backbone.sync).call(this, 'read', this, options); + fetch: function (options) { + options || (options = {}) + var model = this + var success = options.success + options.success = function (resp, status, xhr) { + if (!model.set(model.parse(resp, xhr), options)) return false + if (success) success(model, resp) + } + options.error = wrapError(options.error, model, options) + return (this.sync || Backbone.sync).call(this, 'read', this, options) }, // Set a hash of model attributes, and sync the model to the server. // If the server returns an attributes hash that differs, the model's // state will be `set` again. - save : function(attrs, options) { - options || (options = {}); - if (attrs && !this.set(attrs, options)) return false; - var model = this; - var success = options.success; - options.success = function(resp, status, xhr) { - if (!model.set(model.parse(resp, xhr), options)) return false; - if (success) success(model, resp, xhr); - }; - options.error = wrapError(options.error, model, options); - var method = this.isNew() ? 'create' : 'update'; - return (this.sync || Backbone.sync).call(this, method, this, options); + save: function (attrs, options) { + options || (options = {}) + if (attrs && !this.set(attrs, options)) return false + var model = this + var success = options.success + options.success = function (resp, status, xhr) { + if (!model.set(model.parse(resp, xhr), options)) return false + if (success) success(model, resp, xhr) + } + options.error = wrapError(options.error, model, options) + var method = this.isNew() ? 'create' : 'update' + return (this.sync || Backbone.sync).call(this, method, this, options) }, // Destroy this model on the server if it was already persisted. Upon success, the model is removed // from its collection, if it has one. - destroy : function(options) { - options || (options = {}); - if (this.isNew()) return this.trigger('destroy', this, this.collection, options); - var model = this; - var success = options.success; - options.success = function(resp) { - model.trigger('destroy', model, model.collection, options); - if (success) success(model, resp); - }; - options.error = wrapError(options.error, model, options); - return (this.sync || Backbone.sync).call(this, 'delete', this, options); + destroy: function (options) { + options || (options = {}) + if (this.isNew()) return this.trigger('destroy', this, this.collection, options) + var model = this + var success = options.success + options.success = function (resp) { + model.trigger('destroy', model, model.collection, options) + if (success) success(model, resp) + } + options.error = wrapError(options.error, model, options) + return (this.sync || Backbone.sync).call(this, 'delete', this, options) }, // Default URL for the model's representation on the server -- if you're // using Backbone's restful methods, override this to change the endpoint // that will be called. - url : function() { - var base = getUrl(this.collection) || this.urlRoot || urlError(); - if (this.isNew()) return base; - return base + (base.charAt(base.length - 1) == '/' ? '' : '/') + encodeURIComponent(this.id); + url: function () { + var base = getUrl(this.collection) || this.urlRoot || urlError() + if (this.isNew()) return base + return base + (base.charAt(base.length - 1) == '/' ? '' : '/') + encodeURIComponent(this.id) }, // **parse** converts a response into the hash of attributes to be `set` on // the model. The default implementation is just to pass the response along. - parse : function(resp, xhr) { - return resp; + parse: function (resp, xhr) { + return resp }, // Create a new model with identical attributes to this one. - clone : function() { - return new this.constructor(this); + clone: function () { + return new this.constructor(this) }, // A model is new if it has never been saved to the server, and lacks an id. - isNew : function() { - return this.id == null; + isNew: function () { + return this.id == null }, // Call this method to manually fire a `change` event for this model. // Calling this will cause all objects observing the model to update. - change : function(options) { - this.trigger('change', this, options); - this._previousAttributes = _.clone(this.attributes); - this._changed = false; + change: function (options) { + this.trigger('change', this, options) + this._previousAttributes = _.clone(this.attributes) + this._changed = false }, // Determine if the model has changed since the last `"change"` event. // If you specify an attribute name, determine if that attribute has changed. - hasChanged : function(attr) { - if (attr) return this._previousAttributes[attr] != this.attributes[attr]; - return this._changed; + hasChanged: function (attr) { + if (attr) return this._previousAttributes[attr] != this.attributes[attr] + return this._changed }, // Return an object containing all the attributes that have changed, or false // if there are no changed attributes. Useful for determining what parts of a // view need to be updated and/or what attributes need to be persisted to // the server. - changedAttributes : function(now) { - now || (now = this.attributes); - var old = this._previousAttributes; - var changed = false; + changedAttributes: function (now) { + now || (now = this.attributes) + var old = this._previousAttributes + var changed = false for (var attr in now) { if (!_.isEqual(old[attr], now[attr])) { - changed = changed || {}; - changed[attr] = now[attr]; + changed = changed || {} + changed[attr] = now[attr] } } - return changed; + return changed }, // Get the previous value of an attribute, recorded at the time the last // `"change"` event was fired. - previous : function(attr) { - if (!attr || !this._previousAttributes) return null; - return this._previousAttributes[attr]; + previous: function (attr) { + if (!attr || !this._previousAttributes) return null + return this._previousAttributes[attr] }, // Get all of the attributes of the model at the time of the previous // `"change"` event. - previousAttributes : function() { - return _.clone(this._previousAttributes); + previousAttributes: function () { + return _.clone(this._previousAttributes) }, // Run validation against a set of incoming attributes, returning `true` // if all is well. If a specific `error` callback has been passed, // call that instead of firing the general `"error"` event. - _performValidation : function(attrs, options) { - var error = this.validate(attrs); + _performValidation: function (attrs, options) { + var error = this.validate(attrs) if (error) { if (options.error) { - options.error(this, error, options); + options.error(this, error, options) } else { - this.trigger('error', this, error, options); + this.trigger('error', this, error, options) } - return false; + return false } - return true; + return true } - }); + }) // Backbone.Collection // ------------------- @@ -414,266 +412,266 @@ // Provides a standard collection class for our sets of models, ordered // or unordered. If a `comparator` is specified, the Collection will maintain // its models in sort order, as they're added and removed. - Backbone.Collection = function(models, options) { - options || (options = {}); - if (options.comparator) this.comparator = options.comparator; - _.bindAll(this, '_onModelEvent', '_removeReference'); - this._reset(); - if (models) this.reset(models, {silent: true}); - this.initialize.apply(this, arguments); - }; + Backbone.Collection = function (models, options) { + options || (options = {}) + if (options.comparator) this.comparator = options.comparator + _.bindAll(this, '_onModelEvent', '_removeReference') + this._reset() + if (models) this.reset(models, {silent: true}) + this.initialize.apply(this, arguments) + } // Define the Collection's inheritable methods. _.extend(Backbone.Collection.prototype, Backbone.Events, { // The default model for a collection is just a **Backbone.Model**. // This should be overridden in most cases. - model : Backbone.Model, + model: Backbone.Model, // Initialize is an empty function by default. Override it with your own // initialization logic. - initialize : function(){}, + initialize: function () {}, // The JSON representation of a Collection is an array of the // models' attributes. - toJSON : function() { - return this.map(function(model){ return model.toJSON(); }); + toJSON: function () { + return this.map(function (model) { return model.toJSON() }) }, // Add a model, or list of models to the set. Pass **silent** to avoid // firing the `added` event for every new model. - add : function(models, options) { + add: function (models, options) { if (_.isArray(models)) { for (var i = 0, l = models.length; i < l; i++) { - this._add(models[i], options); + this._add(models[i], options) } } else { - this._add(models, options); + this._add(models, options) } - return this; + return this }, // Remove a model, or a list of models from the set. Pass silent to avoid // firing the `removed` event for every model removed. - remove : function(models, options) { + remove: function (models, options) { if (_.isArray(models)) { for (var i = 0, l = models.length; i < l; i++) { - this._remove(models[i], options); + this._remove(models[i], options) } } else { - this._remove(models, options); + this._remove(models, options) } - return this; + return this }, // Get a model from the set by id. - get : function(id) { - if (id == null) return null; - return this._byId[id.id != null ? id.id : id]; + get: function (id) { + if (id == null) return null + return this._byId[id.id != null ? id.id : id] }, // Get a model from the set by client id. - getByCid : function(cid) { - return cid && this._byCid[cid.cid || cid]; + getByCid: function (cid) { + return cid && this._byCid[cid.cid || cid] }, // Get the model at the given index. - at: function(index) { - return this.models[index]; + at: function (index) { + return this.models[index] }, // Force the collection to re-sort itself. You don't need to call this under normal // circumstances, as the set will maintain sort order as each item is added. - sort : function(options) { - options || (options = {}); - if (!this.comparator) throw new Error('Cannot sort a set without a comparator'); - this.models = this.sortBy(this.comparator); - if (!options.silent) this.trigger('reset', this, options); - return this; + sort: function (options) { + options || (options = {}) + if (!this.comparator) throw new Error('Cannot sort a set without a comparator') + this.models = this.sortBy(this.comparator) + if (!options.silent) this.trigger('reset', this, options) + return this }, // Pluck an attribute from each model in the collection. - pluck : function(attr) { - return _.map(this.models, function(model){ return model.get(attr); }); + pluck: function (attr) { + return _.map(this.models, function (model) { return model.get(attr) }) }, // When you have more items than you want to add or remove individually, // you can reset the entire set with a new list of models, without firing // any `added` or `removed` events. Fires `reset` when finished. - reset : function(models, options) { - models || (models = []); - options || (options = {}); - this.each(this._removeReference); - this._reset(); - this.add(models, {silent: true}); - if (!options.silent) this.trigger('reset', this, options); - return this; + reset: function (models, options) { + models || (models = []) + options || (options = {}) + this.each(this._removeReference) + this._reset() + this.add(models, {silent: true}) + if (!options.silent) this.trigger('reset', this, options) + return this }, // Fetch the default set of models for this collection, resetting the // collection when they arrive. If `add: true` is passed, appends the // models to the collection instead of resetting. - fetch : function(options) { - options || (options = {}); - var collection = this; - var success = options.success; - options.success = function(resp, status, xhr) { - collection[options.add ? 'add' : 'reset'](collection.parse(resp, xhr), options); - if (success) success(collection, resp); - }; - options.error = wrapError(options.error, collection, options); - return (this.sync || Backbone.sync).call(this, 'read', this, options); + fetch: function (options) { + options || (options = {}) + var collection = this + var success = options.success + options.success = function (resp, status, xhr) { + collection[options.add ? 'add' : 'reset'](collection.parse(resp, xhr), options) + if (success) success(collection, resp) + } + options.error = wrapError(options.error, collection, options) + return (this.sync || Backbone.sync).call(this, 'read', this, options) }, // Create a new instance of a model in this collection. After the model // has been created on the server, it will be added to the collection. // Returns the model, or 'false' if validation on a new model fails. - create : function(model, options) { - var coll = this; - options || (options = {}); - model = this._prepareModel(model, options); - if (!model) return false; - var success = options.success; - options.success = function(nextModel, resp, xhr) { - coll.add(nextModel, options); - if (success) success(nextModel, resp, xhr); - }; - model.save(null, options); - return model; + create: function (model, options) { + var coll = this + options || (options = {}) + model = this._prepareModel(model, options) + if (!model) return false + var success = options.success + options.success = function (nextModel, resp, xhr) { + coll.add(nextModel, options) + if (success) success(nextModel, resp, xhr) + } + model.save(null, options) + return model }, // **parse** converts a response into a list of models to be added to the // collection. The default implementation is just to pass it through. - parse : function(resp, xhr) { - return resp; + parse: function (resp, xhr) { + return resp }, // Proxy to _'s chain. Can't be proxied the same way the rest of the // underscore methods are proxied because it relies on the underscore // constructor. chain: function () { - return _(this.models).chain(); + return _(this.models).chain() }, // Reset all internal state. Called when the collection is reset. - _reset : function(options) { - this.length = 0; - this.models = []; - this._byId = {}; - this._byCid = {}; + _reset: function (options) { + this.length = 0 + this.models = [] + this._byId = {} + this._byCid = {} }, // Prepare a model to be added to this collection - _prepareModel: function(model, options) { + _prepareModel: function (model, options) { if (!(model instanceof Backbone.Model)) { - var attrs = model; - model = new this.model(attrs, {collection: this}); - if (model.validate && !model._performValidation(attrs, options)) model = false; + var attrs = model + model = new this.model(attrs, {collection: this}) + if (model.validate && !model._performValidation(attrs, options)) model = false } else if (!model.collection) { - model.collection = this; + model.collection = this } - return model; + return model }, // Internal implementation of adding a single model to the set, updating // hash indexes for `id` and `cid` lookups. // Returns the model, or 'false' if validation on a new model fails. - _add : function(model, options) { - options || (options = {}); - model = this._prepareModel(model, options); - if (!model) return false; - var already = this.getByCid(model); - if (already) throw new Error(["Can't add the same model to a set twice", already.id]); - this._byId[model.id] = model; - this._byCid[model.cid] = model; + _add: function (model, options) { + options || (options = {}) + model = this._prepareModel(model, options) + if (!model) return false + var already = this.getByCid(model) + if (already) throw new Error(["Can't add the same model to a set twice", already.id]) + this._byId[model.id] = model + this._byCid[model.cid] = model var index = options.at != null ? options.at : this.comparator ? this.sortedIndex(model, this.comparator) : - this.length; - this.models.splice(index, 0, model); - model.bind('all', this._onModelEvent); - this.length++; - if (!options.silent) model.trigger('add', model, this, options); - return model; + this.length + this.models.splice(index, 0, model) + model.bind('all', this._onModelEvent) + this.length++ + if (!options.silent) model.trigger('add', model, this, options) + return model }, // Internal implementation of removing a single model from the set, updating // hash indexes for `id` and `cid` lookups. - _remove : function(model, options) { - options || (options = {}); - model = this.getByCid(model) || this.get(model); - if (!model) return null; - delete this._byId[model.id]; - delete this._byCid[model.cid]; - this.models.splice(this.indexOf(model), 1); - this.length--; - if (!options.silent) model.trigger('remove', model, this, options); - this._removeReference(model); - return model; + _remove: function (model, options) { + options || (options = {}) + model = this.getByCid(model) || this.get(model) + if (!model) return null + delete this._byId[model.id] + delete this._byCid[model.cid] + this.models.splice(this.indexOf(model), 1) + this.length-- + if (!options.silent) model.trigger('remove', model, this, options) + this._removeReference(model) + return model }, // Internal method to remove a model's ties to a collection. - _removeReference : function(model) { + _removeReference: function (model) { if (this == model.collection) { - delete model.collection; + delete model.collection } - model.unbind('all', this._onModelEvent); + model.unbind('all', this._onModelEvent) }, // Internal method called every time a model in the set fires an event. // Sets need to update their indexes when models change ids. All other // events simply proxy through. "add" and "remove" events that originate // in other collections are ignored. - _onModelEvent : function(ev, model, collection, options) { - if ((ev == 'add' || ev == 'remove') && collection != this) return; + _onModelEvent: function (ev, model, collection, options) { + if ((ev == 'add' || ev == 'remove') && collection != this) return if (ev == 'destroy') { - this._remove(model, options); + this._remove(model, options) } if (model && ev === 'change:' + model.idAttribute) { - delete this._byId[model.previous(model.idAttribute)]; - this._byId[model.id] = model; + delete this._byId[model.previous(model.idAttribute)] + this._byId[model.id] = model } - this.trigger.apply(this, arguments); + this.trigger.apply(this, arguments) } - }); + }) // Underscore methods that we want to implement on the Collection. var methods = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'find', 'detect', 'filter', 'select', 'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke', 'max', 'min', 'sortBy', 'sortedIndex', 'toArray', 'size', - 'first', 'rest', 'last', 'without', 'indexOf', 'lastIndexOf', 'isEmpty', 'groupBy']; + 'first', 'rest', 'last', 'without', 'indexOf', 'lastIndexOf', 'isEmpty', 'groupBy'] // Mix in each Underscore method as a proxy to `Collection#models`. - _.each(methods, function(method) { - Backbone.Collection.prototype[method] = function() { - return _[method].apply(_, [this.models].concat(_.toArray(arguments))); - }; - }); + _.each(methods, function (method) { + Backbone.Collection.prototype[method] = function () { + return _[method].apply(_, [this.models].concat(_.toArray(arguments))) + } + }) // Backbone.Router // ------------------- // Routers map faux-URLs to actions, and fire events when routes are // matched. Creating a new one sets its `routes` hash, if not set statically. - Backbone.Router = function(options) { - options || (options = {}); - if (options.routes) this.routes = options.routes; - this._bindRoutes(); - this.initialize.apply(this, arguments); - }; + Backbone.Router = function (options) { + options || (options = {}) + if (options.routes) this.routes = options.routes + this._bindRoutes() + this.initialize.apply(this, arguments) + } // Cached regular expressions for matching named param parts and splatted // parts of route strings. - var namedParam = /:([\w\d]+)/g; - var splatParam = /\*([\w\d]+)/g; - var escapeRegExp = /[-[\]{}()+?.,\\^$|#\s]/g; + var namedParam = /:([\w\d]+)/g + var splatParam = /\*([\w\d]+)/g + var escapeRegExp = /[-[\]{}()+?.,\\^$|#\s]/g // Set up all inheritable **Backbone.Router** properties and methods. _.extend(Backbone.Router.prototype, Backbone.Events, { // Initialize is an empty function by default. Override it with your own // initialization logic. - initialize : function(){}, + initialize: function () {}, // Manually bind a single named route to a callback. For example: // @@ -681,70 +679,70 @@ // ... // }); // - route : function(route, name, callback) { - Backbone.history || (Backbone.history = new Backbone.History); - if (!_.isRegExp(route)) route = this._routeToRegExp(route); - Backbone.history.route(route, _.bind(function(fragment) { - var args = this._extractParameters(route, fragment); - callback.apply(this, args); - this.trigger.apply(this, ['route:' + name].concat(args)); - }, this)); + route: function (route, name, callback) { + Backbone.history || (Backbone.history = new Backbone.History()) + if (!_.isRegExp(route)) route = this._routeToRegExp(route) + Backbone.history.route(route, _.bind(function (fragment) { + var args = this._extractParameters(route, fragment) + callback.apply(this, args) + this.trigger.apply(this, ['route:' + name].concat(args)) + }, this)) }, // Simple proxy to `Backbone.history` to save a fragment into the history. - navigate : function(fragment, triggerRoute) { - Backbone.history.navigate(fragment, triggerRoute); + navigate: function (fragment, triggerRoute) { + Backbone.history.navigate(fragment, triggerRoute) }, // Bind all defined routes to `Backbone.history`. We have to reverse the // order of the routes here to support behavior where the most general // routes can be defined at the bottom of the route map. - _bindRoutes : function() { - if (!this.routes) return; - var routes = []; + _bindRoutes: function () { + if (!this.routes) return + var routes = [] for (var route in this.routes) { - routes.unshift([route, this.routes[route]]); + routes.unshift([route, this.routes[route]]) } for (var i = 0, l = routes.length; i < l; i++) { - this.route(routes[i][0], routes[i][1], this[routes[i][1]]); + this.route(routes[i][0], routes[i][1], this[routes[i][1]]) } }, // Convert a route string into a regular expression, suitable for matching // against the current location hash. - _routeToRegExp : function(route) { - route = route.replace(escapeRegExp, "\\$&") - .replace(namedParam, "([^\/]*)") - .replace(splatParam, "(.*?)"); - return new RegExp('^' + route + '$'); + _routeToRegExp: function (route) { + route = route.replace(escapeRegExp, '\\$&') + .replace(namedParam, '([^\/]*)') + .replace(splatParam, '(.*?)') + return new RegExp('^' + route + '$') }, // Given a route, and a URL fragment that it matches, return the array of // extracted parameters. - _extractParameters : function(route, fragment) { - return route.exec(fragment).slice(1); + _extractParameters: function (route, fragment) { + return route.exec(fragment).slice(1) } - }); + }) // Backbone.History // ---------------- // Handles cross-browser history management, based on URL fragments. If the // browser does not support `onhashchange`, falls back to polling. - Backbone.History = function() { - this.handlers = []; - _.bindAll(this, 'checkUrl'); - }; + Backbone.History = function () { + this.handlers = [] + _.bindAll(this, 'checkUrl') + } // Cached regex for cleaning hashes. - var hashStrip = /^#*/; + var hashStrip = /^#*/ // Cached regex for detecting MSIE. - var isExplorer = /msie [\w.]+/; + var isExplorer = /msie [\w.]+/ // Has the history handling already been started? - var historyStarted = false; + var historyStarted = false // Set up all inheritable **Backbone.History** properties and methods. _.extend(Backbone.History.prototype, { @@ -755,173 +753,172 @@ // Get the cross-browser normalized URL fragment, either from the URL, // the hash, or the override. - getFragment : function(fragment, forcePushState) { + getFragment: function (fragment, forcePushState) { if (fragment == null) { if (this._hasPushState || forcePushState) { - fragment = window.location.pathname; - var search = window.location.search; - if (search) fragment += search; - if (fragment.indexOf(this.options.root) == 0) fragment = fragment.substr(this.options.root.length); + fragment = window.location.pathname + var search = window.location.search + if (search) fragment += search + if (fragment.indexOf(this.options.root) == 0) fragment = fragment.substr(this.options.root.length) } else { - fragment = window.location.hash; + fragment = window.location.hash } } - return decodeURIComponent(fragment.replace(hashStrip, '')); + return decodeURIComponent(fragment.replace(hashStrip, '')) }, // Start the hash change handling, returning `true` if the current URL matches // an existing route, and `false` otherwise. - start : function(options) { - + start: function (options) { // Figure out the initial configuration. Do we need an iframe? // Is pushState desired ... is it available? - if (historyStarted) throw new Error("Backbone.history has already been started"); - this.options = _.extend({}, {root: '/'}, this.options, options); - this._wantsPushState = !!this.options.pushState; - this._hasPushState = !!(this.options.pushState && window.history && window.history.pushState); - var fragment = this.getFragment(); - var docMode = document.documentMode; - var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7)); + if (historyStarted) throw new Error('Backbone.history has already been started') + this.options = _.extend({}, {root: '/'}, this.options, options) + this._wantsPushState = !!this.options.pushState + this._hasPushState = !!(this.options.pushState && window.history && window.history.pushState) + var fragment = this.getFragment() + var docMode = document.documentMode + var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7)) if (oldIE) { - this.iframe = $('