ende 0.5.20 → 0.5.21

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

@@ -0,0 +1,419 @@
+root   = window
+$      = require 'jquery'
+extend = require 'assimilate'
+
+require './resource'
+
+# Store association methods
+# TODO Implement setter for route
+plural = # has_many ## TODO embeds_many
+  add   : (params...) ->
+    # TODO check for id and instantly add resource
+    # TODO Set foreign keys?
+    @push @build attributes for attributes in params
+
+  create: (params...) ->
+    for attributes in params
+      record = @build attributes
+      @push record
+      record.save()
+  build: (data = {}) ->
+    data.parent_resource = @parent_resource
+
+    # TODO Setup a before save callback to generate route when there is no id
+    data.route ||= "#{@parent.route}/#{@parent._id}/#{model.pluralize @resource.toString()}" if @parent?
+    throw "associable.has_many: cannot redefine route of association #{@parent_resource}.#{@resource} from #{@route} to #{data.route}" if @route isnt data.route and @route
+    # Adds parent record to children side of association, if not set
+    # TODO check if this reference is unmade on instance elimination
+    data[@parent_resource] ||= @parent
+
+    # TODO store a singular copy of the resource for better performace
+    model[model.singularize @resource] data
+  push    : ->
+    console.warn "#{@resource}.push is deprecated and will be removed, please use add instead"
+    Array.prototype.push.apply @, arguments
+    arguments[0]
+
+  length : 0
+  json   : (methods, omissions) -> record.json(methods, omissions) for record in @
+
+  find   : (id) -> return resource for resource in @ when resource._id is id
+
+  # TODO better support searching
+  filter   :  Array.prototype.filter || _?.filter
+
+
+singular = # belongs_to, has_one ## TODO embeds_one, embedded_in
+  # @ = record
+  create: (data) -> model[@resource].create extend {}, @, data
+  # @ = record
+  # TODO convert to association proxy
+  build : (data) ->
+    # Adds child record of association to parent, and returns new
+    # record
+    @owner[@resource.toString()] = model[@resource.toString()] extend {}, @, data
+
+descriptors =
+  belongs_to:
+    # TODO store association observer in association proxy, also
+    # update observable to support creating empty observers on object
+    # attributes
+    resource_id:
+      getter: -> @owner.observed[@resource + '_id']
+      setter: (resource_id) ->
+        # TODO check for association name in association proxy
+        association_name = @resource.toString()
+
+        # TODO faster nullifing association check
+        # TODO check if its usefull to only allow disassociating with null
+        # TODO notify nullification of associations
+        unless resource_id?
+          # If there is anything to nullify, undefine or falsify, do it
+          if @owner[association_name] or @owner[association_name + '_id']
+            @dirty = true
+            @owner[association_name] = null
+            
+          return resource_id
+
+        # TODO Discover and update inverse side of association
+        # associated[@owner.resource.toString()] = @owner
+        current_resource_id = @owner.observed[association_name]?._id
+        if resource_id != current_resource_id
+
+          # For getter to read, we store conveniently on observable
+          # repository
+          @owner.observed[association_name + '_id'] = resource_id
+
+          # Nullify associated object, so next time user accesses it,
+          # association loader loads the new object
+          @owner.observed[association_name] = null
+
+          # If we have any listener associated with this property,
+          # notify it
+          # TODO implement notification api on observable
+          unless Object.observe
+            @owner.observation.observers[association_name + '_id']?.check_()
+          else
+            change = oldValue: current_resource_id, type: 'update', name: association_name + '_id', object: @owner
+            Object.getNotifier(@owner).notify change
+
+        resource_id
+
+    resource:
+      # TODO Use Auto build and Auto load as association options
+      getter: ->
+        # TODO allow custom association names
+        association_name = @resource.toString()
+        associated       = @owner.observed[association_name]
+        associated_id    = @owner.observed[association_name + '_id']
+
+        # Returns null depending on sustained state of resource and on
+        # retrievability of the resource
+        return associated || null unless associated?._id? or associated_id
+
+        # Returns imediatelly for resources on storage
+        # TODO make this extensible
+        return associated if associated?.sustained
+
+        # Auto build
+        resource = model[association_name]
+        unless resource
+          console.warn "descriptors.belongs_to.resource.getter: associated factory not found for model '#{association_name}' belonging to '#{@owner.resource}'"
+          return associated
+
+        # Search through stored resources to see if it is stored
+        associated   = resource.find associated_id || associated._id
+
+        # Found associated in storage, update this model and return associated
+        return @owner.observed[association_name] = associated if associated
+
+        # Auto load
+        # Not found associated in storage
+        # TODO remote find or local find automatically, and implement find_or_initialize_by
+        associated ||= resource _id: associated_id  # initialize and store a new record
+        associated.reload()                         # fetch resource
+
+        # Store temporary unloaded resource in this model
+        @owner.observed[association_name] = associated
+
+      # Called when associated record changes, so we can silently update the id
+      # TODO Get observer and notify through them
+      setter: (associated) ->
+        association_name = @resource.toString()
+        current_value    = @owner.observed[association_name]
+
+        # Do nothing if the values are not changing
+        return if current_value == associated and !(current_value || associated)
+
+        @owner.observed[association_name] = associated
+        @owner.observed[association_name + '_id'] = if associated then associated._id else null
+
+        # TODO implement notification api on observable
+        unless Object.observe
+          @owner.observation.observers[association_name]?.check_()
+        else
+          change = oldValue: current_value, type: 'update', name: association_name, object: @owner
+          Object.getNotifier(@owner).notify change
+
+          change = oldValue: associated?._id, type: 'update', name: association_name + '_id', object: @owner
+          Object.getNotifier(@owner).notify change
+
+        associated
+
+
+callbacks =
+  has_many:
+    # Forward association nested attributes
+    # TODO write attribute setter, and remove this code
+    nest_attributes: ->
+      # TODO only nest specified nested attributes on model definition
+      # TODO remove associations iteration, and pass throught parameter
+      # TODO DO not support '_attributes' property on instantiating!
+      association_names = model[@resource].has_many
+      if association_names
+        for association_name in association_names
+
+          # Instantiate new records for the association attributes
+          # TODO DO not support '_attributes' property on instantiating!
+          # TODO define setter for attributes
+          associations_attributes = @["#{association_name}_attributes"]
+          association = @[model.pluralize association_name]
+
+          if associations_attributes and associations_attributes.length
+
+            unless association
+              message  = "has_many.nest_attributes: Association not found for #{association_name}. \n"
+              message += "did you set it on model declaration? \n  has_many: #{association_name} "
+              throw message
+
+            # TODO store a singular copy of the resource for better performace
+            association.resource = model.singularize association.resource
+            association.add.apply association, associations_attributes
+            association.resource = model.pluralize   association.resource
+
+          delete @["#{association_name}_attributes"]
+
+    # TODO Update route after setting the id
+    # TODO Update route association only once for each associated record
+    update_association: (data) ->
+      id = @_id || data && (data._id || data.id)
+
+       # Keep trying until we have a id
+      return unless id
+
+      for association_name in model[@resource.toString()].has_many
+        pluralized_association = model.pluralize association_name
+        association = @[pluralized_association]
+        # TODO setter of association.route
+        # to automatically update associated records
+        unless association.route
+          association.route = "/#{model.pluralize @resource.toString()}/#{id}/#{model.pluralize association.resource}"
+
+          for associated in association when not associated.route and associated.parent?
+            associated.route = "/#{model.pluralize @resource.toString()}/#{id}/#{model.pluralize association.resource}"
+
+      true
+    autosave: ->
+      throw 'Not implemented yet'
+      # @save()
+
+  has_one:
+    # Forward association nested attributes
+    # TODO write attribute setter, and remove this code
+    nest_attributes: ->
+      # TODO only nest specified nested attributes on model definition
+      # TODO convert to associations instead of association name
+      # TODO remove associations iteration, and pass throught parameter
+      # TODO DO not support '_attributes' property on instantiating!
+      association_names = model[@resource].has_one
+      if association_names
+        for association_name in association_names
+          associations_attributes = @["#{association_name}_attributes"]
+          if associations_attributes
+            @[association_name] = @["build_#{association_name}"] associations_attributes
+            delete @["#{association_name}_attributes"]
+
+
+# TODO Better association segregation
+associable =
+  model:
+
+    # @ = model instance
+    # param definition modable
+    blender: (definition) ->
+      {model} = associable
+
+      @create_after_hooks  = model.create_after_hooks
+      @create_before_hooks = model.create_before_hooks
+
+      # TODO better default definition of associations
+      @has_many   = [@has_many  ] if @has_many   and $.type(@has_many)   != 'array'
+      @has_one    = [@has_one   ] if @has_one    and $.type(@has_one)    != 'array'
+      @belongs_to = [@belongs_to] if @belongs_to and $.type(@belongs_to) != 'array'
+
+      @has_many   ||= []
+      @has_one    ||= []
+      @belongs_to ||= []
+
+      true
+
+
+    # TODO better organisation of this code
+    # inside this function: @ = record (running on after_initialize)
+    create_after_hooks: (definition) ->
+
+      # TODO Rename options to definition
+      options = model[@resource.name || @resource.toString()]
+
+      # Create association methods
+      # Setup one to many association in model
+      if options.has_many
+
+        # TODO accept more options on has_many association creation
+        for resource in options.has_many
+          # unless model[resource]
+          # throw "Model not found for association with resource '#{resource}', on association 'has_many' "
+
+          # TODO instantiate default resources in has_many association
+          # @resource = model[resource].resource
+
+          # TODO Remember to clear association proxy when object is destroyed
+          association_proxy      = resource: resource, parent_resource: @resource, parent: @
+          association_name       = model.pluralize resource
+
+          # When deserializing has many associated resources from
+          # server, it is common to send as the association without
+          # attributes suffix
+          association_attributes = @[association_name] ||  []
+          @["#{association_name}_attributes"]          ||= []
+          @["#{association_name}_attributes"]            = @["#{association_name}_attributes"].concat association_attributes if association_attributes.length
+
+          # Create or Override sent attributes by the association proxy
+          @[association_name]    = $.extend association_proxy, plural
+
+
+        # Update association attribute
+        @after 'saved', callbacks.has_many.update_association
+
+        # Remove nested attributes and convert them into actual records
+        callbacks.has_many.nest_attributes.call @
+
+      if options.has_one
+        for resource in options.has_one
+          # unless model[resource]
+            # throw "Model not found for association with resource '#{resource}', on association 'has_one' "
+
+          # TODO deprecate parent_resource
+          association_proxy = resource: resource, parent_resource: @resource, owner: @
+          association_proxy[@resource.toString()] = @
+
+          @["build_#{resource}" ] = $.proxy singular.build , association_proxy
+          @["create_#{resource}"] = $.proxy singular.create, association_proxy
+
+
+          # When deserializing has one associated resources from
+          # server, it is common to send as the association without
+          # attributes suffix
+          @["#{association_name}_attributes"] = $.extend @[association_name], @["#{association_name}_attributes"]
+
+          # Update association attribute
+          # TODO @after 'saved', callbacks.has_one.update_association
+
+        # Remove nested attributes and convert them into actual records
+        callbacks.has_one.nest_attributes.call @
+
+      # Externalize this to a file
+      if options.belongs_to
+        # TODO implement association reflection!
+        for resource in options.belongs_to
+          # unless model[resource]
+            # throw "Model not found for association with resource '#{resource}', on association 'belongs_to' "
+
+          # TODO put deprecation warning on parent key
+          association_proxy = resource: resource, parent_resource: @resource, parent: @, owner: @
+
+          # TODO see why this code is here, since we have the owner key
+          association_proxy[@resource.toString()] = @
+
+          @["build_#{resource}"]  = $.proxy singular.build , association_proxy
+          @["create_#{resource}"] = $.proxy singular.create, association_proxy
+
+          # TODO copy from active record and better modularization of
+          # this internals
+          # To prevent association loading request we must nullify the
+          # association when subscribing
+          old_resource_id     = @["#{resource}_id"]
+          old_dirty           = @dirty
+          @["#{resource}_id"] = null
+
+          # TODO implement as a class
+          Object.defineProperty @, "#{resource}_id",
+            get: $.proxy descriptors.belongs_to.resource_id.getter, association_proxy
+            set: $.proxy descriptors.belongs_to.resource_id.setter, association_proxy
+            configurable: true
+
+          # Restore id after loader prevention has passed
+          @["#{resource}_id"] = old_resource_id
+          @dirty              = old_dirty
+
+          # Execute relation attributes binding
+          # TODO validate bindings! When @resource._id != @["#{resource}_id"]
+          # TODO write test for this case
+          # if @["#{resource}_id"] and not @[resource]
+          #   @publish "#{resource}_id", @["#{resource}_id"]
+
+    # TODO better organization of this code, probably transforming the
+    # association into a composable object inside this function: @ =
+    # record (running on before_initialize) Beware there is no
+    # advisable or observable features
+    # @ = model
+    # param record = record instance
+    create_before_hooks: (record) ->
+      definition = @
+
+      # TODO Externalize this to a file
+      if definition.belongs_to
+
+        # TODO implement association reflection!
+        for resource in definition.belongs_to
+          # unless model[resource]
+            # throw "Model not found for association with resource '#{resource}', on association 'belongs_to' "
+
+          # TODO put deprecation warning on parent key
+          association_proxy = resource: resource, parent_resource: @resource, owner: record
+
+          old_resource         = record[resource]
+          old_resource_id      = record[resource + '_id']
+
+          Object.defineProperty record, resource.toString(),
+            get: $.proxy descriptors.belongs_to.resource.getter, association_proxy
+            set: $.proxy descriptors.belongs_to.resource.setter, association_proxy
+            configurable: true
+
+          # Execute setter in order to do the apropriate actions to
+          # the previoulsy stored value in the association property
+          # TODO fix the prototype chain and remove this code
+          record.after_initialize.push (-> (@[resource] = old_resource) or (@[resource + '_id'] = old_resource_id))
+
+  # @ = record
+  record:
+    after_initialize: (attributes) ->
+      throw new Error 'resource must be defined in order to associate' unless @resource?
+      model[@resource.name || @resource.toString()].create_after_hooks.call @
+
+    before_initialize: (creation) ->
+      throw new Error 'resource must be defined in order to associate' unless @resource
+      model[@resource.name || @resource.toString()].create_before_hooks creation
+
+
+# Extend indemma
+model  = root.model     # TODO better way to get parent
+model.mix (modelable) ->
+  modelable.after_mix.push associable.model.blender
+  modelable.record.before_initialize.push associable.record.before_initialize
+  modelable.record.after_initialize.push  associable.record.after_initialize
+
+# This allows to extendind the associable mixin
+model.associable =
+  mix : (blender) ->
+    blender singular, plural

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

