RubyGems - rocket_cms - Versions diffs - 0.1.13 - Mend

rocket_cms 0.1.13

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 (99) hide show

checksums.yaml +7 -0
data/.gitignore +17 -0
data/.rspec +1 -0
data/.ruby-gemset +1 -0
data/.ruby-version +2 -0
data/.travis.yml +19 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +36 -0
data/Rakefile +1 -0
data/app/assets/javascripts/head.load.js +707 -0
data/app/assets/javascripts/jquery.placeholder.js +157 -0
data/app/assets/javascripts/rocket_cms.js.coffee +10 -0
data/app/assets/javascripts/rocket_cms/flash.js.coffee +3 -0
data/app/assets/javascripts/rocket_cms/map.js.coffee +22 -0
data/app/assets/stylesheets/rocket_cms.css.sass +2 -0
data/app/assets/stylesheets/rocket_cms/flash.css.sass +66 -0
data/app/assets/stylesheets/rocket_cms/normalize.css.scss +406 -0
data/app/controllers/concerns/no_cache.rb +12 -0
data/app/controllers/concerns/rs_errors.rb +58 -0
data/app/controllers/concerns/rs_menu.rb +45 -0
data/app/controllers/concerns/rs_pages.rb +41 -0
data/app/controllers/contacts_controller.rb +29 -0
data/app/controllers/news_controller.rb +22 -0
data/app/controllers/pages_controller.rb +12 -0
data/app/controllers/search_controller.rb +25 -0
data/app/mailers/contact_mailer.rb +15 -0
data/app/models/ckeditor/asset.rb +5 -0
data/app/models/ckeditor/attachment_file.rb +15 -0
data/app/models/ckeditor/picture.rb +16 -0
data/app/models/concerns/boolean_field.rb +9 -0
data/app/models/concerns/enableable.rb +8 -0
data/app/models/concerns/geocodeable.rb +4 -0
data/app/models/concerns/manual_slug.rb +38 -0
data/app/models/concerns/mappable.rb +77 -0
data/app/models/concerns/seoable.rb +35 -0
data/app/models/concerns/sort_field.rb +12 -0
data/app/models/concerns/sortable.rb +8 -0
data/app/models/concerns/trackable.rb +8 -0
data/app/models/contact_message.rb +6 -0
data/app/models/menu.rb +6 -0
data/app/models/news.rb +5 -0
data/app/models/page.rb +6 -0
data/app/views/contact_mailer/new_message_email.html.haml +15 -0
data/app/views/contacts/new.html.haml +10 -0
data/app/views/contacts/sent.html.haml +4 -0
data/app/views/errors/_base.html.haml +3 -0
data/app/views/errors/error_403.html.haml +1 -0
data/app/views/errors/error_404.html.haml +1 -0
data/app/views/errors/error_500.html.haml +1 -0
data/app/views/news/index.html.haml +8 -0
data/app/views/news/show.html.haml +8 -0
data/app/views/pages/show.html.haml +1 -0
data/app/views/rails_admin/main/_check_boxes.html.haml +27 -0
data/app/views/rails_admin/main/_form_raw.html.haml +1 -0
data/app/views/search/index.html.haml +19 -0
data/app/views/shared/_admin_link.html.haml +3 -0
data/app/views/shared/_messages.html.haml +7 -0
data/app/views/shared/_meta.html.haml +6 -0
data/app/views/shared/_obj.html.haml +14 -0
data/app/views/shared/_og.html.haml +4 -0
data/config/locales/en.rocket_admin.yml +6 -0
data/config/locales/en.rs.yml +17 -0
data/config/locales/ru.cancan.yml +4 -0
data/config/locales/ru.devise.yml +65 -0
data/config/locales/ru.kaminari.yml +17 -0
data/config/locales/ru.models.yml +78 -0
data/config/locales/ru.mongoid.yml +450 -0
data/config/locales/ru.rails_admin.yml +147 -0
data/config/locales/ru.rocket_admin.yml +6 -0
data/config/locales/ru.rs.yml +17 -0
data/config/locales/ru.simple_captcha.yml +3 -0
data/config/locales/ru.simple_form.yml +9 -0
data/lib/filename_to_slug.rb +32 -0
data/lib/generators/rocket_cms/admin_generator.rb +20 -0
data/lib/generators/rocket_cms/templates/ability.erb +17 -0
data/lib/generators/rocket_cms/templates/admin.erb +71 -0
data/lib/generators/rocket_cms/utils.rb +22 -0
data/lib/history_tracker.rb +4 -0
data/lib/rails_admin/custom_show_in_app.rb +39 -0
data/lib/rocket_cms.rb +57 -0
data/lib/rocket_cms/admin.rb +128 -0
data/lib/rocket_cms/configuration.rb +54 -0
data/lib/rocket_cms/controller.rb +24 -0
data/lib/rocket_cms/elastic_search.rb +32 -0
data/lib/rocket_cms/engine.rb +4 -0
data/lib/rocket_cms/model.rb +16 -0
data/lib/rocket_cms/models/contact_message.rb +37 -0
data/lib/rocket_cms/models/menu.rb +16 -0
data/lib/rocket_cms/models/news.rb +61 -0
data/lib/rocket_cms/models/page.rb +86 -0
data/lib/rocket_cms/patch.rb +58 -0
data/lib/rocket_cms/rails_admin_menu.rb +137 -0
data/lib/rocket_cms/railtie.rb +39 -0
data/lib/rocket_cms/tasks.rb +14 -0
data/lib/rocket_cms/version.rb +3 -0
data/lib/smart_excerpt.rb +98 -0
data/rocket_cms.gemspec +50 -0
metadata +533 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ed1a64eb57baf03872734690527a98a0e18941ad
+  data.tar.gz: 86cf1d01b615448a3614335bbd3f082cc252191b
+SHA512:
+  metadata.gz: f488b1b964d7aec6568244a537d1c77d07ac86846e5d8e82ba56838390c10da9597c7c27ebab134b781f1161e84c98390c57d0434bfcf0b9b67fef64b85da246
+  data.tar.gz: 3bcc95ae984e863f9564a45a0132c43ac4d815a6f09624e52778ab9d489be73ba4210c6d34e7a9bf54a5567bb10806ccdf5a66f155f8a0d9ea4ef76070c0c247

data/.gitignore ADDED Viewed

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec ADDED Viewed

	@@ -0,0 +1 @@
1	+ --color

data/.ruby-gemset ADDED Viewed

	@@ -0,0 +1 @@
1	+ rocket_cms

data/.ruby-version ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ 2.1.2
2	+

data/.travis.yml ADDED Viewed

@@ -0,0 +1,19 @@
+language: ruby
+services: mongodb
+notifications:
+  email: false
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-20mode
+env:
+  - "UPLOADS=paperclip"
+  - "UPLOADS=carrierwave"
+gemfile:
+  - gemfiles/mongoid-3.1.gemfile
+  - gemfiles/mongoid-4.0.gemfile

data/Gemfile ADDED Viewed

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in rocket_cms.gemspec
+gemspec

data/LICENSE.txt ADDED Viewed

@@ -0,0 +1,22 @@
+Copyright (c) 2014 glebtv
+MIT License
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md ADDED Viewed

@@ -0,0 +1,36 @@
+# RocketCMS
+rails_admin + mongoid + elasticsearch CMS
+Very opinionated and tuned for our needs.
+Sorry, no documentation or examples are availiable yet. Stay tuned
+**Before 1.0 API and class names should be considered unstable and can change at
+any time!**
+## Installation
+Add this line to your application's Gemfile:
+    gem 'rocket_cms'
+And then execute:
+    $ bundle
+Or install it yourself as:
+    $ gem install rocket_cms
+## Usage
+TODO: Write usage instructions here
+## Contributing
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile ADDED Viewed

	@@ -0,0 +1 @@
1	+ require "bundler/gem_tasks"

data/app/assets/javascripts/head.load.js ADDED Viewed

