Backport SmartInterval, PrettyTime, SubbableResource from EE.backport-tt

6 files changed, 609 insertions, 0 deletions

diff --git a/app/assets/javascripts/lib/utils/pretty_time.js.es6 b/app/assets/javascripts/lib/utils/pretty_time.js.es6
new file mode 100644
index 00000000000..ccaf447eb0b
--- /dev/null
+++ b/app/assets/javascripts/lib/utils/pretty_time.js.es6
@@ -0,0 +1,67 @@
+(() => {
+  /*
+   * TODO: Make these methods more configurable (e.g. parseSeconds timePeriodContstraints,
+   * stringifyTime condensed or non-condensed, abbreviateTimelengths)
+   * */
+
+  class PrettyTime {
+
+    /*
+     * Accepts seconds and returns a timeObject { weeks: #, days: #, hours: #, minutes: # }
+     * Seconds can be negative or positive, zero or non-zero.
+    */
+    static parseSeconds(seconds) {
+      const DAYS_PER_WEEK = 5;
+      const HOURS_PER_DAY = 8;
+      const MINUTES_PER_HOUR = 60;
+      const MINUTES_PER_WEEK = DAYS_PER_WEEK * HOURS_PER_DAY * MINUTES_PER_HOUR;
+      const MINUTES_PER_DAY = HOURS_PER_DAY * MINUTES_PER_HOUR;
+
+      const timePeriodConstraints = {
+        weeks: MINUTES_PER_WEEK,
+        days: MINUTES_PER_DAY,
+        hours: MINUTES_PER_HOUR,
+        minutes: 1,
+      };
+
+      let unorderedMinutes = PrettyTime.secondsToMinutes(seconds);
+
+      return _.mapObject(timePeriodConstraints, (minutesPerPeriod) => {
+        const periodCount = Math.floor(unorderedMinutes / minutesPerPeriod);
+
+        unorderedMinutes -= (periodCount * minutesPerPeriod);
+
+        return periodCount;
+      });
+    }
+
+    /*
+    * Accepts a timeObject and returns a condensed string representation of it
+    * (e.g. '1w 2d 3h 1m' or '1h 30m'). Zero value units are not included.
+    */
+
+    static stringifyTime(timeObject) {
+      const reducedTime = _.reduce(timeObject, (memo, unitValue, unitName) => {
+        const isNonZero = !!unitValue;
+        return isNonZero ? `${memo} ${unitValue}${unitName.charAt(0)}` : memo;
+      }, '').trim();
+      return reducedTime.length ? reducedTime : '0m';
+    }
+
+    /*
+    * Accepts a time string of any size (e.g. '1w 2d 3h 5m' or '1w 2d') and returns
+    *  the first non-zero unit/value pair.
+    */
+
+    static abbreviateTime(timeStr) {
+      return timeStr.split(' ')
+        .filter(unitStr => unitStr.charAt(0) !== '0')[0];
+    }
+
+    static secondsToMinutes(seconds) {
+      return Math.abs(seconds / 60);
+    }
+  }
+
+  gl.PrettyTime = PrettyTime;
+})(window.gl || (window.gl = {}));
diff --git a/app/assets/javascripts/smart_interval.js.es6 b/app/assets/javascripts/smart_interval.js.es6
new file mode 100644
index 00000000000..5eb15dba79b
--- /dev/null
+++ b/app/assets/javascripts/smart_interval.js.es6
@@ -0,0 +1,130 @@
+/*
+* Instances of SmartInterval extend the functionality of `setInterval`, make it configurable
+* and controllable by a public API.
+*
+* */
+
+(() => {
+  class SmartInterval {
+    /**
+      * @param { function } callback Function to be called on each iteration (required)
+      * @param { milliseconds } startingInterval `currentInterval` is set to this initially
+      * @param { milliseconds } maxInterval `currentInterval` will be incremented to this
+      * @param { integer } incrementByFactorOf `currentInterval` is incremented by this factor
+      * @param { boolean } lazyStart Configure if timer is initialized on instantiation or lazily
+      */
+    constructor({ callback, startingInterval, maxInterval, incrementByFactorOf, lazyStart }) {
+      this.cfg = {
+        callback,
+        startingInterval,
+        maxInterval,
+        incrementByFactorOf,
+        lazyStart,
+      };
+
+      this.state = {
+        intervalId: null,
+        currentInterval: startingInterval,
+        pageVisibility: 'visible',
+      };
+
+      this.initInterval();
+    }
+    /* public */
+
+    start() {
+      const cfg = this.cfg;
+      const state = this.state;
+
+      state.intervalId = window.setInterval(() => {
+        cfg.callback();
+
+        if (this.getCurrentInterval() === cfg.maxInterval) {
+          return;
+        }
+
+        this.incrementInterval();
+        this.resume();
+      }, this.getCurrentInterval());
+    }
+
+    // cancel the existing timer, setting the currentInterval back to startingInterval
+    cancel() {
+      this.setCurrentInterval(this.cfg.startingInterval);
+      this.stopTimer();
+    }
+
+    // start a timer, using the existing interval
+    resume() {
+      this.stopTimer(); // stop exsiting timer, in case timer was not previously stopped
+      this.start();
+    }
+
+    destroy() {
+      this.cancel();
+      $(document).off('visibilitychange').off('page:before-unload');
+    }
+
+    /* private */
+
+    initInterval() {
+      const cfg = this.cfg;
+
+      if (!cfg.lazyStart) {
+        this.start();
+      }
+
+      this.initVisibilityChangeHandling();
+      this.initPageUnloadHandling();
+    }
+
+    initVisibilityChangeHandling() {
+      // cancel interval when tab no longer shown (prevents cached pages from polling)
+      $(document)
+        .off('visibilitychange').on('visibilitychange', (e) => {
+          this.state.pageVisibility = e.target.visibilityState;
+          this.handleVisibilityChange();
+        });
+    }
+
+    initPageUnloadHandling() {
+      // prevent interval continuing after page change, when kept in cache by Turbolinks
+      $(document).on('page:before-unload', () => this.cancel());
+    }
+
+    handleVisibilityChange() {
+      const state = this.state;
+
+      const intervalAction = state.pageVisibility === 'hidden' ? this.cancel : this.resume;
+
+      intervalAction.apply(this);
+    }
+
+    getCurrentInterval() {
+      return this.state.currentInterval;
+    }
+
+    setCurrentInterval(newInterval) {
+      this.state.currentInterval = newInterval;
+    }
+
+    incrementInterval() {
+      const cfg = this.cfg;
+      const currentInterval = this.getCurrentInterval();
+      let nextInterval = currentInterval * cfg.incrementByFactorOf;
+
+      if (nextInterval > cfg.maxInterval) {
+        nextInterval = cfg.maxInterval;
+      }
+
+      this.setCurrentInterval(nextInterval);
+    }
+
+    stopTimer() {
+      const state = this.state;
+
+      state.intervalId = window.clearInterval(state.intervalId);
+    }
+  }
+  gl.SmartInterval = SmartInterval;
+})(window.gl || (window.gl = {}));
diff --git a/app/assets/javascripts/subbable_resource.js.es6 b/app/assets/javascripts/subbable_resource.js.es6
new file mode 100644
index 00000000000..932120157a3
--- /dev/null
+++ b/app/assets/javascripts/subbable_resource.js.es6
@@ -0,0 +1,54 @@
+//= require vue
+//= require vue-resource
+
+(() => {
+/*
+*   SubbableResource can be extended to provide a pubsub-style service for one-off REST
+*   calls. Subscribe by passing a callback or render method you will use to handle responses.
+ *
+* */
+
+  class SubbableResource {
+    constructor(resourcePath) {
+      this.endpoint = resourcePath;
+
+      // TODO: Switch to axios.create
+      this.resource = $.ajax;
+      this.subscribers = [];
+    }
+
+    subscribe(callback) {
+      this.subscribers.push(callback);
+    }
+
+    publish(newResponse) {
+      const responseCopy = _.extend({}, newResponse);
+      this.subscribers.forEach((fn) => {
+        fn(responseCopy);
+      });
+      return newResponse;
+    }
+
+    get(payload) {
+      return this.resource(payload)
+        .then(data => this.publish(data));
+    }
+
+    post(payload) {
+      return this.resource(payload)
+        .then(data => this.publish(data));
+    }
+
+    put(payload) {
+      return this.resource(payload)
+        .then(data => this.publish(data));
+    }
+
+    delete(payload) {
+      return this.resource(payload)
+        .then(data => this.publish(data));
+    }
+  }
+
+  gl.SubbableResource = SubbableResource;
+})(window.gl || (window.gl = {}));
diff --git a/spec/javascripts/pretty_time_spec.js.es6 b/spec/javascripts/pretty_time_spec.js.es6
new file mode 100644
index 00000000000..2e12d45f7a7
--- /dev/null
+++ b/spec/javascripts/pretty_time_spec.js.es6
@@ -0,0 +1,134 @@
+//= require lib/utils/pretty_time
+
+(() => {
+  const PrettyTime = gl.PrettyTime;
+
+  describe('PrettyTime methods', function () {
+    describe('parseSeconds', function () {
+      it('should correctly parse a negative value', function () {
+        const parser = PrettyTime.parseSeconds;
+
+        const zeroSeconds = parser(-1000);
+
+        expect(zeroSeconds.minutes).toBe(16);
+        expect(zeroSeconds.hours).toBe(0);
+        expect(zeroSeconds.days).toBe(0);
+        expect(zeroSeconds.weeks).toBe(0);
+      });
+
+      it('should correctly parse a zero value', function () {
+        const parser = PrettyTime.parseSeconds;
+
+        const zeroSeconds = parser(0);
+
+        expect(zeroSeconds.minutes).toBe(0);
+        expect(zeroSeconds.hours).toBe(0);
+        expect(zeroSeconds.days).toBe(0);
+        expect(zeroSeconds.weeks).toBe(0);
+      });
+
+      it('should correctly parse a small non-zero second values', function () {
+        const parser = PrettyTime.parseSeconds;
+
+        const subOneMinute = parser(10);
+
+        expect(subOneMinute.minutes).toBe(0);
+        expect(subOneMinute.hours).toBe(0);
+        expect(subOneMinute.days).toBe(0);
+        expect(subOneMinute.weeks).toBe(0);
+
+        const aboveOneMinute = parser(100);
+
+        expect(aboveOneMinute.minutes).toBe(1);
+        expect(aboveOneMinute.hours).toBe(0);
+        expect(aboveOneMinute.days).toBe(0);
+        expect(aboveOneMinute.weeks).toBe(0);
+
+        const manyMinutes = parser(1000);
+
+        expect(manyMinutes.minutes).toBe(16);
+        expect(manyMinutes.hours).toBe(0);
+        expect(manyMinutes.days).toBe(0);
+        expect(manyMinutes.weeks).toBe(0);
+      });
+
+      it('should correctly parse large second values', function () {
+        const parser = PrettyTime.parseSeconds;
+
+        const aboveOneHour = parser(4800);
+
+        expect(aboveOneHour.minutes).toBe(20);
+        expect(aboveOneHour.hours).toBe(1);
+        expect(aboveOneHour.days).toBe(0);
+        expect(aboveOneHour.weeks).toBe(0);
+
+        const aboveOneDay = parser(110000);
+
+        expect(aboveOneDay.minutes).toBe(33);
+        expect(aboveOneDay.hours).toBe(6);
+        expect(aboveOneDay.days).toBe(3);
+        expect(aboveOneDay.weeks).toBe(0);
+
+        const aboveOneWeek = parser(25000000);
+
+        expect(aboveOneWeek.minutes).toBe(26);
+        expect(aboveOneWeek.hours).toBe(0);
+        expect(aboveOneWeek.days).toBe(3);
+        expect(aboveOneWeek.weeks).toBe(173);
+      });
+    });
+
+    describe('stringifyTime', function () {
+      it('should stringify values with all non-zero units', function () {
+        const timeObject = {
+          weeks: 1,
+          days: 4,
+          hours: 7,
+          minutes: 20,
+        };
+
+        const timeString = PrettyTime.stringifyTime(timeObject);
+
+        expect(timeString).toBe('1w 4d 7h 20m');
+      });
+
+      it('should stringify values with some non-zero units', function () {
+        const timeObject = {
+          weeks: 0,
+          days: 4,
+          hours: 0,
+          minutes: 20,
+        };
+
+        const timeString = PrettyTime.stringifyTime(timeObject);
+
+        expect(timeString).toBe('4d 20m');
+      });
+
+      it('should stringify values with no non-zero units', function () {
+        const timeObject = {
+          weeks: 0,
+          days: 0,
+          hours: 0,
+          minutes: 0,
+        };
+
+        const timeString = PrettyTime.stringifyTime(timeObject);
+
+        expect(timeString).toBe('0m');
+      });
+    });
+
+    describe('abbreviateTime', function () {
+      it('should abbreviate stringified times for weeks', function () {
+        const fullTimeString = '1w 3d 4h 5m';
+        expect(PrettyTime.abbreviateTime(fullTimeString)).toBe('1w');
+      });
+
+      it('should abbreviate stringified times for non-weeks', function () {
+        const fullTimeString = '0w 3d 4h 5m';
+        expect(PrettyTime.abbreviateTime(fullTimeString)).toBe('3d');
+      });
+    });
+  });
+})(window.gl || (window.gl = {}));
diff --git a/spec/javascripts/smart_interval_spec.js.es6 b/spec/javascripts/smart_interval_spec.js.es6
new file mode 100644
index 00000000000..651d1f0f975
--- /dev/null
+++ b/spec/javascripts/smart_interval_spec.js.es6
@@ -0,0 +1,159 @@
+//= require jquery
+//= require smart_interval
+
+(() => {
+  const DEFAULT_MAX_INTERVAL = 100;
+  const DEFAULT_STARTING_INTERVAL = 5;
+  const DEFAULT_SHORT_TIMEOUT = 75;
+  const DEFAULT_LONG_TIMEOUT = 1000;
+  const DEFAULT_INCREMENT_FACTOR = 2;
+
+  function createDefaultSmartInterval(config) {
+    const defaultParams = {
+      callback: () => {},
+      startingInterval: DEFAULT_STARTING_INTERVAL,
+      maxInterval: DEFAULT_MAX_INTERVAL,
+      incrementByFactorOf: DEFAULT_INCREMENT_FACTOR,
+      delayStartBy: 0,
+      lazyStart: false,
+    };
+
+    if (config) {
+      _.extend(defaultParams, config);
+    }
+
+    return new gl.SmartInterval(defaultParams);
+  }
+
+  describe('SmartInterval', function () {
+    describe('Increment Interval', function () {
+      beforeEach(function () {
+        this.smartInterval = createDefaultSmartInterval();
+      });
+
+      it('should increment the interval delay', function (done) {
+        const interval = this.smartInterval;
+        setTimeout(() => {
+          const intervalConfig = this.smartInterval.cfg;
+          const iterationCount = 4;
+          const maxIntervalAfterIterations = intervalConfig.startingInterval *
+            Math.pow(intervalConfig.incrementByFactorOf, (iterationCount - 1)); // 40
+          const currentInterval = interval.getCurrentInterval();
+
+          // Provide some flexibility for performance of testing environment
+          expect(currentInterval).toBeGreaterThan(intervalConfig.startingInterval);
+          expect(currentInterval <= maxIntervalAfterIterations).toBeTruthy();
+
+          done();
+        }, DEFAULT_SHORT_TIMEOUT); // 4 iterations, increment by 2x = (5 + 10 + 20 + 40)
+      });
+
+      it('should not increment past maxInterval', function (done) {
+        const interval = this.smartInterval;
+
+        setTimeout(() => {
+          const currentInterval = interval.getCurrentInterval();
+          expect(currentInterval).toBe(interval.cfg.maxInterval);
+
+          done();
+        }, DEFAULT_LONG_TIMEOUT);
+      });
+    });
+
+    describe('Public methods', function () {
+      beforeEach(function () {
+        this.smartInterval = createDefaultSmartInterval();
+      });
+
+      it('should cancel an interval', function (done) {
+        const interval = this.smartInterval;
+
+        setTimeout(() => {
+          interval.cancel();
+
+          const intervalId = interval.state.intervalId;
+          const currentInterval = interval.getCurrentInterval();
+          const intervalLowerLimit = interval.cfg.startingInterval;
+
+          expect(intervalId).toBeUndefined();
+          expect(currentInterval).toBe(intervalLowerLimit);
+
+          done();
+        }, DEFAULT_SHORT_TIMEOUT);
+      });
+
+      it('should resume an interval', function (done) {
+        const interval = this.smartInterval;
+
+        setTimeout(() => {
+          interval.cancel();
+
+          interval.resume();
+
+          const intervalId = interval.state.intervalId;
+
+          expect(intervalId).toBeTruthy();
+
+          done();
+        }, DEFAULT_SHORT_TIMEOUT);
+      });
+    });
+
+    describe('DOM Events', function () {
+      beforeEach(function () {
+        // This ensures DOM and DOM events are initialized for these specs.
+        fixture.set('<div></div>');
+
+        this.smartInterval = createDefaultSmartInterval();
+      });
+
+      it('should pause when page is not visible', function (done) {
+        const interval = this.smartInterval;
+
+        setTimeout(() => {
+          expect(interval.state.intervalId).toBeTruthy();
+
+          // simulates triggering of visibilitychange event
+          interval.state.pageVisibility = 'hidden';
+          interval.handleVisibilityChange();
+
+          expect(interval.state.intervalId).toBeUndefined();
+          done();
+        }, DEFAULT_SHORT_TIMEOUT);
+      });
+
+      it('should resume when page is becomes visible at the previous interval', function (done) {
+        const interval = this.smartInterval;
+
+        setTimeout(() => {
+          expect(interval.state.intervalId).toBeTruthy();
+
+          // simulates triggering of visibilitychange event
+          interval.state.pageVisibility = 'hidden';
+          interval.handleVisibilityChange();
+
+          expect(interval.state.intervalId).toBeUndefined();
+
+          // simulates triggering of visibilitychange event
+          interval.state.pageVisibility = 'visible';
+          interval.handleVisibilityChange();
+
+          expect(interval.state.intervalId).toBeTruthy();
+
+          done();
+        }, DEFAULT_SHORT_TIMEOUT);
+      });
+
+      it('should cancel on page unload', function (done) {
+        const interval = this.smartInterval;
+
+        setTimeout(() => {
+          $(document).trigger('page:before-unload');
+          expect(interval.state.intervalId).toBeUndefined();
+          expect(interval.getCurrentInterval()).toBe(interval.cfg.startingInterval);
+          done();
+        }, DEFAULT_SHORT_TIMEOUT);
+      });
+    });
+  });
+})(window.gl || (window.gl = {}));
diff --git a/spec/javascripts/subbable_resource_spec.js.es6 b/spec/javascripts/subbable_resource_spec.js.es6
new file mode 100644
index 00000000000..df395296791
--- /dev/null
+++ b/spec/javascripts/subbable_resource_spec.js.es6
@@ -0,0 +1,65 @@
+/* eslint-disable */
+//= vue
+//= vue-resource
+//= require jquery
+//= require subbable_resource
+
+/*
+* Test that each rest verb calls the publish and subscribe function and passes the correct value back
+*
+*
+* */
+((global) => {
+  describe('Subbable Resource', function () {
+    describe('PubSub', function () {
+      beforeEach(function () {
+        this.MockResource = new global.SubbableResource('https://example.com');
+      });
+      it('should successfully add a single subscriber', function () {
+        const callback = () => {};
+        this.MockResource.subscribe(callback);
+
+        expect(this.MockResource.subscribers.length).toBe(1);
+        expect(this.MockResource.subscribers[0]).toBe(callback);
+      });
+
+      it('should successfully add multiple subscribers', function () {
+        const callbackOne = () => {};
+        const callbackTwo = () => {};
+        const callbackThree = () => {};
+
+        this.MockResource.subscribe(callbackOne);
+        this.MockResource.subscribe(callbackTwo);
+        this.MockResource.subscribe(callbackThree);
+
+        expect(this.MockResource.subscribers.length).toBe(3);
+      });
+
+      it('should successfully publish an update to a single subscriber', function () {
+        const state = { myprop: 1 };
+
+        const callbacks = {
+          one: (data) => expect(data.myprop).toBe(2),
+          two: (data) => expect(data.myprop).toBe(2),
+          three: (data) => expect(data.myprop).toBe(2)
+        };
+
+        const spyOne = spyOn(callbacks, 'one');
+        const spyTwo = spyOn(callbacks, 'two');
+        const spyThree = spyOn(callbacks, 'three');
+
+        this.MockResource.subscribe(callbacks.one);
+        this.MockResource.subscribe(callbacks.two);
+        this.MockResource.subscribe(callbacks.three);
+
+        state.myprop++;
+
+        this.MockResource.publish(state);
+
+        expect(spyOne).toHaveBeenCalled();
+        expect(spyTwo).toHaveBeenCalled();
+        expect(spyThree).toHaveBeenCalled();
+      });
+    });
+  });
+})(window.gl || (window.gl = {}));