ende 0.1.14 → 0.2.0

data/vendor/components/indefinido-indemma/src/lib/record/validatable.coffee

@@ -0,0 +1,209 @@
+require './translationable'
+
+root       = exports ? window
+stampit    = require '../../vendor/stampit'
+observable = require('observable').mixin
+type       = require 'type'
+
+# TODO better model require
+# model = require ...
+
+# TODO Add base settings to validation
+# TODO implement method
+# model[resource].validators_on 'field' # Get all validators related to this field
+
+messages =
+  blank:  (attribute_name) ->
+    attribute_name = @human_attribute_name attribute_name
+    "O campo #{attribute_name} não pode ficar em branco."
+
+  cpf:  (attribute_name) ->
+    attribute_name = @human_attribute_name attribute_name
+    "O campo #{attribute_name} não está válido."
+
+  confirmation:  (attribute_name) ->
+    confirmation_attribute_name = @human_attribute_name attribute_name
+    attribute_name              = @human_attribute_name attribute_name.replace '_confirmation', ''
+    "O campo #{attribute_name} não está de acordo com o campo #{confirmation_attribute_name}."
+
+  associated:  (attribute_name) ->
+    attribute_name = @human_attribute_name attribute_name
+    "O registro associado #{attribute_name} não é válido."
+
+  server:  (attribute_name, options) ->
+    attribute_name = @human_attribute_name attribute_name
+    "#{attribute_name} #{options.server_message}."
+
+  type:  (attribute_name, options) ->
+    attribute_name = @human_attribute_name attribute_name
+    "O campo #{attribute_name} não está válido."
+
+# TODO move to errorsable.coffee
+errorsable = stampit
+  add: (attribute_name, message_key, options) ->
+
+    @push [attribute_name, message_key, options]
+    # TODO Also push to attribute named
+    # @[attribute_name].push message_key, message, options
+
+    @messages[attribute_name] = ''
+
+    translator = messages[message_key]
+
+    if translator?
+      @messages[attribute_name] += translator.call @model, attribute_name, options
+    else
+      @messages[attribute_name] += message_key
+
+  clear: ->
+    if @length
+      @length   = 0
+      @messages[attribute_name] = null for attribute_name of @messages
+
+  push: Array.prototype.push
+  splice: Array.prototype.splice
+,
+  model: null
+  messages: null
+  length: 0
+, ->
+  @messages = {}
+  @
+
+
+initializers =
+  define_triggers: ->
+
+    # TODO remove the extra inheritance level of model[@resource]
+    @errors = errorsable model: model[@resource]
+
+    # TODO only add after save when resourceable is included
+    # TODO @after_initialize validate_field_types
+    # TODO only execute save operation if record is valid
+    @before 'save', -> @validate() if @save
+
+    # TODO move this functionality control to validatorable
+    @validated = false
+    @subscribe 'dirty', -> @validated = false
+
+    Object.defineProperty @, 'valid',
+      get: ->
+
+        @validate()
+
+        if @validation.state() == 'resolved'
+          !@errors.length
+        else
+          null
+
+      set: -> throw new TypeError "You can't set the value for the valid property."
+      enumerable: false
+
+  create_validators: (definitions) ->
+
+    @validators = []
+
+    for name, validator of manager.validators
+      definition = definitions[validator.definition_key]
+
+      if definition
+        definition = [definition] unless type(definition) == 'array'
+
+        for validator_options in definition
+
+          # Parse validation definition
+          validator_options = attribute_name: validator_options unless type(validator_options) == 'object'
+          validator_options.model = @
+
+          # Instantiate validator
+          @validators.push validator validator_options
+
+          # Clear out definition to prevent validators from becoming
+          # attributes
+          delete definitions[validator.definition_key]
+
+# Model and Record extensions
+# TODO Use stampit!
+extensions =
+  model:
+    validators: null
+
+  record:
+
+    validate_attribute: (attribute, doned, failed) ->
+      # TODO better clearing of single attribute error message
+      @errors.messages[attribute] = null
+
+      results = [@, attribute]
+
+      # TODO copy validators reference from model object to record object
+      # TODO update json serializer
+      # TODO filter validators for attribute
+      for validator in model[@resource.toString()].validators
+        if validator.attribute_name is attribute
+          results.push validator.validate_each @, validator.attribute_name, @[validator.attribute_name]
+
+      validation = jQuery.when.apply jQuery, results
+      validation.done doned
+      validation.fail failed
+
+      validation
+
+    validate: (doned, failed) ->
+      return @validation if @validated
+
+      @errors.clear()
+      results  = [@]
+
+      # TODO copy validators reference from model object to record object
+      # TODO update json serializer
+      for validator in model[@resource.toString()].validators
+        results.push validator.validate_each @, validator.attribute_name, @[validator.attribute_name]
+
+      @validation = jQuery.when results...
+      @validation.done doned
+      @validation.fail failed
+
+      # TODO store this callback
+      @validation.then (record) -> record.validated = true
+
+      @validation
+
+
+# Validators management
+manager =
+
+  validators: {}
+
+  # TODO async validator loading
+  # for: (name) ->
+  #   builder = @validators[name] ||= require "validations/#{name}"
+
+
+validatable = 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'
+
+
+# TODO better stampit integration
+model.mix (modelable) ->
+  jQuery.extend modelable, extensions.model
+
+  jQuery.extend modelable.record, extensions.record
+
+  modelable.after_mix.unshift initializers.create_validators
+  modelable.record.after_initialize.push initializers.define_triggers
+
+  model.validators = manager.validators
+
+# Globalize definitions
+root.validatable = validatable
+root.manager     = manager
+
+# TODO async validator loading
+require './validations/confirmation'
+require './validations/associated'
+require './validations/presence'
+require './validations/remote'
+require './validations/type'
+require './validations/cpf'

data/vendor/components/indefinido-indemma/src/lib/record/validations/associated.coffee

@@ -0,0 +1,32 @@
+# 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'
+
+associationable = stampit
+  validate_each: (record, attribute, value) ->
+    # TODO figure out why this method is being called twice
+    if record[attribute]
+
+      # TODO detect association type, and then validate
+      # current we only support has_one associations
+      unless model[record.resource].has_one.indexOf(attribute) != -1
+        throw new Error 'Only has_one associations are supported to validates_associated'
+
+      associated_validation = record[attribute].validate()
+
+      associated_validation.done  ->
+        if record[attribute].errors.length
+          record.errors.add attribute, 'associated', @options
+
+      associated_validation
+
+
+composed = stampit.compose(validations.validatable, associationable)
+composed.definition_key = 'validates_associated'
+
+validations.manager.validators.association = composed

data/vendor/components/indefinido-indemma/src/lib/record/validations/confirmation.coffee

@@ -0,0 +1,19 @@
+# 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'
+
+confirmationable = stampit
+  validate_each: (record, attribute, value) ->
+    if record[attribute] != record["#{attribute}_confirmation"]
+      record.errors.add "#{attribute}_confirmation", 'confirmation', @options
+
+
+composed = stampit.compose(validations.validatable, confirmationable)
+composed.definition_key = 'validates_confirmation_of'
+
+validations.manager.validators.confirmation = composed

data/vendor/components/indefinido-indemma/src/lib/record/validations/cpf.coffee

@@ -0,0 +1,58 @@
+# 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'
+
+cpfable = stampit
+  validate_format: (value) ->
+    value = value.replace /[\.\-]/g, ""
+
+    # Wrong cpf size
+    return false if value.length < 11
+
+    # Dummy but valid values (000.000.000-00, 111.111.111-11, ...)
+    return false if value.match /^(0+|1+|2+|3+|4+|5+|6+|7+|8+|9+)$/
+
+    # Mod 11 validation
+    c  = value.substr 0, 9
+    dv = value.substr 9, 2
+    d1 = 0
+    v  = false
+    i  = 0
+
+    for i in [1..9]
+      d1 += c.charAt(i) * (10 - i)
+
+    return false if d1 == 0
+
+    d1 = 11 - (d1 % 11)
+    d1 = 0 if (d1 > 9 )
+
+    return false if +dv.charAt 0 != d1
+
+    d1 *= 2
+    for i in [1..9]
+      d1 += c.charAt(i) * (11 - i)
+
+
+    d1 = 11 - (d1 % 11)
+    d1 = 0 if (d1 > 9 )
+
+    return false if +dv.charAt(1) != d1
+
+    true
+
+
+  validate_each: (record, attribute, value) ->
+    record.errors.add attribute, 'cpf', @options if value and not @validate_format value
+
+
+
+
+composed = stampit.compose validations.validatable, cpfable
+composed.definition_key = 'validates_cpf_format'
+validations.manager.validators.cpf = composed

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

@@ -0,0 +1,19 @@
+# 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'
+
+presenceable = stampit
+  validate_each: (record, attribute, value) ->
+    if value == null or value == '' or value == undefined
+      record.errors.add attribute, 'blank', @options
+
+
+composed = stampit.compose(validations.validatable, presenceable)
+composed.definition_key = 'validates_presence_of'
+
+validations.manager.validators.presence = composed

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

@@ -0,0 +1,65 @@
+# TODO Add base settings to validation
+# model = window.model
+
+  # TODO implement method
+# model[resource].validators_on 'field' # Get all validators related to this field
+
+root  = exports ? window
+
+validations = require '../validatable'
+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(validations.validatable, remoteable)
+composed.definition_key = 'validates_remotely'
+
+validations.manager.validators.remote = composed

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

@@ -0,0 +1,32 @@
+# 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(validations.validatable, typeable)
+composed.definition_key = 'validates_type_of'
+
+validations.manager.validators.type = composed

data/vendor/components/indefinido-indemma/src/lib/record.coffee

@@ -0,0 +1,123 @@
+$          = require 'jquery'
+type       = require 'type'
+bind       = require 'bind'
+observable = require('observable').mixin
+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: []
+    all: ->
+      # 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)
+    instance = record.call extend Object.create(data), @record, after_initialize: after_initialize # TODO remove @record from outside scope
+
+    # Call and remove used callbacks
+    callback.call instance, instance for callback in instance.after_initialize
+    delete instance.after_initialize
+
+    instance
+
+
+  # Create model
+  mixer = (options) ->
+    throw 'Model mixin called incorrectly call with model.call {} instead of model({})' 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 = []
+
+    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
+
+
+    callback.call instance, instance for callback in modelable.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/vendor/components/indefinido-indemma/src/spec/record/associable_spec.coffee

@@ -0,0 +1,63 @@
+root = exports ? window
+
+require 'indemma/lib/record/associable'
+
+describe 'record',  ->
+  record = root.record
+
+  it 'should create a record'
+
+describe 'model',  ->
+  model  = root.model
+  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'
+
+  describe 'belongs_to', ->
+
+    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 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', ->
+          association.should.have.property 'all'
+          association.should.have.property 'each'
+          association.should.have.property 'reload'
+
+        describe '#all', ->
+
+          it 'should auto observe nested associations attributes'

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

@@ -0,0 +1,64 @@
+require 'indemma/lib/record/restfulable'
+require 'indemma/lib/record/resource'
+
+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()
+      deferred.resolveWith towel(name: 'Arthur'), [_id: 1]
+      sinon.stub(jQuery, "ajax").returns(deferred)
+      promises = towel.create {name: 'Arthur'}, {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'