paloma 1.2.6 → 2.0.0

data/spec/test_app/spec/javascripts/filters_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe 'Paloma.FilterScope', :type => :feature, :js => true do  
+  
+  shared_context 'paths-' do
+    let(:basic_action) { basic_action_bar_path }
+    let(:another_basic_action) { another_basic_action_bar_path }
+    let(:yet_another_basic_action) { yet_another_basic_action_bar_path}
+  end
+  
+  shared_context 'paths-Application' do
+    include_context 'paths-'
+  end
+  
+  shared_context 'paths-Namespaced' do
+    let(:basic_action) { basic_action_sample_namespace_baz_path }
+    let(:another_basic_action) { another_basic_action_sample_namespace_baz_path }
+    let(:yet_another_basic_action) { yet_another_basic_action_sample_namespace_baz_path }  
+  end
+    
+  
+  
+  shared_examples 'standard' do |options|
+    type = options[:type]
+    name = options[:name]
+    method = options[:method] || "##{type}"
+    scope = parse_scope options[:scope]
+    filter =  "#{scope}Standard #{name}"
+  
+    describe method do
+      it "executes filter #{type} callbacks for the passed actions" do
+        visit basic_action
+        page.evaluate_script("filtersExecuted.#{type}").should include filter
+      end
+
+      it "does not execute filter #{type} callbacks for other actions" do
+        visit yet_another_basic_action
+        page.evaluate_script("filtersExecuted.#{type}").should_not include filter
+      end
+    end
+  end
+  
+  
+  shared_examples 'all' do |options|
+    type = options[:type]
+    name = options[:name]
+    method = options[:method] || "##{type}_all"
+    scope = parse_scope options[:scope]
+    filter = "#{scope}#{name} All"
+
+    describe method do
+      it "executes filter #{type} callbacks on all actions" do
+        visit basic_action
+        page.evaluate_script("filtersExecuted.#{type}").should include filter
+      end      
+    end    
+  end
+  
+  
+  shared_examples 'except' do |options|
+    type = options[:type]
+    name = options[:name]
+    method = options[:method] || "#except_#{type}"
+    scope = parse_scope options[:scope]
+    filter = "#{scope}Except #{name}"
+    
+    describe method do
+      it "executes filter #{type} callback on all actions except for passed actions" do
+        visit another_basic_action
+        page.evaluate_script("filtersExecuted.#{type}").should include filter
+      end
+
+      it "does not execute filter #{type} callback on passed actions" do
+        visit basic_action
+        page.evaluate_script("filtersExecuted.#{type}").should_not include filter
+      end
+    end
+  end
+  
+  
+  shared_examples 'filter subtypes' do |options|
+    params = {:type => options[:type], 
+      :name => options[:type].titleize, 
+      :scope => options[:scope]}
+    
+    include_examples 'standard', params
+    include_examples 'all', params
+    include_examples 'except', params
+  end
+  
+  
+  shared_examples 'filters' do |scope|
+    context "when inside the scope of #{scope}" do
+      include_context "paths-#{scope}"
+    
+      def self.parse_scope scope
+        scope.blank? ? scope : "#{scope} "
+      end
+
+      # Before and After Filters
+      include_examples 'filter subtypes', {:type => 'before', :scope => scope}
+      include_examples 'filter subtypes', {:type => 'after', :scope => scope}
+      
+      # Around Filters
+      include_examples 'standard', {:name => 'Around', 
+        :type => 'before', 
+        :method => '#around', 
+        :scope => scope} 
+      
+      include_examples 'standard', {:name => 'Around',
+        :type => 'after', 
+        :method => '#around', 
+        :scope => scope}
+      
+      include_examples 'all', {:name => 'Around', 
+        :type => 'before', 
+        :method => '#around_all', 
+        :scope => scope}
+      
+      include_examples 'all', {:name => 'Around',
+        :type => 'after', 
+        :method => '#around_all',
+        :scope => scope}
+      
+      include_examples 'except', {:name => 'Around', 
+        :type => 'before', 
+        :method => '#except_around', 
+        :scope => scope}
+      
+      include_examples 'except', {:name => 'Around',
+        :type => 'after', 
+        :method => '#except_around', 
+        :scope => scope}
+    end
+  end
+
+
+
+  shared_examples 'skip filters' do |type|
+    name = type.titleize
+    filter = "- Skip This #{name} Filter"
+
+    describe "#skip_#{type}_filter" do
+      context 'when not appended with #only or #expect' do
+        it "skips passed #{type} filters for all actions" do
+          visit basic_action_sample_namespace_baz_path
+          page.evaluate_script("filtersExecuted.#{type}").should_not include "All #{filter}"
+        end
+      end
+
+      context 'with #only' do
+        it "skips passed #{type} filters for actions passed on #only" do
+          visit another_basic_action_sample_namespace_baz_path
+          page.evaluate_script("filtersExecuted.#{type}").should_not include "Only #{filter}"
+        end
+
+        it "performs passed #{type} filters for actions not passed on #only" do
+          visit basic_action_sample_namespace_baz_path
+          page.evaluate_script("filtersExecuted.#{type}").should include "Only #{filter}"
+        end
+      end
+
+      context 'with #except' do
+        it "skips passed #{type} filters for actions not passed on #except" do
+          visit yet_another_basic_action_sample_namespace_baz_path
+          page.evaluate_script("filtersExecuted.#{type}").should_not include "Except #{filter}"
+        end
+
+        it "performs passed #{type} filters for actions passed on #except" do
+          visit another_basic_action_sample_namespace_baz_path
+          page.evaluate_script("filtersExecuted.#{type}").should include "Except #{filter}"
+        end
+      end
+    end  
+  end
+
+
+
+  # Testing starts here
+  include_examples 'filters', ''            # non-namespaced filters
+  include_examples 'filters', 'Namespaced'   # namespaced filters
+  include_examples 'filters', 'Application' # application-wide filters
+
+  #include_examples 'skip filters', 'before'
+  #include_examples 'skip filters', 'after'
+  #include_examples 'skip filters', 'around'
+end

data/spec/test_app/spec/javascripts/locals_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+
+describe 'Locals', :type => :feature, :js => true do
+
+  before do
+    visit basic_action_foo_path
+  end
+
+
+  describe '_l' do
+    it 'has access to local methods' do
+      page.evaluate_script('helperMethodValue').should be 100
+    end
+
+
+    it 'has access to local variables' do
+      page.evaluate_script('helperVariableValue').should be 99
+    end
+
+
+    it 'can override locals from its parent scope' do
+      page.evaluate_script('overriden').should eq 'Override!'
+    end
+  end
+
+end

data/spec/test_app/spec/javascripts/params_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe 'Callback params', :type => :feature, :js => true do
+  
+  shared_examples 'check params' do |params|
+    specify "callback_controller must be the callback's controller" do
+      page.evaluate_script('params.callback_controller').should eq params[:callback_controller]
+    end
+    
+    specify "callback_action must be the callback's action" do
+      page.evaluate_script('params.callback_action').should eq params[:callback_action]
+    end
+    
+    specify "callback_namespace must be callback's namespace" do
+      page.evaluate_script('params.callback_namespace').should eq params[:callback_namespace]
+    end
+    
+    specify "callback_controller_path must be callback's namespace and controller" do
+      page.evaluate_script('params.callback_controller_path').should eq params[:callback_controller_path]
+    end
+    
+    specify "controller must be request's controller" do
+      page.evaluate_script('params.controller').should eq params[:controller]
+    end
+    
+    specify "action must be request's action" do
+      page.evaluate_script('params.action').should eq params[:action]
+    end
+    
+    specify "namespace must be request's namespace" do
+      page.evaluate_script('params.namespace').should eq params[:namespace]
+    end
+    
+    specify "controller_path must be request's namespace and controller" do
+      page.evaluate_script('params.controller_path').should eq params[:controller_path]
+    end
+  end
+
+
+  context 'within a non-namespaced callback' do
+    before do
+      visit callback_from_another_action_foo_path
+    end
+    
+    include_examples('check params', {
+      :controller => 'foo',
+      :action => 'callback_from_another_action',
+      :namespace => '',
+      :controller_path => 'foo',
+      :callback_controller => 'foo',
+      :callback_action => 'basic_action',
+      :callback_namespace => '',
+      :callback_controller_path => 'foo'})
+  end
+  
+  
+  context 'within a namespaced callback' do
+    before do
+      visit callback_from_another_action_sample_namespace_baz_path
+    end
+    
+    include_examples('check params', {
+      :controller => 'baz',
+      :action => 'callback_from_another_action',
+      :namespace => 'sample_namespace',
+      :controller_path => 'sample_namespace/baz',
+      :callback_controller => 'baz',
+      :callback_action => 'basic_action',
+      :callback_namespace => 'sample_namespace',
+      :callback_controller_path => 'sample_namespace/baz'}) 
+  end
+  
+  
+  context 'with passed parameter' do
+    before do
+      visit different_params_bar_path
+    end
+    
+    context 'of type TrueClass or FalseClass' do
+      it 'has the boolean equivalent' do
+        page.evaluate_script("params['boolean'] == true").should be_true
+      end
+    end
+    
+    context 'of type Array' do
+      it 'has the array equivalent' do
+        page.evaluate_script("JSON.stringify(params['array']) == JSON.stringify([1, 2, 3])").should be_true
+      end
+    end
+    
+    context 'of type String' do
+      it 'has the string equivalent' do
+        page.evaluate_script("params['string'] == 'Banana'").should be_true
+      end
+    end
+    
+    context 'of type Fixnum' do
+      it 'has the number equivalent' do
+        page.evaluate_script("params['integer'] == 69").should be_true
+      end
+    end
+    
+    context 'of type Float' do
+      it 'has the number equivalent' do
+        page.evaluate_script("params['float'] == 3.1416").should be_true
+      end
+    end
+    
+    context 'of type Hash' do
+      it 'has the object equivalent' do
+        page.evaluate_script(
+          "JSON.stringify(params['hash']) == JSON.stringify({a : 'Hello', b : 'World'})").should be_true
+      end
+    end
+  end
+end

