modulejs-rails 1.5.0.0 → 1.9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e0e5bb749994c8a1d21de5e0f1d5d98c6671dfd
-  data.tar.gz: d71d082bc7962ee6f17b794a1ce4956361cf2819
+  metadata.gz: 680453523ff2c13c73f0fc272511f74ebdbcd048
+  data.tar.gz: 73747c46addda75bea1f231fd20404b03825a70a
 SHA512:
-  metadata.gz: bc1d431f32b6261cfbc37ba79807e046504397fcf8a0765a2b2eec0998f93059daf9a2d506092d4d0f696063950d630bb19634a88a6401d2942d042e7a91a186
-  data.tar.gz: 60011a834c36d08f720b8a26e9280c95767811bdd4c45cefae67a0aeb2d321063af1ff4816827caeb0541f6db8a0290561e7ecc33e0a516ae41511fe6a771cff
+  metadata.gz: b1aedf2e6c47437b868c8744b09f3f439ffb62bd35fd17c0bdbd44af19c4cedfc507798847eebb5e6ae0e586fd733653294c132b28c5e8c5cfc5a8dc9ed903e7
+  data.tar.gz: e38233c68f9161c56fca77310911ba248f5843f942b5089723905f1af19599725515d8e47fc28e5ca4685e8f45024bd34e7c657ea2b3a02a3398a68046ec48b5

data/lib/modulejs/rails/version.rb

@@ -1,5 +1,5 @@
 module Modulejs
   module Rails
-    VERSION = "1.5.0.0"
+    VERSION = "1.9.0.0"
   end
 end

data/modulejs-rails.gemspec

@@ -1,5 +1,5 @@
 # coding: utf-8
-require 'lib/modulejs/rails/version'
+require_relative 'lib/modulejs/rails/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "modulejs-rails"

data/vendor/assets/javascripts/{README-1.5.0.md → README-1.9.0.md}

@@ -9,7 +9,7 @@ Lightweight JavaScript module system.
 ## License
 The MIT License (MIT)
 
