ende 0.2.9 → 0.2.10

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

@@ -0,0 +1,342 @@
+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
+
+  length : 0
+  json   : (methods, omissions) -> record.json(methods, omissions) for record in @
+
+
+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
+
+subscribers =
+  belongs_to:
+    foreign_key: (resource_id) ->
+      association_name = @resource.toString()
+
+      # TODO faster nullifing association check
+      # TODO only allow nullifying with null
+      if resource_id == null or resource_id == undefined
+        @dirty = true
+        @owner[association_name] = resource_id
+        return resource_id
+
+      # TODO Discover and update inverse side of association
+      # associated[@owner.resource.toString()] = @owner
+      current_resource_id = @owner[association_name]?._id
+      if resource_id != current_resource_id
+        # Update association with blank resource that will update
+        resource = model[association_name]
+        unless resource
+          console.warn "subscribers.belongs_to.foreign_key: associated factory not found for model: #{association_name}"
+          return resource_id
+
+        # TODO remote find or local find automatically, and implement find_or_initialize_by
+        associated   = resource.find resource_id
+        associated ||= resource _id: resource_id
+
+        @owner.observed[association_name] = associated
+
+      resource_id
+
+    # Called when associated record changes, so we can silently update the id
+    associated_changed: (associated) ->
+      @owner.observed["#{@resource.toString()}_id"] = if associated then associated._id else null
+
+modifiers =
+  # Called before record initialization to create the a lazy loader
+  # for other records
+  belongs_to:
+    associated_loader: ->
+      association_name = @resource.toString()
+
+      Object.defineProperty @owner, association_name,
+        # Observable already sets property for us
+        set: (associated) ->
+          @observed[association_name] = associated
+
+        get: =>
+          associated     = @owner.observed[association_name]
+          associated_id  = @owner.observed[association_name + '_id']
+
+          # Returns null or undefined depending on sustained state of
+          # resource and on retrievability of the resource
+          return associated unless associated?._id? or associated_id
+
+          # Retunrs imediatelly for resources on storage
+          # TODO make this extenxible
+          return associated if associated?.sustained
+
+          resource = model[association_name]
+          unless resource
+            console.warn "subscribers.belongs_to.foreign_key: associated factory not found for model: #{association_name}"
+            return associated
+
+          associated   = resource.find associated_id || associated._id
+          associated ||= resource _id: associated_id
+
+          resource.storage.store associated._id, associated
+          associated.reload()
+
+          @owner.observed[association_name] = associated
+
+        configurable: true
+        enumerable: true
+
+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
+          associations_attributes = @["#{association_name}_attributes"]
+          if associations_attributes and associations_attributes.length
+            association = @[model.pluralize association_name]
+
+            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
+
+    # 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
+          @[association_name] = $.extend association_proxy, plural
+
+        # Update association attribute
+        @after 'saved', callbacks.has_many.update_association
+
+        # Forward nested attributes
+        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
+
+          # Update association attribute
+          # TODO @after 'saved', callbacks.has_many.update_association
+
+        # Forward nested attributes
+        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"]
+          @["#{resource}_id"] = null
+
+          @subscribe "#{resource}_id"   , $.proxy subscribers.belongs_to.foreign_key, association_proxy
+          @subscribe resource.toString(), $.proxy subscribers.belongs_to.associated_changed, association_proxy
+
+          # Restore id after loader prevention has passed
+          @resource_id = old_resource_id
+
+          # 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
+
+          modifiers.belongs_to.associated_loader.call association_proxy
+
+
+  # @ = 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/vendor/components/indefinido-indemma/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/vendor/components/indefinido-indemma/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/vendor/components/indefinido-indemma/src/lib/record/persistable.coffee

@@ -0,0 +1,27 @@
+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:
+    after_initialize: ->
+      # 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/vendor/components/indefinido-indemma/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) ->
+    @storage.store key
+  all: ->
+    @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/vendor/components/indefinido-indemma/src/lib/record/resource.coffee

@@ -0,0 +1,106 @@
+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
+
+    @
+
+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
+
+  # TODO move to resourceable method
+  route:
+    get: ->
+      return @initial_route if @initial_route?
+
+      # 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
+      @initial_route = route
+
+      route
+
+    set: (value) -> @initial_route = value
+
+  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
+
+  initialize: ->
+    # Set parent attribute and default nested route
+    if @parent_resource
+      Object.defineProperty @, "#{@parent_resource}_id",
+        value: resourceable.parent_id
+        configurable: true
+        enumerable: true
+
+    # 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', resourceable.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

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

@@ -0,0 +1,28 @@
+$ = require 'jquery'
+
+module.exports =
+  # TODO render route in the object itself with getter, and normalize this methods
+  get   : (data) -> request.call @, 'get'   , (if @_id then  "#{@route}/#{@_id}" else @route), data
+  put   : (data) -> request.call @, 'put'   , (if @_id then  "#{@route}/#{@_id}" else @route), data # TODO change from put to patch
+  post  : (data) -> request.call @, 'post'  , @route, data
+  delete: (data) -> request.call @, 'delete', (if @_id then  "#{@route}/#{@_id}" else @route), data
+
+request = (method, url, data) ->
+  param_name = @resource.param_name || @resource.toString()
+
+  # TODO optmize this serialization lookup
+  if not data and @json
+   data = {}
+   data[param_name] = @json()
+
+  if data and data[param_name]
+    delete data[param_name]['id']
+    delete data[param_name]['_id']
+
+
+  $.ajax
+    url     : url
+    data    : data
+    type    : method
+    dataType: 'json'
+    context : @