data/spec/test_app/spec/javascripts/skip_filters_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+
+describe 'Skip Filter', :type => :feature, :js => true do
+
+  def filters_executed type
+    page.evaluate_script("filtersExecuted.#{type}")
+  end
+
+
+  shared_examples 'skip_*_filter/s' do |execution, name|
+
+    describe "#skip_#{name}_filter/s" do
+      context "with no inclusion method called" do
+        it "skips the #{name} filters" do
+          visit basic_action_bar_path
+          filters_executed(execution).should_not include "Standard Skip #{name.titleize} Filter"
+        end
+      end
+
+
+      context "with #only inclusion method called" do
+        filter = "Only Skip #{name.titleize} Filter"
+        
+        it "skips the #{name} filters for the actions passed" do
+          visit basic_action_bar_path
+          filters_executed(execution).should_not include filter
+        end
+
+        it "does not skip the #{name} filters for the other actions" do
+          visit another_basic_action_bar_path
+          filters_executed(execution).should include filter
+        end
+      end
+
+
+      context "with #except inclusion method called" do
+        filter = "Except Skip #{name.titleize} Filter"
+        
+        it "skips the #{name} filters for the actions which are not passed" do
+          visit basic_action_bar_path
+          filters_executed(execution).should_not include filter
+        end
+
+        it "does not skip the #{name} filters for the actions passed" do
+          visit yet_another_basic_action_bar_path
+          filters_executed(execution).should include filter
+        end
+      end
+    end
+  end
+
+
+  include_examples 'skip_*_filter/s', 'before', 'before'
+  include_examples 'skip_*_filter/s', 'after', 'after'
+  include_examples 'skip_*_filter/s', 'before', 'around'
+  include_examples 'skip_*_filter/s', 'after', 'around'
+end

data/spec/test_app/spec/javascripts/variable_container_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+
+describe '_x', :type => :feature, :js => true  do
+
+  before do
+    visit basic_action_foo_path
+  end
+
+
+  it 'is visible on filters and callback' do
+    final_x = page.evaluate_script 'window.xVisibilityFinal'
+    final_x.should eq ['Before Foo', 'Around Foo', 'Foo', 'After Foo', 'Around Foo']
+  end
+
+
+  it 'is empty after filter and callback executions' do
+    x = page.evaluate_script 'Paloma.variableContainer'
+    x.should be_empty
+  end
+end

data/spec/test_app/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../../config/environment", __FILE__)
+require 'rspec/rails'
+require 'rspec/autorun'
+require 'capybara/rspec'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+
+RSpec.configure do |config|
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+end
+
+
+

data/vendor/assets/javascripts/paloma_core.js

