ende 0.2.9 → 0.2.10

data/vendor/components/indefinido-indemma/src/spec/record/storable_spec.coffee

@@ -0,0 +1,40 @@
+root = exports ? window
+
+storable = require 'indemma/lib/record/storable'
+
+describe 'storable',  ->
+  it 'should set the storable key', ->
+    model.should.have.property 'storable', true
+
+  beforeEach ->
+    @storage = storable()
+
+  describe "#store", ->
+
+    describe "write", ->
+      it "should write object on deep storage"
+      # storage.store 'users.1', data
+
+      it "should write object on storage", ->
+        data = name: 'Arthur Dent'
+        @storage.store '1', data
+        @storage.writes.should.be.eq 1
+        @storage.database['1'].should.be.eq data
+
+      it "should mark an object as sustained",  ->
+        data = name: 'Arthur Dent'
+        @storage.store '1', data
+        data.should.have.property 'sustained', true
+
+
+    describe "read", ->
+      data = null
+
+      beforeEach ->
+        data = name: 'Arthur Dent'
+        @storage.store '1', data
+
+      it "should save object on storage", ->
+        @storage.store('1').should.be.eq data
+
+      it "should unmark an object as sustained"

data/vendor/components/indefinido-indemma/src/spec/record/translationable.coffee

@@ -0,0 +1,19 @@
+root = exports ? window
+
+require 'indemma/lib/record/translationable'
+
+describe 'model',  ->
+  model  = root.model
+  person = null
+
+  beforeEach ->
+    person = model.call
+      resource  : 'person'
+      name: String
+      translation:
+        attributes:
+          name: 'Batata'
+
+  describe '#human_attribute_name', ->
+    it 'should return the translated attribute name', ->
+      person.human_attribute_name('name').should.be.eq 'Batata'

data/vendor/components/indefinido-indemma/src/spec/record/validatable_spec.coffee

@@ -0,0 +1,100 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable'
+
+describe 'model',  ->
+  model  = root.model
+  person = corporation = null
+
+  beforeEach ->
+    person = model.call resource  : 'person'
+
+  it 'should store validators', ->
+    person.should.have.property 'validators'
+    person.validators.should.be.an 'array'
+
+  describe '#()', ->
+
+    describe 'validators instatiation',  ->
+
+      it 'should instantiate validators with prefix validates_', ->
+        person = model.call
+          resource  : 'person'
+          name      : String
+          validates_presence_of: 'name'
+
+        person.validators.should.not.be.empty
+        validator = person.validators[0]
+        validator.should.have.property 'attribute_name', 'name'
+
+      it 'should instantiate validators with in the key validates'
+        #person = model.call
+        #  resource  : 'person'
+        #  name      : String
+        #  validates : {name: {presence: true} }
+
+        #person.validators.should.have.key 'name'
+
+    describe '#validate_attribute', ->
+
+      beforeEach ->
+        # TODO implement better model redefinition pattern
+        person.validators.length = 0
+
+        person = model.call
+          resource  : 'person'
+          name      : String
+          validates_presence_of: 'name'
+
+      it 'should add error messages for the validated attribute', ->
+        arthur = person name: null
+
+        arthur.validate_attribute 'name'
+
+        arthur.errors.length.should.be.eq 1
+        arthur.errors.messages.should.have.property 'name'
+
+    describe '.valid', ->
+      person = null
+
+      beforeEach ->
+        # TODO implement better model redefinition pattern
+        person.validators.length = 0
+
+        person = model.call
+          resource  : 'person'
+          name      : String
+          validates_presence_of: 'name'
+
+      # TODO more specific .valid test functionality
+      it 'should be true when valid', ->
+        arthur = person name: "Arthur"
+
+        arthur.should.have.property 'valid'
+        arthur.valid.should.be.true
+        arthur.errors.length.should.be.eq 0
+
+
+      it 'should exist as read only property', ->
+        arthur = person name: "Arthur"
+        expect(-> arthur.valid = false).to.throw Error
+
+      it 'should validate record', ->
+        anonymous = person name: null
+        anonymous.valid.should.be.false
+        anonymous.errors.length.should.be.eq 1
+
+      it 'should not validate record util it changes', ->
+        anonymous = person name: null
+
+        anonymous.valid.should.be.false
+        anonymous.errors.length.should.be.eq 1
+
+        validation = anonymous.validation
+        # We expect it to not instanitante new validation deferred
+        anonymous.validate().should.be.eq validation
+
+        # Record for some reason changed
+        anonymous.dirty = true
+        # We expect it to instanitante new validation deferred
+        anonymous.validate().should.not.be.eq validation

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

@@ -0,0 +1,35 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable'
+
+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/vendor/components/indefinido-indemma/src/spec/record/validations/confirmation_spec.coffee

@@ -0,0 +1,25 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable'
+
+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/vendor/components/indefinido-indemma/src/spec/record/validations/cpf_spec.coffee

@@ -0,0 +1,28 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable'
+
+describe 'model #() validates_cpf_format',  ->
+
+  describe 'basic usage', ->
+    model  = root.model
+    person = null
+
+    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.943.417-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/vendor/components/indefinido-indemma/src/spec/record/validations/presence_spec.coffee

@@ -0,0 +1,24 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable'
+
+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/vendor/components/indefinido-indemma/src/spec/record/validations/remote_spec.coffee

@@ -0,0 +1,74 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable'
+
+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/vendor/components/indefinido-indemma/src/spec/record/validations/type_spec.coffee

@@ -0,0 +1,33 @@
+root = exports ? window
+
+require 'indemma/lib/record/validatable'
+
+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/vendor/components/indefinido-indemma/src/spec/record_spec.coffee

@@ -0,0 +1,23 @@
+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 record factory', ->
+      person = model.call resource: 'person'
+      person.should.be.object
+
+      john = person()
+      john.should.be.object
+      john.resource.should.have.property 'name', 'person'

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

@@ -0,0 +1,9 @@
+root = exports ? window
+
+indemma = require 'indemma'
+chai    = require 'chaijs-chai'
+
+# sinon is included on karma.conf.js
+
+root.expect = chai.expect
+root.should = chai.should()

data/vendor/components/indefinido-indemma/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/vendor/components/indefinido-indemma/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'));