aspectory 0.1.0

data/spec/hook_spec.rb

@@ -0,0 +1,233 @@
+require 'spec/spec_helper'
+
+describe Aspectory::Hook do
+  attr_reader :klass, :object
+  
+  before(:each) do
+    @klass = Class.new do
+      include Aspectory
+      
+      after :bar, :call!
+      before :foo, :call!
+      around(:fizz) { |fn| call!; fn.call }
+      callback :before, :fizz, :call!
+      
+      def foo; :foo end
+      def bar; :bar end
+      def fizz; :fizz end
+      def buzz; :buzz end
+      def call!; @called = true end
+      def called?; @called end
+      def round(fn); @called = fn.call end
+    end
+    
+    @object = klass.new
+  end
+  
+  describe "#before" do
+    it "allows callbacks to be defined before methods are" do
+      object.should_not be_called
+      object.foo
+      object.should be_called
+    end
+
+    it "allows callbacks to be defined after methods are" do
+      klass.before(:buzz, :call!)
+
+      object.should_not be_called
+      object.buzz
+      object.should be_called
+    end
+    
+    it "allows regex declarations of callback behavior for defined methods" do
+      klass.class_eval { before(/foo|bar/, :regexd!) }
+      mock(object).regexd!.twice
+      object.foo
+      object.bar
+    end
+    
+    it "allows regex declarations of callback behavior for undefined methods" do
+      klass.before(/ping/) { pinged! } #, :pinged!)
+      klass.before(/pong/) { ponged! }
+      
+      klass.class_eval do
+        def ping; :ping end
+        def pong; :pong end
+        def pung; :pung end
+      end
+      
+      mock(object).pinged!
+      mock(object).ponged!
+      mock(object).call!.never
+      object.ping
+      object.pong
+    end
+  end
+  
+  describe "#after" do
+    it "allows callbacks to be defined before methods are" do
+      object.should_not be_called
+      object.bar
+      object.should be_called
+    end
+
+    it "allows callbacks to be defined after methods are" do
+      klass.after(:buzz, :call!)
+
+      object.should_not be_called
+      object.buzz
+      object.should be_called
+    end
+    
+    it "allows regex declarations of callback behavior for defined methods" do
+      klass.class_eval { after(/foo|bar/, :regexd!) }
+      mock(object).regexd!(:foo)
+      mock(object).regexd!(:bar)
+      object.foo
+      object.bar
+    end
+    
+    it "allows regex declarations of callback behavior for undefined methods" do
+      klass.class_eval { after(/ping|pong/, :regexd!) }
+      
+      klass.class_eval { def ping; :ping end }
+      klass.class_eval { def pong; :pong end }
+      
+      mock(object).regexd!(:ping)
+      mock(object).regexd!(:pong)
+      object.ping
+      object.pong
+    end
+    
+    it "allows regex declarations of callback behavior for undefined methods" do
+      klass.after(/ping/) { pinged! } #, :pinged!)
+      klass.after(/pong/) { ponged! }
+      
+      klass.class_eval do
+        def ping; :ping end
+        def pong; :pong end
+        def pung; :pung end
+      end
+      
+      mock(object).pinged!
+      mock(object).ponged!
+      mock(object).call!.never
+      object.ping
+      object.pong
+    end
+  end
+  
+  describe "#around" do
+    it "allows callbacks to be defined before methods are" do
+      object.should_not be_called
+      object.fizz.should == :fizz
+      object.should be_called
+    end
+  
+    it "allows callbacks to be defined after methods are" do
+      klass.around(:buzz) { |fn| call!; fn.call }
+  
+      object.should_not be_called
+      object.buzz
+      object.should be_called
+    end
+    
+    it "allows regex declarations of callback behavior for defined methods" do
+      klass.class_eval do
+        around(/foo|bar/) { |f| regexd! f.call }
+      end
+      mock(object).regexd!(:foo)
+      mock(object).regexd!(:bar)
+      object.foo
+      object.bar
+    end
+    
+    it "allows regex declarations of callback behavior for undefined methods" do
+      klass.class_eval do
+        around(/ping|pong/) { |f| regexd! f.call }
+      end
+      
+      klass.class_eval { def ping; :ping end }
+      klass.class_eval { def pong; :pong end }
+      
+      mock(object).regexd!(:ping)
+      mock(object).regexd!(:pong)
+      object.ping
+      object.pong
+    end
+    
+    it "allows regex declarations of callback behavior for undefined methods" do
+      klass.around(/ping/) { |fn| fn.call pinged! } #, :pinged!)
+      klass.around(/pong/) { |fn| fn.call ponged! }
+      
+      klass.class_eval do
+        def ping; :ping end
+        def pong; :pong end
+        def pung; :pung end
+      end
+      
+      mock(object).pinged!
+      mock(object).ponged!
+      mock(object).call!.never
+      object.ping
+      object.pong
+    end
+  end
+  
+  describe "#callback" do
+    it "allows callbacks to be defined before methods are" do
+      object.should_not be_called
+      object.fizz
+      object.should be_called
+    end
+
+    it "allows callbacks to be defined after methods are" do
+      klass.callback(:before, :buzz, :call!)
+
+      object.should_not be_called
+      object.buzz
+      object.should be_called
+    end
+  end
+  
+  describe "#observe" do
+    it "allows method definitions to be observed" do
+      called = false
+      klass.observe(:boom) { called = true }
+      klass.class_eval { def boom; :boom end }
+      called.should be_true
+    end
+    
+    it "allows multiple callbacks for observed methods" do
+      once = twice = false
+      klass.observe(:boom) { once = true }
+      klass.observe(:boom) { twice = true }
+      klass.class_eval { def boom; :boom end }
+      once.should be_true
+      twice.should be_true
+    end
+    
+    it "only runs callbacks once by default" do
+      called = false
+      klass.observe(:boom) { called = !called }
+      klass.class_eval { def boom; :boom end }
+      klass.class_eval { def boom; :boom end }
+      called.should be_true
+    end
+    
+    it "allows callback limits to be specified" do
+      mock(callee = Object.new).call!.times(3)
+      klass.observe(:foo, :times => 3) { callee.call! }
+      klass.class_eval { def foo; :foo end }
+      klass.class_eval { def foo; :foo end }
+      klass.class_eval { def foo; :foo end }
+      klass.class_eval { def foo; :foo end }
+    end
+    
+    it "should allows metaclasses to be observed" do
+      mock(callee = Object.new).call!
+      klass.observe(:foo, :meta => true) { callee.call! }
+      klass.class_eval { def self.foo; :foo end }
+    end
+  end
+end

data/spec/introspector_spec.rb

@@ -0,0 +1,280 @@
+require 'spec/spec_helper'
+
+describe Aspectory::Introspector do
+  attr_reader :klass, :introspector
+  
+  before(:each) do
+    @klass = Class.new { def foo; :foo end }
+    @introspector = Aspectory::Introspector.new(@klass)
+  end
+  
+  it "knows defined methods" do
+    introspector.defined_methods.should == [:foo]
+  end
+  
+  it "knows if a method is defined" do
+    introspector.should have_method(:foo)
+  end
+  
+  it "knows if a method is not defined" do
+    introspector.should_not have_method(:bar)
+  end
+  
+  it "only observes klass once" do
+    mock(klass).meta_def(:method_added).once
+    introspector.observe_klass!
+    introspector.observe_klass!
+  end
+  
+  describe "observing a method" do
+    context "on a metaclass" do
+      attr_reader :meta_introspector
+      
+      before(:each) do
+        @meta_introspector = Aspectory::Introspector.new(klass, :meta => true)
+      end
+      
+      it "is stored in #observed_methods" do
+        meta_introspector.observe(:bar) { }
+        meta_introspector.observing?(:bar).should be_true
+      end
+
+      it "ceases when method gets defined" do
+        meta_introspector.observe(:bar)
+        klass.class_eval { def self.bar; :bar end }
+        meta_introspector.observing?(:bar).should be_false
+      end
+    
+      it "allows a callback block for when methods get defined" do
+        called = false
+        meta_introspector.observe(:bar) { called = true }
+        klass.class_eval { def self.bar; :bar end }
+        called.should be_true
+      end
+    
+      it "allows multiple callback blocks" do
+        once = twice = false
+        meta_introspector.observe(:bar) { once = true }
+        meta_introspector.observe(:bar) { twice = true }
+        klass.class_eval { def self.bar; :bar end }
+        once.should be_true
+        twice.should be_true
+      end
+    end
+    
+    context "when the method isn't defined" do
+      it "is stored in #observed_methods" do
+        introspector.observe(:bar) { }
+        introspector.observing?(:bar).should be_true
+      end
+
+      it "ceases when method gets defined" do
+        introspector.observe(:bar)
+        klass.class_eval { def bar; :bar end }
+        introspector.observing?(:bar).should be_false
+      end
+    
+      it "allows a callback block for when methods get defined" do
+        called = false
+        introspector.observe(:bar) { called = true }
+        klass.class_eval { def bar; :bar end }
+        called.should be_true
+      end
+    
+      it "allows multiple callback blocks" do
+        once = twice = false
+        introspector.observe(:bar) { once = true }
+        introspector.observe(:bar) { twice = true }
+        klass.class_eval { def bar; :bar end }
+        once.should be_true
+        twice.should be_true
+      end
+    
+      it "only runs callbacks once" do
+        once = false
+        introspector.observe(:bar) { once = !once }
+        klass.class_eval { def bar; :bar end }
+        klass.class_eval { def bar; :bar end }
+        once.should be_true
+      end
+      
+      describe "specifying limits" do
+        it "allows a :times option" do
+          mock(callee = Object.new).call!
+          introspector.observe(:bar, :times => 1) { callee.call! }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+        end
+        
+        it "allows callback to be run 2 times" do
+          mock(callee = Object.new).call!.times(2)
+          introspector.observe(:bar, :times => 2) { callee.call! }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+        end
+        
+        it "allows callback to be run 3 times" do
+          mock(callee = Object.new).call!.times(3)
+          introspector.observe(:bar, :times => 3) { callee.call! }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+        end
+        
+        it "allows callback to be run every time" do
+          mock(callee = Object.new).call!.times(3)
+          introspector.observe(:bar, :times => :infinite) { callee.call! }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+        end
+        
+        it "should works with other times terms abbreviation" do
+          mock(callee = Object.new).call!.times(3)
+          introspector.observe(:bar, :times => :any) { callee.call! }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+        end
+        
+        it "should works with :all abbreviation" do
+          mock(callee = Object.new).call!.times(3)
+          introspector.observe(:bar, :times => :all) { callee.call! }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+        end
+        
+        it "should works with :every abbreviation" do
+          mock(callee = Object.new).call!.times(3)
+          introspector.observe(:bar, :times => :every) { callee.call! }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+          klass.class_eval { def bar; :bar end }
+        end
+      end
+    end
+    
+    context "when the method is defined" do
+      it "is stored in #observed_methods" do
+        introspector.observe(:inspect) { }
+        introspector.observing?(:inspect).should be_true
+      end
+
+      it "ceases when method gets defined" do
+        introspector.observe(:inspect)
+        klass.class_eval { def inspect; :inspect end }
+        introspector.observing?(:inspect).should be_false
+      end
+    
+      it "allows a callback block for when methods get defined" do
+        called = false
+        introspector.observe(:inspect) { called = true }
+        klass.class_eval { def inspect; :inspect end }
+        called.should be_true
+      end
+    
+      it "allows multiple callback blocks" do
+        once = twice = false
+        introspector.observe(:inspect) { once = true }
+        introspector.observe(:inspect) { twice = true }
+        klass.class_eval { def inspect; :inspect end }
+        once.should be_true
+        twice.should be_true
+      end
+    
+      it "only runs callbacks once" do
+        once = false
+        introspector.observe(:inspect) { once = !once }
+        klass.class_eval { def inspect; :inspect end }
+        klass.class_eval { def inspect; :inspect end }
+        once.should be_true
+      end
+    end
+  end
+  
+  describe "observing a regex" do
+    context "when the method isn't defined" do
+      it "is stored in #observed_methods" do
+        introspector.observe(/(foo|bar)/) { }
+        introspector.observing?(/(foo|bar)/).should be_true
+      end
+
+      it "ceases when a matching method gets defined" do
+        introspector.observe(/(foo|bar)/)
+        klass.class_eval { def bar; :bar end }
+        introspector.observing?(/(foo|bar)/).should be_false
+      end
+    
+      it "allows a callback block for when methods get defined" do
+        called = false
+        introspector.observe(/(foo|bar)/) { called = true }
+        klass.class_eval { def bar; :bar end }
+        called.should be_true
+      end
+    
+      it "allows multiple callback blocks" do
+        once = twice = false
+        introspector.observe(/(bar)/) { once = true }
+        introspector.observe(/(foo|bar)/) { twice = true }
+        klass.class_eval { def bar; :bar end }
+        once.should be_true
+        twice.should be_true
+      end
+      
+      it "passes the method name" do
+        called = false
+        introspector.observe(/(foo|bar)/) { |method_id| called = method_id.eql?(:bar) }
+        klass.class_eval { def bar; :bar end }
+        called.should be_true
+      end
+    
+      it "only runs callbacks once" do
+        once = false
+        introspector.observe(/(foo|bar)/) { once = !once }
+        klass.class_eval { def foo; :foo end }
+        klass.class_eval { def bar; :bar end }
+        once.should be_true
+      end
+    end
+    
+    context "when the method is defined" do
+      it "is stored in #observed_methods" do
+        introspector.observe(/inspect/) { }
+        introspector.observing?(/inspect/).should be_true
+      end
+    
+      it "ceases when method gets defined" do
+        introspector.observe(/inspect/)
+        klass.class_eval { def inspect; :inspect end }
+        introspector.observing?(/inspect/).should be_false
+      end
+    
+      it "allows a callback block for when methods get defined" do
+        called = false
+        introspector.observe(/inspect/) { called = true }
+        klass.class_eval { def inspect; :inspect end }
+        called.should be_true
+      end
+    
+      it "allows multiple callback blocks" do
+        once = twice = false
+        introspector.observe(/inspect/) { once = true }
+        introspector.observe(/inspect/) { twice = true }
+        klass.class_eval { def inspect; :inspect end }
+        once.should be_true
+        twice.should be_true
+      end
+    
+      it "only runs callbacks once" do
+        once = false
+        introspector.observe(/inspect/) { once = !once }
+        klass.class_eval { def inspect; :inspect end }
+        klass.class_eval { def inspect; :inspect end }
+        once.should be_true
+      end
+    end
+  end
+end