micro-rails 0.1.0.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8c88558102874866560fd567001b83370fcd0b4a
+  data.tar.gz: 9dbaf135cbda3e86067ade9da53625a934350d20
+SHA512:
+  metadata.gz: c4c2f58ad7e3cd30a144b6cbf5ee2f192caec0015d1d3080d56b4517296a16ccd46d0c7bc099a0ddc8b71d36258315ab3febd1453f0b5add7f7e247b10110b92
+  data.tar.gz: be97b232c2919d48f2a41467bb32b65e2ed779bf889b6d5620c555b8f522fc2593f36aa29666433fb91aef32ee002e739817abf1c4a6cd1cd16a3d5c53e9846f

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jérôme Guyon
+
+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,31 @@
+# Micro::Rails
+
+This gem ships the javascript library **Micro**, a micro library helping to structure your client code by using the concept of components.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'micro-rails'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install micro-rails
+
+Then in your application.js file, add:
+
+```javascript
+//= require jquery
+//= require underscore
+//= require micro
+```
+
+## Usage
+
+See [the Micro README](https://github.com/jguyon/micro/blob/master/README.md).

data/Rakefile

@@ -0,0 +1,7 @@
+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`
+end

data/lib/micro/rails/engine.rb

@@ -0,0 +1,6 @@
+module Micro
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/micro/rails/version.rb

@@ -0,0 +1,6 @@
+module Micro
+  module Rails
+    VERSION = "0.1.0-alpha"
+    MICRO_VERSION = VERSION
+  end
+end

data/lib/micro/rails.rb

@@ -0,0 +1,6 @@
+require "micro/rails/version"
+
+module Micro
+  module Rails
+  end
+end

data/lib/micro-rails.rb

@@ -0,0 +1 @@
+require 'micro/rails'

data/micro-rails.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'micro/rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "micro-rails"
+  spec.version       = Micro::Rails::VERSION
+  spec.authors       = ["Jérôme Guyon"]
+  spec.email         = ["jeromep.guyon@gmail.com"]
+  spec.summary       = %q{Ships the javascript library Micro for the Rails asset-pipeline.'}
+  spec.homepage      = "https://github.com/jguyon/micro-rails"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "jquery-rails", ">= 4.0"
+  spec.add_dependency "underscore-rails", ">= 1.7"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/vendor/assets/javascripts/micro.js

@@ -0,0 +1,865 @@
+// Generated by CoffeeScript 1.9.0
+(function() {
+  var Component, Factory, Module, Namespace, Unit, factory, splitOnce, splitUnitName, µ,
+    __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; },
+    __hasProp = {}.hasOwnProperty,
+    __slice = [].slice;
+
+  splitOnce = function(string, char) {
+    var splits;
+    splits = string.split(char);
+    return [splits.shift(), splits.join(char)];
+  };
+
+  splitUnitName = function(name) {
+    var label, namespace, _ref;
+    _ref = splitOnce(name, '.'), namespace = _ref[0], label = _ref[1];
+    if (!label) {
+      label = namespace;
+      namespace = factory.config.defaultNamespace;
+    }
+    return [namespace, label];
+  };
+
+  Factory = (function() {
+    function Factory() {
+      this.config = {
+        defaultNamespace: 'app',
+        dataPrefix: 'micro',
+        methodPrefix: 'µ'
+      };
+      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, selector, config) {
+            var Component;
+            if (!(_.isString(selector) || _.isElement(selector))) {
+              config = selector;
+              selector = null;
+            }
+            Component = _this.component(name);
+            selector || (selector = Component.config.defaultSelector);
+            if (!selector) {
+              throw new Error('you must provide a selector or define defaultSelector in the component configuration');
+            }
+            _this._initialize.push(function() {
+              Component.initialize(this.filter(selector), config);
+              return Component.initialize(this.find(selector), config);
+            });
+            return _this._destroy.unshift(function() {
+              Component.destroy(this.filter(selector));
+              return Component.destroy(this.find(selector));
+            });
+          };
+        })(this)
+      });
+    };
+
+    Factory.prototype.initialize = function(el) {
+      var $el, initialize, _i, _len, _ref, _results;
+      if (el) {
+        $el = $(el);
+      } else {
+        $el = $(document);
+      }
+      _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;
+      if (el) {
+        $el = $(el);
+      } else {
+        $el = $(this.config.rootElement);
+      }
+      _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() {
+      µ.destroy();
+      this._namespaces = {};
+      this._initialize = [];
+      return this._destroy = [];
+    };
+
+    Factory.prototype.namespace = function(label, doNotRaise) {
+      var namespace;
+      if (doNotRaise == null) {
+        doNotRaise = false;
+      }
+      if (!((namespace = this._namespaces[label]) || doNotRaise)) {
+        throw new Error("could not find namespace " + label);
+      }
+      return namespace;
+    };
+
+    Factory.prototype.component = function(name, doNotRaise) {
+      var label, namespace, _ref;
+      if (doNotRaise == null) {
+        doNotRaise = false;
+      }
+      _ref = splitUnitName(name), namespace = _ref[0], label = _ref[1];
+      return this.namespace(namespace, doNotRaise).component(label, doNotRaise);
+    };
+
+    Factory.prototype.module = function(name, doNotRaise) {
+      var label, namespace, _ref;
+      if (doNotRaise == null) {
+        doNotRaise = false;
+      }
+      _ref = splitUnitName(name), namespace = _ref[0], label = _ref[1];
+      return this.namespace(namespace, doNotRaise).module(label, doNotRaise);
+    };
+
+    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._dataName = function(name) {
+      return this.config.dataPrefix + "-" + name;
+    };
+
+    return Factory;
+
+  })();
+
+  Namespace = (function() {
+    Namespace.labelFormat = /^[a-z][a-zA-Z0-9]*$/;
+
+    Namespace.prototype.µObject = function() {
+      return {
+        configure: (function(_this) {
+          return function(config) {
+            _this.configure(config);
+            return _this.µObject();
+          };
+        })(this)
+      };
+    };
+
+    function Namespace(_at_factory, _at_label) {
+      this.factory = _at_factory;
+      this.label = _at_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.configure = function(config) {
+      if (config == null) {
+        config = {};
+      }
+      return _.extend(this.config, config);
+    };
+
+    Namespace.prototype.component = function(label, doNotRaise) {
+      var Component;
+      if (doNotRaise == null) {
+        doNotRaise = false;
+      }
+      if (!((Component = this._components[label]) || doNotRaise)) {
+        throw new Error("component " + label + " could not be found in namespace " + this.name);
+      }
+      return Component;
+    };
+
+    Namespace.prototype.module = function(label, doNotRaise) {
+      var Module;
+      if (doNotRaise == null) {
+        doNotRaise = false;
+      }
+      if (!((Module = this._modules[label]) || doNotRaise)) {
+        throw new Error("module " + label + " could not be found in namespace " + this.name);
+      }
+      return Module;
+    };
+
+    Namespace.prototype.addUnit = function(Unit) {
+      var prototype;
+      prototype = Unit.prototype;
+      if (prototype instanceof Component) {
+        return this._addComponent(Unit);
+      } else if (prototype instanceof Module) {
+        return this._addModule(Unit);
+      } else {
+        throw new Error("the unit must be a module or a component");
+      }
+    };
+
+    Namespace.prototype._addComponent = function(Component) {
+      Component.namespace = this;
+      return this._components[Component.label] = Component;
+    };
+
+    Namespace.prototype._addModule = function(Module) {
+      Module.namespace = this;
+      return this._modules[Module.label] = Module;
+    };
+
+    return Namespace;
+
+  })();
+
+  Unit = (function() {
+    Unit.namespace = null;
+
+    Unit.label = null;
+
+    Unit.labelFormat = /^[A-Z][A-Za-z0-9]*$/;
+
+    Unit.config = {};
+
+    Unit._initializeMethods = [];
+
+    Unit._destroyMethods = [];
+
+    Unit.extend = function(options) {
+      var Child, Parent;
+      if (!options.namespace) {
+        throw new Error("you must provide a namespace when creating a component");
+      }
+      if (!options.label) {
+        throw new Error("you must provide a name when creating a component");
+      }
+      if (!options.label.match(this.labelFormat)) {
+        throw new Error(options.label + " is not a valid component name");
+      }
+      Parent = this;
+      Child = (function(_super) {
+        var _destroy, _initialize;
+
+        __extends(Child, _super);
+
+        function Child() {
+          return Child.__super__.constructor.apply(this, arguments);
+        }
+
+        Child.label = options.label;
+
+        Child.config = _.clone(Child.config);
+
+        if (options.config) {
+          _.extend(Child.config, options.config);
+        }
+
+        Child._modules = _.clone(Child._modules);
+
+        if (options.properties) {
+          if (_initialize = options.properties._initialize) {
+            Child._initializeMethods = _.clone(Child._initializeMethods);
+            Child._initializeMethods.push(_initialize);
+            delete options.properties._initialize;
+          }
+          if (_destroy = options.properties._destroy) {
+            Child._destroyMethods = _.clone(Child._destroyMethods);
+            Child._destroyMethods.unshift(_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.µObject();
+    };
+
+    Unit.fullName = function() {
+      return this.namespace.label + "-" + this.label;
+    };
+
+    function Unit(_at_config) {
+      var initialize, method, name, _i, _len, _ref, _ref1;
+      this.config = _at_config != null ? _at_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._initializeMethods;
+      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._destroyMethods;
+      _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.µObject = 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(componentName) {
+              options.extend = factory.component(componentName);
+              return _this.µObject(options);
+            };
+          })(this),
+          module: (function(_this) {
+            return function(moduleName) {
+              if (options.modules) {
+                options.modules.push(moduleName);
+              } else {
+                options.modules = [moduleName];
+              }
+              return _this.µObject(options);
+            };
+          })(this),
+          configure: (function(_this) {
+            return function(config) {
+              if (options.config) {
+                _.extend(options.config, config);
+              } else {
+                options.config = config;
+              }
+              return _this.µObject(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, moduleName, _i, _len, _ref;
+      Child = Component.__super__.constructor.extend.call(this, options);
+      if (options.modules) {
+        _ref = options.modules;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          moduleName = _ref[_i];
+          Child.include(moduleName);
+        }
+      }
+      return Child.µObject();
+    };
+
+    Component.include = function(moduleName) {
+      var Module;
+      Module = this.namespace.factory.module(moduleName);
+      if (this._modules[Module.fullName()]) {
+        throw new Error("module " + Module.namespace + "." + Module.label + " is already included");
+      }
+      this._modules[Module.label] = 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.µObject();
+    };
+
+    Component._methods = function(instances) {
+      var methodName, methodNames, methods, prefix, _fn, _i, _len;
+      prefix = this.namespace.factory.config.methodPrefix;
+      methodNames = _.chain(this.prototype).functions().filter(function(name) {
+        return name.match(new RegExp("^" + prefix + "[A-Z]"));
+      }).value();
+      methods = {};
+      _fn = function(oldName) {
+        var newName;
+        newName = methodName[prefix.length].toLowerCase() + methodName.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 = results.pop();
+          if (_.isNull(lastResult)) {
+            return methods;
+          } else {
+            return lastResult;
+          }
+        };
+      };
+      for (_i = 0, _len = methodNames.length; _i < _len; _i++) {
+        methodName = methodNames[_i];
+        _fn(methodName);
+      }
+      methods.destroy = (function(_this) {
+        return function() {
+          _.invoke(instances, 'destroy');
+          return _this.µObject();
+        };
+      })(this);
+      return methods;
+    };
+
+    Component._instance = function($el) {
+      var components;
+      components = this.namespace.factory.data($el, 'components') || {};
+      if (!components[this.fullName()]) {
+        throw new Error('component is not initialized');
+      }
+      return components[this.fullName()];
+    };
+
+    function Component(_at_$el, config) {
+      var Module, components, factory, moduleLabel, name, _ref;
+      this.$el = _at_$el;
+      factory = this.constructor.namespace.factory;
+      components = factory.data(this.$el, 'components') || {};
+      name = this.constructor.fullName();
+      if (components[name]) {
+        throw new Error('component is already initialized');
+      }
+      components[name] = this;
+      factory.data(this.$el, 'components', components);
+      this._uniqueId = _.uniqueId((this.constructor.fullName()) + "-");
+      this._listeners = $();
+      this._dataFull = $();
+      this._dataNames = [];
+      Component.__super__.constructor.call(this, config);
+      this._moduleInstances = [];
+      _ref = this.constructor._modules;
+      for (moduleLabel in _ref) {
+        Module = _ref[moduleLabel];
+        this._moduleInstances.push(new Module(this, this.config));
+      }
+    }
+
+    Component.prototype.destroy = function() {
+      var components, dataName, factory, moduleInstance, _i, _j, _len, _len1, _ref, _ref1;
+      Component.__super__.destroy.apply(this, arguments);
+      _ref = this._moduleInstances;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        moduleInstance = _ref[_i];
+        moduleInstance.destroy();
+      }
+      factory = this.constructor.namespace.factory;
+      this._listeners.off("." + this._uniqueId);
+      _ref1 = this._dataNames;
+      for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+        dataName = _ref1[_j];
+        factory.removeData(this._dataFull, dataName);
+      }
+      components = factory.data(this.$el, 'components');
+      delete components[this.constructor.fullName()];
+      return factory.data(this.$el, 'components', components);
+    };
+
+    Component.prototype.$ = function(selector) {
+      return this.$el.find(selector);
+    };
+
+    Component.prototype.on = function(el, handlers) {
+      var $el, event, handler, selector, type, _ref, _results;
+      if (!handlers) {
+        handlers = el;
+        $el = this.$el;
+      } else {
+        $el = $(el);
+      }
+      this._listeners = this._listeners.add($el);
+      _results = [];
+      for (event in handlers) {
+        handler = handlers[event];
+        _ref = splitOnce(event, ' '), type = _ref[0], selector = _ref[1];
+        type = type + "." + this._uniqueId;
+        if (_.isString(handler)) {
+          (function(_this) {
+            return (function(method) {
+              return handler = function() {
+                var args;
+                args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+                return _this[method].apply(_this, args);
+              };
+            });
+          })(this)(handler);
+        }
+        if (selector) {
+          _results.push($el.on(type, selector, handler));
+        } else {
+          _results.push($el.on(type, handler));
+        }
+      }
+      return _results;
+    };
+
+    Component.prototype.off = function(el, eventType) {
+      var $el;
+      if (arguments.length < 2 && _.isString(el) || _.isUndefined(el)) {
+        eventType = el;
+        $el = this.$el;
+      } else {
+        $el = $(el);
+      }
+      if (eventType) {
+        return $el.off(eventType + "." + this._uniqueId);
+      } else {
+        return $el.off("." + this._uniqueId);
+      }
+    };
+
+    Component.prototype.trigger = function() {
+      var eventType, namespace, params, _ref;
+      eventType = arguments[0], params = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      namespace = this.constructor.fullName();
+      return (_ref = this.$el).trigger.apply(_ref, [namespace + ":" + eventType].concat(__slice.call(params)));
+    };
+
+    Component.prototype.data = function(el, name, value) {
+      var factory;
+      if (arguments.length < 3 && _.isString(el)) {
+        value = name;
+        name = el;
+        el = this.$el;
+      }
+      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.add(el);
+        return this._dataNames.push(name);
+      }
+    };
+
+    Component.prototype.removeData = function(el, name) {
+      var factory;
+      if (arguments.length < 2) {
+        name = el;
+        el = this.$el;
+      }
+      factory = this.constructor.namespace.factory;
+      name = this._dataName(name);
+      return factory.removeData(el, name);
+    };
+
+    Component.prototype._dataName = function(name) {
+      return this._uniqueId + "-" + name;
+    };
+
+    return Component;
+
+  })(Unit);
+
+  Module = (function(_super) {
+    var componentMethod, delegatedMethods, _fn, _i, _len;
+
+    __extends(Module, _super);
+
+    Module._extensions = {};
+
+    Module.µObject = 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.µObject(options);
+            };
+          })(this),
+          extend: (function(_this) {
+            return function(moduleName) {
+              options.extend = factory.module(moduleName);
+              return _this.µObject(options);
+            };
+          })(this),
+          extensions: (function(_this) {
+            return function(extensions) {
+              options.extensions = extensions;
+              return _this.µObject(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);
+      if (options.extensions) {
+        _.extend(Child._extensions, options.extensions);
+      }
+      return Child.µObject();
+    };
+
+    Module.included = function(Component) {
+      return _.extend(Component.prototype, this._extensions);
+    };
+
+    function Module(_at_component, config) {
+      this.component = _at_component;
+      this.$el = this.component.$el;
+      Module.__super__.constructor.call(this, config);
+    }
+
+    Module.prototype.on = function(el, handlers) {
+      var event, handler;
+      if (!handlers) {
+        handlers = el;
+        el = this.$el;
+      }
+      for (event in handlers) {
+        handler = handlers[event];
+        if (_.isString(handler)) {
+          (function(_this) {
+            return (function(method) {
+              return handler = function() {
+                var args;
+                args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+                return _this[method].apply(_this, args);
+              };
+            });
+          })(this)(handler);
+          handlers[event] = handler;
+        }
+      }
+      return this.component.on(el, handlers);
+    };
+
+    delegatedMethods = ['$', '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++) {
+      componentMethod = delegatedMethods[_i];
+      _fn(componentMethod);
+    }
+
+    return Module;
+
+  })(Unit);
+
+  factory = new Factory();
+
+  µ = 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.µObject();
+    }
+    switch (currentName) {
+      case 'components':
+        componentName = names.shift();
+        if (C = namespace.component(componentName, true)) {
+          return C.µObject();
+        } else {
+          return Component.µObject({
+            namespace: namespace,
+            label: componentName
+          });
+        }
+        break;
+      case 'modules':
+        moduleName = names.shift();
+        if (M = namespace.module(moduleName, true)) {
+          return M.µObject();
+        } else {
+          return Module.µObject({
+            namespace: namespace,
+            label: moduleName
+          });
+        }
+        break;
+      default:
+        if (C = namespace.component(currentName, true)) {
+          return C.µObject();
+        } else if (M = namespace.module(currentName, true)) {
+          return M.µObject();
+        } else {
+          return Component.µObject({
+            namespace: namespace,
+            label: currentName
+          });
+        }
+    }
+  };
+
+  _.extend(µ, {
+    configure: function(config) {
+      return factory.configure(config);
+    },
+    setup: function(setup) {
+      return factory.setup(setup);
+    },
+    initialize: function(el) {
+      return factory.initialize(el);
+    },
+    destroy: function(el) {
+      return factory.destroy(el);
+    },
+    clean: function() {
+      return factory.clean();
+    }
+  });
+
+  window.Micro = window.µ = µ;
+
+}).call(this);

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: micro-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.alpha
+platform: ruby
+authors:
+- Jérôme Guyon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jquery-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: underscore-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- jeromep.guyon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/micro-rails.rb
+- lib/micro/rails.rb
+- lib/micro/rails/engine.rb
+- lib/micro/rails/version.rb
+- micro-rails.gemspec
+- vendor/assets/javascripts/micro.js
+homepage: https://github.com/jguyon/micro-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Ships the javascript library Micro for the Rails asset-pipeline.'
+test_files: []