ruby_ext 0.5.1 → 0.5.2

data/Rakefile

@@ -8,8 +8,6 @@ project(
   gem: true,
   summary: "Ruby Extensions",
 
-  version: '0.5.1',
-
   author: "Alexey Petrushin",
   homepage: "http://github.com/alexeypetrushin/ruby_ext"
 )

data/lib/rake_ext.rb

@@ -21,12 +21,16 @@ require 'fileutils'
 begin
   require 'rspec/core/rake_task'
   task default: :spec
-
-  RSpec::Core::RakeTask.new('spec') do |t|
-    t.pattern = "spec/**/[^_]*_spec.rb"
-  end
+  task spec: 'spec:find_and_specs'  
 
   namespace :spec do
+    desc "Finds Specifications"
+    task :find_and_specs do
+      RSpec::Core::RakeTask.new('spec') do |t|
+        t.pattern = "spec/[^_]**/[^_]*_spec.rb"
+      end
+    end
+    
     desc "Run RSpec code exapmples in isolated mode (every spec file in another Ruby process)"
     task :isolated do
       Dir.glob("spec/[^_]**/[^_]*_spec.rb").each do |spec_file|

data/lib/ruby_ext/core/module.rb

@@ -48,9 +48,9 @@ Module.class_eval do
     each_ancestor &b
     each_namespace &b
   end
-  
+
   # TODO cache it?
-  def self.namespace_for class_name    
+  def self.namespace_for class_name
     list = class_name.split("::")
     if list.size > 1
       list.pop

data/lib/ruby_ext/core/object.rb

@@ -1,6 +1,6 @@
 Object.class_eval do
   def self; self end
-  
+
   def metaclass &block
     (class << self; self; end)
   end
@@ -8,11 +8,15 @@ Object.class_eval do
     metaclass.class_eval(&block)
     self
   end
-  
+
   def respond_to method, *args
     respond_to?(method) ? send(method, *args) : nil
   end
 
+  def try method, *args, &block
+    self && self.send(method, *args, &block)
+  end
+
   public :extend
 #  def copy
 #    Marshal.load(Marshal.dump self) # Stub

data/lib/ruby_ext/core/open_object.rb

@@ -122,7 +122,7 @@ class OpenObject < Hash
       r
     end
   end
-  
+
   # support :extract_options for OpenObject (Rails integration)
   def extractable_options?; true end
 

data/lib/ruby_ext/more.rb

@@ -8,5 +8,5 @@ module RubyExt; end
   open_constructor
   tuple
   callbacks
-  miscellaneous  
+  miscellaneous
 ).each{|f| require "ruby_ext/more/#{f}"}

data/lib/ruby_ext/more/callbacks.rb

@@ -1,172 +1,212 @@
 module RubyExt::Callbacks
   class AbstractCallback
-    attr_accessor :terminator
-    
     attr_reader :executor
-    def executor= executor      
+    def executor= executor
       @executor = executor.must_be.a Symbol, Proc
     end
-    
+
     attr_reader :conditions
     def conditions= conditions
       @conditions = {}
       conditions.each do |k, v|
-        @conditions[k.to_sym] = if v.is_a? Symbol
-          v.to_s
+        @conditions[k] = if v.is_a? Symbol
+          v
         elsif v.is_a? Array
-          v.collect{|e| e.to_s}
+          raise "method names must be symbols (#{v})!" unless v.all?{|e| e.is_a? Symbol}
+          v
         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
+
+    def run? target, data
       if cond = conditions[:if]
-        evaluate_if(cond, target, inf)
+        evaluate_if(cond, target, data)
       elsif cond = conditions[:unless]
-        !evaluate_if(cond, target, inf)
+        !evaluate_if(cond, target, data)
       elsif cond = conditions[:only]
-        evaluate_only(cond, inf)
+        evaluate_only(cond, data)
       elsif cond = conditions[:except]
-        !evaluate_only(cond, inf)
+        !evaluate_only(cond, data)
       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
