redmine_extensions 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eee22e1f0eeb964e748a80f0610126541f431768
-  data.tar.gz: 6d824882250e9379351fae51a6fb68ea4d62924c
+  metadata.gz: 002eb7a53213f9d31059a1c7bcc099463893c3b4
+  data.tar.gz: 3e26d2836b750e51d43361822f6c2f9da2453e5a
 SHA512:
-  metadata.gz: fc4adc022915545c8432e4867827169ba72e0d0af19eac89c2e0961fdd7843b461c241b6139791a91c3bb24e8280a9cb2109fee45219b794509f490b677b9db4
-  data.tar.gz: 938ab6557a3b51aee80e345aaad6c37237bb1cae9b725280763e4f2ca38e6fc72ab85e1db651a40ee1e2bd7fb79ec70fc91fae49cd5132af54d49c73a35db9c9
+  metadata.gz: c04c0b3b80337845436b639be277afba66b7322613f57973cccfe58fd640de034c3cad54120de67237967f1455873990667a7604ec894a901f951dda4a94a6eb
+  data.tar.gz: 642bf45996d775e20dad82f5c56fbb4d1e6f5252ec371a8a6104e8e3138a7ebd03948c8ccc0df21f5eec52527326b1993e4b742a81b343d1a25777b3fbce94cf

data/app/assets/javascripts/redmine_extensions/application.js

@@ -12,4 +12,6 @@
 //
 //= require ./easy_togglers
 //= require ./jquery.entityarray
+//= require ./render_polyfill
+//= require ./dynamic_loading
 //= require ./redmine_extensions

data/app/assets/javascripts/redmine_extensions/blocking.js

@@ -1,6 +1,10 @@
 /**
  * code, that cannot be delayed after window.onload or deferred
  */
-//= require ./blocking_polyfill
+//= require ./blocking_namespace
+// require ./event_bus
 //= require ./blocking_schedule
-//= require ./blocking_module
+// require ./blocking_module
+//= require ./blocking_polyfill
+//= require ./blocking_render
+//= require ./blocking_utils

data/app/assets/javascripts/redmine_extensions/blocking_module.js

