removed nospecs and added vows + refactored sequelize

sequelize.js

@@ -6,34 +6,10 @@
     callback
     callback
   })
   })
 */
 */
-var log = function(obj){ var sys = require("sys"); sys.puts(sys.inspect(obj)) }
-var keys = function(object) {
-  var results = []
-  for (var property in object)
-    results.push(property)
-  return results
-}
-var values = function(object) {
-  var result = []
-  keys(object).forEach(function(key) {
-    result.push(object[key])
-  })
-  return result
-}
-var evaluateTemplate = function(template, replacements) {
-  var result = template
-  keys(replacements).forEach(function(key) {
-    result = result.replace("%{" + key + "}", replacements[key])
-  })
-  return result
-}
+
 var mysql = require(__dirname + "/lib/node-mysql/mysql")
 var mysql = require(__dirname + "/lib/node-mysql/mysql")
 
 
 exports.Sequelize = function(database, username, password) {
 exports.Sequelize = function(database, username, password) {
-  this.STRING   = 'VARCHAR(255)'
-  this.TEXT     = 'VARCHAR(4000)'
-  this.INTEGER  = 'INT'
-  
   this.config = {
   this.config = {
     database: database,
     database: database,
     username: username,
     username: username,
@@ -43,6 +19,10 @@ exports.Sequelize = function(database, username, password) {
   this.tables = {}
   this.tables = {}
 }
 }
 
 
+exports.Sequelize.STRING   = 'VARCHAR(255)'
+exports.Sequelize.TEXT     = 'VARCHAR(4000)'
+exports.Sequelize.INTEGER  = 'INT'
+
 exports.Sequelize.prototype = {
 exports.Sequelize.prototype = {
   asTableName: function(name) {
   asTableName: function(name) {
     return name + "s"
     return name + "s"
@@ -56,79 +36,143 @@ exports.Sequelize.prototype = {
   },
   },
   
   
   get tableNames() {
   get tableNames() {
-    return keys(this.tables)
+    var result = []
+    var self = this
+    Helper.Hash.keys(this.tables).forEach(function(tableName) {
+      result.push(self.asTableName(tableName))
+    })
+    return result
   },
   },
   
   
-  query: function(queryString, callback) {
+  query: function(queryString, options) {
+    options = options || {}
     log("Executing the query: " + queryString)
     log("Executing the query: " + queryString)
     this.connection.connect()
     this.connection.connect()
-    this.connection.query(queryString)
+    this.connection.query(queryString, options.onSuccess, options.onError)
   }
   }
 }
 }
 
 
+// table object
+
 var TableWrapper = function(sequelize, tableName, attributes) {
 var TableWrapper = function(sequelize, tableName, attributes) {
   var table = function(values) {
   var table = function(values) {
     var self = this
     var self = this
-    keys(values).forEach(function(key) {
-      if(attributes[key])
+    Helper.Hash.keys(values).forEach(function(key) {
+      if(attributes[key]) {
         self[key] = values[key]
         self[key] = values[key]
+      }
     })
     })
     this.id = null // specify id as null to declare this object as unsaved and as not present in the database
     this.id = null // specify id as null to declare this object as unsaved and as not present in the database
     this.tableName = tableName
     this.tableName = tableName
     this.attributes = attributes
     this.attributes = attributes
   }
   }
   
   
-  table.sync = function() {
+  table.sync = function(options) {
     var fields = ["id INT"]
     var fields = ["id INT"]
-    attributes.forEach(function(type, name) { fields.push(name + " " + type) })
+    Helper.Hash.keys(attributes).forEach(function(name) { fields.push(name + " " + attributes[name]) })
     var query = "CREATE TABLE IF NOT EXISTS " + tableName + " (" + fields.join(', ') + ")"
     var query = "CREATE TABLE IF NOT EXISTS " + tableName + " (" + fields.join(', ') + ")"
 
 
-    sequelize.query(query)
+    sequelize.query(query, options)
   }
   }
   
   
-  table.drop = function() {
+  table.drop = function(options) {
     var query = "DROP TABLE IF EXISTS " + tableName
     var query = "DROP TABLE IF EXISTS " + tableName
-    sequelize.query(query)
+    sequelize.query(query, options)
   }
   }
   
   
   table.prototype = {
   table.prototype = {
-    get values() {
-      var result = {}
-      var self = this
-      keys(this.attributes).forEach(function(key) {
-        result[key] = self[key]
-      })
-      return result
-    },
-    
-    get valuesAsString() {
-      var actualValues = this.values
-      var values = []
-      var self = this
-      keys(this.values).forEach(function(key) {
-        switch(self.attributes[key]) {
-          case sequelize.INT: actualValues[key]; break;
-          default "'" + actualValues[key] + "'"
-        }
-        var valueAsString = 
-        values.push
-      })
-    }
-    
-    save: function() {
+    save: function(options) {
       var query = null
       var query = null
+
       if(this.id == null) {
       if(this.id == null) {
-        query = evaluateTemplate(
+        query = Helper.evaluateTemplate(
           "INSERT INTO %{table} (%{fields}) VALUES (%{values})",
           "INSERT INTO %{table} (%{fields}) VALUES (%{values})",
-          { table: this.tableName, fields: keys(this.values).join(", "), values: this.valuesAsString }
+          { table: this.tableName, fields: Helper.fieldsForInsertQuery(this), values: Helper.valuesForInsertQuery(this) }
         )
         )
       } else {
       } else {
-        
+        query = evaluateTemplate(
+          "UPDATE %{table} SET %{values} WHERE id = %{id}",
+          { table: this.tableName, values: Helper.valuesForUpdate(this), id: this.id }
+        )
       }
       }
       
       
-      sequelize.query(query)
+      sequelize.query(query, options)
     }
     }
   }
   }
   
   
   return table
   return table
-}
+}
\ No newline at end of file
+
+// Helper methods
+
+var Helper = {
+  log: function(obj) {
+    var sys = require("sys")
+    sys.puts(sys.inspect(obj))
+  },
+  
+  values: function(object) {
+    var result = {}
+    Helper.Hash.keys(object.attributes).forEach(function(key) {
+      result[key] = object[key]
+    })
+    return result
+  },
+  
+  valuesForInsertQuery: function(object) {
+    var actualValues = Helper.values(object),
+        result  = []
+        
+    Helper.Hash.keys(actualValues).forEach(function(key) {
+      var value     = null,
+          dataType  = object.attributes[key]
+      
+      switch(dataType) {
+        case exports.Sequelize.INTEGER:
+          value = actualValues[key];
+          break;
+        default:
+          value = "'" + actualValues[key] + "'"
+      }
+
+      result.push(value)
+    })
+    
+    return result
+  },
+  
+  fieldsForInsertQuery: function(object) {
+    return Helper.Hash.keys(Helper.values(object)).join(", ")
+  },
+  
+  get valuesForUpdate() {
+    
+  },
+  
+  evaluateTemplate: function(template, replacements) {
+    var result = template
+    Helper.Hash.keys(replacements).forEach(function(key) {
+      result = result.replace("%{" + key + "}", replacements[key])
+    })
+    return result
+  },
+  
+  Hash: {
+    keys: function(object) {
+      var results = []
+      for (var property in object)
+        results.push(property)
+      return results
+    },
+
+    values: function(object) {
+      var result = []
+      Helper.Hash.keys(object).forEach(function(key) {
+        result.push(object[key])
+      })
+      return result
+    }
+  }
+}
+
+exports.SequelizeHelper = Helper
\ No newline at end of file

spec/specs.js

-describe('Sequelize', function() {
-  before(function() {
-    var mapper = new Sequelize('sequelize_test', 'test', 'test')
-  })
-  
-  describe("tableNames", function() {
-    it("should return the registered table names", function() {
-      var Day = mapper.define('Day', { name: mapper.STRING })
-      expect(mapper.tableNames.length).toEqual(1)
-    })
-  })
-  
-  describe('schema definition', function() {
-    before(function() {
-      var Day = mapper.define('Day', { name: mapper.STRING })
-    })
-
-    it("should return a proper object", function() {
-      expect(Day.attributes).toBeDefined()
-      expect(Day.attributes).toMatch({ name: mapper.STRING })
-    })
-    
-    it("should save the new schema in tables variable", function() {
-      expect(mapper.tables.Day).toBeDefined()
-    })
-  })
-  
-  describe('object', function() {
-    it("should only use passed values if specified before in schema", function() {
-      var Day = mapper.define('Day', { name: mapper.STRING })
-      var day = new Day({ name: 'Monday', foo: 'bar' })
-      
-      expect(day.name).toBeDefined()
-      expect(day.name).toEqual('Monday')
-      expect(day.foo).toBeUndefined()
-    })
-  })
-  
-  describe("object.save", function() {
-    it("should do smth", function() {
-      var Day = mapper.define('Day', { name: mapper.STRING })
-      var day = new Day({ name: 'Monday', foo: 'bar' })
-      day.save()
-    })
-  })
-})
\ No newline at end of file

spec/starter.js

-var kiwi = require("kiwi")
-kiwi.require("NoSpec")
-
-new NoSpec()
-  .define("Sequelize", __dirname + "/../sequelize", "Sequelize")
-  .load(__dirname + "/specs") // use this to load all files in a folder and its subfolders
-  .run()
\ No newline at end of file

specs.js

+var vows    = require('vows'),
+    assert  = require('assert'),
+    Sequelize = require(__dirname + "/sequelize").Sequelize,
+    SequelizeHelper = require(__dirname + "/sequelize").SequelizeHelper
+
+vows.describe('Sequelize').addBatch({
+  'constants': {
+    topic: function() { return Sequelize },
+    'STRING': function(Sequelize) {
+      assert.isString(Sequelize.STRING)
+    },
+    'TEXT': function(Sequelize) {
+      assert.isString(Sequelize.TEXT)
+    },
+    'INTEGER': function(Sequelize) {
+      assert.isString(Sequelize.INTEGER)
+    }
+  },
+  'constructor': {
+    topic: function() {
+      return new Sequelize('database', 'username', 'password')
+    },
+    'sets config correctly': function(s) {
+      assert.equal(s.config.database, 'database')
+      assert.equal(s.config.username, 'username')
+      assert.equal(s.config.password, 'password')
+    },
+    'creates a connection object': function(s) {
+      assert.isObject(s.connection)
+    },
+    'initializes empty table hash': function(s) {
+      assert.isObject(s.tables)
+    }
+  },
+  'Sequalize#asTableName': {
+    topic: function() {
+      return new Sequelize('database', 'username', 'password')
+    },
+    'should return the correct name': function(s) {
+      assert.equal(s.asTableName('Name'), 'Names')
+    }
+  },
+  'Sequelize#define': {
+    topic: function() {
+      var s = new Sequelize('database', 'username', 'password')
+      return [s, s.define('Day', { name: Sequelize.TEXT })]
+    },
+    'should return a function': function(obj) {
+      var s   = obj[0],
+          Day = obj[1]
+          
+      assert.isFunction(Day)
+    },
+    'should store attributes': function(obj) {
+      var s   = obj[0],
+          Day = obj[1]
+          
+      assert.isObject(Day.attributes)
+      assert.deepEqual(Day.attributes, { name: Sequelize.TEXT })
+    },
+    'should add new table to tables': function(obj) {
+      var s   = obj[0],
+          Day = obj[1]
+      
+      assert.include(s.tables, 'Day')
+    }
+  },
+  'Sequelize#tableNames': {
+    topic: function() {
+      return new Sequelize('database', 'username', 'password')
+    },
+    'should be an empty array if no tables are specified': function(s) {
+      assert.deepEqual(s.tableNames, [])
+    },
+    'should be no empty array if tables are specified': function(s) {
+      s.define('Day', { name: Sequelize.TEXT })
+      assert.deepEqual(s.tableNames, ['Days'])
+    }
+  },
+  'Table#sync': {
+    topic: function() {
+      var s = new Sequelize('sequelize_test', 'test', 'test')
+      return s.define('Day', { name: s.TEXT })
+    },
+    'send sync call': function(Day) {
+/*      Day.sync()*/
+    }
+  },
+  'Table#drop': {
+    topic: function() {
+      var s = new Sequelize('sequelize_test', 'test', 'test')
+      return s.define('Day', { name: s.TEXT })
+    },
+    'send drop call': function(Day) {
+      // create table before drop...
+
+    }
+  },
+  'Table#constructor': {
+    topic: function() {
+      var s = new Sequelize('sequelize_test', 'test', 'test')
+      var Day = s.define('Day', { name: Sequelize.STRING })
+      return new Day({ name: 'Monday', foo: 'asd'})
+    },
+    'should ignore passed attributes which are not in the schema': function(day) {
+      assert.equal(day.name, 'Monday')
+      assert.isUndefined(day.foo)
+    },
+    'should save the defined table name': function(day) {
+      assert.equal(day.tableName, 'Days')
+    },
+    'should overwrite id with null': function(day) {
+      assert.isNull(day.id)
+    },
+    'should save attributes': function(day) {
+      assert.deepEqual(day.attributes, { name: Sequelize.STRING })
+    }
+  },
+
+}).export(module)
+
+vows.describe('SequelizeHelper').addBatch({
+  'values': {
+    topic: function() {
+      var s = new Sequelize('sequelize_test', 'test', 'test')
+      var Day = s.define('Day', { name: Sequelize.STRING })
+      return new Day({ name: 'Monday', foo: 'asd'})
+    },
+    'should return {name: Monday}': function(day) {
+      assert.deepEqual(SequelizeHelper.values(day), {name: 'Monday'})
+    }
+  },
+  'valuesForInsertQuery': {
+    topic: function() {
+      var s = new Sequelize('sequelize_test', 'test', 'test')
+      var Day = s.define('Day', { name: Sequelize.STRING, foo: Sequelize.INTEGER })
+      return new Day({ name: 'Monday', foo: 2})
+    },
+    'should return an array': function(day) {
+      assert.isArray(SequelizeHelper.valuesForInsertQuery(day))
+    },
+    'should return an encoded string': function(day) {
+      assert.isString(SequelizeHelper.valuesForInsertQuery(day)[0])
+      assert.equal(SequelizeHelper.valuesForInsertQuery(day)[0], "'Monday'")
+    },
+    'should return a number if passed': function(day) {
+      assert.isNumber(SequelizeHelper.valuesForInsertQuery(day)[1])
+      assert.equal(SequelizeHelper.valuesForInsertQuery(day)[1], 2)
+    }
+  },
+  'fieldsForInsertQuery': {
+    topic: function() {
+      var s = new Sequelize('sequelize_test', 'test', 'test')
+      var Day = s.define('Day', { name: Sequelize.STRING, foo: Sequelize.INTEGER })
+      return new Day({ name: 'Monday', foo: 2})
+    },
+    'should return a string': function(day) {
+      assert.isString(SequelizeHelper.fieldsForInsertQuery(day))
+    },
+    'should be a comma seperated string': function(day) {
+      assert.equal(SequelizeHelper.fieldsForInsertQuery(day), "name, foo")
+    }
+  }
+}).export(module)
\ No newline at end of file