@@ -0,0 +1,707 @@
+///#source 1 1 /src/1.0.0/load.js
+/*! head.load - v1.0.3 */
+/*
+ * HeadJS     The only script in your <HEAD>
+ * Author     Tero Piirainen  (tipiirai)
+ * Maintainer Robert Hoffmann (itechnology)
+ * License    MIT / http://bit.ly/mit-license
+ * WebSite    http://headjs.com
+ */
+(function (win, undefined) {
+    "use strict";
+    //#region variables
+    var doc        = win.document,
+        domWaiters = [],
+        handlers   = {}, // user functions waiting for events
+        assets     = {}, // loadable items in various states
+        isAsync    = "async" in doc.createElement("script") || "MozAppearance" in doc.documentElement.style || win.opera,
+        isDomReady,
+        /*** public API ***/
+        headVar = win.head_conf && win.head_conf.head || "head",
+        api     = win[headVar] = (win[headVar] || function () { api.ready.apply(null, arguments); }),
+        // states
+        PRELOADING = 1,
+        PRELOADED  = 2,
+        LOADING    = 3,
+        LOADED     = 4;
+    //#endregion
+    //#region PRIVATE functions
+    //#region Helper functions
+    function noop() {
+        // does nothing
+    }
+    function each(arr, callback) {
+        if (!arr) {
+            return;
+        }
+        // arguments special type
+        if (typeof arr === "object") {
+            arr = [].slice.call(arr);
+        }
+        // do the job
+        for (var i = 0, l = arr.length; i < l; i++) {
+            callback.call(arr, arr[i], i);
+        }
+    }
+    /* A must read: http://bonsaiden.github.com/JavaScript-Garden
+     ************************************************************/
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+    function isFunction(item) {
+        return is("Function", item);
+    }
+    function isArray(item) {
+        return is("Array", item);
+    }
+    function toLabel(url) {
+        ///<summary>Converts a url to a file label</summary>
+        var items = url.split("/"),
+             name = items[items.length - 1],
+             i    = name.indexOf("?");
+        return i !== -1 ? name.substring(0, i) : name;
+    }
+    // INFO: this look like a "im triggering callbacks all over the place, but only wanna run it one time function" ..should try to make everything work without it if possible
+    // INFO: Even better. Look into promises/defered's like jQuery is doing
+    function one(callback) {
+        ///<summary>Execute a callback only once</summary>
+        callback = callback || noop;
+        if (callback._done) {
+            return;
+        }
+        callback();
+        callback._done = 1;
+    }
+    //#endregion
+    function conditional(test, success, failure, callback) {
+        ///<summary>
+        /// INFO: use cases:
+        ///    head.test(condition, null       , "file.NOk" , callback);
+        ///    head.test(condition, "fileOk.js", null       , callback);
+        ///    head.test(condition, "fileOk.js", "file.NOk" , callback);
+        ///    head.test(condition, "fileOk.js", ["file.NOk", "file.NOk"], callback);
+        ///    head.test({
+        ///               test    : condition,
+        ///               success : [{ label1: "file1Ok.js"  }, { label2: "file2Ok.js" }],
+        ///               failure : [{ label1: "file1NOk.js" }, { label2: "file2NOk.js" }],
+        ///               callback: callback
+        ///    );
+        ///    head.test({
+        ///               test    : condition,
+        ///               success : ["file1Ok.js" , "file2Ok.js"],
+        ///               failure : ["file1NOk.js", "file2NOk.js"],
+        ///               callback: callback
+        ///    );
+        ///</summary>
+        var obj = (typeof test === "object") ? test : {
+            test: test,
+            success: !!success ? isArray(success) ? success : [success] : false,
+            failure: !!failure ? isArray(failure) ? failure : [failure] : false,
+            callback: callback || noop
+        };
+        // Test Passed ?
+        var passed = !!obj.test;
+        // Do we have a success case
+        if (passed && !!obj.success) {
+            obj.success.push(obj.callback);
+            api.load.apply(null, obj.success);
+        }
+        // Do we have a fail case
+        else if (!passed && !!obj.failure) {
+            obj.failure.push(obj.callback);
+            api.load.apply(null, obj.failure);
+        }
+        else {
+            callback();
+        }
+        return api;
+    }
+    function getAsset(item) {
+        ///<summary>
+        /// Assets are in the form of
+        /// {
+        ///     name : label,
+        ///     url  : url,
+        ///     state: state
+        /// }
+        ///</summary>
+        var asset = {};
+        if (typeof item === "object") {
+            for (var label in item) {
+                if (!!item[label]) {
+                    asset = {
+                        name: label,
+                        url : item[label]
+                    };
+                }
+            }
+        }
+        else {
+            asset = {
+                name: toLabel(item),
+                url : item
+            };
+        }
+        // is the item already existant
+        var existing = assets[asset.name];
+        if (existing && existing.url === asset.url) {
+            return existing;
+        }
+        assets[asset.name] = asset;
+        return asset;
+    }
+    function allLoaded(items) {
+        items = items || assets;
+        for (var name in items) {
+            if (items.hasOwnProperty(name) && items[name].state !== LOADED) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function onPreload(asset) {
+        asset.state = PRELOADED;
+        each(asset.onpreload, function (afterPreload) {
+            afterPreload.call();
+        });
+    }
+    function preLoad(asset, callback) {
+        if (asset.state === undefined) {
+            asset.state     = PRELOADING;
+            asset.onpreload = [];
+            loadAsset({ url: asset.url, type: "cache" }, function () {
+                onPreload(asset);
+            });
+        }
+    }
+    function apiLoadHack() {
+        /// <summary>preload with text/cache hack
+        ///
+        /// head.load("http://domain.com/file.js","http://domain.com/file.js", callBack)
+        /// head.load(["http://domain.com/file.js","http://domain.com/file.js"], callBack)
+        /// head.load({ label1: "http://domain.com/file.js" }, { label2: "http://domain.com/file.js" }, callBack)
+        /// head.load([{ label1: "http://domain.com/file.js" }, { label2: "http://domain.com/file.js" }], callBack)
+        /// </summary>
+        var args     = arguments,
+            callback = args[args.length - 1],
+            rest     = [].slice.call(args, 1),
+            next     = rest[0];
+        if (!isFunction(callback)) {
+            callback = null;
+        }
+        // if array, repush as args
+        if (isArray(args[0])) {
+            args[0].push(callback);
+            api.load.apply(null, args[0]);
+            return api;
+        }
+        // multiple arguments
+        if (!!next) {
+            /* Preload with text/cache hack (not good!)
+             * http://blog.getify.com/on-script-loaders/
+             * http://www.nczonline.net/blog/2010/12/21/thoughts-on-script-loaders/
+             * If caching is not configured correctly on the server, then items could load twice !
+             *************************************************************************************/
+            each(rest, function (item) {
+                // item is not a callback or empty string
+                if (!isFunction(item) && !!item) {
+                    preLoad(getAsset(item));
+                }
+            });
+            // execute
+            load(getAsset(args[0]), isFunction(next) ? next : function () {
+                api.load.apply(null, rest);
+            });
+        }
+        else {
+            // single item
+            load(getAsset(args[0]));
+        }
+        return api;
+    }
+    function apiLoadAsync() {
+        ///<summary>
+        /// simply load and let browser take care of ordering
+        ///
+        /// head.load("http://domain.com/file.js","http://domain.com/file.js", callBack)
+        /// head.load(["http://domain.com/file.js","http://domain.com/file.js"], callBack)
+        /// head.load({ label1: "http://domain.com/file.js" }, { label2: "http://domain.com/file.js" }, callBack)
+        /// head.load([{ label1: "http://domain.com/file.js" }, { label2: "http://domain.com/file.js" }], callBack)
+        ///</summary>
+        var args     = arguments,
+            callback = args[args.length - 1],
+            items    = {};
+        if (!isFunction(callback)) {
+            callback = null;
+        }
+        // if array, repush as args
+        if (isArray(args[0])) {
+            args[0].push(callback);
+            api.load.apply(null, args[0]);
+            return api;
+        }
+        // JRH 262#issuecomment-26288601
+        // First populate the items array.
+        // When allLoaded is called, all items will be populated.
+        // Issue when lazy loaded, the callback can execute early.
+        each(args, function (item, i) {
+            if (item !== callback) {
+                item             = getAsset(item);
+                items[item.name] = item;
+            }
+        });
+        each(args, function (item, i) {
+            if (item !== callback) {
+                item = getAsset(item);
+                load(item, function () {
+                    if (allLoaded(items)) {
+                        one(callback);
+                    }
+                });
+            }
+        });
+        return api;
+    }
+    function load(asset, callback) {
+        ///<summary>Used with normal loading logic</summary>
+        callback = callback || noop;
+        if (asset.state === LOADED) {
+            callback();
+            return;
+        }
+        // INFO: why would we trigger a ready event when its not really loaded yet ?
+        if (asset.state === LOADING) {
+            api.ready(asset.name, callback);
+            return;
+        }
+        if (asset.state === PRELOADING) {
+            asset.onpreload.push(function () {
+                load(asset, callback);
+            });
+            return;
+        }
+        asset.state = LOADING;
+        loadAsset(asset, function () {
+            asset.state = LOADED;
+            callback();
+            // handlers for this asset
+            each(handlers[asset.name], function (fn) {
+                one(fn);
+            });
+            // dom is ready & no assets are queued for loading
+            // INFO: shouldn't we be doing the same test above ?
+            if (isDomReady && allLoaded()) {
+                each(handlers.ALL, function (fn) {
+                    one(fn);
+                });
+            }
+        });
+    }
+    function getExtension(url) {
+        url = url || "";
+        var items = url.split("?")[0].split(".");
+        return items[items.length-1].toLowerCase();
+    }
+    /* Parts inspired from: https://github.com/cujojs/curl
+    ******************************************************/
+    function loadAsset(asset, callback) {
+        callback = callback || noop;
+        function error(event) {
+            event = event || win.event;
+            // release event listeners
+            ele.onload = ele.onreadystatechange = ele.onerror = null;
+            // do callback
+            callback();
+            // need some more detailed error handling here
+        }
+        function process(event) {
+            event = event || win.event;
+            // IE 7/8 (2 events on 1st load)
+            // 1) event.type = readystatechange, s.readyState = loading
+            // 2) event.type = readystatechange, s.readyState = loaded
+            // IE 7/8 (1 event on reload)
+            // 1) event.type = readystatechange, s.readyState = complete
+            // event.type === 'readystatechange' && /loaded|complete/.test(s.readyState)
+            // IE 9 (3 events on 1st load)
+            // 1) event.type = readystatechange, s.readyState = loading
+            // 2) event.type = readystatechange, s.readyState = loaded
+            // 3) event.type = load            , s.readyState = loaded
+            // IE 9 (2 events on reload)
+            // 1) event.type = readystatechange, s.readyState = complete
+            // 2) event.type = load            , s.readyState = complete
+            // event.type === 'load'             && /loaded|complete/.test(s.readyState)
+            // event.type === 'readystatechange' && /loaded|complete/.test(s.readyState)
+            // IE 10 (3 events on 1st load)
+            // 1) event.type = readystatechange, s.readyState = loading
+            // 2) event.type = load            , s.readyState = complete
+            // 3) event.type = readystatechange, s.readyState = loaded
+            // IE 10 (3 events on reload)
+            // 1) event.type = readystatechange, s.readyState = loaded
+            // 2) event.type = load            , s.readyState = complete
+            // 3) event.type = readystatechange, s.readyState = complete
+            // event.type === 'load'             && /loaded|complete/.test(s.readyState)
+            // event.type === 'readystatechange' && /complete/.test(s.readyState)
+            // Other Browsers (1 event on 1st load)
+            // 1) event.type = load, s.readyState = undefined
+            // Other Browsers (1 event on reload)
+            // 1) event.type = load, s.readyState = undefined
+            // event.type == 'load' && s.readyState = undefined
+            // !doc.documentMode is for IE6/7, IE8+ have documentMode
+            if (event.type === "load" || (/loaded|complete/.test(ele.readyState) && (!doc.documentMode || doc.documentMode < 9))) {
+                // remove timeouts
+                win.clearTimeout(asset.errorTimeout);
+                win.clearTimeout(asset.cssTimeout);
+                // release event listeners
+                ele.onload = ele.onreadystatechange = ele.onerror = null;
+                // do callback
+                callback();
+            }
+        }
+        function isCssLoaded() {
+            // should we test again ? 20 retries = 5secs ..after that, the callback will be triggered by the error handler at 7secs
+            if (asset.state !== LOADED && asset.cssRetries <= 20) {
+                // loop through stylesheets
+                for (var i = 0, l = doc.styleSheets.length; i < l; i++) {
+                    // do we have a match ?
+                    // we need to tests agains ele.href and not asset.url, because a local file will be assigned the full http path on a link element
+                    if (doc.styleSheets[i].href === ele.href) {
+                        process({ "type": "load" });
+                        return;
+                    }
+                }
+                // increment & try again
+                asset.cssRetries++;
+                asset.cssTimeout = win.setTimeout(isCssLoaded, 250);
+            }
+        }
+        var ele;
+        var ext = getExtension(asset.url);
+        if (ext === "css") {
+            ele      = doc.createElement("link");
+            ele.type = "text/" + (asset.type || "css");
+            ele.rel  = "stylesheet";
+            ele.href = asset.url;
+            /* onload supported for CSS on unsupported browsers
+             * Safari windows 5.1.7, FF < 10
+             */
+            // Set counter to zero
+            asset.cssRetries = 0;
+            asset.cssTimeout = win.setTimeout(isCssLoaded, 500);
+        }
+        else {
+            ele      = doc.createElement("script");
+            ele.type = "text/" + (asset.type || "javascript");
+            ele.src = asset.url;
+        }
+        ele.onload  = ele.onreadystatechange = process;
+        ele.onerror = error;
+        /* Good read, but doesn't give much hope !
+         * http://blog.getify.com/on-script-loaders/
+         * http://www.nczonline.net/blog/2010/12/21/thoughts-on-script-loaders/
+         * https://hacks.mozilla.org/2009/06/defer/
+         */
+        // ASYNC: load in parallel and execute as soon as possible
+        ele.async = false;
+        // DEFER: load in parallel but maintain execution order
+        ele.defer = false;
+        // timout for asset loading
+        asset.errorTimeout = win.setTimeout(function () {
+            error({ type: "timeout" });
+        }, 7e3);
+        // use insertBefore to keep IE from throwing Operation Aborted (thx Bryan Forbes!)
+        var head = doc.head || doc.getElementsByTagName("head")[0];
+        // but insert at end of head, because otherwise if it is a stylesheet, it will not override values
+        head.insertBefore(ele, head.lastChild);
+    }
+    /* Parts inspired from: https://github.com/jrburke/requirejs
+    ************************************************************/
+    function init() {
+        var items = doc.getElementsByTagName("script");
+        // look for a script with a data-head-init attribute
+        for (var i = 0, l = items.length; i < l; i++) {
+            var dataMain = items[i].getAttribute("data-headjs-load");
+            if (!!dataMain) {
+                api.load(dataMain);
+                return;
+            }
+        }
+    }
+    function ready(key, callback) {
+        ///<summary>
+        /// INFO: use cases:
+        ///    head.ready(callBack);
+        ///    head.ready(document , callBack);
+        ///    head.ready("file.js", callBack);
+        ///    head.ready("label"  , callBack);
+        ///    head.ready(["label1", "label2"], callback);
+        ///</summary>
+        // DOM ready check: head.ready(document, function() { });
+        if (key === doc) {
+            if (isDomReady) {
+                one(callback);
+            }
+            else {
+                domWaiters.push(callback);
+            }
+            return api;
+        }
+        // shift arguments
+        if (isFunction(key)) {
+            callback = key;
+            key      = "ALL"; // holds all callbacks that where added without labels: ready(callBack)
+        }
+        // queue all items from key and return. The callback will be executed if all items from key are already loaded.
+        if (isArray(key)) {
+            var items = {};
+            each(key, function (item) {
+                items[item] = assets[item];
+                api.ready(item, function() {
+                    if (allLoaded(items)) {
+                        one(callback);
+                    }
+                });
+            });
+            return api;
+        }
+        // make sure arguments are sane
+        if (typeof key !== "string" || !isFunction(callback)) {
+            return api;
+        }
+        // this can also be called when we trigger events based on filenames & labels
+        var asset = assets[key];
+        // item already loaded --> execute and return
+        if (asset && asset.state === LOADED || key === "ALL" && allLoaded() && isDomReady) {
+            one(callback);
+            return api;
+        }
+        var arr = handlers[key];
+        if (!arr) {
+            arr = handlers[key] = [callback];
+        }
+        else {
+            arr.push(callback);
+        }
+        return api;
+    }
+    /* Mix of stuff from jQuery & IEContentLoaded
+     * http://dev.w3.org/html5/spec/the-end.html#the-end
+     ***************************************************/
+    function domReady() {
+        // Make sure body exists, at least, in case IE gets a little overzealous (jQuery ticket #5443).
+        if (!doc.body) {
+            // let's not get nasty by setting a timeout too small.. (loop mania guaranteed if assets are queued)
+            win.clearTimeout(api.readyTimeout);
+            api.readyTimeout = win.setTimeout(domReady, 50);
+            return;
+        }
+        if (!isDomReady) {
+            isDomReady = true;
+            init();
+            each(domWaiters, function (fn) {
+                one(fn);
+            });
+        }
+    }
+    function domContentLoaded() {
+        // W3C
+        if (doc.addEventListener) {
+            doc.removeEventListener("DOMContentLoaded", domContentLoaded, false);
+            domReady();
+        }
+        // IE
+        else if (doc.readyState === "complete") {
+            // we're here because readyState === "complete" in oldIE
+            // which is good enough for us to call the dom ready!
+            doc.detachEvent("onreadystatechange", domContentLoaded);
+            domReady();
+        }
+    }
+    // Catch cases where ready() is called after the browser event has already occurred.
+    // we once tried to use readyState "interactive" here, but it caused issues like the one
+    // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
+    if (doc.readyState === "complete") {
+        domReady();
+    }
+    // W3C
+    else if (doc.addEventListener) {
+        doc.addEventListener("DOMContentLoaded", domContentLoaded, false);
+        // A fallback to window.onload, that will always work
+        win.addEventListener("load", domReady, false);
+    }
+    // IE
+    else {
+        // Ensure firing before onload, maybe late but safe also for iframes
+        doc.attachEvent("onreadystatechange", domContentLoaded);
+        // A fallback to window.onload, that will always work
+        win.attachEvent("onload", domReady);
+        // If IE and not a frame
+        // continually check to see if the document is ready
+        var top = false;
+        try {
+            top = !win.frameElement && doc.documentElement;
+        } catch (e) { }
+        if (top && top.doScroll) {
+            (function doScrollCheck() {
+                if (!isDomReady) {
+                    try {
+                        // Use the trick by Diego Perini
+                        // http://javascript.nwbox.com/IEContentLoaded/
+                        top.doScroll("left");
+                    } catch (error) {
+                        // let's not get nasty by setting a timeout too small.. (loop mania guaranteed if assets are queued)
+                        win.clearTimeout(api.readyTimeout);
+                        api.readyTimeout = win.setTimeout(doScrollCheck, 50);
+                        return;
+                    }
+                    // and execute any waiting functions
+                    domReady();
+                }
+            }());
+        }
+    }
+    //#endregion
+    //#region Public Exports
+    // INFO: determine which method to use for loading
+    api.load  = api.js = isAsync ? apiLoadAsync : apiLoadHack;
+    api.test  = conditional;
+    api.ready = ready;
+    //#endregion
+    //#region INIT
+    // perform this when DOM is ready
+    api.ready(doc, function () {
+        if (allLoaded()) {
+            each(handlers.ALL, function (callback) {
+                one(callback);
+            });
+        }
+        if (api.feature) {
+            api.feature("domloaded", true);
+        }
+    });
+    //#endregion
+}(window));