RubyGems - rocket_cms - Versions diffs - 0.1.13 - Mend

rocket_cms 0.1.13

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));