RubyGems - batman-rails-flo - Versions diffs - 0.0.1 - Mend

batman-rails-flo 0.0.1

Files changed (162) hide show

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/client/devtools.html ADDED Viewed

@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+<head>
+<!-- Script order implies dependencies -->
+<script src="logger.js"></script>
+<script src="connection.js"></script>
+<script src="session.js"></script>
+<script src="index.js"></script>
+</head>
+<body>
+</body>
+</html>

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/client/index.js ADDED Viewed

@@ -0,0 +1,323 @@
+/**
+ *  Copyright (c) 2014, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+/*global Session:false */
+/* jshint evil:true */
+(function() {
+  'use strict';
+  /**
+   * Flo client controller.
+   *
+   * @class FloClient
+   * @private
+   */
+  function FloClient() {
+    this.config = loadConfig();
+    this.session = null;
+    this.panelWindow = null;
+    this.panelEventBuffer = [];
+    this.status = this.status.bind(this);
+    this.startNewSession = this.startNewSession.bind(this);
+    this.createLogger = Logger(this.triggerEvent.bind(this, 'log'));
+    this.loggger = this.createLogger('flo');
+    this.createPanel();
+    this.start();
+  }
+  /**
+   * Save and optionally set new config.
+   *
+   * @param {object} config
+   * @private
+   */
+  FloClient.prototype.saveConfig = function() {
+    localStorage.setItem('flo-config', JSON.stringify(this.config));
+  };
+  /**
+   * Listen on the panel window for an event `type`, i.e. receive a message
+   * from the panel.
+   *
+   * @param {string} type
+   * @param {function} callback
+   * @private
+   */
+  FloClient.prototype.listenToPanel = function(type, callback) {
+    if (!this.panelWindow) {
+      throw new Error('Panel not found');
+    }
+    this.panelWindow.addEventListener('flo_' + type, callback.bind(this));
+  };
+  /**
+   * Trigger an event on the panel window, i.e. send a message to the panel.
+   * If the panel wasn't instantiated yet, the event is buffered.
+   *
+   * @param {string} type
+   * @param {object} data
+   * @private
+   */
+  FloClient.prototype.triggerEvent = function(type, data) {
+    var event = new Event('flo_' + type);
+    event.data = data;
+    // Save events for anytime we need to reinit the panel with prev state.
+    this.panelEventBuffer.push(event);
+    if (this.panelWindow) {
+      this.panelWindow.dispatchEvent(event);
+    }
+    return event;
+  };
+  /**
+   * Create a new panel.
+   *
+   * @param {function} callback
+   * @private
+   */
+  FloClient.prototype.createPanel = function(callback) {
+    var self = this;
+    chrome.devtools.panels.create(
+      'flo',
+      '',
+      'configure/configure.html',
+      function (panel) {
+        panel.onShown.addListener(function(panelWindow) {
+          if (!panelWindow.wasShown) {
+            self.panelWindow = panelWindow;
+            self.initPanel();
+            panelWindow.wasShown = true;
+          }
+        });
+      }
+    );
+  };
+  /**
+   * Called after the panel is first created to listen on it's events.
+   * Will also trigger all buffered events on the panel.
+   *
+   * @param {object} config
+   * @private
+   */
+  FloClient.prototype.initPanel = function() {
+    this.listenToPanel('config_changed', function(e) {
+      this.config = e.data;
+      this.saveConfig();
+      this.startNewSession();
+    });
+    this.listenToPanel('retry', this.startNewSession);
+    this.listenToPanel('enable_for_host', this.enableForHost);
+    this.panelEventBuffer.forEach(function(event) {
+      this.panelWindow.dispatchEvent(event);
+    }, this);
+    this.triggerEvent('load', this.config);
+  };
+  /**
+   * Starts the flo client.
+   *
+   * @private
+   */
+  FloClient.prototype.start = function() {
+    this.status('starting');
+    this.startNewSession();
+  };
+  /**
+   * Stops flo client.
+   *
+   * @private
+   */
+  FloClient.prototype.stop = function() {
+    this.session.destroy();
+    this.session = null;
+  };
+  /**
+   * Get the url location of the inspected window.
+   *
+   * @param {function} callback
+   * @private
+   */
+  FloClient.prototype.getLocation = function(callback) {
+    chrome.devtools.inspectedWindow['eval'](
+      'location.hostname',
+      callback.bind(this)
+    );
+  };
+  /**
+   * Match config patterns against `host` and returns the matched site record.
+   *
+   * @param {string} host
+   * @return {object|null}
+   * @private
+   */
+  FloClient.prototype.getSite = function(host) {
+    var config = this.config;
+    for (var i = 0; i < config.sites.length; i++) {
+      var site = config.sites[i];
+      var pattern = parsePattern(site.pattern);
+      var matched = false;
+      if (pattern instanceof RegExp) {
+        matched = pattern.exec(host);
+      } else {
+        matched = pattern === host;
+      }
+      if (matched) return site;
+    }
+    return null;
+  };
+  /**
+   * Instantiates a new `session`.
+   *
+   * @private
+   */
+  FloClient.prototype.startNewSession = function() {
+    if (this.session) {
+      this.stop();
+    }
+    this.getLocation(
+      function (host) {
+        var site = this.getSite(host);
+        if (site) {
+          this.session = new Session(
+            site.server || host,
+            site.port || this.config.port,
+            this.status,
+            this.createLogger
+          );
+          this.session.start();
+        } else {
+          this.status('disabled');
+        }
+      }
+    );
+  };
+  /**
+   * Enables flo for the current inspected window host.
+   *
+   * @private
+   */
+  FloClient.prototype.enableForHost = function() {
+    this.getLocation(function(host) {
+      if (!this.getSite(host)) {
+        this.config.sites.push({
+          pattern: host,
+          server: host
+        });
+        this.saveConfig();
+        this.triggerEvent('load', this.config);
+        this.startNewSession();
+      }
+    });
+  };
+  /**
+   * Reports status changes to panel.
+   *
+   * @param {string} status
+   * @param {object} aux
+   * @private
+   */
+  FloClient.prototype.status = function(status, aux) {
+    var text, action;
+    switch (status) {
+      case 'starting':
+        text = 'Starting';
+        break;
+      case 'disabled':
+        text = 'Disabled for this site';
+        action = 'enable';
+        break;
+      case 'connecting':
+        text = 'Connecting';
+        break;
+      case 'connected':
+        text = 'Connected';
+        break;
+      case 'started':
+        text = 'Started';
+        break;
+      case 'retry':
+        text = 'Failed to connect, retrying in ' + (aux / 1000) + 's';
+        break;
+      case 'error':
+        text = 'Error connecting';
+        action = 'retry';
+        break;
+      default:
+        throw new Error('Unknown session status.');
+    }
+    this.triggerEvent('status_change', {
+      type: status,
+      text: text,
+      action: action
+    });
+  };
+  /**
+   * Loads config from localstorage.
+   *
+   * @private
+   */
+  function loadConfig() {
+    var config = localStorage.getItem('flo-config');
+    try {
+      config = JSON.parse(config);
+    } catch (e) {} finally {
+      return config || {
+        sites: [],
+        port: 8888
+      };
+    }
+  }
+  /**
+   * Optionally parses config from JSON to an object.
+   * Also, parses patterns into regexp.
+   *
+   * @private
+   * @return {object}
+   */
+  function parsePattern(pattern) {
+    if (!pattern) return null;
+    var m = pattern.match(/^\/(.+)\/([gim]{0,3})$/);
+    if (m && m[1]) {
+      return new RegExp(m[1], m[2]);
+    }
+    return pattern;
+  }
+  // Start the app.
+  new FloClient();
+})();

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/client/logger.js ADDED Viewed

@@ -0,0 +1,42 @@
+/**
+ *  Copyright (c) 2014, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+/* jshint evil:true */
+this.Logger = (function() {
+  'use strict';
+  function Logger(log) {
+    return function(namespace) {
+      return {
+        error: createLogLevel('error'),
+        log: createLogLevel('log')
+      };
+      function createLogLevel(level) {
+        return function () {
+          var args = [].slice.call(arguments);
+          args[0] = '[' + namespace + '] ' + args[0];
+          return log([level, args]);
+        };
+      }
+    };
+  }
+  Logger.logInContext = function(arg, method) {
+    if (!method) {
+      method = 'log';
+    }
+    chrome.devtools.inspectedWindow['eval'](
+      'console.' + method + '("' + arg.toString() + '")'
+    );
+  };
+  return Logger;
+})();

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/client/logo.png ADDED Viewed

Binary file

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/client/manifest.json ADDED Viewed

@@ -0,0 +1,13 @@
+{
+  "name": "fb-flo",
+  "version": "0.11",
+  "description": "Modify running web apps without reloading",
+  "devtools_page": "devtools.html",
+  "manifest_version": 2,
+  "permissions": [
+    "*://*/"
+  ],
+  "icons": {
+    "128": "logo.png"
+  }
+}

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/client/session.js ADDED Viewed

@@ -0,0 +1,305 @@
+/**
+ *  Copyright (c) 2014, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+/*global Connection:false */
+(function () {
+  'use strict';
+  /**
+   * Export to Node for testing and to global for production.
+   */
+  if (typeof module === 'object' && typeof exports === 'object') {
+    module.exports = Session;
+  } else {
+    this.Session = Session;
+  }
+  /**
+   * Manages a user sessios.
+   *
+   * @param {string} host
+   * @param {number} port
+   * @param {function} status
+   * @param {function} logger
+   * @class Session
+   * @public
+   */
+  function Session(host, port, status, createLogger) {
+    this.host = host;
+    this.port = port;
+    this.status = status;
+    this.createLogger = createLogger;
+    this.logger = createLogger('session');
+    this.resources = null;
+    this.conn = null;
+    this.listeners = {};
+    this.messageHandler = this.messageHandler.bind(this);
+    this.started = this.started.bind(this);
+  }
+  /**
+   * Registers the resources, connects to server and listens to events.
+   *
+   * @public
+   */
+  Session.prototype.start = function() {
+    this.logger.log('Starting flo for host', this.host);
+    this.getResources(this.connect.bind(this, this.started));
+  };
+  /**
+   * Similar to restart but does only what's needed to get flo started.
+   *
+   * @public
+   */
+  Session.prototype.restart = function() {
+    this.logger.log('Restarting');
+    this.removeEventListeners();
+    if (this.conn.connected()) {
+      // No need to reconnect. We just refetch the resources.
+      this.getResources(this.started.bind(this));
+    } else {
+      this.start();
+    }
+  };
+  /**
+   * This method takes care of listening to events defined by the chrome api
+   * @see http://developer.chrome.com/extensions/events
+   * We also keep an internal map of events we're listening to so we can
+   * unsubscribe in the future.
+   *
+   * @param {object} object
+   * @param {string} event
+   * @param {function} listener
+   * @private
+   */
+  Session.prototype.listen = function(obj, event, listener) {
+    listener = listener.bind(this);
+    obj[event].addListener(listener);
+    this.listeners[event] = {
+      obj: obj,
+      listener: listener
+    };
+  };
+  /**
+   * Remove all event listeners.
+   *
+   * @private
+   */
+  Session.prototype.removeEventListeners = function() {
+    Object.keys(this.listeners).forEach(function(event) {
+      var desc = this.listeners[event];
+      desc.obj[event].removeListener(desc.listener);
+    }, this);
+  };
+  /**
+   * Registers the resources and listens to onResourceAdded events.
+   *
+   * @param {function} callback
+   * @private
+   */
+  Session.prototype.getResources = function(callback) {
+    var self = this;
+    chrome.devtools.inspectedWindow.getResources(function (resources) {
+      self.resources = resources;
+      // After we register the current resources, we listen to the
+      // onResourceAdded event to push on more resources lazily fetched
+      // to our array.
+      self.listen(
+        chrome.devtools.inspectedWindow,
+        'onResourceAdded',
+        function (res) {
+          self.resources.push(res);
+        }
+      );
+      callback();
+    });
+  };
+  /**
+   * Connect to server.
+   *
+   * @param {function} callback
+   * @private
+   */
+  Session.prototype.connect = function(callback) {
+    callback = once(callback);
+    var self = this;
+    this.conn = new Connection(this.host, this.port, this.createLogger)
+      .onmessage(this.messageHandler)
+      .onerror(function () {
+        self.status('error');
+      })
+      .onopen(function () {
+        self.status('connected');
+        callback();
+      })
+      .onretry(function(delay) {
+        self.status('retry', delay);
+      })
+      .onconnecting(function() {
+        self.status('connecting');
+      })
+      .connect();
+  };
+  /**
+   * Does whatever needs to be done after the session is started. Currenlty
+   * just listening to page refresh events.
+   *
+   * @param {function} callback
+   */
+  Session.prototype.started = function() {
+    this.logger.log('Started');
+    this.status('started');
+    this.listen(
+      chrome.devtools.network,
+      'onNavigated',
+      this.restart
+    );
+  };
+  /**
+   * Handler for messages from the server.
+   *
+   * @param {object} updatedResource
+   * @private
+   */
+  Session.prototype.messageHandler = function(updatedResource) {
+    this.logger.log('Requested resource update', updatedResource.resourceURL);
+    if (updatedResource.reload) {
+      chrome.devtools.inspectedWindow.reload();
+      return;
+    }
+    var match = updatedResource.match;
+    var matcher;
+    if (typeof match === 'string') {
+      if (match === 'indexOf') {
+        matcher = indexOfMatcher;
+      } else if (match === 'equal') {
+        matcher = equalMatcher;
+      } else {
+        this.logger.error('Unknown match string option', match);
+        return;
+      }
+    } else if (match && typeof match === 'object') {
+      if (match.type === 'regexp') {
+        var flags = '';
+        if (match.ignoreCase) {
+          flags += 'i';
+        }
+        if (match.multiline) {
+          flags += 'm';
+        }
+        if (match.global) {
+          flags += 'g';
+        }
+        var r = new RegExp(match.source, flags);
+        matcher = r.exec.bind(r);
+      } else {
+        this.logger.error('Unknown matcher object:', match);
+        return;
+      }
+    }
+    var resource = this.resources.filter(function (res) {
+      return matcher(res.url, updatedResource.resourceURL);
+    })[0];
+    if (!resource) {
+      this.logger.error(
+        'Resource with the following URL is not on the page:',
+        updatedResource.resourceURL
+      );
+      return;
+    }
+    resource.setContent(updatedResource.contents, true, function (status) {
+      if (status.code === 'OK') {
+        this.logger.log('Resource update successful');
+        triggerReloadEvent(updatedResource);
+      } else {
+        this.logger.error(
+          'flo failed to update, this shouldn\'t happen please report it: ' +
+            JSON.stringify(status)
+        );
+      }
+    }.bind(this));
+  };
+  /**
+   * Destroys session.
+   *
+   * @public
+   */
+  Session.prototype.destroy = function() {
+    this.removeEventListeners();
+    if (this.conn) this.conn.disconnect();
+  };
+  /**
+   * Utility to ensure's a function is called only once.
+   *
+   * @param {function} cb
+   * @private
+   */
+  function once(cb) {
+    var called = false;
+    return function() {
+      if (!called) {
+        called = true;
+        return cb.apply(this, arguments);
+      }
+    };
+  }
+  function triggerReloadEvent(resource) {
+    var data = {
+      url: resource.resourceURL,
+      contents: resource.contents
+    };
+    var script = '(function() {' +
+      'var event = new Event(\'fb-flo-reload\');' +
+      'event.data = ' + JSON.stringify(data) + ';' +
+      'window.dispatchEvent(event);' +
+      '})()';
+    chrome.devtools.inspectedWindow.eval(script);
+  }
+  function indexOfMatcher(val, resourceURL) {
+    return val.indexOf(resourceURL) > -1;
+  }
+  function equalMatcher(val, resourceURL) {
+    return resourceURL === val;
+  }
+}).call(this);