ende 0.5.20 → 0.5.21

data/components/indefinido/indemma/master/src/spec/record/validations/associated_spec.coffee

@@ -0,0 +1,35 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable.js'
+
+describe 'model ( validates_associated: ... )',  ->
+
+  describe 'basic usage', ->
+    model  = root.model
+    person = address = null
+
+    beforeEach ->
+      address = model.call
+        resource : 'address'
+        street   : String
+        validates_presence_of: 'street'
+
+      person = model.call
+        resource : 'person'
+        has_one  : 'address'
+        validates_associated: 'address'
+
+    afterEach ->
+      person.validators.length  = 0
+      address.validators.length = 0
+
+    describe '.validate()', ->
+
+      it 'should add error to record when fields does not match', ->
+        arthur = person {}
+        arthur.build_address street: null
+
+        arthur.valid
+
+        arthur.errors.messages.should.have.deep.property 'address', 'O registro associado address não é válido.'
+        arthur.address.errors.messages.should.have.deep.property 'street', 'O campo street não pode ficar em branco.'

data/components/indefinido/indemma/master/src/spec/record/validations/confirmation_spec.coffee

@@ -0,0 +1,25 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable.js'
+
+describe 'model #() validates_confirmation_of',  ->
+
+  describe 'basic usage', ->
+    model  = root.model
+    person = null
+
+    beforeEach ->
+      person = model.call
+        resource : 'person'
+        password : String
+        validates_confirmation_of: 'password'
+
+    afterEach ->
+      person.validators.length = 0
+
+    describe '#validate', ->
+
+      it 'should add error to record when fields does not match', ->
+        arthur = person password: "domo", password_confirmation: "kun"
+        arthur.valid
+        arthur.errors.messages.should.have.deep.property 'password_confirmation', 'O campo password não está de acordo com o campo password_confirmation.'

data/components/indefinido/indemma/master/src/spec/record/validations/cpf_spec.coffee

@@ -0,0 +1,27 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable.js'
+
+describe 'model #() validates_cpf_format',  ->
+
+  describe 'basic usage', ->
+    model  = root.model
+
+    beforeEach ->
+      @person = model.call
+        resource : 'person'
+        cpf      : String
+        validates_cpf_format: 'cpf'
+
+    afterEach ->
+      # Clear validators from resource
+      @person.validators.length = 0
+
+    describe '#validate', ->
+
+      it 'should add error to record when fields is in invalid format', ->
+        arthur = @person cpf: '871.95FRANGO-00'
+        arthur.valid
+
+        # TODO figure out why the heck the validators aren't being reset
+        arthur.errors.messages.should.have.deep.property 'cpf', "O campo cpf não está válido."

data/components/indefinido/indemma/master/src/spec/record/validations/presence_spec.coffee

@@ -0,0 +1,24 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable.js'
+
+describe 'model #() validates presence of',  ->
+
+  describe 'basic usage', ->
+    model  = root.model
+    person = null
+
+    beforeEach ->
+      person = model.call
+        resource  : 'person'
+        name      : String
+        belongs_to: 'corporation'
+        validates_presence_of: 'name'
+
+    afterEach ->
+      person.validators.length = 0
+
+    describe '#validate', ->
+
+      it 'should add error to record when required field is empty (null, undefined or \'\')'
+

data/components/indefinido/indemma/master/src/spec/record/validations/remote_spec.coffee

