RubyGems - dou-rails - Versions diffs - 0.0.1 - Mend

dou-rails 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

checksums.yaml +7 -0
data/MIT-LICENSE +20 -0
data/README.md +39 -0
data/lib/dou/engine.rb +4 -0
data/lib/dou/version.rb +3 -0
data/lib/dou.rb +5 -0
data/vendor/assets/javascripts/dou-min.js +1 -0
data/vendor/assets/javascripts/dou.js +783 -0
metadata +72 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f212032ed226297e6384b770060d9209d5a97bb7
+  data.tar.gz: 6412f6c14c3d320b65d4d473c9c3ef98aa8a1b46
+SHA512:
+  metadata.gz: 8c6b44ec31e41935290b2a2d9c9a3e6b6f739d419c5bfd66fbf3cce18ca3cdda6f52ce56a07083860b2aae8d9fbd5e397453f6a2ac0d59f2120c1d371c0ac24e
+  data.tar.gz: 239eb1687d3d126ae53760a0828c310cf427516772ceb691cd0683dfbb45b8b9d775a539cfcb33ee58d3499abe60ba318cd43dbd349f9c3ea339d252b84092c3

data/MIT-LICENSE ADDED Viewed

@@ -0,0 +1,20 @@
+Copyright 2014 Hatio, Lab.
+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 ADDED Viewed

@@ -0,0 +1,39 @@
+dou
+=======
+Light-weight javascript module framework
+## Features
+ * Mixin base
+## Usage
+```js
+var dou = require('dou');
+function Super() {
+...
+}
+function mixin1() {
+	this.methodA = function() { return 'foo'; };
+}
+function mixin2() {
+	this.methodB = function() { return 'bar'; };
+}
+var Clazz = dou.define({
+	extend : Super,
+	mixins : [mixin1, mixin2]
+});
+var inst = new Clazz();
+inst.methodA();
+inst.methodB();
+```
+## License
+Copyright (c) 2014 Hearty, Oh. Licensed under the MIT license.

data/lib/dou/engine.rb ADDED Viewed

@@ -0,0 +1,4 @@
+module Dou
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/dou/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Dou
+  VERSION = "0.0.1"
+end

data/lib/dou.rb ADDED Viewed

@@ -0,0 +1,5 @@
+require 'dou/engine' if ::Rails.version >= '3.1'
+require 'dou/version'
+module Dou
+end

data/vendor/assets/javascripts/dou-min.js ADDED Viewed

@@ -0,0 +1 @@

data/vendor/assets/javascripts/dou.js ADDED Viewed

@@ -0,0 +1,783 @@
+/*! dou - v0.0.1 - 2014-02-25
+* https://github.com/heartyoh/dou
+* Copyright (c) 2014 Hearty, Oh.; Licensed MIT */
+(function() {
+  define(['./compose'], function(compose) {
+    "use strict";
+    var advice;
+    advice = {
+      around: function(base, wrapped) {
+        return function() {
+          var args, el, i, l, _i, _len;
+          l = arguments.length;
+          args = new Array(l + 1);
+          args[0] = base.bind(this);
+          for (i = _i = 0, _len = args.length; _i < _len; i = ++_i) {
+            el = args[i];
+            args[i + 1] = arguments[i];
+          }
+          return wrapped.apply(this, args);
+        };
+      },
+      before: function(base, before) {
+        var beforeFn;
+        beforeFn = typeof before === 'function' ? before : before.obj[before.fnName];
+        return function() {
+          beforeFn.apply(this, arguments);
+          return base.apply(this, arguments);
+        };
+      },
+      after: function(base, after) {
+        var afterFn;
+        afterFn = (typeof after === 'function' ? after : after.obj[after.fnName]);
+        return function() {
+          var res;
+          res = (base.unbound || base).apply(this, arguments);
+          afterFn.apply(this, arguments);
+          return res;
+        };
+      },
+      withAdvice: function() {
+        return ['before', 'after', 'around'].forEach(function(m) {
+          return this[m] = function(method, fn) {
+            return compose.unlockProperty(this, method, function() {
+              if (typeof this[method] === 'function') {
+                this[method] = advice[m](this[method], fn);
+              } else {
+                this[method] = fn;
+              }
+              return this[method];
+            });
+          };
+        }, this);
+      }
+    };
+    return advice;
+  });
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty;
+  define(['./utils', './debug'], function(utils, debug) {
+    "use strict";
+    var canWriteProtect, dontLock, e, mixin, setPropertyWritability, unlockProperty;
+    canWriteProtect = debug.enabled && !utils.isEnumerable(Object, 'getOwnPropertyDescriptor');
+    dontLock = ['mixedIn', 'mixingIn'];
+    if (canWriteProtect) {
+      try {
+        Object.getOwnPropertyDescriptor(Object, 'keys');
+      } catch (_error) {
+        e = _error;
+        canWriteProtect = false;
+      }
+    }
+    setPropertyWritability = function(obj, isWritable) {
+      var desc, key, props;
+      if (!canWriteProtect) {
+        return;
+      }
+      props = Object.create(null);
+      for (key in obj) {
+        if (!__hasProp.call(obj, key)) continue;
+        if (dontLock.indexOf(key < 0)) {
+          desc = Object.getOwnPropertyDescriptor(obj, key);
+          desc.writable = isWritable;
+          props[key] = desc;
+        }
+      }
+      return Object.defineProperties(obj, props);
+    };
+    unlockProperty = function(obj, prop, op) {
+      var writable;
+      if (!canWriteProtect || !obj.hasOwnProperty(prop)) {
+        return op.call(obj);
+      }
+      writable = Object.getOwnPropertyDescriptor(obj, prop).writable;
+      Object.defineProperties(obj, prop, {
+        writable: true
+      });
+      op.call(obj);
+      return Object.defineProperties(obj, prop, {
+        writable: writable
+      });
+    };
+    mixin = function(base, mixins) {
+      var _i, _len;
+      if (!(mixins instanceof Array)) {
+        return this.mixin(base, [mixins]);
+      }
+      base.mixedIn = base.hasOwnProperty('mixedIn') ? base.mixedIn : [];
+      base.mixingIn = base.hasOwnProperty('mixingIn') ? base.mixingIn : [];
+      setPropertyWritability(base, false);
+      for (_i = 0, _len = mixins.length; _i < _len; _i++) {
+        mixin = mixins[_i];
+        if (!(base.mixedIn.indexOf(mixin) === -1)) {
+          continue;
+        }
+        if (base.mixingIn.indexOf(mixin) > -1) {
+          throw new Error('found cyclic dependencies between ' + base.mixingIn);
+        }
+        base.mixingIn.push(mixin);
+        mixin.call(base);
+        base.mixingIn.pop();
+        base.mixedIn.push(mixin);
+      }
+      return setPropertyWritability(base, true);
+    };
+    return {
+      mixin: mixin,
+      unlockProperty: unlockProperty
+    };
+  });
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty;
+  define([], function() {
+    "use strict";
+    var ALL, byName, byNameContains, byType, byValue, byValueCoerced, custom, defaultActionsFilter, defaultEventNamesFilter, filterEventLogsByAction, filterEventLogsByName, global, hideAllEventLogs, logFilter, retrieveLogFilter, saveLogFilter, search, showAllEventLogs, tests, traverse;
+    global = window || {};
+    traverse = function(comparator, clue, options) {
+      var obj, path, prop, _results;
+      options = options || {};
+      obj = options.obj || global;
+      path = options.path || (obj === global ? 'global' : '');
+      _results = [];
+      for (prop in obj) {
+        if (!__hasProp.call(obj, prop)) continue;
+        if ((tests[comparator] || comparator)(clue, obj, prop)) {
+          console.log("" + path + "." + prop + " -> (" + (typeof obj[prop]) + ")", obj[prop]);
+        }
+        if (obj[prop] && typeof obj[prop] === 'object' && obj[prop] !== obj) {
+          _results.push(traverse(comparator, clue, {
+            obj: obj[prop],
+            path: "" + path + "." + prop
+          }));
+        } else {
+          _results.push(void 0);
+        }
+      }
+      return _results;
+    };
+    search = function(comparator, expected, clue, options) {
+      if (!expected || typeof clue === expected) {
+        return traverse(comparator, clue, options);
+      } else {
+        return console.error("" + clue + " must be " + expected);
+      }
+    };
+    tests = {
+      name: function(clue, obj, prop) {
+        return clue === prop;
+      },
+      nameContains: function(clue, obj, prop) {
+        return prop.indexOf(clue) > -1;
+      },
+      type: function(clue, obj, prop) {
+        return obj[prop] instanceof clue;
+      },
+      value: function(clue, obj, prop) {
+        return obj[prop] === clue;
+      },
+      valueCoerced: function(clue, obj, prop) {
+        return obj[prop] == clue;
+      }
+    };
+    byName = function(clue, options) {
+      return search('name', 'string', clue, options);
+    };
+    byNameContains = function(clue, options) {
+      return search('nameContains', 'string', clue, options);
+    };
+    byType = function(clue, options) {
+      return search('type', 'function', clue, options);
+    };
+    byValue = function(clue, options) {
+      return search('value', null, clue, options);
+    };
+    byValueCoerced = function(clue, options) {
+      return search('valueCoerced', null, clue, options);
+    };
+    custom = function(comparator, options) {
+      return traverse(comparator, null, options);
+    };
+    filterEventLogsByAction = function() {
+      var actions;
+      actions = [].slice.call(arguments);
+      logFilter.eventNames.length || (logFilter.eventNames = ALL);
+      logFilter.actions = actions.length ? actions : ALL;
+      return saveLogFilter();
+    };
+    filterEventLogsByName = function() {
+      var eventNames;
+      eventNames = [].slice.call(arguments);
+      logFilter.actions.length || (logFilter.actions = ALL);
+      logFilter.eventNames = eventNames.length ? eventNames : ALL;
+      return saveLogFilter();
+    };
+    hideAllEventLogs = function() {
+      logFilter.actions = [];
+      logFilter.eventNames = [];
+      return saveLogFilter();
+    };
+    showAllEventLogs = function() {
+      logFilter.actions = ALL;
+      logFilter.eventNames = ALL;
+      return saveLogFilter();
+    };
+    saveLogFilter = function() {
+      if (global.localStorage) {
+        global.localStorage.setItem('logFilter_eventNames', logFilter.eventNames);
+        return global.localStorage.setItem('logFilter_actions', logFilter.actions);
+      }
+    };
+    retrieveLogFilter = function() {
+      var key, result, value;
+      result = {
+        eventNames: (global.localStorage && global.localStorage.getItem('logFilter_eventNames')) || defaultEventNamesFilter,
+        actions: (global.localStorage && global.localStorage.getItem('logFilter_actions')) || defaultActionsFilter
+      };
+      for (key in result) {
+        if (!__hasProp.call(result, key)) continue;
+        value = result[key];
+        if (typeof value === 'string' && value !== ALL) {
+          result[key] = value.split('.');
+        }
+      }
+      return result;
+    };
+    ALL = 'all';
+    defaultEventNamesFilter = [];
+    defaultActionsFilter = [];
+    logFilter = retrieveLogFilter();
+    return {
+      enable: function(enable) {
+        this.enabled = !!enable;
+        if (enable && global.console) {
+          console.info('Booting in DEBUG mode');
+          console.info('You can configure event logging with DEBUG.events.logAll()/logNone()/logByName()/logByAction()');
+        }
+        return global.DEBUG = this;
+      },
+      find: {
+        byName: byName,
+        byNameContains: byNameContains,
+        byType: byType,
+        byValue: byValue,
+        byValueCoerced: byValueCoerced,
+        custom: custom
+      },
+      events: {
+        logFilter: logFilter,
+        logByAction: filterEventLogsByAction,
+        logByName: filterEventLogsByName,
+        logAll: showAllEventLogs,
+        logNone: hideAllEventLogs
+      }
+    };
+  });
+}).call(this);
+(function() {
+  var __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; };
+  define(['./compose'], function(compose) {
+    "use strict";
+    var define;
+    define = function(options) {
+      var Component;
+      if (options["extends"]) {
+        Component = (function(_super) {
+          __extends(Component, _super);
+          function Component() {
+            return Component.__super__.constructor.apply(this, arguments);
+          }
+          return Component;
+        })(options["extends"]);
+      } else {
+        Component = (function() {
+          function Component() {}
+          return Component;
+        })();
+      }
+      if (options.mixins) {
+        compose.mixin(Component.prototype, options.mixins);
+      }
+      if (options.name) {
+        Component.name = options.name;
+      }
+      return Component;
+    };
+    return {
+      define: define
+    };
+  });
+}).call(this);
+(function() {
+  define(['./utils'], function(utils) {
+    "use strict";
+    var Event, eventSplitter, eventsApi, implementation, listenMethods, method, slice, triggerEvents;
+    slice = [].slice;
+    Event = {
+      withEvent: function() {
+        var method, _i, _len, _ref, _results;
+        _ref = ['on', 'off', 'once', 'trigger'];
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          method = _ref[_i];
+          _results.push(this[method] = Event[method]);
+        }
+        return _results;
+      },
+      on: function(name, callback, context) {
+        var events;
+        if (!eventsApi(this, 'on', name, [callback, context]) || !callback) {
+          return this;
+        }
+        this._events || (this._events = {});
+        events = this._events[name] || (this._events[name] = []);
+        events.push({
+          callback: callback,
+          context: context,
+          ctx: context || this
+        });
+        return this;
+      },
+      once: function(name, callback, context) {
+        var once, self;
+        if (!eventsApi(this, 'once', name, [callback, context]) || !callback) {
+          return this;
+        }
+        self = this;
+        once = utils.once(function() {
+          self.off(name, once);
+          return callback.apply(this, arguments);
+        });
+        once._callback = callback;
+        return this.on(name, once, context);
+      },
+      off: function(name, callback, context) {
+        var ev, events, i, j, names, retain, _i, _j, _len, _len1;
+        if (!this._events || !eventsApi(this, 'off', name, [callback, context])) {
+          return this;
+        }
+        if (!name && !callback && !context) {
+          this._events = void 0;
+          return this;
+        }
+        names = name ? [name] : Object.keys(this._events);
+        for (i = _i = 0, _len = names.length; _i < _len; i = ++_i) {
+          name = names[i];
+          if ((events = this._events[name])) {
+            this._events[name] = retain = [];
+            if (callback || context) {
+              for (j = _j = 0, _len1 = events.length; _j < _len1; j = ++_j) {
+                ev = events[j];
+                if ((callback && callback !== ev.callback && callback !== ev.callback._callback) || (context && context !== ev.context)) {
+                  retain.push(ev);
+                }
+              }
+            }
+            if (!retain.length) {
+              delete this._events[name];
+            }
+          }
+        }
+        return this;
+      },
+      trigger: function(name) {
+        var allEvents, args, events;
+        if (!this._events) {
+          return this;
+        }
+        args = slice.call(arguments, 1);
+        if (!eventsApi(this, 'trigger', name, args)) {
+          return this;
+        }
+        events = this._events[name];
+        allEvents = this._events.all;
+        if (events) {
+          triggerEvents(events, args);
+        }
+        if (allEvents) {
+          triggerEvents(allEvents, arguments);
+        }
+        return this;
+      },
+      stopListening: function(obj, name, callback) {
+        var id, listeningTo, remove;
+        listeningTo = this._listeningTo;
+        if (!listeningTo) {
+          return this;
+        }
+        remove = !name && !callback;
+        if (!callback && typeof name === 'object') {
+          callback = this;
+        }
+        if (obj) {
+          (listeningTo = {})[obj._listenId] = obj;
+        }
+        for (id in listeningTo) {
+          obj = listeningTo[id];
+          obj.off(name, callback, this);
+          if (remove || _.isEmpty(obj._events)) {
+            delete this._listeningTo[id];
+          }
+        }
+        return this;
+      }
+    };
+    eventSplitter = /\s+/;
+    eventsApi = function(obj, action, name, rest) {
+      var key, names, val, _i, _len;
+      if (!name) {
+        return true;
+      }
+      if (typeof name === 'object') {
+        for (key in name) {
+          val = name[key];
+          obj[action].apply(obj, [key, val].concat(rest));
+        }
+        return false;
+      }
+      if (eventSplitter.test(name)) {
+        names = name.split(eventSplitter);
+        for (_i = 0, _len = names.length; _i < _len; _i++) {
+          val = names[_i];
+          obj[action].apply(obj, [val].concat(rest));
+        }
+        return false;
+      }
+      return true;
+    };
+    triggerEvents = function(events, args) {
+      var ev, _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = events.length; _i < _len; _i++) {
+        ev = events[_i];
+        _results.push(ev.callback.apply(ev.ctx, args));
+      }
+      return _results;
+    };
+    listenMethods = {
+      listenTo: 'on',
+      listenToOnce: 'once'
+    };
+    for (method in listenMethods) {
+      implementation = listenMethods[method];
+      Event[method] = function(obj, name, callback) {
+        var id, listeningTo;
+        listeningTo = this._listeningTo || (this._listeningTo = {});
+        id = obj._listenId || (obj._listenId = utils.uniqueId('l'));
+        listeningTo[id] = obj;
+        if (!callback && typeof name === 'object') {
+          callback = this;
+        }
+        obj[implementation](name, callback, this);
+        return this;
+      };
+    }
+    return Event;
+  });
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty;
+  define(['./compose', './property'], function(compose, withProperty) {
+    "use strict";
+    return function() {
+      compose.mixin(this, withProperty);
+      this.initialize = function(attrs) {
+        var cloned, key, val, _ref;
+        attrs || (attrs = {});
+        cloned = {};
+        for (key in attrs) {
+          if (!__hasProp.call(attrs, key)) continue;
+          val = attrs[key];
+          cloned[key] = val;
+        }
+        _ref = this.defaults;
+        for (key in _ref) {
+          if (!__hasProp.call(_ref, key)) continue;
+          val = _ref[key];
+          if (!cloned.hasOwnProperty(key)) {
+            cloned[key] = val;
+          }
+        }
+        this.set(cloned);
+        return this;
+      };
+      return this.despose = function() {};
+    };
+  });
+}).call(this);
+(function() {
+  var __hasProp = {}.hasOwnProperty;
+  define(['./utils', './compose', './event'], function(utils, compose, event) {
+    "use strict";
+    return function() {
+      compose.mixin(this, event.withEvent);
+      this.set = function(key, val) {
+        var after, attrs, before, _ref, _ref1;
+        if (!key) {
+          return this;
+        }
+        if (arguments.length > 1 && typeof arguments[0] === 'string') {
+          attrs = {};
+          attrs[key] = val;
+          return this.set(attrs);
+        }
+        this.attrs || (this.attrs = {});
+        attrs = key;
+        after = {};
+        before = {};
+        _ref = this.attrs;
+        for (key in _ref) {
+          if (!__hasProp.call(_ref, key)) continue;
+          val = _ref[key];
+          before[key] = val;
+        }
+        utils.push(this.attrs, attrs);
+        _ref1 = this.attrs;
+        for (key in _ref1) {
+          if (!__hasProp.call(_ref1, key)) continue;
+          val = _ref1[key];
+          if (val !== before[key]) {
+            after[key] = val;
+          } else {
+            delete before[key];
+          }
+        }
+        if (Object.keys(after).length !== 0) {
+          this.trigger('change', {
+            before: before,
+            after: after
+          }, true);
+        }
+        return this;
+      };
+      return this.get = function(attr) {
+        return this.attrs && this.attrs[attr];
+      };
+    };
+  });
+}).call(this);
+(function() {
+  define(['./compose', './property'], function(compose, withProperty) {
+    "use strict";
+    return function() {
+      compose.mixin(this, withProperty);
+      this.serialize = function() {
+        return ["type: " + this.name, "id: " + this.id, "props: " + (JSON.stringify(this.attrs))].join(',');
+      };
+      return this.deserialize = function() {};
+    };
+  });
+}).call(this);
+(function() {
+  var __slice = [].slice,
+    __hasProp = {}.hasOwnProperty;
+  define([], function() {
+    "use strict";
+    var DEFAULT_INTERVAL, idCounter;
+    DEFAULT_INTERVAL = 100;
+    idCounter = 0;
+    return {
+      merge: function() {
+        var extenders, key, other, target, val, _i, _len;
+        target = arguments[0], extenders = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+        if (!target || typeof target === !"object") {
+          target = {};
+        }
+        for (_i = 0, _len = extenders.length; _i < _len; _i++) {
+          other = extenders[_i];
+          for (key in other) {
+            if (!__hasProp.call(other, key)) continue;
+            val = other[key];
+            if (typeof val !== "object") {
+              target[key] = val;
+            } else {
+              target[key] = this.merge(target[key], val);
+            }
+          }
+        }
+        return target;
+      },
+      push: function(base, extra, protect) {
+        var key, val;
+        if (!base || !extra) {
+          return base;
+        }
+        for (key in extra) {
+          if (!__hasProp.call(extra, key)) continue;
+          val = extra[key];
+          if (base[key] && protect) {
+            throw new Error("utils.push attempted to overwrite \"" + key + "\" while running in protected mode");
+          }
+          if (typeof base[key] === "object" && typeof extra[key] === "object") {
+            this.push(base[key], extra[key]);
+          } else {
+            base[key] = extra[key];
+          }
+        }
+        return base;
+      },
+      isEnumerable: function(obj, property) {
+        return Object.keys(obj).indexOf(property) > -1;
+      },
+      compose: function() {
+        var funcs;
+        funcs = arguments;
+        return function() {
+          var args, i, _i, _ref;
+          args = arguments;
+          for (i = _i = _ref = funcs.length - 1; _ref <= 0 ? _i <= 0 : _i >= 0; i = _ref <= 0 ? ++_i : --_i) {
+            args = funcs[i].apply(this, args);
+          }
+          return args[0];
+        };
+      },
+      uniqueArray: function(array) {
+        var a, item, u, _i, _len;
+        u = {};
+        a = [];
+        for (_i = 0, _len = array.length; _i < _len; _i++) {
+          item = array[_i];
+          if (u.hasOwnProperty(item)) {
+            continue;
+          }
+          a.push(item);
+          u[item] = 1;
+        }
+        return a;
+      },
+      debounce: function(func, wait, immediate) {
+        var result, timeout;
+        if (typeof wait !== 'number') {
+          wait = DEFAULT_INTERVAL;
+        }
+        timeout = 0;
+        result = null;
+        return function() {
+          var args, callNow, context, later;
+          context = this;
+          args = arguments;
+          later = function() {
+            timeout = null;
+            if (!immediate) {
+              return result = func.apply(context, args);
+            }
+          };
+          callNow = immediate && !timeout;
+          clearTimeout(timeout);
+          timeout = setTimeout(later, wait);
+          if (callNow) {
+            result = func.apply(context, args);
+          }
+          return result;
+        };
+      },
+      throttle: function(func, wait) {
+        var args, context, more, result, throttling, timeout, whenDone;
+        if (typeof wait !== 'number') {
+          wait = DEFAULT_INTERVAL;
+        }
+        context = args = timeout = throttling = more = result = null;
+        whenDone = this.debounce(function() {
+          return more = throttling = false;
+        }, wait);
+        return function() {
+          var later;
+          context = this;
+          args = arguments;
+          later = function() {
+            timeout = null;
+            if (more) {
+              result = func.apply(context, args);
+            }
+            return whenDone();
+          };
+          if (!timeout) {
+            timeout = setTimeout(later, wait);
+          }
+          if (throttling) {
+            more = true;
+          } else {
+            throttling = true;
+            result = func.apply(context, args);
+          }
+          whenDone();
+          return result;
+        };
+      },
+      countThen: function(num, base) {
+        return function() {
+          if (!--num) {
+            return base.apply(this, arguments);
+          }
+        };
+      },
+      delegate: function(rules) {
+        return function(e, data) {
+          var parent, selector, target;
+          target = $(e.target);
+          parent = null;
+          for (selector in rules) {
+            if (!__hasProp.call(rules, selector)) continue;
+            if (!e.isPropagationStopped() && (parent = target.closest(selector)).length) {
+              data = data || {};
+              data.el = parent[0];
+              return rules[selector].apply(this, [e, data]);
+            }
+          }
+        };
+      },
+      once: function(func) {
+        var ran, result;
+        ran = false;
+        result = null;
+        return function() {
+          if (ran) {
+            return result;
+          }
+          result = func.apply(this, arguments);
+          ran = true;
+          return result;
+        };
+      },
+      uniqueId: function(prefix) {
+        var id;
+        id = (++idCounter) + '';
+        if (prefix) {
+          return prefix + id;
+        } else {
+          return id;
+        }
+      }
+    };
+  });
+}).call(this);

metadata ADDED Viewed

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: dou-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Hearty, Oh
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-02-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: This gem provides light-weight javascript module framework for your Rails
+  3 application.
+email:
+- heartyoh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/dou.rb
+- lib/dou/engine.rb
+- lib/dou/version.rb
+- vendor/assets/javascripts/dou-min.js
+- vendor/assets/javascripts/dou.js
+homepage: http://github.com/heartyoh/dou
+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.6
+requirements: []
+rubyforge_project:
+rubygems_version: 2.2.1
+signing_key:
+specification_version: 4
+summary: A gem for Dou javascript module framework
+test_files: []