+      def evaluate_if cond, target, data
+        if cond.is_a? Symbol
           target.send cond
         elsif cond.is_a? Proc
-          cond.call target, inf
+          cond.call target, data
         else
           must_be.never_called
         end
       end
-    
-      def evaluate_only cond, inf
-        method = inf[:method].to_s
-        if cond.is_a? String
+
+      def evaluate_only cond, data
+        method = data[:method]
+        method.must_be.a Symbol if method
+        if cond.is_a? Symbol
           cond == method
         elsif cond.is_a? Array
           cond.include? method
+        else
+          must_be.never_called
         end
       end
   end
 
-  class BeforeCallback < AbstractCallback    
-    def build_block target, &the_next
-      lambda do        
-        result = if executor.is_a? Symbol
-          target.send executor
-        elsif executor.is_a? Proc
-          executor.call target
-        else          
-          must_be.never_called
+  class BeforeCallback < AbstractCallback
+    attr_accessor :terminator
+
+    def build_block target, data, &block
+      -> do
+        if run? target, data
+          block.call if run target, data
+        else
+          block.call
         end
+      end
+    end
 
-        the_next.call unless terminate? target, result
+    def run target, data
+      callback_result = if executor.is_a? Symbol
+        target.send executor
+      elsif executor.is_a? Proc
+        executor.call target
+      else
+        must_be.never_called
       end
+
+      !terminate?(target, callback_result)
     end
+
+    protected
+      def terminate? target, result
+        unless terminator.nil?
+          if terminator.is_a? Proc
+            terminator.call target, result
+          else
+            result == terminator
+          end
+        else
+          false
+        end
+      end
   end
 
-  class AroundCallback < AbstractCallback
-    def build_block target, &the_next
-      lambda do
-        if executor.is_a? Symbol
-          target.send executor, &the_next
-        elsif executor.is_a? Proc
-          executor.call target, the_next
+  class AfterCallback < AbstractCallback
+    def build_block target, data, &block
+      -> do
+        if run? target, data
+          result = block.call
+          run target, data
+          result
         else
-          must_be.never_called
+          block.call
         end
-      end      
+      end
+    end
+
+    def run target, data
+      if executor.is_a? Symbol
+        target.send executor
+      elsif executor.is_a? Proc
+        executor.call target
+      else
+        must_be.never_called
+      end
     end
   end
 
-  class AfterCallback < AbstractCallback
-    def build_block target, &the_next
-      lambda do
-        result = if executor.is_a? Symbol
-          target.send executor
-        elsif executor.is_a? Proc
-          executor.call target
+  class AroundCallback < AbstractCallback
+    def build_block target, data, &block
+      -> do
+        if run? target, data
+          run target, data, &block
         else
-          must_be.never_called
+          block.call
         end
-      
-        the_next.call unless terminate? target, result
-      end      
+      end
+    end
+
+    def run target, data, &block
+      if executor.is_a? Symbol
+        target.send executor, &block
+      elsif executor.is_a? Proc
+        executor.call target, block
+      else
+        must_be.never_called
+      end
+    end
+  end
+
+  def run_before_callbacks callback_name, data = {}
+    callback_name.must_be.a Symbol
+    self.class.callbacks[callback_name].try :each do |callback|
+      if callback.is_a? BeforeCallback
+        return false unless callback.run self, data
+      end
+    end
+    true
+  end
+
+  def run_after_callbacks callback_name, data = {}
+    callback_name.must_be.a Symbol
+    self.class.callbacks[callback_name].try :each do |callback|
+      callback.run self, data if callback.is_a? AfterCallback
     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
+  def run_callbacks callback_name, data = {}, &block
+    callback_name.must_be.a Symbol
+    if callbacks = self.class.callbacks[callback_name]
+      chain = block || -> {}
+      chain = callbacks.reverse.reduce chain do |chain, callback|
+        callback.build_block self, data, &chain
       end
+      chain.call
+    else
+      block.call if block
     end
-    chain_head.call
   end
 
   module ClassMethods
     inheritable_accessor :callbacks, {}
-  
-    def set_callback callback_name, type, *executor_or_options, &block         
+
+    def set_callback callback_name, type, *executor_or_options, &block
+      callback_name.must_be.a Symbol
+      type.must_be.a Symbol
+
       # parsing arguments
-      type, callback_name = type.to_s, callback_name.to_s
-      opt = executor_or_options.extract_options!        
+      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}
+
+      type.must_be.in [:before, :around, :after]
       executor.must_be.defined
-      
+
       # creating callback
+      callback = AbstractCallback.new
       callback = case type
-      when 'before' then BeforeCallback.new
-      when 'around' then AroundCallback.new
-      when 'after' then AfterCallback.new
-      end            
+      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.terminator = opt.delete :terminator if type == :before
       callback.conditions = opt
-    
-      callbacks[callback_name] ||= []
-      callbacks[callback_name] << callback
+
+      (self.callbacks[callback_name] ||= []) << callback
+      # callbacks.send(type) << callback
+      # (callbacks[callback_name][type] ||= []) << callback
     end
-      
+
   end
 end

data/lib/ruby_ext/more/declarative_cache.rb

@@ -8,7 +8,7 @@ Module.class_eval do
   def cache_method_with_params *methods
     DeclarativeCache.cache_method_with_params self, *methods
   end
-  
+
   def clear_cache obj
     obj.instance_variables.each do |iv|
       obj.send :remove_instance_variable, iv if iv =~ /_cache$/ or iv =~ /_cache_check$/

data/spec/core/object_spec.rb

@@ -7,7 +7,7 @@ describe 'Object' do
     class RespondTest
       def test; 2 end
     end
-    
+
     r = RespondTest.new
     r.respond_to(:not_exist).should be_nil
     r.respond_to(:test).should == 2

data/spec/more/callbacks_spec.rb

@@ -2,35 +2,45 @@ require 'more/spec_helper'
 
 describe "Callbacks" do
   before :all do
-    class BasicCallbacksSpec
+    module CallbacksSpec; end
+    class CallbacksSpec::Basic
       inherit RubyExt::Callbacks
 
-      set_callback :callback_name, :before, :before_callback
-      set_callback :callback_name, :after, :after_callback
-      set_callback :callback_name, :around, :around_callback
+      set_callback :save, :before, :before_save
+      set_callback :save, :around, :around_save
+      set_callback :save, :after, :after_save
 
       protected
-        def around_callback
-          around_callback_called
+        def around_save
+          around_save_called
           yield
         end
     end
   end
-  
+  after(:all){remove_constants :CallbacksSpec}
+
   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"
+    o = CallbacksSpec::Basic.new
+    o.should_receive :before_save
+    o.should_receive :around_save_called
+    o.should_receive :after_save
+    o.run_callbacks(:save){"result"}.should == "result"
+  end
+
+  it "should be possible to call before & after separatelly (in this mode :around is not available)" do
+    o = CallbacksSpec::Basic.new
+    o.should_receive :before_save
+    o.run_before_callbacks(:save)
+    o.should_receive :after_save
+    o.run_after_callbacks(:save)
   end
 
   it "blocks" do
-    class BlockCallbacksSpec
+    class CallbacksSpec::Blocks
       inherit RubyExt::Callbacks
-      
-      set_callback(:callback_name, :before){|controller| controller.result << :before}
-      set_callback :callback_name, :around do |controller, block|
+
+      set_callback(:save, :before){|controller| controller.result << :before}
+      set_callback :save, :around do |controller, block|
         begin
           controller.result << :around_begin
           block.call
@@ -38,118 +48,143 @@ describe "Callbacks" do
           controller.result << :around_end
         end
       end
-      set_callback(:callback_name, :after){|controller| controller.result << :after}      
+      set_callback(:save, :after){|controller| controller.result << :after}
 
       def result
         @result ||= []
       end
     end
