extjs-mvc 0.4.0.j → 0.4.0.k

data/test/app/vendor/extjs-mvc/model/UrlBuilder.js

@@ -0,0 +1,106 @@
+/**
+ * @class ExtMVC.UrlBuilder
+ * Builds URLs...
+ */
+ExtMVC.UrlBuilder = function() {
+  
+};
+
+ExtMVC.UrlBuilder.prototype = {
+  
+  /**
+   * @property baseUrlNamespace
+   * @type String
+   * An optional url namespace to prepend to all urls (e.g. /admin).  Defaults to an empty string
+   */
+  baseUrlNamespace: '',
+  
+  /**
+   * @property baseUrlFormat
+   * @type String
+   * An optional url extension to append to all urls (e.g. .json).  Defaults to an empty string
+   */
+  baseUrlFormat: '',
+  
+  /**
+   * @property segmentJoiner
+   * @type String
+   * The string to join url segments on (defaults to '/')
+   */
+  segmentJoiner: '/',
+  
+  /**
+   * Generates a url for the given object or function definition
+   * @param {Mixed} obj The object to create a URL for
+   * @return {String} The generated URL
+   */
+  urlFor: function() {
+    var config  = {};
+    var lastArg = Array.prototype.slice.call(arguments, arguments.length - 1)[0];
+    
+    //if the last argument is a config object
+    if (typeof lastArg == 'object' && !lastArg.className) {
+      //set some default url building options
+      Ext.apply(config, lastArg, {
+        format:       this.baseUrlFormat,
+        urlNamespace: this.baseUrlNamespace
+      });
+      
+      //use all but the last argument now
+      var arguments = Array.prototype.slice.call(arguments, 0, arguments.length - 1);
+    };
+    
+    //set some default url building options
+    Ext.applyIf(config, {
+      format:       this.baseUrlFormat,
+      urlNamespace: this.baseUrlNamespace
+    });
+    
+    var segments = [config.urlNamespace];
+    
+    //iterate over valid arguments, appending each to segments
+    for (var i=0; i < arguments.length; i++) {
+      var arg = arguments[i];
+      var res = [];
+      
+      switch(typeof arg) {
+        case 'string':   res = [arg];                         break;
+        case 'object':   res = this.segmentsForInstance(arg); break;
+        case 'function': res = this.segmentsForClass(arg);    break;
+      }
+      
+      for (var j=0; j < res.length; j++) {
+        segments.push(res[j]);
+      };
+    };
+    
+    var url = segments.join(this.segmentJoiner);
+    if (config.format) { url += "." + config.format; }
+    
+    return url;
+  },
+  
+  /**
+   * Returns an array of url segments for a model instance
+   * @param {ExtMVC.model} instance A Model instance with at least its primary key value set
+   * @return {Array} An array of segments for this url (e.g. ['users', '10'])
+   */
+  segmentsForInstance: function(instance) {
+    return [instance.constructor.urlName, instance.data.id];
+  },
+  
+  /**
+   * Returns an array of url segments for a given class and optional primary key
+   * @param {Function} cls The class to generate a url for
+   * @param {String} id An optional ID to add to the segments
+   * @return {Array} An array of segments for this class
+   */
+  segmentsForClass: function(cls, id) {
+    var segs = [cls.urlName];
+    if (id) { segs.push(id); }
+    
+    return segs;
+  }
+};
+
+ExtMVC.UrlBuilder = new ExtMVC.UrlBuilder();

data/test/app/vendor/extjs-mvc/model/adapters/AbstractAdapter.js

@@ -0,0 +1,296 @@
+/**
+ * @class ExtMVC.model.plugin.adapter
+ * @ignore
+ */
+ExtMVC.model.plugin.adapter = {
+  initialize: function(model) {
+    var adapter = new this.RESTJSONAdapter();
+    
+    Ext.override(Ext.data.Record, adapter.instanceMethods());
+    Ext.apply(model, adapter.classMethods());
+    
+    //associations are optional so only add them if they are present
+    // try {
+    //   Ext.override(ExtMVC.model.plugin.association.HasMany,   adapter.hasManyAssociationMethods());
+    //   Ext.override(ExtMVC.model.plugin.association.BelongsTo, adapter.belongsToAssociationMethods());
+    // } catch(e) {};
+  }
+};
+
+ExtMVC.model.addPlugin(ExtMVC.model.plugin.adapter);
+
+/**
+ * @class ExtMVC.model.plugin.adapter.Abstract
+ * Abstract adapter class containing methods that all Adapters should provide
+ * All of these methods are expected to be asynchronous except for loaded()
+ */
+
+/**
+ * @constructor
+ * @param {ExtMVC.model} model The model this adapter represents
+*/
+ExtMVC.model.plugin.adapter.Abstract = function(model) {
+  /**
+   * @property model
+   * @type ExtMVC.model.Base
+   * The model this adapter represents (set on initialize)
+   */
+  // this.model = model;
+};
+
+ExtMVC.model.plugin.adapter.Abstract.prototype = {
+  
+  /**
+   * Abstract save method which should be overridden by an Adapter subclass
+   * @param {ExtMVC.model.Base} instance A model instance to save
+   * @param {Object} options Save options (e.g. {success: function(), failure: function()})
+   */
+  doSave: Ext.emptyFn,
+  
+  /**
+   * Abstract find method which should be overridden by an Adapter subclass
+   * @param {Object} options Options for the find, such as primaryKey and conditions
+   */
+  doFind: Ext.emptyFn,
+  
+  /**
+   * Abstract destroy method which should be overridden by an Adapter subclass
+   * @param {ExtMVC.model.Base} instance The model instance to destroy
+   */
+  doDestroy: Ext.emptyFn,
+  
+  /**
+   * @property instanceMethods
+   * @type Object
+   * An object of properties that get added to the model's prototype
+   * These all run within the scope of a model instance
+   */
+  instanceMethods: function() {
+    return {
+      adapter: this,
+    
+      /**
+       * Attempts to save this instance
+       * @member ExtMVC.model.Base
+       * @param {Object} options Options (see collectionMethods.create for arguments)
+       */
+      save: function(options) {
+        options = options || {};
+        if (options.skipValidation === true || this.isValid()) {
+          //looks good, attempt the save
+          return this.adapter.doSave(this, options);
+        } else {
+          //couldn't save
+          if (typeof options.failure == 'function') {
+            return options.failure.call(options.scope || this, this);
+          };
+        };
+      },
+    
+      /**
+       * Attempts to destroy this instance (asynchronously)
+       * @member ExtMVC.model.Base
+       * @param {Object} options Options to pass to the destroy command (see collectionMethods.create for args)
+       */
+      destroy: function(options) {
+        return this.adapter.doDestroy(this, options);
+      },
+    
+      /**
+       * Updates selected fields with new values and saves straight away
+       * @member ExtMVC.model.Base
+       * @param {Object} data The fields to update with new values
+       * @param {Object} options Options (see collectionMethods.create for arguments)
+       */
+      update: function(data, options) {
+        this.setValues(data);
+        this.save(options);
+      },
+    
+      /**
+       * Returns true if this instance has been loaded from backend storage or has only been instantiated
+       * @member ExtMVC.model.Base
+       * @return {Boolean} True if loaded from the server
+       */
+      loaded: function() {
+      
+      }
+    };
+  },
+  
+  classMethods: function() {
+    return {
+      adapter: this,
+    
+      /**
+       * Attempts to create and save a new instance of this model
+       * @param {Object} data The data to use in creating and saving an instance of this model
+       * @param {Object} options Options object:
+       * * skipValidation - set to true to bypass validation before saving (defaults to false)
+       * * scope   - The scope to run callback functions in
+       * * success - pass in a function as a callback if save succeeds.  Function called with 1
+       *             argument - the new model instance
+       * * failure - pass in a function as a callback if save succeeds.  Function called with 2
+       *             arguments - the unsaved model instance and the json response
+       */
+      create: function(data, options) {
+        var instance = new this(data);
+        instance.save(options);
+      
+        return instance;
+      },
+    
+      /**
+       * Builds a new model on this collection but does not save it
+       * @param {Object} data The data to use in creating and saving an instance of this model
+       * @return {Object} The new model instance
+       */
+      build: function(data) {
+        return new this(data);
+      },
+    
+      /**
+       * Finds the given related model on a relationship
+       * @param {Number|String|Object} conditions The unique identifier for this model, or a conditions object
+       * @param {Object} options Options (see collectionMethods.create for arguments)
+       */
+      find: function(conditions, options) {
+        //assume to be the primary key
+        if (typeof(conditions) == 'number' || typeof(conditions) == 'string') conditions = {primaryKey: conditions};
+        
+        return this.adapter.doFind(conditions, options, this);
+      },
+    
+      /**
+       * Issues a destroy (delete) command to delete the appropriate related object by ID
+       * @param {Number|String} id The ID of the associated model to delete
+       * @param {Object} options Options (see collectionMethods.create for arguments)
+       */
+      destroy: function(id, options) {
+        return this.adapter.doDestroy(id, options, this);
+      }
+    };
+  },
+
+  /**
+   * @property hasManyAssociationMethods
+   * @type Object
+   * An object full of properties and functions that get mixed in to hasMany association collections
+   * These methods are run in the scope of the model instance that owns the association, e.g. if
+   * User hasMany Posts, then 'this' refers to the user instance
+   */
+  hasManyAssociationMethods: function() {
+    return {
+      /**
+       * @member ExtMVC.model.plugin.association.HasMany
+       * @ignore (member doesn't seem to work for properties)
+       * @property adapter
+       * @type ExtMVC.model.plugin.adapter.Abstract
+       * A reference to the adapter attached to this association. Useful if you need to dip down to a lower
+       * level than the methods inside HasMany provide
+       */
+      adapter: this,
+    
+      /**
+       * Attempts to create and save a new instance of this model
+       * @member ExtMVC.model.plugin.association.HasMany
+       * @param {Object} data The data to use in creating and saving an instance of this model
+       * @param {Object} options Options object:
+       * * skipValidation - set to true to bypass validation before saving (defaults to false)
+       * * success - pass in a function as a callback if save succeeds.  Function called with 1
+       *             arguments - the new model instance
+       * * failure - pass in a function as a callback if save succeeds.  Function called with 2
+       *             arguments - the unsaved model instance and the json response
+       */
+      create: function(data, options) {
+        var instance = new this.associatedClass(data);
+        
+        //automatically set the foreign key here
+        // instance.set(this.foreignKey, )
+      },
+    
+      /**
+       * Builds a new model on this collection but does not save it
+       * @member ExtMVC.model.plugin.association.HasMany
+       * @param {Object} data The data to use in creating and saving an instance of this model
+       * @return {Object} The new model instance
+       */
+      build: function(data, options) {
+      
+      },
+    
+      /**
+       * Finds the given related model on a relationship
+       * @member ExtMVC.model.plugin.association.HasMany
+       * @param {Number|String} id The unique identifier for this model.
+       */
+      find: function(id) {
+      
+      },
+    
+      /**
+       * Returns true if this association has been fully loaded yet
+       * @member ExtMVC.model.plugin.association.HasMany
+       * @return {Boolean} True if this association has been loaded yet
+       */
+      loaded: function() {
+      
+      },
+    
+      /**
+       * Issues a destroy (delete) command to delete the appropriate related object by ID
+       * @member ExtMVC.model.plugin.association.HasMany
+       * @param {Number|String} id The ID of the associated model to delete
+       */
+      destroy: function(id) {
+      
+      }
+    };
+  },
+  
+  /**
+   * @property belongsToAssociationMethods
+   * @type Object
+   * An object full of properties and functions that get mixed in to belongsTo association collections
+   */
+  belongsToAssociationMethods: function() {
+    return {
+      /**
+       * @member ExtMVC.model.plugin.association.BelongsTo
+       * @ignore (member doesn't seem to work for properties)
+       * @property adapter
+       * @type ExtMVC.model.plugin.adapter.Abstract
+       * A reference to the adapter attached to this association. Useful if you need to dip down to a lower
+       * level than the methods inside BelongsTo provide
+       */
+      adapter: this,
+      
+      /**
+       * Finds the given related model on a relationship
+       * @member ExtMVC.model.plugin.association.BelongsTo
+       * @param {Number|String} id The unique identifier for this model.
+       */
+      find: function(id) {
+      
+      },
+    
+      /**
+       * Returns true if this association has been fully loaded yet
+       * @member ExtMVC.model.plugin.association.BelongsTo
+       * @return {Boolean} True if this association has been loaded yet
+       */
+      loaded: function() {
+      
+      },
+    
+      /**
+       * Issues a destroy (delete) command to delete the appropriate related object by ID
+       * @member ExtMVC.model.plugin.association.BelongsTo
+       * @param {Number|String} id The ID of the associated model to delete
+       */
+      destroy: function(id) {
+      
+      }
+    };
+  }
+};

