message-recorder 1.0.1 → 1.0.2

data/Manifest.txt

@@ -13,6 +13,7 @@ lib/message-recorder/chain.rb
 lib/message-recorder/chaining_mock.rb
 lib/message-recorder/collector.rb
 lib/message-recorder/message.rb
+lib/message-recorder/message_call.rb
 lib/message-recorder/recorder.rb
 lib/message-recorder/version.rb
 log/debug.log
@@ -22,8 +23,6 @@ script/txt2html
 setup.rb
 spec/chain_spec.rb
 spec/collector_spec.rb
-spec/fob_spec.rb
-spec/message_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
 tasks/deployment.rake

data/lib/message-recorder.rb

@@ -25,6 +25,7 @@ module Message ; end
 
 require File.join(File.dirname(__FILE__), "message-recorder", "recorder")
 require File.join(File.dirname(__FILE__), "message-recorder", "message")
+require File.join(File.dirname(__FILE__), "message-recorder", "message_call")
 require File.join(File.dirname(__FILE__), "message-recorder", "chain")
 require File.join(File.dirname(__FILE__), "message-recorder", "collector")
 require File.join(File.dirname(__FILE__), "message-recorder", "branching_mock")

data/lib/message-recorder/chain.rb

@@ -27,15 +27,16 @@ class Message::Recorder::Chain < ::Array # :nodoc:
   end
   
   def record(m, *args, &block)
-    push Message::Recorder::Message.new(m, *args, &block)
+    push Message::Recorder::Message.new(m, args, block)
   end
   
   def send_to(subject_, recorder)
     inject(subject_) do |subject,message|
-      return nil unless recorder.filter_before(subject, message.method_name, message.arguments)
-      new_subject = message.send_to(subject, recorder)
-      recorder.filter_after(subject, message.method_name, message.arguments, new_subject)
-      new_subject
+      message_call = message.to_message_call(subject)
+      return nil unless recorder.filter_before(message_call)
+      message_call.execute
+      recorder.filter_after(message_call)
+      message_call.return_value
     end
   end
   

data/lib/message-recorder/message.rb

@@ -23,22 +23,14 @@
 class Message::Recorder::Message # :nodoc:
   attr_accessor :method_name, :arguments, :block
 
-  def initialize(m, *a, &b)
-    self.method_name = m
-    self.arguments   = a
-    self.block       = b
+  def initialize(method_name, arguments, block)
+    self.method_name = method_name
+    self.arguments   = arguments
+    self.block       = block
   end
-
-  def send_to(subject, recorder)
-    subject.__send__(self.method_name, *self.arguments, &self.block)
-  end
-
-  def arguments
-    @arguments ||= []
-  end
-
-  def block
-    @block ||= Proc.new { nil }
+  
+  def to_message_call(subject)
+    Message::Recorder::MessageCall.new(subject, method_name, arguments, block)
   end
   
 end

data/lib/message-recorder/message_call.rb

@@ -0,0 +1,45 @@
+# Copyright (c) 2008 Simon Menke
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# An object on this class is passed to the filter blocks
+class Message::Recorder::MessageCall
+  attr_reader :subject, :method_name, :arguments, :block, :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:
+    @subject      = subject
+    @method_name  = method_name
+    @arguments    = arguments
+    @block        = block
+    @return_value = return_value
+  end
+  
+  def execute # :nodoc:
+    @return_value = @subject.__send__(@method_name, *@arguments, &@block)
+  end
+  
+end

data/lib/message-recorder/recorder.rb

@@ -22,26 +22,28 @@
 # Example:
 #   recorder = Message::Recorder.new
 #   recorder.record.downcase.intern
-#   recorder.before do |subject, method, arguments|
-#     !(subject.nil? or subject.empty?)
+#   recorder.before do |message_call|
+#     p message_call.class # => Message::Recorder::MessageCall
+#     !(message_call.subject.nil? or message_callsubject.empty?)
 #   end
-#   recorder.after do |subject, method, arguments, return_value|
-#     p return_value
+#   recorder.after do |message_call|
+#     p message_call.class # => Message::Recorder::MessageCall
+#     p message_call.return_value
 #   end
 #   recorder.send_to(nil)        # => nil
 #   recorder.send_to("")         # => nil
 #   recorder.send_to("Mr_Henry") # => :mr_henry
 class Message::Recorder
   
-  # Takes a block with three arguments
-  #   recorder.before { |subject, method, arguments| ... }
+  # Takes a block with one argument of type Message::Recorder::MessageCall
+  #   recorder.before { |message_call| ... }
   # if the block returns false the chain will be broken.
   def before(&block)
     before_filters << block
   end
   
-  # Takes a block with four arguments
-  #   recorder.after { |subject, method, arguments, return_value| ... }
+  # Takes a block with one argument of type Message::Recorder::MessageCall
+  #   recorder.after { |message_call| ... }
   def after(&block)
     after_filters << block
   end
