ratnikov-ajax_resource 0.02 → 0.03

data/jake.yml

@@ -0,0 +1,25 @@
+---
+source_directory:       src
+build_directory:        build
+packer:
+  shrink_vars:  true
+  private:      true
+  base62:       true
+
+packages:
+  base:
+    - init
+    - attribute_mod
+    - routing
+    - view
+    - base
+
+  utils:
+    - semaphore
+    - form
+    - errors
+
+bundles:
+  ajax_resource:
+    - base
+    - utils

data/src/attribute_mod.js

@@ -0,0 +1,48 @@
+AjaxResource.AttributeMod = function() {
+  this._attributes = {};
+  this._errors = [];
+};
+
+AjaxResource.AttributeMod.prototype.attributes = function() {
+  return this._attributes;
+};
+
+AjaxResource.AttributeMod.prototype.errors = function() {
+  return this._errors;
+};
+
+AjaxResource.AttributeMod.prototype.has_errors = function() {
+  return this.errors().length !== 0;
+};
+
+AjaxResource.AttributeMod.prototype.valid = function() {
+  return !this.has_errors();
+};
+
+AjaxResource.AttributeMod.prototype.id = function() {
+  if (typeof this.attributes().id !== "undefined") {
+    return this.attributes().id;
+  } else {
+
+    // if there is no id attribute, return null as id
+    return null;
+  }
+};
+
+AjaxResource.AttributeMod.prototype.is_new = function() {
+  return this.id() === null;
+};
+
+AjaxResource.AttributeMod.prototype.update_attributes = function(json) {
+  if (typeof(json.errors) !== "undefined") {
+    this._errors = json.errors;
+    delete json.errors;
+  } else {
+
+    // if there are no errors reported by json, emptying out errors
+    this._errors = [];
+  }
+
+  // use all other properties as attributes
+  jQuery.extend(this._attributes, json);
+};

data/src/base.js

@@ -0,0 +1,149 @@
+
+AjaxResource.Base = function(spec) {
+  AjaxResource.AttributeMod.apply(this);
+
+  if (typeof spec.resource !== "undefined") {
+    this._resource_name = spec.resource;
+  } else {
+    throw("Must specify resource");
+  }
+
+  // include the routes
+  this._assign_routes(spec);
+};
+
+AjaxResource.Base.prototype._assign_routes = function(spec) {
+  var route_spec = {};
+
+  if (typeof spec.controller !== "undefined") {
+    route_spec.controller = spec.controller;
+  } else {
+    route_spec.controller = this.resource_name() + 's';
+  }
+
+  AjaxResource.Routing.apply(this, [ route_spec ]);
+};
+
+jQuery.extend(AjaxResource.Base.prototype, AjaxResource.AttributeMod.prototype);
+jQuery.extend(AjaxResource.Base.prototype, AjaxResource.Routing.prototype);
+jQuery.extend(AjaxResource.Base.prototype, AjaxResource.View.prototype);
+
+AjaxResource.Base.prototype.resource_name = function() {
+  return this._resource_name;
+};
+
+AjaxResource.Base.prototype.serialized_attributes = function() {
+  var base = this;
+  var serialized = {};
+  jQuery.each(this.attributes(), function(key, value) {
+    serialized[base.resource_name() + '[' + key + ']'] = value;
+  });
+  return serialized;
+};
+
+AjaxResource.Base.prototype.parse_json = function(json) {
+  var resource_json = json[this.resource_name()];
+
+  if (typeof resource_json !== "undefined") {
+
+    if (typeof resource_json.html !== "undefined") {
+      // set to use custom html if specified
+      this.set_custom(resource_json.html);
+      delete resource_json.html;
+    } else {
+      // otherwise set to use default html
+      this.set_custom(null);
+    }
+
+    // update the attributes with the resource_json
+    this.update_attributes(resource_json);
+
+    return true;
+  } else {
+    // if no resource json was parsed, return false
+    return false;
+  }
+};
+
+AjaxResource.Base.prototype.create = function(success_callback) {
+
+  // sanity check
+  if (!this.is_new()) {
+    throw("Cannot create an existing record");
+  }
+
+  var post_data = jQuery.extend({ _method : 'post' }, this.serialized_attributes());
+  var resource = this;
+
+  return jQuery.ajax({
+    type: 'POST',
+    url: this.collection_path(),
+    data: post_data,
+    success: function(json) {
+      if (resource.parse_json(json)) {
+	success_callback(resource);
+      } else {
+	// do nothing on error
+      }
+    },
+    dataType: 'json'
+  });
+};
+
+AjaxResource.Base.prototype.update = function(success_callback) {
+
+  // sanity check
+  if (this.is_new()) {
+    throw("Cannot update a new record");
+  }
+
+  var post_data = jQuery.extend({ _method : 'put' }, this.serialized_attributes());
+  var resource = this;
+
+  return jQuery.ajax({
+    type: 'POST',
+    url : this.member_path(this.id()),
+    data: post_data,
+    success: function(json) {
+      if (resource.parse_json(json)) {
+	success_callback(resource);
+      } else {
+	// do nothing on error
+      }
+    },
+    dataType: 'json'
+  });
+};
+
+AjaxResource.Base.prototype.save = function(callback) {
+  if (this.is_new()) {
+    return this.create(callback);
+  } else {
+    return this.update(callback);
+  }
+};
+
+AjaxResource.Base.prototype.destroy = function(success_callback) {
+
+  // sanity check
+  if (this.is_new()) {
+    throw("Cannot destroy a new record");
+  }
+
+  var post_data = { _method : 'delete' };
+  var resource = this;
+
+  return jQuery.ajax({
+    type : 'POST',
+    url : this.member_path(this.id()),
+    data : post_data,
+    success: function(json) {
+      if (resource.parse_json(json)) {
+	success_callback(resource);
+      } else {
+	// do nothing on error
+      }
+    },
+    dataType: 'json'
+  });
+};

data/src/errors.js

@@ -0,0 +1,53 @@
+
+AjaxResource.Errors = function(selector) {
+  this._error_div = jQuery(selector).find('div.error');
+};
+
+AjaxResource.Errors.prototype.error_div = function() {
+  return this._error_div;
+};
+
+AjaxResource.Errors.prototype.ul = function() {
+  return this.error_div().find("ul");
+};
+
+AjaxResource.Errors.prototype.append = function(errors) {
+  var self = this;
+  jQuery.each(errors, function() {
+    if (this.length == 2) {
+      var desc = this[0];
+      var msg = this[1];
+    } else {
+      throw "Unsupported error format for: "+this;
+    }
+
+    var full_message;
+    if (desc !== 'base') {
+      full_message = desc + ' ' + msg;
+    } else {
+      // Use only the error message for base errors
+      full_message = msg;
+    }
+
+    self.ul().append("<li>" + full_message + "</li>");
+  });
+};
+
+AjaxResource.Errors.prototype.clear = function() {
+  this.ul().html("");
+  this.hide();
+};
+
+AjaxResource.Errors.prototype.set = function(errors) {
+  this.clear();
+  this.append(errors);
+  this.show();
+};
+
+AjaxResource.Errors.prototype.hide = function() {
+  this.error_div().hide();
+};
+
+AjaxResource.Errors.prototype.show = function() {
+  this.error_div().show();
+};

data/src/form.js

@@ -0,0 +1,111 @@
+
+AjaxResource.Form = function(form, options) {
+  var self = this;
+
+  this._form = jQuery(form);
+  this._error_panel = new AjaxResource.Errors(form);
+
+  if (typeof options === "undefined") {
+    options = {};
+  }
+
+  if (typeof options.model !== "undefined") {
+    this._model = options.model;
+  } else {
+    throw("Must specify model");
+  }
+
+  this._on_save = options.on_save;
+
+  this._semaphore = new AjaxResource.Semaphore();
+
+  this.submit_button().bind("click", function(event) {
+    event.preventDefault();
+    self.submit();
+  });
+};
+
+AjaxResource.Form.prototype.form = function() {
+  return this._form;
+};
+
+AjaxResource.Form.prototype.submit_button = function() {
+  return this.form().find(":submit");
+};
+
+AjaxResource.Form.prototype.error_panel = function(){ 
+  return this._error_panel;
+}
+
+AjaxResource.Form.prototype.fetch_model = function() {
+  if (jQuery.isFunction(this._model)) {
+    return this._model();
+  } else { 
+    return this._model;
+  }
+};
+
+AjaxResource.Form.prototype.semaphore = function() {
+  return this._semaphore;
+};
+
+AjaxResource.Form.prototype.on_save = function(model) {
+  if (typeof this._on_save !== "undefined") {
+    this._on_save(model);
+  } else {
+    // do nothing since no on_save callback was specified
+  }
+};
+
+AjaxResource.Form.prototype.parse_fields = function() {
+  var parsed_attributes = {};
+  jQuery(this.form()).find(":input").each(function() {
+    var regex = '(.*)\\[(.*)\\]';
+    var match = new RegExp(regex).exec(jQuery(this).attr("name"));
+    if (match !== null) {
+      var resource_name = match[1];
+      var attr_name = match[2];
+
+      // initialize the hash for the resource if not present yet
+      if (typeof parsed_attributes[resource_name] === "undefined") {
+	parsed_attributes[resource_name] = {};
+      }
+
+      parsed_attributes[resource_name][attr_name] = jQuery(this).attr("value");
+    } else {
+      // input field name does not match the foo[bar] format so ignoring
+    }
+  });
+
+  return parsed_attributes;
+};
+
+AjaxResource.Form.prototype.submit = function() {
+  var self = this;
+  if (this.semaphore().available()) {
+    var model = this.fetch_model();
+
+    // update the model from the attributes within the form
+    model.parse_json(this.parse_fields());
+
+    model.save(function(saved_model) {
+      if (saved_model.valid()) {
+	// if the model is valid, clear error_panel and execute the on_saved callback
+
+	self.error_panel().clear();
+	self.on_save(saved_model);
+      } else {
+	// if returned model contained error_panel, report them
+	self.error_panel().set(saved_model.errors());
+      }
+
+      // the request was handled, decrease the semaphore
+      self.semaphore().dec();
+    });
+
+    // just initiated request, increment semaphore to prevent further submissions
+    this.semaphore().inc();
+  } else {
+    // do nothing if semaphore is not available
+  }
+};

