ende 0.4.5 → 0.4.6

data/vendor/components/indefinido-observable/components/kapit-observe-shim/component.json

@@ -0,0 +1,11 @@
+{
+  "name": "observe-shim",
+  "version": "0.1.1",
+  "main": "lib/observe-shim.js",
+  "devDependencies": {
+    "mocha": "~1.8.x",
+    "expect": "~0.2.0",
+    "sinon": "http://sinonjs.org/releases/sinon-1.6.0.js"
+  },
+  "repo": "https://raw.github.com/kapit/observe-shim"
+}

data/vendor/components/indefinido-observable/components/kapit-observe-utils/component.json

@@ -0,0 +1,13 @@
+{
+  "name": "observe-utils",
+  "version": "0.1.0",
+  "main": "lib/observe-utils.js",
+  "devDependencies": {
+    "expect": "~0.2.0",
+    "sinon": "http://sinonjs.org/releases/sinon-1.6.0.js",
+    "observe-shim": "https://github.com/KapIT/observe-shim.git",
+    "mocha": "~1.8.1",
+    "es5-shim": "~2.0.8"
+  },
+  "repo": "https://raw.github.com/kapit/observe-utils"
+}

data/vendor/components/indefinido-observable/karma.conf.js

@@ -0,0 +1,92 @@
+// Karma configuration
+
+module.exports = function(config) {
+  config.set({
+    // base path, that will be used to resolve files and exclude
+    basePath:  '',
+
+    // list of files / patterns to load in the browser
+    files:  [
+
+      // Test environment
+      //MOCHA,            Switch to mocha when not testing ie
+      //MOCHA_ADAPTER,
+      JASMINE,
+      JASMINE_ADAPTER,
+      'components/cjohansen-sinon/sinon.js',
+
+      // Test dependencies
+      'build/test.js',
+
+      // Test Source files
+      'spec/spec_helper.js',
+      'spec/**/*.js'
+    ],
+
+
+    // list of files to exclude
+    exclude:  [
+      'spec/coverage'
+    ],
+
+    // Custom frameworks
+    frameworks:  ['jasmine'],
+
+
+    // test results reporter to use
+    // possible values: 'dots', 'progress', 'junit'
+    reporters:  ['progress'], // , 'coverage'],
+
+
+    // web server port
+    port:  9876,
+
+
+    // cli runner port
+    runnerPort:  9100,
+
+
+    // enable / disable colors in the output (reporters and logs)
+    colors:  true,
+
+
+    // level of logging
+    // possible values: LOG_DISABLE || LOG_ERROR || LOG_WARN || LOG_INFO || LOG_DEBUG
+    logLevel:  LOG_INFO,
+
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch:  true,
+
+
+    // Start these browsers, currently available:
+    // - Chrome
+    // - ChromeCanary
+    // - Firefox
+    // - Opera
+    // - Safari (only Mac)
+    // - PhantomJS
+    // - IE (only Windows)
+    browsers:  ['Chrome'],
+
+
+    // If browser does not capture in given timeout [ms], kill it
+    captureTimeout:  60000,
+
+
+    // Continuous Integration mode
+    // if true, it capture browsers, run tests and exit
+    singleRun:  false,
+
+    // Coverage preprocessors
+    // preprocessors:  {
+    //  '**/lib/*.js': 'coverage'
+    // },
+
+    // Converage configuration
+    coverageReporter:  {
+      type : 'html',
+      dir  : 'spec/coverage'
+    }
+  });
+}

data/vendor/components/indefinido-observable/lib/adapters/rivets.js

@@ -3,7 +3,9 @@ exports.adapter = {
     if (record == null) {
       throw new TypeError('observable.adapters.rivets.subscribe: No record provided for subscription');
     }
-    return record.subscribe(attribute_path, callback);
+    if (attribute_path) {
+      return record.subscribe(attribute_path, callback);
+    }
   },
   unsubscribe: function(record, attribute_path, callback) {
     if (record == null) {

data/vendor/components/indefinido-observable/lib/observable.js

@@ -7,11 +7,12 @@ if (!Array.prototype.indexOf) require('../vendor/shims/array.indexOf');
 
 // Object.defineProperty (for ie5+)
 if (typeof require != 'undefined') {
-  require('../vendor/shims/accessors.js');
-
   // __lookup*__ and __define*__ for browsers with defineProperty support
   // TODO Figure out why gives an infinity loop
   require('../vendor/shims/accessors-legacy.js');
+
+  // Creates Object.defineProperty
+  require('../vendor/shims/accessors.js');
 }
 
 // Require Dependencies
@@ -88,9 +89,10 @@ mixin = {
 if (requiresDomElement) {
 
   observable = function (object) {
+    var fix;
 
     // observable() or observable(object)
-      if (this.document && this.location) {
+    if (this.document && this.location) {
       if (!object) {
         object = {};
       }
@@ -105,15 +107,28 @@ if (requiresDomElement) {
       }
     }
 
+    // TODO better documentation
     if (!jQuery.isReady) throw new Error('observable.call: For compatibility reasons, observable can only be called when dom is loaded.');
-    var fix = document.createElement('fix');
 
-    if (!jQuery.isReady) $(function () {document.body.appendChild(fix);});
-    else document.body.appendChild(fix);
+    // Create dom element if object isn't one
+    if (!(typeof object.nodeName === 'string')) {
+      fix = document.createElement('fix');
+
+      if (!jQuery.isReady) $(function () {document.body.appendChild(fix);});
+      else document.body.appendChild(fix);
 
-    if (!object.observed) generator.observable_for(fix);
+      // Replace object with dom node
+      object = fix;
+    }
+
+    // Observe element if it is not observed
+    // TODO remove jquery dependency
+    if (!object.observed) {
+      generator.observable_for(object);
+      object = $.extend(object, mixin);
+    }
 
-    return $.extend(fix, object, mixin);
+    return object;
   };
 
   var ignores = document.createElement('fix'), fix_ignores = [], property;
@@ -151,9 +166,8 @@ if (requiresDomElement) {
   observable.ignores = [];
 }
 
-
 observable.unobserve = function (object) {
-  var name, value, subname;
+  var name, value, subname, unobserved = {};
 
   // TODO remove root setter and root getter and callbacks from
   // callback thread
@@ -166,6 +180,7 @@ observable.unobserve = function (object) {
   // Remove array properties overrides
   for (name in object) {
     value = object[name];
+
     if ($.type(value) == 'array') {
       delete value.thread;
       delete value.object;
@@ -177,8 +192,16 @@ observable.unobserve = function (object) {
     }
   }
 
+  for (name in object) {
+    // TODO put Array.indexOf as a dependency
+    if (observable.ignores && observable.ignores.indexOf(name) == -1) {
+      unobserved[name] = object[name];
+    }
+  }
+
   delete object.observed;
-  return true;
+
+  return unobserved;
 };
 
 check = function (keypath, value) {
@@ -190,7 +213,8 @@ check = function (keypath, value) {
 };
 
 generator = {
-  observe: function(keypath, callback) {
+  // TODO pass object as parameter
+  observe: function (keypath, callback) {
     return Object.defineProperty(this, keypath, {
       get: generator.getter.call(this, keypath),
       set: generator.setter.call(this, keypath, callback),
@@ -199,11 +223,21 @@ generator = {
   },
 
   observable_for: function (object) {
-    return Object.defineProperty(object, 'observed', {
+    Object.defineProperty(object, 'observed', {
       configurable: true,
       enumerable: false,
       value: {}
     });
+
+    // TODO call the current object.toJSON after this method
+    return Object.defineProperty(object, 'toJSON', {
+      enumerable: false,
+      value: function () {
+        // TODO remove underscore dependency
+        return observable.unobserve(_.omit(this, observable.ignores));
+        // old_to_json()
+      }
+    });
   },
 
   // TODO improve readability

data/vendor/components/indefinido-observable/spec/legacy/observable_spec.js

@@ -0,0 +1,126 @@
+var $, observable, root;
+
+observable = require('observable').mixin;
+
+root = typeof exports !== "undefined" && exports !== null ? exports : window;
+
+$ = require('jquery');
+
+describe('observable #()', function() {
+  var object;
+
+  object = null;
+  beforeEach(function() {
+    return object = {
+      property: 'value'
+    };
+  });
+  it('should not have observed property', function() {
+    return expect(object.observed).toBeUndefined();
+  });
+  xit('should let element unsubscribe to property', function() {});
+  describe('#subscribe', function() {
+    var called;
+
+    called = null;
+    beforeEach(function() {
+      object = observable({});
+      called = false;
+      return true;
+    });
+    it('should subscribe to property', function() {
+      var spy;
+
+      spy = sinon.spy();
+      object.subscribe('other', spy);
+      object.other = 'mafagafo';
+      return expect(spy.called).toBe(true);
+    });
+    it('should let multiple function subscriptions to property', function() {
+      var also_also_called, also_called;
+
+      also_called = false;
+      also_also_called = false;
+      object.subscribe('other', function() {
+        return called = true;
+      });
+      object.subscribe('other', function() {
+        return also_called = true;
+      });
+      object.subscribe('other', function() {
+        return also_also_called = true;
+      });
+      object.other = 'mafagafo';
+      expect(called).toBe(true);
+      return expect(also_called).toBe(true);
+    });
+    it('should handle truth comparisons well', function() {
+      var block_called, spy;
+
+      spy = sinon.spy;
+      block_called = false;
+      object.invert = true;
+      object.truthy = true;
+      object.falsey = false;
+      object.subscribe('truthy', spy);
+      object.subscribe('falsey', spy);
+      object.subscribe('invert', spy);
+      block_called = false;
+      if (object.truthy) {
+        block_called = true;
+      }
+      expect(block_called).toBe(true);
+      block_called = false;
+      if (!object.falsey) {
+        block_called = true;
+      }
+      expect(block_called).toBe(true);
+      block_called = false;
+      if (object.invert) {
+        block_called = true;
+      }
+      object.invert = false;
+      block_called = false;
+      if (object.invert === false) {
+        block_called = true;
+      }
+      return expect(block_called).toBe(true);
+    });
+    describe('subscribes to properties of type array', function() {
+      it('should observe objects added to array', function() {
+        var friend, spy;
+
+        spy = sinon.spy();
+        friend = {
+          domo: 1
+        };
+        object.friends = [];
+        object.subscribe('friends', function() {});
+        object.friends = [friend];
+        friend = object.friends[0];
+        expect(friend.domo).toBeDefined();
+        expect(friend.observed).toBeDefined();
+        friend.subscribe('domo', spy);
+        friend.domo = 2;
+        return expect(spy.callCount).toBe(1);
+      });
+      it('should override native methods');
+      return it('should preserve array bindings when setting new array', function() {
+        var spy;
+
+        spy = sinon.spy();
+        object.friends = [];
+        object.subscribe('friends', spy);
+        object.friends.push(1);
+        object.friends = [];
+        object.friends.push(2);
+        expect(object.friends.length).toBe(1);
+        return expect(spy.callCount).toBe(3);
+      });
+    });
+    return it('should create a observed property', function() {});
+  });
+  return xdescribe('#publish', function() {
+    return xit('should let element publish to property', function() {});
+  });
+});

data/vendor/components/indefinido-observable/spec/observable_spec.js

@@ -0,0 +1,92 @@
+var observable, root;
+
+observable = require('observable').mixin;
+
+root = typeof exports !== "undefined" && exports !== null ? exports : window;
+
+describe('observable #()', function() {
+  var object;
+
+  if (!root.should) {
+    return;
+  }
+  object = null;
+  beforeEach(function() {
+    return object = {
+      property: 'value'
+    };
+  });
+  it('should not have observed property', function() {
+    return object.should.not.have.property('observed');
+  });
+  xit('should let element unsubscribe to property', function() {});
+  describe('#subscribe', function() {
+    var called;
+
+    called = null;
+    beforeEach(function() {
+      object = observable({});
+      called = false;
+      return true;
+    });
+    it('should subscribe to property', function() {
+      var spy;
+
+      spy = sinon.spy();
+      object.subscribe('other', spy);
+      object.other = 'mafagafo';
+      return spy.called.should.be["true"];
+    });
+    it('should let multiple function subscriptions to property', function() {
+      var also_called;
+
+      also_called = false;
+      object.subscribe('other', function() {
+        return called = true;
+      });
+      object.subscribe('other', function() {
+        return also_called = true;
+      });
+      object.other = 'mafagafo';
+      called.should.be["true"];
+      return also_called.should.be["true"];
+    });
+    describe('subscribes to properties of type array', function() {
+      it('should observe objects added to array', function() {
+        var friend, spy;
+
+        spy = sinon.spy();
+        friend = {
+          domo: 1
+        };
+        object.friends = [];
+        object.subscribe('friends', function() {});
+        object.friends = [friend];
+        object.friends[0].should.be.eq(friend);
+        friend.should.have.property('observed');
+        friend.subscribe('domo', spy);
+        friend.domo = 2;
+        return spy.callCount.should.be.eq(1);
+      });
+      xit('should override native methods');
+      return it('should preserve array bindings when setting new array', function() {
+        var spy;
+
+        spy = sinon.spy();
+        object.friends = [];
+        object.subscribe('friends', spy);
+        object.friends.push(1);
+        object.friends = [];
+        object.friends.push(2);
+        object.friends.length.should.be.eq(1);
+        return spy.callCount.should.be.eq(3);
+      });
+    });
+    return it('should create a observed property', function() {
+      return object.should.have.property('observed');
+    });
+  });
+  return xdescribe('#publish', function() {
+    return xit('should let element publish to property', function() {});
+  });
+});

data/vendor/components/indefinido-observable/spec/spec_helper.js

@@ -0,0 +1,8 @@
+var chai, root;
+
+root = typeof exports !== "undefined" && exports !== null ? exports : window;
+
+if (Object.prototype.defineProperty) {
+  chai = require('chaijs-chai');
+  root.should = chai.should();
+}

data/vendor/components/indefinido-observable/spec/vendor/accessors_spec.js

@@ -0,0 +1,63 @@
+var $;
+
+require('observable/vendor/shims/accessors.js');
+
+$ = require('jquery');
+
+describe('Object #defineProperty', function() {
+  describe('on dom elements', function() {
+    var object, spy;
+
+    spy = object = null;
+    beforeEach(function() {
+      object = document.createElement('domo');
+      document.body.appendChild(object);
+      return spy = sinon.spy();
+    });
+    it('should define property', function(done) {
+      return Object.defineProperty(object, 'kun', {});
+    });
+    it('should define property getter', function(done) {
+      var getter;
+
+      getter = sinon.stub().returns(42);
+      Object.defineProperty(object, 'kun', {
+        get: getter
+      });
+      expect(object.kun + 1).toBe(43);
+      return expect(getter.called).toBe(true);
+    });
+    return it('should define property setter', function(done) {
+      Object.defineProperty(object, 'kun', {
+        set: spy
+      });
+      object.kun = 10;
+      return expect(spy.calledWith(10)).toBe(true);
+    });
+  });
+  return describe('off dom elements', function() {
+    beforeEach(function() {
+      this.object = {};
+      return this.spy = sinon.spy();
+    });
+    it('should not define property setter', function(done) {
+      var _this = this;
+
+      return expect(function() {
+        return Object.defineProperty(_this.object, 'kun', {
+          set: _this.spy
+        });
+      }).toThrow();
+    });
+    return it('should define property getter', function(done) {
+      var getter;
+
+      getter = sinon.stub().returns(42);
+      Object.defineProperty(this.object, 'kun', {
+        get: getter
+      });
+      expect(this.object.kun + 1).toBe(43);
+      return expect(getter.called).toBe(true);
+    });
+  });
+});

data/vendor/components/indefinido-observable/src/lib/adapters/rivets.js.coffee

@@ -0,0 +1,15 @@
+exports.adapter =
+  subscribe: (record, attribute_path, callback) ->
+    throw new TypeError 'observable.adapters.rivets.subscribe: No record provided for subscription' unless record?
+    # TODO parse aura widget attributes options, remove, add as a
+    # comentary, and let rivets bindings flow, and remove the if check
+    record.subscribe attribute_path, callback if attribute_path
+  unsubscribe: (record, attribute_path, callback) ->
+    throw new TypeError 'observable.adapters.rivets.unsubscribe: No record provided for subscription' unless record?
+    record.unsubscribe attribute_path, callback
+  read: (record, attribute_path) ->
+    throw new TypeError 'observable.adapters.rivets.read: No record provided for subscription' unless record?
+    record[attribute_path]
+  publish: (record, attribute_path, value) ->
+    throw new TypeError 'observable.adapters.rivets.publish: No record provided for subscription' unless record?
+    record[attribute_path] = value

data/vendor/components/indefinido-observable/src/spec/legacy/observable_spec.coffee

@@ -0,0 +1,132 @@
+observable = require('observable').mixin
+root = exports ? window
+$ = require 'jquery'
+
+describe 'observable #()',  ->
+
+  object = null
+
+  beforeEach ->
+    object = property: 'value'
+
+  it 'should not have observed property', ->
+    expect(object.observed).toBeUndefined()
+
+  xit 'should let element unsubscribe to property', ->
+
+  describe '#subscribe', ->
+    called = null
+
+    beforeEach ->
+      object = observable({})
+      called = false
+      true
+
+    it 'should subscribe to property', ->
+      spy = sinon.spy()
+      object.subscribe 'other', spy
+      object.other = 'mafagafo'
+
+      expect(spy.called).toBe true
+
+
+    it 'should let multiple function subscriptions to property', ->
+      also_called = false
+      also_also_called = false
+
+      object.subscribe 'other', -> called = true
+
+      object.subscribe 'other', -> also_called = true
+
+      object.subscribe 'other', -> also_also_called = true
+
+      object.other = 'mafagafo'
+
+      expect(called).toBe true
+      expect(also_called).toBe true
+
+    it 'should handle truth comparisons well', ->
+      spy = sinon.spy
+      block_called  = false
+      object.invert = true
+      object.truthy = true
+      object.falsey  = false
+
+      object.subscribe 'truthy', spy
+      object.subscribe 'falsey' , spy
+      object.subscribe 'invert', spy
+
+      block_called = false
+      if object.truthy
+        # dump 'truthy'
+        block_called = true
+
+      expect(block_called).toBe true
+
+      block_called = false
+      # dump (object.falsey + '') == 'false'
+      unless object.falsey
+        # dump 'falsey'
+        block_called = true
+
+      expect(block_called).toBe true
+
+      block_called = false
+      if object.invert
+        # dump 'invert'
+        block_called = true
+
+      object.invert = false
+
+      block_called = false
+      if object.invert == false
+        # dump 'inverted'
+        block_called = true
+
+      expect(block_called).toBe true
+
+
+    describe 'subscribes to properties of type array', ->
+      it 'should observe objects added to array', ->
+        spy = sinon.spy()
+        friend = {domo: 1}
+
+        # TODO implement a one time setter to solve this
+        # Specifically on array types
+        # property must be an array before subscribing
+        object.friends = []
+
+        # Remember, you must subscribe to new properties to
+        # turn then into observable ones
+        object.subscribe 'friends', ->
+
+        object.friends = [friend]
+        friend = object.friends[0]
+
+        expect(friend.domo    ).toBeDefined()
+        expect(friend.observed).toBeDefined()
+
+        friend.subscribe 'domo', spy
+        friend.domo = 2
+        expect(spy.callCount).toBe 1
+
+      it 'should override native methods'
+
+      it 'should preserve array bindings when setting new array', ->
+        spy = sinon.spy()
+        object.friends = []
+        object.subscribe 'friends', spy
+
+        object.friends.push 1
+        object.friends = []
+        object.friends.push 2
+
+        expect(object.friends.length).toBe 1
+        expect(spy.callCount).toBe 3
+
+    it 'should create a observed property', ->
+#      object.should.have.property 'observed'
+
+  xdescribe '#publish', ->
+
+    xit 'should let element publish to property', ->