ende 0.5.20 → 0.5.21

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

@@ -0,0 +1,279 @@
+require './restfulable'
+require './resource'
+
+stampit    = require '../../vendor/stampit'
+extend     = require 'assimilate'
+observable = require('observable').mixin
+merge      = extend.withStrategy 'deep'
+$          = require 'jquery'
+rest       = require './rest'
+
+# TODO merge all with fetch and remove this util object
+util =
+  model:
+    map: (records) ->
+      return record if @build
+      @.call @, record for record, index in records
+
+# TODO better responsibilty division for this code
+scopable =
+  builder: stampit().enclose ->
+
+    # Builds a given scope
+    # {param} name Scope name also, the name of method used to invoke it
+    # {param} type Default value for scope, or base class to derive default for default type
+
+    stampit.mixIn (name, type) ->
+      if $.type(type) == 'function'
+        @["$#{name}"] = type() || new type
+        type          = $.type @["$#{name}"]
+      else
+        @["$#{name}"] = defaults[type] || type
+
+      type    = $.type type if $.type(type) != 'string' or type.toString() == ''
+      builder = builders[type]
+
+      throw "Unknown scope type: '#{type}', For model with resource: '#{@resource}'" unless builder?
+
+      @scope.declared.push name
+      @[name] = builder name: name
+    ,
+      data:     {}
+      then:     []
+      fail:     []
+      declared: []
+      fetch: (data, done, fail) ->
+
+        if typeof data == 'function'
+          done = data
+          data = {}
+
+        # Copy current scope data for request
+        # TODO think in a better way to only copy scope data for the request
+        scope = extend {}, @scope.data
+        delete scope[method] for method of observable.methods
+
+
+        if scope.noned?
+          deferred = $.Deferred()
+          deferred.resolveWith @, [[]]
+        else
+          deferred = rest.get.call(@, extend scope, data)
+
+        deferred
+          .then(util.model.map)
+          .done(@scope.then.concat [done])
+          .fail(@scope.fail.concat [fail])
+
+        @scope.clear()
+
+        deferred
+
+      clear: ->
+        @data      = {}
+        @callbacks = []
+
+  # Shared scope stuff
+  base: stampit().state
+    name: 'unamed_scope'
+
+  record:
+    # Parse error json if any
+    failed: (xhr, error, status) ->
+      payload       = xhr.responseJSON
+      try payload ||= JSON.parse(xhr.responseText) catch e
+      payload     ||= xhr.responseText
+
+      # When client fail
+      switch xhr.status
+        when 422
+          @valid = false
+          return @errors = payload.errors
+        # Unknown fail
+        else
+          message  = "Fail in #{@resource}.save:\n"
+          message += "Record: #{@}\n"
+          message += "Status: #{status} (#{payload.status || xhr.status})\n"
+          message += "Error : #{payload.error || payload.message || payload}"
+
+      console.error message
+  model:
+    # TODO implement getter for none property!
+    none: ->
+      @scope.data.noned = true
+      @
+
+    # TODO merge with all object
+    fetch: (data, done, fail) ->
+      if typeof data == 'function'
+        done = data
+        data = null
+
+      @scope.fetch.call @, data, done, fail
+
+    # TODO optmize this iterations or add support for stampit on associable and merge factories
+    # TODO rename this method to forward extensions to association, and store extensions on has_many definitions
+    # @ = record instance
+    forward_scopes_to_associations: ->
+      factory = model[@resource.name]
+
+      for association_name in factory.has_many
+        associated_resource = model.singularize association_name
+        associated_factory  = model[associated_resource]
+
+        # TODO change this warn message into a exception when
+        # associations are renamable
+        unless model[associated_resource]
+          console.warn("Associated factory not found for associated resource: #{associated_resource}")
+          continue
+
+        association         = @[association_name]
+        association.scope   = scopable.builder association
+
+        for scope in associated_factory.scope.declared
+          association.scope scope, associated_factory["$#{scope}"]
+
+      true
+  # @ = model instance
+  after_mix: ->
+    @scope = scopable.builder @
+
+    for property, type of @
+      if property.charAt(0) == '$'
+        name = property.substring 1
+        @scope name, type
+
+builders =
+  # Builds a string scope builder
+  string: stampit().enclose ->
+    base = scopable.base @
+
+    stampit.mixIn (value, callbacks...) ->
+      callbacks.length and @scope.then = @scope.then.concat callbacks
+      @scope.data[base.name] ||= value ? @["$#{base.name}"]
+      @
+
+  # Builds a boolean scope builder
+  boolean: stampit().enclose ->
+    base = scopable.base @
+
+    stampit.mixIn (value, callbacks...) ->
+      callbacks.length and @scope.then = @scope.then.concat callbacks
+      @scope.data[base.name] ||= value ? @["$#{base.name}"]
+      @
+
+  # Builds a array scope builder
+  array: stampit().enclose ->
+    base = scopable.base @
+
+    stampit.mixIn (values...) ->
+      @scope.data[base.name] ||= values ? @["$#{base.name}"]
+      @
+
+defaults =
+  boolean: true
+  array: []
+
+# Extend indemma
+model  = window.model     # TODO better way to get parent
+record = window.record     # TODO better way to get parent
+
+model.scopable = true
+
+# TODO use stampit to extend record and model
+#record.mix (recordable) ->
+#  merge recordable, scopable.record
+
+model.mix (modelable) ->
+  merge modelable, scopable.model
+
+  modelable.after_mix.push scopable.after_mix
+
+
+# TODO create a deferred to better mix models
+if model.associable
+  model.mix (modelable) ->
+    modelable.record.after_initialize.push ->
+      scopable.model.forward_scopes_to_associations.call @
+
+  model.associable.mix (singular_association,  plural_association) ->
+
+    # reload (done callbacks...)
+    plural_association.every = plural_association.reload = (data, done, fail) ->
+      # TODO move route discovery to plural_association.after_mix
+      @route ||= "#{@parent.route}/#{@parent._id}/#{model.pluralize @resource}" if @parent?
+      promises = []
+
+      # TODO better calculate fetch settings
+      # dirty    = 0
+      # if more than 5 records are dirty, we reftech all
+      #    if dirty < 5
+      #      for record in @
+      #        promises.push record.reload()
+      # else we reload everthing!
+      #    else
+      #
+      # for record in @
+      #   dirty++ if record.dirty
+
+      if typeof data == 'function'
+        done = data
+        data = undefined
+
+      promises.push @scope.fetch.call @, data, null, scopable.record.failed
+
+      reload = $.when.apply jQuery, promises
+
+      # Update association with data sent from the server
+      # TODO implement setter on this association and let user to set
+      reload.done (records, status) ->
+
+        # if no records were found by the server on this association
+        unless records.length
+          # Clear current stored cache on this association
+          # it to an empty array
+          Array.prototype.splice.call @, 0 if @length
+
+          return true
+
+
+        singular_resource = model.singularize @resource
+
+        # Normalize json data for building on association
+        for record in records
+
+          # TODO only nest specified nested attributes on model definition
+          # TODO create special deserialization method no plural association
+          # TODO check if we need to nest attributes in other association tipes
+          for association_name in model[singular_resource].has_many
+            record["#{association_name}_attributes"] = record[association_name]
+            delete record[association_name]
+
+        # Update found records
+        # TODO create update method
+        create = []
+        for record, index in records
+          if target = @find record._id
+            target.assign_attributes record
+          else
+            create.push record
+
+        # Load new records on this association
+        @add.apply @, create
+
+        # Override the response records object with added to association records
+        records.splice 0
+        records.push.apply records, @
+
+
+      reload.done done
+      reload.fail fail
+
+      reload
+
+    plural_association.each = (callback) ->
+      @route ||= "#{@parent.route}/#{@parent._id}/#{model.pluralize @resource}" if @parent?
+
+      # TODO cache models
+      @get().done (records) =>
+        callback record for record in @

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

@@ -0,0 +1,49 @@
+extend  = require 'assimilate'
+merge   = extend.withStrategy 'deep'
+stampit = require '../../vendor/stampit'
+
+# TODO use this as an external component or shim
+Object.values ||= _?.values || (object) -> value for key, value of object
+
+storable = stampit
+  store: (keypath, value, options) ->
+    collection = @database
+    keypath = keypath.toString().split '.'
+    key     = keypath.pop()
+
+    for entry in keypath
+      collection[entry] ||= {}
+      collection = collection[entry]
+
+    if arguments.length == 1
+      @reads++
+      collection[key]
+    else
+      @writes++
+
+      # TODO use object.defineProperty
+      value.sustained ||= true
+      collection[key] = value
+
+  values: ->
+    Object.values @database
+  ,
+    type: 'object'
+    writes: 0
+    reads: 0
+  , ->
+    @database ||= {}
+    @
+
+
+# Extend indemma
+# TODO use stampit to extend record and model
+model  = window.model     # TODO better way to get parent
+record = window.record     # TODO better way to get parent
+
+model.storable = true
+module.exports = storable
+#model.mix (modelable) ->
+#  merge modelable, storable.model
+
+

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

@@ -0,0 +1,18 @@
+root       = exports ? window
+
+# TODO better way to get core model definition
+# model = require ...
+
+# TODO implement method
+# model[resource].validators_on 'field' # Get all validators related to this field
+
+extend      = require('assimilate')
+
+extensions =
+  model:
+    human_attribute_name: (attribute_name) ->
+      @translation?.attributes?[attribute_name] or attribute_name
+
+model.mix (modelable) ->
+  extend modelable, extensions.model
+

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

