first attempt at refactoring getters/setters to use defineproperty on the prototype

lib/dao-factory.js

@@ -141,26 +141,49 @@ module.exports = (function() {
       })
       })
     }
     }
 
 
-    Utils._.each(['Get', 'Set'], function(type) {
-      var prop  = type.toLowerCase()
-        , opt   = prop + 'terMethods'
-        , meth  = '__define' + type + 'ter__'
+    var attributeManipulation = {};
+
+    Utils._.each(['get', 'set'], function(type) {
+      var opt   = type + 'terMethods'
         , funcs = Utils._.isObject(self.options[opt]) ? self.options[opt] : {}
         , funcs = Utils._.isObject(self.options[opt]) ? self.options[opt] : {}
 
 
-      Utils._.each(self.rawAttributes, function(attr, name) {
-        if (attr.hasOwnProperty(prop)) {
-          funcs[name] = attr[prop]
+
+      Utils._.each(self.rawAttributes, function(attribute, name) {
+        if (attribute.hasOwnProperty(type)) {
+          funcs[name] = attribute[type]
+        } else if (typeof funcs[name] === "undefined") {
+          if (type === 'get') {
+            funcs[name] = function()  { return this.dataValues[attribute]; }
+          }
+          if (type === 'set') {
+            funcs[name] = function(value) {
+              if (Utils.hasChanged(this.dataValues[attribute], value)) {
+                //Only dirty the object if the change is not due to id, touchedAt, createdAt or updatedAt being initiated
+                var updatedAtAttr = Utils._.underscoredIf(this.__options.updatedAt, this.__options.underscored)
+                  , createdAtAttr = Utils._.underscoredIf(this.__options.createdAt, this.__options.underscored)
+                  , touchedAtAttr = Utils._.underscoredIf(this.__options.touchedAt, this.__options.underscored)
+
+                if (this.dataValues[attribute] || (attribute != 'id' && attribute != touchedAtAttr && attribute != createdAtAttr && attribute != updatedAtAttr)) {
+                  this.isDirty = true
+                }
+              }
+              this.dataValues[attribute] = value
+            }
+          }
         }
         }
       })
       })
 
 
       Utils._.each(funcs, function(fct, name) {
       Utils._.each(funcs, function(fct, name) {
-        if (!Utils._.isFunction(fct)) {
-          throw new Error(type + 'ter for "' + name + '" is not a function.')
-        }
-
-        self.DAO.prototype[meth](name, fct)
+        if (!attributeManipulation[name]) attributeManipulation[name] = {}
+        attributeManipulation[name][type] = fct
       })
       })
     })
     })
+    
+    for (var attribute in attributeManipulation) {
+      if (attributeManipulation.hasOwnProperty(attribute)) {
+        Object.defineProperty(this.DAO.prototype, attribute, attributeManipulation[attribute])
+      }
+    }
 
 
     this.DAO.prototype.attributes    = Object.keys(this.DAO.prototype.rawAttributes);
     this.DAO.prototype.attributes    = Object.keys(this.DAO.prototype.rawAttributes);
     this.DAO.prototype.booleanValues = []
     this.DAO.prototype.booleanValues = []

lib/dao.js

@@ -427,43 +427,6 @@ module.exports = (function() {
       value = !!value
       value = !!value
     }
     }
 
 
-    var has = (function(o) {
-      var predef = Object.getOwnPropertyDescriptor(o, attribute);
-
-      if (predef && predef.hasOwnProperty('value')) {
-        return true // true here means 'this property exist as a simple value property, do not place setters or getters at all'
-      }
-
-      return {
-        get: (predef && predef.hasOwnProperty('get') ? predef.get : null) || o.__lookupGetter__(attribute),
-        set: (predef && predef.hasOwnProperty('set') ? predef.set : null) || o.__lookupSetter__(attribute)
-      };
-    })(this);
-
-    // @ node-v0.8.19:
-    //    calling __defineGetter__ destroys any previously defined setters for the attribute in
-    //    question *if* that property setter was defined on the object's prototype (which is what
-    //    we do in dao-factory) ... therefore we need to [re]define both the setter and getter
-    //    here with either the function that already existed OR the default/automatic definition
-    //
-    //    (the same is true for __defineSetter and 'prototype' getters)
-    if (has !== true) {
-      this.__defineGetter__(attribute, has.get || function()  { return this.dataValues[attribute]; });
-      this.__defineSetter__(attribute, has.set || function(v) {
-        if (Utils.hasChanged(this.dataValues[attribute], v)) {
-          //Only dirty the object if the change is not due to id, touchedAt, createdAt or updatedAt being initiated
-          var updatedAtAttr = Utils._.underscoredIf(this.__options.updatedAt, this.__options.underscored)
-            , createdAtAttr = Utils._.underscoredIf(this.__options.createdAt, this.__options.underscored)
-            , touchedAtAttr = Utils._.underscoredIf(this.__options.touchedAt, this.__options.underscored)
-
-          if (this.dataValues[attribute] || (attribute != 'id' && attribute != touchedAtAttr && attribute != createdAtAttr && attribute != updatedAtAttr)) {
-            this.isDirty = true
-          }
-        }
-        this.dataValues[attribute] = v
-      });
-    }
-
     this[attribute] = value;
     this[attribute] = value;
   }
   }