-Copyright (c) 2014 Lars Jung (http://larsjung.de)
+Copyright (c) 2015 Lars Jung (http://larsjung.de)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -34,8 +34,8 @@ THE SOFTWARE.
 [github]: https://github.com/lrsjng/modulejs
 [travis]: https://travis-ci.org/lrsjng/modulejs
 
-[license-img]: http://img.shields.io/badge/license-MIT-a0a060.svg?style=flat-square
-[web-img]: http://img.shields.io/badge/web-larsjung.de/modulejs-a0a060.svg?style=flat-square
-[github-img]: http://img.shields.io/badge/github-lrsjng/modulejs-a0a060.svg?style=flat-square
-[bower-img]: http://img.shields.io/badge/bower-lrsjng/modulejs-a0a060.svg?style=flat-square
-[travis-img]: http://img.shields.io/travis/lrsjng/modulejs.svg?style=flat-square
+[license-img]: https://img.shields.io/badge/license-MIT-a0a060.svg?style=flat-square
+[web-img]: https://img.shields.io/badge/web-larsjung.de/modulejs-a0a060.svg?style=flat-square
+[github-img]: https://img.shields.io/badge/github-lrsjng/modulejs-a0a060.svg?style=flat-square
+[bower-img]: https://img.shields.io/badge/bower-lrsjng/modulejs-a0a060.svg?style=flat-square
+[travis-img]: https://img.shields.io/travis/lrsjng/modulejs.svg?style=flat-square

data/vendor/assets/javascripts/modulejs.js

@@ -1,283 +1,244 @@
-/* modulejs 1.5.0 - http://larsjung.de/modulejs/ */
-(function (factory) {
-
-this.modulejs = factory();
-
-}(function () {
+(function (root, factory) {
 'use strict';
 
-// # Util
-
-// References.
-var objectPrototype = Object.prototype;
-var arrayForEach = Array.prototype.forEach;
-
-// Returns a function that returns `true` if `arg` is of the correct `type`, otherwise `false`.
-function createIsTypeFn(type) {
-
-    return function (arg) {
-
-        return objectPrototype.toString.call(arg) === '[object ' + type + ']';
-    };
+// istanbul ignore else
+if (typeof exports === 'object') {
+    module.exports = factory();
+} else {
+    root.modulejs = factory();
 }
 
-// ## isString
-// Returns `true` if argument is a string, otherwise `false`.
-var isString = createIsTypeFn('String');
-
-// ## isFunction
-// Returns `true` if argument is a function, otherwise `false`.
-var isFunction = createIsTypeFn('Function');
-
-// ## isArray
-// Returns `true` if argument is an array, otherwise `false`.
-var isArray = Array.isArray || createIsTypeFn('Array');
+}(this, function () {
+    'use strict';
 
-// ## isObject
-// Returns `true` if argument is an object, otherwise `false`.
-function isObject(arg) {
+    var OBJ_PROTO = Object.prototype;
 
-    return arg === new Object(arg);
-}
+    // Returns a function that returns `true` if `x` is of the correct
+    // `type`, otherwise `false`.
+    function _create_is_x_fn(type) {
+        return function (x) {
+            return OBJ_PROTO.toString.call(x) === '[object ' + type + ']';
+        };
+    }
 
-// ## has
-// Short cut for `hasOwnProperty`.
-function has(arg, id) {
+    // Type checking functions.
+    var isArray = _create_is_x_fn('Array');
+    var isFunction = _create_is_x_fn('Function');
+    var isString = _create_is_x_fn('String');
 
-    return objectPrototype.hasOwnProperty.call(arg, id);
-}
-
-// ## each
-// Iterates over all elements af an array or all own keys of an object.
-function each(obj, iterator, context) {
+    // Short cut for `hasOwnProperty`.
+    function has(x, id) {
+        return x !== undefined && x !== null && OBJ_PROTO.hasOwnProperty.call(x, id);
+    }
 
-    if (arrayForEach && obj.forEach === arrayForEach) {
-        obj.forEach(iterator, context);
-    } else if (obj.length === +obj.length) {
-        for (var i = 0, l = obj.length; i < l; i += 1) {
-            iterator.call(context, obj[i], i, obj);
-        }
-    } else {
-        for (var key in obj) {
-            if (has(obj, key)) {
-                iterator.call(context, obj[key], key, obj);
+    // Iterates over all elements af an array or all own keys of an object.
+    function each(x, fn) {
+        if (x && x.length) {
+            for (var i = 0, l = x.length; i < l; i += 1) {
+                fn(x[i], i, x);
+            }
+        } else {
+            for (var k in x) {
+                if (has(x, k)) {
+                    fn(x[k], k, x);
+                }
             }
         }
     }
-}
-
-// ## contains
-// Returns `true` if array contains element, otherwise `false`.
-function contains(array, element) {
 
-    for (var i = 0, l = array.length; i < l; i += 1) {
-        if (array[i] === element) {
-            return true;
+    // Returns `true` if `x` contains `val`, otherwise `false`.
+    function contains(x, val) {
+        if (x && x.length) {
+            for (var i = 0, l = x.length; i < l; i += 1) {
+                if (x[i] === val) {
+                    return true;
+                }
+            }
         }
+        return false;
     }
-    return false;
-}
-
-// ## uniq
-// Returns an new array containing no duplicates. Preserves first occurence and order.
-function uniq(array) {
-
-    var elements = {};
-    var result = [];
 
-    each(array, function (el) {
+    // Returns an new array containing no duplicates. Preserves first
+    // occurence and order.
+    function uniq(x) {
+        var result = [];
+        each(x, function (val) {
+            if (!contains(result, val)) {
+                result.push(val);
+            }
+        });
+        return result;
+    }
 
-        if (!has(elements, el)) {
-            result.push(el);
-            elements[el] = 1;
+    // Throws an error if `expression` is falsy.
+    function assert(expression, message) {
+        if (!expression) {
+            throw new Error('[modulejs] ' + message);
         }
-    });
-
-    return result;
-}
-
-// ## err
-// Throws an error if `condition` is `true`.
-function err(condition, code, message) {
-
-    if (condition) {
-        var e = new Error('[modulejs-' + code + '] ' + message);
-        e.code = code;
-        throw e;
     }
-}
-
 
+    function create() {
+        // Module definitions.
+        var definitions = {};
 
-// # Private
+        // Module instances.
+        var instances = {};
 
-// ## definitions
-// Module definitions.
-var definitions = {};
+        // Resolves `id` to an object. If `mixed` is `true` only returns
+        // dependency-IDs. If `mixed` is an object it is used instead of the
+        // already memorized `instances` to allow mock-dependencies. `stack`
+        // is used internal to check for circular dependencies.
+        function resolve(id, mixed, stack) {
 
-// ## instances
-// Module instances.
-var instances = {};
+            // check arguments
+            assert(isString(id), 'id must be string: ' + id);
+            var onlyDepIds = mixed === true;
+            var resolvedInstances = (onlyDepIds ? undefined : mixed) || instances;
 
-// ## resolve
-// Resolves an `id` to an object, or if `onlyDepIds` is `true` only returns dependency-ids.
-// `stack` is used internal to check for circular dependencies.
-function resolve(id, onlyDepIds, stack) {
+            // if a module is required that was already created return that
+            // object
+            if (!onlyDepIds && has(resolvedInstances, id)) {
+                return resolvedInstances[id];
+            }
 
-    // check arguments
-    err(!isString(id), 31, 'id must be a string "' + id + '"');
+            // check if `id` is defined
+            var def = definitions[id];
+            assert(def, 'id not defined: ' + id);
 
-    // if a module is required that was already created return that object
-    if (!onlyDepIds && has(instances, id)) {
-        return instances[id];
-    }
+            // copy resolve stack and add this `id`
+            stack = (stack || []).slice();
+            stack.push(id);
 
-    // check if `id` is defined
-    var def = definitions[id];
-    err(!def, 32, 'id not defined "' + id + '"');
+            // if `onlyDepIds` this will hold the dependency-IDs, otherwise it
+            // will hold the dependency-objects
+            var deps = [];
 
-    // copy resolve stack and add this `id`
-    stack = (stack || []).slice(0);
-    stack.push(id);
+            each(def.deps, function (depId) {
 
-    // if onlyDepIds this will hold the dependency-ids, otherwise it will hold the dependency-objects
-    var deps = [];
+                // check for circular dependencies
+                assert(!contains(stack, depId), 'circular dependencies: ' + depId + ' in ' + stack);
 
-    each(def.deps, function (depId) {
+                if (onlyDepIds) {
+                    deps = deps.concat(resolve(depId, mixed, stack));
+                    deps.push(depId);
+                } else {
+                    deps.push(resolve(depId, mixed, stack));
+                }
+            });
 
-        // check for circular dependencies
-        err(contains(stack, depId), 33, 'circular dependencies: ' + stack + ' & ' + depId);
+            // if `onlyDepIds` return only dependency-ids in right order
+            if (onlyDepIds) {
+                return uniq(deps);
+            }
 
-        if (onlyDepIds) {
-            deps = deps.concat(resolve(depId, onlyDepIds, stack));
-            deps.push(depId);
-        } else {
-            deps.push(resolve(depId, onlyDepIds, stack));
+            // create, memorize and return object
+            var obj = def.fn.apply(undefined, deps);
+            resolvedInstances[id] = obj;
+            return obj;
         }
-    });
-
-    // if `onlyDepIds` return only dependency-ids in right order
-    if (onlyDepIds) {
-        return uniq(deps);
-    }
-
-    // create, memorize and return object
-    var obj = def.fn.apply(undefined, deps);
-    instances[id] = obj;
-    return obj;
-}
-
-
-
-// # Public
-
-// ## define
-// Defines a module for `id: String`, optional `deps: Array[String]`,
-// `arg: Object/function`.
-function define(id, deps, arg) {
-
-    // sort arguments
-    if (arg === undefined) {
-        arg = deps;
-        deps = [];
-    }
-    // check arguments
-    err(!isString(id), 11, 'id must be a string "' + id + '"');
-    err(definitions[id], 12, 'id already defined "' + id + '"');
-    err(!isArray(deps), 13, 'dependencies for "' + id + '" must be an array "' + deps + '"');
-    err(!isObject(arg) && !isFunction(arg), 14, 'arg for "' + id + '" must be object or function "' + arg + '"');
-
-    // accept definition
-    definitions[id] = {
-        id: id,
-        deps: deps,
-        fn: isFunction(arg) ? arg : function () { return arg; }
-    };
-}
 
-// ## require
-// Returns an instance for `id`.
-function require(id) {
+        // Defines a module for `id: String`, optional `deps: Array[String]`,
+        // `def: mixed`.
+        function define(id, deps, def) {
 
-    return resolve(id);
-}
+            // sort arguments
+            if (arguments.length < 3) {
+                def = deps;
+                deps = [];
+            }
+            // check arguments
+            assert(isString(id), 'id must be string: ' + id);
+            assert(!has(definitions, id), 'id already defined: ' + id);
+            assert(isArray(deps), 'deps must be array: ' + id);
+
+            // accept definition
+            definitions[id] = {
+                id: id,
+                deps: deps,
+                fn: isFunction(def) ? def : function () { return def; }
+            };
+        }
 
-// ## state
-// Returns an object that holds infos about the current definitions and dependencies.
-function state() {
+        // Returns an instance for `id`. If a `mocks` object is given, it is
+        // used to resolve the dependencies.
+        function require(id, mocks) {
 
-    var res = {};
+            return resolve(id, mocks);
+        }
 
-    each(definitions, function (def, id) {
+        // Returns an object that holds infos about the current definitions
+        // and dependencies.
+        function state() {
 
-        res[id] = {
+            var res = {};
 
-            // direct dependencies
-            deps: def.deps.slice(0),
+            each(definitions, function (def, id) {
 
-            // transitive dependencies
-            reqs: resolve(id, true),
+                res[id] = {
 
-            // already initiated/required
-            init: has(instances, id)
-        };
-    });
+                    // direct dependencies
+                    deps: def.deps.slice(),
 
-    each(definitions, function (def, id) {
+                    // transitive dependencies
+                    reqs: resolve(id, true),
 
-        var inv = [];
-        each(definitions, function (def2, id2) {
+                    // already initiated/required
+                    init: has(instances, id)
+                };
+            });
 
-            if (contains(res[id2].reqs, id)) {
-                inv.push(id2);
-            }
-        });
+            each(definitions, function (def, id) {
 
-        // all inverse dependencies
-        res[id].reqd = inv;
-    });
+                var inv = [];
+                each(definitions, function (def2, id2) {
 
-    return res;
-}
+                    if (contains(res[id2].reqs, id)) {
+                        inv.push(id2);
+                    }
+                });
 
-// ## log
-// Returns a string that displays module dependencies.
-function log(inv) {
+                // all inverse dependencies
+                res[id].reqd = inv;
+            });
 
-    var out = '\n';
+            return res;
+        }
 
-    each(state(), function (st, id) {
+        // Returns a string that displays module dependencies.
+        function log(inv) {
 
-        var list = inv ? st.reqd : st.reqs;
-        out += (st.init ? '* ' : '  ') + id + ' -> [ ' + list.join(', ') + ' ]\n';
-    });
+            var out = '\n';
 
-    return out;
-}
+            each(state(), function (st, id) {
 
+                var list = inv ? st.reqd : st.reqs;
+                out += (st.init ? '* ' : '  ') + id + ' -> [ ' + list.join(', ') + ' ]\n';
+            });
 
+            return out;
+        }
 
-// # Publish
-
-return {
-    define: define,
-    require: require,
-    state: state,
-    log: log,
-    _private: {
-        isString: isString,
-        isFunction: isFunction,
-        isArray: isArray,
-        isObject: isObject,
-        has: has,
-        each: each,
-        contains: contains,
-        uniq: uniq,
-        err: err,
-        definitions: definitions,
-        instances: instances,
-        resolve: resolve
+        return {
+            create: create,
+            define: define,
+            log: log,
+            require: require,
+            state: state,
+            _private: {
+                assert: assert,
+                contains: contains,
+                definitions: definitions,
+                each: each,
+                has: has,
+                instances: instances,
+                isArray: isArray,
+                isFunction: isFunction,
+                isString: isString,
+                resolve: resolve,
+                uniq: uniq
+            }
+        };
     }
-};
 
+    return create();
 }));

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modulejs-rails
 version: !ruby/object:Gem::Version
-  version: 1.5.0.0
+  version: 1.9.0.0
 platform: ruby
 authors:
 - Ales Vilchytski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-11-25 00:00:00.000000000 Z
+date: 2015-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -69,7 +69,7 @@ files:
 - lib/modulejs/rails/engine.rb
 - lib/modulejs/rails/version.rb
 - modulejs-rails.gemspec
-- vendor/assets/javascripts/README-1.5.0.md
+- vendor/assets/javascripts/README-1.9.0.md
 - vendor/assets/javascripts/modulejs.js
 homepage: https://github.com/ales-vilchytski/modulejs-rails
 licenses: