loada 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a69f44bcf2fc9eb668f80fa257cc1a64c63d1c0f
+  data.tar.gz: 282b21259d8ee5f8a3a3f57be5498e64f8886687
+SHA512:
+  metadata.gz: b43a7aaeb2a8b03a748c5b39dde9a0fdec9e4edf74e02b478b5079004b928efe97f3038c9ae17ec466d33e9140e6d3cae385a251f52280ae7a51ae29ee2dcb28
+  data.tar.gz: 9d3130489c18dde76b39af8d9f5ef332272213fdf85f824e87d1de06731fbd165127ef634548faab2803eeca07cacce39636f43d24f19dcce80e1484710ebda5

data/.gitignore

@@ -0,0 +1,5 @@
+.grunt
+node_modules
+index.html
+components
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,7 @@
+language: node_js
+node_js:
+  - 0.8
+before_script:
+  - npm install -g grunt-cli
+  - ./node_modules/.bin/bower install
+script: "grunt test"

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gemspec
+

data/Gruntfile.coffee

@@ -0,0 +1,106 @@
+module.exports = (grunt) ->
+
+  grunt.loadNpmTasks 'grunt-contrib-connect'
+  grunt.loadNpmTasks 'grunt-contrib-coffee'
+  grunt.loadNpmTasks 'grunt-contrib-jasmine'
+  grunt.loadNpmTasks 'grunt-contrib-watch'
+  grunt.loadNpmTasks 'grunt-contrib-uglify'
+  grunt.loadNpmTasks 'grunt-coffeelint'
+  grunt.loadNpmTasks 'grunt-release'
+
+  grunt.initConfig
+    watch:
+      source:
+        files: ['src/**/*.coffee']
+        tasks: ['coffee:source']
+      specs:
+        files: ['spec/**/*.coffee']
+        tasks: ['coffee:specs']
+
+    coffee:
+      source:
+        files:
+          'lib/loada.js': 'src/loada.coffee'
+
+      specs:
+        expand: true
+        src: ["spec/**/*.coffee"]
+        dest: '.grunt'
+        ext: '.js'
+
+    coffeelint:
+      source:
+        files:
+          src: ['src/**/*.coffee']
+        options:
+          'max_line_length':
+            level: 'ignore'
+
+    connect:
+      specs:
+        options:
+          port: 8888
+
+    release:
+      options:
+        bump: false
+        add: false
+        commit: false
+        push: false
+
+    jasmine:
+      core:
+        options:
+          host: 'http://localhost:8888/'
+          keepRunner: true
+          outfile: "index.html"
+          vendor: 'components/sinonjs/sinon.js'
+          specs: ".grunt/spec/**/*_spec.js"
+          helpers: ".grunt/spec/helpers/**/*.js"
+        src: "lib/loada.js"
+
+    uglify:
+      core:
+        files:
+          'lib/loada.min.js': 'lib/loada.js'
+
+  grunt.registerTask 'default', ['coffee', 'connect', 'jasmine:core:build', 'watch']
+
+  grunt.registerTask 'test', ['coffee', 'connect', 'coffeelint', 'jasmine', 'bowerize']
+
+  grunt.registerTask 'publish', ['test', 'publish:ensureCommits', 'release', 'publish:gem']
+
+  grunt.registerTask 'bowerize', ->
+    bower = require './bower.json'
+    meta  = require './package.json'
+
+    bower.version = meta.version
+    require('fs').writeFileSync 'bower.json', JSON.stringify(bower, null, 2)
+
+  grunt.registerTask 'publish:ensureCommits', ->
+    complete = @async()
+
+    grunt.util.spawn {cmd: "git", args: ["status", "--porcelain" ]}, (error, result) ->
+      if !!error || result.stdout.length > 0
+        console.log ""
+        console.log "Uncommited changes found. Please commit prior to release or use `--force`.".bold
+        console.log ""
+        complete false
+      else
+        complete true
+
+  grunt.registerTask 'publish:gem', ->
+    meta     = require './package.json'
+    complete = @async()
+
+    grunt.util.spawn {cmd: "gem", args: ["build", "loada.gemspec"]}, (error, result) ->
+      return complete false if error
+
+      gem = "loada-#{meta.version.replace('-', '.')}.gem"
+      grunt.log.ok "Built #{gem}"
+
+      grunt.util.spawn {cmd: "gem", args: ["push", gem]}, (error, result) ->
+        return complete false if error
+        grunt.log.ok "Published #{gem}"
+        grunt.file.delete gem
+        complete(true)

