paloma 2.0.6 → 3.0.0

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

@@ -1,187 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/vendor/assets/javascripts/paloma_core.js

@@ -1,296 +0,0 @@
-(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;
-  
-  if (callbackFound){
-    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, params);
-  if (callbackFound){ callback(params); }
-  performFilters(afterFilters, params);
-
-  // 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);
-  }
-};
-
-
-})();