redmine_extensions 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee45cc8ecef4a8702670c2992e3599fdb96682dd
-  data.tar.gz: ffd40d9a0183a752fc463c8f7be2ae4aec17ddf7
+  metadata.gz: 4b6908fe3fa7949e58a19003cbc84109a5aa1d99
+  data.tar.gz: ef57c4be4e0d348483a6f44d3d31920fbb22f0c4
 SHA512:
-  metadata.gz: 3561ac257b97d0eb8a69a1cf5b7a7c185e852e0dc40db32f6d192a2e82ebe8336f44e741d2963d18602c37b43bebd343caa90afb804f54a66dad60321fa1cb89
-  data.tar.gz: fae10df3d70b5b551fa62bdf4289ff09490eba0cc3aa6423307923e49674e8fa5580e431419408c2ba706681ac783c003293ad3c56323f49f34e6d0254898615
+  metadata.gz: 0fbc838412a96e26c5c068af3c641404bdd11bb87237935826c8ffe33ebdae4b758d76ffa60b61f4670888a43bcc8b63267c87a45370e3c70a57d56241bfd8b7
+  data.tar.gz: be933bea060cdb21c914b7e8d91504f8442426ec2b3ecf2923165f271e80b8d6c84446ada363068d23c01a5269d86ebf8d8e65cfb8c95b360eda42796ced39c5

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

@@ -13,5 +13,4 @@
 //= require ./easy_togglers
 //= require ./jquery.entityarray
 //= require ./render_polyfill
-//= require ./dynamic_loading
 //= require ./redmine_extensions

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

@@ -4,7 +4,8 @@
 //= require ./blocking_namespace
 // require ./event_bus
 //= require ./blocking_schedule
-// require ./blocking_module
+//= require ./blocking_module
 //= require ./blocking_polyfill
 //= require ./blocking_render
 //= require ./blocking_utils
+//= require ./blocking_dynamic_loading

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

@@ -0,0 +1,53 @@
+(function () {
+  var alreadyLoaded = {};
+  EasyGem.dynamic = {
+    _alreadyLoaded: alreadyLoaded,
+    /**
+     * Append Javascript <script> tag to page
+     * @example
+     * EasyGem.dynamic.jsTag("/plugin_assets/my_plugin/javascripts/counter.js");
+     * EasyGem.schedule.require(function(counter){
+     *   setInterval(counter.count(), 1000);
+     * }, function(){
+     *   return window.utils.counter;
+     * })
+     * @param {String} src - absolute path to requested file
+     */
+    jsTag: function (src) {
+      if (alreadyLoaded[src]) return;
+      alreadyLoaded[src] = true;
+      var jsScript = document.createElement("script");
+      jsScript.setAttribute("src", src);
+      jsScript.setAttribute("defer", "true");
+      document.head.appendChild(jsScript);
+    },
+    /**
+     * Append CSS <link> tag to page
+     * @param {String} src - absolute path to requested file
+     */
+    cssTag: function (src) {
+      if (alreadyLoaded[src]) return;
+      alreadyLoaded[src] = true;
+      var link = document.createElement('link');
+      link.rel = "stylesheet";
+      link.type = "text/css";
+      link.href = src;
+      link.media = "all";
+      document.head.appendChild(link);
+    },
+    /**
+     * Load multiple JS files into page
+     * @param {Array.<String>} array
+     */
+    jsTags: function (array) {
+      array.forEach(this.jsTag);
+    },
+    /**
+     * Load multiple CSS files into page
+     * @param {Array.<String>} array
+     */
+    cssTags: function (array) {
+      array.forEach(this.cssTag);
+    }
+  };
+})();

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

@@ -1,163 +1,244 @@
 (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);
-      })
-    }
-  });
+  var moduleInstances = {};
+  /** @type {Object.<String,EasyModule>} */
+  var moduleDefinitions = {};
+  /** @type {Array.<Waiter>} */
+  var waiters = [];
+  /** @type {Object.<String,String>} */
+  var urls = {};
 
+  function Waiter(dependencies, callback) {
+    this.dependencies = dependencies;
+    this.callback = callback;
+  }
 
   /**
-   * @property {Function} factory
    * @property {String} name
-   * @property {Array.<Module>} dependencies
+   * @property {Array.<String>} dependencies
+   * @property {Array.<Waiter>} waiters
    * @constructor
    */
-  function Module(moduleName, dependencies, factory) {
+  function EasyModule(moduleName) {
     this.name = moduleName;
-    this.dependencies = dependencies;
-    this.factory = factory;
-    if (modulesOrdered[moduleName]) {
-      this.construct();
-    }
+    setTimeout(function () {
+      executeWaiters();
+    }, 0);
   }
 
-  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;
+  /**
+   * @methodOf EasyModule
+   */
+  EasyModule.prototype.checkDependencies = function () {
+    if (!checkDependencies(this.dependencies)) return false;
+    var instance = {};
+    var waiters = this.waiters;
+    for (var i = 0; i < waiters.length; i++) {
+      var waiter = waiters[i];
+      var instances = waiter.dependencies.map(function (moduleName) {
+        return moduleInstances[moduleName];
+      });
+      instance = waiter.callback.apply(instance, instances) || instance;
     }
+    moduleInstances[this.name] = instance;
+  };
+
+  function checkDependencies(dependencies) {
+    // console.log({dependencies: dependencies,instances:Object.keys(moduleInstances),definitions:Object.keys(moduleDefinitions)});
+    for (var i = 0; i < dependencies.length; i++) {
+      /** @type {String} */
+      var dependency = dependencies[i];
+      if (moduleInstances[dependency]) continue;
+      if (!moduleDefinitions[dependency]) {
 
-    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]));
+        for (var j = i; j < dependencies.length; j++) {
+          loadModule(dependencies[j]);
         }
+        return false;
       }
+      moduleDefinitions[dependency].checkDependencies();
+      if (!moduleInstances[dependency]) return false;
     }
-    this.instance = this.factory(dependencyInstances);
-    if (this.instance) {
-      EASY.eventBus.fire("moduleReady", this.name);
-    } else {
-      var self = this;
-      setTimeout(function () {
-        self.construct();
-      }, 10);
-    }
-  };
+    return true;
+  }
 
-  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;
+  function executeWaiter(waiter) {
+    var instances = waiter.dependencies.map(function (moduleName) {
+      return moduleInstances[moduleName];
+    });
+    waiter.callback.apply(window, instances);
+  }
+
+  function executeWaiters() {
+    var executed = false;
+    for (var i = 0; i < waiters.length; i++) {
+      var waiter = waiters[i];
+      if (checkDependencies(waiter.dependencies)) {
+        executeWaiter(waiter);
+        executed = true;
+        waiters[i] = null;
       }
-      dependencyInstances.push(dependency.instance);
-    }
-    return dependencyInstances;
-  };
-  /**
-   * @param {{dependencies:Array.<String>,body:Function,context:Object}} pack
-   */
-  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;
     }
+    waiters = waiters.filter(function (item) {
+      return item;
+    })
+  }
 
-    if (!waiters[missingModule]) {
-      waiters[missingModule] = [];
+  function loadModule(moduleName) {
+    var url = urls[moduleName];
+    if (url) {
+      EasyGem.dynamic.jsTag(url);
     }
-    waiters[missingModule].push(pack);
-  };
+  }
 
+  function findMissingModules() {
+    var moduleMap = {};
+    for (var i = 0; i < waiters.length; i++) {
+      missingModules(waiters[i].dependencies, moduleMap);
+    }
+    var modules = Object.keys(moduleMap);
+    if (modules.length > 0) {
+      throw "Missing modules: " + modules.join(", ");
+    }
+  }
 
-  //####################################################################################################################
+  function missingModules(dependencies, modules) {
+    for (var i = 0; i < dependencies.length; i++) {
+      /** @type {String} */
+      var dependency = dependencies[i];
+      if (moduleInstances[dependency]) continue;
+      if (!moduleDefinitions[dependency]) {
+        modules[dependency] = true;
+        continue;
+      }
+      missingModules(moduleDefinitions[dependency].dependencies, modules);
+    }
+  }
 
   /**
-   * Module constructor. Execute [factory] only if [moduleName] is registered
-   * Works also, if EASY.registerModule is called after module definition
-   * @param {String} moduleName
-   * @param {Array.<String>} dependencies
-   * @param {Function} factory
+   *
+   * @type {{urls: Object<String, String>, module: EasyGem.module.module, part: EasyGem.module.part, transform: EasyGem.module.transform, setUrl: EasyGem.module.setUrl}}
    */
-  EASY.modules.module = function easyModule(moduleName, dependencies, factory) {
-    modules[moduleName] = new Module(moduleName, dependencies, factory);
+  EasyGem.module = {
+    /**
+     * Object containing urls for modules. Filling the urls is recommended to do in <head>.
+     * Use [moduleName] as key and absolute path (with or without a hostname) as value
+     *   If url have to be specified later, use EasyGem.module.setUrl() instead.
+     * @type {Object<String, String>}
+     * @example
+     *   EasyGem.module.urls["myModule"] = "/assets/my_module.js"
+     */
+    urls: urls,
+    /**
+     * Define module in one separate file. Use this method as first line of the file
+     * Module can be downloaded on-demand by loadModules() if url is provided by setUrl() function.
+     * @example
+     *   EasyGem.module.module("myModule", ["jQuery", "c3"], function($, c3) {
+     *     return {
+     *       init: function(){
+     *         c3.init($("#graph"));
+     *       }
+     *     }
+     *   }
+     * @param {String} moduleName
+     * @param {Array.<String>} prerequisites - other modules needed for construction of module
+     * @param {Function} getter - factory function
+     */
+    module: function (moduleName, prerequisites, getter) {
+      var module = moduleDefinitions[moduleName] = new EasyModule(moduleName);
+      module.dependencies = prerequisites;
+      module.waiters = [new Waiter(prerequisites, getter)];
+    },
+    /**
+     * Define module part if module code is distributed into many separate files.
+     *   For dynamic loading by url, all files have to be combine by pipeline into one.
+     * Module is executed only if all [prerequisites] from all parts of the module is fulfilled, but only part's
+     *   [prerequisites] will be used as arguments for [getter].
+     * [prerequisites] argument can be omitted if no prerequisites are required
+     * @param {String} moduleName
+     * @param {Array.<String>|Function} prerequisites
+     * @param {Function} [getter]
+     */
+    part: function (moduleName, prerequisites, getter) {
+      if (getter === undefined) {
+        getter = prerequisites;
+        prerequisites = [];
+      }
+      var module = moduleDefinitions[moduleName];
+      if (!module){
+        module = moduleDefinitions[moduleName] = new EasyModule(moduleName);
+        module.waiters = [];
+        module.dependencies = [];
+      }
+      module.waiters.push(new Waiter(prerequisites, getter));
+      for (var i = 0; i < prerequisites.length; i++) {
+        var prerequisite = prerequisites[i];
+        if (module.dependencies.indexOf(prerequisite) === -1) {
+          module.dependencies.push(prerequisite);
+        }
+      }
+    },
+    /**
+     * Transform simple EasyGem.schedule.require [prerequisite] into proper module.
+     * Use it sparingly if module have to be defined for usage in other modules as prerequisite.
+     * If named getter is saved by EasyGem.schedule.define, the name can also be used.
+     * @param {String} moduleName
+     * @param {String|Function} prerequisite - getter function
+     * @example
+     *   EasyGem.module.transform("c3", function() {
+     *     return window.c3;
+     *   });
+     *     -- OR --
+     *   EasyGem.module.transform("c3", "c3");
+     */
+    transform: function (moduleName, prerequisite) {
+      EasyGem.schedule.require(function (instance) {
+        moduleInstances[moduleName] = instance;
+        executeWaiters();
+      }, prerequisite);
+    },
+    /**
+     * Save url for later dynamic load of the module. Use it only if url is defined later in page parsing.
+     *   If you can specify url in header, use EasyGem.module.urls object instead;
+     * @param {String} moduleName
+     * @param {String} url - absolute url of the module file, with or without hostname
+     */
+    setUrl: function (moduleName, url) {
+      urls[moduleName] = url;
+      executeWaiters();
+    }
   };
   /**
-   * @param {String} moduleName
-   * @param {Function} getter
+   * Load specified modules and execute [callback].
+   * Module instances are constructed if not constructed before.
+   * Missing modules are downloaded if url is provided.
+   * @param {Array.<String>} moduleNames
+   * @param {Function} callback - function with module instances as arguments
+   * @example
+   *   EasyGem.loadModules(["jQuery", "myModule"], function($, myModule) {
+   *     myModule.init($("#my_module_container"));
+   *   });
    */
-  EASY.modules.toModule = function (moduleName, getter) {
-    modules[moduleName] = new Module(moduleName, null, getter);
+  EasyGem.loadModules = function (moduleNames, callback) {
+    var waiter = new Waiter(moduleNames, callback);
+    if (checkDependencies(moduleNames)) {
+      executeWaiter(waiter);
+    } else {
+      waiters.push(waiter);
+      setTimeout(findMissingModules, 5000);
+    }
   };
   /**
-   * @param {Array.<String>} dependencies
-   * @param {Function} body
-   * @param {Object} [context]
+   * Same as EasyGem.loadModules, but only for one module.
+   * @param {String} moduleName
+   * @param {Function} callback - function with the module instance as first argument
    */
-  EASY.modules.require = function (dependencies, body, context) {
-    if (!dependencies || dependencies.length === 0) body.call(context || window);
-    requireTry({dependencies: dependencies, body: body, context: context});
+  EasyGem.loadModule = function (moduleName, callback) {
+    this.loadModules([moduleName], callback);
   };
-  //####################################################################################################################
+  var transform = EasyGem.module.transform;
+  transform("jQuery", "jQuery");
+  transform("jQueryUI", "jQueryUI");
 
-  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_schedule.js

@@ -86,9 +86,25 @@
     if (prerequisiteArray.length === 0) return 0;
     var count = 0;
     for (var i = 0; i < prerequisiteArray.length; i++) {
-      if (executeOnePrerequisite(prerequisiteArray[i])) {
+      var pack = prerequisiteArray[i];
+      if (!pack) {
         count++;
-        prerequisiteArray[i] = null;
+        continue;
+      }
+      if (pack.pre) {
+        var instance = preparePrerequisite(pack.pre);
+        if (instance) {
+          count++;
+          prerequisiteArray[i] = null;
+          pack.func.call(window, instance);
+        }
+      } else {
+        var instances = prepareMorePrerequisites(pack.pres);
+        if (instances) {
+          count++;
+          prerequisiteArray[i] = null;
+          pack.func.apply(window, instances);
+        }
       }
     }
     if (count) {
@@ -97,28 +113,6 @@
     }
     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)}
@@ -140,6 +134,15 @@
       return getter();
     }
   };
+  var prepareMorePrerequisites = function (getters) {
+    var instance, instances = [];
+    for (var j = 0; j < getters.length; j++) {
+      instance = preparePrerequisite(getters[j]);
+      if (!instance) return null;
+      instances.push(instance);
+    }
+    return instances;
+  };
 
   var cycle = function scheduleCycle() {
     setTimeout(cycle, 30);
@@ -148,7 +151,7 @@
   document.addEventListener("DOMContentLoaded", cycle);
   /**
    *
-   * @type {{out: boolean, late: EASY.schedule.late, require: EASY.schedule.require, main: EASY.schedule.main, define: EASY.schedule.define}}
+   * @type {{late: EasyGem.schedule.late, require: EasyGem.schedule.require, main: EasyGem.schedule.main, define: EasyGem.schedule.define}}
    */
   EasyGem.schedule = {
     /**
@@ -187,17 +190,21 @@
             pres.push(arguments[i]);
           }
         }
-        var pack = {func: func, pres: pres};
-        if (!executeOnePrerequisite(pack)) {
-          prerequisiteArray.push(pack);
+        var instances = prepareMorePrerequisites(pres);
+        if (instances) {
+          func.apply(window, instances);
+        } else {
+          prerequisiteArray.push({func: func, pres: pres});
         }
       } else {
         if (typeof prerequisite === "string") {
           prerequisite = prerequisite.toLowerCase();
         }
-        pack = {func: func, pre: prerequisite};
-        if (!executeOnePrerequisite(pack)) {
-          prerequisiteArray.push(pack);
+        var instance = preparePrerequisite(prerequisite);
+        if (instance) {
+          func.call(window, instance);
+        } else {
+          prerequisiteArray.push({func: func, pre: prerequisite});
         }
       }
     },
@@ -223,9 +230,19 @@
      * });
      * @param {string} name
      * @param {Function} getter - getter or constructor
+     * @param {...(SchedulePrerequisite|string)} [prerequisite] - more than one prerequisite can be specified here
+     *                                           as rest parameters. Function or String are accepted. If String is used,
+     *                                           predefined getter from [moduleGetters] or getter defined by [define]
+     *                                           are called.
      */
-    define: function (name, getter) {
-      moduleGetters[name.toLowerCase()] = getter;
+    define: function (name, getter, prerequisite) {
+      if (prerequisite) {
+        this.require.apply(this, [function () {
+          moduleGetters[name.toLowerCase()] = getter;
+        }].concat(Array.prototype.slice.call(arguments, 2)));
+      } else {
+        moduleGetters[name.toLowerCase()] = getter;
+      }
     }
   };
   EASY.schedule = EasyGem.schedule;

data/app/views/easy_front_end/_easy_front_end.html.erb

@@ -2,7 +2,7 @@
   <%=
     if params['combine_by_pipeline'].nil?
       if Rails.env.development? && ENV['DART'] == '1'
-        javascript_include_tag('dart/localhost', plugin: plugin)
+        javascript_include_tag('dart/localhost', plugin: plugin, defer: true)
       else
         javascript_include_tag("#{plugin}.dart", defer: true)
       end
@@ -10,7 +10,7 @@
       if params['combine_by_pipeline'] == 'false'
         #javascript_include_tag('dart/debug', plugin: plugin, defer: true)
         if ENV['DART'] == '1'
-          javascript_include_tag('dart/localhost', plugin: plugin)
+          javascript_include_tag('dart/localhost', plugin: plugin, defer: true)
         end
       else
         javascript_include_tag("#{plugin}.dart", defer: true)

data/lib/generators/redmine_extensions/entity/templates/index.api.rsb.erb

@@ -1,5 +1,5 @@
-api.array :<%= model_name_pluralize_underscored %>, api_meta(total_count: @entity_count, offset: @offset, limit: @limit) do
-  @entities.each do |<%= model_name_underscored %>|
-    render_api_<%= model_name_underscored %>(api, <%= model_name_underscored %>)
-  end
-end
+api.array :<%= model_name_pluralize_underscored %>, api_meta(total_count: @entity_count, offset: @offset, limit: @limit) do
+  @entities.each do |<%= model_name_underscored %>|
+    render_api_<%= model_name_underscored %>(api, <%= model_name_underscored %>)
+  end
+end

data/lib/generators/redmine_extensions/entity/templates/mail_added.html.erb.erb

@@ -1 +1 @@
-<h1><%%= link_to(@<%= model_name_underscored %>.to_s, @<%= model_name_underscored %>_url) %></h1>
+<h1><%%= link_to(@<%= model_name_underscored %>.to_s, @<%= model_name_underscored %>_url) %></h1>

data/lib/generators/redmine_extensions/entity/templates/mail_added.text.erb.erb

@@ -1,2 +1,2 @@
-<%%= @<%= model_name_underscored %>.to_s %>
-<%%= @<%= model_name_underscored %>_url %>
+<%%= @<%= model_name_underscored %>.to_s %>
+<%%= @<%= model_name_underscored %>_url %>

data/lib/generators/redmine_extensions/entity/templates/mail_updated.text.erb.erb

@@ -1,2 +1,2 @@
-<%%= @<%= model_name_underscored %>.to_s %>
-<%%= @<%= model_name_underscored %>_url %>
+<%%= @<%= model_name_underscored %>.to_s %>
+<%%= @<%= model_name_underscored %>_url %>

data/lib/generators/redmine_extensions/entity/templates/routes.rb.erb

@@ -1,13 +1,13 @@
-<% if project? %>
-resources :projects do
-  resources :<%= model_name_pluralize_underscored %>
-end
-<% end %>
-resources :<%= model_name_pluralize_underscored %> do
-  collection do
-    get 'autocomplete'
-    get 'bulk_edit'
-    post 'bulk_update'
-    get 'context_menu'
-  end
+<% if project? %>
+resources :projects do
+  resources :<%= model_name_pluralize_underscored %>
+end
+<% end %>
+resources :<%= model_name_pluralize_underscored %> do
+  collection do
+    get 'autocomplete'
+    get 'bulk_edit'
+    post 'bulk_update'
+    get 'context_menu'
+  end
 end

data/lib/redmine_extensions/version.rb

@@ -1,3 +1,3 @@
 module RedmineExtensions
-  VERSION = '0.2.10'
+  VERSION = '0.2.11'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redmine_extensions
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.11
 platform: ruby
 authors:
 - Easy Software Ltd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-18 00:00:00.000000000 Z
+date: 2018-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -146,13 +146,13 @@ files:
 - Rakefile
 - app/assets/javascripts/redmine_extensions/application.js
 - app/assets/javascripts/redmine_extensions/blocking.js
+- app/assets/javascripts/redmine_extensions/blocking_dynamic_loading.js
 - app/assets/javascripts/redmine_extensions/blocking_module.js
 - app/assets/javascripts/redmine_extensions/blocking_namespace.js
 - app/assets/javascripts/redmine_extensions/blocking_polyfill.js
 - app/assets/javascripts/redmine_extensions/blocking_render.js
 - app/assets/javascripts/redmine_extensions/blocking_schedule.js
 - app/assets/javascripts/redmine_extensions/blocking_utils.js
-- app/assets/javascripts/redmine_extensions/dynamic_loading.js
 - app/assets/javascripts/redmine_extensions/easy_togglers.js
 - app/assets/javascripts/redmine_extensions/event_bus.js
 - app/assets/javascripts/redmine_extensions/jquery.entityarray.js
@@ -304,22 +304,22 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: Redmine Extensions is set of usefull features for Redmine. Main focus is
   on development helpers, but many users can find it helpfull
 test_files:
-- spec/spec_helper.rb
-- spec/features/autocomplete_spec.rb
-- spec/models/easy_setting_spec.rb
-- spec/presenters/redmine_extensions/easy_setting_presenter_spec.rb
-- spec/support/plugin_generator.rb
+- spec/factories/easy_queries.rb
 - spec/factories/easy_settings.rb
+- spec/factories/issues.rb
 - spec/factories/projects.rb
-- spec/factories/trackers.rb
 - spec/factories/time_entries.rb
-- spec/factories/easy_queries.rb
+- spec/factories/trackers.rb
 - spec/factories/users.rb
-- spec/factories/issues.rb
+- spec/features/autocomplete_spec.rb
+- spec/models/easy_setting_spec.rb
+- spec/presenters/redmine_extensions/easy_setting_presenter_spec.rb
 - spec/rails_helper.rb
+- spec/spec_helper.rb
+- spec/support/plugin_generator.rb

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

@@ -1,54 +0,0 @@
-EasyGem.dynamic = {
-  _alreadyLoaded: {},
-  /**
-   * Append Javascript <script> tag to page
-   * @example
-   * EasyGem.dynamic.jsTag("/plugin_assets/my_plugin/javascripts/counter.js");
-   * EasyGem.schedule.require(function(counter){
-   *   setInterval(counter.count(), 1000);
-   * }, function(){
-   *   return window.utils.counter;
-   * })
-   * @param {String} src - absolute path to requested file
-   */
-  jsTag: function (src) {
-    if (this._alreadyLoaded[src]) return;
-    this._alreadyLoaded[src] = true;
-    var jsScript = document.createElement("script");
-    jsScript.setAttribute("src", src);
-    jsScript.setAttribute("defer", "true");
-    document.head.appendChild(jsScript);
-  },
-  /**
-   * Append CSS <link> tag to page
-   * @param {String} src - absolute path to requested file
-   */
-  cssTag: function (src) {
-    if (this._alreadyLoaded[src]) return;
-    this._alreadyLoaded[src] = true;
-    var link = document.createElement('link');
-    link.rel = "stylesheet";
-    link.type = "text/css";
-    link.href = src;
-    link.media = "all";
-    document.head.appendChild(link);
-  },
-  /**
-   * Load multiple JS files into page
-   * @param {Array.<String>} array
-   */
-  jsTags: function (array) {
-    for (var i = 0; i < array.length; i++) {
-      this.jsTag(array[i]);
-    }
-  },
-  /**
-   * Load multiple CSS files into page
-   * @param {Array.<String>} array
-   */
-  cssTags: function (array) {
-    for (var i = 0; i < array.length; i++) {
-      this.cssTag(array[i]);
-    }
-  }
-};