@@ -69,17 +71,17 @@ class Message::Recorder
     @before_filters ||= []
   end
   
-  def filter_before(subject, method, arguments) # :nodoc:
+  def filter_before(message_call) # :nodoc:
     before_filters.each do |filter|
-      should_break = filter.call(subject, method, arguments)
+      should_break = filter.call(message_call)
       return false if should_break === false
     end
     return true
   end
   
-  def filter_after(subject, method, arguments, return_value) # :nodoc:
+  def filter_after(message_call) # :nodoc:
     after_filters.each do |filter|
-      filter.call(subject, method, arguments, return_value)
+      filter.call(message_call)
     end
   end
   

data/lib/message-recorder/version.rb

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

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.1</a>
+      <a href="http://rubyforge.org/projects/message-recorder" class="numbers">1.0.2</a>
     </div>
     <h2>&#x2192; &#8216;message-recorder&#8217;</h2>
 
@@ -81,6 +81,37 @@
 </pre></p>
 
 
+	<p>Here we use two before filters to make sure that we get a non-nil adn non-empty subject.
+And we use an after filter to print the result of each message call.</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">recorder</span> <span class="punct">=</span> <span class="constant">Message</span><span class="punct">::</span><span class="constant">Recorder</span><span class="punct">.</span><span class="ident">new</span>
+<span class="ident">recorder</span><span class="punct">.</span><span class="ident">record</span><span class="punct">.</span><span class="ident">strip</span><span class="punct">.</span><span class="ident">downcase</span>
+<span class="ident">recorder</span><span class="punct">.</span><span class="ident">before</span> <span class="keyword">do</span> <span class="punct">|</span><span class="ident">message_call</span><span class="punct">|</span>
+  <span class="ident">message_call</span><span class="punct">.</span><span class="ident">subject</span><span class="punct">.</span><span class="ident">nil?</span> <span class="punct">==</span> <span class="constant">false</span>
+<span class="keyword">end</span>
+<span class="ident">recorder</span><span class="punct">.</span><span class="ident">before</span> <span class="keyword">do</span> <span class="punct">|</span><span class="ident">message_call</span><span class="punct">|</span>
+  <span class="ident">message_call</span><span class="punct">.</span><span class="ident">subject</span><span class="punct">.</span><span class="ident">empty?</span> <span class="punct">==</span> <span class="constant">false</span>
+<span class="keyword">end</span>
+<span class="ident">recorder</span><span class="punct">.</span><span class="ident">after</span> <span class="keyword">do</span> <span class="punct">|</span><span class="ident">message_call</span><span class="punct">|</span>
+  <span class="ident">puts</span> <span class="punct">&quot;</span><span class="string"><span class="expr">#{message_call.method_name}</span>: <span class="expr">#{message_call.return_value.inspect}</span></span><span class="punct">&quot;</span>
+<span class="keyword">end</span>
+<span class="ident">recorder</span><span class="punct">.</span><span class="ident">send_to</span><span class="punct">(</span><span class="constant">nil</span><span class="punct">)</span>           <span class="comment"># =&gt; nil</span>
+<span class="ident">recorder</span><span class="punct">.</span><span class="ident">send_to</span><span class="punct">(&quot;</span><span class="string"></span><span class="punct">&quot;)</span>            <span class="comment"># =&gt; nil</span>
+<span class="ident">recorder</span><span class="punct">.</span><span class="ident">send_to</span><span class="punct">(&quot;</span><span class="string">Mr. Henry</span><span class="punct">&quot;)</span>   <span class="comment"># =&gt; &quot;mr. henry&quot;</span>
+<span class="ident">recorder</span><span class="punct">.</span><span class="ident">send_to</span><span class="punct">(&quot;</span><span class="string"> Mr. Simon </span><span class="punct">&quot;)</span> <span class="comment"># =&gt; &quot;mr. henry&quot;</span>
+</pre></p>
+
+
+Print out:
+<pre>
+strip: "Mr. Henry" 
+downcase: "mr. henry" 
+strip: "Mr. Simon" 
+downcase: "mr. simon" 
+</pre>
+
 	<h2>Demonstration of usage</h2>
 
 

data/website/index.txt

@@ -36,6 +36,35 @@ end
 recorder.send_to("HELLO") # => [:hello, "Hello"]
 </pre>
 
