paloma 4.2.1 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c6d90c6346ffaca96320b8924a984d7b4a09d26b
-  data.tar.gz: d77644a771b84cfbb6e55ded22be99a7a930ac90
+SHA256:
+  metadata.gz: 4ee7609f0466009c6a9b25ec20036d427680b2843a709127d87b7a33e8c8e335
+  data.tar.gz: 4f6b2dc1090af53a981621caeade5fb21b11dd1ab3616b9a017cf194928372b9
 SHA512:
-  metadata.gz: ebc6f8eafd2f25d3983ee8c253be793da6e2736deebe61fa887a28e9d71250b677f00d74d571f51bed4ddd9af72ebe1aad9c4d4fa97071c0a6572569ff7d5a22
-  data.tar.gz: 67753deb514e0615089d462cf86130ea85c29b1b23074b3940f7a165d7b3ba38395dc048702c1ebbad7b1cb72305cd800efdbb9579ee0144cd34bb952d202056
+  metadata.gz: 5667955b863d020b0d86df40f0461900745e76b4f664ca26352bdabe3ea9f6170a3ac70bc1a986e38517cd1aa1e917530608cc0bb8a6f4aa55d48fbba323145e
+  data.tar.gz: ea1a99055633259a9806e773bd471f70068f753c84ba4603353074bf9bc570e5a825ea6c99cd1f137f8fee654855de45c49692e85148ceb41903f398568dfece

data/app/views/paloma/_hook.html.erb

@@ -1,25 +1,22 @@
 <% id = "#{Time.now.to_i}#{(rand * 1000).ceil}" %>
 
-<div class="js-paloma-hook" data-id="<%= id %>">
+<div class="js-paloma-hook" data-palomaid="<%= id %>">
   <script type="text/javascript">
     (function(){
-      // Do not continue if Paloma not found.
-      if (window['Paloma'] === undefined) {
-        return true;
-      }
 
+      if ( !window['Paloma'] ) return true;
       Paloma.env = '<%= Rails.env %>';
 
-      // Remove any callback details if any
-      $('.js-paloma-hook[data-id!=' + <%= id %> + ']').remove();
-
-      var request = <%= request.to_json.html_safe %>;
+      var id = "<%= id %>",
+          request = <%= request.to_json.html_safe %>;
 
       Paloma.engine.setRequest({
-        id: "<%= id %>",
-        resource: request['resource'],
-        action: request['action'],
-        params: request['params']});
+        id: id,
+        resource: request.resource,
+        action: request.action,
+        params: request.params
+      });
+
     })();
   </script>
 </div>

data/lib/paloma/action_controller_extension.rb

@@ -9,9 +9,7 @@ module Paloma
 
 
       base.module_eval do
-        prepend_view_path "#{Paloma.root}/app/views/"
-
-        before_filter :track_paloma_request
+        before_action :track_paloma_request
         helper_method :insert_paloma_hook
       end
     end
@@ -33,7 +31,7 @@ module Paloma
         scope[:only] = options[:only] if options[:only]
         scope[:except] = options[:except] if options[:except]
 
