pusher-fake 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a0baacfdc962376a761f7cae9a985206c7f342b
-  data.tar.gz: 3437e5854d08159a3bcb9ca3444330e359dfc973
+  metadata.gz: 39d56e9bb6902ed10adbe4bca8166649d40749fc
+  data.tar.gz: 5a8e70714a86266a036d0a56c31564fbf8972dd2
 SHA512:
-  metadata.gz: 87dd985dcb991ca210d6b8a6fa84f45b869fee5c4898cf4810f925fd71c1c45d02148928e1e3c5b1ceebef94deaf0959312b05fc5777366c4da1b0f7c649cda8
-  data.tar.gz: 91110daa9de7f58e8888672b6ac86fda72802083fc504d92dbb662900d9a97ac9b73087a8c47a265942da6923ee380b29acbebf185d5f6f31fbd8ee1c2a1c63e
+  metadata.gz: 31ab418c7631fb803180cef6bca7eddac1ba06b5dc64be52cd35033412404b6e328cf631c962e11a1a8fe8f5a613dc7fa80d834004b2a0df6f3d4ea0eb62149e
+  data.tar.gz: bac0c88bd45616f6dc8ef8a829d2fe4682be67879778c95786aca8cc77e4175679c578bbf958b13cf64e064fc059a4a7ac56d4c55963f10ee014997b7141f22d

data/features/support/application/public/javascripts/vendor/{pusher-2.0.5.js → pusher-2.1.2.js}