data/README.md

@@ -0,0 +1,153 @@
+# The Loada
+
+[![NPM version](https://badge.fury.io/js/loada.png)](http://badge.fury.io/js/loada)
+[![Build Status](https://travis-ci.org/inossidabile/loada.png?branch=master)](https://travis-ci.org/inossidabile/loada)
+
+The kickass in-browser assets (JS/CSS/Text) loader with the support of localStorage caching and progress tracking. The Loada is here to give you control over assets loading order, parallelism, cache expiration and actual code evaluation. 
+
+Use it to:
+
+  * Make beautiful preloader of a big RICH browser application
+  * Manually control assets cache
+  * Preload and manage your code partially in the background (templates, extensions, etc...)
+
+## Installation
+
+The Loada is available through [Bower](http://bower.io) as `loada`. 
+
+Alternatively you can download [minified version](https://raw.github.com/inossidabile/loada/master/lib/loada.min.js). But you should not. Seriously. Use package managers. Please.
+
+## Basic usage
+
+The Loada splits your dependencies into sets. Each set is an instance of The Loada. Each set is an atomic cache part: if the number of cached assets changes – unused caches get busted on the next run keeping your **localStorage** space usage low. You can i.e. have *main* set, the core of application, and *templates* that will be treated and cached separately.
+
+---
+
+Create a set to start:
+
+```coffee
+loader = Loada.set('dependencies') # name of the set defaults to `*` if omitted.
+```
+
+To load an asset with the default options run
+
+```coffee
+loader.require url: '/assets/application.css'
+```
+
+To load several assets one after another (they depend on each other?) run
+
+```coffee
+loader.require {url: '/assets/jquery.js'}, {url: '/assets/application.js'}
+```
+
+And to load an external library that shouldn't be cached at **localStorage** (but has to be kept at
+the browser cache) run
+
+```coffee
+loader.require {url: 'http://../facebook.js', localStorage: false}
+```
+
+According to our requires, the assets will be loaded in the following groups (:
+
+  * **/assets/application.css** in parallel with
+  * ( **/assets/jquery.js** and then **/assets/appliation.js** ) in parallel with
+  * **http://../facebook.js**
+
+And now that we have our dependencies specified, load'em!
+
+```coffee
+loader.load
+  # During downloading you will get this callback called from time to time
+  progress: (percents) -> # ...
+
+  # And this one will run as soon as all assets are around
+  complete: -> # ...
+```
+
+## Progress tracker limitations and advanced usage
+
+The Loada will try to make progress ticks as often as possible. There are some things you should keep in mind to sort it out though:
+
+  * You can pass in `size` to the asset options to specify download size. This is the most efficient scenario so if you have a chance to count size programmatically – do that.
+  * The Loada will run separate `HEAD` query  for every asset with unknown size expecting server to return `Content-Length`.
+  * During downloading it will tick exact percentage for assets with known size and two points at start and finish for every other.
+
+So in the worst case when The Loada was not able to find sizes from any source, you will get percentage split to the number of loading assets. In the best case, when all sizes are known, ticks will happen every 100ms and will be pretty detailed.
+
+**Important note**: The Loada WILL NOT make separate `HEAD` queries unless you pass `progress` callback. So if you don't need the progress tracking feature – you are not hitting the overhead. In the case when you passed `progress` in and still want to avoid `HEAD` queries (resulting into "per-library" percentage), pass `0` as the `size` value to every asset.
+
+## Options and Methods
+
+### Instance-level options
+
+```coffee
+set = Loada.set 'name',
+  prefix: 'foobar'
+  localStorage: false
+```
+
+  * **prefix**: changes localStorage keys prefix (defaults to `loada`)
+  * **localStorage**: globally turns off the localStorage cache and (unfortunately) detailed progress tracking
+
+**Important note**: The Loada is only able to work with JS with localStorage mode turned off.
+
+### Asset-level options
+
+```coffee
+set.require
+  url: '/assets/application.js'
+  key: 'app'
+  type: 'js'
+  revision: 1
+  expires: 5
+  cache: true
+  require: true
+  size: 0
+```
+  * **url**: URL to download asset from
+  * **key**: key to use to store asset within the set (defaults to `url`)
+  * **type**: type of the asset: `css`, `js` or `text` (The Loada tries to parse URL to get extension if omitted)
+  * **revision**: asset revision to control cache expiration manually – cache will get busted if new value of this option doesn't match the stored one
+  * **expires**: number of hours to keep asset for (defaults to forever cache)
+  * **cache**: pass `false` in to turn localStorage caching off for this particular asset
+  * **require**: whether asset should be automatically required or just downloaded and cached
+  * **size**: downloadable size of asset to help The Loada with detailed progress tracking
+
+### Instance-level methods
+
+#### **get**
+
+Gets raw asset source by its key
+
+```coffee
+source = set.get 'app'
+```
+
+#### **expire**
+
+Manually triggers expiration check for current storage
+
+```coffee
+set.expire()
+```
+
+#### **clear**
+
+Busts all cache of the current set
+
+```coffee
+set.clear()
+```
+
+## History
+
+Loada is an extraction from [Joosy](http://joosy.ws) core.
+
+## Credits
+
+* Boris Staal ([@_inossidabile](http://twitter.com/#!/_inossidabile)) [![endorse](http://api.coderwall.com/inossidabile/endorsecount.png)](http://coderwall.com/inossidabile)
+
+## LICENSE
+
+It is free software, and may be redistributed under the terms of MIT license.

data/bower.json

@@ -0,0 +1,18 @@
+{
+  "name": "loada",
+  "version": "0.1.3",
+  "main": "lib/loada.min.js",
+  "ignore": [
+    "Gruntfile.coffee",
+    "package.json",
+    "spec",
+    ".travis.yml",
+    ".gitignore",
+    "lib/loada.rb",
+    "loada.gemspec",
+    "Gemfile"
+  ],
+  "devDependencies": {
+    "sinonjs": "~1.7.1"
+  }
+}

data/lib/loada.js

@@ -0,0 +1,321 @@
+(function() {
+  var $head,
+    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+    __slice = [].slice;
+
+  $head = document.getElementsByTagName("head")[0];
+
+  this.Loada = (function() {
+    Loada.prototype.Progress = (function() {
+      function _Class(count, progressCallback) {
+        this.count = count;
+        this.progressCallback = progressCallback;
+        this.data = {};
+      }
+
+      _Class.prototype.set = function(key, percent) {
+        this.data[key] = Math.min(percent, 100.0);
+        return typeof this.progressCallback === "function" ? this.progressCallback(this.total()) : void 0;
+      };
+
+      _Class.prototype.total = function() {
+        var key, percent, total, _ref;
+        total = 0;
+        _ref = this.data;
+        for (key in _ref) {
+          percent = _ref[key];
+          total += Math.round(percent / this.count * 100) / 100;
+        }
+        return total;
+      };
+
+      return _Class;
+
+    })();
+
+    Loada.set = function() {
+      return (function(func, args, ctor) {
+        ctor.prototype = func.prototype;
+        var child = new ctor, result = func.apply(child, args);
+        return Object(result) === result ? result : child;
+      })(this, arguments, function(){});
+    };
+
+    function Loada(set, options) {
+      var k, v;
+      this.set = set;
+      this._loadGroup = __bind(this._loadGroup, this);
+      this.options = {
+        prefix: 'loada',
+        localStorage: true
+      };
+      this.requires = {
+        input: [],
+        set: {},
+        length: 0
+      };
+      this.set || (this.set = '*');
+      if (options) {
+        for (k in options) {
+          v = options[k];
+          this.options[k] = v;
+        }
+      }
+      this.key = "" + this.options.prefix + "." + this.set;
+      this.setup();
+    }
+
+    Loada.prototype.setup = function() {
+      if (this.options.localStorage) {
+        this.storage = localStorage[this.key] || {};
+        if (typeof this.storage === 'string') {
+          return this.storage = JSON.parse(localStorage[this.key]);
+        }
+      }
+    };
+
+    Loada.prototype.save = function() {
+      return localStorage[this.key] = JSON.stringify(this.storage);
+    };
+
+    Loada.prototype.clear = function() {
+      return delete localStorage[this.key];
+    };
+
+    Loada.prototype.get = function(key) {
+      var _ref;
+      return (_ref = this.storage[key]) != null ? _ref.source : void 0;
+    };
+
+    Loada.prototype.expire = function() {
+      var byDate, byExistance, byRevision, key, library, now, _ref, _results,
+        _this = this;
+      now = new Date;
+      byDate = function(library) {
+        return library.expirationDate && new Date(library.expirationDate) <= now;
+      };
+      byExistance = function(library) {
+        return !_this.requires.set[key];
+      };
+      byRevision = function(library) {
+        return _this.requires.set[key].revision !== library.revision;
+      };
+      _ref = this.storage;
+      _results = [];
+      for (key in _ref) {
+        library = _ref[key];
+        if (byDate(library) || byExistance(library) || byRevision(library)) {
+          _results.push(delete this.storage[key]);
+        } else {
+          _results.push(void 0);
+        }
+      }
+      return _results;
+    };
+
+    Loada.prototype.require = function() {
+      var libraries, library, now, _i, _len, _ref;
+      libraries = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      for (_i = 0, _len = libraries.length; _i < _len; _i++) {
+        library = libraries[_i];
+        library.key || (library.key = library.url);
+        library.type || (library.type = (_ref = library.url) != null ? _ref.split('.').pop() : void 0);
+        if (library.localStorage == null) {
+          library.localStorage = true;
+        }
+        if (library.require == null) {
+          library.require = true;
+        }
+        if (library.expires) {
+          now = new Date;
+          library.expirationDate = now.setTime(now.getTime() + library.expires * 60 * 60 * 1000);
+        }
+        if (library.type === 'js' || library.type === 'css' || library.type === 'text') {
+          this.requires.set[library.key] = library;
+        } else {
+          console.error("Unknown asset type for " + library.url + " – skipped");
+        }
+      }
+      this.requires.length += libraries.length;
+      return this.requires.input.push(libraries);
+    };
+
+    Loada.prototype.load = function(callbacks) {
+      var loaders, progress,
+        _this = this;
+      callbacks || (callbacks = {});
+      if (this.options.localStorage) {
+        this.expire();
+      }
+      progress = new this.Progress(this.requires.length, callbacks.progress);
+      loaders = 0;
+      return this._ensureSizes(callbacks.progress != null, function() {
+        var group, _i, _len, _ref, _results;
+        _ref = _this.requires.input;
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          group = _ref[_i];
+          loaders++;
+          _results.push(_this._loadGroup(group.slice(0), progress, function() {
+            loaders--;
+            if (loaders === 0) {
+              _this.save();
+              return typeof callbacks.success === "function" ? callbacks.success() : void 0;
+            }
+          }));
+        }
+        return _results;
+      });
+    };
+
+    Loada.prototype._ensureSizes = function(perform, callback) {
+      var key, library, requests, _ref, _ref1, _results,
+        _this = this;
+      if (!perform) {
+        _ref = this.requires.set;
+        for (key in _ref) {
+          library = _ref[key];
+          library.size = 0;
+        }
+        return callback();
+      }
+      requests = 0;
+      _ref1 = this.requires.set;
+      _results = [];
+      for (key in _ref1) {
+        library = _ref1[key];
+        _results.push((function(library) {
+          if (library.size == null) {
+            requests++;
+            return _this._ajax('HEAD', library.url, function(xhr) {
+              var size;
+              requests--;
+              size = xhr.getResponseHeader('Content-Length');
+              if (size) {
+                size = parseInt(size);
+              }
+              library.size = size || 0;
+              if (requests === 0) {
+                return callback();
+              }
+            });
+          }
+        })(library));
+      }
+      return _results;
+    };
+
+    Loada.prototype._loadGroup = function(group, progress, callback) {
+      var library, method,
+        _this = this;
+      library = group.shift();
+      if (!library) {
+        return callback();
+      }
+      if (this.options.localStorage && this.storage[library.key] && library.localStorage) {
+        if (progress != null) {
+          progress.set(library.key, 100);
+        }
+        if (this.storage[library.key].require) {
+          this._inject(this.storage[library.key]);
+        }
+        return this._loadGroup(group, progress, callback);
+      } else {
+        method = this.options.localStorage ? "_loadAJAX" : "_loadInline";
+        return this[method](library, progress, function() {
+          if (_this.options.localStorage) {
+            _this.storage[library.key] = library;
+          }
+          if (library.require) {
+            _this._inject(library);
+          }
+          return _this._loadGroup(group, progress, callback);
+        });
+      }
+    };
+
+    Loada.prototype._loadAJAX = function(library, progress, callback) {
+      var poller, xhr,
+        _this = this;
+      xhr = this._ajax('GET', library.url, function(xhr) {
+        library.source = xhr.responseText;
+        clearInterval(poller);
+        if (progress != null) {
+          progress.set(library.key, 100);
+        }
+        return callback();
+      });
+      if (library.size > 0) {
+        return poller = setInterval((function() {
+          var percent;
+          percent = Math.round(xhr.responseText.length / library.size * 100 * 100) / 100;
+          return progress != null ? progress.set(library.key, percent) : void 0;
+        }), 100);
+      }
+    };
+
+    Loada.prototype._loadInline = function(library, progress, callback) {
+      var done, proceed, script;
+      if (library.type !== 'js') {
+        console.error("Attempt to load something other than JS without localStorage.");
+        console.error("" + library.url + " is not loaded!");
+        if (progress != null) {
+          progress.set(library.key, 100);
+        }
+        return callback();
+      }
+      script = document.createElement("script");
+      done = false;
+      proceed = function() {
+        if (!done && ((this.readyState == null) || this.readyState === "loaded" || this.readyState === "complete")) {
+          done = true;
+          if (progress != null) {
+            progress.set(library.key, 100);
+          }
+          if (typeof callback === "function") {
+            callback();
+          }
+          return script.onload = script.onreadystatechange = null;
+        }
+      };
+      script.onload = script.onreadystatechange = proceed;
+      script.src = library.url;
+      return $head.appendChild(script);
+    };
+
+    Loada.prototype._inject = function(library) {
+      var script, style;
+      if (library.type === 'js') {
+        script = document.createElement("script");
+        script.defer = true;
+        script.text = library.source;
+        return $head.appendChild(script);
+      } else if (library.type === 'css') {
+        style = document.createElement("style");
+        style.innerHTML = library.source;
+        return $head.appendChild(style);
+      }
+    };
+
+    Loada.prototype._ajax = function(method, url, callback) {
+      var xhr;
+      if (window.XMLHttpRequest) {
+        xhr = new XMLHttpRequest;
+      } else {
+        xhr = new ActiveXObject('Microsoft.XMLHTTP');
+      }
+      xhr.open(method, url, 1);
+      xhr.onreadystatechange = function() {
+        if (xhr.readyState > 3) {
+          return typeof callback === "function" ? callback(xhr) : void 0;
+        }
+      };
+      xhr.send();
+      return xhr;
+    };
+
+    return Loada;
+
+  })();
+
+}).call(this);