rad_core 0.2.6 → 0.2.7

data/lib/rad/_support/callbacks.rb

@@ -1,166 +0,0 @@
-module Rad::Callbacks
-  class AbstractCallback
-    attr_accessor :executor, :terminator
-    attr_reader :conditions
-    def conditions= conditions
-      @conditions = {}
-      conditions.each do |k, v|
-        @conditions[k.to_sym] = if v.is_a? Symbol
-          v.to_s
-        elsif v.is_a? Array
-          v.collect{|e| e.to_s}
-        else
-          v
-        end
-      end
-      @conditions
-    end
-  
-    def terminate? target, result
-      unless terminator.nil?
-        if terminator.is_a? Proc
-          terminator.call target, result
-        else
-          result == terminator
-        end
-      else
-        false
-      end
-    end
-  
-    def run? target, inf
-      if cond = conditions[:if]
-        evaluate_if(cond, target, inf)
-      elsif cond = conditions[:unless]
-        !evaluate_if(cond, target, inf)
-      elsif cond = conditions[:only]
-        evaluate_only(cond, inf)
-      elsif cond = conditions[:except]
-        !evaluate_only(cond, inf)
-      else
-        true
-      end
-    end
-  
-    def add_to_chain target, inf, &the_next
-      if run? target, inf
-        build_block target, &the_next
-      else
-        the_next
-      end         
-    end
-    
-    alias_method :deep_clone, :clone
-    
-    protected
-      def evaluate_if cond, target, inf
-        if cond.is_a? String
-          target.send cond
-        elsif cond.is_a? Proc
-          cond.call target, inf
-        else
-          must_be.never_called
-        end
-      end
-    
-      def evaluate_only cond, inf
-        method = inf[:method].to_s
-        if cond.is_a? String
-          cond == method
-        elsif cond.is_a? Array
-          cond.include? method
-        end
-      end
-  end
-
-  class BeforeCallback < AbstractCallback    
-    def build_block target, &the_next
-      lambda do        
-        result = if executor.string_or_symbol?
-          target.send executor
-        elsif executor.is_a? Proc
-          executor.call target
-        else
-          must_be.never_called
-        end
-
-        the_next.call unless terminate? target, result
-      end
-    end
-  end
-
-  class AroundCallback < AbstractCallback
-    def build_block target, &the_next
-      lambda do
-        if executor.string_or_symbol?
-          target.send executor, &the_next
-        elsif executor.is_a? Proc
-          executor.call target, the_next
-        else
-          must_be.never_called
-        end
-      end      
-    end
-  end
-
-  class AfterCallback < AbstractCallback
-    def build_block target, &the_next
-      lambda do
-        result = if executor.string_or_symbol?
-          target.send executor
-        elsif executor.is_a? Proc
-          executor.call target
-        else
-          must_be.never_called
-        end
-      
-        the_next.call unless terminate? target, result
-      end      
-    end
-  end
-
-  def run_callbacks callback_name, additional_information = {}, &block
-    callback_name = callback_name.to_s
-    block.must_be.defined
-  
-    callbacks = self.class.callbacks[callback_name]
-    chain_head = block
-    if callbacks and !callbacks.empty?
-      callbacks.reverse_each do |callback|
-        block = callback.add_to_chain self, additional_information, &chain_head
-        chain_head = block if block
-      end
-    end
-    chain_head.call
-  end
-
-  module ClassMethods
-    inheritable_accessor :callbacks, {}
-  
-    def set_callback callback_name, type, *executor_or_options, &block   
-      # parsing arguments
-      type, callback_name = type.to_s, callback_name.to_s
-      opt = executor_or_options.extract_options!        
-      "You can't provide both method name and block for filter!" if block and !executor_or_options.empty?
-      executor = block || executor_or_options.first
-    
-      type.must_be.in %w{before around after}
-      executor.must_be.defined
-      
-      # creating callback
-      callback = case type
-      when 'before' then BeforeCallback.new
-      when 'around' then AroundCallback.new
-      when 'after' then AfterCallback.new
-      end            
-
-      callback.executor = executor
-      callback.terminator = opt.delete :terminator
-      callback.conditions = opt
-    
-      callbacks[callback_name] ||= []
-      callbacks[callback_name] << callback
-    end
-      
-  end
-end

data/lib/rad/_support/ruby_ext_with_active_support.rb

@@ -1,4 +0,0 @@
-OpenObject.class_eval do
-  # support :extract_options for OpenObject
-  def extractable_options?; true end
-end

data/spec/support/callbacks_spec.rb

@@ -1,157 +0,0 @@
-require 'support/spec_helper'
-
-require "rad/_support/callbacks"
-
-describe "Callbacks" do
-  before :all do
-    class BasicCallbacksSpec
-      inherit Rad::Callbacks
-
-      set_callback :callback_name, :before, :before_callback
-      set_callback :callback_name, :after, :after_callback
-      set_callback :callback_name, :around, :around_callback
-
-      protected
-        def around_callback
-          around_callback_called
-          yield
-        end
-    end
-  end
-  
-  it "basic" do
-    o = BasicCallbacksSpec.new
-    o.should_receive :before_callback
-    o.should_receive :around_callback_called
-    o.should_receive :after_callback
-    o.run_callbacks(:callback_name){"result"}.should == "result"
-  end
-
-  it "blocks" do
-    class BlockCallbacksSpec
-      inherit Rad::Callbacks
-      
-      set_callback(:callback_name, :before){|controller| controller.result << :before}
-      set_callback :callback_name, :around do |controller, block|
-        begin
-          controller.result << :around_begin
-          block.call
-        ensure
-          controller.result << :around_end
-        end
-      end
-      set_callback(:callback_name, :after){|controller| controller.result << :after}      
-
-      def result
-        @result ||= []
-      end
-    end
-    
-    o = BlockCallbacksSpec.new
-    o.run_callbacks(:callback_name){"result"}.should == "result"
-    o.result.should == [:before, :around_begin, :after, :around_end]
-  end
-
-  it "inheritance" do
-    class InheritedCallbacksSpec < BasicCallbacksSpec
-      set_callback :callback_name, :before, :before_callback2
-    end
-    
-    o = InheritedCallbacksSpec.new
-    o.should_receive :before_callback
-    o.should_receive :before_callback2
-    o.should_receive :around_callback_called
-    o.should_receive :after_callback
-    o.run_callbacks(:callback_name){"result"}.should == "result"
-  end
-  
-  it 'terminator' do
-    class CallbackTerminatorSpec
-      inherit Rad::Callbacks
-
-      set_callback :callback_name, :before, :before_callback, terminator: false
-      set_callback :callback_name, :before, :before_callback2      
-
-      def method
-        run_callbacks :callback_name do
-          "result"
-        end
-      end
-
-      protected
-        def before_callback
-          false 
-        end
-    end
-    
-    o = CallbackTerminatorSpec.new
-    o.should_not_receive :before_callback2
-    o.run_callbacks(:callback_name){"result"}.should_not == "result"
-  end
-  
-  it 'conditions' do
-    class CallbackConditionsSpec
-      inherit Rad::Callbacks
-
-      set_callback :callback_name, :before, :before_callback, only: :another_method
-    end
-    
-    o = CallbackConditionsSpec.new
-    o.should_not_receive :before_callback
-    o.run_callbacks(:callback_name, method: :method){"result"}.should == 'result'
-    
-    o = CallbackConditionsSpec.new
-    o.should_receive :before_callback
-    o.run_callbacks(:callback_name, method: :another_method){"result"}.should == 'result'
-  end
-  
-  it "if, unless conditions" do
-    c = Rad::Callbacks::AbstractCallback.new
-    c.conditions = {if: lambda{|target, inf| true}}
-    c.run?(nil, {}).should be_true
-    
-    c.conditions = {if: lambda{|target, inf| false}}
-    c.run?(nil, {}).should be_false
-    
-    c.conditions = {unless: lambda{|target, inf| true}}
-    c.run?(nil, {}).should be_false
-    
-    c.conditions = {unless: lambda{|target, inf| false}}
-    c.run?(nil, {}).should be_true
-  end
-  
-  it "only, except conditions" do
-    c = Rad::Callbacks::AbstractCallback.new
-    c.conditions = {only: :a}
-    c.run?(nil, {method: :a}).should be_true
-    
-    c.conditions = {only: :b}
-    c.run?(nil, {method: :a}).should be_false
-    
-    c.conditions = {except: :a}
-    c.run?(nil, {method: :a}).should be_false
-    
-    c.conditions = {except: :b}
-    c.run?(nil, {method: :a}).should be_true
-    
-    c.conditions = {only: :a}
-    c.run?(nil, {method: :a}).should be_true
-  end
-  
-  
-  it "around callback should be able to change result value" do
-    class ChangeResultValueSpec
-      inherit Rad::Callbacks
-  
-      set_callback :callback_name, :around, :around_callback
-      
-      def around_callback        
-        yield
-        'another result'
-      end
-    end
-    
-    o = ChangeResultValueSpec.new
-    o.run_callbacks(:callback_name){"result"}.should == 'another result'
-  end
-end