@@ -0,0 +1,47 @@
+'use strict'
+
+dirtyable =
+  # TODO move ignored diryifing properties to the record
+  ignores: ['dirty', 'resource', 'route', 'initial_route', 'after_initialize', 'before_initialize', 'parent_resource', 'nested_attributes', 'reloading', 'ready', 'saving', 'saved', 'failed', 'salvation', 'sustained', 'element', 'default', 'lock', 'validate', 'validated', 'validation', 'errors', 'dirty', 'json']
+  reserved_filter: (name) -> @ignores.indexOf(name) == -1
+  record:
+    after_initialize: [ ->
+      @subscribe (added, removed, changed, past) ->
+        @dirty ||= !!Object.keys($.extend {}, added, removed, changed).filter(dirtyable.reserved_filter, dirtyable).length
+    ]
+    
+# Shim browsers without Object.observe
+unless Object.observe
+
+  $.extend dirtyable,
+    descriptor:
+      get:         -> @observed.dirty
+      set: (value) ->
+        @observed.dirty = value
+        @observation.scheduler.schedule()
+        value
+
+  dirtyable.record.after_initialize.push ->
+    Object.defineProperty @, 'dirty', dirtyable.descriptor
+
+# Automatically dirt records without id
+# FIXME
+dirtyable.record.after_initialize.push ->
+   # TODO rename _id to id
+   @dirty = !!@_id
+
+
+
+# Extend indemma
+model  = window.model     # TODO better way to get parent
+record = window.record     # TODO better way to get parent
+
+model.dirtyable = true
+
+record.mix (recordable) ->
+  recordable.after_initialize = recordable.after_initialize.concat dirtyable.record.after_initialize
+
+model.mix  (modelable ) ->
+  # merge modelable , restful.model
+
+`export default dirtyable`

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