-    
-    o = BlockCallbacksSpec.new
-    o.run_callbacks(:callback_name){"result"}.should == "result"
+
+    o = CallbacksSpec::Blocks.new
+    o.run_callbacks(:save){"result"}.should == "result"
     o.result.should == [:before, :around_begin, :after, :around_end]
   end
 
+  it "execution order" do
+    class CallbacksSpec::ExecutionOrder
+      inherit RubyExt::Callbacks
+
+      # order is important, don't change it
+      set_callback :save, :before, :before1
+      set_callback :save, :after,  :after1
+      set_callback :save, :around, :around1
+      set_callback :save, :before, :before2
+
+      protected
+        def around1
+          around1_called
+          yield
+        end
+    end
+
+    o = CallbacksSpec::ExecutionOrder.new
+    o.should_receive(:before1).ordered.once
+    o.should_receive(:around1_called).ordered.once
+    o.should_receive(:before2).ordered.once
+    o.should_receive(:after1).ordered.once
+    o.run_callbacks :save
+  end
+
   it "inheritance" do
-    class InheritedCallbacksSpec < BasicCallbacksSpec
-      set_callback :callback_name, :before, :before_callback2
+    class CallbacksSpec::Inheritance < CallbacksSpec::Basic
+      set_callback :save, :before, :before_save2
     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"
+
+    o = CallbacksSpec::Inheritance.new
+    o.should_receive :before_save
+    o.should_receive :before_save2
+    o.should_receive :around_save_called
+    o.should_receive :after_save
+    o.run_callbacks(:save){"result"}.should == "result"
   end
-  
+
   it 'terminator' do
-    class CallbackTerminatorSpec
+    class CallbacksSpec::Terminator
       inherit RubyExt::Callbacks
 
-      set_callback :callback_name, :before, :before_callback, terminator: false
-      set_callback :callback_name, :before, :before_callback2      
+      set_callback :save, :before, :before_save, terminator: false
+      set_callback :save, :before, :before_save2
 
       def method
-        run_callbacks :callback_name do
+        run_callbacks :save do
           "result"
         end
       end
 
       protected
-        def before_callback
-          false 
+        def before_save
+          false
         end
     end
-    
-    o = CallbackTerminatorSpec.new
-    o.should_not_receive :before_callback2
-    o.run_callbacks(:callback_name){"result"}.should_not == "result"
+
+    o = CallbacksSpec::Terminator.new
+    o.should_not_receive :before_save2
+    o.run_callbacks(:save){"result"}.should_not == "result"
   end
-  
+
   it 'conditions' do
-    class CallbackConditionsSpec
+    class CallbacksSpec::Conditions
       inherit RubyExt::Callbacks
 
-      set_callback :callback_name, :before, :before_callback, only: :another_method
+      set_callback :save, :before, :before_save, 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'
+
+    o = CallbacksSpec::Conditions.new
+    o.should_not_receive :before_save
+    o.run_callbacks(:save, method: :method){"result"}.should == 'result'
+
+    o = CallbacksSpec::Conditions.new
+    o.should_receive :before_save
+    o.run_callbacks(:save, method: :another_method){"result"}.should == 'result'
   end
-  
+
   it "if, unless conditions" do
     c = RubyExt::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 = RubyExt::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
+    class CallbacksSpec::ChangeResult
       inherit RubyExt::Callbacks
-  
-      set_callback :callback_name, :around, :around_callback
-      
-      def around_callback        
+
+      set_callback :save, :around, :around_save
+
+      def around_save
         yield
         'another result'
       end
     end
-    
-    o = ChangeResultValueSpec.new
-    o.run_callbacks(:callback_name){"result"}.should == 'another result'
+
+    o = CallbacksSpec::ChangeResult.new
+    o.run_callbacks(:save){"result"}.should == 'another result'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_ext
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-20 00:00:00.000000000Z
+date: 2011-08-23 00:00:00.000000000Z
 dependencies: []
 description: 
 email: