kea-rails 1.0.9 → 2.0.0.pre.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4da6393851b76167dd2176aa44c4b8c5ac95324
-  data.tar.gz: d6403e529a02f942d584612fbeb0e3bc56b2edad
+  metadata.gz: 3d318d6587c37b80be0e5b445d30e98b24823cd4
+  data.tar.gz: 5f299d6ec9ddd4773ea906cb33e0ea9a48bbab29
 SHA512:
-  metadata.gz: 6eac8d1bc587254405cc834826d17536ebb7b309f59da7f2b28bd214f80cb045a6982d2109867b12b8b7d0ea74683eef54ba8615260eb134cb23de0470ad5206
-  data.tar.gz: 3945382663310e144f494ef575cea287d1782a99dc2f10f94a46c3e38d8d003a9257a7f6ecf3978cb9ac073ae0bf68292fd8cbff42525f4ef5f9638108e57660
+  metadata.gz: c9ebfc93950958bd732d2aa3ed4293fc6b54a1e8eeae4efd1a1e9248383ab8855c7e51eae0617a2f437051b33f71e543293d4f7fc8ecc11ab3a769fba7f70acb
+  data.tar.gz: 8cf68356acd861629aeb45ee5cfa2d9ea3ef14223b4145c45cf5343c5ba8f9aada74de13b32e885e31a3f265bfa66818f4561e7225ae2602f248a4097ef0d921

data/app/assets/javascripts/kea/models/base.js

@@ -2,15 +2,134 @@
   "use strict";
 
   var Base,
+      Serializable,
       Validatable;
 
   Base = function Base() {
-
+    
+    this.id            = null;
+    this.resource_path = null;
+    
+    this.persisted = ko.observable(false);
+    
+    this._attributeNames                    = [];
+    this._deserializableAttributes          = [];
+    this._serializableAttributes            = [];
+    this._deserializableAssociations        = {};
+    this._serializableAssociations          = {};
+    this._deserializableHasManyAssociations = {};
+    this._serializableHasManyAssociations   = {};
+    
+    this.deserializationOptions = { attributes: {} };
+    this.serializationOptions   = { attributes: {} };
   };
 
   Base.prototype._modelName = function _modelName() {
     console.error("Model does not implement _modelName");
   };
