first steps for better private method scoping

lib/model-factory.js

@@ -115,12 +115,13 @@ ModelFactory.prototype.find = function(options) {
 }
 
 ModelFactory.prototype.build = function(values, options) {
-  var instance = new Model(values, Utils._.extend(this.options, {hasPrimaryKeys: this.hasPrimaryKeys}))
+  var instance = new Model(values, Utils._.extend(this.options, this.attributes, { hasPrimaryKeys: this.hasPrimaryKeys }))
     , self     = this
 
   options = options || {}
   instance.__definition = this
 
+  //console.log(this.attributes)
   Utils._.map(this.attributes, function(definition, name) {
     if(typeof instance[name] == 'undefined') {
       var value = null
@@ -129,7 +130,7 @@ ModelFactory.prototype.build = function(values, options) {
         value = self.rawAttributes[name].defaultValue
 
       instance[name] = value
-      instance.addAttribute(name, value)
+      instance.__addAttribute(name, value)
     }
   })
   Utils._.each(this.options.instanceMethods || {}, function(fct, name) { instance[name] = fct })

lib/model.js

 var Utils          = require("./utils")
   , Mixin          = require("./associations/mixin")
 
-var Model = module.exports = function(values, options) {
-  var self = this
+module.exports = (function() {
+  var Model = function(values, options) {
+    var self = this
 
-  this.__definition = null // will be set in Model.build
-  this.attributes = []
-  this.__options = options || {}
+    this.__definition = null // will be set in Model.build
+    this.attributes = []
+    this.__options = options || {}
 
-  // add all passed values to the model and store the attribute names in this.attributes
-  Utils._.map(values, function(value, key) { self.addAttribute(key, value) })
+    initAttributes.call(this, values)
+  }
+  Utils.addEventEmitter(Model)
+  Utils._.extend(Model.prototype, Mixin.prototype)
 
-  // set id to null if not passed as value
-  // a newly created model has no id
-  var defaults = this.__options.hasPrimaryKeys ? {} : { id: null }
+  Model.Events = {
+    insert: 'InsertQuery',
+    update: 'UpdateQuery',
+    destroy: 'DestroyQuery'
+  }
 
-  if(this.__options.timestamps) {
-    defaults[this.__options.underscored ? 'created_at' : 'createdAt'] = new Date()
-    defaults[this.__options.underscored ? 'updated_at' : 'updatedAt'] = new Date()
+  Model.prototype.__defineGetter__('QueryGenerator', function() {
+    return this.__definition.QueryGenerator
+  })
 
-    if(this.__options.paranoid)
-      defaults[this.__options.underscored ? 'deleted_at' : 'deletedAt'] = null
+  Model.prototype.save = function() {
+    var attr = this.__options.underscored ? 'updated_at' : 'updatedAt'
+
+    if(this.hasOwnProperty(attr))
+      this[attr] = new Date()
+
+    if(this.isNewRecord) {
+      var self = this
+      var eventEmitter = new Utils.CustomEventEmitter(function() {
+        query.call(self, self.QueryGenerator.insertQuery(self.__definition.tableName, self.values))
+        .on('success', function(obj) {
+          obj.isNewRecord = false
+          eventEmitter.emit('success', obj)
+        })
+        .on('failure', function(err) { eventEmitter.emit('failure', err) })
+      })
+      return eventEmitter.run()
+    } else {
+      var identifier = this.__options.hasPrimaryKeys ? this.primaryKeyValues : this.id
+      return query.call(this, this.QueryGenerator.updateQuery(this.__definition.tableName, this.values, identifier))
+    }
   }
 
-  Utils._.map(defaults, function(value, attr) {
-    if(!self.hasOwnProperty(attr))
-      self.addAttribute(attr, value)
-  })
-}
-Utils.addEventEmitter(Model)
-Utils._.extend(Model.prototype, Mixin.prototype)
+  Model.prototype.updateAttributes = function(updates) {
+    var self = this
 
-Model.Events = {
-  insert: 'InsertQuery',
-  update: 'UpdateQuery',
-  destroy: 'DestroyQuery'
-}
+    var readOnlyAttributes = Utils._.keys(this.__definition.primaryKeys)
+    readOnlyAttributes.push('id')
+    readOnlyAttributes.push('createdAt')
+    readOnlyAttributes.push('updatedAt')
+    readOnlyAttributes.push('deletedAt')
+
+    Utils._.each(updates, function(value, attr) {
+      var updateAllowed = (
+        (readOnlyAttributes.indexOf(attr) == -1) &&
+        (readOnlyAttributes.indexOf(Utils._.underscored(attr)) == -1) &&
+        (self.attributes.indexOf(attr) > -1)
+      )
+      updateAllowed && (self[attr] = value)
+    })
+    return this.save()
+  }
 
-Model.prototype.__defineGetter__('QueryGenerator', function() {
-  return this.__definition.QueryGenerator
-})
+  Model.prototype.destroy = function() {
+    if(this.__options.timestamps && this.__options.paranoid) {
+      this[this.__options.underscored ? 'deleted_at' : 'deletedAt'] = new Date()
+      return this.save()
+    } else {
+      var identifier = this.__options.hasPrimaryKeys ? this.primaryKeyValues : this.id
+      return query.call(this, this.QueryGenerator.deleteQuery(this.__definition.tableName, identifier))
+    }
+  }
 
-Model.prototype.addAttribute = function(attribute, value) {
-  this[attribute] = value
-  this.attributes.push(attribute)
-}
+  Model.prototype.__defineGetter__("identifiers", function() {
+    var primaryKeys = Utils._.keys(this.__definition.primaryKeys)
+      , result      = {}
+      , self        = this
 
-Model.prototype.query = function() {
-  var args = Utils._.map(arguments, function(arg, _) { return arg })
-    , s    = this.__definition.modelManager.sequelize
+    if(!this.__definition.hasPrimaryKeys)
+      primaryKeys = ['id']
 
-  args.push(this)
-  return s.query.apply(s, args)
-}
+    primaryKeys.forEach(function(identifier) {
+      result[identifier] = self[identifier]
+    })
 
-Model.prototype.save = function() {
-  var attr = this.__options.underscored ? 'updated_at' : 'updatedAt'
+    return result
+  })
 
-  if(this.hasOwnProperty(attr))
-    this[attr] = new Date()
+  Model.prototype.__defineGetter__('isDeleted', function() {
+    var result = this.__options.timestamps && this.__options.paranoid
+    result = result && this[this.__options.underscored ? 'deleted_at' : 'deletedAt'] != null
 
-  if(this.isNewRecord) {
-    var self = this
-    var eventEmitter = new Utils.CustomEventEmitter(function() {
-      self.query(self.QueryGenerator.insertQuery(self.__definition.tableName, self.values))
-      .on('success', function(obj) {
-        obj.isNewRecord = false
-        eventEmitter.emit('success', obj)
-      })
-      .on('failure', function(err) { eventEmitter.emit('failure', err) })
-    })
-    return eventEmitter.run()
-  } else {
-    var identifier = this.__options.hasPrimaryKeys ? this.primaryKeyValues : this.id
-    return this.query(this.QueryGenerator.updateQuery(this.__definition.tableName, this.values, identifier))
-  }
-}
-
-Model.prototype.updateAttributes = function(updates) {
-  var self = this
-
-  var readOnlyAttributes = Utils._.keys(this.__definition.primaryKeys)
-  readOnlyAttributes.push('id')
-  readOnlyAttributes.push('createdAt')
-  readOnlyAttributes.push('updatedAt')
-  readOnlyAttributes.push('deletedAt')
-
-  Utils._.each(updates, function(value, attr) {
-    var updateAllowed = (
-      (readOnlyAttributes.indexOf(attr) == -1) &&
-      (readOnlyAttributes.indexOf(Utils._.underscored(attr)) == -1) &&
-      (self.attributes.indexOf(attr) > -1)
-    )
-    updateAllowed && (self[attr] = value)
+    return result
   })
-  return this.save()
-}
 
-Model.prototype.destroy = function() {
-  if(this.__options.timestamps && this.__options.paranoid) {
-    this[this.__options.underscored ? 'deleted_at' : 'deletedAt'] = new Date()
-    return this.save()
-  } else {
-    var identifier = this.__options.hasPrimaryKeys ? this.primaryKeyValues : this.id
-    return this.query(this.QueryGenerator.deleteQuery(this.__definition.tableName, identifier))
-  }
-}
+  Model.prototype.__defineGetter__('values', function() {
+    var result = {}
+      , self   = this
 
-Model.prototype.__defineGetter__("identifiers", function() {
-  var primaryKeys = Utils._.keys(this.__definition.primaryKeys)
-    , result      = {}
-    , self        = this
+    this.attributes.forEach(function(attr) {
+      result[attr] = self[attr]
+    })
+
+    return result
+  })
 
-  if(!this.__definition.hasPrimaryKeys)
-    primaryKeys = ['id']
+  Model.prototype.__defineGetter__('primaryKeyValues', function() {
+    var result = {}
+      , self   = this
+
+    Utils._.each(this.__definition.primaryKeys, function(_, attr) {
+      result[attr] = self[attr]
+    })
 
-  primaryKeys.forEach(function(identifier) {
-    result[identifier] = self[identifier]
+    return result
   })
 
-  return result
-})
+  Model.prototype.equals = function(other) {
+    var result = true
+      , self   = this
 
-Model.prototype.__defineGetter__('isDeleted', function() {
-  var result = this.__options.timestamps && this.__options.paranoid
-  result = result && this[this.__options.underscored ? 'deleted_at' : 'deletedAt'] != null
+    Utils._.each(this.values, function(value, key) {
+      result = result && (value == other[key])
+    })
 
-  return result
-})
+    return result
+  }
 
-Model.prototype.__defineGetter__('values', function() {
-  var result = {}
-    , self   = this
+  Model.prototype.equalsOneOf = function(others) {
+    var result = false
+      , self   = this
 
-  this.attributes.forEach(function(attr) {
-    result[attr] = self[attr]
-  })
+    others.forEach(function(other) { result = result || self.equals(other) })
 
-  return result
-})
+    return result
+  }
 
-Model.prototype.__defineGetter__('primaryKeyValues', function() {
-  var result = {}
-    , self   = this
+  // private
 
-  Utils._.each(this.__definition.primaryKeys, function(_, attr) {
-    result[attr] = self[attr]
-  })
+  var initAttributes = function(values) {
+    var self = this
 
-  return result
-})
+    // add all passed values to the model and store the attribute names in this.attributes
+    Utils._.map(values, function(value, key) { self.__addAttribute(key, value) })
 
-Model.prototype.equals = function(other) {
-  var result = true
-    , self   = this
+    // set id to null if not passed as value
+    // a newly created model has no id
+    var defaults = this.__options.hasPrimaryKeys ? {} : { id: null }
 
-  Utils._.each(this.values, function(value, key) {
-    result = result && (value == other[key])
-  })
+    if(this.__options.timestamps) {
+      defaults[this.__options.underscored ? 'created_at' : 'createdAt'] = new Date()
+      defaults[this.__options.underscored ? 'updated_at' : 'updatedAt'] = new Date()
+
+      if(this.__options.paranoid)
+        defaults[this.__options.underscored ? 'deleted_at' : 'deletedAt'] = null
+    }
 
-  return result
-}
+    Utils._.map(defaults, function(value, attr) {
+      if(!self.hasOwnProperty(attr))
+        self.__addAttribute(attr, value)
+    })
+  }
 
-Model.prototype.equalsOneOf = function(others) {
-  var result = false
-    , self   = this
+  var query = function() {
+    var args = Utils._.map(arguments, function(arg, _) { return arg })
+      , s    = this.__definition.modelManager.sequelize
+
+    args.push(this)
+    return s.query.apply(s, args)
+  }
+
+  Model.prototype.__addAttribute = function(attribute, value) {
+    this[attribute] = value
+    this.attributes.push(attribute)
+  }
 
-  others.forEach(function(other) { result = result || self.equals(other) })
 
-  return result
-}
+  /* Add the instance methods to Model */
+  Utils._.extend(Model.prototype, Mixin.prototype)
 
-/* Add the instance methods to Model */
-Utils._.extend(Model.prototype, Mixin.prototype)
+  return Model
+})()