@@ -0,0 +1,294 @@
+(function(){
+window.Paloma = {
+  callbacks : {},
+  filterScopes : {},
+  locals : {},
+  variableContainer : {}
+};
+
+
+var FILTER_TYPES = {},
+  FILTER_TYPE_NAMES = ['BEFORE', 'AFTER', 'AROUND'],
+  INCLUSION_TYPES = {},
+  INCLUSION_TYPE_NAMES = ['ALL', 'ONLY', 'EXCEPT'];
+
+FILTER_TYPES.BEFORE = 0;
+FILTER_TYPES.AFTER = 1;
+FILTER_TYPES.AROUND = 2;
+
+INCLUSION_TYPES.ALL = 3;
+INCLUSION_TYPES.ONLY = 4;
+INCLUSION_TYPES.EXCEPT = 5;
+  
+
+Paloma.inheritLocals = function(options){
+  var from = Paloma.locals[options['from']],
+    to = Paloma.locals[options['to']];
+
+  for (var local in from){
+    // Overriding is allowed.
+    if ( to.hasOwnProperty(local) ){ continue; }
+    
+    to[local] = from[local];
+  }
+};
+
+
+
+Paloma.FilterScope = function(name){ 
+  this.name = name;
+  
+  this.filters = {};
+  this.skippers = {};
+
+  for (var i = 0, n = FILTER_TYPE_NAMES.length; i < n; i++){
+    var type = FILTER_TYPE_NAMES[i].toUpperCase();
+    this.filters[ FILTER_TYPES[type] ] = [];
+    this.skippers[ FILTER_TYPES[type] ] = [];
+  }
+
+  Paloma.filterScopes[name] = this;
+};
+
+
+// Creates a new Filter instance registered under this FilterScope.
+Paloma.FilterScope.prototype.as = function(filterName){
+  return (new Paloma.Filter(this, filterName));
+};
+
+
+// skip_*_filter/s methods
+(function(){
+  for (var i = 0, n = FILTER_TYPE_NAMES.length; i < n; i++){
+    var type = FILTER_TYPE_NAMES[i],
+      singular = 'skip_' + type.toLowerCase() + '_filter',
+      plural = singular + 's',
+      method = function(skipperType){ 
+        return function(){
+          return (new Paloma.Skipper(this, FILTER_TYPES[skipperType], arguments));
+        };
+      };
+
+    Paloma.FilterScope.prototype[singular] = new method(type);
+    Paloma.FilterScope.prototype[plural] = Paloma.FilterScope.prototype[singular];
+  }
+})();
+
+
+
+
+// Skipper class
+Paloma.Skipper = function(scope, type, filters){
+  this.scope = scope;
+  this.type = type;
+  this.filters = Array.prototype.slice.call(filters);
+  this.inclusionType = INCLUSION_TYPES.ALL;
+  this.actions = [];
+
+  // Register this skipper on its scope.
+  this.scope.skippers[this.type].push(this);
+};
+
+
+Paloma.Skipper.prototype.skip = function(filter, action){
+  if (this.filters.indexOf(filter.name) == -1){ return false; }
+
+  var actionIsListed = this.actions.indexOf(action) != -1, 
+    isAllActions = this.inclusionType == INCLUSION_TYPES.ALL,
+    isQualified = this.inclusionType == INCLUSION_TYPES.ONLY && actionIsListed,
+    isNotExcepted = this.inclusionType == INCLUSION_TYPES.EXCEPT && !actionIsListed;
+
+  return (isAllActions || isQualified || isNotExcepted); 
+};
+
+
+Paloma.Skipper.prototype.only = function(){
+  this.inclusionType = INCLUSION_TYPES.ONLY;
+  this.actions = Array.prototype.slice.call(arguments);
+};
+
+
+Paloma.Skipper.prototype.except = function(){ 
+  this.inclusionType = INCLUSION_TYPES.EXCEPT;
+  this.actions = Array.prototype.slice.call(arguments);
+};
+
+
+
+// Filter class
+Paloma.Filter = function(scope, name){
+  this.scope = scope;
+  this.name = name;
+
+  this.type = undefined;
+  this.inclusionType = INCLUSION_TYPES.ONLY;
+
+  this.actions = [];
+  this.method = undefined;
+};
+
+
+// Create Methods:
+//  - before, after, around, *_all, except_*
+(function(){
+var Basic = function(type){ 
+  return function(){ 
+    return this.setProperties(type, INCLUSION_TYPES.ONLY, arguments); 
+  };
+};
+
+var All = function(type){
+  return function(){ 
+    return this.setProperties(type, INCLUSION_TYPES.ALL, []);
+  };
+};
+
+var Except = function(type){
+  return function(){
+    return this.setProperties(type, INCLUSION_TYPES.EXCEPT, arguments);
+  };
+};
+
+for (var i = 0, n = FILTER_TYPE_NAMES.length; i < n; i++){
+  var name = FILTER_TYPE_NAMES[i].toLowerCase(),
+    type = FILTER_TYPES[name.toUpperCase()];
+
+  Paloma.Filter.prototype[name] = new Basic(type);
+  Paloma.Filter.prototype[name + '_all'] = new All(type);
+  Paloma.Filter.prototype['except_' + name] = new Except(type);
+}
+})();
+// End of creating methods.
+
+
+// This will be the last method to be invoked when declaring a filter.
+// This will set what method/function will be executed when the filter is called.
+Paloma.Filter.prototype.perform = function(method){
+  this.method = method;
+
+  // This is the only time the filter is registered to its owner scope.  
+  this.scope.filters[this.type].push(this);
+  return this;
+};
+
+
+Paloma.Filter.prototype.isApplicable = function(action){
+  var actionIsListed = this.actions.indexOf(action) != -1, 
+    isAllActions = this.inclusionType == INCLUSION_TYPES.ALL,
+    isQualified = this.inclusionType == INCLUSION_TYPES.ONLY && actionIsListed,
+    isNotExcepted = this.inclusionType == INCLUSION_TYPES.EXCEPT && !actionIsListed;
+
+  return (isAllActions || isQualified || isNotExcepted);
+};
+
+
+Paloma.Filter.prototype.setProperties = function(type, inclusion, actions){
+  this.type = type;
+  this.inclusionType = inclusion;
+  this.actions = Array.prototype.slice.call(actions);
+  return this;
+};
+
+
+
+
+// Execute callback that corresponds to the controller and action passed.
+Paloma.execute = function(controller, action, params){
+  var callbackFound = true;
+  
+  var callback = Paloma.callbacks[controller];
+  callbackFound = callback != undefined;
+  
+  callback = callback[action];
+  callbackFound = callback != undefined;
+  
+  // Parse parameters
+  params = params || {};
+  
+  // Request details
+  var requestControllerPath = params['controller_path'].split('/');
+  params['controller'] = requestControllerPath.pop();
+  params['namespace'] = requestControllerPath.join('/');
+  
+  // Callback details
+  var callbackControllerPath = controller.split('/');
+  params['callback_controller'] = callbackControllerPath.pop();
+  params['callback_namespace'] = callbackControllerPath.join('/');
+  params['callback_controller_path'] = controller;
+  params['callback_action'] = action;
+  
+
+  var beforeFilters = getOrderedFilters(
+    FILTER_TYPES.BEFORE, 
+    params['callback_namespace'], 
+    controller, 
+    action);
+
+  var afterFilters = getOrderedFilters(
+    FILTER_TYPES.AFTER,
+    params['callback_namespace'],
+    controller,
+    action);
+
+  // Start filter and callback executions
+  performFilters(beforeFilters);
+  if (callbackFound){ callback(params); }
+  performFilters(afterFilters);
+
+  // variableContainer is used to share variable between filters and callbacks.
+  // It will be cleared after it is used.
+  Paloma.variableContainer = [];
+};
+
+
+var getOrderedFilters = function(beforeOrAfter, namespace, controller, action){
+  var filters = [],
+    applicableFilters = [],
+    skippers = [],
+    scopes = [
+      Paloma.filterScopes['/'], 
+      Paloma.filterScopes[namespace], 
+      Paloma.filterScopes[controller]];
+  
+  for (var i = 0, n = scopes.length; i < n; i++){
+    var scope = scopes[i];
+    if (scope == undefined){ continue; }
+
+    var mainFilters = scope.filters[beforeOrAfter],
+      aroundFilters = scope.filters[FILTER_TYPES.AROUND];
+    
+    // Around Filters have lower precedence than before or after filters.
+    if (mainFilters != undefined){ filters = filters.concat(mainFilters); }
+    if (aroundFilters != undefined){ filters = filters.concat(aroundFilters); }
+    
+    skippers = skippers.concat(
+        scope.skippers[beforeOrAfter], 
+        scope.skippers[FILTER_TYPES.AROUND]);
+  }
+
+
+  // Select only applicable filters for the passed action.
+  for (var i = 0, n = filters.length; i < n; i++){
+    var filter = filters[i],
+      isApplicable = filter.isApplicable(action),
+      isNotSkipped = true;
+
+    for (var k = 0, len = skippers.length; k < len; k++){
+      if ( skippers[k].skip(filter, action) ){ isNotSkipped = false; break;}
+    }
+
+    if (isApplicable && isNotSkipped){ applicableFilters.push(filter); } 
+  }
+
+  return applicableFilters;
+};
+
+
+var performFilters = function(filters, params){
+  for (var i = 0, n = filters.length; i < n; i++){
+    filters[i].method(params);
+  }
+};
+
+
+})();