ack_rocket_cms 0.7.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 71cf0a840e9fc4d90edd0b8e308078414d68d866
+  data.tar.gz: 38d6511abca3082f32617f41a1c7a7fe7125a969
+SHA512:
+  metadata.gz: ad84e1aae5374151b462a1cb293289219ca036d2974f4bc4a9281f05fa3329249ea217d77d04bcd746353e1127737b31c400b41d969acf6a11ae5cd335fe93ee
+  data.tar.gz: 5c06f4eeed839d11ef4d98b076ab62f6b6d8ceb86c1166a746b2df5aa14d5dc2485a7abd4fc74f714b9f602c636f73972075b339133dfea453511bd73a013a24

data/.gitignore

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

data/.rspec

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

data/.ruby-gemset

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

data/.ruby-version

@@ -0,0 +1 @@
+2.2.0

data/.travis.yml

@@ -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

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

data/Gemfile.lock

@@ -0,0 +1,244 @@
+PATH
+  remote: .
+  specs:
+    ack_rocket_cms (0.7.2.1)
+      addressable
+      coffee-rails
+      devise
+      geocoder
+      glebtv-ckeditor
+      glebtv-simple_captcha
+      jquery-rails
+      kaminari
+      rails (>= 4.1.0, < 5.0)
+      rails_admin
+      rails_admin_mongoid_localize_field (~> 0.1.2)
+      rails_admin_nested_set
+      rails_admin_settings (~> 0.9.0)
+      rails_admin_toggleable
+      simple-navigation
+      simple_form
+      sitemap_generator
+      smart_excerpt
+      stringex
+      thor
+      turbolinks
+      validates_email_format_of
+      x-real-ip
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (4.2.0)
+      actionpack (= 4.2.0)
+      actionview (= 4.2.0)
+      activejob (= 4.2.0)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+    actionpack (4.2.0)
+      actionview (= 4.2.0)
+      activesupport (= 4.2.0)
+      rack (~> 1.6.0)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.1)
+    actionview (4.2.0)
+      activesupport (= 4.2.0)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.1)
+    activejob (4.2.0)
+      activesupport (= 4.2.0)
+      globalid (>= 0.3.0)
+    activemodel (4.2.0)
+      activesupport (= 4.2.0)
+      builder (~> 3.1)
+    activerecord (4.2.0)
+      activemodel (= 4.2.0)
+      activesupport (= 4.2.0)
+      arel (~> 6.0)
+    activesupport (4.2.0)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.3.7)
+    arel (6.0.0)
+    bcrypt (3.1.10)
+    bson (2.3.0)
+    builder (3.2.2)
+    coffee-rails (4.1.0)
+      coffee-script (>= 2.2.0)
+      railties (>= 4.0.0, < 5.0)
+    coffee-script (2.3.0)
+      coffee-script-source
+      execjs
+    coffee-script-source (1.9.0)
+    connection_pool (2.1.1)
+    devise (3.4.1)
+      bcrypt (~> 3.0)
+      orm_adapter (~> 0.1)
+      railties (>= 3.2.6, < 5)
+      responders
+      thread_safe (~> 0.1)
+      warden (~> 1.2.3)
+    erubis (2.7.0)
+    execjs (2.3.0)
+    font-awesome-rails (4.3.0.0)
+      railties (>= 3.2, < 5.0)
+    geocoder (1.2.7)
+    glebtv-ckeditor (4.4.6)
+      mime-types
+      orm_adapter (~> 0.5.0)
+      rails (~> 4.0)
+    glebtv-simple_captcha (0.6.7)
+    globalid (0.3.3)
+      activesupport (>= 4.1.0)
+    haml (4.0.6)
+      tilt
+    hike (1.2.3)
+    htmlentities (4.3.3)
+    i18n (0.7.0)
+    jquery-rails (4.0.3)
+      rails-dom-testing (~> 1.0)
+      railties (>= 4.2.0)
+      thor (>= 0.14, < 2.0)
+    jquery-ui-rails (5.0.3)
+      railties (>= 3.2.16)
+    json (1.8.2)
+    kaminari (0.16.3)
+      actionpack (>= 3.0.0)
+      activesupport (>= 3.0.0)
+    loofah (2.0.1)
+      nokogiri (>= 1.5.9)
+    mail (2.6.3)
+      mime-types (>= 1.16, < 3)
+    mime-types (2.4.3)
+    mini_portile (0.6.2)
+    minitest (5.5.1)
+    mongoid (4.0.1)
+      activemodel (~> 4.0)
+      moped (~> 2.0.0)
+      origin (~> 2.1)
+      tzinfo (>= 0.3.37)
+    moped (2.0.3)
+      bson (~> 2.2)
+      connection_pool (~> 2.0)
+      optionable (~> 0.2.0)
+    multi_json (1.10.1)
+    nested_form (0.3.2)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    optionable (0.2.0)
+    origin (2.1.1)
+    orm_adapter (0.5.0)
+    rack (1.6.0)
+    rack-pjax (0.8.0)
+      nokogiri (~> 1.5)
+      rack (~> 1.1)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails (4.2.0)
+      actionmailer (= 4.2.0)
+      actionpack (= 4.2.0)
+      actionview (= 4.2.0)
+      activejob (= 4.2.0)
+      activemodel (= 4.2.0)
+      activerecord (= 4.2.0)
+      activesupport (= 4.2.0)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.2.0)
+      sprockets-rails
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.5)
+      activesupport (>= 4.2.0.beta, < 5.0)
+      nokogiri (~> 1.6.0)
+      rails-deprecated_sanitizer (>= 1.0.1)
+    rails-html-sanitizer (1.0.1)
+      loofah (~> 2.0)
+    rails_admin (0.6.6)
+      builder (~> 3.1)
+      coffee-rails (~> 4.0)
+      font-awesome-rails (>= 3.0, < 5)
+      haml (~> 4.0)
+      jquery-rails (>= 3.0, < 5)
+      jquery-ui-rails (~> 5.0)
+      kaminari (~> 0.14)
+      nested_form (~> 0.3)
+      rack-pjax (~> 0.7)
+      rails (~> 4.0)
+      remotipart (~> 1.0)
+      safe_yaml (~> 1.0)
+      sass-rails (>= 4.0, < 6)
+    rails_admin_mongoid_localize_field (0.1.3)
+      haml
+      mongoid (>= 3.0)
+      rails (>= 3.0)
+      rails_admin (>= 0.5)
+    rails_admin_nested_set (0.4.0)
+      rails_admin (~> 0.6.6)
+    rails_admin_settings (0.9.1)
+    rails_admin_toggleable (0.5.0)
+      rails_admin (~> 0.6.6)
+    railties (4.2.0)
+      actionpack (= 4.2.0)
+      activesupport (= 4.2.0)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.4.2)
+    remotipart (1.2.1)
+    responders (2.1.0)
+      railties (>= 4.2.0, < 5)
+    safe_yaml (1.0.4)
+    sass (3.4.11)
+    sass-rails (5.0.1)
+      railties (>= 4.0.0, < 5.0)
+      sass (~> 3.1)
+      sprockets (>= 2.8, < 4.0)
+      sprockets-rails (>= 2.0, < 4.0)
+      tilt (~> 1.1)
+    simple-navigation (3.14.0)
+      activesupport (>= 2.3.2)
+    simple_form (3.1.0)
+      actionpack (~> 4.0)
+      activemodel (~> 4.0)
+    sitemap_generator (5.0.5)
+      builder
+    smart_excerpt (0.1.5)
+      activesupport
+      htmlentities
+    sprockets (2.12.3)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sprockets-rails (2.2.4)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (>= 2.8, < 4.0)
+    stringex (2.5.2)
+    thor (0.19.1)
+    thread_safe (0.3.4)
+    tilt (1.4.1)
+    turbolinks (2.5.3)
+      coffee-rails
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    validates_email_format_of (1.6.2)
+      i18n
+    warden (1.2.3)
+      rack (>= 1.0)
+    x-real-ip (0.2.0)
+      activesupport
+      rack
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ack_rocket_cms!
+  bundler
+  rake

