can.observe.attributes.js

/*!
* CanJS - 1.1.4 (2013-02-05)
* http://canjs.us/
* Copyright (c) 2013 Bitovi
* Licensed MIT
*/
(function (can, window, undefined) {

  can.each([can.Observe, can.Model], function (clss) {

    if (clss === undefined) {
      return;
    }

    can.extend(clss, {

      attributes: {},


      convert: {
        "date": function (str) {
          var type = typeof str;
          if (type === "string") {
            return isNaN(Date.parse(str)) ? null : Date.parse(str)
          } else if (type === 'number') {
            return new Date(str)
          } else {
            return str
          }
        },
        "number": function (val) {
          return parseFloat(val);
        },
        "boolean": function (val) {
          if (val === 'false' || val === '0' || !val) {
            return false;
          }
          return true;
        },
        "default": function (val, oldVal, error, type) {
          var construct = can.getObject(type),
            context = window,
            realType;

          if (type.indexOf(".") >= 0) {

            realType = type.substring(0, type.lastIndexOf("."));

            context = can.getObject(realType);
          }
          return typeof construct == "function" ? construct.call(context, val, oldVal) : val;
        }
      },

      serialize: {
        "default": function (val, type) {
          return isObject(val) && val.serialize ? val.serialize() : val;
        },
        "date": function (val) {
          return val && val.getTime()
        }
      }
    });

    var oldSetup = clss.setup;


    clss.setup = function (superClass, stat, proto) {
      var self = this;
      oldSetup.call(self, superClass, stat, proto);

      can.each(["attributes"], function (name) {
        if (!self[name] || superClass[name] === self[name]) {
          self[name] = {};
        }
      });

      can.each(["convert", "serialize"], function (name) {
        if (superClass[name] != self[name]) {
          self[name] = can.extend({}, superClass[name], self[name]);
        }
      });
    };
  });

  var oldSetup = can.Observe.prototype.setup;

  can.Observe.prototype.setup = function (obj) {

    var diff = {};

    oldSetup.call(this, obj);

    can.each(this.constructor.defaults, function (value, key) {
      if (!this.hasOwnProperty(key)) {
        diff[key] = value;
      }
    }, this);

    this._init = 1;
    this.attr(diff);
    delete this._init;
  };

  can.Observe.prototype.__convert = function (prop, value) {

    var Class = this.constructor,
      oldVal = this.attr(prop),
      type, converter;

    if (Class.attributes) {

      type = Class.attributes[prop];
      converter = Class.convert[type] || Class.convert['default'];
    }

    return value === null || !type ?

    value :

    converter.call(Class, value, oldVal, function () {}, type);
  };

  can.Observe.prototype.serialize = function (attrName) {
    var where = {},
      Class = this.constructor,
      attrs = {};

    if (attrName != undefined) {
      attrs[attrName] = this[attrName];
    } else {
      attrs = this.__get();
    }

    can.each(attrs, function (val, name) {
      var type, converter;

      type = Class.attributes ? Class.attributes[name] : 0;
      converter = Class.serialize ? Class.serialize[type] : 0;

      where[name] = val && typeof val.serialize == 'function' ?

      val.serialize() :

      converter ?

      converter(val, type) :

      val
    });

    return attrName != undefined ? where[attrName] : where;
  };

})(can, this);