@@ -0,0 +1,20 @@
+# TODO externalize errorsable from validatable
+# errorsable = stampit
+#   add: (attribute, message_key, options) ->
+#
+#       @push [attribute, message_key, options]
+#       @messages[attribute_name] messages[message_key](attribute_name)
+#
+#   clear: ->
+#     if @length
+#       @length   = 0
+#       @messages = {}
+#
+#   push: Array.prototype.push
+#   splice: Array.prototype.splice
+# ,
+#   messages: {}
+#   length: 0
+# , ->
+#   @messages = []
+#   @

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

@@ -0,0 +1,16 @@
+maid =
+
+  model : ->
+    @record.after_initialize.push maid.record if @washing?
+
+  record: ->
+
+    @subscribe 'dirty', (dirty) ->
+      dirty && setTimeout =>
+        @save()
+      , 500
+
+# Extend indemma
+model = window.model
+model.mix (modelable) ->
+  modelable.after_mix.unshift maid.model

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

@@ -0,0 +1,34 @@
+require './queryable'
+
+handlers =
+  store_after_saved: ->
+    # TODO remove global model usage
+    {storage} = model[@resource.toString()]
+
+    # TODO check persistable configuration before attaching handlers
+    # and remove the @_id presence check
+    storage.store @_id, @ if @_id
+
+
+persistable =
+  record:
+    # TODO better caching check after resource initialization
+    # TODO think how to retrieve already stored resources
+    after_initialize: ->
+      if @_id
+        # TODO remove global model usage
+        {storage} = model[@resource.toString()]
+        storage.store @_id, @
+      else
+        # TODO check persistable configuration before attaching handlers
+        @after 'saved', handlers.store_after_saved
+
+# 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.persistable = true
+
+model.mix (modelable) ->
+  modelable.record.after_initialize.push persistable.record.after_initialize

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

