renamed modeldefinition to modelfactory

lib/model-definition.js → lib/model-factory.js

@@ -2,7 +2,7 @@ var Utils = require("./utils")
   , Model = require("./model")
   , Model = require("./model")
   , DataTypes = require("./data-types")
   , DataTypes = require("./data-types")
 
 
-var ModelDefinition = module.exports = function(name, attributes, options) {
+var ModelFactory = module.exports = function(name, attributes, options) {
   var self = this
   var self = this
 
 
   this.options = options || {}
   this.options = options || {}
@@ -18,13 +18,13 @@ var ModelDefinition = module.exports = function(name, attributes, options) {
   this.__addOptionalClassMethods()
   this.__addOptionalClassMethods()
   this.__findAutoIncrementField()
   this.__findAutoIncrementField()
 }
 }
-Utils.addEventEmitter(ModelDefinition)
+Utils.addEventEmitter(ModelFactory)
 
 
-ModelDefinition.prototype.__defineGetter__('QueryGenerator', function() {
+ModelFactory.prototype.__defineGetter__('QueryGenerator', function() {
   return this.modelManager.sequelize.connectorManager.getQueryGenerator()
   return this.modelManager.sequelize.connectorManager.getQueryGenerator()
 })
 })
 
 
-ModelDefinition.prototype.sync = function(options) {
+ModelFactory.prototype.sync = function(options) {
   options = Utils.merge(options || {}, this.options)
   options = Utils.merge(options || {}, this.options)
 
 
   var self = this
   var self = this
@@ -45,15 +45,15 @@ ModelDefinition.prototype.sync = function(options) {
   return this
   return this
 }
 }
 
 
-ModelDefinition.prototype.drop = function() {
+ModelFactory.prototype.drop = function() {
   return this.__query(this.QueryGenerator.dropTableQuery(this.tableName, this.id))
   return this.__query(this.QueryGenerator.dropTableQuery(this.tableName, this.id))
 }
 }
 
 
-ModelDefinition.prototype.all = function() {
+ModelFactory.prototype.all = function() {
   return this.__query(this.QueryGenerator.selectQuery(this.tableName))
   return this.__query(this.QueryGenerator.selectQuery(this.tableName))
 }
 }
 
 
-ModelDefinition.prototype.count = function(options) {
+ModelFactory.prototype.count = function(options) {
   var self = this
   var self = this
 
 
   var emitter = new Utils.CustomEventEmitter(function() {
   var emitter = new Utils.CustomEventEmitter(function() {
@@ -64,7 +64,7 @@ ModelDefinition.prototype.count = function(options) {
   return emitter.run()
   return emitter.run()
 }
 }
 
 
-ModelDefinition.prototype.max = function(field, options) {
+ModelFactory.prototype.max = function(field, options) {
   var self = this
   var self = this
 
 
   var emitter = new Utils.CustomEventEmitter(function() {
   var emitter = new Utils.CustomEventEmitter(function() {
@@ -74,7 +74,7 @@ ModelDefinition.prototype.max = function(field, options) {
   })
   })
   return emitter.run()
   return emitter.run()
 }
 }
-ModelDefinition.prototype.min = function(field, options) {
+ModelFactory.prototype.min = function(field, options) {
   var self = this
   var self = this
 
 
   var emitter = new Utils.CustomEventEmitter(function() {
   var emitter = new Utils.CustomEventEmitter(function() {
@@ -84,11 +84,11 @@ ModelDefinition.prototype.min = function(field, options) {
   })
   })
   return emitter.run()
   return emitter.run()
 }
 }
-ModelDefinition.prototype.findAll = function(options) {
+ModelFactory.prototype.findAll = function(options) {
   return this.__query(this.QueryGenerator.selectQuery(this.tableName, options))
   return this.__query(this.QueryGenerator.selectQuery(this.tableName, options))
 }
 }
 
 
-ModelDefinition.prototype.find = function(options) {
+ModelFactory.prototype.find = function(options) {
   // options is not a hash but an id
   // options is not a hash but an id
   if(typeof options == 'number')
   if(typeof options == 'number')
     options = {where: options}
     options = {where: options}
@@ -113,7 +113,7 @@ ModelDefinition.prototype.find = function(options) {
   return this.__query(query, this, {plain: true})
   return this.__query(query, this, {plain: true})
 }
 }
 
 
-ModelDefinition.prototype.build = function(values, 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, {hasPrimaryKeys: this.hasPrimaryKeys}))
     , self     = this
     , self     = this
 
 
@@ -142,11 +142,11 @@ ModelDefinition.prototype.build = function(values, options) {
   return instance
   return instance
 }
 }
 
 
-ModelDefinition.prototype.create = function(values) {
+ModelFactory.prototype.create = function(values) {
   return this.build(values).save()
   return this.build(values).save()
 }
 }
 
 
-ModelDefinition.prototype.__defineGetter__('primaryKeys', function() {
+ModelFactory.prototype.__defineGetter__('primaryKeys', function() {
   var result = {}
   var result = {}
 
 
   Utils._.each(this.attributes, function(dataTypeString, attributeName) {
   Utils._.each(this.attributes, function(dataTypeString, attributeName) {
@@ -157,17 +157,17 @@ ModelDefinition.prototype.__defineGetter__('primaryKeys', function() {
   return result
   return result
 })
 })
 
 
-ModelDefinition.prototype.__defineGetter__('primaryKeyCount', function() {
+ModelFactory.prototype.__defineGetter__('primaryKeyCount', function() {
   return Utils._.keys(this.primaryKeys).length
   return Utils._.keys(this.primaryKeys).length
 })
 })
 
 
-ModelDefinition.prototype.__defineGetter__('hasPrimaryKeys', function() {
+ModelFactory.prototype.__defineGetter__('hasPrimaryKeys', function() {
   return this.primaryKeyCount > 0
   return this.primaryKeyCount > 0
 })
 })
 
 
 // private
 // private
 
 
-ModelDefinition.prototype.__query = function() {
+ModelFactory.prototype.__query = function() {
   var args = Utils._.map(arguments, function(arg, _) { return arg })
   var args = Utils._.map(arguments, function(arg, _) { return arg })
     , s    = this.modelManager.sequelize
     , s    = this.modelManager.sequelize
 
 
@@ -176,12 +176,12 @@ ModelDefinition.prototype.__query = function() {
   return s.query.apply(s, args)
   return s.query.apply(s, args)
 }
 }
 
 
-ModelDefinition.prototype.__addOptionalClassMethods = function() {
+ModelFactory.prototype.__addOptionalClassMethods = function() {
   var self = this
   var self = this
   Utils._.each(this.options.classMethods || {}, function(fct, name) { self[name] = fct })
   Utils._.each(this.options.classMethods || {}, function(fct, name) { self[name] = fct })
 }
 }
 
 
-ModelDefinition.prototype.__addDefaultAttributes = function() {
+ModelFactory.prototype.__addDefaultAttributes = function() {
   var defaultAttributes = {id: {type: DataTypes.INTEGER, allowNull: false, primaryKey: true, autoIncrement: true}}
   var defaultAttributes = {id: {type: DataTypes.INTEGER, allowNull: false, primaryKey: true, autoIncrement: true}}
     , self = this
     , self = this
 
 
@@ -199,7 +199,7 @@ ModelDefinition.prototype.__addDefaultAttributes = function() {
   Utils._.map(defaultAttributes, function(value, attr) { self.attributes[attr] = value })
   Utils._.map(defaultAttributes, function(value, attr) { self.attributes[attr] = value })
 }
 }
 
 
-ModelDefinition.prototype.__findAutoIncrementField = function() {
+ModelFactory.prototype.__findAutoIncrementField = function() {
   var self = this
   var self = this
 
 
   this.autoIncrementField = null
   this.autoIncrementField = null
@@ -213,4 +213,4 @@ ModelDefinition.prototype.__findAutoIncrementField = function() {
   })
   })
 }
 }
 
 
-Utils._.extend(ModelDefinition.prototype, require("./associations/mixin"))
+Utils._.extend(ModelFactory.prototype, require("./associations/mixin"))

lib/sequelize.js

 var Utils        = require("./utils")
 var Utils        = require("./utils")
-  , ModelDefinition  = require("./model-definition")
+  , ModelFactory = require("./model-factory")
   , DataTypes    = require('./data-types')
   , DataTypes    = require('./data-types')
   , ModelManager = require("./model-manager")
   , ModelManager = require("./model-manager")
 
 
@@ -34,7 +34,7 @@ var instanceMethods = {
     if(this.options.define)
     if(this.options.define)
       options = Sequelize.Utils.merge(options, this.options.define)
       options = Sequelize.Utils.merge(options, this.options.define)
 
 
-    var model = this.modelManager.addModel(new ModelDefinition(modelName, attributes, options))
+    var model = this.modelManager.addModel(new ModelFactory(modelName, attributes, options))
 
 
     return model
     return model
   },
   },

spec/model-definition.spec.js

@@ -3,7 +3,7 @@ var config    = require("./config/config")
   , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
   , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
   , Helpers   = new (require("./config/helpers"))(sequelize)
   , Helpers   = new (require("./config/helpers"))(sequelize)
 
 
-describe('ModelDefinition', function() {
+describe('ModelFactory', function() {
   beforeEach(function() { Helpers.sync() })
   beforeEach(function() { Helpers.sync() })
   afterEach(function() { Helpers.drop() })
   afterEach(function() { Helpers.drop() })
 
 

test/Model/mixin.js

 var assert       = require("assert")
 var assert       = require("assert")
-  , ModelDefinition = require("./../../lib/model-definition")
+  , ModelFactory = require("./../../lib/model-factory")
 
 
 module.exports = {
 module.exports = {
   'mixin should be correctly added to the model': function() {
   'mixin should be correctly added to the model': function() {
-    assert.isDefined(ModelDefinition.prototype.hasOne)
-    assert.isDefined(ModelDefinition.prototype.hasMany)
-    assert.isDefined(ModelDefinition.prototype.belongsTo)
+    assert.isDefined(ModelFactory.prototype.hasOne)
+    assert.isDefined(ModelFactory.prototype.hasMany)
+    assert.isDefined(ModelFactory.prototype.belongsTo)
   }
   }
 }
 }