backbone-radio-rails 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 818f7c98b75413c6b674c1dea57051012105fecd
+  data.tar.gz: 44ef6191264ce8cc4b4865f1e25029a5a3c43fa3
+SHA512:
+  metadata.gz: f6e64bc6ddfb0ca4761744f32e3243042d5728ec8b795e4bc78ce1261a58ab058fda76aa776e2c50d7dfc3145f9dfaccf06656eba6491abbcf073e5a8e5fef96
+  data.tar.gz: 14749b3ebbeefa9cd403e240542a6100c7d451971fcfa7040f0faa77bdae489d85233965aa21827604aeba7d33c52c48d08c7ea20c526f26c69cf792862d345d

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in backbone-radio-rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Alexander Schwartzberg
+
+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/README.md

@@ -0,0 +1,23 @@
+backbone-radio-rails
+=======================
+
+Rails (3.1 and up) asset wrapper for the latest version of [backbone.radio](https://github.com/marionettejs/backbone.radio) (0.9.0).
+
+# Installation
+#### Step 1: Add it to your gemfile:
+
+    gem 'backbone-radio-rails'
+
+#### Step 2: Include assets:
+
+```javascript
+// In application.js
+//= require backbone.radio
+```
+or
+```javascript
+// In application.js
+//= require backbone.radio.min
+```
+
+#####Special thanks to [Marionette.js](https://github.com/marionettejs) for their work on [backbone.radio](https://github.com/marionettejs/backbone.radio).

data/VERSION

@@ -0,0 +1 @@
+0.9.0

data/backbone-radio-rails.gemspec

@@ -0,0 +1,15 @@
+# coding: utf-8
+VERSION = File.read(File.expand_path('../VERSION', __FILE__)).strip
+
+Gem::Specification.new do |spec|
+  spec.name          = "backbone-radio-rails"
+  spec.version       = VERSION
+  spec.authors       = ["Alexander Schwartzberg"]
+  spec.email         = ["aeksco@gmail.com"]
+  spec.summary       = "Rails asset wrapper for backbone.radio"
+  spec.homepage      = "https://github.com/aeksco/backbone-radio-rails"
+  spec.license       = "MIT"
+
+  spec.files       = `git ls-files`.split("\n")
+  spec.require_paths = ["lib"]
+end

data/lib/backbone-radio-rails.rb

@@ -0,0 +1,8 @@
+module Backbone
+  module Radio
+    module Rails
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+end

data/vendor/assets/javascripts/backbone.radio.js

@@ -0,0 +1,426 @@
+// Backbone.Radio v0.9.0
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['backbone', 'underscore'], function(Backbone, _) {
+      return factory(Backbone, _);
+    });
+  }
+  else if (typeof exports !== 'undefined') {
+    var Backbone = require('backbone');
+    var _ = require('underscore');
+    module.exports = factory(Backbone, _);
+  }
+  else {
+    factory(root.Backbone, root._);
+  }
+}(this, function(Backbone, _) {
+  'use strict';
+
+  var previousRadio = Backbone.Radio;
+
+  var Radio = Backbone.Radio = {};
+
+  Radio.VERSION = '0.9.0';
+
+  // This allows you to run multiple instances of Radio on the same
+  // webapp. After loading the new version, call `noConflict()` to
+  // get a reference to it. At the same time the old version will be
+  // returned to Backbone.Radio.
+  Radio.noConflict = function () {
+    Backbone.Radio = previousRadio;
+    return this;
+  };
+
+  // Whether or not we're in DEBUG mode or not. DEBUG mode helps you
+  // get around the issues of lack of warnings when events are mis-typed.
+  Radio.DEBUG = false;
+
+  // Format debug text.
+  Radio._debugText = function(warning, eventName, channelName) {
+    return warning + (channelName ? ' on the ' + channelName + ' channel' : '') +
+      ': "' + eventName + '"';
+  };
+
+  // This is the method that's called when an unregistered event was called.
+  // By default, it logs warning to the console. By overriding this you could
+  // make it throw an Error, for instance. This would make firing a nonexistent event
+  // have the same consequence as firing a nonexistent method on an Object.
+  Radio.debugLog = function(warning, eventName, channelName) {
+    if (Radio.DEBUG && console && console.warn) {
+      console.warn(Radio._debugText(warning, eventName, channelName));
+    }
+  };
+
+  var eventSplitter = /\s+/;
+
+  // An internal method used to handle Radio's method overloading for Requests and
+  // Commands. It's borrowed from Backbone.Events. It differs from Backbone's overload
+  // API (which is used in Backbone.Events) in that it doesn't support space-separated
+  // event names.
+  Radio._eventsApi = function(obj, action, name, rest) {
+    if (!name) {
+      return false;
+    }
+
+    var results = {};
+
+    // Handle event maps.
+    if (typeof name === 'object') {
+      for (var key in name) {
+        var result = obj[action].apply(obj, [key, name[key]].concat(rest));
+        eventSplitter.test(key) ? _.extend(results, result) : results[key] = result;
+      }
+      return results;
+    }
+
+    // Handle space separated event names.
+    if (eventSplitter.test(name)) {
+      var names = name.split(eventSplitter);
+      for (var i = 0, l = names.length; i < l; i++) {
+        results[names[i]] = obj[action].apply(obj, [names[i]].concat(rest));
+      }
+      return results;
+    }
+
+    return false;
+  };
+
+  // An optimized way to execute callbacks.
+  Radio._callHandler = function(callback, context, args) {
+    var a1 = args[0], a2 = args[1], a3 = args[2];
+    switch(args.length) {
+      case 0: return callback.call(context);
+      case 1: return callback.call(context, a1);
+      case 2: return callback.call(context, a1, a2);
+      case 3: return callback.call(context, a1, a2, a3);
+      default: return callback.apply(context, args);
+    }
+  };
+
+  // A helper used by `off` methods to the handler from the store
+  function removeHandler(store, name, callback, context) {
+    var event = store[name];
+    if (
+       (!callback || (callback === event.callback || callback === event.callback._callback)) &&
+       (!context || (context === event.context))
+    ) {
+      delete store[name];
+      return true;
+    }
+  }
+
+  function removeHandlers(store, name, callback, context) {
+    store || (store = {});
+    var names = name ? [name] : _.keys(store);
+    var matched = false;
+
+    for (var i = 0, length = names.length; i < length; i++) {
+      name = names[i];
+
+      // If there's no event by this name, log it and continue
+      // with the loop
+      if (!store[name]) {
+        continue;
+      }
+
+      if (removeHandler(store, name, callback, context)) {
+        matched = true;
+      }
+    }
+
+    return matched;
+  }
+
+  /*
+   * tune-in
+   * -------
+   * Get console logs of a channel's activity
+   *
+   */
+
+  var _logs = {};
+
+  // This is to produce an identical function in both tuneIn and tuneOut,
+  // so that Backbone.Events unregisters it.
+  function _partial(channelName) {
+    return _logs[channelName] || (_logs[channelName] = _.partial(Radio.log, channelName));
+  }
+
+  _.extend(Radio, {
+
+    // Log information about the channel and event
+    log: function(channelName, eventName) {
+      var args = _.rest(arguments, 2);
+      console.log('[' + channelName + '] "' + eventName + '"', args);
+    },
+
+    // Logs all events on this channel to the console. It sets an
+    // internal value on the channel telling it we're listening,
+    // then sets a listener on the Backbone.Events
+    tuneIn: function(channelName) {
+      var channel = Radio.channel(channelName);
+      channel._tunedIn = true;
+      channel.on('all', _partial(channelName));
+      return this;
+    },
+
+    // Stop logging all of the activities on this channel to the console
+    tuneOut: function(channelName) {
+      var channel = Radio.channel(channelName);
+      channel._tunedIn = false;
+      channel.off('all', _partial(channelName));
+      delete _logs[channelName];
+      return this;
+    }
+  });
+
+  /*
+   * Backbone.Radio.Commands
+   * -----------------------
+   * A messaging system for sending orders.
+   *
+   */
+
+  Radio.Commands = {
+
+    // Issue a command
+    command: function(name) {
+      var args = _.rest(arguments);
+      if (Radio._eventsApi(this, 'command', name, args)) {
+        return this;
+      }
+      var channelName = this.channelName;
+      var commands = this._commands;
+
+      // Check if we should log the command, and if so, do it
+      if (channelName && this._tunedIn) {
+        Radio.log.apply(this, [channelName, name].concat(args));
+      }
+
+      // If the command isn't handled, log it in DEBUG mode and exit
+      if (commands && (commands[name] || commands['default'])) {
+        var handler = commands[name] || commands['default'];
+        args = commands[name] ? args : arguments;
+        Radio._callHandler(handler.callback, handler.context, args);
+      } else {
+        Radio.debugLog('An unhandled command was fired', name, channelName);
+      }
+
+      return this;
+    },
+
+    // Register a handler for a command.
+    comply: function(name, callback, context) {
+      if (Radio._eventsApi(this, 'comply', name, [callback, context])) {
+        return this;
+      }
+      this._commands || (this._commands = {});
+
+      if (this._commands[name]) {
+        Radio.debugLog('A command was overwritten', name, this.channelName);
+      }
+
+      this._commands[name] = {
+        callback: callback,
+        context: context || this
+      };
+
+      return this;
+    },
+
+    // Register a handler for a command that happens just once.
+    complyOnce: function(name, callback, context) {
+      if (Radio._eventsApi(this, 'complyOnce', name, [callback, context])) {
+        return this;
+      }
+      var self = this;
+
+      var once = _.once(function() {
+        self.stopComplying(name);
+        return callback.apply(this, arguments);
+      });
+
+      return this.comply(name, once, context);
+    },
+
+    // Remove handler(s)
+    stopComplying: function(name, callback, context) {
+      if (Radio._eventsApi(this, 'stopComplying', name)) {
+        return this;
+      }
+
+      // Remove everything if there are no arguments passed
+      if (!name && !callback && !context) {
+        delete this._commands;
+      } else if (!removeHandlers(this._commands, name, callback, context)) {
+        Radio.debugLog('Attempted to remove the unregistered command', name, this.channelName);
+      }
+
+      return this;
+    }
+  };
+
+  /*
+   * Backbone.Radio.Requests
+   * -----------------------
+   * A messaging system for requesting data.
+   *
+   */
+
+  function makeCallback(callback) {
+    return _.isFunction(callback) ? callback : function () { return callback; };
+  }
+
+  Radio.Requests = {
+
+    // Make a request
+    request: function(name) {
+      var args = _.rest(arguments);
+      var results = Radio._eventsApi(this, 'request', name, args);
+      if (results) {
+        return results;
+      }
+      var channelName = this.channelName;
+      var requests = this._requests;
+
+      // Check if we should log the request, and if so, do it
+      if (channelName && this._tunedIn) {
+        Radio.log.apply(this, [channelName, name].concat(args));
+      }
+
+      // If the request isn't handled, log it in DEBUG mode and exit
+      if (requests && (requests[name] || requests['default'])) {
+        var handler = requests[name] || requests['default'];
+        args = requests[name] ? args : arguments;
+        return Radio._callHandler(handler.callback, handler.context, args);
+      } else {
+        Radio.debugLog('An unhandled request was fired', name, channelName);
+      }
+    },
+
+    // Set up a handler for a request
+    reply: function(name, callback, context) {
+      if (Radio._eventsApi(this, 'reply', name, [callback, context])) {
+        return this;
+      }
+
+      this._requests || (this._requests = {});
+
+      if (this._requests[name]) {
+        Radio.debugLog('A request was overwritten', name, this.channelName);
+      }
+
+      this._requests[name] = {
+        callback: makeCallback(callback),
+        context: context || this
+      };
+
+      return this;
+    },
+
+    // Set up a handler that can only be requested once
+    replyOnce: function(name, callback, context) {
+      if (Radio._eventsApi(this, 'replyOnce', name, [callback, context])) {
+        return this;
+      }
+
+      var self = this;
+
+      var once = _.once(function() {
+        self.stopReplying(name);
+        return makeCallback(callback).apply(this, arguments);
+      });
+
+      return this.reply(name, once, context);
+    },
+
+    // Remove handler(s)
+    stopReplying: function(name, callback, context) {
+      if (Radio._eventsApi(this, 'stopReplying', name)) {
+        return this;
+      }
+
+      // Remove everything if there are no arguments passed
+      if (!name && !callback && !context) {
+        delete this._requests;
+      } else if (!removeHandlers(this._requests, name, callback, context)) {
+        Radio.debugLog('Attempted to remove the unregistered request', name, this.channelName);
+      }
+
+      return this;
+    }
+  };
+
+  /*
+   * Backbone.Radio.channel
+   * ----------------------
+   * Get a reference to a channel by name.
+   *
+   */
+
+  Radio._channels = {};
+
+  Radio.channel = function(channelName) {
+    if (!channelName) {
+      throw new Error('You must provide a name for the channel.');
+    }
+
+    if (Radio._channels[channelName]) {
+      return Radio._channels[channelName];
+    } else {
+      return (Radio._channels[channelName] = new Radio.Channel(channelName));
+    }
+  };
+
+  /*
+   * Backbone.Radio.Channel
+   * ----------------------
+   * A Channel is an object that extends from Backbone.Events,
+   * Radio.Commands, and Radio.Requests.
+   *
+   */
+
+  Radio.Channel = function(channelName) {
+    this.channelName = channelName;
+  };
+
+  _.extend(Radio.Channel.prototype, Backbone.Events, Radio.Commands, Radio.Requests, {
+
+    // Remove all handlers from the messaging systems of this channel
+    reset: function() {
+      this.off();
+      this.stopListening();
+      this.stopComplying();
+      this.stopReplying();
+      return this;
+    }
+  });
+
+  /*
+   * Top-level API
+   * -------------
+   * Supplies the 'top-level API' for working with Channels directly
+   * from Backbone.Radio.
+   *
+   */
+
+  var channel, args, systems = [Backbone.Events, Radio.Commands, Radio.Requests];
+
+  _.each(systems, function(system) {
+    _.each(system, function(method, methodName) {
+      Radio[methodName] = function(channelName) {
+        args = _.rest(arguments);
+        channel = this.channel(channelName);
+        return channel[methodName].apply(channel, args);
+      };
+    });
+  });
+
+  Radio.reset = function(channelName) {
+    var channels = !channelName ? this._channels : [this._channels[channelName]];
+    _.invoke(channels, 'reset');
+  };
+
+
+  return Radio;
+}));

data/vendor/assets/javascripts/backbone.radio.min.js

@@ -0,0 +1,4 @@
+// Backbone.Radio v0.9.0
+
+!function(a,b){if("function"==typeof define&&define.amd)define(["backbone","underscore"],function(a,c){return b(a,c)});else if("undefined"!=typeof exports){var c=require("backbone"),d=require("underscore");module.exports=b(c,d)}else b(a.Backbone,a._)}(this,function(a,b){"use strict";function c(a,b,c,d){var e=a[b];return c&&c!==e.callback&&c!==e.callback._callback||d&&d!==e.context?void 0:(delete a[b],!0)}function d(a,d,e,f){a||(a={});for(var g=d?[d]:b.keys(a),h=!1,i=0,j=g.length;j>i;i++)d=g[i],a[d]&&c(a,d,e,f)&&(h=!0);return h}function e(a){return j[a]||(j[a]=b.partial(h.log,a))}function f(a){return b.isFunction(a)?a:function(){return a}}var g=a.Radio,h=a.Radio={};h.VERSION="0.9.0",h.noConflict=function(){return a.Radio=g,this},h.DEBUG=!1,h._debugText=function(a,b,c){return a+(c?" on the "+c+" channel":"")+': "'+b+'"'},h.debugLog=function(a,b,c){h.DEBUG&&console&&console.warn&&console.warn(h._debugText(a,b,c))};var i=/\s+/;h._eventsApi=function(a,c,d,e){if(!d)return!1;var f={};if("object"==typeof d){for(var g in d){var h=a[c].apply(a,[g,d[g]].concat(e));i.test(g)?b.extend(f,h):f[g]=h}return f}if(i.test(d)){for(var j=d.split(i),k=0,l=j.length;l>k;k++)f[j[k]]=a[c].apply(a,[j[k]].concat(e));return f}return!1},h._callHandler=function(a,b,c){var d=c[0],e=c[1],f=c[2];switch(c.length){case 0:return a.call(b);case 1:return a.call(b,d);case 2:return a.call(b,d,e);case 3:return a.call(b,d,e,f);default:return a.apply(b,c)}};var j={};b.extend(h,{log:function(a,c){var d=b.rest(arguments,2);console.log("["+a+'] "'+c+'"',d)},tuneIn:function(a){var b=h.channel(a);return b._tunedIn=!0,b.on("all",e(a)),this},tuneOut:function(a){var b=h.channel(a);return b._tunedIn=!1,b.off("all",e(a)),delete j[a],this}}),h.Commands={command:function(a){var c=b.rest(arguments);if(h._eventsApi(this,"command",a,c))return this;var d=this.channelName,e=this._commands;if(d&&this._tunedIn&&h.log.apply(this,[d,a].concat(c)),e&&(e[a]||e["default"])){var f=e[a]||e["default"];c=e[a]?c:arguments,h._callHandler(f.callback,f.context,c)}else h.debugLog("An unhandled command was fired",a,d);return this},comply:function(a,b,c){return h._eventsApi(this,"comply",a,[b,c])?this:(this._commands||(this._commands={}),this._commands[a]&&h.debugLog("A command was overwritten",a,this.channelName),this._commands[a]={callback:b,context:c||this},this)},complyOnce:function(a,c,d){if(h._eventsApi(this,"complyOnce",a,[c,d]))return this;var e=this,f=b.once(function(){return e.stopComplying(a),c.apply(this,arguments)});return this.comply(a,f,d)},stopComplying:function(a,b,c){return h._eventsApi(this,"stopComplying",a)?this:(a||b||c?d(this._commands,a,b,c)||h.debugLog("Attempted to remove the unregistered command",a,this.channelName):delete this._commands,this)}},h.Requests={request:function(a){var c=b.rest(arguments),d=h._eventsApi(this,"request",a,c);if(d)return d;var e=this.channelName,f=this._requests;if(e&&this._tunedIn&&h.log.apply(this,[e,a].concat(c)),f&&(f[a]||f["default"])){var g=f[a]||f["default"];return c=f[a]?c:arguments,h._callHandler(g.callback,g.context,c)}h.debugLog("An unhandled request was fired",a,e)},reply:function(a,b,c){return h._eventsApi(this,"reply",a,[b,c])?this:(this._requests||(this._requests={}),this._requests[a]&&h.debugLog("A request was overwritten",a,this.channelName),this._requests[a]={callback:f(b),context:c||this},this)},replyOnce:function(a,c,d){if(h._eventsApi(this,"replyOnce",a,[c,d]))return this;var e=this,g=b.once(function(){return e.stopReplying(a),f(c).apply(this,arguments)});return this.reply(a,g,d)},stopReplying:function(a,b,c){return h._eventsApi(this,"stopReplying",a)?this:(a||b||c?d(this._requests,a,b,c)||h.debugLog("Attempted to remove the unregistered request",a,this.channelName):delete this._requests,this)}},h._channels={},h.channel=function(a){if(!a)throw new Error("You must provide a name for the channel.");return h._channels[a]?h._channels[a]:h._channels[a]=new h.Channel(a)},h.Channel=function(a){this.channelName=a},b.extend(h.Channel.prototype,a.Events,h.Commands,h.Requests,{reset:function(){return this.off(),this.stopListening(),this.stopComplying(),this.stopReplying(),this}});var k,l,m=[a.Events,h.Commands,h.Requests];return b.each(m,function(a){b.each(a,function(a,c){h[c]=function(a){return l=b.rest(arguments),k=this.channel(a),k[c].apply(k,l)}})}),h.reset=function(a){var c=a?[this._channels[a]]:this._channels;b.invoke(c,"reset")},h});
+//# sourceMappingURL=backbone.radio.min.js.map

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: backbone-radio-rails
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Alexander Schwartzberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-20 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- aeksco@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- VERSION
+- backbone-radio-rails.gemspec
+- lib/backbone-radio-rails.rb
+- vendor/assets/javascripts/backbone.radio.js
+- vendor/assets/javascripts/backbone.radio.min.js
+homepage: https://github.com/aeksco/backbone-radio-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Rails asset wrapper for backbone.radio
+test_files: []