@@ -1,58 +1,163 @@
 (function () {
   "use strict";
+  return;
+
+  var modules = {};
+  var waiters = {};
+  var modulesOrdered = {};
+
+  window.EASY = window.EASY || {};
+  EASY.modules = {};
+
+  var getMissingModule = function (dependencyNames) {
+    for (var i = 0; i < dependencyNames.length; i++) {
+      var dependencyName = dependencyNames[i];
+      var dependency = modules[dependencyName];
+      if (!dependency || !dependency.instance) return dependencyName;
+    }
+    return null;
+  };
+
+  EASY.eventBus.on("moduleReady", function (moduleName) {
+    if (waiters[moduleName]) {
+      var subWaiters = waiters[moduleName];
+      delete waiters[moduleName];
+      delete modulesOrdered[moduleName];
+      subWaiters.forEach(function (pack) {
+        requireTry(pack);
+      })
+    }
+  });
+
+
   /**
-   * @type {Object.<String,Array.<Function>>}
+   * @property {Function} factory
+   * @property {String} name
+   * @property {Array.<Module>} dependencies
+   * @constructor
    */
-  var waitingModules = {};
+  function Module(moduleName, dependencies, factory) {
+    this.name = moduleName;
+    this.dependencies = dependencies;
+    this.factory = factory;
+    if (modulesOrdered[moduleName]) {
+      this.construct();
+    }
+  }
+
+  Module.prototype.instance = null;
+  Module.prototype.factory = function () {
+    return {};
+  };
+  Module.prototype.name = "unnamed";
+  Module.prototype.dependencies = [];
+  Module.prototype.construct = function (visited) {
+    var dependencyInstances;
+    visited = visited || [];
+    if(visited.indexOf(this.name)>-1){
+      throw "Cyclic dependency: " + this.name + " -> " + visited[visited.length - 1] + " -> " + this.name;
+    }
+
+    if (this.dependencies) {
+      dependencyInstances = [];
+      /** @type {Module} */
+      var dependency;
+      for (var i = 0; i < this.dependencies.length; i++) {
+        dependency = this.dependencies[i];
+        if (dependency.instance) {
+          dependencyInstances.push(dependency.instance);
+        } else {
+          return dependency.construct(visited.concat([this.name]));
+        }
+      }
+    }
+    this.instance = this.factory(dependencyInstances);
+    if (this.instance) {
+      EASY.eventBus.fire("moduleReady", this.name);
+    } else {
+      var self = this;
+      setTimeout(function () {
+        self.construct();
+      }, 10);
+    }
+  };
+
+  var getDependencies = function (dependencyNames) {
+    var dependencyInstances = [];
+    for (var i = 0; i < dependencyNames.length; i++) {
+      var dependencyName = dependencyNames[i];
+      var dependency = modules[dependencyName];
+      if (!dependency) return null;
+      if (!dependency.instance) {
+        dependency.construct();
+      }
+      if (!dependency.instance) {
+        return null;
+      }
+      dependencyInstances.push(dependency.instance);
+    }
+    return dependencyInstances;
+  };
   /**
-   * @type {Object<String,boolean>}
+   * @param {{dependencies:Array.<String>,body:Function,context:Object}} pack
    */
-  var registeredModules = {};
+  var requireTry = function (pack) {
+    var dependencyInstances = getDependencies(pack.dependencies);
+    if (dependencyInstances !== null) {
+      return pack.body.apply([pack.context || window].concat(dependencyInstances));
+    }
+    var missingModule = getMissingModule(pack.dependencies);
+    if (missingModule === null) return;
+    if (!modules[missingModule]) {
+      modulesOrdered[missingModule] = true;
+    }
+
+    if (!waiters[missingModule]) {
+      waiters[missingModule] = [];
+    }
+    waiters[missingModule].push(pack);
+  };
 
 
-  window.EASY = window.EASY || {};
+  //####################################################################################################################
+
   /**
-   * Module constructor. Execute [func] only if [moduleName] is registered
+   * Module constructor. Execute [factory] only if [moduleName] is registered
    * Works also, if EASY.registerModule is called after module definition
    * @param {String} moduleName
-   * @param {Function} func
-   * @param {...*} rest - parameters for [func]
+   * @param {Array.<String>} dependencies
+   * @param {Function} factory
    */
-  EASY.module = function easyModule(moduleName, func, rest) {
-    if (registeredModules[moduleName]) {
-      if (rest !== undefined) {
-        func.apply(window, Array.prototype.slice.call(arguments, 2));
-      } else {
-        func();
-      }
-      return;
-    }
-    var modules = waitingModules[moduleName];
-    if (!modules) {
-      waitingModules[moduleName] = modules = [];
-    }
-    if (rest) {
-      var args = Array.prototype.slice.call(arguments, 2);
-      modules.push(function () {
-        func.apply(window, args);
-      })
-    } else {
-      modules.push(func);
-    }
+  EASY.modules.module = function easyModule(moduleName, dependencies, factory) {
+    modules[moduleName] = new Module(moduleName, dependencies, factory);
   };
   /**
-   * Enables modules with [moduleName] name
-   * If any modules are in waitingModules, they are executed immediately.
    * @param {String} moduleName
+   * @param {Function} getter
    */
-  EASY.registerModule = function registerModule(moduleName) {
-    registeredModules[moduleName] = true;
-    if (waitingModules[moduleName]) {
-      var modules = waitingModules[moduleName];
-      for (var i = 0; i < modules.length; i++) {
-        modules[i]();
-      }
-      delete waitingModules[moduleName];
-    }
+  EASY.modules.toModule = function (moduleName, getter) {
+    modules[moduleName] = new Module(moduleName, null, getter);
   };
+  /**
+   * @param {Array.<String>} dependencies
+   * @param {Function} body
+   * @param {Object} [context]
+   */
+  EASY.modules.require = function (dependencies, body, context) {
+    if (!dependencies || dependencies.length === 0) body.call(context || window);
+    requireTry({dependencies: dependencies, body: body, context: context});
+  };
+  //####################################################################################################################
+
+  EASY.modules.toModule("jQuery", function () {
+    return window.jQuery;
+  });
+  EASY.modules.toModule("$", function () {
+    return window.jQuery;
+  });
+  EASY.modules.toModule("jQueryUI", function () {
+    if (window.jQuery && window.jQuery.widget) {
+      return window.jQuery;
+    }
+  });
 })();

data/app/assets/javascripts/redmine_extensions/blocking_namespace.js

@@ -0,0 +1,3 @@
+window.EASY = window.EASY || {};
+window.EasyGem = window.EasyGem || {};
+window.EasyGem.test = window.EasyGem.test || {};

data/app/assets/javascripts/redmine_extensions/blocking_polyfill.js

@@ -1,5 +1,4 @@
-
-(function($, window, undefined) {
+(function (window, undefined) {
   // http://paulirish.com/2011/requestanimationframe-for-smart-animating/
   // http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating
 
@@ -7,28 +6,21 @@
   // fixes from Paul Irish and Tino Zijdel
 
   var lastTime = 0,
-      running,
-      animate = function (elem) {
-        if (running) {
-          window.requestAnimationFrame(animate, elem);
-          jQuery.fx.tick();
-        }
-      },
       vendors = ['ms', 'moz', 'webkit', 'o'];
 
-  for(var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
-    window.requestAnimationFrame = window[vendors[x]+'RequestAnimationFrame'];
-    window.cancelAnimationFrame = window[vendors[x]+'CancelAnimationFrame']
-        || window[vendors[x]+'CancelRequestAnimationFrame'];
+  for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
+    window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
+    window.cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame']
+        || window[vendors[x] + 'CancelRequestAnimationFrame'];
   }
 
   if (!window.requestAnimationFrame)
-    window.requestAnimationFrame = function(fn, element) {
+    window.requestAnimationFrame = function (fn, element) {
       var currTime = new Date().getTime(),
           delta = currTime - lastTime,
           timeToCall = Math.max(0, 16 - delta);
 
-      var id = window.setTimeout(function() {
+      var id = window.setTimeout(function () {
             fn(currTime + timeToCall);
           },
           timeToCall
@@ -40,20 +32,8 @@
     };
 
   if (!window.cancelAnimationFrame) {
-    window.cancelAnimationFrame = function(id) {
+    window.cancelAnimationFrame = function (id) {
       clearTimeout(id);
     };
   }
-
-  jQuery.fx.timer = function (timer) {
-    if (timer() && jQuery.timers.push(timer) && !running) {
-      running = true;
-      animate(timer.elem);
-    }
-  };
-
-  jQuery.fx.stop = function() {
-    running = false;
-  };
-
-}(jQuery, this));
+}(this));

data/app/assets/javascripts/redmine_extensions/blocking_render.js

@@ -0,0 +1,112 @@
+(function () {
+  /**
+   * @callback RenderFunction
+   */
+  // noinspection JSMismatchedCollectionQueryUpdate
+  /**
+   * @type {Array.<{body:RenderFunction,ctx:Object}>}
+   */
+  var readQueue = [];
+  // noinspection JSMismatchedCollectionQueryUpdate
+  /**
+   * @type {Array.<{body:RenderFunction,ctx:Object,value:*}>}
+   */
+  var renderQueue = [];
+  var renderPhase = false;
+  var lastTime = 0.0;
+  /**
+   * @param {RenderFunction} body
+   * @param {Object} [context]
+   */
+  EasyGem.read = function (body, context) {
+    if (renderPhase) {
+      readQueue.push({body: body, ctx: context});
+    } else {
+      body.call(context);
+    }
+  };
+  /**
+   * @param {RenderFunction} body
+   * @param {Object} [context]
+   */
+  EasyGem.render = function (body, context) {
+    if (renderPhase) {
+      body.call(context, lastTime);
+    } else {
+      renderQueue.push({body: body, ctx: context});
+    }
+  };
+  /**
+   * @param {RenderFunction} read
+   * @param {RenderFunction} render
+   * @param {Object} [context]
+   */
+  EasyGem.readAndRender = function (read, render, context) {
+    if (renderPhase) {
+      readQueue.push({
+        body: function () {
+          var value = read.call(context);
+          renderQueue.push({body: render, ctx: context, value: value});
+        }, ctx: context
+      });
+    } else {
+      var value = read.call(context);
+      renderQueue.push({body: render, ctx: context, value: value});
+    }
+  };
+  EasyGem.schedule.main(function () {
+    var loop = function (time) {
+      renderPhase = true;
+      lastTime=time;
+
+      setTimeout(function () {
+        renderPhase = false;
+        if (readQueue.length) {
+          var queue = readQueue;
+          readQueue = [];
+          for (i = 0; i < queue.length; i++) {
+            var pack = queue[i];
+            pack.body.call(pack.ctx);
+          }
+        }
+      }, 0);
+      if (renderQueue.length) {
+        var queue = renderQueue;
+        renderQueue = [];
+        for (var i = 0; i < queue.length; i++) {
+          var pack = queue[i];
+          pack.body.call(pack.ctx, time, pack.value);
+        }
+        renderQueue = [];
+      }
+      requestAnimationFrame(loop);
+    };
+    requestAnimationFrame(loop);
+  });
+  EasyGem.test.render = {
+    getPhase: function () {
+      return renderPhase ? "render" : "read";
+    }
+    // ,
+    // test1: function () {
+    //   console.log("Phase "+this.getPhase());
+    //   EasyGem.render(function (time) {
+    //     console.assert(this.getPhase() === "render", "Phase should be render, not ", this.getPhase());
+    //     console.assert(typeof time === "number", "Time ", time, " should be number, not ", typeof time);
+    //     console.log("render done");
+    //   }, this);
+    //   EasyGem.read(function () {
+    //     console.assert(this.getPhase() === "read", "Phase should be read, not ", this.getPhase());
+    //     console.log("read done");
+    //   }, this);
+    //   EasyGem.readAndRender(function () {
+    //     console.assert(this.getPhase() === "read", "Phase should be read, not ", this.getPhase());
+    //     return 562;
+    //   }, function (time, value) {
+    //     console.assert(this.getPhase() === "render", "Phase should be render, not ", this.getPhase());
+    //     console.assert(value === 562, "Value should be 562, not ", value);
+    //     console.log("readAndRender done");
+    //   }, this)
+    // }
+  };
+})();

data/app/assets/javascripts/redmine_extensions/blocking_schedule.js

@@ -1,20 +1,35 @@
 (function () {
   "use strict";
   /**
-   * @typedef {Function} SchedulePrerequisite
+   * @callback SchedulePrerequisite
    * @return {boolean}
    */
   /**
-   * @typedef {{func:Function,[priority]:number,[pre]:SchedulePrerequisite}} ScheduleTask
+   * @typedef {{func:Function,[priority]:number,[pre]:SchedulePrerequisite,[pres]:Array.<SchedulePrerequisite>}} ScheduleTask
    */
-  var lateMaxDelay = 3;
-  var lateDelay = lateMaxDelay;
+  // noinspection JSMismatchedCollectionQueryUpdate
   /** @type {Array.<ScheduleTask>} */
   var mainArray = [];
   /** @type {Array.<ScheduleTask>} */
   var lateArray = [];
-  /** @type {Array.<ScheduleTask|null>} */
+  /** @type {Array.<?ScheduleTask>} */
   var prerequisiteArray = [];
+  var moduleGetters = {
+    jquery: function () {
+      return window.jQuery;
+    },
+    jqueryui: function () {
+      return window.jQuery && jQuery.Widget;
+    },
+    c3:function () {
+      return window.c3;
+    },
+    ckeditor:function () {
+      return window.CKEDITOR;
+    }
+  };
+  var moduleInstances = {};
+  var writeOut = false;
 
   /** @param {ScheduleTask} a
    * @param {ScheduleTask} b
@@ -28,39 +43,35 @@
     if (mainArray.length > 0) {
       count1 = mainArray.length;
       mainArray.sort(sortFunction);
-      for (var i = 0; i < mainArray.length; i++) {
-        mainArray[i].func();
-      }
+      var queue = mainArray;
       mainArray = [];
-      lateDelay = lateMaxDelay;
+      for (var i = 0; i < queue.length; i++) {
+        queue[i].func();
+      }
     }
     var count2 = executePrerequisites();
     var count3 = 0;
-    if (lateArray.length) {
-      if (lateDelay === 0) {
-        lateArray.sort(sortFunction);
-        // console.log(lateArray.map(function (p1) {
-        //   return p1.priority
-        // }));
-        var limitPriority = lateArray[0].priority - 5;
-        for (i = 0; i < lateArray.length; i++) {
-          if (lateArray[i].priority <= limitPriority) break;
-          lateArray[i].func.call(window);
-        }
-        if (i === lateArray.length) {
-          count3 = lateArray.length;
-          lateArray = [];
-          lateDelay = lateMaxDelay;
-        } else {
-          lateArray = lateArray.slice(i);
-          count3 = i;
-        }
+    if (lateArray.length && count1 === 0 && count2 === 0) {
+      lateArray.sort(sortFunction);
+      var limitPriority = lateArray[0].priority - 5;
+      for (i = 0; i < lateArray.length; i++) {
+        if (lateArray[i].priority <= limitPriority) break;
+      }
+      count3 = i;
+      if (i === lateArray.length) {
+        queue = lateArray;
+        lateArray = [];
       } else {
-        lateDelay--;
+        queue = lateArray.slice(0, i);
+        lateArray = lateArray.slice(i);
+      }
+      for (i = 0; i < queue.length; i++) {
+        if (queue[i].priority <= limitPriority) break;
+        queue[i].func.call(window);
       }
     }
-    if (EASY.schedule.out && (count1 || count2 || count3)) {
-      console.log("EE: " + count1 + " REQ: " + count2 + " LATE: " + count3);
+    if (writeOut && (count1 || count2 || count3)) {
+      console.log("MAIN: " + count1 + " REQ: " + count2 + " LATE: " + count3);
     }
   };
   var isNotNull = function (a) {
@@ -71,9 +82,8 @@
     if (prerequisiteArray.length === 0) return 0;
     var count = 0;
     for (var i = 0; i < prerequisiteArray.length; i++) {
-      if (prerequisiteArray[i].pre()) {
+      if(executeOnePrerequisite(prerequisiteArray[i])) {
         count++;
-        prerequisiteArray[i].func.call(window);
         prerequisiteArray[i] = null;
       }
     }
@@ -83,19 +93,60 @@
     }
     return count;
   };
+  var executeOnePrerequisite = function (pack) {
+    var getter, getters, instance, instances;
+    if (getter = pack.pre) {
+      instance = preparePrerequisite(getter);
+      if (instance) {
+        pack.func.call(window, instance);
+        return true;
+      }
+      return false;
+    } else if (getters = pack.pres) {
+      instances = [];
+      for (var j = 0; j < getters.length; j++) {
+        getter = getters[j];
+        instance = preparePrerequisite(getter);
+        if (!instance) break;
+        instances.push(instance);
+      }
+      if (instances.length !== getters.length) return false;
+      pack.func.apply(window, instances);
+      return true;
+    }
+  };
+  /**
+   * @param {(Function|string)} getter
+   * @return {(Object|null)}
+   */
+  var preparePrerequisite = function (getter) {
+    var instance;
+    if (typeof getter === "string") {
+      if (moduleInstances[getter]) {
+        return moduleInstances[getter];
+      } else if (moduleGetters[getter]) {
+        instance = moduleGetters[getter]();
+        if (instance) {
+          moduleInstances[getter] = instance;
+        }
+        return instance;
+      }
+      return null;
+    } else {
+      return getter();
+    }
+  };
 
   var cycle = function scheduleCycle() {
+    setTimeout(cycle, 30);
     tick();
-    window.requestAnimationFrame(cycle);
   };
   document.addEventListener("DOMContentLoaded", cycle);
-  window.EASY = window.EASY || {};
   /**
    *
-   * @type {{out: boolean, late: EASY.schedule.late, require: EASY.schedule.require, main: EASY.schedule.main}}
+   * @type {{out: boolean, late: EASY.schedule.late, require: EASY.schedule.require, main: EASY.schedule.main, define: EASY.schedule.define}}
    */
-  EASY.schedule = {
-    out: false,
+  EasyGem.schedule = {
     /**
      * Functions, which should be executed right after "DOMContentLoaded" event
      * @param {Function} func
@@ -105,20 +156,83 @@
       mainArray.push({func: func, priority: priority || 0})
     },
     /**
-     * Functions, which should wait for prerequisite fulfillment
+     * Functions, which should wait for [prerequisite] fulfillment
+     * After that [func] is executed with return value of [prerequisite] as parameter
      * @param {Function} func
-     * @param {SchedulePrerequisite} prerequisite
+     * @param {...(SchedulePrerequisite|string)} prerequisite
      */
     require: function (func, prerequisite) {
-      prerequisiteArray.push({func: func, pre: prerequisite})
+      if (arguments.length > 2) {
+        var pres = [];
+        for (var i = 1; i < arguments.length; i++) {
+          if (typeof arguments[i] === "string") {
+            pres.push(arguments[i].toLocaleLowerCase());
+          } else {
+            pres.push(arguments[i]);
+          }
+        }
+        var pack = {func: func, pres: pres};
+        if (!executeOnePrerequisite(pack)) {
+          prerequisiteArray.push(pack);
+        }
+      } else {
+        if (typeof prerequisite === "string") {
+          prerequisite = prerequisite.toLocaleLowerCase();
+        }
+        pack = {func: func, pre: prerequisite};
+        if (!executeOnePrerequisite(pack)) {
+          prerequisiteArray.push(pack);
+        }
+      }
     },
     /**
      * Functions, which should be executed after several render loops after "DOMContentLoaded" event
+     * each 5 levels of priority increase delay by one stack
      * @param {Function} func
      * @param {number} [priority]
      */
     late: function (func, priority) {
       lateArray.push({func: func, priority: priority || 0})
+    },
+    /**
+     * Define module, which will be loaded by [require] function with [name] argument
+     * Only one instance will be created
+     * @param {string} name
+     * @param {Function} getter
+     */
+    define: function (name, getter) {
+      moduleGetters[name.toLocaleLowerCase()] = getter;
+    }
+  };
+  EASY.schedule = EasyGem.schedule;
+  EasyGem.test.schedule = {
+    setOut: function (state) {
+      writeOut = state;
+    },
+    isLoaded: function () {
+      if (mainArray.length > 0) return false;
+      if (prerequisiteArray.length > 0) return false;
+      return lateArray.length <= 0;
+    },
+    lateIsLoaded: function () {
+      return lateArray.length <= 0;
+    },
+    queueContents: function () {
+      var modules = [];
+      for (var i = 0; i < prerequisiteArray.length; i++) {
+        var prerequisite = prerequisiteArray[i];
+        if (typeof prerequisite.pre === "string") {
+          modules.push(prerequisite.pre);
+        } else if (prerequisite.pres) {
+          for (var j = 0; j < prerequisite.pres.length; j++) {
+            var pre = prerequisite.pres[j];
+            if (typeof pre === "string") {
+              modules.push(pre);
+            }
+          }
+        }
+      }
+      return {main: mainArray.length, late: lateArray, require: prerequisiteArray.length, waitsFor: modules};
     }
   };
 })();