-        self.before_filter(
+        self.before_action(
           Proc.new {
             self.js path_or_options, options[:params]
           },
@@ -113,6 +111,8 @@ module Paloma
 
         self.paloma.resource ||= self.default_resource
         self.paloma.action ||= self.default_action
+
+        self.paloma.save_request_history
       end
 
 

data/lib/paloma/controller.rb

@@ -3,10 +3,13 @@ module Paloma
 
     attr_accessor :resource, :action, :params
 
+    if ::Rails.env.test?
+      attr_reader :request_history
+    end
 
 
     def initialize
-      self.clear_request
+      clear_request
     end
 
 
@@ -18,14 +21,20 @@ module Paloma
       true
     end
 
+    def save_request_history
+      if ::Rails.env.test?
+        @request_history ||= []
+        @request_history.push(self.request)
+      end
+    end
 
     def request
-      {:resource => self.resource, :action => self.action, :params => self.params}
+      { resource: resource, action: action, params: params }
     end
 
 
     def has_request?
-      self.resource.present? && self.action.present?
+      resource.present? && action.present?
     end
 
 
@@ -35,4 +44,4 @@ module Paloma
 
 
   end
-end
+end

data/lib/paloma/test_helper.rb

@@ -0,0 +1,7 @@
+module Paloma
+  module TestHelper
+    def js_params
+      @js_params ||= @controller.send(:paloma).request_history.last[:params]
+    end
+  end
+end

data/vendor/assets/javascripts/paloma/base_controller.js

@@ -0,0 +1,8 @@
+Paloma.BaseController = function(params){
+  this.params = params;
+};
+
+Paloma.BaseController.prototype = {
+  before: []
+};
+

data/vendor/assets/javascripts/paloma/before_callback_performer.js

@@ -0,0 +1,69 @@
+Paloma.BeforeCallbackPerformer = function(controller){
+  this.controller = controller;
+  this.entries = controller.before || [];
+  this.action = null;
+};
+
+Paloma.BeforeCallbackPerformer.prototype = {
+
+  perform: function(action){
+    this.action = action;
+    this._executeCallbacks();
+  },
+
+  _executeCallbacks: function(){
+    for (var i = 0, n = this._callbacks().length; i < n; i++)
+      this._executeCallback( this._callbacks()[i] );
+  },
+
+  _executeCallback: function(name){
+    var callback = this.controller[name];
+    if (callback) callback.call(this.controller);
+  },
+
+  _callbacks: function(){
+    if (this._callbackList) return this._callbackList;
+
+    this._callbackList = [];
+
+    for (var i = 0, n = this.entries.length; i < n; i++){
+      var entry = this.entries[i];
+
+      this._callbackList =
+        this._callbackList.concat( this._getCallbacksIfForAction(entry) );
+    }
+
+    return this._callbackList;
+  },
+
+  _getCallbacksIfForAction: function(entry){
+    var parsedEntry = this._parseEntry(entry);
+
+    if (
+      this._actionIsOn(parsedEntry.actions) ||
+      this._allIsOn(parsedEntry.actions)
+    )
+      return parsedEntry.callbacks;
+
+    return [];
+  },
+
+  _actionIsOn: function(actions){
+    return actions.indexOf(this.action) != -1;
+  },
+
+  _allIsOn: function(actions){
+    return actions.indexOf('all') != -1;
+  },
+
+  _parseEntry: function(entry){
+    var parts = entry.split('->'),
+        data = {actions: [], callbacks: []};
+
+    if (parts[0]) data.actions = parts[0].trim().split(' ');
+    if (parts[1]) data.callbacks = parts[1].trim().split(' ');
+
+    return data;
+  }
+
+};

data/vendor/assets/javascripts/paloma/controller_builder.js

@@ -0,0 +1,36 @@
+Paloma.ControllerBuilder = function(classFactory){
+  this.classFactory = classFactory;
+  this.options = {};
+};
+
+Paloma.ControllerBuilder.prototype = {
+
+  build: function(options){
+    this.options = options;
+
+    var ControllerClass = this._controllerClass();
+    if ( !ControllerClass ) return null;
+
+    var controller = new ControllerClass( this._buildParams() );
+
+    controller.controller = this.options.controller;
+    controller.action = this.options.action;
+
+    return controller;
+  },
+
+  _controllerClass: function(){
+    return this.classFactory.get( this.options.controller );
+  },
+
+  _buildParams: function(){
+    var params = {};
+
+    for (var k in this.options.params)
+      if (this.options.params.hasOwnProperty(k))
+        params[k] = this.options.params[k];
+
+    return params;
+  }
+
+};

data/vendor/assets/javascripts/paloma/controller_class_factory.js

@@ -0,0 +1,62 @@
+Paloma.ControllerClassFactory = function(){
+  this._controllers = {};
+  this._inheritanceSymbol = '<';
+};
+
+Paloma.ControllerClassFactory.prototype = {
+
+  make: function(controllerAndParent, prototype){
+    var parts = this._extractParts(controllerAndParent),
+        controller = this._getOrCreate( parts.controller );
+
+    this._updatePrototype(controller, prototype);
+    this._updateParent(controller, parts.parent);
+
+    return controller;
+  },
+
+  get: function(name){
+    return this._controllers[name] || null;
+  },
+
+  _updateParent: function(controller, parent){
+    if (!parent) return;
+
+    var parentClass = this.get(parent);
+    if (parentClass) controller.prototype = Object.create(parentClass.prototype, controller.prototype);
+  },
+
+  _updatePrototype: function(controller, newPrototype){
+    for (var k in newPrototype)
+      if (newPrototype.hasOwnProperty(k))
+        controller.prototype[k] = newPrototype[k];
+  },
+
+  _getOrCreate: function(name){
+    return this.get(name) || this._create(name);
+  },
+
+  _create: function(name){
+    var controller = function(params){
+      Paloma.BaseController.call(this, params);
+    };
+
+    controller.prototype = Object.create(Paloma.BaseController.prototype);
+    controller.prototype.constructor = controller;
+
+    this._controllers[name] = controller;
+    return controller;
+  },
+
+  _extractParts: function(controllerAndParent){
+    var parts = controllerAndParent.split( this._inheritanceSymbol );
+
+    var controller = parts[0].trim(),
+        parent = parts[1];
+
+    if (parent) parent = parent.trim();
+
+    return {controller: controller, parent: parent};
+  }
+
+};

data/vendor/assets/javascripts/paloma/engine.js

@@ -1,71 +1,77 @@
-(function(Paloma){
+Paloma.Engine = function(controllerBuilder){
+  this.controllerBuilder = controllerBuilder;
+  this._clearRequest();
+};
 
-  var Engine = function(config){
-    this.factory = config.factory;
-    this._request = null;
-  };
+Paloma.Engine.prototype = {
 
-  Engine.prototype.start = function(){
-    // Do not execute if there is no request available.
-    if ( !this._request ) return;
+  setRequest: function(options){
+    this._request = {
+      id: options.id,
+      controller: options.resource,
+      action: options.action,
+      params: options.params,
+      executed: false
+    };
+  },
 
-    // Do not execute if already executed.
-    //
-    // This happens when using turbolinks,
-    // if a page using js(false) is rendered
-    // after a page with executed js, then the
-    // previous js will be executed again.
-    if ( this._request.executed ) return;
+  hasRequest: function(){
+    return this._request != null;
+  },
 
-    var resource = this._request['controller'],
-        Controller = this.factory.get(resource);
+  lastRequest: function(){
+    return this._lastRequest = this._lastRequest || {executed: false};
+  },
 
-    if (!Controller){
-      return Paloma.warn('Paloma: undefined controller -> ' + resource);
-    }
+  start: function(){
+    if ( this._shouldStop() ) return;
 
-    var controller = new Controller( this._request['params'] ),
-        action = this._request['action'],
-        params = this._request['params'];
+    this._logRequest();
+    this._lastRequest = this._request;
 
-    if (!controller[action]){
-      return Paloma.warn('Paloma: undefined action <' + action +
-        '> for <' + resource + '> controller');
-    }
+    this._executeControllerAction();
+    this._clearRequest();
+  },
 
+  _executeControllerAction: function(){
+    var controller = this._buildController();
+    if (!controller) return;
 
-    Paloma.log('Paloma: Execute ' + resource + '#' + action + ' with');
-    Paloma.log(params);
+    var callbackPerformer = new Paloma.BeforeCallbackPerformer(controller);
+    callbackPerformer.perform( this._request.action );
 
-    controller[ this._request['action'] ]();
+    var method = controller[ this._request.action ];
+    if (method) method.call(controller);
 
-    this._request.executed = true;
-  };
+    this._lastRequest.executed = true;
+  },
 
+  _buildController: function(){
+    return this.controllerBuilder.build({
+      controller: this._request.controller,
+      action: this._request.action,
+      params: this._request.params
+    });
+  },
 
-  //
-  // options:
-  //  resource
-  //  action
-  //  params
-  //  id
-  //
-  Engine.prototype.setRequest = function(options){
-    this._request = {
-      id: options.id,
-      controller: options.resource,
-      action: options.action,
-      params: options.params,
-      executed: false
-    };
-  };
+  _shouldStop: function(){
+    if ( !this.hasRequest() ) return true;
+    if ( this._request.id == this.lastRequest().id ) return true;
 
+    return false;
+  },
 
-  Engine.prototype.getRequest = function(key){
-    return (!key ? this._request : this._request[key]);
-  };
+  _logRequest: function(){
+    Paloma.log(
+      'Paloma: ' + this._request.controller + '#' +
+      this._request.action + ' with params:'
+    );
 
+    Paloma.log( this._request.params );
+  },
 
-  Paloma.Engine = Engine;
+  _clearRequest: function(){
+    this._request = null;
+  }
 
-})(window.Paloma);
+};

data/vendor/assets/javascripts/paloma/index.js

@@ -1,6 +1,7 @@
 //= require ./init.js
-//= require ./router.js
-//= require ./controller.js
-//= require ./controller_factory.js
+//= require ./base_controller.js
+//= require ./controller_class_factory.js
+//= require ./before_callback_performer.js
+//= require ./controller_builder.js
 //= require ./engine.js
-//= require ./paloma.js
+//= require ./paloma.js