emerald-rails 0.0.2 → 0.0.3

data/README.md

@@ -1,6 +1,8 @@
-# Emerald::Rails
+# emerald-rails gem
 
-TODO: Write a gem description
+This gem integrates
+[Emerald.js](https://github.com/kurko/emerald.js)
+with your Rails application automagically.
 
 ## Installation
 
@@ -12,13 +14,15 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
+Then add this line to your Javascript manifest file (`application.js`)
+before your own scripts:
 
-    $ gem install emerald-rails
+    //= require emerald
 
 ## Usage
 
-TODO: Write usage instructions here
+For instructions on how to use Emerald.js, visit its page,
+[https://github.com/kurko/emerald.js](https://github.com/kurko/emerald.js).
 
 ## Contributing
 
@@ -27,3 +31,7 @@ TODO: Write usage instructions here
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+##License
+
+This software is released under the MIT License.

data/Rakefile

@@ -4,6 +4,10 @@ desc "Downloads the latest stable Javascript file"
 task :stable do
   stable_url = "https://raw.github.com/kurko/emerald.js/master/build/stable.js"
   assets_dir = "app/assets/javascript"
-  cmd = "( cd #{assets_dir} > /dev/null ; curl -O #{stable_url} ; )"
+
+  cmd =  "cd #{assets_dir}"
+  cmd << " && curl -O #{stable_url}"
+  cmd << " && mv stable.js emerald.js"
+  cmd << " && cp emerald.js ../../../lib/generators/emerald/install/templates/emerald.js"
   exec cmd
 end

data/emerald-rails.gemspec

@@ -5,7 +5,7 @@ require 'emerald-rails/version'
 
 Gem::Specification.new do |gem|
   gem.name          = "emerald-rails"
-  gem.version       = Emerald::Rails::VERSION
+  gem.version       = EmeraldRails::VERSION
   gem.authors       = ["Alexandre de Oliveira"]
   gem.email         = ["chavedomundo@gmail.com"]
   gem.description   = %q{Brings Emerald.js into your Rails app automagically}

data/lib/emerald-rails/version.rb

@@ -1,5 +1,3 @@
-module Emerald
-  module Rails
-    VERSION = "0.0.2"
-  end
+module EmeraldRails
+  VERSION = "0.0.3"
 end

data/lib/emerald-rails.rb

@@ -1,8 +1,6 @@
 require "emerald-rails/version"
 
-module Emerald
-  module Rails
-    class Engine < ::Rails::Engine
-    end
+module EmeraldRails
+  class Engine < ::Rails::Engine
   end
 end

data/lib/generators/emerald/install/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Copies emerald.js to app/assets/javascripts/ directory. Recommended for
+    whom is going to edit or debug the code file.
+
+Example:
+    rails generate emerald:install
+
+    This will create:
+        app/assets/javascripts/emerald.js

data/lib/generators/emerald/install/install_generator.rb

@@ -0,0 +1,11 @@
+module Emerald
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_emerald
+        copy_file "emerald.js", "app/assets/javascripts/emerald.js"
+      end
+    end
+  end
+end

data/lib/generators/emerald/install/templates/emerald.js

@@ -0,0 +1,308 @@
+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;
+  var _this = this;
+  _this.actions = actions;
+
+  if (_this.actions.initialize) {
+    $(document).ready(function(){
+      _this.actions.initialize();
+    });
+  }
+
+  // initializes this View's elements
+  $(document).ready(function() {
+    Emerald.ActionView.Elements.bindToView();
+    Emerald.ActionView.Events.bindElementToViewAction(_this.actions);
+  });
+
+  // defines the method of the new view instance
+  for (action in actions) {
+    instance[action] = actions[action];
+  }
+
+  return instance;
+}
+
+Emerald.ActionView.Elements.bindToView = function() {
+  $("[data-view-action]").each(function(index, viewElement){
+    var elementsView = $(this).closest("[data-view]").data("view");
+    viewElement.setAttribute('extendsView', elementsView);
+  });
+}
+
+Emerald.ActionView.Elements.dataFieldsSelector = function(){
+  var selector = "";
+  selector+= "input[type='text'], ";
+  selector+= "input[type='radio']:checked";
+  return selector;
+}
+
+Emerald.ActionView.Elements.dataFields = function(){
+  var selectors = this.dataFieldsSelector();
+  return $(selectors);
+}
+
+Emerald.ActionView.Events.bindElementToViewAction = function(viewActions) {
+  $('[data-view-action]').each(function(index, viewElement){
+    var _event = viewElement.getAttribute('data-event');
+    var _viewAction = viewElement.getAttribute('data-view-action');
+
+    _event = Emerald.ActionView.Events.defineDefaultEvent(viewElement, _event);
+
+    var dataFieldSelector = "";
+    dataFieldSelector+= "input[type='text'][data-view-action='"+_viewAction+"'], ";
+    dataFieldSelector+= "input[type='radio'][data-view-action='"+_viewAction+"']:checked";
+
+    $(this).on(_event, function(e){
+      var dataFields = $(dataFieldSelector);
+      viewActions[_viewAction](e, dataFields);
+    });
+  });
+}
+
+Emerald.ActionView.Events.defineDefaultEvent = function(domElement, _event) {
+  if (_event)
+    return _event;
+  else
+    return 'keyup';
+}
+
+Emerald.Controller.extend = function(actions){
+  var instance = new Object;
+  var _this = this;
+  _this.actions = actions;
+
+  // defines the method of the new controller instance
+  for (action in actions) {
+    instance[action] = actions[action];
+  }
+
+  instance.params = function(domElements){
+    var params = new Object;
+
+    for (i = 0; i < domElements.length; i++) {
+      var element = domElements[i];
+      params[element.name] = element.value;
+    }
+
+    return params;
+  }
+
+  instance.persistView = true;
+
+  instance.persistViewCallback = function(JSON, observerObject) {
+    if (!observerObject)
+      observerObject = Emerald.Model.Observer;
+
+    if (this.persistView)
+      observerObject.update(JSON);
+
+    return true;
+  }
+
+  return instance;
+}
+
+Emerald.Model.extend = function(properties) {
+  var instance = new Object;
+  var _this = this;
+  this.properties = properties;
+
+  // defines the method of the new view instance
+  for (property in properties) {
+    instance[property] = properties[property];
+  }
+
+  // runs initialization on startup
+  if (this.properties.initialize) {
+    $(document).ready(function(){ _this.properties.initialize(); });
+  }
+
+  // defines attrAccessible fields
+  Emerald.Model.Attributes.initAttrAccessible(instance, properties.attrAccessible);
+
+  instance.get = function(attribute) {
+    if (_this.properties[attribute])
+      return _this.properties[attribute];
+    else
+      return null;
+  }
+
+  instance.save = function(data, andCallbackController, persistenceObject) {
+    if (!persistenceObject)
+      persistenceObject = Emerald.Persistence;
+
+    // TODO verify that `data` fields are the ones listed in this.attrAccessible
+    return new persistenceObject(this).save(data, andCallbackController);
+  }
+
+  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;
+    }
+  }
+
+  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
+// call is made, the JSON response should be passed in to
+//
+//   observer.update(response)
+//
+// It will update all the elements in the document with the JSON data.
+//
+// Example:
+//
+//   JSON: {"item":{"name":"My item", "price":"US$40,00"}}
+//
+//   Document:
+//
+//     <span data-observe="item.name"></span>
+//     <span data-observe="item.price"></span>
+//
+// The first HTML element will be updated with "My item" automatically and
+// the second, price, with "US$40,00".
+//
+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
+        return false;
+      });
+
+      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);
+  }
+
+  return instance;
+}
+
+
+Emerald.Persistence.save = function(model, callbackController) {
+  var instance = function() {
+    this.initialize = function(model) {
+      this.model = model;
+      return this;
+    }
+
+    this.save = function(model, controller) {
+      var attributes = this.model.attributes();
+
+      if (!attributes)
+        return false;
+
+      var _controller = controller;
+      var requestSpecs = Emerald.Persistence.saveRequest(model);
+
+      $.ajax(requestSpecs).done(function(jsonResponse) {
+        if (_controller)
+          _controller.persistViewCallback(jsonResponse);
+      }).fail(function(jsonResponse) {
+        if (_controller)
+          _controller.failedAjaxResponseCallback(jsonResponse);
+      });
+
+      return requestSpecs;
+    }
+
+    return this;
+  }
+
+  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";
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: emerald-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -39,10 +39,13 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- app/assets/javascript/stable.js
+- app/assets/javascript/emerald.js
 - emerald-rails.gemspec
 - lib/emerald-rails.rb
 - lib/emerald-rails/version.rb
+- lib/generators/emerald/install/USAGE
+- lib/generators/emerald/install/install_generator.rb
+- lib/generators/emerald/install/templates/emerald.js
 homepage: http://github.com/kurko/emerald-rails
 licenses: []
 post_install_message: