ende 0.4.5 → 0.4.6

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

@@ -0,0 +1,85 @@
+observable = require('observable').mixin
+root = exports ? window
+
+describe 'observable #()',  ->
+  return unless root.should
+
+  object = null
+
+  beforeEach ->
+    object = property: 'value'
+
+  it 'should not have observed property', ->
+    object.should.not.have.property 'observed'
+
+  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'
+      spy.called.should.be.true
+
+    it 'should let multiple function subscriptions to property', ->
+      also_called = false
+
+      object.subscribe 'other', -> called = true
+
+      object.subscribe 'other', -> also_called = true
+
+      object.other = 'mafagafo'
+      called.should.be.true
+      also_called.should.be.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]
+
+        object.friends[0].should.be.eq friend
+        friend.should.have.property 'observed'
+
+        friend.subscribe 'domo', spy
+        friend.domo = 2
+        spy.callCount.should.be.eq 1
+
+      xit '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
+
+        object.friends.length.should.be.eq 1
+        spy.callCount.should.be.eq 3
+
+
+    it 'should create a observed property', ->
+      object.should.have.property 'observed'
+
+  xdescribe '#publish', ->
+
+    xit 'should let element publish to property', ->

data/vendor/components/indefinido-observable/src/spec/spec_helper.coffee

@@ -0,0 +1,5 @@
+root = exports ? window
+
+if Object.prototype.defineProperty
+  chai = require 'chaijs-chai'
+  root.should = chai.should()

data/vendor/components/indefinido-observable/src/spec/vendor/accessors_spec.coffee

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

data/vendor/components/indefinido-observable/vendor/shims/accessors.js

@@ -70,7 +70,10 @@
           changed_value = object[property];
           descriptor.set.call(object, changed_value);
 
-          // Restore get function if it exists and there's no falsey value
+          // Restore get function if:
+          //  it was mentioned on definition
+          //  there's no falsey value, in that case we just need to return falsey value
+          //  current toString is not the getter, to prevent further unecessary redefinitions
           if (descriptor.get && descriptor.value && descriptor.value.toString != descriptor.bound_getter) {
             // TODO if (descriptor.get + '' === 'undefined') descriptor.get = '';        // Handle undefined getter
             descriptor.value.toString = descriptor.bound_getter
@@ -88,33 +91,37 @@
       }
 
       return setter;
-    }
+    };
 
     // Shim define property with apropriated fail cases exceptions
     Object.defineProperty = function (obj, prop, descriptor) {
       var fix;
 
-      if (!obj.attachEvent) throw new TypeError('Object.defineProperty: First parameter must be a dom element.');
+      if (!prop)
 
-      if (!fix && !inDocument(obj)) throw new TypeError('Object.defineProperty: Dom element must be attached in document.');
+      if (descriptor.set) {
+        if (!obj.attachEvent) throw new TypeError('Object.defineProperty: First parameter must be a dom element. When descriptor has \'set\' property.');
 
-      if (!descriptor) throw new TypeError('Object.defineProperty (object, property, descriptor): Descriptor must be an object, was \'' + descriptor + '\'.');
+        if (!fix && !inDocument(obj)) throw new TypeError('Object.defineProperty: Dom element must be attached in document.');
+      }
 
-      if ((descriptor.get || descriptor.set) && descriptor.value) throw new TypeError('Object.defineProperty: Descriptor must have only getters and setters or value.');
+      if (!descriptor) throw new TypeError('Object.defineProperty (object, property, descriptor): Descriptor must be an object, was \'' + descriptor + '\'.');
 
       // Store current value in descriptor
+      // TODO only try to set descriptor value if it was passed as parameter
       descriptor.value = descriptor.value || (descriptor.get && descriptor.get.call(obj)) || obj[prop];
 
-      if (descriptor.get || descriptor.set) {
+      if (descriptor.set) {
         // Detach old listeners if any
         detach = true;
         obj[prop] = 'detaching';
         detach = false;
 
         if (descriptor.get) {
+          // TODO remove jquery dependency
           descriptor.bound_getter   = $.extend($.proxy(descriptor.get, obj), descriptor.get);
 
-          // We only bind the getter when we have a non falsey value
+          // Why? we only bind the getter when we have a non falsey value
           if (descriptor.value) descriptor.value.toString = descriptor.bound_getter;
 
           // Although its not allowed for convention to have getters
@@ -125,6 +132,16 @@
 
         (fix || obj).attachEvent("onpropertychange", generate_setter(obj, prop, descriptor));
 
+      } else if (descriptor.get) {
+        descriptor.bound_getter   = $.extend($.proxy(descriptor.get, obj), descriptor.get);
+
+        // Why? we only bind the getter when we have a non falsey value
+        if (descriptor.value) descriptor.value.toString = descriptor.bound_getter;
+
+        // Although its not allowed for convention to have getters
+        // and setters with the descriptor value, here we just reuse
+        // the descriptor stored value
+        obj[prop] = descriptor.value;
       } else {
         obj[prop] = descriptor.value;
       }
@@ -146,7 +163,52 @@
         }
       }
     };
-  }
+
+    ObjectCreate = Object.create;
+    baseElement  = document.createElement('fix');
+
+    Object.create = function (prototype, properties) {
+      var complexDescriptor, fix, descriptor, name;
+
+      for (name in properties) {
+        descriptor = properties[name]
+        if (descriptor instanceof Object) {
+          complexDescriptor = !!(descriptor.get || descriptor.set)
+
+          if (complexDescriptor) {
+            break;
+          }
+        }
+      }
+
+      if (complexDescriptor || prototype.nodeName === 'fix' || properties && properties._shim) {
+        properties && delete properties._shim;
+
+        if (typeof object != 'function') {
+          fix = document.createElement('fix');
+          document.appendChild(fix);
+
+          // Copy over prototype properties
+          for (name in prototype) {
+            try {
+              if (name in baseElement) continue;
+              fix[name] = prototype[name];
+            } catch (e) {
+              console.warn("Object.create: Invalid shimmed property: " + name + ", with error " + e);
+            }
+          }
+
+          Object.defineProperties(fix, properties);
+        } else {
+          throw new TypeError('Functions with complex descriptors not implemented yet');
+        }
+        return fix;
+      } else {
+        return ObjectCreate(prototype, properties)
+      }
+    }
+  };
+
 
   /* TODO Use define Property, and only define if
      non-enumerable properties are allowed

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

@@ -0,0 +1,104 @@
+// Jasmine boot.js for browser runners - exposes external/global interface, builds the Jasmine environment and executes it.
+(function() {
+  var env = jasmine.getEnv();
+
+  var jasmineInterface = {
+    describe: function(description, specDefinitions) {
+      return env.describe(description, specDefinitions);
+    },
+
+    xdescribe: function(description, specDefinitions) {
+      return env.xdescribe(description, specDefinitions);
+    },
+
+    it: function(desc, func) {
+      return env.it(desc, func);
+    },
+
+    xit: function(desc, func) {
+      return env.xit(desc, func);
+    },
+
+    beforeEach: function(beforeEachFunction) {
+      return env.beforeEach(beforeEachFunction);
+    },
+
+    afterEach: function(afterEachFunction) {
+      return env.afterEach(afterEachFunction);
+    },
+
+    expect: function(actual) {
+      return env.expect(actual);
+    },
+
+    pending: function() {
+      return env.pending();
+    },
+
+    addMatchers: function(matchers) {
+      return env.addMatchers(matchers);
+    },
+
+    spyOn: function(obj, methodName) {
+      return env.spyOn(obj, methodName);
+    },
+
+    clock: env.clock,
+    setTimeout: env.clock.setTimeout,
+    clearTimeout: env.clock.clearTimeout,
+    setInterval: env.clock.setInterval,
+    clearInterval: env.clock.clearInterval,
+
+    jsApiReporter: new jasmine.JsApiReporter(jasmine)
+  };
+
+  if (typeof window == "undefined" && typeof exports == "object") {
+    extend(exports, jasmineInterface);
+  } else {
+    extend(window, jasmineInterface);
+  }
+
+  var queryString = new jasmine.QueryString({
+    getWindowLocation: function() { return window.location; }
+  });
+
+  // TODO: move all of catching to raise so we don't break our brains
+  var catchingExceptions = queryString.getParam("catch");
+  env.catchExceptions(typeof catchingExceptions === "undefined" ? true : catchingExceptions);
+
+  var htmlReporter = new jasmine.HtmlReporter({
+    env: env,
+    queryString: queryString,
+    onRaiseExceptionsClick: function() { queryString.setParam("catch", !env.catchingExceptions()); },
+    getContainer: function() { return document.body; },
+    createElement: function() { return document.createElement.apply(document, arguments); },
+    createTextNode: function() { return document.createTextNode.apply(document, arguments); }
+  });
+
+  env.addReporter(jasmineInterface.jsApiReporter);
+  env.addReporter(htmlReporter);
+
+  var specFilter = new jasmine.HtmlSpecFilter({
+    filterString: function() { return queryString.getParam("spec"); }
+  });
+
+  env.specFilter = function(spec) {
+    return specFilter.matches(spec.getFullName());
+  };
+
+  var currentWindowOnload = window.onload;
+
+  window.onload = function() {
+    if (currentWindowOnload) {
+      currentWindowOnload();
+    }
+    htmlReporter.initialize();
+    env.execute();
+  };
+
+  function extend(destination, source) {
+    for (var property in source) destination[property] = source[property];
+    return destination;
+  }
+
+}());