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

batman-rails-flo 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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);