micro-rails 0.1.0.pre.alpha5 → 0.1.0.pre.alpha6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a27a44bf4d1565a98df7e4806cebf4cc9108d317
-  data.tar.gz: ef6d95d799d484c1c06acf90401405250559c53a
+  metadata.gz: 52e327d8894efaf370b3924cc0ea95f13ec10759
+  data.tar.gz: 6bd0a32dcb304d9cd99dcbd743a130050d50b2e4
 SHA512:
-  metadata.gz: 52bd0da0d0f3fc89eacfe4979dbb70577f6082d2adb4a7fda4ba49203b0f604b733d42677a391db21175373a5fa0f4adaec7a3bd615dc219b95a77f338d32d12
-  data.tar.gz: 6c6fb30a16f14be37ff741f1640d91626f61735772a31ac0d34ebb3d23db8ca63949f130b3bcb31c3cb7d65761b49988f1d5044fabc4595e69b584b0ad9c7b2d
+  metadata.gz: a98d8367473837f8ae740075938529601a6aa1b963de02d3b4c7e7e1caf86eb68b592dee4fb846922356db3a752700a0c35b68f6fe361a88aed3ed79121834dd
+  data.tar.gz: 0573fb192c64c9a940c9aac95ce8269ddb0f36086f54ea449edb641e6ef9019bf3e80e5428f7475ae2ae73cc1a94c91309d95525136cbc826b1ee70f5ef0628c

data/Rakefile

@@ -3,5 +3,5 @@ require "bundler/gem_tasks"
 desc 'Download micro.js in vendor/assets/javascripts'
 task 'download' do
   puts 'Downloading micro.js'
-  puts `curl -o vendor/assets/javascripts/micro.js https://raw.githubusercontent.com/jguyon/micro/v#{Micro::Rails::MICRO_VERSION}/lib/micro.js`
+  puts `curl -o vendor/assets/javascripts/micro.js https://raw.githubusercontent.com/jguyon/micro/v#{Micro::Rails::MICRO_VERSION}/dist/micro.js`
 end

data/lib/micro/rails/version.rb

@@ -1,6 +1,6 @@
 module Micro
   module Rails
-    VERSION = "0.1.0-alpha5"
+    VERSION = "0.1.0-alpha6"
     MICRO_VERSION = "0.1.0-alpha1"
   end
 end

data/vendor/assets/javascripts/micro.js

@@ -1 +1,899 @@
-Not Found
+(function() {
+  var Component, Factory, Module, Namespace, Unit, delegatedMethods, factory, method, mu, splitOnce, _fn, _i, _len,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    __slice = [].slice;
+
+  splitOnce = function(string, char) {
+    var splits;
+    splits = string.split(char);
+    return [splits.shift(), splits.join(char)];
+  };
+
+  Factory = (function() {
+    function Factory() {
+      this.config = {
+        defaultNamespace: 'app',
+        dataPrefix: 'micro'
+      };
+      this._namespaces = {};
+      this._initialize = [];
+      this._destroy = [];
+    }
+
+    Factory.prototype.configure = function(config) {
+      return _.extend(this.config, config);
+    };
+
+    Factory.prototype.setup = function(setup) {
+      return setup.call({
+        initialize: (function(_this) {
+          return function(initialize) {
+            return _this._initialize.push(initialize);
+          };
+        })(this),
+        destroy: (function(_this) {
+          return function(destroy) {
+            return _this._destroy.unshift(destroy);
+          };
+        })(this),
+        component: (function(_this) {
+          return function(name, el, config) {
+            var Component;
+            if (!(_.isString(el) || _.isElement(el))) {
+              config = el;
+              el = null;
+            }
+            Component = _this.component(name);
+            el || (el = Component.config.defaultSelector);
+            if (!el) {
+              throw new Error('you must provide a selector or define' + ' defaultSelector in the component configuration');
+            }
+            _this._initialize.push(function() {
+              Component.initialize(this.filter(el), config);
+              return Component.initialize(this.find(el), config);
+            });
+            return _this._destroy.unshift(function() {
+              Component.destroy(this.filter(el));
+              return Component.destroy(this.find(el));
+            });
+          };
+        })(this)
+      });
+    };
+
+    Factory.prototype.initialize = function(el) {
+      var $el, initialize, _i, _len, _ref, _results;
+      $el = $(el);
+      _ref = this._initialize;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        initialize = _ref[_i];
+        _results.push(initialize.call($el));
+      }
+      return _results;
+    };
+
+    Factory.prototype.destroy = function(el) {
+      var $el, destroy, _i, _len, _ref, _results;
+      $el = $(el);
+      _ref = this._destroy;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        destroy = _ref[_i];
+        _results.push(destroy.call($el));
+      }
+      return _results;
+    };
+
+    Factory.prototype.clean = function() {
+      this._namespaces = {};
+      this._initialize = [];
+      return this._destroy = [];
+    };
+
+    Factory.prototype.namespace = function(label, doNotThrow) {
+      var namespace;
+      if (doNotThrow == null) {
+        doNotThrow = false;
+      }
+      if (!((namespace = this._namespaces[label]) || doNotThrow)) {
+        throw new Error("could not find namespace " + label);
+      }
+      return namespace;
+    };
+
+    Factory.prototype.component = function(name, doNotThrow) {
+      var label, namespace, _ref;
+      if (doNotThrow == null) {
+        doNotThrow = false;
+      }
+      _ref = this._splitUnitName(name), namespace = _ref[0], label = _ref[1];
+      return this.namespace(namespace, doNotThrow).component(label, doNotThrow);
+    };
+
+    Factory.prototype.module = function(name, doNotThrow) {
+      var label, namespace, _ref;
+      if (doNotThrow == null) {
+        doNotThrow = false;
+      }
+      _ref = this._splitUnitName(name), namespace = _ref[0], label = _ref[1];
+      return this.namespace(namespace, doNotThrow).module(label, doNotThrow);
+    };
+
+    Factory.prototype.createNamespace = function(label) {
+      if (this._namespaces[label]) {
+        throw new Error("namespace " + label + " already exists");
+      }
+      return this._namespaces[label] = new Namespace(this, label);
+    };
+
+    Factory.prototype.data = function(el, name, value) {
+      if (arguments.length < 3) {
+        return $(el).data(this._dataName(name));
+      } else {
+        return $(el).data(this._dataName(name), value);
+      }
+    };
+
+    Factory.prototype.removeData = function(el, name) {
+      return $(el).removeData(this._dataName(name));
+    };
+
+    Factory.prototype._splitUnitName = function(name) {
+      var label, namespace, _ref;
+      _ref = splitOnce(name, '.'), namespace = _ref[0], label = _ref[1];
+      if (!label) {
+        label = namespace;
+        namespace = this.config.defaultNamespace;
+      }
+      return [namespace, label];
+    };
+
+    Factory.prototype._dataName = function(name) {
+      return "" + this.config.dataPrefix + "-" + name;
+    };
+
+    return Factory;
+
+  })();
+
+  Namespace = (function() {
+    Namespace.labelFormat = /^[a-z][a-zA-Z0-9]*$/;
+
+    function Namespace(factory, label) {
+      this.factory = factory;
+      this.label = label;
+      if (!this.label.match(this.constructor.labelFormat)) {
+        throw new Error("" + this.label + " is not a valid namespace name");
+      }
+      this._components = {};
+      this._modules = {};
+      this.config = {};
+    }
+
+    Namespace.prototype.muObject = function() {
+      return {
+        configure: (function(_this) {
+          return function(config) {
+            _this.configure(config);
+            return _this.muObject();
+          };
+        })(this)
+      };
+    };
+
+    Namespace.prototype.configure = function(config) {
+      return _.extend(this.config, config);
+    };
+
+    Namespace.prototype.component = function(label, doNotThrow) {
+      var Component;
+      if (doNotThrow == null) {
+        doNotThrow = false;
+      }
+      if (!((Component = this._components[label]) || doNotThrow)) {
+        throw new Error("component " + label + " could not be found in namespace " + this.name);
+      }
+      return Component;
+    };
+
+    Namespace.prototype.module = function(label, doNotThrow) {
+      var Module;
+      if (doNotThrow == null) {
+        doNotThrow = false;
+      }
+      if (!((Module = this._modules[label]) || doNotThrow)) {
+        throw new Error("module " + label + " could not be found in namespace " + this.name);
+      }
+      return Module;
+    };
+
+    Namespace.prototype.addUnit = function(Unit) {
+      var prototype;
+      if (Unit.namespace !== this) {
+        throw new Error("Unit " + Unit.label + " does not belong to namespace " + this.name);
+      }
+      prototype = Unit.prototype;
+      if (prototype instanceof Component) {
+        return this._components[Unit.label] = Unit;
+      } else if (prototype instanceof Module) {
+        return this._modules[Unit.label] = Unit;
+      } else {
+        throw new Error('cannot add a unit that is not a child of Component or Module');
+      }
+    };
+
+    return Namespace;
+
+  })();
+
+  Unit = (function() {
+    Unit.namespace = null;
+
+    Unit.label = null;
+
+    Unit.labelFormat = /^[A-Z][A-Za-z0-9]*$/;
+
+    Unit.config = {};
+
+    Unit._initialize = [];
+
+    Unit._destroy = [];
+
+    Unit.extend = function(options) {
+      var Child, Parent;
+      if (!options.label.match(this.labelFormat)) {
+        throw new Error("" + options.label + " is not a valid name");
+      }
+      Parent = this;
+      Child = (function(_super) {
+        var destroy, initialize;
+
+        __extends(Child, _super);
+
+        function Child() {
+          return Child.__super__.constructor.apply(this, arguments);
+        }
+
+        Child.namespace = options.namespace;
+
+        Child.label = options.label;
+
+        Child.config = _.clone(Child.config);
+
+        if (options.config) {
+          _.extend(Child.config, options.config);
+        }
+
+        if (options.properties) {
+          if (initialize = options.properties._initialize) {
+            Child._initialize = Child._initialize.concat([initialize]);
+            delete options.properties._initialize;
+          }
+          if (destroy = options.properties._destroy) {
+            Child._destroy = [destroy].concat(Child._destroy);
+            delete options.properties._destroy;
+          }
+          _.extend(Child.prototype, options.properties);
+        }
+
+        return Child;
+
+      })(Parent);
+      return options.namespace.addUnit(Child);
+    };
+
+    Unit.configure = function(config) {
+      _.extend(this.config, config);
+      return this.muObject();
+    };
+
+    Unit.fullName = function() {
+      return "" + this.namespace.label + "-" + this.label;
+    };
+
+    function Unit(config) {
+      var initialize, method, name, _i, _len, _ref, _ref1;
+      this.config = config != null ? config : {};
+      if (this.constructor.__super__) {
+        this["super"] = {};
+        _ref = this.constructor.__super__;
+        for (name in _ref) {
+          method = _ref[name];
+          this["super"][name] = _.bind(method, this);
+        }
+      }
+      _.defaults(this.config, this.constructor.config, this.constructor.namespace.config);
+      _ref1 = this.constructor._initialize;
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        initialize = _ref1[_i];
+        initialize.call(this);
+      }
+    }
+
+    Unit.prototype.destroy = function() {
+      var destroy, _i, _len, _ref, _results;
+      _ref = this.constructor._destroy;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        destroy = _ref[_i];
+        _results.push(destroy.call(this));
+      }
+      return _results;
+    };
+
+    return Unit;
+
+  })();
+
+  Component = (function(_super) {
+    __extends(Component, _super);
+
+    Component._modules = {};
+
+    Component.muObject = function(options) {
+      var prototype;
+      prototype = this.prototype;
+      if (prototype instanceof Component) {
+        return {
+          configure: (function(_this) {
+            return function(config) {
+              return _this.configure(config);
+            };
+          })(this),
+          initialize: (function(_this) {
+            return function(el, config) {
+              return _this.initialize(el, config);
+            };
+          })(this),
+          instance: (function(_this) {
+            return function(el) {
+              return _this.instance(el);
+            };
+          })(this),
+          destroy: (function(_this) {
+            return function(el) {
+              return _this.destroy(el);
+            };
+          })(this)
+        };
+      } else {
+        return {
+          extend: (function(_this) {
+            return function(name) {
+              options.extend = options.namespace.factory.component(name);
+              return _this.muObject(options);
+            };
+          })(this),
+          module: (function(_this) {
+            return function(name) {
+              var Module;
+              Module = options.namespace.factory.module(name);
+              if (options.modules) {
+                options.modules.push(Module);
+              } else {
+                options.modules = [Module];
+              }
+              return _this.muObject(options);
+            };
+          })(this),
+          configure: (function(_this) {
+            return function(config) {
+              if (options.config) {
+                _.extend(options.config, config);
+              } else {
+                options.config = config;
+              }
+              return _this.muObject(options);
+            };
+          })(this),
+          create: (function(_this) {
+            return function(properties) {
+              var Parent;
+              options.properties = properties;
+              Parent = options.extend || _this;
+              return Parent.extend(options);
+            };
+          })(this)
+        };
+      }
+    };
+
+    Component.extend = function(options) {
+      var Child, Module, _i, _len, _ref;
+      Child = Component.__super__.constructor.extend.call(this, options);
+      Child._modules = _.clone(Child._modules);
+      if (options.modules) {
+        _ref = options.modules;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          Module = _ref[_i];
+          Child.include(Module);
+        }
+      }
+      return Child.muObject();
+    };
+
+    Component.include = function(Module) {
+      this._modules[Module.fullName()] = Module;
+      return Module.included(this);
+    };
+
+    Component.initialize = function(el, config) {
+      var instances;
+      instances = [];
+      $(el).each((function(_this) {
+        return function(i, el) {
+          return instances.push(new _this($(el), config));
+        };
+      })(this));
+      return this._methods(instances);
+    };
+
+    Component.instance = function(el) {
+      var instances;
+      instances = $(el).map((function(_this) {
+        return function(i, el) {
+          return _this._instance($(el));
+        };
+      })(this)).get();
+      return this._methods(instances);
+    };
+
+    Component.destroy = function(el, config) {
+      $(el).each((function(_this) {
+        return function(i, el) {
+          return _this._instance($(el)).destroy();
+        };
+      })(this));
+      return this.muObject();
+    };
+
+    Component._methods = function(instances) {
+      var methodNames, methods, name, prefix, _fn, _i, _len;
+      prefix = this.config.methodPrefix || 'mu';
+      methodNames = _.chain(this.prototype).functions().filter(function(name) {
+        return name.match(new RegExp("^" + prefix + "[A-Z]"));
+      }).value();
+      methods = {};
+      _fn = function(oldName) {
+        var newName;
+        newName = oldName[prefix.length].toLowerCase() + oldName.slice(prefix.length + 1);
+        return methods[newName] = function() {
+          var args, lastResult, results;
+          args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+          results = _.invoke.apply(_, [instances, oldName].concat(__slice.call(args)));
+          lastResult = _.last(results);
+          if (_.isNull(lastResult)) {
+            return methods;
+          } else {
+            return lastResult;
+          }
+        };
+      };
+      for (_i = 0, _len = methodNames.length; _i < _len; _i++) {
+        name = methodNames[_i];
+        _fn(name);
+      }
+      methods.destroy = (function(_this) {
+        return function() {
+          _.invoke(instances, 'destroy');
+          return _this.muObject();
+        };
+      })(this);
+      return methods;
+    };
+
+    Component._instance = function($el) {
+      var components, instance;
+      components = this.namespace.factory.data($el, 'components') || {};
+      if (!(instance = components[this.fullName()])) {
+        throw new Error('component is not initialized');
+      }
+      return instance;
+    };
+
+    function Component($el, config) {
+      var Module, components, factory, name, _ref;
+      this.$el = $el;
+      factory = this.constructor.namespace.factory;
+      components = factory.data(this.$el, 'components') || {};
+      if (components[this.constructor.fullName()]) {
+        throw new Error('component is already initialized');
+      }
+      components[this.constructor.fullName()] = this;
+      factory.data(this.$el, 'components', components);
+      this._uniqueId = _.uniqueId("component-");
+      this._listeners = $();
+      this._dataFull = $();
+      this._dataNames = [];
+      this._handlers = {};
+      Component.__super__.constructor.call(this, config);
+      this._moduleInstances = {};
+      _ref = this.constructor._modules;
+      for (name in _ref) {
+        Module = _ref[name];
+        this._moduleInstances[name] = new Module(this, this.config);
+      }
+    }
+
+    Component.prototype.destroy = function() {
+      var components, factory, instance, name, _i, _len, _ref, _ref1;
+      _ref = this._moduleInstances;
+      for (name in _ref) {
+        instance = _ref[name];
+        instance.destroy();
+      }
+      Component.__super__.destroy.apply(this, arguments);
+      factory = this.constructor.namespace.factory;
+      this._listeners.off("." + this._uniqueId);
+      _ref1 = this._dataNames;
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        name = _ref1[_i];
+        factory.removeData(this._dataFull, name);
+      }
+      components = factory.data(this.$el, 'components');
+      delete components[this.constructor.fullName()];
+      return factory.data(this.$el, 'components', components);
+    };
+
+    Component.prototype.$ = function(el) {
+      return this.$el.find(el);
+    };
+
+    Component.prototype.on = function($el, event, handler) {
+      var handlers, selector, type, _ref;
+      if (arguments.length < 2) {
+        handlers = $el;
+        for (event in handlers) {
+          handler = handlers[event];
+          this.on(event, handler);
+        }
+        return this;
+      } else if (arguments.length < 3) {
+        if (!(_.isString(event) || _.isFunction(event))) {
+          handlers = event;
+          for (event in handlers) {
+            handler = handlers[event];
+            this.on($el, event, handler);
+          }
+          return this;
+        } else {
+          handler = event;
+          event = $el;
+          $el = this.$el;
+        }
+      }
+      if (!($el instanceof $)) {
+        throw new Error('the element provided to on must be a jQuery object');
+      }
+      this._listeners = this._listeners.add($el);
+      _ref = splitOnce(event, ' '), type = _ref[0], selector = _ref[1];
+      type = "" + type + "." + this._uniqueId;
+      if (_.isString(handler)) {
+        handler = this._handler(handler);
+      }
+      if (selector) {
+        $el.on(type, selector, handler);
+      } else {
+        $el.on(type, handler);
+      }
+      return this;
+    };
+
+    Component.prototype.off = function($el, event, handler) {
+      var events, handlers, selector, type, _i, _j, _len, _len1, _ref;
+      if (arguments.length < 1) {
+        $el = this.$el;
+      } else if (arguments.length < 2) {
+        if (_.isArray($el)) {
+          events = $el;
+          for (_i = 0, _len = events.length; _i < _len; _i++) {
+            event = events[_i];
+            this.off(event);
+          }
+          return this;
+        } else if ($.isPlainObject($el)) {
+          handlers = $el;
+          for (event in handlers) {
+            handler = handlers[event];
+            this.off(event, handler);
+          }
+          return this;
+        } else if (_.isString($el)) {
+          event = $el;
+          $el = this.$el;
+        }
+      } else if (arguments.length < 3) {
+        if (_.isArray(event)) {
+          events = event;
+          for (_j = 0, _len1 = events.length; _j < _len1; _j++) {
+            event = events[_j];
+            this.off($el, event);
+          }
+          return this;
+        } else if (_.isObject(event)) {
+          handlers = event;
+          for (event in handlers) {
+            handler = handlers[event];
+            this.off($el, event, handler);
+          }
+          return this;
+        } else if (!($el instanceof $)) {
+          handler = event;
+          event = $el;
+          $el = this.$el;
+        }
+      }
+      if (!($el instanceof $)) {
+        throw new Error('the element provided to off must be a jQuery object');
+      }
+      if (_.isString(handler)) {
+        handler = this._handler(handler);
+      }
+      if (event) {
+        _ref = splitOnce(event, ' '), type = _ref[0], selector = _ref[1];
+        type = "" + type + "." + this._uniqueId;
+        if (selector) {
+          $el.off(type, selector, handler);
+        } else {
+          $el.off(type, handler);
+        }
+      } else {
+        $el.off("." + this._uniqueId);
+      }
+      return this;
+    };
+
+    Component.prototype.trigger = function() {
+      var componentLabel, event, namespaceLabel, params, type;
+      type = arguments[0], params = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      namespaceLabel = this.constructor.namespace.label.toLowerCase();
+      componentLabel = this.constructor.label.toLowerCase();
+      event = "" + namespaceLabel + ":" + componentLabel + ":" + type;
+      return this.$el.trigger(event, params);
+    };
+
+    Component.prototype.data = function($el, name, value) {
+      var factory;
+      if (arguments.length < 3 && _.isString($el)) {
+        value = name;
+        name = $el;
+        $el = this.$el;
+      }
+      if (!($el instanceof $)) {
+        throw new Error('given element to data must be a jQuery object');
+      }
+      factory = this.constructor.namespace.factory;
+      name = this._dataName(name);
+      if (_.isUndefined(value)) {
+        return factory.data($el, name);
+      } else {
+        factory.data($el, name, value);
+        this._dataFull = this._dataFull.add($el);
+        return this._dataNames.push(name);
+      }
+    };
+
+    Component.prototype.removeData = function($el, name) {
+      var factory;
+      if (arguments.length < 2) {
+        name = $el;
+        $el = this.$el;
+      }
+      if (!($el instanceof $)) {
+        throw new Error('given element to removeData must be a jQuery object');
+      }
+      factory = this.constructor.namespace.factory;
+      name = this._dataName(name);
+      return factory.removeData($el, name);
+    };
+
+    Component.prototype._handler = function(name) {
+      if (this._handlers[name]) {
+        return this._handlers[name];
+      } else {
+        return this._handlers[name] = (function(_this) {
+          return function() {
+            var args;
+            args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+            return _this[name].apply(_this, args);
+          };
+        })(this);
+      }
+    };
+
+    Component.prototype._dataName = function(name) {
+      return "" + this._uniqueId + "-" + name;
+    };
+
+    return Component;
+
+  })(Unit);
+
+  Module = (function(_super) {
+    var delegatedMethods, method, _fn, _i, _len;
+
+    __extends(Module, _super);
+
+    Module._extensions = {};
+
+    Module.muObject = function(options) {
+      var prototype;
+      prototype = this.prototype;
+      if (prototype instanceof Module) {
+        return {
+          configure: (function(_this) {
+            return function(config) {
+              return _this.configure(config);
+            };
+          })(this)
+        };
+      } else {
+        return {
+          configure: (function(_this) {
+            return function(config) {
+              options.config = config;
+              return _this.muObject(options);
+            };
+          })(this),
+          extend: (function(_this) {
+            return function(name) {
+              options.extend = factory.module(name);
+              return _this.muObject(options);
+            };
+          })(this),
+          extensions: (function(_this) {
+            return function(extensions) {
+              options.extensions = extensions;
+              return _this.muObject(options);
+            };
+          })(this),
+          create: (function(_this) {
+            return function(properties) {
+              var Parent;
+              options.properties = properties;
+              Parent = options.extend || _this;
+              return Parent.extend(options);
+            };
+          })(this)
+        };
+      }
+    };
+
+    Module.extend = function(options) {
+      var Child;
+      Child = Module.__super__.constructor.extend.call(this, options);
+      Child._extensions = _.clone(Child._extensions);
+      if (options.extensions) {
+        _.extend(Child._extensions, options.extensions);
+      }
+      return Child.muObject();
+    };
+
+    Module.included = function(Component) {
+      var extension, fullName, name, _ref, _results;
+      fullName = this.fullName();
+      _ref = this._extensions;
+      _results = [];
+      for (name in _ref) {
+        extension = _ref[name];
+        _results.push((function(extension) {
+          return Component.prototype[name] = function() {
+            var args, instance;
+            args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+            instance = this._moduleInstances[fullName];
+            return extension.apply(instance, args);
+          };
+        })(extension));
+      }
+      return _results;
+    };
+
+    function Module(component, config) {
+      this.component = component;
+      this.$el = this.component.$el;
+      Module.__super__.constructor.call(this, config);
+    }
+
+    delegatedMethods = ['$', 'on', 'off', 'trigger', 'data', 'removeData'];
+
+    _fn = function(name) {
+      return Module.prototype[name] = function() {
+        var args, _ref;
+        args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+        return (_ref = this.component)[name].apply(_ref, args);
+      };
+    };
+    for (_i = 0, _len = delegatedMethods.length; _i < _len; _i++) {
+      method = delegatedMethods[_i];
+      _fn(method);
+    }
+
+    return Module;
+
+  })(Unit);
+
+  factory = new Factory();
+
+  mu = function(objectName) {
+    var C, M, componentName, currentName, moduleName, names, namespace, namespaceName;
+    if (objectName == null) {
+      objectName = '';
+    }
+    names = objectName.split('.');
+    currentName = names.shift();
+    switch (currentName) {
+      case 'components':
+      case 'modules':
+      case '':
+        namespaceName = factory.config.defaultNamespace;
+        break;
+      default:
+        if (currentName.match(Unit.labelFormat)) {
+          namespaceName = factory.config.defaultNamespace;
+        } else {
+          namespaceName = currentName;
+          currentName = names.shift();
+        }
+    }
+    if (!(namespace = factory.namespace(namespaceName, true))) {
+      namespace = factory.createNamespace(namespaceName);
+    }
+    if (!currentName) {
+      return namespace.muObject();
+    }
+    switch (currentName) {
+      case 'components':
+        componentName = names.shift();
+        if (C = namespace.component(componentName, true)) {
+          return C.muObject();
+        } else {
+          return Component.muObject({
+            namespace: namespace,
+            label: componentName
+          });
+        }
+        break;
+      case 'modules':
+        moduleName = names.shift();
+        if (M = namespace.module(moduleName, true)) {
+          return M.muObject();
+        } else {
+          return Module.muObject({
+            namespace: namespace,
+            label: moduleName
+          });
+        }
+        break;
+      default:
+        if (C = namespace.component(currentName, true)) {
+          return C.muObject();
+        } else if (M = namespace.module(currentName, true)) {
+          return M.muObject();
+        } else {
+          return Component.muObject({
+            namespace: namespace,
+            label: currentName
+          });
+        }
+    }
+  };
+
+  delegatedMethods = ['configure', 'setup', 'initialize', 'destroy', 'clean'];
+
+  _fn = function(name) {
+    return mu[name] = function() {
+      var args;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      return factory[name].apply(factory, args);
+    };
+  };
+  for (_i = 0, _len = delegatedMethods.length; _i < _len; _i++) {
+    method = delegatedMethods[_i];
+    _fn(method);
+  }
+
+  window.Micro = window.mu = mu;
+
+}).call(this);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: micro-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha5
+  version: 0.1.0.pre.alpha6
 platform: ruby
 authors:
 - Jérôme Guyon