+  
+  Base.prototype.addAttribute = function addAttribute(name, options) {
+    options             = options || {};
+    options.array       = typeof options.array !== 'undefined' ? options.array : false;
+    options.deserialize = typeof options.deserialize !== 'undefined' ? options.deserialize : true;
+    options.serialize   = typeof options.serialize !== 'undefined' ? options.serialize : true;
+    
+    if (options.array) {
+      this[name] = ko.observableArray([]);
+    } else {
+      this[name] = ko.observable(options.value);
+    }
+    
+    if (options.deserialize) {
+      this._deserializableAttributes.push(name);
+      
+      if (typeof options !== 'boolean') {
+        this.deserializationOptions.attributes[name] = options.deserialize;
+      }
+    }
+    
+    if (options.serialize) {
+      this._serializableAttributes.push(name);
+      
+      if (typeof options !== 'boolean') {
+        this.serializationOptions.attributes[name] = options.serialize;
+      }
+    }
+  };
+  
+  Base.prototype.unserializableAttributes = function unserializableAttributes(attributeNames) {
+    attributeNames.forEach(function(name) {
+      this.addAttribute(name, {serialize: false});
+    }, this);
+  };
+  
+  Base.prototype.serializableAttributes = function unserializableAttributes(attributeNames) {
+    attributeNames.forEach(function(name) {
+      this.addAttribute(name);
+    }, this);
+  };
+  
+  Base.prototype.addAssociation = function addAssociation(modelName, attributeName, type, options) {
+    var deserializationKey,
+        serializationKey;
+        
+    options             = options || {};
+    options.deserialize = typeof options.deserialize !== 'undefined' ? options.deserialize : true;
+    options.serialize   = typeof options.serialize !== 'undefined' ? options.serialize : true;
+    
+    if (type === 'hasOne') {
+      this[attributeName] = ko.observable();
+      deserializationKey  = '_deserializableAssociations';
+      serializationKey    = '_serializableAssociations';
+      
+    } else if (type === 'hasMany') {
+      this[attributeName] = ko.observableArray([]);
+      deserializationKey  = '_deserializableHasManyAssociations';
+      serializationKey    = '_serializableHasManyAssociations';
+      
+    } else {
+      console.error('unsupported association type %s', type);
+      return;
+    }
+    
+    if (options.deserialize) {
+      this[deserializationKey][attributeName] = modelName;
+      
+      if (typeof options !== 'boolean') {
+        this.deserializationOptions.attributes[name] = options.deserialize;
+      }
+    }
+    
+    if (options.serialize) {
+      this[serializationKey][attributeName] = modelName;
+      
+      if (typeof options !== 'boolean') {
+        this.serializationOptions.attributes[name] = options.serialize;
+      }
+    }
+  };
+  
+  Base.prototype.hasOne = function hasOne(modelName, attributeName, options) {
+    if (typeof attributeName === 'undefined') {
+      attributeName = modelName.toLowerCase();
+    }
+    
+    this.addAssociation(modelName, attributeName, 'hasOne', options);
+  };
+  
+  Base.prototype.hasMany = function hasMany(modelName, attributeName, options) {
+    this.addAssociation(modelName, attributeName, 'hasMany', options);
+  };
+  
+  Base.prototype.forEachAssocation = function forEachAssocation(type, callback) {
+    var key = '_' + type + 'Associations';
+    
+    for (var attributeName in this[key]) {
+      if ( this[key].hasOwnProperty(attributeName) ) {
+        callback.call(this, attributeName, this[key][attributeName]);
+      }
+    }
+  };
 
   Base.prototype.service = function service() {
     if (DEBUG) {
@@ -20,14 +139,6 @@
     return app.services[ this._modelName() ];
   };
 
-  Base.prototype.fromJSON = function fromJSON(json) {
-    console.error("object does not implement fromJSON: %O", this);
-  };
-
-  Base.prototype.serialize = function serialize() {
-    console.error("object does not implement serialize: %O", this);
-  };
-
   Base.prototype.update = function update(params) {
     var that = this,
         deferred;
@@ -35,7 +146,7 @@
     deferred = this.service()
       .update(that, params)
       .done(function(data) {
-        that.fromJSON(data);
+        that.deserialize(data);
       });
 
     return deferred;
@@ -52,7 +163,125 @@
 
     });
   };
+  
+  Base.prototype.deserialize = function deserialize(data) {
+    this.persisted(true);
+    
+    this.id            = data.id;
+    this.resource_path = data.resource_path;
+    
+    this._deserializableAttributes.forEach(function(name) {
+      this[name]( data[name] );
+    }, this);
+    
+    this.forEachAssocation('deserializable', function(attributeName, modelName) {
+      if ( data[attributeName] ) {
+        this[attributeName]( new app.models[modelName](data[attributeName]) );
+      }
+    });
+    
+    this.forEachAssocation('deserializableHasMany', function(attributeName, modelName) {
+      if ( data[attributeName] ) {
+        this[attributeName].removeAll();
+        
+        data[attributeName].forEach(function(associationData) {
+          this[attributeName].push( new app.models[modelName](associationData) );
+        }, this);
+      }
+    });
+    
+    if (typeof this.fromJS === 'function') {
+      this.fromJS(data);
+    }
+  };
+  
+  Base.prototype.serialize = function serialize(options) {
+    var result = {},
+        defaultOptions,
+        attributeList,
+        attributeOptions,
+        isBlank,
+        shouldIncludeAttribute;
+    
+    defaultOptions = {
+      includeId: false,
+      attributes: {}
+    };
+    
+    options = $.extend({}, defaultOptions, this.serializationOptions, options);
+    
+    attributeOptions = function attributeOptions(attributeName) {
+      return options.attributes[attributeName] || {};
+    };
+    
+    isBlank = function isBlank(value) {
+      return typeof value === 'undefined' || value === null || value === '' || (Array.isArray(value) && value.length === 0 );
+    };
+    
+    shouldIncludeAttribute = function shouldIncludeAttribute(name, value) {
+      var skipBlank = typeof attributeOptions(name).skipBlank !== 'undefined' ? attributeOptions(name).skipBlank : options.skipBlank;
+      
+      if ( this._serializeableAttributes.indexOf(name) === -1) {
+        return false;
+      } else if (skipBlank && isBlank(value)) {
+        return false;
+      } else {
+        return true;
+      }
+    };
+    
+    if (options.includeId) {
+      result.id = this.id;
+    }
+    
+    if (this._destroy) {
+      result._destroy = true;
+    }
+    
+    this._serializeableAttributes.forEach(function(name) {
+      if (typeof this.associations[name] !== 'undefined' || typeof this.hasManyAssociations[name] !== 'undefined') {
+        return;
+      }
+      
+      var value = this[name]();
+      
+      if (shouldIncludeAttribute(name, value)) {
+        result[name] = value;
+      }
+    }, this);
+    
+    this.forEachAssocation('serializable', function(attributeName, modelName) {
+      var value,
+          key;
+      
+      if (attributeOptions(attributeName).idOnly) {
+        value = this[attributeName]() ? this[attributeName]().id : null;
+        key   = attributeName + '_id';
+      } else {
+        value = this[attributeName]().serialize();
+        key   = attributeName;
+      }
 
+      if (shouldIncludeAttribute(attributeName, value)) {
+        result[key] = value;
+      }
+    });
+    
+    this.forEachHasManyAssocation('serializableHasMany', function(attributeName, modelName) {
+      var value = this[attributeName]().map(function(association) { return association.serialize(); } );
+      
+      if (shouldIncludeAttribute(attributeName, value)) {
+        result[attributeName + '_attributes'] = value;
+      }
+    });
+    
+    if (typeof this.toJS === 'function') {
+      result = this.toJS(result);
+    }
+    
+    return result;
+  };
+  
   kea.models.Base = Base;
 
   Validatable = function Validatable() {
@@ -84,7 +313,7 @@
     this.forEachValidatableField = function forEachValidatableField(callback) {
       ko.utils.arrayForEach(this.validatableFields(), function(field) {
         if (that[field].isValidatable) {
-          callback.call(that, that[field]);
+          callback.call(that, that[field], field);
         }
       });
     };
@@ -96,7 +325,7 @@
         var association = that[association_name]();
         
         if (association.isValidatable && association.isValidatable()) {
-          callback.call(that, association);
+          callback.call(that, association, association_name);
         }
       });
 
@@ -136,15 +365,15 @@
     this.validationMessages = ko.computed(function validationMessages() {
       var messages = [];
 
-      that.forEachValidatableField(function(observable) {
+      that.forEachValidatableField(function(observable, fieldName) {
         if (observable.hasError()) {
-          messages.push(observable.validationMessage());
+          messages.push(fieldName + ': ' + observable.validationMessage());
         }
       }, this);
 
-      that.forEachValidatableAssociation(function(association) {
+      that.forEachValidatableAssociation(function(association, name) {
         if (association.hasErrors()) {
-          messages = messages.concat(association.validationMessages());
+          messages = name + ': ' + messages.concat(association.validationMessages());
         }
       });
 

data/app/assets/javascripts/kea/services/base.js

@@ -133,11 +133,11 @@
 
       } else {
         
-        if (typeof modelObject.refreshFromJSON === 'function') {
+        if (typeof modelObject.refreshFromJS === 'function') {
           modelObject.refresh(data);
           
         } else {
-          modelObject.fromJSON(data);
+          modelObject.deserialize(data);
         }
         
         return modelObject;

data/lib/kea-rails/version.rb

@@ -1,3 +1,3 @@
 module Kea
-  VERSION = "1.0.9"
+  VERSION = "2.0.0-alpha1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kea-rails
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 2.0.0.pre.alpha1
 platform: ruby
 authors:
 - Jan-Christian Foeh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-13 00:00:00.000000000 Z
+date: 2015-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '4.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '4.1'
 description: A collection of helpers for structuring Knockout.js applications
 email:
 - jan@programmanstalt.de
@@ -226,12 +226,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A collection of helpers for structuring Knockout.js applications