emerald-rails 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in emerald-rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Alexandre de Oliveira
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Emerald::Rails
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'emerald-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install emerald-rails
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+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

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+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} ; )"
+  exec cmd
+end

data/app/assets/javascript/stable.js

@@ -0,0 +1,292 @@
+var Emerald = {
+  Core: {},
+  ActionView: {
+    Elements: {},
+    Events:   {}
+  }
+};
+
+
+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';
+}
+
+function emeraldActionController(){
+  this.extend = function(properties){
+    var _this = this;
+    _this.properties = properties;
+
+    return new emeraldActionControllerInstance(properties);
+  }
+}
+
+function emeraldActionControllerInstance(properties){
+  var singleton = function() {
+    this.self = function(properties){
+      this.properties = properties;
+
+      for (propertyName in properties) {
+        if (!this[propertyName])
+          this[propertyName] = properties[propertyName];
+      }
+
+      return this;
+    }
+
+    this.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;
+    }
+
+    this.persistView = true;
+
+    this.persistViewCallback = function(JSON) {
+      debugger;
+      if (this.persistView)
+        Emerald.modelObserver.update(JSON);
+      return true;
+    }
+  }
+
+  var instance = new singleton().self(properties);
+  return instance;
+}
+
+function emeraldActiveModel(){
+  this.extend = function(properties){
+    var _this = this;
+    _this.properties = properties;
+
+    return new emeraldActiveModelInstance(properties);
+  }
+}
+
+function emeraldActiveModelInstance(properties){
+  var singleton = function() {
+    this.self = function(properties){
+      this.properties = properties;
+      return this;
+    }
+
+    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;
+    }
+
+    this.route = function() { return this.properties.route; }
+
+    this.get = function(attribute) {
+      if (this.properties[attribute])
+        return this.properties[attribute];
+      else
+        return "none";
+    }
+
+    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;
+    }
+  }
+
+  function createAccessibleAttributes(singleton, attributes) {
+    for (attribute in attributes) {
+      singleton.prototype[attributes[attribute]] = null;
+    }
+  }
+
+  var instance = new singleton().self(properties);
+  createAccessibleAttributes(singleton, properties.attrAccessible);
+  return instance;
+}
+
+// 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".
+//
+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")
+        currentValue = currentValue[value];
+      else
+        return false;
+    });
+
+    switch (typeof currentValue) {
+      case "number":
+      case "bool":
+      case "string":
+        $(this).html(currentValue);
+        return true;
+    }
+
+  });
+};
+
+function emeraldPersistence(model){
+  var singleton = function() {
+    this.initialize = function(model, _class) {
+      this.model = model;
+      this._class = _class;
+      return this;
+    }
+
+    this.save = function(data, callbackController){
+      return new this._class.PersistenceSave().save(data, callbackController);
+    }
+  }
+
+  this.PersistenceSave = function() {
+    var singleton = function() {
+      this.initialize = function(model, _class) {
+        this.model = model;
+        this._class = _class;
+        return this;
+      }
+
+      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;
+      }
+
+      this.requestType = function(attributes) {
+        if (attributes["id"])
+          return "PUT";
+        else
+          return "POST";
+      }
+    }
+
+    var instance = new singleton().initialize(model, this);
+    return instance;
+  }
+
+  var instance = new singleton().initialize(model, this);
+  return instance;
+}
+

data/emerald-rails.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'emerald-rails/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "emerald-rails"
+  gem.version       = Emerald::Rails::VERSION
+  gem.authors       = ["Alexandre de Oliveira"]
+  gem.email         = ["chavedomundo@gmail.com"]
+  gem.description   = %q{Brings Emerald.js into your Rails app automagically}
+  gem.summary       = %q{This gem embed the latest Emerald.js stable version into a Rails app.}
+  gem.homepage      = "http://github.com/kurko/emerald-rails"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib", "app"]
+  gem.add_dependency "railties", "~> 3.1"
+end

data/lib/emerald-rails/version.rb

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

data/lib/emerald-rails.rb

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

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: emerald-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alexandre de Oliveira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Brings Emerald.js into your Rails app automagically
+email:
+- chavedomundo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascript/stable.js
+- emerald-rails.gemspec
+- lib/emerald-rails.rb
+- lib/emerald-rails/version.rb
+homepage: http://github.com/kurko/emerald-rails
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- app
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: This gem embed the latest Emerald.js stable version into a Rails app.
+test_files: []