emerald-rails 0.0.1 → 0.0.2

data/app/assets/javascript/stable.js

@@ -1,12 +1,14 @@
 var Emerald = {
+  Version: "0.0.1",
   Core: {},
+  Controller: {},
   ActionView: {
     Elements: {},
     Events:   {}
-  }
+  },
+  Model: {}
 };
 
-
 Emerald.ActionView.extend = function(actions){
   // instance object to be returned
   var instance = new Object;
@@ -77,108 +79,119 @@ Emerald.ActionView.Events.defineDefaultEvent = function(domElement, _event) {
     return 'keyup';
 }
 
-function emeraldActionController(){
-  this.extend = function(properties){
-    var _this = this;
-    _this.properties = properties;
+Emerald.Controller.extend = function(actions){
+  var instance = new Object;
+  var _this = this;
+  _this.actions = actions;
 
-    return new emeraldActionControllerInstance(properties);
+  // defines the method of the new controller instance
+  for (action in actions) {
+    instance[action] = actions[action];
   }
-}
 
-function emeraldActionControllerInstance(properties){
-  var singleton = function() {
-    this.self = function(properties){
-      this.properties = properties;
-
-      for (propertyName in properties) {
-        if (!this[propertyName])
-          this[propertyName] = properties[propertyName];
-      }
+  instance.params = function(domElements){
+    var params = new Object;
 
-      return this;
+    for (i = 0; i < domElements.length; i++) {
+      var element = domElements[i];
+      params[element.name] = element.value;
     }
 
-    this.params = function(domElements){
-      var params = new Object;
+    return params;
+  }
 
-      for (i = 0; i < domElements.length; i++) {
-        var element = domElements[i];
-        params[element.name] = element.value;
-      }
+  instance.persistView = true;
 
-      return params;
-    }
+  instance.persistViewCallback = function(JSON, observerObject) {
+    if (!observerObject)
+      observerObject = Emerald.Model.Observer;
 
-    this.persistView = true;
+    if (this.persistView)
+      observerObject.update(JSON);
 
-    this.persistViewCallback = function(JSON) {
-      debugger;
-      if (this.persistView)
-        Emerald.modelObserver.update(JSON);
-      return true;
-    }
+    return true;
   }
 
-  var instance = new singleton().self(properties);
   return instance;
 }
 
-function emeraldActiveModel(){
-  this.extend = function(properties){
-    var _this = this;
-    _this.properties = properties;
+Emerald.Model.extend = function(properties) {
+  var instance = new Object;
+  var _this = this;
+  this.properties = properties;
 
-    return new emeraldActiveModelInstance(properties);
+  // defines the method of the new view instance
+  for (property in properties) {
+    instance[property] = properties[property];
   }
-}
 
-function emeraldActiveModelInstance(properties){
-  var singleton = function() {
-    this.self = function(properties){
-      this.properties = properties;
-      return this;
-    }
+  // runs initialization on startup
+  if (this.properties.initialize) {
+    $(document).ready(function(){ _this.properties.initialize(); });
+  }
 
-    this.attributes = function() {
-      attributesValues = {};
-      if (this.properties.attrAccessible) {
-        var attributes = this.properties.attrAccessible;
-        for (attribute in attributes) {
-          var attributeName = attributes[attribute];
-          if (this[attributeName])
-            attributesValues[attributeName] = this[attributeName];
-        }
-      }
-      return attributesValues;
-    }
+  // defines attrAccessible fields
+  Emerald.Model.Attributes.initAttrAccessible(instance, properties.attrAccessible);
 
-    this.route = function() { return this.properties.route; }
+  instance.get = function(attribute) {
+    if (_this.properties[attribute])
+      return _this.properties[attribute];
+    else
+      return null;
+  }
 
-    this.get = function(attribute) {
-      if (this.properties[attribute])
-        return this.properties[attribute];
-      else
-        return "none";
-    }
+  instance.save = function(data, andCallbackController, persistenceObject) {
+    if (!persistenceObject)
+      persistenceObject = Emerald.Persistence;
 
-    this.save = function(data, andCallbackController) {
-      // TODO verify that `data` fields are the ones listed in this.attrAccessible
-      debugger;
-      var persistence = new emeraldPersistence(this).save(data, andCallbackController);
-      return persistence;
-    }
+    // TODO verify that `data` fields are the ones listed in this.attrAccessible
+    return new persistenceObject(this).save(data, andCallbackController);
   }
 
-  function createAccessibleAttributes(singleton, attributes) {
-    for (attribute in attributes) {
-      singleton.prototype[attributes[attribute]] = null;
+  return instance;
+}
+
+Emerald.Model.Attributes = {}
+Emerald.Model.Attributes.initAttrAccessible = function(model, attrAccessible) {
+  model.attributes = function() { return false; }
+  if (!attrAccessible)
+    return false;
+
+  var attributes = attrAccessible;
+  for (attribute in attributes) {
+    var attributeName = attributes[attribute];
+
+    // model method
+    if (!model[attributeName])
+      model[attributeName] = "";
+
+    // attributes hash
+    model.attributes = function(attributeName) {
+      var attributes = Emerald.Model.Attributes.getAttributes(model);
+
+      if (attributeName)
+        return attributes[attributeName];
+      else
+        return attributes;
     }
   }
 
-  var instance = new singleton().self(properties);
-  createAccessibleAttributes(singleton, properties.attrAccessible);
-  return instance;
+  return true;
+}
+
+Emerald.Model.Attributes.getAttributes = function(model) {
+  var attributesValues = {}
+  if (!model.attrAccessible)
+    return attributesValues;
+
+  var attributes = model.attrAccessible;
+  for (attribute in attributes) {
+    var attributeName = attributes[attribute];
+
+    // model method
+    attributesValues[attributeName] = model[attributeName];
+  }
+  return attributesValues;
 }
 
 // Observes the whole document for [data-observe] elements. Whenever an Ajax
@@ -200,93 +213,96 @@ function emeraldActiveModelInstance(properties){
 // The first HTML element will be updated with "My item" automatically and
 // the second, price, with "US$40,00".
 //
-function modelObserver(){}
-
-Emerald.modelObserver = new modelObserver();
-
-modelObserver.prototype.update = function(jsonData){
-  $("[data-observe]").each(function(index){
-    var observing = $(this).data("observe");
-    var observedResources = observing.split(".");
-
-    var currentValue = jsonData;
-    $.each(observedResources, function(index, value){
-      if (currentValue[value] || typeof currentValue[value] == "string")
+Emerald.Model.Observer = {
+  update: function(jsonData){
+    $("[data-observe]").each(function(index){
+      var observing = $(this).data("observe");
+      var observedResources = observing.split(".");
+
+      var currentValue = jsonData;
+      $.each(observedResources, function(index, value){
+        if (currentValue[value] || typeof currentValue[value] == "string")
         currentValue = currentValue[value];
-      else
+        else
         return false;
+      });
+
+      switch (typeof currentValue) {
+        case "number":
+        case "bool":
+        case "string":
+          $(this).html(currentValue);
+          return true;
+      }
+
     });
 
-    switch (typeof currentValue) {
-      case "number":
-      case "bool":
-      case "string":
-        $(this).html(currentValue);
-        return true;
-    }
+    return true;
+  }
+}
 
-  });
-};
+Emerald.Persistence = function(model, persistenceObject) {
+  var instance = new Object;
+
+  if (!persistenceObject)
+    persistenceObject = Emerald.Persistence;
+
+  instance.save = function(model, callbackController){
+    return persistenceObject.save(model, callbackController);
+  }
 
-function emeraldPersistence(model){
-  var singleton = function() {
-    this.initialize = function(model, _class) {
+  return instance;
+}
+
+
+Emerald.Persistence.save = function(model, callbackController) {
+  var instance = function() {
+    this.initialize = function(model) {
       this.model = model;
-      this._class = _class;
       return this;
     }
 
-    this.save = function(data, callbackController){
-      return new this._class.PersistenceSave().save(data, callbackController);
-    }
-  }
+    this.save = function(model, controller) {
+      var attributes = this.model.attributes();
 
-  this.PersistenceSave = function() {
-    var singleton = function() {
-      this.initialize = function(model, _class) {
-        this.model = model;
-        this._class = _class;
-        return this;
-      }
+      if (!attributes)
+        return false;
 
-      this.save = function(data, controller) {
-        //var attributes = this.model.attributes();
-        var attributes = data;
-        var _controller = controller;
-
-        var requestSpecs = {
-          url: this.model.route(),
-          data: attributes,
-          type: this.requestType(attributes),
-          dataType: "json"
-        };
-
-        $.ajax(requestSpecs).done(function(JSON) {
-          debugger;
-          if (_controller)
-            _controller.persistViewCallback(JSON);
-        }).fail(function(response) {
-          // TODO handle errors
-          if (_controller)
-            _controller.persistViewCallback(JSON);
-        });
-
-        return requestSpecs;
-      }
+      var _controller = controller;
+      var requestSpecs = Emerald.Persistence.saveRequest(model);
 
-      this.requestType = function(attributes) {
-        if (attributes["id"])
-          return "PUT";
-        else
-          return "POST";
-      }
+      $.ajax(requestSpecs).done(function(jsonResponse) {
+        if (_controller)
+          _controller.persistViewCallback(jsonResponse);
+      }).fail(function(jsonResponse) {
+        if (_controller)
+          _controller.failedAjaxResponseCallback(jsonResponse);
+      });
+
+      return requestSpecs;
     }
 
-    var instance = new singleton().initialize(model, this);
-    return instance;
+    return this;
   }
 
-  var instance = new singleton().initialize(model, this);
-  return instance;
+  instance().initialize(model);
+  return instance().save(model, callbackController);
 }
 
+Emerald.Persistence.saveRequest = function(model) {
+  var attributes = model.attributes();
+
+  return {
+    url: model.route,
+    data: attributes,
+    type: Emerald.Persistence.saveRequestType(attributes),
+    dataType: "json"
+  }
+}
+
+Emerald.Persistence.saveRequestType = function(attributes) {
+  if (attributes["id"])
+    return "PUT";
+  else
+    return "POST";
+}

data/lib/emerald-rails/version.rb

@@ -1,5 +1,5 @@
 module Emerald
   module Rails
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: emerald-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-21 00:00:00.000000000 Z
+date: 2012-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties