message-recorder 1.0.3 → 1.0.4

data/History.txt

@@ -1,3 +1,8 @@
+== 1.0.4 2008-02-22
+
+* You can now filter before and after call, chain and branch.
+* the after call filter now can break a callchain.
+
 == 1.0.3 2008-02-15
 
 * Fixed a small bug.

data/lib/message-recorder/branching_mock.rb

@@ -23,21 +23,31 @@ class Message::Recorder::BranchingMock # :nodoc:
   alias_method :__instance_eval__, :instance_eval
   instance_methods.each { |m| undef_method m unless m =~ /^__/ }
   
-  def initialize(collector)
+  def initialize(recorder, collector)
+    @recorder = recorder
     @branched_collectors = []
     @collector_prototype = collector.deep_copy
     @collector = collector.clear
   end
+  
   def __branch__(&block)
     __instance_eval__(&block) unless block.nil?
     @branched_collectors.each { |branched_collector| @collector.concat branched_collector }
-    Message::Recorder::ChainingMock.new(@collector)
+    Message::Recorder::ChainingMock.new(@recorder, @collector)
   end
+  
   def method_missing(m, *args, &block)
+    @recorder.filter_before_branch(@collector_prototype)
     branched_collector = @collector_prototype.branch
     @branched_collectors << branched_collector
+    @recorder.filter_after_branch(@collector_prototype, branched_collector)
+    
+    
+    message = ::Message::Recorder::Message.new(m, args, block)
+    @recorder.filter_before_chain(message)
+    branched_collector.record(message)
+    @recorder.filter_after_chain(message)
     
-    branched_collector.record(m, *args, &block)
-    Message::Recorder::ChainingMock.new(branched_collector)
+    Message::Recorder::ChainingMock.new(@recorder, branched_collector)
   end
 end

data/lib/message-recorder/chain.rb

@@ -26,16 +26,20 @@ class Message::Recorder::Chain < ::Array # :nodoc:
     super(array)
   end
   
-  def record(m, *args, &block)
-    push Message::Recorder::Message.new(m, args, block)
+  def record_message(m, *args, &block)
+    record ::Message::Recorder::Message.new(m, args, block)
   end
   
-  def send_to(subject_, recorder)
-    inject(subject_) do |subject,message|
-      message_call = message.to_message_call(subject)
-      return nil unless recorder.filter_before(message_call)
+  def record(message)
+    push message
+  end
+  
+  def send_to(chain_subject, recorder)
+    inject(chain_subject) do |call_subject,message|
+      message_call = message.to_message_call(call_subject)
+      return nil unless recorder.filter_before_call(message_call)
       message_call.execute
-      recorder.filter_after(message_call)
+      return nil unless recorder.filter_after_call(message_call)
       message_call.return_value
     end
   end

data/lib/message-recorder/chaining_mock.rb

@@ -24,12 +24,16 @@
 class Message::Recorder::ChainingMock
   instance_methods.each { |m| undef_method m unless m =~ /^__/ }
   
-  def initialize(collector) # :nodoc:
+  def initialize(recorder, collector) # :nodoc:
+    @recorder  = recorder
     @collector = collector
   end
   
   def method_missing(m, *args, &block) # :nodoc:
-    @collector.record(m, *args, &block)
+    message = ::Message::Recorder::Message.new(m, args, block)
+    @recorder.filter_before_chain(message)
+    @collector.record(message)
+    @recorder.filter_after_chain(message)
     return self
   end
   
@@ -46,7 +50,7 @@ class Message::Recorder::ChainingMock
   #   recorder.record.bye
   #   recorder.send_to subject
   def __branch__(&block)
-    Message::Recorder::BranchingMock.new(@collector).__branch__(&block)
+    Message::Recorder::BranchingMock.new(@recorder, @collector).__branch__(&block)
   end
   alias_method :with_results, :__branch__
   alias_method :with_result,  :__branch__

data/lib/message-recorder/collector.rb

@@ -19,31 +19,41 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-class Message::Recorder::Collector < ::Array # :nodoc:
+
+# The Collector stores all the callchains.
+class Message::Recorder::Collector < ::Array
+  
+  attr_accessor :recorder # :nodoc:
   
-  def initialize(array=[], root=nil)
-    super(array)
+  def initialize(options={}) # :nodoc:
+    super(options[:array]) unless options[:array].nil?
     push ::Message::Recorder::Chain.new if self.empty?
-    root_collector = root
+    self.recorder = options[:recorder]
+  end
+  
+  def collect_messages # :nodoc:
+    ::Message::Recorder::ChainingMock.new(self.recorder, self)
   end
   
-  def collect_messages
-    ::Message::Recorder::ChainingMock.new(self)
+  # record a message on all callchains.
+  def record_message(m, *args, &block)
+    record ::Message::Recorder::Message.new(m, args, block)
   end
   
-  def record(m, *args, &block)
-    each { |chain| chain.record(m, *args, &block) }
+  # record a message object on all callchains.
+  def record(message)
+    each { |chain| chain.record(message) }
   end
   
-  def branch
+  def branch # :nodoc:
     self.deep_copy
   end
   
-  def deep_copy
-    ::Message::Recorder::Collector.new(collect { |chain| chain.dup })
+  def deep_copy # :nodoc:
+    ::Message::Recorder::Collector.new(:array => collect { |chain| chain.dup }, :recorder => self.recorder)
   end
   
-  def send_to(subject, recorder)
+  def send_to(subject, recorder) # :nodoc:
     results = ::Array.new
     each { |chain| results << chain.send_to(subject, recorder) }
     results

data/lib/message-recorder/message.rb

@@ -19,18 +19,32 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+# The Message class describes a message.
+class Message::Recorder::Message
+  # the name of the method being called.
+  attr_reader :method_name
+  
+  # the arguments passed to the method.
+  attr_reader :arguments
+  
+  # the block passed to the method.
+  attr_reader :block
 
-class Message::Recorder::Message # :nodoc:
-  attr_accessor :method_name, :arguments, :block
-
-  def initialize(method_name, arguments, block)
-    self.method_name = method_name
-    self.arguments   = arguments
-    self.block       = block
+  def initialize(method_name, arguments, block) # :nodoc:
+    @method_name = method_name
+    @arguments   = arguments
+    @block       = block
   end
   
-  def to_message_call(subject)
-    Message::Recorder::MessageCall.new(subject, method_name, arguments, block)
+  def to_message_call(subject) # :nodoc:
+    Message::Recorder::MessageCall.new(subject, self)
   end
   
+  def arguments # :nodoc:
+    @arguments ||= []
+  end
+  
+  def block # :nodoc:
+    @block ||= Proc.new { || false }
+  end
 end

data/lib/message-recorder/message_call.rb

@@ -21,25 +21,23 @@
 
 # An object on this class is passed to the filter blocks
 class Message::Recorder::MessageCall
-  attr_reader :subject, :method_name, :arguments, :block, :return_value
+  # the receiver of the message
+  attr_reader :subject
+  # the message sed to the subject when execute is called.
+  attr_reader :message
+  # the return value of the message call.
+  attr_reader :return_value
   
-  def arguments # :nodoc:
-    @arguments ||= []
-  end
-  def block # :nodoc:
-    @block ||= Proc.new { || false }
-  end
-  
-  def initialize(subject, method_name, arguments, block, return_value=nil) # :nodoc:
+  # initialize a message call
+  def initialize(subject, message, return_value=nil)
     @subject      = subject
-    @method_name  = method_name
-    @arguments    = arguments
-    @block        = block
+    @message      = message
     @return_value = return_value
   end
   
-  def execute # :nodoc:
-    @return_value = @subject.__send__(@method_name, *@arguments, &@block)
+  # send <tt>message</tt> to <tt>subject</tt>.
+  def execute
+    @return_value = @subject.__send__(@message.method_name, *@message.arguments, &@message.block)
   end
   
 end

data/lib/message-recorder/recorder.rb

@@ -35,17 +35,85 @@
 #   recorder.send_to("Mr_Henry") # => :mr_henry
 class Message::Recorder
   
+  
+  # <b>BEFORE CALL FILTER:</b>
+  # 
   # Takes a block with one argument of type Message::Recorder::MessageCall
   #   recorder.before { |message_call| ... }
+  #   recorder.before :call { |message_call| ... }
+  #   recorder.before :call, :my_filter_method
+  #   def my_filter_method(message_call)
+  #     ...
+  #   end
   # if the block returns false the chain will be broken.
-  def before(&block)
-    before_filters << block
+  # 
+  # <b>BEFORE CHAIN FILTER:</b>
+  # 
+  # Takes a block with one argument of type Message::Recorder::Message
+  #   recorder.before :chain { |message| ... }
+  #   recorder.before :chain, :my_filter_method
+  #   def my_filter_method(message)
+  #     ...
+  #   end
+  #
+  # <b>BEFORE BRANCH FILTER:</b>
+  # 
+  # Takes a block with one argument of type Message::Recorder::Collector
+  #   recorder.before :branch { |collector| ... }
+  #   recorder.before :branch, :my_filter_method
+  #   def my_filter_method(collector)
+  #     ...
+  #   end
+  def before(*options,&block)
+    type     = options.shift if [:call, :chain, :branch].include? options.first
+    type   ||= :call
+    filter   = block 
+    filter ||= method(options.shift)
+    case type
+    when :call   then before_call_filters   << filter
+    when :chain  then before_chain_filters  << filter
+    when :branch then before_branch_filters << filter
+    end
   end
   
+  # <b>AFTER CALL FILTER:</b>
+  # 
   # Takes a block with one argument of type Message::Recorder::MessageCall
   #   recorder.after { |message_call| ... }
-  def after(&block)
-    after_filters << block
+  #   recorder.after :call { |message_call| ... }
+  #   recorder.after :call, :my_filter_method
+  #   def my_filter_method(message_call)
+  #     ...
+  #   end
+  # if the block returns false the chain will be broken.
+  # 
+  # <b>AFTER CHAIN FILTER:</b>
+  # 
+  # Takes a block with one argument of type Message::Recorder::Message
+  #   recorder.after :chain { |message| ... }
+  #   recorder.after :chain, :my_filter_method
+  #   def my_filter_method(message)
+  #     ...
+  #   end
+  #
+  # <b>AFTER BRANCH FILTER:</b>
+  # 
+  # Takes a block with two arguments of type Message::Recorder::Collector
+  #   recorder.after :branch { |original_collector, new_collector| ... }
+  #   recorder.after :branch, :my_filter_method
+  #   def my_filter_method(original_collector, new_collector)
+  #     ...
+  #   end
+  def after(*options,&block)
+    type     = options.shift if [:call, :chain, :branch].include? options.first
+    type   ||= :call
+    filter   = block 
+    filter ||= method(options.shift)
+    case type
+    when :call   then after_call_filters   << filter
+    when :chain  then after_chain_filters  << filter
+    when :branch then after_branch_filters << filter
+    end
   end
   
   # #record returns a mock object which will store all the messages you send to it.
@@ -60,33 +128,79 @@ class Message::Recorder
   end
   
   
-  attr_accessor :before_filters # :nodoc:
-  attr_accessor :after_filters  # :nodoc:
+  attr_accessor :before_call_filters # :nodoc:
+  attr_accessor :after_call_filters  # :nodoc:
+  attr_accessor :before_branch_filters # :nodoc:
+  attr_accessor :after_branch_filters  # :nodoc:
+  attr_accessor :before_chain_filters # :nodoc:
+  attr_accessor :after_chain_filters  # :nodoc:
+  
+  def before_call_filters # :nodoc:
+    @before_call_filters ||= []
+  end
+  
+  def after_call_filters # :nodoc:
+    @after_call_filters ||= []
+  end
+  
+  def before_branch_filters # :nodoc:
+    @before_branch_filters ||= []
+  end
   
-  def before_filters # :nodoc:
-    @before_filters ||= []
+  def after_branch_filters # :nodoc:
+    @after_branch_filters ||= []
   end
   
-  def after_filters # :nodoc:
-    @before_filters ||= []
+  def before_chain_filters # :nodoc:
+    @before_chain_filters ||= []
   end
   
-  def filter_before(message_call) # :nodoc:
-    before_filters.each do |filter|
+  def after_chain_filters # :nodoc:
+    @after_chain_filters ||= []
+  end
+  
+  def filter_before_call(message_call) # :nodoc:
+    before_call_filters.each do |filter|
       should_break = filter.call(message_call)
       return false if should_break === false
     end
     return true
   end
   
-  def filter_after(message_call) # :nodoc:
-    after_filters.each do |filter|
-      filter.call(message_call)
+  def filter_after_call(message_call) # :nodoc:
+    after_call_filters.each do |filter|
+      should_break = filter.call(message_call)
+      return false if should_break === false
+    end
+    return true
+  end
+  
+  def filter_before_branch(collector) # :nodoc:
+    before_branch_filters.each do |filter|
+      filter.call(collector)
+    end
+  end
+  
+  def filter_after_branch(original, branch) # :nodoc:
+    after_branch_filters.each do |filter|
+      filter.call(original, branch)
+    end
+  end
+  
+  def filter_before_chain(message) # :nodoc:
+    before_chain_filters.each do |filter|
+      filter.call(collector)
+    end
+  end
+  
+  def filter_after_chain(message) # :nodoc:
+    after_chain_filters.each do |filter|
+      filter.call(message)
     end
   end
   
   def collector # :nodoc:
-    @collector ||= ::Message::Recorder::Collector.new
+    @collector ||= ::Message::Recorder::Collector.new(:recorder => self)
   end
   
 end

data/lib/message-recorder/version.rb

@@ -23,7 +23,7 @@ module Message #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 0
-    TINY  = 3
+    TINY  = 4
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/chain_spec.rb

@@ -8,8 +8,8 @@ describe Message::Recorder::Chain do
   
   it "should record" do
     chain = Message::Recorder::Chain.new
-    chain.record(:downcase)
-    chain.record(:+, " world")
+    chain.record_message(:downcase)
+    chain.record_message(:+, " world")
     
     chain.size.should be_eql(2)
     chain.send_to("HELLO",@recorder).should be_eql("hello world")
@@ -17,8 +17,8 @@ describe Message::Recorder::Chain do
   
   it "should dup properly" do
     chain = Message::Recorder::Chain.new
-    chain.record(:downcase)
-    chain.record(:+, " world")
+    chain.record_message(:downcase)
+    chain.record_message(:+, " world")
     
     chain.dup.should be_eql(chain)
   end

data/spec/collector_spec.rb

@@ -9,9 +9,9 @@ describe Message::Recorder::Collector do
   end
   
   it "should record" do
-    chain = Message::Recorder::Collector.new
-    chain.record(:downcase)
-    chain.record(:+, " world")
+    chain = Message::Recorder::Collector.new(:recorder => @recorder)
+    chain.record_message(:downcase)
+    chain.record_message(:+, " world")
     
     chain.size.should be_eql(1)
     chain.first.size.should be_eql(2)
@@ -19,16 +19,16 @@ describe Message::Recorder::Collector do
   end
   
   it "should branch" do
-    chain = Message::Recorder::Collector.new
-    chain.record(:downcase)
-    chain.record(:+, " world")
+    chain = Message::Recorder::Collector.new(:recorder => @recorder)
+    chain.record_message(:downcase)
+    chain.record_message(:+, " world")
     
     chain.size.should be_eql(1)
     chain.first.size.should be_eql(2)
     chain.send_to("HELLO", @recorder).should be_eql(["hello world"])
     
     branch = chain.branch
-    branch.record(:+, "!")
+    branch.record_message(:+, "!")
     branch.size.should be_eql(1)
     branch.first.size.should be_eql(3)
     branch.send_to("HELLO", @recorder).should be_eql(["hello world!"])
@@ -37,7 +37,7 @@ describe Message::Recorder::Collector do
   end
   
   it "should collect a single chain" do
-    collector = Message::Recorder::Collector.new
+    collector = Message::Recorder::Collector.new(:recorder => @recorder)
     collector.collect_messages.downcase + " world"
     
     collector.size.should be_eql(1)
@@ -45,7 +45,7 @@ describe Message::Recorder::Collector do
   end
   
   it "should collect a branched chain" do
-    collector = Message::Recorder::Collector.new
+    collector = Message::Recorder::Collector.new(:recorder => @recorder)
     collector.collect_messages.downcase.with_results do
       intern
       capitalize
@@ -58,7 +58,7 @@ describe Message::Recorder::Collector do
   end
   
   it "should collect a branched chain" do
-    collector = Message::Recorder::Collector.new
+    collector = Message::Recorder::Collector.new(:recorder => @recorder)
     collector.collect_messages.compact.with_results do
       collect { |s| s.intern }
       collect { |s| s.capitalize }.with_results do

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>message recorder</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/message-recorder"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/message-recorder" class="numbers">1.0.3</a>
+      <a href="http://rubyforge.org/projects/message-recorder" class="numbers">1.0.4</a>
     </div>
     <h2>&#x2192; &#8216;message-recorder&#8217;</h2>
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: message-recorder
 version: !ruby/object:Gem::Version 
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors: 
 - Simon Menke
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-15 00:00:00 +01:00
+date: 2008-02-22 00:00:00 +01:00
 default_executable: 
 dependencies: []