data/LICENSE.txt

@@ -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

@@ -0,0 +1,74 @@
+# RocketCMS
+
+rails_admin + mongoid/activerecord + 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_mongoid', github: "ack43/rocket_cms", branch: :master
+
+or:
+
+    gem 'rocket_cms_activerecord', github: "ack43/rocket_cms", branch: :master
+
+*Only PostgreSQL is tested or supported for AR. Others will probably work, but untested.*
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rocket_cms
+
+For activerecord, generate migrations and run them
+
+    rails g rails_admin_settings:migration
+    rails g rocket_cms:migration
+    rake db:migrate
+
+## Usage
+
+### Using app generator
+
+Make sure you have rails 4.1 installed
+
+    rails -v
+
+If not, uninstall rails and install again
+
+    gem uninstall rails
+    gem install rocket_cms
+    
+Then, for mongoid:
+
+    rails new my_app -T -O -m https://raw.github.com/ack43/rocket_cms/master/template.rb
+
+for ActiveRecord:
+
+    rails new my_app -T --database=postgresql -m https://raw.github.com/ack43/rocket_cms/master/template.rb
+
+generator creates a new RVM gemset, so after cd'ing to app dir, you should run `bundle install` again if you use rvm.
+
+### Documentation
+
+It's basically Mongoid + Rails Admin + some of our common models and controllers, capistrano config, etc.
+
+See their documentation for more info
+
+## 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

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

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

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