ende 0.5.20 → 0.5.21

data/components/indefinido/indemma/master/src/lib/record/validations/presence.coffee

@@ -0,0 +1,16 @@
+# TODO Add base settings to validation
+# model = window.model
+
+# TODO implement method
+# model[resource].validators_on 'field' # Get all validators related to this field
+
+stampit     = require '../../../vendor/stampit'
+
+presenceable = stampit
+  validate_each: (record, attribute, value) ->
+    if value == null or value == '' or value == undefined
+      record.errors.add attribute, 'blank', @options
+
+composed = stampit.compose require('./validatorable'), presenceable
+composed.definition_key = 'validates_presence_of'
+module.exports = composed

data/components/indefinido/indemma/master/src/lib/record/validations/remote.coffee

@@ -0,0 +1,61 @@
+# TODO Add base settings to validation
+# model = window.model
+
+# TODO implement method
+# model[resource].validators_on 'field' # Get all validators related to this field
+
+rest        = require '../rest'
+stampit     = require '../../../vendor/stampit'
+
+remoteable = stampit
+  validate_each: (record, attribute, value) ->
+    data = @json record
+
+    # TODO best partial application
+    # @post(data).done(_.partial @succeeded, record)
+    @post(data).done((json) => @succeeded(json, record))
+
+  json: (record) ->
+    param = @resource.param_name || @resource.toString()
+
+    data = {}
+    data[param] = record.json()
+
+    # TODO stop renaming id field, lol
+    data[param].id ||= data[param]._id
+    delete data[param]._id
+
+    data
+
+  # TODO Use rest.post
+  post: (data) ->
+
+    jQuery.ajax
+      url     : @route
+      data    : data
+      type    : 'post'
+      dataType: 'json'
+      context : @
+
+  succeeded: (json, record) ->
+    error_messages = json[@attribute_name]
+
+    return unless error_messages
+
+    for error_message in error_messages
+      record.errors.add @attribute_name, 'server', server_message: error_message
+,
+  message: "Remote validation failed"
+  route: null
+, ->
+  # TODO discover why @model.route is coming null!
+  # Desglobalize model constant
+  pluralized_resource  = model.pluralize @model.resource.toString()
+  @resource            = @model.resource
+  @route             ||= "/#{pluralized_resource}/validate"
+  @
+
+
+composed = stampit.compose require('./validatorable'), remoteable
+composed.definition_key = 'validates_remotely'
+module.exports = composed

data/components/indefinido/indemma/master/src/lib/record/validations/type.coffee

@@ -0,0 +1,31 @@
+# TODO Add base settings to validation
+# model = window.model
+
+# TODO implement method
+# model[resource].validators_on 'field' # Get all validators related to this field
+
+validations = require '../validatable'
+stampit     = require '../../../vendor/stampit'
+
+typeable = stampit
+  validate_each: (record, attribute, value) ->
+    # TODO store type on validator instantiation
+    @type ||= model[record.resource.toString()][attribute]
+
+    if value
+
+      if value instanceof @type
+
+        # TODO store type_name on costructor
+        @type_name ||= @type.name
+
+        unless value.valid # Will trigger validation
+          record.errors.add attribute, 'type', type_name: @type_name?
+
+      else
+        throw new Error "Invalid attribute value type! Found #{typeof value} expected #{@type.name}"
+
+
+composed = stampit.compose require('./validatorable'), typeable
+composed.definition_key = 'validates_type_of'
+module.exports = composed

data/components/indefinido/indemma/master/src/lib/record/validations/validatorable.coffee

@@ -0,0 +1,5 @@
+stampit     = require '../../../vendor/stampit'
+
+module.exports = stampit
+  validate: -> throw new Error 'Composed factory must override the validate method'
+  validate_each: -> throw new Error 'Composed factory must override the validate each method'

data/components/indefinido/indemma/master/src/lib/record.coffee

@@ -0,0 +1,143 @@
+$          = require 'jquery'
+type       = require 'type'
+bind       = require 'bind'
+observable = require 'observable'
+advisable  = require('advisable' ).mixin
+extend     = require 'assimilate'
+merge      = require('assimilate').withStrategy 'deep'
+
+# TODO support other type of associations
+@model = do -> # mixin
+  modelable =
+    after_mix: []
+    record:
+      # TODO usar deferred
+      after_initialize: []
+      # TODO usar deferred
+      before_initialize: []
+    every: ->
+      # TODO transform model in a array like object and store cache in root
+      @cache
+    # TODO better find support
+    create: (params...) ->
+      # Implementat non restful model creation
+      throw 'model.create not implemented yet, try using the restful.model.create method'
+#    find: (id) ->
+#      @where id: id, true
+    where: (conditions, first = false) ->
+      results = []
+      conditions.id = [conditions.id] if type(conditions.id) != 'array'
+      # TODO transform model in a array like object and store cache in root
+      for record in @cache when conditions.id.indexOf(record._id) isnt -1
+        if first
+          return record
+        else
+          results.push record
+
+      if first then null else results
+
+  initialize_record = (data = {resource: @resource, parent_resource: @parent_resource}) ->
+    data.resource          ||= @resource
+    data.parent_resource   ||= @resource.parent || @parent_resource
+    data.route             ||= @route
+    data.nested_attributes   = @nested_attributes || []
+
+    # instance = record.call extend data, @record # TODO remove @record from outside scop
+    after_initialize = (data.after_initialize || []).concat(@record.after_initialize)
+
+    # TODO only shim in older browsers
+    # TODO try to remove _shim need
+    creation = extend Object.create(data, {_shim: {}}), @record, creation, after_initialize: after_initialize
+
+    # TODO use deferred instead of before_initialize array
+    for callback, index in @record.before_initialize
+      callback.call @, creation
+
+    instance = record.call creation # TODO remove @record from outside scope
+
+
+    # Call and remove used callbacks
+    # TODO use deferred instead of after_initialize array
+    for callback, index in instance.after_initialize
+      callback.call instance, instance
+
+    delete instance.after_initialize
+
+    instance
+
+
+  # Create model
+  mixer = (options) ->
+    throw 'Model mixin called incorrectly! \n Call with model.call({}) instead of model({}) \n Also the first argument must be non null.' if @ == window
+    mixer.stale = true unless mixer.stale # Prevent model changes
+
+    # TODO Use stampit and solve this mess!!
+    if @record and @record.after_initialize
+      after_initialize = @record.after_initialize.splice 0
+    else
+      after_initialize = []
+
+    # TODO Use stampit and solve this mess!!
+    if @after_mix
+      after_mix = @after_mix.splice 0
+    else
+      after_mix = []
+
+    instance = bind @, initialize_record
+
+    extend instance, merge @, modelable
+
+    @record =  instance.record  = merge {}, instance.record, modelable.record
+    @record.after_initialize    = instance.record.after_initialize = instance.record.after_initialize.concat after_initialize
+
+    @record.before_initialize   = instance.record.before_initialize.concat []
+
+    callback.call instance, instance for callback in modelable.after_mix.concat after_mix
+
+    # Store model for later use
+    # TODO implement correctly stampit usage, and remove the need for
+    # direct storage
+    mixer[@resource.name || @resource.toString()] = instance
+
+  mixer.mix = (blender) ->
+    throw "Trying to change model mixin with #{object} but model already used.\nCheck your configuration order" if @stale
+
+    blender modelable
+
+  # window.model
+  mixer
+
+@record = do -> # mixin
+
+  callbacks =
+    # TODO search for a existing word and rename method, 'smudge' perhaps?
+    dirtify: ->
+# TODO add suport to subscribe to any property
+#      @subscribe (prop, value, old) ->
+#        if prop isnt 'dirty' and not @dirty and value isnt old
+#          console.groupCollapsed "◉ Property '#{prop}' dirtied a #{@resource}"
+#          console.log old, "→", value
+#          console.log @
+#          console.groupEnd()
+#          @dirty = true
+
+  recordable =
+    # TODO usar deferred
+    dirty: false
+    after_initialize: [ callbacks.dirtify ]
+
+  that = (data) ->
+    throw "Mixin called incorrectly, call mixin with call method: record.call(object, data)" if @ == window
+
+    data ||= {}
+    after_initialize  = (@after_initialize || []).concat(data.after_initialize || []).concat(recordable.after_initialize)
+    advisable observable(extend(@, recordable, data, after_initialize: after_initialize))
+
+
+  that.mix = (blender) ->
+    blender recordable
+
+  that
+
+exports.record = @record
+exports.model  = @model

data/components/indefinido/indemma/master/src/spec/record/associable_spec.coffee

@@ -0,0 +1,205 @@
+root = exports ? window
+
+require 'indemma/lib/record/associable.js'
+$ = require 'jquery'
+
+describe 'record',  ->
+  record = root.record
+
+  it 'should create a record'
+
+describe 'model',  ->
+  model  = root.model
+  arthur = radio       = null
+  person = corporation = null
+
+  beforeEach ->
+    corporation = model.call
+      resource: 'corporation'
+
+    # TODO implement support for self referential associations
+    friend = model.call
+      resource: 'friends'
+
+
+    person = model.call
+      resource  : 'person'
+      has_many  : 'friends'
+      belongs_to: 'corporation'
+
+    radio = corporation
+      _id: 1
+      name: 'Local Radio'
+
+    ford = friend
+      _id: 2
+      name: 'Ford Perfect'
+
+    @arthur = arthur = person
+      _id: 3
+      name: 'Arthur Philip Dent'
+
+  describe 'has_one', ->
+    it 'should add a has_one property with the associations descriptions', ->
+      $.type(person.has_one).should.be.eq 'array'
+
+
+  describe 'belongs_to', ->
+    it 'should add a belongs_to property with the associations descriptions', ->
+      $.type(person.belongs_to).should.be.eq 'array'
+
+    describe "{associated}_id", ->
+      xdescribe 'with autobuild option on the asssociation', ->
+        xit 'should return an partial resource when acessing associated', ->
+          @arthur.corporation_id = radio._id
+
+          @arthur.should.have.property 'corporation'
+          @arthur.corporation.should.be.object
+          @arthur.corporation.should.have.property 'resource'
+          @arthur.corporation.should.have.property '_id', radio._id
+
+      xit 'should fetch the resource when accessing associated and resource not present', (done) ->
+        radio = corporation
+          _id: 1
+          name: 'Local Radio'
+
+        @arthur.corporation_id = radio._id
+
+        @arthur.corporation.should.be.object
+        @arthur.corporation.should.have.property 'resource', radio.resource
+        @arthur.corporation._id.should.be null
+        @arthur.corporation.locking.should.be.object
+
+        @arthur.corporation.locking.done (corporation) ->
+          corporation.should.have.property '_id' , radio.id
+          corporation.should.have.property 'name', radio.name
+
+      it 'should notify changes', ->
+        radio      = corporation _id: 1, name: 'Local Radio'
+        subscribed_id = sinon.spy()
+        subscribed = sinon.spy()
+
+        @arthur.subscribe 'corporation_id', subscribed_id
+        @arthur.subscribe 'corporation'   , subscribed
+        @arthur.corporation_id = radio._id
+        @arthur.observation.deliver()
+
+        @arthur.corporation_id = null
+        @arthur.observation.deliver()
+
+        # Tests
+        subscribed.called.should.be.true
+        subscribed.callCount.should.be.eq 2
+        subscribed_id.called.should.be.true
+        subscribed_id.callCount.should.be.eq 2
+
+
+      it 'should remove {associated} when nulifying', ->
+        radio      = corporation _id: 1, name: 'Local Radio'
+        subscribed = sinon.spy()
+
+        # Associate arthur with a corporation through id
+        @arthur.subscribe 'corporation_id', subscribed
+        @arthur.corporation_id = radio._id
+        @arthur.observation.deliver()
+
+        # Unassociate arthur with a corporation through id
+        @arthur.corporation_id = null
+        @arthur.observation.deliver()
+
+        subscribed.called.should.be.true
+        subscribed.callCount.should.be.eq 2
+        @arthur.should.have.property 'corporation_id', null
+        @arthur.should.have.property 'corporation'   , null
+
+
+    describe "{associated}", ->
+
+      describe 'with autoload option on the association', ->
+
+        it 'should create associated when sustained and stored', ->
+          radio.sustained.should.be.true
+          @arthur.corporation_id = radio._id
+          @arthur.should.have.property 'corporation', radio
+
+
+      it 'should update {associated_id} and record when associated record changes', ->
+        radio = corporation
+          _id: 1
+          name: 'Local Radio'
+          sustained: true
+
+        expect(@arthur.corporation).to.be.null
+
+        @arthur.corporation = radio
+
+        @arthur.corporation_id
+        @arthur.should.have.property 'corporation'   , radio
+        @arthur.should.have.property 'corporation_id', radio._id
+
+        @arthur.corporation = null
+        @arthur.observation.deliver()
+
+        @arthur.should.have.property 'corporation'   , null
+        @arthur.should.have.property 'corporation_id', null
+
+      it 'should notify changes', ->
+        radio         = corporation _id: 1, name: 'Local Radio'
+        subscribed    = sinon.spy()
+        subscribed_id = sinon.spy()
+
+        @arthur.subscribe 'corporation'   , subscribed
+        @arthur.subscribe 'corporation_id', subscribed_id
+        @arthur.corporation = radio
+        @arthur.observation.deliver()
+
+        @arthur.corporation = null
+        @arthur.observation.deliver()
+
+        # Tests
+        subscribed.called.should.be.true
+        subscribed.callCount.should.be.eq 2
+
+        subscribed_id.called.should.be.true
+        subscribed_id.callCount.should.be.eq 2
+
+    describe "#build_{associated}", ->
+      it 'should add builded object to association named attribute', ->
+        @arthur = person
+          name: 'Arthur Dent'
+
+        corporation = @arthur.build_corporation()
+        @arthur.should.have.property 'corporation'
+        expect(corporation).to.be.ok
+
+  describe 'has_many', ->
+    it 'should add a has_many property with the associations descriptions', ->
+      $.type(person.has_many).should.be.eq 'array'
+
+    it 'should return a record factory with associations stored', ->
+      person.has_many.should.be.array
+
+      has_many = Array.prototype.splice.call person.has_many, 0
+
+      has_many.should.contain 'friends'
+
+    describe '#()', ->
+
+      it 'should return a record with an association object', ->
+        person().should.have.property 'friends'
+
+      describe '{generated_association}', ->
+        association = null
+
+        beforeEach -> association = person().friends
+
+        it 'should have query methods', ->
+          # THINK Why has many check is here
+          # association.should.have.property 'has_many'
+          association.should.have.property 'find'
+          association.should.have.property 'each'
+          association.should.have.property 'reload'
+
+        describe '#every', ->
+
+          it 'should auto observe nested associations attributes'

