hippo-fw 0.9.8 → 0.9.9

data/client/hippo/lib/action_cable/connection_monitor.js

@@ -0,0 +1,135 @@
+/* eslint-disable */
+import ActionCable from './cable';
+
+// Responsible for ensuring the cable connection is in good health by validating the heartbeat pings sent from the server, and attempting
+// revival reconnections if things go astray. Internal class, not intended for direct user manipulation.
+ActionCable.ConnectionMonitor = (function() {
+    var clamp, now, secondsSince;
+
+    class ConnectionMonitor {
+        constructor(connection) {
+            this.visibilityDidChange = this.visibilityDidChange.bind(this);
+            this.connection = connection;
+            this.reconnectAttempts = 0;
+        }
+
+        start() {
+            if (!this.isRunning()) {
+                this.startedAt = now();
+                delete this.stoppedAt;
+                this.startPolling();
+                document.addEventListener("visibilitychange", this.visibilityDidChange);
+                return ActionCable.log(`ConnectionMonitor started. pollInterval = ${this.getPollInterval()} ms`);
+            }
+        }
+
+        stop() {
+            if (this.isRunning()) {
+                this.stoppedAt = now();
+                this.stopPolling();
+                document.removeEventListener("visibilitychange", this.visibilityDidChange);
+                return ActionCable.log("ConnectionMonitor stopped");
+            }
+        }
+
+        isRunning() {
+            return (this.startedAt != null) && (this.stoppedAt == null);
+        }
+
+        recordPing() {
+            return this.pingedAt = now();
+        }
+
+        recordConnect() {
+            this.reconnectAttempts = 0;
+            this.recordPing();
+            delete this.disconnectedAt;
+            return ActionCable.log("ConnectionMonitor recorded connect");
+        }
+
+        recordDisconnect() {
+            this.disconnectedAt = now();
+            return ActionCable.log("ConnectionMonitor recorded disconnect");
+        }
+
+        // Private
+        startPolling() {
+            this.stopPolling();
+            return this.poll();
+        }
+
+        stopPolling() {
+            return clearTimeout(this.pollTimeout);
+        }
+
+        poll() {
+            return this.pollTimeout = setTimeout(() => {
+                this.reconnectIfStale();
+                return this.poll();
+            }, this.getPollInterval());
+        }
+
+        getPollInterval() {
+            var interval, max, min;
+            ({min, max} = this.constructor.pollInterval);
+            interval = 5 * Math.log(this.reconnectAttempts + 1);
+            return Math.round(clamp(interval, min, max) * 1000);
+        }
+
+        reconnectIfStale() {
+            if (this.connectionIsStale()) {
+                ActionCable.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, pollInterval = ${this.getPollInterval()} ms, time disconnected = ${secondsSince(this.disconnectedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
+                this.reconnectAttempts++;
+                if (this.disconnectedRecently()) {
+                    return ActionCable.log("ConnectionMonitor skipping reopening recent disconnect");
+                } else {
+                    ActionCable.log("ConnectionMonitor reopening");
+                    return this.connection.reopen();
+                }
+            }
+        }
+
+        connectionIsStale() {
+            var ref;
+            return secondsSince((ref = this.pingedAt) != null ? ref : this.startedAt) > this.constructor.staleThreshold;
+        }
+
+        disconnectedRecently() {
+            return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
+        }
+
+        visibilityDidChange() {
+            if (document.visibilityState === "visible") {
+                return setTimeout(() => {
+                    if (this.connectionIsStale() || !this.connection.isOpen()) {
+                        ActionCable.log(`ConnectionMonitor reopening stale connection on visibilitychange. visbilityState = ${document.visibilityState}`);
+                        return this.connection.reopen();
+                    }
+                }, 200);
+            }
+        }
+
+    };
+
+    ConnectionMonitor.pollInterval = {
+        min: 3,
+        max: 30
+    };
+
+    ConnectionMonitor.staleThreshold = 6; // Server::Connections::BEAT_INTERVAL * 2 (missed two pings)
+
+    now = function() {
+        return new Date().getTime();
+    };
+
+    secondsSince = function(time) {
+        return (now() - time) / 1000;
+    };
+
+    clamp = function(number, min, max) {
+        return Math.max(min, Math.min(max, number));
+  };
+
+  return ConnectionMonitor;
+
+})();

data/client/hippo/lib/action_cable/consumer.js

@@ -0,0 +1,56 @@
+/* eslint-disable */
+import ActionCable from './cable';
+
+// The ActionCable.Consumer establishes the connection to a server-side Ruby Connection object. Once established,
+// the ActionCable.ConnectionMonitor will ensure that its properly maintained through heartbeats and checking for stale updates.
+// The Consumer instance is also the gateway to establishing subscriptions to desired channels through the #createSubscription
+// method.
+
+// The following example shows how this can be setup:
+
+//   @App = {}
+//   App.cable = ActionCable.createConsumer "ws://example.com/accounts/1"
+//   App.appearance = App.cable.subscriptions.create "AppearanceChannel"
+
+// For more details on how you'd configure an actual channel subscription, see ActionCable.Subscription.
+
+// When a consumer is created, it automatically connects with the server.
+
+// To disconnect from the server, call
+
+//   App.cable.disconnect()
+
+// and to restart the connection:
+
+//   App.cable.connect()
+
+// Any channel subscriptions which existed prior to disconnecting will
+// automatically resubscribe.
+ActionCable.Consumer = class Consumer {
+    constructor(url) {
+        this.url = url;
+        this.subscriptions = new ActionCable.Subscriptions(this);
+        this.connection = new ActionCable.Connection(this);
+    }
+
+    send(data) {
+        return this.connection.send(data);
+    }
+
+    connect() {
+        return this.connection.open();
+    }
+
+    disconnect() {
+        return this.connection.close({
+            allowReconnect: false
+        });
+    }
+
+    ensureActiveConnection() {
+        if (!this.connection.isActive()) {
+            return this.connection.open();
+    }
+  }
+
+};

data/client/hippo/lib/action_cable/subscription.js

@@ -0,0 +1,98 @@
+/* eslint-disable */
+import ActionCable from './cable';
+
+// A new subscription is created through the ActionCable.Subscriptions instance available on the consumer.
+// It provides a number of callbacks and a method for calling remote procedure calls on the corresponding
+// Channel instance on the server side.
+
+// An example demonstrates the basic functionality:
+
+//   App.appearance = App.cable.subscriptions.create "AppearanceChannel",
+//     connected: ->
+//       # Called once the subscription has been successfully completed
+
+//     disconnected: ({ willAttemptReconnect: boolean }) ->
+//       # Called when the client has disconnected with the server.
+//       # The object will have an `willAttemptReconnect` property which
+//       # says whether the client has the intention of attempting
+//       # to reconnect.
+
+//     appear: ->
+//       @perform 'appear', appearing_on: @appearingOn()
+
+//     away: ->
+//       @perform 'away'
+
+//     appearingOn: ->
+//       $('main').data 'appearing-on'
+
+// The methods #appear and #away forward their intent to the remote AppearanceChannel instance on the server
+// by calling the `@perform` method with the first parameter being the action (which maps to AppearanceChannel#appear/away).
+// The second parameter is a hash that'll get JSON encoded and made available on the server in the data parameter.
+
+// This is how the server component would look:
+
+//   class AppearanceChannel < ApplicationActionCable::Channel
+//     def subscribed
+//       current_user.appear
+//     end
+
+//     def unsubscribed
+//       current_user.disappear
+//     end
+
+//     def appear(data)
+//       current_user.appear on: data['appearing_on']
+//     end
+
+//     def away
+//       current_user.away
+//     end
+//   end
+
+// The "AppearanceChannel" name is automatically mapped between the client-side subscription creation and the server-side Ruby class name.
+// The AppearanceChannel#appear/away public methods are exposed automatically to client-side invocation through the @perform method.
+ActionCable.Subscription = (function() {
+    var extend;
+
+    class Subscription {
+        constructor(consumer, params = {}, mixin) {
+            this.consumer = consumer;
+            this.identifier = JSON.stringify(params);
+            extend(this, mixin);
+        }
+
+        // Perform a channel action with the optional data passed as an attribute
+        perform(action, data = {}) {
+            data.action = action;
+            return this.send(data);
+        }
+
+        send(data) {
+            return this.consumer.send({
+                command: "message",
+                identifier: this.identifier,
+                data: JSON.stringify(data)
+            });
+        }
+
+        unsubscribe() {
+            return this.consumer.subscriptions.remove(this);
+        }
+
+    };
+
+    extend = function(object, properties) {
+        var key, value;
+        if (properties != null) {
+            for (key in properties) {
+                value = properties[key];
+                object[key] = value;
+            }
+        }
+        return object;
+  };
+
+  return Subscription;
+
+})();

data/client/hippo/lib/action_cable/subscriptions.js

@@ -0,0 +1,129 @@
+/* eslint-disable */
+import ActionCable from './cable';
+
+// Collection class for creating (and internally managing) channel subscriptions. The only method intended to be triggered by the user
+// us ActionCable.Subscriptions#create, and it should be called through the consumer like so:
+
+//   @App = {}
+//   App.cable = ActionCable.createConsumer "ws://example.com/accounts/1"
+//   App.appearance = App.cable.subscriptions.create "AppearanceChannel"
+
+// For more details on how you'd configure an actual channel subscription, see ActionCable.Subscription.
+ActionCable.Subscriptions = class Subscriptions {
+    constructor(consumer) {
+        this.consumer = consumer;
+        this.subscriptions = [];
+    }
+
+    create(channelName, mixin) {
+        var channel, params, subscription;
+        channel = channelName;
+        params = typeof channel === "object" ? channel : {channel};
+        subscription = new ActionCable.Subscription(this.consumer, params, mixin);
+        return this.add(subscription);
+    }
+
+    // Private
+    add(subscription) {
+        this.subscriptions.push(subscription);
+        this.consumer.ensureActiveConnection();
+        this.notify(subscription, "initialized");
+        this.sendCommand(subscription, "subscribe");
+        return subscription;
+    }
+
+    remove(subscription) {
+        this.forget(subscription);
+        if (!this.findAll(subscription.identifier).length) {
+            this.sendCommand(subscription, "unsubscribe");
+        }
+        return subscription;
+    }
+
+    reject(identifier) {
+        var i, len, ref, results, subscription;
+        ref = this.findAll(identifier);
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+            subscription = ref[i];
+            this.forget(subscription);
+            this.notify(subscription, "rejected");
+            results.push(subscription);
+        }
+        return results;
+    }
+
+    forget(subscription) {
+        var s;
+        this.subscriptions = (function() {
+            var i, len, ref, results;
+            ref = this.subscriptions;
+            results = [];
+            for (i = 0, len = ref.length; i < len; i++) {
+                s = ref[i];
+                if (s !== subscription) {
+                    results.push(s);
+                }
+            }
+            return results;
+        }).call(this);
+        return subscription;
+    }
+
+    findAll(identifier) {
+        var i, len, ref, results, s;
+        ref = this.subscriptions;
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+            s = ref[i];
+            if (s.identifier === identifier) {
+                results.push(s);
+            }
+        }
+        return results;
+    }
+
+    reload() {
+        var i, len, ref, results, subscription;
+        ref = this.subscriptions;
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+            subscription = ref[i];
+            results.push(this.sendCommand(subscription, "subscribe"));
+        }
+        return results;
+    }
+
+    notifyAll(callbackName, ...args) {
+        var i, len, ref, results, subscription;
+        ref = this.subscriptions;
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+            subscription = ref[i];
+            results.push(this.notify(subscription, callbackName, ...args));
+        }
+        return results;
+    }
+
+    notify(subscription, callbackName, ...args) {
+        var i, len, results, subscriptions;
+        if (typeof subscription === "string") {
+            subscriptions = this.findAll(subscription);
+        } else {
+            subscriptions = [subscription];
+        }
+        results = [];
+        for (i = 0, len = subscriptions.length; i < len; i++) {
+            subscription = subscriptions[i];
+            results.push(typeof subscription[callbackName] === "function" ? subscription[callbackName](...args) : void 0);
+        }
+        return results;
+    }
+
+    sendCommand(subscription, command) {
+        var identifier;
+        ({identifier} = subscription);
+        return this.consumer.send({command, identifier});
+  }
+
+};

data/client/hippo/lib/date-range.js

@@ -1,10 +1,19 @@
-import moment from 'moment';
-import { observable, computed } from 'mobx';
-import { isString, isEmpty, map, isNaN } from 'lodash';
+import moment from 'moment-timezone';
+import { observable, computed, isObservableArray, intercept } from 'mobx';
+import { includes, isString, isEmpty, map, isArray, first, last } from 'lodash';
 import {
     identifiedBy,
 } from 'mobx-decorated-models';
 
+function coerceToMoment(change) {
+    if (!includes(['start', 'end'], change.name)) { return change; }
+    if (change.newValue && !moment.isMoment(change.newValue)) {
+        change.newValue = moment(change.newValue);
+    }
+    return change;
+}
+
+
 @identifiedBy('date-range')
 export default class DateRange {
 
@@ -12,8 +21,12 @@ export default class DateRange {
     @observable end;
 
     constructor(range) {
+        intercept(this, coerceToMoment);
         if (isString(range) && !isEmpty(range)) {
             [this.start, this.end] = map(range.split('...'), d => new Date(d));
+        } else if (isArray(range) || isObservableArray(range)) {
+            this.start = first(range);
+            this.end = last(range);
         } else if (range) {
             this.start = range.start;
             this.end = range.end;
@@ -21,8 +34,8 @@ export default class DateRange {
     }
 
     toJSON() {
-        if (this.start && this.end && !isNaN(this.start) && !isNaN(this.end)) {
-            // this strange format is what PG user and is therefore what active record expects
+        if (this.start && this.end && this.start.isValid() && this.end.isValid()) {
+            // this strange format is what PG uses and is therefore what active record expects
             return `[${this.start.toISOString()},${this.end.toISOString()})`;
         }
         return '';
@@ -36,4 +49,8 @@ export default class DateRange {
         return moment(this.end).isAfter() && moment(this.start).isBefore();
     }
 
+    @computed get asArray() {
+        return [this.start, this.end];
+    }
+
 }