@@ -0,0 +1,29 @@
+extend   = require 'assimilate'
+storable = require './storable'
+# merge    = extend.withStrategy 'deep'
+stampit  = require '../../vendor/stampit'
+
+queryable =
+  # FIXME don't let everyone use the same storage instance! or let it?
+  storage: storable()
+  find: (key) ->
+    throw new TypeError "InvalidFind: #{@resource.toString()}.find was called with a falsey value" unless key
+    @storage.store key
+  every: (callback) -> callback @storage.values()
+  where: ->
+    throw new Error 'queryable.where: Not implemented yet'
+
+# 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
+
+# queryable = stampit.compose queryable, storable
+
+
+model.queryable = true
+module.exports = queryable
+
+model.mix (modelable) ->
+  # TODO use stampit to extend record and model
+  extend modelable, queryable

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

@@ -0,0 +1,107 @@
+stampit = require '../../vendor/stampit'
+require '../../vendor/owl/pluralize'
+
+# TODO Think of a better name
+resource = stampit
+    toString: -> @name
+    # TODO move resourceable.route() to here
+  ,
+    name    : 'unknown'
+    scope   : null
+    singular: false
+  , ->
+
+    # TODO better integration with record.coffee, and stop storing
+    # original reference
+    if @original_reference
+      stampit.mixIn @original_reference, @
+      @original_reference.toString     = @toString
+      @original_reference.param_name ||= @name
+
+      return @original_reference
+
+    @param_name ||= @name
+
+    @
+
+# TODO Think of a better name, and move to a composable stampit item
+# TODO Externalize route generatio so we can reuse in other files
+descriptors =
+  route:
+    get: ->
+       # TODO use resource object on associations!
+      @resource = name: @resource if typeof @resource == 'string'
+
+      route  = '/'
+      route += "#{@parent.route}/#{@parent._id}" + "/" if @parent?
+      route += @resource.scope + '/' if @resource.scope?
+
+      route += if @resource.singular then @resource.name else model.pluralize @resource.name
+
+      @route = route
+
+    configurable: true
+#    set: (value) -> @initial_route = value
+
+  # TODO Deprecated! Remove on 15/02/2014
+  # parent_id:
+  #   get: -> @[@parent_resource]._id if @[@parent_resource]
+  #   set: -> console.error 'Warning changing associations throught parent_id not allowed for security and style guide purposes' # TODO
+  #   configurable: true
+  #   enumerable: true
+
+# TODO Think of a better name, and move to a composable stampit item
+resourceable =
+  pluralize: (word, count, plural) ->
+    throw new TypeError "Invalid string passed to pluralize '#{word}'" unless word and word.length
+
+    unless word.indexOf('s') == word.length - 1
+      owl.pluralize word, count, plural
+    else
+      word
+
+  singularize: (word) ->
+    throw new TypeError "Invalid string passed to singularize '#{word}'" unless word and word.length
+
+    if word.lastIndexOf('s') == word.length - 1
+      word.substring 0, word.length - 1
+    else
+      word
+
+  initialize: ->
+
+    # Deprecated! Remove on 15/02/2014
+    # Set parent attribute and default nested route
+    # If you're using the associable plugin, this getter and setter will be overwritten!
+    # if @parent_resource
+    #   Object.defineProperty @, "#{@parent_resource}_id", descriptors.parent_id
+
+    # Setup resource
+    resource_definition = {}
+    resource_definition = name: @resource if typeof @resource == 'string'
+    if typeof @resource == 'object'
+      # TODO deeper resource integration with record.coffee, and remove original reference
+      # To prevent reference lost and allow dinamic modification of resources
+      # we need to preserve the original reference
+      @resource.original_reference = @resource
+
+      resource_definition = @resource
+
+    # TODO remove mentions of @parent_resource and use only resource: {parent: ...}
+    resource_definition.parent = @parent_resource
+
+    @resource = resource resource_definition
+
+    # TODO Support route parsing, and change route to /parents/:id/childrens
+    @route ? Object.defineProperty @, 'route', descriptors.route
+
+
+# Extend indemma
+model = window.model # TODO better way to get parent
+
+model.mix (modelable) ->
+  modelable.record.after_initialize.unshift resourceable.initialize
+  modelable.after_mix.unshift resourceable.initialize
+
+model.singularize = resourceable.singularize
+model.pluralize = resourceable.pluralize