@@ -1,5 +1,5 @@
 /*!
- * Pusher JavaScript Library v2.0.5
+ * Pusher JavaScript Library v2.1.2
  * http://pusherapp.com/
  *
  * Copyright 2013, Pusher
@@ -8,70 +8,75 @@
 
 ;(function() {
   function Pusher(app_key, options) {
+    checkAppKey(app_key);
+    options = options || {};
+
     var self = this;
 
-    this.options = options || {};
     this.key = app_key;
+    this.config = Pusher.Util.extend(
+      Pusher.getGlobalConfig(),
+      options.cluster ? Pusher.getClusterConfig(options.cluster) : {},
+      options
+    );
+
     this.channels = new Pusher.Channels();
     this.global_emitter = new Pusher.EventsDispatcher();
     this.sessionID = Math.floor(Math.random() * 1000000000);
 
-    checkAppKey(this.key);
+    this.timeline = new Pusher.Timeline(this.key, this.sessionID, {
+      features: Pusher.Util.getClientFeatures(),
+      params: this.config.timelineParams || {},
+      limit: 50,
+      level: Pusher.Timeline.INFO,
+      version: Pusher.VERSION
+    });
+    if (!this.config.disableStats) {
+      this.timelineSender = new Pusher.TimelineSender(this.timeline, {
+        host: this.config.statsHost,
+        path: "/timeline"
+      });
+    }
 
     var getStrategy = function(options) {
       return Pusher.StrategyBuilder.build(
-        Pusher.getDefaultStrategy(),
-        Pusher.Util.extend({}, self.options, options)
+        Pusher.getDefaultStrategy(self.config),
+        Pusher.Util.extend({}, self.config, options)
       );
     };
-    var getTimeline = function() {
-      return new Pusher.Timeline(self.key, self.sessionID, {
-        features: Pusher.Util.getClientFeatures(),
-        params: self.options.timelineParams || {},
-        limit: 50,
-        level: Pusher.Timeline.INFO,
-        version: Pusher.VERSION
-      });
-    };
-    var getTimelineSender = function(timeline, options) {
-      if (self.options.disableStats) {
-        return null;
-      }
-      return new Pusher.TimelineSender(timeline, {
-        encrypted: self.isEncrypted() || !!options.encrypted,
-        host: Pusher.stats_host,
-        path: "/timeline"
-      });
-    };
 
     this.connection = new Pusher.ConnectionManager(
       this.key,
       Pusher.Util.extend(
         { getStrategy: getStrategy,
-          getTimeline: getTimeline,
-          getTimelineSender: getTimelineSender,
-          activityTimeout: Pusher.activity_timeout,
-          pongTimeout: Pusher.pong_timeout,
-          unavailableTimeout: Pusher.unavailable_timeout
+          timeline: this.timeline,
+          activityTimeout: this.config.activity_timeout,
+          pongTimeout: this.config.pong_timeout,
+          unavailableTimeout: this.config.unavailable_timeout
         },
-        this.options,
+        this.config,
         { encrypted: this.isEncrypted() }
       )
     );
 
     this.connection.bind('connected', function() {
       self.subscribeAll();
+      if (self.timelineSender) {
+        self.timelineSender.send(self.connection.isEncrypted());
+      }
     });
     this.connection.bind('message', function(params) {
       var internal = (params.event.indexOf('pusher_internal:') === 0);
       if (params.channel) {
         var channel = self.channel(params.channel);
         if (channel) {
-          channel.emit(params.event, params.data);
+          channel.handleEvent(params.event, params.data);
         }
       }
       // Emit globaly [deprecated]
-      if (!internal) self.global_emitter.emit(params.event, params.data);
+      if (!internal) {
+        self.global_emitter.emit(params.event, params.data);
+      }
     });
     this.connection.bind('disconnected', function() {
       self.channels.disconnect();
@@ -125,10 +130,25 @@
 
   prototype.connect = function() {
     this.connection.connect();
+
+    if (this.timelineSender) {
+      if (!this.timelineSenderTimer) {
+        var encrypted = this.connection.isEncrypted();
+        var timelineSender = this.timelineSender;
+        this.timelineSenderTimer = new Pusher.PeriodicTimer(60000, function() {
+          timelineSender.send(encrypted);
+        });
+      }
+    }
   };
 
   prototype.disconnect = function() {
     this.connection.disconnect();
+
+    if (this.timelineSenderTimer) {
+      this.timelineSenderTimer.ensureAborted();
+      this.timelineSenderTimer = null;
+    }
   };
 
   prototype.bind = function(event_name, callback) {
@@ -151,35 +171,17 @@
   };
 
   prototype.subscribe = function(channel_name) {
-    var self = this;
     var channel = this.channels.add(channel_name, this);
-
     if (this.connection.state === 'connected') {
-      channel.authorize(
-        this.connection.socket_id,
-        this.options,
-        function(err, data) {
-          if (err) {
-            channel.emit('pusher:subscription_error', data);
-          } else {
-            self.send_event('pusher:subscribe', {
-              channel: channel_name,
-              auth: data.auth,
-              channel_data: data.channel_data
-            });
-          }
-        }
-      );
+      channel.subscribe();
     }
     return channel;
   };
 
   prototype.unsubscribe = function(channel_name) {
-    this.channels.remove(channel_name);
+    var channel = this.channels.remove(channel_name);
     if (this.connection.state === 'connected') {
-      this.send_event('pusher:unsubscribe', {
-        channel: channel_name
-      });
+      channel.unsubscribe();
     }
   };
 
@@ -191,7 +193,7 @@
     if (Pusher.Util.getDocumentLocation().protocol === "https:") {
       return true;
     } else {
-      return !!this.options.encrypted;
+      return Boolean(this.config.encrypted);
     }
   };
 
@@ -488,7 +490,11 @@
     },
 
     getLocalStorage: function() {
-      return window.localStorage;
+      try {
+        return window.localStorage;
+      } catch (e) {
+        return undefined;
+      }
     },
 
     getClientFeatures: function() {
@@ -503,39 +509,40 @@
 }).call(this);
 
 ;(function() {
-  Pusher.VERSION = '2.0.5';
+  Pusher.VERSION = '2.1.2';
   Pusher.PROTOCOL = 6;
 
-  // WS connection parameters
+  // DEPRECATED: WS connection parameters
   Pusher.host = 'ws.pusherapp.com';
   Pusher.ws_port = 80;
   Pusher.wss_port = 443;
-  // SockJS fallback parameters
+  // DEPRECATED: SockJS fallback parameters
   Pusher.sockjs_host = 'sockjs.pusher.com';
   Pusher.sockjs_http_port = 80;
   Pusher.sockjs_https_port = 443;
   Pusher.sockjs_path = "/pusher";
-  // Stats
+  // DEPRECATED: Stats
   Pusher.stats_host = 'stats.pusher.com';
-  // Other settings
+  // DEPRECATED: Other settings
   Pusher.channel_auth_endpoint = '/pusher/auth';
-  Pusher.cdn_http = 'http://js.pusher.com/';
-  Pusher.cdn_https = 'https://d3dy5gmtp8yhk7.cloudfront.net/';
-  Pusher.dependency_suffix = '';
   Pusher.channel_auth_transport = 'ajax';
   Pusher.activity_timeout = 120000;
   Pusher.pong_timeout = 30000;
   Pusher.unavailable_timeout = 10000;
+  // CDN configuration
+  Pusher.cdn_http = 'http://js.pusher.com/';
+  Pusher.cdn_https = 'https://d3dy5gmtp8yhk7.cloudfront.net/';
+  Pusher.dependency_suffix = '';
 
-  Pusher.getDefaultStrategy = function() {
+  Pusher.getDefaultStrategy = function(config) {
     return [
       [":def", "ws_options", {
-        hostUnencrypted: Pusher.host + ":" + Pusher.ws_port,
-        hostEncrypted: Pusher.host + ":" + Pusher.wss_port
+        hostUnencrypted: config.wsHost + ":" + config.wsPort,
+        hostEncrypted: config.wsHost + ":" + config.wssPort
       }],
       [":def", "sockjs_options", {
-        hostUnencrypted: Pusher.sockjs_host + ":" + Pusher.sockjs_http_port,
-        hostEncrypted: Pusher.sockjs_host + ":" + Pusher.sockjs_https_port
+        hostUnencrypted: config.httpHost + ":" + config.httpPort,
+        hostEncrypted: config.httpHost + ":" + config.httpsPort
       }],
       [":def", "timeouts", {
         loop: true,
@@ -543,7 +550,12 @@
         timeoutLimit: 60000
       }],
 
-      [":def", "ws_manager", [":transport_manager", { lives: 2 }]],
+      [":def", "ws_manager", [":transport_manager", {
+        lives: 2,
+        minPingDelay: 10000,
+        maxPingDelay: config.activity_timeout
+      }]],
+
       [":def_transport", "ws", "ws", 3, ":ws_options", ":ws_manager"],
       [":def_transport", "flash", "flash", 2, ":ws_options", ":ws_manager"],
       [":def_transport", "sockjs", "sockjs", 1, ":sockjs_options"],
@@ -569,6 +581,34 @@
   };
 }).call(this);
 
+;(function() {
+  Pusher.getGlobalConfig = function() {
+    return {
+      wsHost: Pusher.host,
+      wsPort: Pusher.ws_port,
+      wssPort: Pusher.wss_port,
+      httpHost: Pusher.sockjs_host,
+      httpPort: Pusher.sockjs_http_port,
+      httpsPort: Pusher.sockjs_https_port,
+      httpPath: Pusher.sockjs_path,
+      statsHost: Pusher.stats_host,
+      authEndpoint: Pusher.channel_auth_endpoint,
+      authTransport: Pusher.channel_auth_transport,
+      // TODO make this consistent with other options in next major version
+      activity_timeout: Pusher.activity_timeout,
+      pong_timeout: Pusher.pong_timeout,
+      unavailable_timeout: Pusher.unavailable_timeout
+    };
+  };
+
+  Pusher.getClusterConfig = function(clusterName) {
+    return {
+      wsHost: "ws-" + clusterName + ".pusher.com",
+      httpHost: "sockjs-" + clusterName + ".pusher.com"
+    };
+  };
+}).call(this);
+
 ;(function() {
   function buildExceptionClass(name) {
     var klass = function(message) {
@@ -697,24 +737,22 @@
 
     if (this.loaded[name]) {
       callback();
-      return;
-    }
+    } else if (this.loading[name] && this.loading[name].length > 0) {
+      this.loading[name].push(callback);
+    } else {
+      this.loading[name] = [callback];
 
-    if (!this.loading[name]) {
-      this.loading[name] = [];
-    }
-    this.loading[name].push(callback);
-    if (this.loading[name].length > 1) {
-      return;
-    }
+      require(this.getPath(name), function() {
+        self.loaded[name] = true;
 
-    require(this.getPath(name), function() {
-      for (var i = 0; i < self.loading[name].length; i++) {
-        self.loading[name][i]();
-      }
-      delete self.loading[name];
-      self.loaded[name] = true;
-    });
+        if (self.loading[name]) {
+          for (var i = 0; i < self.loading[name].length; i++) {
+            self.loading[name][i]();
+          }
+          delete self.loading[name];
+        }
+      });
+    }
   };
 
   /** Returns a root URL for pusher-js CDN.
@@ -850,6 +888,42 @@
   Pusher.Timer = Timer;
 }).call(this);
 
+;(function() {
+  /** Cross-browser compatible periodic timer abstraction.
+   *
+   * @param {Number} interval
+   * @param {Function} callback
+   */
+  function PeriodicTimer(interval, callback) {
+    var self = this;
+
+    this.interval = setInterval(function() {
+      if (self.interval !== null) {
+        callback();
+      }
+    }, interval);
+  }
+  var prototype = PeriodicTimer.prototype;
+
+  /** Returns whether the timer is still running.
+   *
+   * @return {Boolean}
+   */
+  prototype.isRunning = function() {
+    return this.interval !== null;
+  };
+
+  /** Aborts a timer when it's running. */
+  prototype.ensureAborted = function() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  };
+
+  Pusher.PeriodicTimer = PeriodicTimer;
+}).call(this);
+
 (function() {
 
   var Base64 = {
@@ -1114,7 +1188,9 @@
       if (!error) {
         self.sent++;
       }
-      callback(error, result);
+      if (callback) {
+        callback(error, result);
+      }
     });
 
     return true;
@@ -1135,26 +1211,30 @@
   }
   var prototype = TimelineSender.prototype;
 
-  prototype.send = function(callback) {
+  prototype.send = function(encrypted, callback) {
     if (this.timeline.isEmpty()) {
       return;
     }
 
-    var options = this.options;
-    var scheme = "http" + (this.isEncrypted() ? "s" : "") + "://";
+    var self = this;
+    var scheme = "http" + (encrypted ? "s" : "") + "://";
 
     var sendJSONP = function(data, callback) {
-      return Pusher.JSONPRequest.send({
+      var params = {
         data: data,
-        url: scheme + options.host + options.path,
+        url: scheme + (self.host || self.options.host) + self.options.path,
         receiver: Pusher.JSONP
-      }, callback);
+      };
+      return Pusher.JSONPRequest.send(params, function(error, result) {
+        if (result.host) {
+          self.host = result.host;
+        }
+        if (callback) {
+          callback(error, result);
+        }
+      });
     };
-    this.timeline.send(sendJSONP, callback);
-  };
-
-  prototype.isEncrypted = function() {
-    return !!this.options.encrypted;
+    self.timeline.send(sendJSONP, callback);
   };
 
   Pusher.TimelineSender = TimelineSender;
@@ -1826,7 +1906,9 @@
       // Workaround for MobileSafari bug (see https://gist.github.com/2052006)
       var self = this;
       setTimeout(function() {
-        self.socket.send(data);
+        if (self.socket) {
+          self.socket.send(data);
+        }
       }, 0);
       return true;
     } else {
@@ -1847,14 +1929,20 @@
   /** @protected */
   prototype.onError = function(error) {
     this.emit("error", { type: 'WebSocketError', error: error });
-    this.timeline.error(this.buildTimelineMessage({
-      error: getErrorDetails(error)
-    }));
+    this.timeline.error(this.buildTimelineMessage({}));
   };
 
   /** @protected */
   prototype.onClose = function(closeEvent) {
-    this.changeState("closed", closeEvent);
+    if (closeEvent) {
+      this.changeState("closed", {
+        code: closeEvent.code,
+        reason: closeEvent.reason,
+        wasClean: closeEvent.wasClean
+      });
+    } else {
+      this.changeState("closed");
+    }
     this.socket = undefined;
   };
 
@@ -1926,22 +2014,6 @@
     return Pusher.Util.extend({ cid: this.id }, message);
   };
 
-  function getErrorDetails(error) {
-    if (typeof error === "string") {
-      return error;
-    }
-    if (typeof error === "object") {
-      return Pusher.Util.mapObject(error, function(value) {
-        var valueType = typeof value;
-        if (valueType === "object" || valueType == "function") {
-          return valueType;
-        }
-        return value;
-      });
-    }
-    return typeof error;
-  }
-
   Pusher.AbstractTransport = AbstractTransport;
 }).call(this);
 
@@ -2103,7 +2175,7 @@
 
   /** @protected */
   prototype.getPath = function() {
-    return "/pusher";
+    return this.options.httpPath || "/pusher";
   };
 
   /** @protected */
@@ -2178,8 +2250,8 @@
   function AssistantToTheTransportManager(manager, transport, options) {
     this.manager = manager;
     this.transport = transport;
-    this.minPingDelay = options.minPingDelay || 10000;
-    this.maxPingDelay = options.maxPingDelay || Pusher.activity_timeout;
+    this.minPingDelay = options.minPingDelay;
+    this.maxPingDelay = options.maxPingDelay;
     this.pingDelay = null;
   }
   var prototype = AssistantToTheTransportManager.prototype;
@@ -2214,11 +2286,11 @@
         pingTimer = null;
       }
 
-      if (closeEvent.wasClean) {
-        return;
-      }
-
-      if (openTimestamp) {
+      if (closeEvent.code === 1002 || closeEvent.code === 1003) {
+        // we don't want to use transports not obeying the protocol
+        self.manager.reportDeath();
+      } else if (!closeEvent.wasClean && openTimestamp) {
+        // report deaths only for short-living transport
         var lifespan = Pusher.Util.now() - openTimestamp;
         if (lifespan < 2 * self.maxPingDelay) {
           self.manager.reportDeath();
@@ -2822,7 +2894,7 @@
     this.state = "initialized";
     this.connection = null;
     this.encrypted = !!options.encrypted;
-    this.timeline = this.options.getTimeline();
+    this.timeline = this.options.timeline;
 
     this.connectionCallbacks = this.buildConnectionCallbacks();
     this.errorCallbacks = this.buildErrorCallbacks();
@@ -2844,14 +2916,6 @@
       }
     });
 
-    var sendTimeline = function() {
-      if (self.timelineSender) {
-        self.timelineSender.send(function() {});
-      }
-    };
-    this.bind("connected", sendTimeline);
-    setInterval(sendTimeline, 60000);
-
     this.updateStrategy();
   }
   var prototype = ConnectionManager.prototype;
@@ -2883,19 +2947,18 @@
     }
 
     self.updateState("connecting");
-    self.timelineSender = self.options.getTimelineSender(
-      self.timeline,
-      { encrypted: self.encrypted },
-      self
-    );
 
     var callback = function(error, handshake) {
       if (error) {
         self.runner = self.strategy.connect(0, callback);
       } else {
-        // we don't support switching connections yet
-        self.runner.abort();
-        self.handshakeCallbacks[handshake.action](handshake);
+        if (handshake.action === "error") {
+          self.timeline.error({ handshakeError: handshake.error });
+        } else {
+          // we don't support switching connections yet
+          self.runner.abort();
+          self.handshakeCallbacks[handshake.action](handshake);
+        }
       }
     };
     self.runner = self.strategy.connect(0, callback);
@@ -2946,6 +3009,10 @@
     }
   };
 
+  prototype.isEncrypted = function() {
+    return this.encrypted;
+  };
+
   /** @private */
   prototype.updateStrategy = function() {
     this.strategy = this.options.getStrategy({
@@ -2959,6 +3026,9 @@
   prototype.retryIn = function(delay) {
     var self = this;
     self.timeline.info({ action: "retry", delay: delay });
+    if (delay > 0) {
+      self.emit("connecting_in", Math.round(delay / 1000));
+    }
     self.retryTimer = new Pusher.Timer(delay || 0, function() {
       self.disconnect();
       self.connect();
@@ -3004,6 +3074,7 @@
           self.activityTimer = new Pusher.Timer(
             self.options.pongTimeout,
             function() {
+              self.timeline.error({ pong_timed_out: self.options.pongTimeout });
               self.connection.close();
             }
           );
@@ -3055,6 +3126,7 @@
         self.clearUnavailableTimer();
         self.setConnection(handshake.connection);
         self.socket_id = self.connection.id;
+        self.timeline.info({ socket_id: self.socket_id });
         self.updateState("connected");
       }
     });
@@ -3180,187 +3252,331 @@
 }).call(this);
 
 ;(function() {
-  Pusher.Channels = function() {
-    this.channels = {};
+  /** Represents a collection of members of a presence channel. */
+  function Members() {
+    this.reset();
+  }
+  var prototype = Members.prototype;
+
+  /** Returns member's info for given id.
+   *
+   * Resulting object containts two fields - id and info.
+   *
+   * @param {Number} id
+   * @return {Object} member's info or null
+   */
+  prototype.get = function(id) {
+    if (Object.prototype.hasOwnProperty.call(this.members, id)) {
+      return {
+        id: id,
+        info: this.members[id]
+      };
+    } else {
+      return null;
+    }
   };
 
-  Pusher.Channels.prototype = {
-    add: function(channel_name, pusher) {
-      var existing_channel = this.find(channel_name);
-      if (!existing_channel) {
-        var channel = Pusher.Channel.factory(channel_name, pusher);
-        this.channels[channel_name] = channel;
-        return channel;
-      } else {
-        return existing_channel;
-      }
-    },
+  /** Calls back for each member in unspecified order.
+   *
+   * @param  {Function} callback
+   */
+  prototype.each = function(callback) {
+    var self = this;
+    Pusher.Util.objectApply(self.members, function(member, id) {
+      callback(self.get(id));
+    });
+  };
 
-    find: function(channel_name) {
-      return this.channels[channel_name];
-    },
+  /** Updates the id for connected member. For internal use only. */
+  prototype.setMyID = function(id) {
+    this.myID = id;
+  };
 
-    remove: function(channel_name) {
-      delete this.channels[channel_name];
-    },
+  /** Handles subscription data. For internal use only. */
+  prototype.onSubscription = function(subscriptionData) {
+    this.members = subscriptionData.presence.hash;
+    this.count = subscriptionData.presence.count;
+    this.me = this.get(this.myID);
+  };
 
-    disconnect: function () {
-      for(var channel_name in this.channels){
-        this.channels[channel_name].disconnect()
-      }
+  /** Adds a new member to the collection. For internal use only. */
+  prototype.addMember = function(memberData) {
+    if (this.get(memberData.user_id) === null) {
+      this.count++;
     }
+    this.members[memberData.user_id] = memberData.user_info;
+    return this.get(memberData.user_id);
   };
 
-  Pusher.Channel = function(channel_name, pusher) {
-    var self = this;
-    Pusher.EventsDispatcher.call(this, function(event_name, event_data) {
-      Pusher.debug('No callbacks on ' + channel_name + ' for ' + event_name);
-    });
-
-    this.pusher = pusher;
-    this.name = channel_name;
-    this.subscribed = false;
+  /** Adds a member from the collection. For internal use only. */
+  prototype.removeMember = function(memberData) {
+    var member = this.get(memberData.user_id);
+    if (member) {
+      delete this.members[memberData.user_id];
+      this.count--;
+    }
+    return member;
+  };
 
-    this.bind('pusher_internal:subscription_succeeded', function(data) {
-      self.onSubscriptionSucceeded(data);
-    });
+  /** Resets the collection to the initial state. For internal use only. */
+  prototype.reset = function() {
+    this.members = {};
+    this.count = 0;
+    this.myID = null;
+    this.me = null;
   };
 
-  Pusher.Channel.prototype = {
-    // inheritable constructor
-    init: function() {},
-    disconnect: function() {
-      this.subscribed = false;
-      this.emit("pusher_internal:disconnected");
-    },
+  Pusher.Members = Members;
+}).call(this);
 
-    onSubscriptionSucceeded: function(data) {
-      this.subscribed = true;
-      this.emit('pusher:subscription_succeeded');
-    },
+;(function() {
+  /** Provides base public channel interface with an event emitter.
+   *
+   * Emits:
+   * - pusher:subscription_succeeded - after subscribing successfully
+   * - other non-internal events
+   *
+   * @param {String} name
+   * @param {Pusher} pusher
+   */
+  function Channel(name, pusher) {
+    Pusher.EventsDispatcher.call(this, function(event, data) {
+      Pusher.debug('No callbacks on ' + name + ' for ' + event);
+    });
 
-    authorize: function(socketId, options, callback){
-      return callback(false, {}); // normal channels don't require auth
-    },
+    this.name = name;
+    this.pusher = pusher;
+    this.subscribed = false;
+  }
+  var prototype = Channel.prototype;
+  Pusher.Util.extend(prototype, Pusher.EventsDispatcher.prototype);
 
-    trigger: function(event, data) {
-      return this.pusher.send_event(event, data, this.name);
-    }
+  /** Skips authorization, since public channels don't require it.
+   *
+   * @param {Function} callback
+   */
+  prototype.authorize = function(socketId, callback) {
+    return callback(false, {});
   };
 
-  Pusher.Util.extend(Pusher.Channel.prototype, Pusher.EventsDispatcher.prototype);
+  /** Triggers an event */
+  prototype.trigger = function(event, data) {
+    return this.pusher.send_event(event, data, this.name);
+  };
 
-  Pusher.Channel.PrivateChannel = {
-    authorize: function(socketId, options, callback){
-      var self = this;
-      var authorizer = new Pusher.Channel.Authorizer(this, Pusher.channel_auth_transport, options);
-      return authorizer.authorize(socketId, function(err, authData) {
-        if(!err) {
-          self.emit('pusher_internal:authorized', authData);
-        }
+  /** Signals disconnection to the channel. For internal use only. */
+  prototype.disconnect = function() {
+    this.subscribed = false;
+  };
 
-        callback(err, authData);
-      });
+  /** Handles an event. For internal use only.
+   *
+   * @param {String} event
+   * @param {*} data
+   */
+  prototype.handleEvent = function(event, data) {
+    if (event.indexOf("pusher_internal:") === 0) {
+      if (event === "pusher_internal:subscription_succeeded") {
+        this.subscribed = true;
+        this.emit("pusher:subscription_succeeded", data);
+      }
+    } else {
+      this.emit(event, data);
     }
   };
 
-  Pusher.Channel.PresenceChannel = {
-    init: function(){
-      this.members = new Members(this); // leeches off channel events
-    },
+  /** Sends a subscription request. For internal use only. */
+  prototype.subscribe = function() {
+    var self = this;
 
-    onSubscriptionSucceeded: function(data) {
-      this.subscribed = true;
-      // We override this because we want the Members obj to be responsible for
-      // emitting the pusher:subscription_succeeded.  It will do this after it has done its work.
-    }
+    self.authorize(self.pusher.connection.socket_id, function(error, data) {
+      if (error) {
+        self.handleEvent('pusher:subscription_error', data);
+      } else {
+        self.pusher.send_event('pusher:subscribe', {
+          auth: data.auth,
+          channel_data: data.channel_data,
+          channel: self.name
+        });
+      }
+    });
   };
 
-  var Members = function(channel) {
-    var self = this;
-    var channelData = null;
+  /** Sends an unsubscription request. For internal use only. */
+  prototype.unsubscribe = function() {
+    this.pusher.send_event('pusher:unsubscribe', {
+      channel: this.name
+    });
+  };
 
-    var reset = function() {
-      self._members_map = {};
-      self.count = 0;
-      self.me = null;
-      channelData = null;
-    };
-    reset();
+  Pusher.Channel = Channel;
+}).call(this);
 
-    var subscriptionSucceeded = function(subscriptionData) {
-      self._members_map = subscriptionData.presence.hash;
-      self.count = subscriptionData.presence.count;
-      self.me = self.get(channelData.user_id);
-      channel.emit('pusher:subscription_succeeded', self);
-    };
+;(function() {
+  /** Extends public channels to provide private channel interface.
+   *
+   * @param {String} name
+   * @param {Pusher} pusher
+   */
+  function PrivateChannel(name, pusher) {
+    Pusher.Channel.call(this, name, pusher);
+  }
+  var prototype = PrivateChannel.prototype;
+  Pusher.Util.extend(prototype, Pusher.Channel.prototype);
 
-    channel.bind('pusher_internal:authorized', function(authorizedData) {
-      channelData = JSON.parse(authorizedData.channel_data);
-      channel.bind("pusher_internal:subscription_succeeded", subscriptionSucceeded);
-    });
+  /** Authorizes the connection to use the channel.
+   *
+   * @param  {String} socketId
+   * @param  {Function} callback
+   */
+  prototype.authorize = function(socketId, callback) {
+    var authorizer = new Pusher.Channel.Authorizer(this, this.pusher.config);
+    return authorizer.authorize(socketId, callback);
+  };
 
-    channel.bind('pusher_internal:member_added', function(data) {
-      if(self.get(data.user_id) === null) { // only incr if user_id does not already exist
-        self.count++;
-      }
+  Pusher.PrivateChannel = PrivateChannel;
+}).call(this);
 
-      self._members_map[data.user_id] = data.user_info;
-      channel.emit('pusher:member_added', self.get(data.user_id));
-    });
+;(function() {
+  /** Adds presence channel functionality to private channels.
+   *
+   * @param {String} name
+   * @param {Pusher} pusher
+   */
+  function PresenceChannel(name, pusher) {
+    Pusher.PrivateChannel.call(this, name, pusher);
+    this.members = new Pusher.Members();
+  }
+  var prototype = PresenceChannel.prototype;
+  Pusher.Util.extend(prototype, Pusher.PrivateChannel.prototype);
 
-    channel.bind('pusher_internal:member_removed', function(data) {
-      var member = self.get(data.user_id);
-      if(member) {
-        delete self._members_map[data.user_id];
-        self.count--;
-        channel.emit('pusher:member_removed', member);
+  /** Authenticates the connection as a member of the channel.
+   *
+   * @param  {String} socketId
+   * @param  {Function} callback
+   */
+  prototype.authorize = function(socketId, callback) {
+    var _super = Pusher.PrivateChannel.prototype.authorize;
+    var self = this;
+    _super.call(self, socketId, function(error, authData) {
+      if (!error) {
+        if (authData.channel_data === undefined) {
+          Pusher.warn(
+            "Invalid auth response for channel '" +
+            self.name +
+            "', expected 'channel_data' field"
+          );
+          callback("Invalid auth response");
+          return;
+        }
+        var channelData = JSON.parse(authData.channel_data);
+        self.members.setMyID(channelData.user_id);
       }
+      callback(error, authData);
     });
+  };
 
-    channel.bind('pusher_internal:disconnected', function() {
-      reset();
-      channel.unbind("pusher_internal:subscription_succeeded", subscriptionSucceeded);
-    });
+  /** Handles presence and subscription events. For internal use only.
+   *
+   * @param {String} event
+   * @param {*} data
+   */
+  prototype.handleEvent = function(event, data) {
+    switch (event) {
+      case "pusher_internal:subscription_succeeded":
+        this.members.onSubscription(data);
+        this.subscribed = true;
+        this.emit("pusher:subscription_succeeded", this.members);
+        break;
+      case "pusher_internal:member_added":
+        var addedMember = this.members.addMember(data);
+        this.emit('pusher:member_added', addedMember);
+        break;
+      case "pusher_internal:member_removed":
+        var removedMember = this.members.removeMember(data);
+        if (removedMember) {
+          this.emit('pusher:member_removed', removedMember);
+        }
+        break;
+      default:
+        Pusher.PrivateChannel.prototype.handleEvent.call(this, event, data);
+    }
   };
 
-  Members.prototype = {
-    each: function(callback) {
-      for(var i in this._members_map) {
-        callback(this.get(i));
-      }
-    },
+  /** Resets the channel state, including members map. For internal use only. */
+  prototype.disconnect = function() {
+    this.members.reset();
+    Pusher.PrivateChannel.prototype.disconnect.call(this);
+  };
 
-    get: function(user_id) {
-      if (this._members_map.hasOwnProperty(user_id)) { // have heard of this user user_id
-        return {
-          id: user_id,
-          info: this._members_map[user_id]
-        }
-      } else { // have never heard of this user
-        return null;
-      }
+  Pusher.PresenceChannel = PresenceChannel;
+}).call(this);
+
+;(function() {
+  /** Handles a channel map. */
+  function Channels() {
+    this.channels = {};
+  }
+  var prototype = Channels.prototype;
+
+  /** Creates or retrieves an existing channel by its name.
+   *
+   * @param {String} name
+   * @param {Pusher} pusher
+   * @return {Channel}
+   */
+  prototype.add = function(name, pusher) {
+    if (!this.channels[name]) {
+      this.channels[name] = createChannel(name, pusher);
     }
+    return this.channels[name];
   };
 
-  Pusher.Channel.factory = function(channel_name, pusher){
-    var channel = new Pusher.Channel(channel_name, pusher);
-    if (channel_name.indexOf('private-') === 0) {
-      Pusher.Util.extend(channel, Pusher.Channel.PrivateChannel);
-    } else if (channel_name.indexOf('presence-') === 0) {
-      Pusher.Util.extend(channel, Pusher.Channel.PrivateChannel);
-      Pusher.Util.extend(channel, Pusher.Channel.PresenceChannel);
-    };
-    channel.init();
+  /** Finds a channel by its name.
+   *
+   * @param {String} name
+   * @return {Channel} channel or null if it doesn't exist
+   */
+  prototype.find = function(name) {
+    return this.channels[name];
+  };
+
+  /** Removes a channel from the map.
+   *
+   * @param {String} name
+   */
+  prototype.remove = function(name) {
+    var channel = this.channels[name];
+    delete this.channels[name];
     return channel;
   };
+
+  /** Proxies disconnection signal to all channels. */
+  prototype.disconnect = function() {
+    Pusher.Util.objectApply(this.channels, function(channel) {
+      channel.disconnect();
+    });
+  };
+
+  function createChannel(name, pusher) {
+    if (name.indexOf('private-') === 0) {
+      return new Pusher.PrivateChannel(name, pusher);
+    } else if (name.indexOf('presence-') === 0) {
+      return new Pusher.PresenceChannel(name, pusher);
+    } else {
+      return new Pusher.Channel(name, pusher);
+    }
+  }
+
+  Pusher.Channels = Channels;
 }).call(this);
 
 ;(function() {
-  Pusher.Channel.Authorizer = function(channel, type, options) {
+  Pusher.Channel.Authorizer = function(channel, options) {
     this.channel = channel;
-    this.type = type;
+    this.type = options.authTransport;
 
+    this.options = options;
     this.authOptions = (options || {}).auth || {};
   };
 
@@ -3394,7 +3610,7 @@
         xhr = (window.XMLHttpRequest ? new window.XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP"));
       }
 
-      xhr.open("POST", Pusher.channel_auth_endpoint, true);
+      xhr.open("POST", self.options.authEndpoint, true);
 
       // add request headers
       xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
@@ -3436,6 +3652,7 @@
       var callbackName = nextAuthCallbackID.toString();
       nextAuthCallbackID++;
 
+      var document = Pusher.Util.getDocument();
       var script = document.createElement("script");
       // Hacked wrapper.
       Pusher.auth_callbacks[callbackName] = function(data) {
@@ -3443,7 +3660,7 @@
       };
 
       var callback_name = "Pusher.auth_callbacks['" + callbackName + "']";
-      script.src = Pusher.channel_auth_endpoint +
+      script.src = this.options.authEndpoint +
         '?callback=' +
         encodeURIComponent(callback_name) +
         this.composeQuery(socketId);