@@ -0,0 +1,74 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable.js'
+
+describe 'model #() validates_remotely',  ->
+  model   = root.model
+  request = arthur  = person = null
+
+  describe 'basic usage', ->
+
+    beforeEach ->
+      person = model.call
+        resource  : 'person'
+        name      : String
+        validates_remotely: 'name'
+
+      arthur = person name: "Arthur Dent"
+
+    afterEach ->
+      person?.validators.length = 0
+
+    describe '#validate', ->
+
+      beforeEach ->
+        request = jQuery.Deferred()
+        sinon.stub(jQuery, "ajax").returns(request)
+
+      afterEach  -> jQuery.ajax.restore()
+
+      it 'should send paramenters accordingly', ->
+        arthur.validate()
+
+        jQuery.ajax.called.should.be.true
+
+        jQuery.ajax.calledWithMatch(
+          url: '/people/validate'
+          type: 'post'
+          data:
+            person:
+              name: 'Arthur Dent'
+        ).should.be.true
+
+
+      it 'should add errors to record when request responds with errors', ->
+        arthur.validate()
+        request.resolveWith arthur,
+          [name: ['The name should be Marvin!', 'The name should be in lowercase!']]
+
+        arthur.errors.length.should.be.eq 2
+        arthur.errors.messages.name.should.exist
+
+  describe 'with options usage', ->
+
+    beforeEach ->
+      person?.validators.length = 0
+
+      person = model.call
+        resource  : 'person'
+        name      : String
+        validates_remotely: 'name'
+
+      arthur = person name: "Arthur Dent"
+
+    describe '#validate', ->
+
+      beforeEach ->
+        request = jQuery.Deferred()
+        sinon.stub(jQuery, "ajax").returns(request)
+
+      afterEach  -> jQuery.ajax.restore()
+
+      it 'should make ajax call', ->
+        arthur.validate()
+        jQuery.ajax.called.should.be.true

data/components/indefinido/indemma/master/src/spec/record/validations/type_spec.coffee

@@ -0,0 +1,33 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable.js'
+
+describe 'model #() validates type of',  ->
+
+  describe 'basic usage', ->
+    model  = root.model
+    person = null
+
+    beforeEach ->
+      person = model.call
+        resource  : 'person'
+        name      : String
+        phone     : Phone
+        validates_type_of: ['name', 'phone']
+
+    afterEach ->
+      person.validators.length = 0
+
+    describe '#validate', ->
+
+      #it 'should use Phone#valid getter to find out if object is valid'
+      it 'should use Phone#validate to find out if attribute is valid'
+      it 'should add error to record when phone typed attribute has an non valid phone value', ->
+        arthur = person phone: new Phone 'batata'
+        arthur.valid.should.be.false
+        arthur.errors.messages.should.have.property 'phone'
+        expect(arthur.errors.messages.phone).to.match /não está válido/
+
+      it 'should throw error to when phone typed attribute has an non phone value', ->
+        arthur = person phone: 'batata'
+        expect( -> arthur.valid).to.throw /invalid attribute value type/i

data/components/indefinido/indemma/master/src/spec/record_spec.coffee

@@ -0,0 +1,29 @@
+root = exports ? window
+
+describe 'record',  ->
+  record = root.record
+
+  it 'should create a record', ->
+    arthur = record.call resource: 'person'
+    arthur.should.be.object
+
+describe 'model',  ->
+  model = root.model
+
+  describe '#()', ->
+
+    xit 'should throw exception if no resource is passed'
+
+    it 'should create a resource factory', ->
+      person = model.call resource: 'person'
+      person.should.be.object
+
+      john = person()
+      john.should.be.object
+      john.resource.should.have.property 'name', 'person'
+
+    it 'should execute after mix callbacks', (done) ->
+
+      person = model.call
+        resource: 'person'
+        after_mix: [-> done()]

data/components/indefinido/indemma/master/src/spec/spec_helper.coffee

@@ -0,0 +1,11 @@
+root = exports ? window
+
+root.indemma = require 'indemma'
+root.sinon   = require 'indemma/vendor/spec/sinon.js'
+
+chai    = require 'chaijs-chai'
+root.expect = chai.expect
+root.should = chai.should()
+
+jQuery = require "component~jquery@1.0.0"
+

data/components/indefinido/indemma/master/src/spec/support/value_objects/phone.coffee

@@ -0,0 +1,30 @@
+# TODO locales support
+class @Phone
+
+  constructor: (@area_code, @number) ->
+    {@area_code, @number} = @area_code if typeof @area_code == 'object'
+
+
+    # TODO parse argument types to validate value object domain
+    # constraints
+
+    unless @number
+      @number    = @area_code
+      @area_code = null
+
+    Object.defineProperty @, 'valid', get: @validate
+
+  # TODO move type validation to indemma files
+  validate: -> @area_code? && @number?
+
+  toString: ->
+    formatted_number = @number.substr(0, 4) + '-' + @number.substr(4) if @number?
+
+    if @area_code?
+      "(#{@area_code}) #{formatted_number}"
+    else
+      formatted_number
+
+  toJSON: ->
+    area_code: @area_code
+    number: @number

data/components/indefinido/indemma/master/vendor/object/mixin.js

@@ -0,0 +1,196 @@
+/*jslint browser: true, forin: true, plusplus: true, indent: 4 */
+(function(Object, mixin) {
+    "use strict"; // happy linter ^_____^
+
+    /* <droppable> interesting code after line 110, here
+     * ad-hoc polyfill section for this purpose only
+     * never use these functions outside this closure ... like ...
+ne*/var
+
+        // borrowed methods for unknown Objects
+        ObjectPrototype = Object.prototype,
+
+        lookupGetter = ObjectPrototype.__lookupGetter__,
+        lookupSetter = ObjectPrototype.__lookupSetter__,
+        defineGetter = ObjectPrototype.__defineGetter__,
+        defineSetter = ObjectPrototype.__defineSetter__,
+        has          = ObjectPrototype.hasOwnProperty,
+
+        emptyArray   = [],
+        // slice        = emptyArray.slice,
+
+        // for IE < 9 and non IE5 yet browsers
+        goNative = true,
+        defineProperty = (function(defineProperty){
+          try{
+            return defineProperty && defineProperty({},'_',{value:1})._ && defineProperty;
+          } catch(IE8) {
+            goNative = false;
+          }
+        }(Object.defineProperty)) ||
+        function (o, k, d) {
+            var
+                get = d.get, // has.call(d, 'get') would be better but
+                set = d.set; // ES5 is just like this
+            if (get && defineGetter) {
+                defineGetter.call(o, k, get);
+            }
+            if (set && defineSetter) {
+                defineSetter.call(o, k, set);
+            }
+            if (!(get || set)) {
+                o[k] = d.value;
+            }
+        },
+        // for IE < 9 and non IE5 yet browsers
+        getOwnPropertyNames = (goNative && Object.getOwnPropertyNames) ||
+        (function () {
+            var
+                addHiddenOwnProperties = function (result) {
+                    return result;
+                },
+                list = [],
+                key,
+                i,
+                length;
+
+            for (key in {valueOf: key}) {
+                list.push(key);
+            }
+
+            if (!list.length) {
+                length = list.push(
+                    'constructor',
+                    'hasOwnProperty',
+                    'isPrototypeOf',
+                    'propertyIsEnumerable',
+                    'toLocaleString',
+                    'toString',
+                    'valueOf'
+                ) - 1;
+                addHiddenOwnProperties = function (result, o) {
+                    for (i = 0; i < length; i++) {
+                        key = list[i];
+                        if (has.call(o, key)) {
+                            result.push(key);
+                        }
+                    }
+                    return result;
+                };
+            }
+
+            return function (o) {
+                var
+                    result = [],
+                    key;
+                for (key in o) {
+                    if (has.call(o, key)) {
+                        result.push(key);
+                    }
+                }
+                return addHiddenOwnProperties(result, o);
+            };
+        }()),
+        // IE < 9 or other non ES5 yet browsers
+        getOwnPropertyDescriptor = (goNative && Object.getOwnPropertyDescriptor) ||
+        function (o, k) {
+            var
+                descriptor = {
+                    enumerable: true,
+                    configurable: true
+                },
+                get = lookupGetter && lookupGetter.call(o, k),
+                set = lookupSetter && lookupSetter.call(o, k);
+            if (get) {
+                descriptor.get = get;
+            }
+            if (set) {
+                descriptor.set = set;
+            }
+            if (!(get || set)) {
+                descriptor.writable = true;
+                descriptor.value = o[k];
+            }
+            return descriptor;
+        };
+    // </droppable>
+
+    // if already defined get out of here
+    // this should be 
+    // if (mixin in Object) return;
+    // but for some reason I went for JSLint ... 
+    if (Object[mixin]) {
+        return;
+    }
+    // same descriptor as other spec'd methods
+    defineProperty(
+        Object,
+        mixin,
+        {
+            enumerable: false,
+            writable: true,
+            configurable: true,
+            value: function (
+                target, // object to enrich with
+                source, // mixin object or Trait (Function)
+                args    // optional arguments for Trait
+            ) {
+                var
+                    i,
+                    length,
+                    keys,
+                    key;
+
+                if (typeof source === 'function') {
+                    // if the source is a function
+                    // it will be invoked with object as target
+                    // this let us define mixin as closures
+                    // function addFunctionality() {
+                    //     this.functionality = function () {
+                    //       // do amazing stuff
+                    //     }
+                    // }
+                    // addFunctionality.call(Class.prototype);
+                    // addFunctionality.call(genericObject);
+                    // // or
+                    // Object.mixin(Class.prototype, addFunctionality);
+
+                    source.apply(target, args || emptyArray);
+                    /*
+                    // try to perform as fast as possible
+                    if (arguments.length < 3) {
+                        // so if no extra args are passed ...
+                        source.call(target);
+                    } else {
+                        // there is no need to slice them as done here
+                        source.apply(target, slice.call(arguments, 2));
+                    }
+                    */
+                } else {
+                    // if source is an object
+                    // grab all possibe properties
+                    // and per each of them ...
+                    keys = getOwnPropertyNames(source);
+                    length = keys.length;
+                    i = 0;
+                    while (i < length) {
+                        key = keys[i++];
+                        // ... define it ...
+                        defineProperty(
+                            target,
+                            key,
+                            // ... using the same descriptor
+                            getOwnPropertyDescriptor(
+                                source,
+                                key
+                            )
+                        );
+                    }
+                }
+                // always return the initial target
+                // ignoring all possible different return with functions
+                return target;
+            }
+        }
+    );
+}(Object, 'mixin'));

data/components/indefinido/indemma/master/vendor/spec/sinon/assert.js

@@ -0,0 +1,199 @@
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ */
+/*jslint eqeqeq: false, onevar: false, nomen: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Assertions matching the test spy retrieval interface.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+"use strict";
+
+(function (sinon, global) {
+    var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
+    var slice = Array.prototype.slice;
+    var assert;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function verifyIsStub() {
+        var method;
+
+        for (var i = 0, l = arguments.length; i < l; ++i) {
+            method = arguments[i];
+
+            if (!method) {
+                assert.fail("fake is not a spy");
+            }
+
+            if (typeof method != "function") {
+                assert.fail(method + " is not a function");
+            }
+
+            if (typeof method.getCall != "function") {
+                assert.fail(method + " is not stubbed");
+            }
+        }
+    }
+
+    function failAssertion(object, msg) {
+        object = object || global;
+        var failMethod = object.fail || assert.fail;
+        failMethod.call(object, msg);
+    }
+
+    function mirrorPropAsAssertion(name, method, message) {
+        if (arguments.length == 2) {
+            message = method;
+            method = name;
+        }
+
+        assert[name] = function (fake) {
+            verifyIsStub(fake);
+
+            var args = slice.call(arguments, 1);
+            var failed = false;
+
+            if (typeof method == "function") {
+                failed = !method(fake);
+            } else {
+                failed = typeof fake[method] == "function" ?
+                    !fake[method].apply(fake, args) : !fake[method];
+            }
+
+            if (failed) {
+                failAssertion(this, fake.printf.apply(fake, [message].concat(args)));
+            } else {
+                assert.pass(name);
+            }
+        };
+    }
+
+    function exposedName(prefix, prop) {
+        return !prefix || /^fail/.test(prop) ? prop :
+            prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);
+    }
+
+    assert = {
+        failException: "AssertError",
+
+        fail: function fail(message) {
+            var error = new Error(message);
+            error.name = this.failException || assert.failException;
+
+            throw error;
+        },
+
+        pass: function pass(assertion) {},
+
+        callOrder: function assertCallOrder() {
+            verifyIsStub.apply(null, arguments);
+            var expected = "", actual = "";
+
+            if (!sinon.calledInOrder(arguments)) {
+                try {
+                    expected = [].join.call(arguments, ", ");
+                    var calls = slice.call(arguments);
+                    var i = calls.length;
+                    while (i) {
+                        if (!calls[--i].called) {
+                            calls.splice(i, 1);
+                        }
+                    }
+                    actual = sinon.orderByFirstCall(calls).join(", ");
+                } catch (e) {
+                    // If this fails, we'll just fall back to the blank string
+                }
+
+                failAssertion(this, "expected " + expected + " to be " +
+                              "called in order but were called as " + actual);
+            } else {
+                assert.pass("callOrder");
+            }
+        },
+
+        callCount: function assertCallCount(method, count) {
+            verifyIsStub(method);
+
+            if (method.callCount != count) {
+                var msg = "expected %n to be called " + sinon.timesInWords(count) +
+                    " but was called %c%C";
+                failAssertion(this, method.printf(msg));
+            } else {
+                assert.pass("callCount");
+            }
+        },
+
+        expose: function expose(target, options) {
+            if (!target) {
+                throw new TypeError("target is null or undefined");
+            }
+
+            var o = options || {};
+            var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix;
+            var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail;
+
+            for (var method in this) {
+                if (method != "export" && (includeFail || !/^(fail)/.test(method))) {
+                    target[exposedName(prefix, method)] = this[method];
+                }
+            }
+
+            return target;
+        },
+
+        match: function match(actual, expectation) {
+            var matcher = sinon.match(expectation);
+            if (matcher.test(actual)) {
+                assert.pass("match");
+            } else {
+                var formatted = [
+                    "expected value to match",
+                    "    expected = " + sinon.format(expectation),
+                    "    actual = " + sinon.format(actual)
+                ]
+                failAssertion(this, formatted.join("\n"));
+            }
+        }
+    };
+
+    mirrorPropAsAssertion("called", "expected %n to have been called at least once but was never called");
+    mirrorPropAsAssertion("notCalled", function (spy) { return !spy.called; },
+                          "expected %n to not have been called but was called %c%C");
+    mirrorPropAsAssertion("calledOnce", "expected %n to be called once but was called %c%C");
+    mirrorPropAsAssertion("calledTwice", "expected %n to be called twice but was called %c%C");
+    mirrorPropAsAssertion("calledThrice", "expected %n to be called thrice but was called %c%C");
+    mirrorPropAsAssertion("calledOn", "expected %n to be called with %1 as this but was called with %t");
+    mirrorPropAsAssertion("alwaysCalledOn", "expected %n to always be called with %1 as this but was called with %t");
+    mirrorPropAsAssertion("calledWithNew", "expected %n to be called with new");
+    mirrorPropAsAssertion("alwaysCalledWithNew", "expected %n to always be called with new");
+    mirrorPropAsAssertion("calledWith", "expected %n to be called with arguments %*%C");
+    mirrorPropAsAssertion("calledWithMatch", "expected %n to be called with match %*%C");
+    mirrorPropAsAssertion("alwaysCalledWith", "expected %n to always be called with arguments %*%C");
+    mirrorPropAsAssertion("alwaysCalledWithMatch", "expected %n to always be called with match %*%C");
+    mirrorPropAsAssertion("calledWithExactly", "expected %n to be called with exact arguments %*%C");
+    mirrorPropAsAssertion("alwaysCalledWithExactly", "expected %n to always be called with exact arguments %*%C");
+    mirrorPropAsAssertion("neverCalledWith", "expected %n to never be called with arguments %*%C");
+    mirrorPropAsAssertion("neverCalledWithMatch", "expected %n to never be called with match %*%C");
+    mirrorPropAsAssertion("threw", "%n did not throw exception%C");
+    mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C");
+
+    sinon.assert = assert;
+
+    if (typeof define === "function" && define.amd) {
+        define(["module"], function(module) { module.exports = assert; });
+    } else if (commonJSModule) {
+        module.exports = assert;
+    }
+}(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : (typeof self != "undefined") ? self : global));