data/test/app/vendor/extjs-mvc/model/adapters/MemoryAdapter.js

@@ -0,0 +1,103 @@
+/**
+ * @class ExtMVC.model.plugin.adapter.MemoryAdapter
+ * @extends ExtMVC.model.plugin.adapter.Abstract
+ * Provides a very basic storage system where model data get stored to an object in memory
+ */
+ExtMVC.model.plugin.adapter.MemoryAdapter = Ext.extend(ExtMVC.model.plugin.adapter.Abstract, {
+  
+  /**
+   * @property store
+   * @type Object
+   * A simple object that models get saved to
+   */
+  store: {},
+  
+  primaryKeys: {},
+    
+  /**
+   * Performs the actual save request.  Uses POST for new records, PUT when updating existing ones
+   */
+  doSave: function(instance, options) {
+    if (typeof instance == 'undefined') throw new Error('No instance provided to REST Adapter save');
+    options = options || {};
+    
+    //if this model doesn't have a primary key yet, give it one now and mark it as saved
+    var id = instance.get(instance.primaryKey);
+    if (typeof id == 'undefined') {
+      id = this.primaryKeyFor(instance);
+      instance.set(instance.primaryKey, id);
+    }
+    
+    //put the model data into its store
+    this.store[instance.tableName] = this.store[instance.tableName] || {};
+    this.store[instance.tableName][id.toString()] = instance.data;
+  },
+  
+  /**
+   * Performs the actual find request.
+   * @param {Object} conditions An object containing find conditions. If a primaryKey is set this will be used
+   * to build the url for that particular instance, otherwise the collection url will be used
+   * @param {Object} options Callbacks (use callback, success and failure)
+   */
+  doFind: function(conditions, options, constructor) {
+    conditions = conditions || {}; options = options || {};
+    
+    //helper function to cut down repetition in Ajax request callback
+    var callIf = function(callback, args) {
+      if (typeof callback == 'function') callback.apply(options.scope, args);
+    };
+    
+    var modelStore = this.store[constructor.prototype.tableName] || {};
+    
+    if (typeof conditions.primaryKey == 'undefined') {
+      //return everything
+      var records = [];
+      
+      for (primaryKey in modelStore) {
+        records.push((modelStore[primaryKey]));
+      }
+      
+      console.log(records);
+      
+      return new Ext.data.Store({
+        autoLoad: true,
+        data: {'rows': records},
+        // proxy: new Ext.data.MemoryProxy({'rows': records}),
+        fields: constructor.prototype.fields.items,
+        reader: new Ext.data.JsonReader({root: 'rows'}, constructor)
+      });
+      
+    } else {
+      var data = modelStore[conditions.primaryKey.toString()];
+      
+      if (typeof data == 'undefined') {
+        callIf(options.failure);
+      } else {
+        callIf(options.success, [new constructor(data)]);
+      }
+    }
+  },
+  
+  doDestroy: function(instance, options) {
+    if (typeof instance == 'undefined') throw new Error('No instance provided to REST Adapter save');
+    options = options || {};
+    
+    Ext.Ajax.request(
+      Ext.applyIf(options, {
+        method: this.destroyMethod,
+        url:    this.instanceUrl(instance)
+      })
+    );
+  },
+  
+  /**
+   * Returns the next available primary key for a model instance
+   * @param {ExtMVC.model.Base} instance The model instance
+   * @return {Number} The primary key to use for this instance
+   */
+  primaryKeyFor: function(instance) {
+    this.primaryKeys[instance.tableName] = this.primaryKeys[instance.tableName] || 1;
+    
+    return this.primaryKeys[instance.tableName] ++;
+  }
+});