@@ -0,0 +1,241 @@
+require './translationable'
+
+root       = exports ? @
+stampit    = require '../../vendor/stampit'
+observable = require 'observable'
+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
+
+# TODO use http://validatejs.org for internal handling
+
+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) ->
+    # TODO Better checking of base attribute case, better yet remove
+    # checking from here, just like active record
+    if attribute_name == 'base'
+      options.server_message
+    else
+      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
+  indexOf: Array.prototype.indexOf
+,
+  model: null
+  messages: null
+  length: 0
+, ->
+  @messages = {}
+  @
+
+
+initializers =
+  # TODO move ignored properties to the record
+  ignores: ['dirty', 'resource', 'route', 'initial_route', 'after_initialize', 'before_initialize', 'parent_resource', 'nested_attributes', 'reloading', 'ready', 'saving', 'salvation', 'sustained', 'element', 'default', 'lock', 'validated', 'validation', 'errors', 'dirty']
+  reserved_filter: (name) -> @ignores.indexOf(name) == -1
+
+  define_triggers: ->
+
+    # TODO remove the extra inheritance level of model[@resource]
+    @errors = errorsable model: model[@resource]
+
+    # TODO only add before 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 validatable
+    @validated  = false
+    @validation = null
+    # TODO subscribe and unsubscribe depending on validation state
+    @subscribe (added, removed, changed) ->
+      # When any property is added, removed or changed, we consider
+      # that the record has been modified
+      modified = !!Object.keys($.extend added, removed, changed).filter(initializers.reserved_filter, initializers).length
+
+      # To enable the future validations of this record, mark it as
+      # not validated, since it has changed
+      modified and @validated = false
+
+    Object.defineProperty @, 'valid',
+      get: ->
+        # To prevent multiple consecutive remote validations, if the
+        # record has not changed since last validation call, we
+        # schedule a validation
+        if @validation?.state() == 'pending'
+          @validation.done -> @valid if @dirty or !@validated
+          return null
+
+        @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
+
+    # The observable package reads the valid property when it's added
+    # to the model, causing it to validate unwatedly. So we need to
+    # stub some calls to prevent validation to
+    # TODO make deliver(true) really ignore the change records,
+    # better yet make it ignore only add records for valid property
+    original_validate = @validate
+    @validate = ->
+    @validation = $.Deferred()
+    @observation.deliver true
+    @validation = null
+    @validate = original_validate
+
+  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.done (record) -> record.validated ||= true
+
+# Validators management
+manager =
+
+  validators: {}
+
+  # TODO async validator loading
+  # for: (name) ->
+  #   builder = @validators[name] ||= require "validations/#{name}"
+
+
+# TODO better stampit integration
+model.mix (modelable) ->
+
+  # TODO discover why component builder is including this file
+  # multiple times and remove this check
+  return if modelable.record.validate
+
+  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
+
+# TODO async validator loading
+manager.validators.confirmation = require './validations/confirmation'
+manager.validators.associated   = require './validations/associated'
+manager.validators.presence     = require './validations/presence'
+manager.validators.remote       = require './validations/remote'
+manager.validators.type         = require './validations/type'
+manager.validators.cpf          = require './validations/cpf'

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

@@ -0,0 +1,34 @@
+# 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'
+
+associationable = stampit
+  validate_each: (record, attribute, value) ->
+    associated = record[attribute]
+
+    # TODO figure out why this method is being called twice
+    if associated
+
+      # TODO detect association type, and then validate
+      # current we only support has_one associations
+      # TODO better way to getting access to the global 'model' definition
+      unless model[record.resource].has_one.indexOf(attribute) != -1
+        throw new Error 'Only has_one associations are supported to validates_associated'
+
+      associated_validation = associated.validate()
+
+      # To have a complete view in parent record of associated errors,
+      # forward the messages to record
+      associated_validation.done  ->
+        record.errors.add attribute, 'associated', @options if associated.errors.length
+
+      associated_validation
+
+
+composed = stampit.compose(require('./validatorable'), associationable)
+composed.definition_key = 'validates_associated'
+module.exports = composed

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

@@ -0,0 +1,17 @@
+# 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'
+
+confirmationable = stampit
+  validate_each: (record, attribute, value) ->
+    if record[attribute] != record["#{attribute}_confirmation"]
+      record.errors.add "#{attribute}_confirmation", 'confirmation', @options
+
+
+composed = stampit.compose require('./validatorable'), confirmationable
+composed.definition_key = 'validates_confirmation_of'
+module.exports = composed

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

@@ -0,0 +1,57 @@
+# 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'
+
+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 [0..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 [0..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 require('./validatorable'), cpfable
+composed.definition_key = 'validates_cpf_format'
+module.exports = composed