data/components/indefinido/indemma/master/src/spec/record/dirtyable_spec.coffee

@@ -0,0 +1,47 @@
+require 'indemma/lib/record/restfulable.js'
+require 'indemma/lib/record/dirtyable.js'
+
+'use strict'
+
+root = exports ? window
+
+model  = root.model  # TODO model = require 'indemma/model'
+record = root.record # TODO model = require 'indemma/record'
+jQuery = require 'component-jquery'
+
+describe 'dirtyable', ->
+
+  describe 'when included', ->
+    it 'sets te dirtyable loaded flag on model', ->
+      model.dirtyable.should.be.true
+
+  describe 'record',  ->
+    # TODO Convert to @arthur
+    describe '()',  ->
+
+      beforeEach ->
+        # TODO Convert to @arthur
+        @person = model.call resource: 'person'
+        @arthur = @person    name    : 'Arthur Philip Dent'
+
+      describe '.dirty', ->
+        it 'should exist after initialization', ->
+          @arthur.should.have.property 'dirty'
+
+        it 'should be true on record changes', ->
+          @arthur.name = 10
+
+          # Force instantaneous delivery
+          @arthur.observation.deliver()
+
+          @arthur.dirty.should.be.true
+
+      describe '.saved()', ->
+        beforeEach -> sinon.stub(jQuery, "ajax").returns(jQuery.Deferred())
+        afterEach  -> jQuery.ajax.restore()
+
+        it 'should clean record after', ->
+
+
+  describe 'model' ,  ->
+    describe '()', ->

data/components/indefinido/indemma/master/src/spec/record/maid_spec.coffee

@@ -0,0 +1,34 @@
+'use strict'
+
+maid = require 'indemma/lib/record/maid.js'
+
+describe 'maid', ->
+
+  beforeEach ->
+    @personable = model.call
+      resource: 'person'
+      washing: true
+  
+  it 'should save upon record dirtying', (done) ->
+    @arthur = @personable name: 'Arthur Dent'
+    
+    sinon.stub(@arthur, 'save').returns true
+    @arthur.name = 'Arthur Philip Dent'
+    
+    setTimeout =>
+      @arthur.save.called.should.be.true
+      done()
+    , 1000
+
+
+  it 'should not save upon record creation', (done) ->
+    @timeout 10000
+    sinon.stub(jQuery, "ajax").returns(jQuery.Deferred())
+    @arthur = @personable name: 'Arthur Dent'
+
+    setTimeout =>
+      jQuery.ajax.called.should.be.false
+      jQuery.ajax.restore()
+      done()
+    , 2000
+    

data/components/indefinido/indemma/master/src/spec/record/persistable_spec.coffee

@@ -0,0 +1,39 @@
+root = exports ? window
+
+require 'indemma/lib/record/persistable.js'
+
+describe 'persistable',  ->
+
+  describe 'model', ->
+    it 'should set the persistable key', ->
+      model.should.have.property 'persistable', true
+
+    describe '#find', ->
+      beforeEach ->
+        @xhr = jQuery.Deferred()
+        sinon.stub(jQuery, "ajax").returns @xhr
+
+        @personable = model.call
+          resource  : 'person'
+          has_many  : 'friends'
+          belongs_to: 'corporation'
+
+        @arthur = @personable
+          name: 'Arthur Philip Dent'
+
+        @xhr.resolveWith @arthur, [_id: 1]
+
+        # TODO use another way to check if record has persisted
+        @arthur.dirty = true
+
+      afterEach  -> jQuery.ajax.restore()
+
+      it 'should try to store a record after saving when initialzed without id', (done) ->
+        sinon.stub(@personable.storage, 'store').returns true
+
+        @arthur.save =>
+          expect(@personable.storage.store.calledOnce).to.be.true
+          done()
+
+        @personable.storage.store.restore()
+

data/components/indefinido/indemma/master/src/spec/record/queryable_spec.coffee

@@ -0,0 +1,33 @@
+root = exports ? window
+
+queryable = require 'indemma/lib/record/queryable.js'
+
+describe 'queryable',  ->
+
+  describe 'model', ->
+    beforeEach ->
+      @personable = model.call
+        resource  : 'person'
+
+    it 'should set the queryable key', ->
+      model.should.have.property 'queryable', true
+
+    it 'should create a storage', ->
+      @personable.should.have.property 'storage'
+
+    describe '#find', ->
+      beforeEach ->
+        @xhr = jQuery.Deferred()
+        sinon.stub(jQuery, "ajax").returns @xhr
+
+        @arthur = @personable
+          _id: '1'
+          name: 'Arthur Philip Dent'
+
+        @arthur.save()
+        @xhr.resolveWith @arthur, [@arthur.json()]
+
+      afterEach  -> jQuery.ajax.restore()
+
+      it 'should retrieve a record by key', ->
+        @personable.find('1').should.have.property 'name', @arthur.name

data/components/indefinido/indemma/master/src/spec/record/resource_spec.coffee

@@ -0,0 +1,69 @@
+require 'indemma/lib/record/restfulable.js'
+require 'indemma/lib/record/resource.js'
+
+root = exports ? window
+
+model  = root.model  # TODO model = require 'indemma/model'
+record = root.record # TODO model = require 'indemma/record'
+jQuery = require 'component-jquery'
+
+describe 'resource', ->
+
+  describe 'with scope option', ->
+    person = towel = null
+
+    beforeEach ->
+      person   = model.call
+        resource: 'person'
+
+      towel    = model.call
+        resource:
+          name: 'towel'
+          scope: 'users'
+
+
+    it 'should be prefixed with scope', ->
+      towel.       route.should.be.eq '/users/towels'
+      towel( { } ).route.should.be.eq '/users/towels'
+      towel(id: 1).route.should.be.eq '/users/towels'
+
+
+  describe 'with singular resource', ->
+    towel = null
+
+    beforeEach ->
+      towel   = model.call
+        resource:
+          name: 'towel'
+          singular: true
+
+      deferred = jQuery.Deferred()
+
+      context = towel(name: 'Arthur Philip Dent')
+      context.lock = JSON.stringify context.json()
+      deferred.resolveWith context, [_id: 1, name: 'Arthur Philip Dent']
+
+      sinon.stub(jQuery, "ajax").returns(deferred)
+
+      promises = towel.create {name: 'Arthur Philip Dent'}, {name: 'Ford'}
+
+    afterEach  -> jQuery.ajax.restore()
+
+    it 'the route should be in singular form', ->
+      towel.       route.should.be.eq '/towel'
+      towel( { } ).route.should.be.eq '/towel'
+      towel(id: 1).route.should.be.eq '/towel'
+
+
+  describe 'when included', ->
+    xit 'sets the resource loaded flag on model', ->
+      # model.resource.should.be.true
+
+  describe 'model' ,  ->
+    it 'add methods to model object'
+
+    describe '#pluralize', ->
+      xit 'transforms word into plural form'
+
+    describe '#singularize', ->
+      xit 'transforms word into singular form'