+Here we use two before filters to make sure that we get a non-nil adn non-empty subject.
+And we use an after filter to print the result of each message call.
+
+<pre syntax="ruby">
+recorder = Message::Recorder.new
+recorder.record.strip.downcase
+recorder.before do |message_call|
+  message_call.subject.nil? == false
+end
+recorder.before do |message_call|
+  message_call.subject.empty? == false
+end
+recorder.after do |message_call|
+  puts "#{message_call.method_name}: #{message_call.return_value.inspect}"
+end
+recorder.send_to(nil)           # => nil
+recorder.send_to("")            # => nil
+recorder.send_to("Mr. Henry")   # => "mr. henry"
+recorder.send_to(" Mr. Simon ") # => "mr. henry"
+</pre>
+
+Print out:
+<pre>
+strip: "Mr. Henry"
+downcase: "mr. henry"
+strip: "Mr. Simon"
+downcase: "mr. simon"
+</pre>
+
 h2. Demonstration of usage
 
 This is a more complex example with nested branches.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: message-recorder
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - Simon Menke
@@ -42,6 +42,7 @@ files:
 - lib/message-recorder/chaining_mock.rb
 - lib/message-recorder/collector.rb
 - lib/message-recorder/message.rb
+- lib/message-recorder/message_call.rb
 - lib/message-recorder/recorder.rb
 - lib/message-recorder/version.rb
 - log/debug.log
@@ -51,8 +52,6 @@ files:
 - setup.rb
 - spec/chain_spec.rb
 - spec/collector_spec.rb
-- spec/fob_spec.rb
-- spec/message_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - tasks/deployment.rake

data/spec/fob_spec.rb

@@ -1,13 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Message::Recorder do
-  
-  it "should dup properly" do
-    chain = Message::Recorder::Chain.new
-    chain.record(:downcase)
-    chain.record(:+, " world")
-    
-    chain.dup.should be_eql(chain)
-  end
-  
-end

data/spec/message_spec.rb

@@ -1,89 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Message::Recorder::Message do
-  
-  before do
-    @recorder = Message::Recorder.new
-  end
-  
-  it "should init properly (with all arguments)" do
-    message = Message::Recorder::Message.new(:inject, 0) { |sum, n| sum += n }
-    message.method_name.should be_eql(:inject)
-    message.arguments.should be_eql([0])
-    message.block.should_not be_nil
-  end
-  
-  it "should init properly (with all arguments, except block)" do
-    message = Message::Recorder::Message.new(:inject, 0)
-    message.method_name.should be_eql(:inject)
-    message.arguments.should be_eql([0])
-    message.block.should_not be_nil
-  end
-  
-  it "should init properly (with all arguments, except m_arguments)" do
-    message = Message::Recorder::Message.new(:inject) { |sum, n| sum += n }
-    message.method_name.should be_eql(:inject)
-    message.arguments.should be_eql([])
-    message.block.should_not be_nil
-  end
-  
-  it "should init properly (with all arguments, except block m_arguments)" do
-    message = Message::Recorder::Message.new(:inject)
-    message.method_name.should be_eql(:inject)
-    message.arguments.should be_eql([])
-    message.block.should_not be_nil
-  end
-  
-  it "should send itself properly to a subject (without arguments and block)" do
-    message = Message::Recorder::Message.new(:downcase)
-    message.send_to("HELLO", @recorder).should be_eql("hello")
-  end
-  
-  it "should send itself properly to a subject (without block)" do
-    message = Message::Recorder::Message.new(:+, " world")
-    message.send_to("hello", @recorder).should be_eql("hello world")
-  end
-  
-  it "should send itself properly to a subject (without arguments)" do
-    message = Message::Recorder::Message.new(:inject) { |sum, n| sum + n }
-    message.send_to([1,2,3], @recorder).should be_eql(6)
-  end
-  
-  it "should send itself properly to a subject" do
-    message = Message::Recorder::Message.new(:inject, 6) { |sum, n| sum + n }
-    message.send_to([1,2,3], @recorder).should be_eql(12)
-  end
-  
-  it "should dup properly (with all arguments)" do
-    message = Message::Recorder::Message.new(:inject, 0) { |sum, n| sum += n }
-    message = message.dup
-    message.method_name.should be_eql(:inject)
-    message.arguments.should be_eql([0])
-    message.block.should_not be_nil
-  end
-  
-  it "should dup properly (with all arguments, except block)" do
-    message = Message::Recorder::Message.new(:inject, 0)
-    message = message.dup
-    message.method_name.should be_eql(:inject)
-    message.arguments.should be_eql([0])
-    message.block.should_not be_nil
-  end
-  
-  it "should dup properly (with all arguments, except m_arguments)" do
-    message = Message::Recorder::Message.new(:inject) { |sum, n| sum += n }
-    message = message.dup
-    message.method_name.should be_eql(:inject)
-    message.arguments.should be_eql([])
-    message.block.should_not be_nil
-  end
-  
-  it "should dup properly (with all arguments, except block m_arguments)" do
-    message = Message::Recorder::Message.new(:inject)
-    message = message.dup
-    message.method_name.should be_eql(:inject)
-    message.arguments.should be_eql([])
-    message.block.should_not be_nil
-  end
-  
-end