data/src/init.js

@@ -0,0 +1,3 @@
+var AjaxResource = function() {
+  return {};
+}();

data/src/routing.js

@@ -0,0 +1,41 @@
+
+/*
+ * Creates a new routing object. 
+ *
+ * Following options are required:
+ *
+ *  - controller: the name of the controller to use for routing.
+ *
+ * Following options are available:
+ *
+ *  - prefix: prefix to use by the route. By default is ''
+ */
+AjaxResource.Routing = function(spec) {
+  if (typeof spec.controller !== "undefined") {
+    this._controller_name = spec.controller;
+  } else {
+    throw "Must specify controller to use";
+  }
+
+  if (typeof spec.prefix !== "undefined") {
+    this._prefix = spec.prefix;
+  } else {
+    this._prefix = '';
+  }
+};
+
+AjaxResource.Routing.prototype.controller_name = function() {
+  return this._controller_name;
+};
+
+AjaxResource.Routing.prototype.prefix = function() {
+  return this._prefix;
+};
+
+AjaxResource.Routing.prototype.collection_path = function() {
+  return this.prefix() + '/' + this.controller_name();
+};
+
+AjaxResource.Routing.prototype.member_path = function(identifier) {
+  return this.prefix() + '/' + this.controller_name() + '/' + identifier;
+};

data/src/semaphore.js

@@ -0,0 +1,49 @@
+
+AjaxResource.Semaphore = function(options) {
+  if (typeof options === "undefined") {
+    options = {};
+  }
+
+  this._value = 0;
+
+  this._on_available = options.on_available;
+  this._on_unavailable = options.on_unavailable;
+};
+
+AjaxResource.Semaphore.prototype.dec = function() {
+  if (this._value > 0) {
+    this._value -= 1;
+
+    if (this.available()) {
+      this.on_available();
+    } 
+
+  } else {
+    // do nothing since value should not go below zero
+  }
+};
+
+AjaxResource.Semaphore.prototype.inc = function() {
+  var was_available = this.available();
+  this._value += 1;
+
+  if (was_available && !this.available()) {
+    this.on_unavailable();
+  }
+};
+
+AjaxResource.Semaphore.prototype.on_available = function() {
+  if (typeof this._on_available !== "undefined") {
+    this._on_available();
+  }
+};
+
+AjaxResource.Semaphore.prototype.on_unavailable = function() {
+  if (typeof this._on_unavailable !== "undefined") {
+    this._on_unavailable();
+  }
+};
+
+AjaxResource.Semaphore.prototype.available = function() {
+  return this._value === 0;
+};

data/src/view.js

@@ -0,0 +1,24 @@
+
+AjaxResource.View = function() { };
+
+AjaxResource.View.prototype.default_view = function() {
+  return this.resource_name() + ' (id: '+this.id()+')';
+};
+
+AjaxResource.View.prototype.set_custom = function(html) {
+  if (html !== null) {
+    this._html = html;
+  } else {
+    // if null, delete the entry, dropping back to default view
+    delete this._html;
+  }
+};
+
+AjaxResource.View.prototype.html = function() {
+  if (typeof this._html !== "undefined") {
+    return this._html;
+  } else {
+    // fall back to default view
+    return this.default_view();
+  }
+};

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ratnikov-ajax_resource
 version: !ruby/object:Gem::Version 
-  version: "0.02"
+  version: "0.03"
 platform: ruby
 authors: 
 - Dmitry Ratnikov
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-23 00:00:00 -08:00
+date: 2009-02-27 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,9 +31,16 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- build/ajax_resource-min.js
-- build/ajax_resource-src.js
 - tasks/ajax_resource.rb
+- jake.yml
+- src/init.js
+- src/view.js
+- src/attribute_mod.js
+- src/routing.js
+- src/base.js
+- src/semaphore.js
+- src/errors.js
+- src/form.js
 has_rdoc: false
 homepage: http://github.com/ratnikov/ajax_resource/tree/master
 post_install_message: