sender 1.4.3 → 1.5

data/CHANGELOG.rdoc

@@ -40,3 +40,17 @@ Fixed path problem for VERSION.rdoc.
 === 1.4.3 2010-06-29
 
 Fixed problems with superclass method definitions so __sender__ and __caller__ return the caller to the first method in the class chain.
+
+=== 1.5 2010-07-09
+
+Added to Kernel:
+* :each_backtrace_frame
+* :backtrace_includes?
+* :backtrace_includes_one_of?
+* :backtrace_frame_with
+* :backtrace_frames_with
+
+Added Hash-specification support for context inspection. Now functions take element value (object instance, class, method symbol, filename string,
+line number fixnum) or Hash containing frame detail specification. 
+
+Added Enumerator support. Non-block enumeration will iterate the backtrace that was the active context when :each_backtrace_frame was called.

data/Makefile

@@ -53,7 +53,7 @@ COUTFLAG = -o
 RUBY_EXTCONF_H = 
 cflags   = $(optflags) $(debugflags) $(warnflags)
 optflags = 
-debugflags = -gdwarf-2 -g3  
+debugflags = -g3  
 warnflags = -Wall -Wno-parentheses
 CFLAGS   =  -fno-common  $(cflags)  -fno-common -pipe -fno-common 
 INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir) -I/usr/src/ruby

data/README.rdoc

@@ -4,9 +4,11 @@ http://rubygems.org/gems/sender
 
 == DESCRIPTION:
 
-Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1, as well
-as providing object-oriented :backtrace supporting n-levels backward, and :backtrace_includes?,
-which allows contents of the backtrace to be queried.
+Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1.
+
+Also provides object-oriented :backtrace supporting n-levels backward, :each_backtrace_frame for iteration, :backtrace_includes?, 
+and :backtrace_includes_one_of? for context inspection, and :backtrace_frame_with and :backtrace_frames_with, which return
+matching frame information for the frame(s) matching the given description.
 
 == SUMMARY:
 	
@@ -17,10 +19,14 @@ which allows contents of the backtrace to be queried.
 	* __caller__
 	* backtrace
 	* backtrace( frames_to_trace_backward )
-	* backtrace_includes?( Class )
-	* backtrace_includes?( class_instance )
-	* backtrace_includes?( :symbol )
-	* backtrace_includes?( Class, class_instance, :symbol, ... )
+	* backtrace_includes?( Class, class_instance, :symbol, {frame_hash}, ... )
+	* backtrace_includes?( frames_to_trace_backward, Class, class_instance, :symbol, {frame_hash}, ... )
+	* backtrace_includes_one_of?( Class, class_instance, :symbol, {frame_hash}, ... )
+	* backtrace_includes_one_of?( frames_to_trace_backward, Class, class_instance, :symbol, {frame_hash}, ... )
+	* backtrace_frame_with( Class, class_instance, :symbol, {frame_hash}, ... )
+	* backtrace_frame_with( frames_to_trace_backward, Class, class_instance, :symbol, {frame_hash}, ... )
+	* backtrace_frames_with( Class, class_instance, :symbol, {frame_hash}, ... )
+	* backtrace_frames_with( frames_to_trace_backward, Class, class_instance, :symbol, {frame_hash}, ... )
 
 == INSTALL:
 
@@ -29,73 +35,103 @@ which allows contents of the backtrace to be queried.
 == EXAMPLE:
 
 	require 'sender'
-
 	require 'pp'
 
 	class Test
-  
-	  def initialize
-	    puts 'In method <Test>:initialize'
-	    puts 'Sender was: ' + __sender__.pretty_inspect.to_s
-	    puts 'Caller was: ' + __caller__.to_s
-	  end
-  
-	  def test
-	    puts 'In <Test>:test'
-	    self.another_test
-	  end
-  
-	  def another_test
-	    puts 'In method <Test>:another_test'
-	    test2 = Test2.new
-	    test2.and_another_test_in_another_object
-	  end
-    
-	  def and_another_test_in_another_object
-	    puts 'In method <Test>:and_another_test_in_another_object'
-	    puts 'Sender was: ' + __sender__.pretty_inspect.to_s
-	    puts 'Caller was: ' + __caller__.to_s
-	  end
-    
+
+		def initialize
+			puts 'In method <Test>:initialize'
+			puts 'Sender was: ' + __sender__.pretty_inspect.to_s
+			puts 'Caller was: ' + __caller__.to_s
+		end
+
+		def test
+			puts 'In <Test>:test'
+			self.another_test
+		end
+
+		def another_test
+			puts 'In method <Test>:another_test'
+			test2 = Test2.new
+			test2.and_another_test_in_another_object
+		end
+
+		def and_another_test_in_another_object
+			puts 'In method <Test>:and_another_test_in_another_object'
+			puts 'Sender was: ' + __sender__.pretty_inspect.to_s
+			puts 'Caller was: ' + __caller__.to_s
+		end
+
 	end
 
 	class Test2 < Test
-  
-	  def initialize
-	    puts 'In method <Test2>:initialize'
-	    super
-	    puts 'Sender was: ' + __sender__.pretty_inspect.to_s
-	    puts 'Caller was: ' + __caller__.to_s
-	    pp Kernel.backtrace
-	  end
-  
-	  def and_another_test_in_another_object
-	    puts 'In method <Test2>:and_another_test_in_another_object'
-	    super
-	    pp self
-	    puts 'Sender was: ' + __sender__.pretty_inspect.to_s
-	    puts 'Caller was: ' + __caller__.to_s
-	    pp Kernel.backtrace    
-	    pp Kernel.backtrace( 2 )
-	    puts 'These should be true:'
-	    pp Kernel.backtrace_includes?( :another_test )
-	    pp Kernel.backtrace_includes?( Test )
-	    pp Kernel.backtrace_includes?( $test )
-	    pp Kernel.backtrace_includes?( :another_test, Test, $test )
-	    puts 'These should be false:'
-	    pp Kernel.backtrace_includes?( :yet_another_test )
-	    pp Kernel.backtrace_includes?( Test2 )
-	    pp Kernel.backtrace_includes?( self )
-	    pp Kernel.backtrace_includes?( :yet_another_test, Test2, self )
-	  end
-  
-	end
 
-	$test = Test.new
-	$test.test
+		def initialize
+			puts 'In method <Test2>:initialize'
+			super
+			puts 'Sender was: ' + __sender__.pretty_inspect.to_s
+			puts 'Caller was: ' + __caller__.to_s
+			pp Kernel.backtrace
+		end
+
+		def and_another_test_in_another_object
+			puts 'In method <Test2>:and_another_test_in_another_object'
+			super
+			pp self
+			puts 'Sender was: ' + __sender__.pretty_inspect.to_s
+			puts 'Caller was: ' + __caller__.to_s
+			pp Kernel.backtrace		
+			pp Kernel.backtrace( 2 )
+			puts 'These should be true:'
+			pp Kernel.backtrace_includes?( :another_test )
+			pp Kernel.backtrace_includes?( Test )
+			pp Kernel.backtrace_includes?( $test )
+			pp Kernel.backtrace_includes?( :another_test, Test, $test )
+			pp Kernel.backtrace_includes?( "sender_test.rb" )
+			puts 'These should be false:'
+			pp Kernel.backtrace_includes?( :yet_another_test )
+			pp Kernel.backtrace_includes?( Test2 )
+			pp Kernel.backtrace_includes?( self )
+			pp Kernel.backtrace_includes?( :yet_another_test, Test2, self )
+			pp Kernel.backtrace_includes?( "sender_test.rbi" )
+
+			puts 'And now we get a step by step backtrace'
+			which_step = 1
+			Kernel.each_backtrace_frame do |this_frame|
+				puts 'Frame number ' + which_step.to_s + ':'
+				pp this_frame
+				which_step += 1
+			end
+			puts 'And now we try a backtrace inside a block.'
+			block_item = [ 'one_item' ]
+			block_item.each do |this_item|
+				pp Kernel.backtrace
+			end
 
-	puts 'Finished Test.'
-	exit
+			puts 'And :backtrace_includes_one_of?; this should be true:'
+			pp Kernel.backtrace_includes_one_of?( :some_method_that_does_not_exit, :another_test, :test, :some_other_test_that_does_not_exist )
+			puts 'as should this:'
+			pp Kernel.backtrace_includes_one_of?( { :method => :another_test, :object => $test }, { :method => :test } )
+
+			puts 'And :backtrace_frame_with; this should be a Hash:'
+			pp Kernel.backtrace_frame_with( :test )
+			puts 'as should this:'
+			pp Kernel.backtrace_frame_with( "sender_test.rb" )
+
+			puts 'And :backtrace_frames_with; this should be an Array of Hashes'
+			pp Kernel.backtrace_frames_with( :object => $test )
+			puts 'as should this:'
+			pp Kernel.backtrace_frames_with( :file => "sender_test.rb" )
+
+		    puts 'And try iterating with an Enumerator'
+		    enumerator = Kernel.each_backtrace_frame
+		    pp enumerator
+		    while result = enumerator.next
+		      pp result
+		    end
+
+		end
+	end
 
 == EXAMPLE's OUTPUT:
 	
@@ -106,65 +142,155 @@ which allows contents of the backtrace to be queried.
 	In method <Test>:another_test
 	In method <Test2>:initialize
 	In method <Test>:initialize
-	Sender was: #<Test:0x0000010102a400>
+	Sender was: #<Test:0x0000010081ba10>
 	Caller was: another_test
-	Sender was: #<Test:0x0000010102a400>
+	Sender was: #<Test:0x0000010081ba10>
 	Caller was: another_test
-	[{:object=>#<Test2:0x00000100823030>,
-	  :file=>"sender_test.rb",
-	  :line=>40,
-	  :method=>:initialize},
+	[{:object=>#<Test2:0x0000010081a7e8>,
+		:file=>"sender_test.rb",
+		:line=>39,
+		:method=>:initialize},
 	 {:object=>Test2, :file=>nil, :line=>nil, :method=>:new},
-	 {:object=>#<Test:0x0000010102a400>,
-	  :file=>"sender_test.rb",
-	  :line=>20,
-	  :method=>:another_test},
-	 {:object=>#<Test:0x0000010102a400>,
-	  :file=>"sender_test.rb",
-	  :line=>15,
-	  :method=>:test},
-	 {:object=>main, :file=>"sender_test.rb", :line=>66, :method=>:"<main>"},
+	 {:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>20,
+		:method=>:another_test},
+	 {:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>15,
+		:method=>:test},
+	 {:object=>main, :file=>"sender_test.rb", :line=>96, :method=>:"<main>"},
 	 {:object=>main, :file=>"<main>", :line=>0, :method=>:"<main>"}]
 	In method <Test2>:and_another_test_in_another_object
 	In method <Test>:and_another_test_in_another_object
-	This is the super method for :and_another_test_in_another_object
-	Sender was: #<Test2:0x00000100823030>
+	Sender was: #<Test2:0x0000010081a7e8>
 	Caller was: another_test
-	#<Test2:0x00000100823030>
-	Sender was: #<Test:0x0000010102a400>
+	#<Test2:0x0000010081a7e8>
+	Sender was: #<Test:0x0000010081ba10>
 	Caller was: another_test
-	[{:object=>#<Test2:0x00000100823030>,
-	  :file=>"sender_test.rb",
-	  :line=>49,
-	  :method=>:and_another_test_in_another_object},
-	 {:object=>#<Test:0x0000010102a400>,
-	  :file=>"sender_test.rb",
-	  :line=>21,
-	  :method=>:another_test},
-	 {:object=>#<Test:0x0000010102a400>,
-	  :file=>"sender_test.rb",
-	  :line=>15,
-	  :method=>:test},
-	 {:object=>main, :file=>"sender_test.rb", :line=>66, :method=>:"<main>"},
+	[{:object=>#<Test2:0x0000010081a7e8>,
+		:file=>"sender_test.rb",
+		:line=>48,
+		:method=>:and_another_test_in_another_object},
+	 {:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>21,
+		:method=>:another_test},
+	 {:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>15,
+		:method=>:test},
+	 {:object=>main, :file=>"sender_test.rb", :line=>96, :method=>:"<main>"},
 	 {:object=>main, :file=>"<main>", :line=>0, :method=>:"<main>"}]
-	[{:object=>#<Test2:0x00000100823030>,
-	  :file=>"sender_test.rb",
-	  :line=>50,
-	  :method=>:and_another_test_in_another_object},
-	 {:object=>#<Test:0x0000010102a400>,
-	  :file=>"sender_test.rb",
-	  :line=>21,
-	  :method=>:another_test}]
+	[{:object=>#<Test2:0x0000010081a7e8>,
+		:file=>"sender_test.rb",
+		:line=>49,
+		:method=>:and_another_test_in_another_object},
+	 {:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>21,
+		:method=>:another_test}]
 	These should be true:
 	true
 	true
 	true
 	true
+	true
 	These should be false:
 	false
 	false
 	false
 	false
+	false
+	And now we get a step by step backtrace
+	Frame number 1:
+	{:object=>#<Test:0x0000010081ba10>,
+	 :file=>"sender_test.rb",
+	 :line=>21,
+	 :method=>:another_test}
+	Frame number 2:
+	{:object=>#<Test:0x0000010081ba10>,
+	 :file=>"sender_test.rb",
+	 :line=>15,
+	 :method=>:test}
+	Frame number 3:
+	{:object=>main, :file=>"sender_test.rb", :line=>96, :method=>:"<main>"}
+	Frame number 4:
+	{:object=>main, :file=>"<main>", :line=>0, :method=>:"<main>"}
+	And now we try a backtrace inside a block.
+	[{:object=>#<Test2:0x0000010081a7e8>,
+		:file=>"sender_test.rb",
+		:line=>73,
+		:method=>:"block in and_another_test_in_another_object"},
+	 {:object=>["one_item"], :file=>nil, :line=>nil, :method=>:each},
+	 {:object=>#<Test2:0x0000010081a7e8>,
+		:file=>"sender_test.rb",
+		:line=>72,
+		:method=>:and_another_test_in_another_object},
+	 {:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>21,
+		:method=>:another_test},
+	 {:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>15,
+		:method=>:test},
+	 {:object=>main, :file=>"sender_test.rb", :line=>96, :method=>:"<main>"},
+	 {:object=>main, :file=>"<main>", :line=>0, :method=>:"<main>"}]
+	And :backtrace_includes_one_of?; this should be true:
+	true
+	as should this:
+	true
+	And :backtrace_frame_with; this should be a Hash:
+	{:object=>#<Test:0x0000010081ba10>,
+	 :file=>"sender_test.rb",
+	 :line=>15,
+	 :method=>:test}
+	as should this:
+	{:object=>#<Test:0x0000010081ba10>,
+	 :file=>"sender_test.rb",
+	 :line=>21,
+	 :method=>:another_test}
+	And :backtrace_frames_with; this should be an Array of Hashes
+	[{:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>21,
+		:method=>:another_test},
+	 {:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>15,
+		:method=>:test}]
+	as should this:
+	[{:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>21,
+		:method=>:another_test},
+	 {:object=>#<Test:0x0000010081ba10>,
+		:file=>"sender_test.rb",
+		:line=>15,
+		:method=>:test},
+	 {:object=>main, :file=>"sender_test.rb", :line=>96, :method=>:"<main>"}]
+	And try iterating with an Enumerator
+	#<Enumerator:0x000001010480e0>
+	{:object=>#<Test2:0x0000010081a388>,
+	 :file=>"sender_test.rb",
+	 :line=>92,
+	 :method=>:and_another_test_in_another_object}
+	{:object=>#<Test:0x0000010081b770>,
+	 :file=>"sender_test.rb",
+	 :line=>21,
+	 :method=>:another_test}
+	{:object=>#<Test:0x0000010081b770>,
+	 :file=>"sender_test.rb",
+	 :line=>15,
+	 :method=>:test}
+	{:object=>main, :file=>"sender_test.rb", :line=>103, :method=>:"<main>"}
+	{:object=>main, :file=>"<main>", :line=>0, :method=>:"<main>"}
+	sender_test.rb:94:in `next': iteration reached at end (StopIteration)
+		from sender_test.rb:94:in `and_another_test_in_another_object'
+		from sender_test.rb:21:in `another_test'
+		from sender_test.rb:15:in `test'
+		from sender_test.rb:103:in `<main>'
 	Finished Test.
 
 == LICENSE:

data/Rakefile

@@ -5,13 +5,13 @@ require 'rake/extensiontask'
 Hoe.spec 'sender' do
   developer( 'Asher', 'asher@ridiculouspower.com' )
   self.rubyforge_name   = 'asher'
+  self.version          = File.open( 'VERSION.rdoc' ).readline
   self.readme_file			= 'README.rdoc'
   self.history_file     = 'CHANGELOG.rdoc'
   self.extra_rdoc_files	= FileList['*.rdoc']
   self.spec_extras			= { :extensions => ["ext/sender/extconf.rb"] }
   self.extra_dev_deps << ['rake-compiler', '>= 0']  
 
-  self.version=File.open( 'VERSION.rdoc' ).readline
 
   Rake::ExtensionTask.new( 'sender', spec ) do |ext|
     ext.lib_dir = File.join('lib', 'sender')

data/VERSION.rdoc

@@ -1 +1 @@
-1.4.3
+1.5

data/ext/sender/RPSender_internal.h

@@ -4,6 +4,11 @@
 	#include "ruby.h"
 	#include "eval_intern.h"
 
+	typedef enum BOOL_e	{
+		FALSE,
+		TRUE
+	} BOOL;
+
 	rb_control_frame_t* RPRuby_internal_framePriorTo( rb_control_frame_t* control_frame );
 	VALUE RPSender_internal_backtraceHashForControlFrame( const rb_control_frame_t* c_top_of_control_frame );
 

data/ext/sender/RubySourceSupport.c

@@ -65,11 +65,16 @@ found:
     return line_no;
 }
 
-
-
-
-
-
-
-
-
+struct enumerator* enumerator_ptr(VALUE obj)
+{
+    struct enumerator *ptr;
+	
+    Data_Get_Struct(obj, struct enumerator, ptr);
+	
+	//	modified because a call to a local version of enumerator_mark won't verify
+	
+    if (!ptr || ptr->obj == Qundef) {
+		rb_raise(rb_eArgError, "uninitialized enumerator");
+    }
+    return ptr;
+}

data/ext/sender/RubySourceSupport.h

@@ -5,8 +5,69 @@
 	#include "eval_intern.h"
 	#include "vm_core.h"
 
+	#define MAX_POSBUF 128
+
+	enum context_type {
+		CONTINUATION_CONTEXT = 0,
+		FIBER_CONTEXT = 1,
+		ROOT_FIBER_CONTEXT = 2
+	};
+
+	typedef struct rb_context_struct {
+		enum context_type type;
+		VALUE self;
+		int argc;
+		VALUE value;
+		VALUE *vm_stack;
+	#ifdef CAPTURE_JUST_VALID_VM_STACK
+		int vm_stack_slen;  /* length of stack (head of th->stack) */
+		int vm_stack_clen;  /* length of control frames (tail of th->stack) */
+	#endif
+		VALUE *machine_stack;
+		VALUE *machine_stack_src;
+	#ifdef __ia64
+		VALUE *machine_register_stack;
+		VALUE *machine_register_stack_src;
+		int machine_register_stack_size;
+	#endif
+		rb_thread_t saved_thread;
+		rb_jmpbuf_t jmpbuf;
+		int machine_stack_size;
+	} rb_context_t;
+
+	enum fiber_status {
+		CREATED,
+		RUNNING,
+		TERMINATED
+	};
+
+	typedef struct rb_fiber_struct {
+		rb_context_t cont;
+		VALUE prev;
+		enum fiber_status status;
+		struct rb_fiber_struct *prev_fiber;
+		struct rb_fiber_struct *next_fiber;
+	} rb_fiber_t;
+
+	struct enumerator {
+		VALUE obj;
+		ID    meth;
+		VALUE args;
+		VALUE fib;
+		VALUE dst;
+		VALUE no_next;
+	};
+
+	#define GetFiberPtr(obj, ptr)  do {\
+				ptr = (rb_fiber_t*)DATA_PTR(obj);\
+				if (!ptr) rb_raise(rb_eFiberError, "uninitialized fiber");\
+			} while(0)
+
+
 	ID frame_func_id( rb_control_frame_t *cfp );
 	ID rb_frame_caller(void);
 	int rb_vm_get_sourceline(const rb_control_frame_t *cfp);
-
+	void control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp);
+	struct enumerator* enumerator_ptr(VALUE obj);
+	
 #endif

data/ext/sender/rb_Kernel.c

@@ -12,20 +12,29 @@
 
 void Init_senderKernel()	{
 	
-	rb_define_singleton_method( rb_mKernel, "backtrace",				rb_RPRuby_Sender_Kernel_backtrace,				-1 );
-	rb_define_singleton_method( rb_mKernel, "backtrace_includes?",		rb_RPRuby_Sender_Kernel_backtrace_includes,		-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace",						rb_RPRuby_Sender_Kernel_backtrace,						-1 );
+	rb_define_singleton_method( rb_mKernel, "each_backtrace_frame",				rb_RPRuby_Sender_Kernel_each_backtrace_frame,			-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace_includes?",				rb_RPRuby_Sender_Kernel_backtrace_includes,				-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace_includes_one_of?",		rb_RPRuby_Sender_Kernel_backtrace_includes_one_of,		-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace_frame_with",				rb_RPRuby_Sender_Kernel_backtrace_frame_with,			-1 );
+	rb_define_singleton_method( rb_mKernel, "backtrace_frames_with",			rb_RPRuby_Sender_Kernel_backtrace_frames_with,			-1 );
+
 
 }
 
+static VALUE rb_eFiberError;
+
+#define RPRUBY_SENDER_ERROR_NO_ENUMERATORS							"Enumerators not currently enabled due to difficulty with Fiber support."
+
 /***************************************************************************************************************************************************************
 ****************************************************************************************************************************************************************
 													Ruby Kernel Methods
 ****************************************************************************************************************************************************************
 ***************************************************************************************************************************************************************/
 
-/******************
- *  __backtrace__  *
- ******************/
+/**********************
+ *  Kernel.backtrace  *
+ *********************/
 
 /*
  * call-seq:
@@ -73,6 +82,10 @@ VALUE rb_RPRuby_Sender_Kernel_backtrace(	int		argc,
 		
 		VALUE	rb_frame_hash	=	rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	& c_current_context_frame );
 	   
+		if ( rb_frame_hash == Qnil )	{
+			break;
+		}
+		
 		//	push hash to array
 		rb_ary_push(	rb_return_array,
 						rb_frame_hash );
@@ -84,10 +97,83 @@ VALUE rb_RPRuby_Sender_Kernel_backtrace(	int		argc,
    return rb_return_array;
 }
 
+/*********************************
+ *  Kernel.each_backtrace_frame  *
+ ********************************/
+
+/*
+ * call-seq:
+ *   Kernel.each_backtrace_frame( & block )
+ *
+ * Return array of hashes with object and method frame information for backtrace.
+ * Specifying number_of_frames will cause only the last number_of_frames to be returned.
+ * Kernel.backtrace returns all frames including the current context (__method__/__callee__).
+ */
+VALUE rb_RPRuby_Sender_Kernel_each_backtrace_frame(	int		argc,
+													VALUE*	args,
+													VALUE	rb_self )	{
+
+	rb_thread_t*			c_thread					= GET_THREAD();
+	//	Get the current frame - we're doing a backtrace, so our current working frame to start is the first previous thread
+	rb_control_frame_t*		c_current_context_frame		= RUBY_VM_PREVIOUS_CONTROL_FRAME( RUBY_VM_PREVIOUS_CONTROL_FRAME( c_thread->cfp ) );
+	
+	//	c_top_of_control_frame describes the top edge of the stack trace
+	//	set c_top_of_control_frame to the first frame in <main>
+    rb_control_frame_t*		c_top_of_control_frame	=	RUBY_VM_NEXT_CONTROL_FRAME( RUBY_VM_NEXT_CONTROL_FRAME( (void *)( c_thread->stack + c_thread->stack_size ) ) );
+	
+	VALUE	rb_stored_backtrace_array	=	Qnil;
+	
+	//	if we were passed a stored backtrace array, use it
+	if (	argc == 1
+		&&	TYPE( args[ 0 ] ) == T_ARRAY )	{
+		rb_stored_backtrace_array	=	args[ 0 ];
+	}
+				
+	//	for each control frame:
+    while ( c_current_context_frame < c_top_of_control_frame ) {
+
+		VALUE	rb_frame_hash;
+		//	if we are using a stored backtrace we don't need to ask for a new hash
+		if ( rb_stored_backtrace_array == Qnil )	{
+			rb_frame_hash	=	rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	& c_current_context_frame );
+		}
+		else {
+			rb_frame_hash	=	rb_ary_shift( rb_stored_backtrace_array );
+		}
 
-/*****************************
- *  __backtrace_includes?__  *
- ****************************/
+		if ( rb_frame_hash == Qnil )	{
+			break;
+		}
+		
+		//	if we try to iterate using an Enumerator we will lose our context
+		if ( ! rb_block_given_p() )	{
+			
+			//	we solve this by assuming that the desired context is the moment when each_backtrace_frame is called
+			//	this allows us to store the backtrace and iterate it as we want
+			//	the only downside is that we have to get the entire backtrace first in order to store it
+			rb_stored_backtrace_array	=	rb_RPRuby_Sender_Kernel_backtrace(	0,
+																				NULL,
+																				rb_self );
+		
+			RETURN_ENUMERATOR( rb_self, 1, & rb_stored_backtrace_array );
+			//rb_raise( rb_eArgError, RPRUBY_SENDER_ERROR_NO_ENUMERATORS );
+		}
+		
+		//	otherwise, yield the block
+		rb_yield( rb_frame_hash );
+		
+		//	only move the frame if we are not using a stored backtrace
+		if ( rb_stored_backtrace_array == Qnil )	{
+			c_current_context_frame = RUBY_VM_PREVIOUS_CONTROL_FRAME( c_current_context_frame );		
+		}
+	}
+	
+	return Qnil;
+}
+	
+/********************************
+ *  Kernel.backtrace_includes?  *
+ *******************************/
 
 /*
  * call-seq:
@@ -102,12 +188,40 @@ VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int		argc,
 													VALUE*	args,
 													VALUE	rb_self )	{
 	
+	//	this function is also used for 
+	//	* backtrace_includes_one_of?
+	//	* backtrace_includes_frame?
+	//	* backtrace_includes_one_of_frames?
+	
 	//	create tracking array
 	VALUE	rb_tracking_array	=	rb_ary_new();
 	
 	//	populate tracking array with methods/objects
-	int	c_which_arg	=	0;
-	for ( c_which_arg = 0 ; c_which_arg < argc ; c_which_arg++ )	{
+	//	optional - if first arg is Qtrue, we are looking for one of the args instead of all of the args
+	int		c_which_arg				=	0;
+	BOOL	c_requires_all_items	= TRUE;
+	if (	args[ 0 ] == Qnil
+		||	(	argc > 1
+			 &&	args[ 1 ] == Qnil ) )	{
+		c_which_arg++;
+		c_requires_all_items = FALSE;
+	}
+	BOOL	c_return_frame	=	FALSE;
+	if (	args[ 0 ] == Qfalse
+		||	(	argc > 1
+			 &&	args[ 1 ] == Qfalse ) )	{
+		c_which_arg++;
+		c_return_frame = TRUE;
+	}
+	BOOL	c_return_all_frames	=	FALSE;
+	if (	args[ 0 ] == Qtrue
+		||	(	argc > 1
+			 &&	args[ 1 ] == Qtrue ) )	{
+		c_which_arg++;
+		c_return_all_frames = TRUE;
+	}
+	int	c_args_offset	=	c_which_arg;
+	for ( ; c_which_arg < argc ; c_which_arg++ )	{
 		rb_ary_push(	rb_tracking_array,
 						args[ c_which_arg ] );
 	}
@@ -120,6 +234,29 @@ VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int		argc,
 	//	set c_top_of_control_frame to the first frame in <main>
     rb_control_frame_t*		c_top_of_control_frame	=	RUBY_VM_NEXT_CONTROL_FRAME( RUBY_VM_NEXT_CONTROL_FRAME( (void *)( c_thread->stack + c_thread->stack_size ) ) );
 	
+	VALUE	rb_test_index_array	=	rb_ary_new();
+	//	:object
+	//	instance or class
+	rb_ary_push(	rb_test_index_array,
+					ID2SYM( rb_intern( "object" ) ) );
+	//	:method				
+	rb_ary_push(	rb_test_index_array,
+					ID2SYM( rb_intern( "method" ) ) );
+	//	:file
+	rb_ary_push(	rb_test_index_array,
+					ID2SYM( rb_intern( "file" ) ) );
+	//	:line
+	rb_ary_push(	rb_test_index_array,
+					ID2SYM( rb_intern( "line" ) ) );
+	
+	//	only used if c_return_all_frames == TRUE
+	VALUE	rb_frame_hashes_array	=	Qnil;
+	if ( c_return_all_frames == TRUE )	{
+		rb_frame_hashes_array		=	rb_ary_new();
+	}
+	
+	VALUE	rb_frame_hash;
+	
 	//	for each control frame:
     while ( c_current_context_frame < c_top_of_control_frame ) {
 	   
@@ -127,61 +264,272 @@ VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int		argc,
 		int	c_which_member;
 		for ( c_which_member = 0 ; c_which_member < RARRAY_LEN( rb_tracking_array ) ; c_which_member++ )	{
 		   
-			VALUE	rb_array_member	=	args[ c_which_member ];
+			VALUE	rb_this_arg	=	args[ c_which_member + c_args_offset ];
 		   
-			int		matched	=	0;
+			BOOL		matched	=	FALSE;
 		   
-			//	if rb_array_member is a class
-			if	( TYPE( rb_array_member ) == T_CLASS ) {
-				//	if rb_array_member is the current frame's object's class
-				if ( rb_array_member == rb_class_of( c_current_context_frame->self ) )	{
-					matched	=	1;
+			rb_frame_hash	=	rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	& c_current_context_frame );
+			
+			//	if we have a hash we are testing multiple items in a frame
+			if ( TYPE( rb_this_arg ) == T_HASH )	{
+
+				VALUE	rb_frame_test_array	=	rb_obj_clone( rb_test_index_array );
+			
+				//	for each element that we could test for
+				int	c_which_index;
+				int	c_skipped_index_count	=	0;
+				for ( c_which_index = 0 ; c_which_index < RARRAY_LEN( rb_frame_test_array ) ; c_which_index++ )	{
+					
+					VALUE	rb_this_index	=	RARRAY_PTR( rb_frame_test_array )[ c_which_index ];
+					
+					//	see if our requested test hash includes the potential test element
+					if ( rb_hash_lookup(	rb_this_arg,
+											rb_this_index ) != Qnil )	{
+						
+						VALUE	rb_required_element	=	rb_hash_aref(	rb_this_arg,
+																		rb_this_index );
+						VALUE	rb_frame_element	=	rb_hash_aref(	rb_frame_hash,
+																		rb_this_index	);
+									 						
+						//	if it does, we need to see if the current frame's element matches this element
+						VALUE	rb_required_element_klass;
+						if ( rb_required_element == rb_frame_element
+							//	if we have a string, which is a filename
+							||	(	TYPE( rb_required_element ) == T_STRING
+								 &&	rb_funcall( rb_frame_element, rb_intern( "==" ), 1, rb_required_element ) == Qtrue )
+							//	if we have a class, which is a special case for :object
+							||	(	rb_this_index == ID2SYM( rb_intern( "class" ) ) 
+								 &&	( rb_required_element_klass = ( ( TYPE( rb_required_element ) == T_CLASS ) ? rb_required_element : rb_funcall( rb_required_element, rb_intern( "class" ), 0 ) ) )
+								 &&	rb_required_element_klass == rb_required_element ) )	{
+
+							rb_ary_delete_at(	rb_frame_test_array,
+												c_which_index );
+							c_which_index--;
+						}
+					}
+					else {
+						c_skipped_index_count++;
+					}
+
+					if ( RARRAY_LEN( rb_frame_test_array ) == c_skipped_index_count )	{
+						if ( c_return_frame == TRUE )	{
+							return rb_frame_hash;
+						}
+						else if ( c_return_all_frames == TRUE )	{
+							rb_ary_push(	rb_frame_hashes_array,
+											rb_frame_hash );
+						}
+						else {
+							return Qtrue;							
+						}
+					}					
 				}
 			}
-			//	if rb_array_member is a method symbol and matches our current frame's method
-			else if	( TYPE( rb_array_member ) == T_SYMBOL )	{
-			   
-				if ( rb_to_id( rb_array_member ) == frame_func_id( c_current_context_frame ) )	{
-					matched	=	1;
+			else {
+
+				//	:object => <class:instance>
+				if	(	TYPE( rb_this_arg ) == T_OBJECT )	{
+
+					if ( rb_hash_aref(	rb_frame_hash,
+										ID2SYM( rb_intern( "object" ) ) ) == rb_this_arg )	{
+						matched = TRUE;
+					}
 				}
-			}
-			//	if rb_array_member is an object
-			else if ( TYPE( rb_array_member ) == T_OBJECT )	{
-				//	if rb_array_member is the current frame's object (self)
-				if ( rb_array_member == c_current_context_frame->self )	{
-					matched	=	1;
+				//	:object => <class>
+				else if	( TYPE( rb_this_arg ) == T_CLASS )	{
+					
+					VALUE	rb_frame_object			=	rb_hash_aref(	rb_frame_hash,
+																		ID2SYM( rb_intern( "object" ) ) );
+					VALUE	rb_frame_object_klass	=	TYPE( rb_frame_object ) == T_CLASS ? rb_frame_object : rb_funcall( rb_frame_object, rb_intern( "class" ), 0 );
+					if ( rb_frame_object_klass == rb_this_arg )	{
+						matched = TRUE;
+					}
+				}
+				//	:method => :method
+				else if	( TYPE( rb_this_arg ) == T_SYMBOL )	{
+				   
+					if ( rb_hash_aref(	rb_frame_hash,
+										ID2SYM( rb_intern( "method" ) ) ) == rb_this_arg )	{
+						matched = TRUE;
+					}
+				}
+				//	:file => "filename"
+				else if ( TYPE( rb_this_arg ) == T_STRING )	{
+					VALUE	rb_filename	=	rb_hash_aref(	rb_frame_hash,
+															ID2SYM( rb_intern( "file" ) ) );
+					VALUE	rb_comparison	=	rb_funcall( rb_filename, rb_intern( "==" ), 1, rb_this_arg );
+					if ( rb_comparison == Qtrue )	{
+						matched = TRUE;
+					}
+				}
+				//	:line => number
+				else if ( TYPE( rb_this_arg ) == T_FIXNUM )	{
+					if ( rb_hash_aref(	rb_frame_hash,
+										ID2SYM( rb_intern( "line" ) ) ) == rb_this_arg )	{
+						matched = TRUE;
+					}
 				}
-			}
-		   
-			//	if array member exists in frame, remove from array
-			if ( matched )	{
-				//	delete this index
-				rb_ary_delete_at(	rb_tracking_array,
-									c_which_member );
 			   
-				//	decrement the loop iterator so that the increase is offset
-				//	this is necessary since we just removed an index and are iterating vs. the length of the array
-				c_which_member--;
+				//	if array member exists in frame, remove from array
+				if ( matched )	{
+					if ( c_requires_all_items == FALSE )	{
+						if ( c_return_frame == TRUE )	{
+							return rb_frame_hash;
+						}
+						else {
+							return Qtrue;							
+						}
+
+					}
+					else {
+						
+						//	delete this index
+						rb_ary_delete_at(	rb_tracking_array,
+											c_which_member );
+						
+						//	decrement the loop iterator so that the increase is offset
+						//	this is necessary since we just removed an index and are iterating vs. the length of the array
+						c_which_member--;
+					}
+				}
 			}
 		}
 	   
 		//	if array is empty, return true
 		//	we check here as well as at the end so we can stop iterating the backtrace if we find all our items
 		if ( RARRAY_LEN( rb_tracking_array ) == 0 )	{
-			return Qtrue;
+			if ( c_return_frame == TRUE )	{
+				return rb_frame_hash;
+			}
+			else if ( c_return_all_frames == TRUE )	{
+				rb_ary_push(	rb_frame_hashes_array,
+								rb_frame_hash );
+				return rb_frame_hashes_array;
+			}
+			else {
+				return Qtrue;							
+			}
 		}
 		c_current_context_frame = RUBY_VM_PREVIOUS_CONTROL_FRAME( c_current_context_frame );		
 	}
-
+	
+	if (	c_return_all_frames == TRUE
+		&&	RARRAY_LEN( rb_frame_hashes_array ) > 0 ) {
+		return rb_frame_hashes_array;
+	}
 	//	if we finish iterating frames and still have items in the array, return false
-	if ( RARRAY_LEN( rb_tracking_array ) > 0 )	{
+	else if ( RARRAY_LEN( rb_tracking_array ) > 0 )	{
 		return Qfalse;
 	}
-	
 	//	otherwise, return true
-	return Qtrue;
+	else if ( c_return_frame == TRUE )	{
+		return rb_frame_hash;
+	}
+	else {
+		return Qtrue;							
+	}
+	//	we don't get here
+	return Qnil;
+}
+
+/***************************************
+ *  Kernel.backtrace_includes_one_of?  *
+ **************************************/
+
+/*
+ * call-seq:
+ *   Kernel.backtrace_includes_one_of?( method_or_object, ... ) -> true or false
+ *   Kernel.backtrace_includes_one_of?( number_of_frames, method_or_object, ... ) -> true or false
+ *
+ * Returns whether one of the specified methods or objects or classes are in the current backtrace context.
+ * Kernel.backtrace_includes_one_of? begins with the prior frame, so asking if the backtrace includes the current method
+ * will only report true if the current method is part of the earlier call chain.
+ */
+VALUE rb_RPRuby_Sender_Kernel_backtrace_includes_one_of(	int		argc,
+															VALUE*	args,
+															VALUE	rb_self )	{
+
+	//	method implemented as special case of backtrace_includes?
+	
+	//	create a new array starting with Qtrue and then followed by args
+	VALUE		c_methods_array[ argc + 1 ];
+	c_methods_array[ 0 ] = Qnil;
+	int	c_which_arg;
+	for ( c_which_arg = 0 ; c_which_arg < argc ; c_which_arg++ )	{
+		c_methods_array[ c_which_arg + 1 ] = args[ c_which_arg ];
+	}
+	return rb_RPRuby_Sender_Kernel_backtrace_includes(	argc + 1,
+														c_methods_array,
+														rb_self );
+}
+
+/*********************************
+ *  Kernel.backtrace_frame_with  *
+ ********************************/
+
+/*
+ * call-seq:
+ *   Kernel.backtrace_frame_with( method_or_object, ... ) -> true or false
+ *   Kernel.backtrace_frame_with( number_of_frames, method_or_object, ... ) -> true or false
+ *
+ * Returns first frame matching specifications, which work like Kernel.backtrace_includes?. 
+ * Kernel.backtrace_includes_one_of? begins with the prior frame, so asking if the backtrace includes the current method
+ * will only report true if the current method is part of the earlier call chain.
+ */
+VALUE rb_RPRuby_Sender_Kernel_backtrace_frame_with(	int		argc,
+													VALUE*	args,
+													VALUE	rb_self )	{
+	
+	//	create a new array starting with Qtrue and then followed by args
+	VALUE		c_methods_array[ argc + 1 ];
+	//	Qfalse tells backtrace_includes to return frame hash instead of true/false
+	c_methods_array[ 0 ] = Qfalse;
+	int	c_which_arg;
+	for ( c_which_arg = 0 ; c_which_arg < argc ; c_which_arg++ )	{
+		c_methods_array[ c_which_arg + 1 ] = args[ c_which_arg ];
+	}
+	return rb_RPRuby_Sender_Kernel_backtrace_includes_one_of(	argc + 1,
+																c_methods_array,
+																rb_self );	
+}
+
+/**********************************
+ *  Kernel.backtrace_frames_with  *
+ *********************************/
+
+/*
+ * call-seq:
+ *   Kernel.backtrace_frames_with( method_or_object, ... ) -> true or false
+ *   Kernel.backtrace_frames_with( number_of_frames, method_or_object, ... ) -> true or false
+ *
+ * Returns all frames matching specifications, which work like Kernel.backtrace_includes?. 
+ * Kernel.backtrace_includes_one_of? begins with the prior frame, so asking if the backtrace includes the current method
+ * will only report true if the current method is part of the earlier call chain.
+ */
+VALUE rb_RPRuby_Sender_Kernel_backtrace_frames_with(	int		argc,
+														VALUE*	args,
+														VALUE	rb_self )	{
+	
+	
+	//	create a new array starting with Qtrue and then followed by args
+	VALUE		c_methods_array[ argc + 1 ];
+	//	Qtrue tells backtrace_includes to return all frame hashes specified instead of the first
+	c_methods_array[ 0 ] = Qtrue;
+	int	c_which_arg;
+	for ( c_which_arg = 0 ; c_which_arg < argc ; c_which_arg++ )	{
+		c_methods_array[ c_which_arg + 1 ] = args[ c_which_arg ];
+	}
+	return rb_RPRuby_Sender_Kernel_backtrace_includes(	argc + 1,
+														c_methods_array,
+														rb_self );	
 }
 
+/***************************************************************************************************************************************************************
+****************************************************************************************************************************************************************
+													Internal Methods
+****************************************************************************************************************************************************************
+***************************************************************************************************************************************************************/
+
 /**********************************
  *  backtraceHashForControlFrame  *
  *********************************/
@@ -214,6 +562,7 @@ VALUE rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	rb_control_
 			
 			//	get name of instruction sequence
 			rb_method_name			=	ID2SYM( rb_intern( StringValuePtr( iseq->name ) ) );				
+			rb_object_for_frame	=	( *c_current_frame )->self;
 		}
 	}
 	else if ( RUBYVM_CFUNC_FRAME_P( *c_current_frame ) ) {
@@ -221,6 +570,68 @@ VALUE rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	rb_control_
 		//	get name of method
 		c_method_name				=	rb_id2name( ( *c_current_frame )->method_id );
 		rb_method_name				=	( c_method_name == NULL ? Qnil : ID2SYM( rb_intern( c_method_name ) ) );
+		rb_object_for_frame	=	( *c_current_frame )->self;		
+	}
+	//	we have to test this case - it works for blocks but there may be other cases too
+	else if (	( *c_current_frame )->block_iseq != 0
+			 &&	( *c_current_frame )->pc == 0)	{
+	
+		//	If we got here we have a fiber
+		//	There doesn't seem to be much that we can tell about a fiber's context
+			
+		VALUE			rb_current_fiber	=	rb_fiber_current();
+		rb_fiber_t*		c_current_fiber		=	NULL;
+
+		GetFiberPtr(	rb_current_fiber, 
+						c_current_fiber);
+						
+		rb_context_t*	c_context			=	& c_current_fiber->cont;
+		
+//		rb_block_t*	c_blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP( *c_current_frame );
+		 
+		rb_object_for_frame	=	( *c_current_frame )->self;
+		
+		//	get sourcefile name and set in hash
+		rb_sourcefile_name		=	Qnil;
+
+		//	get sourcefile line and set in hash
+		rb_sourcefile_line		=	Qnil;
+		
+		//	get name of instruction sequence
+		rb_method_name			=	rb_str_new2( "<Fiber>" );		
+		
+		//	if we have a fiber we also include its ruby reference since we have so little other context
+		rb_hash_aset(	rb_frame_hash,
+						ID2SYM( rb_intern( "fiber" ) ),
+						c_context->self );
+		
+		//	The one time that we know a fiber is in use in the Ruby base is with Enumerators
+		//	For now we will handle that with a special case
+		
+		VALUE	rb_enumerator_class	=	rb_const_get(	rb_cObject,
+														rb_intern( "Enumerator" ) );
+		
+		VALUE	rb_object_for_frame_klass	=	( ( TYPE( rb_object_for_frame ) == T_CLASS ) ? rb_object_for_frame : rb_funcall( rb_object_for_frame, rb_intern( "class" ), 0 ) );
+
+		VALUE	rb_ancestors	=	rb_funcall(	rb_object_for_frame_klass,
+												rb_intern( "ancestors" ),
+												0 );
+		
+		if ( rb_ary_includes(	rb_ancestors,
+								rb_enumerator_class ) )	{
+			
+			struct enumerator* c_enumerator		=	enumerator_ptr( rb_object_for_frame );
+			
+			rb_object_for_frame	=	c_enumerator->obj;
+			rb_method_name		=	ID2SYM( c_enumerator->meth );			
+		}
+		
+	}
+	else if (	( *c_current_frame )->block_iseq == 0
+			 &&	( *c_current_frame )->pc == 0)	{
+		//	this happens after we had a fiber and we try to go up - which doesn't make sense with a fiber
+		//	not sure what we want to do here, if anything
+		return Qnil;
 	}
 	else {
 		//	The third possibility is that we have an iseq frame with nil params for what we want
@@ -239,7 +650,6 @@ VALUE rb_RPRuby_Sender_Kernel_internal_backtraceHashForControlFrame(	rb_control_
 
 	//	Push values to return hash
 
-	rb_object_for_frame	=	( *c_current_frame )->self;
 	rb_hash_aset(	rb_frame_hash,
 					ID2SYM( rb_intern( "object" ) ),
 					rb_object_for_frame );

data/ext/sender/rb_Kernel.h

@@ -11,8 +11,21 @@
 	VALUE rb_RPRuby_Sender_Kernel_backtrace(	int		argc,
 											VALUE*	args,
 											VALUE	rb_self );
+	VALUE rb_RPRuby_Sender_Kernel_each_backtrace_frame(	int		argc,
+													   VALUE*	args,
+													   VALUE	rb_self );
 	VALUE rb_RPRuby_Sender_Kernel_backtrace_includes(	int	argc,
 														VALUE*	args,
 														VALUE	rb_self );
-
+	VALUE rb_RPRuby_Sender_Kernel_backtrace_includes_one_of(	int		argc,
+																VALUE*	args,
+																VALUE	rb_self );
+	VALUE rb_RPRuby_Sender_Kernel_backtrace_frame_with(	int		argc,
+														VALUE*	args,
+														VALUE	rb_self );
+	VALUE rb_RPRuby_Sender_Kernel_backtrace_frames_with(	int		argc,
+															VALUE*	args,
+															VALUE	rb_self );
+	
+	
 #endif

data/lib/VERSION.rdoc

@@ -1 +1 @@
-1.4.3
+1.5

data/sender.gemspec

@@ -2,14 +2,16 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sender}
-  s.version = "1.4.3"
+  s.version = "1.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Asher"]
-  s.date = %q{2010-06-29}
-  s.description = %q{Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1, as well
-as providing object-oriented :backtrace supporting n-levels backward, and :backtrace_includes?,
-which allows contents of the backtrace to be queried.}
+  s.date = %q{2010-07-09}
+  s.description = %q{Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1.
+
+Also provides object-oriented :backtrace supporting n-levels backward, :each_backtrace_frame for iteration, :backtrace_includes?, 
+and :backtrace_includes_one_of? for context inspection, and :backtrace_frame_with and :backtrace_frames_with, which return
+matching frame information for the frame(s) matching the given description.}
   s.email = ["asher@ridiculouspower.com"]
   s.extensions = ["ext/sender/extconf.rb"]
   s.extra_rdoc_files = ["Manifest.txt", "CHANGELOG.rdoc", "README.rdoc", "VERSION.rdoc"]
@@ -19,7 +21,7 @@ which allows contents of the backtrace to be queried.}
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{asher}
   s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1, as well as providing object-oriented :backtrace supporting n-levels backward, and :backtrace_includes?, which allows contents of the backtrace to be queried.}
+  s.summary = %q{Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1}
   s.test_files = ["test/test_sender.rb"]
 
   if s.respond_to? :specification_version then

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: sender
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 5
   prerelease: false
   segments: 
   - 1
-  - 4
-  - 3
-  version: 1.4.3
+  - 5
+  version: "1.5"
 platform: ruby
 authors: 
 - Asher
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-29 00:00:00 -04:00
+date: 2010-07-09 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -65,9 +64,11 @@ dependencies:
   type: :development
   version_requirements: *id003
 description: |-
-  Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1, as well
-  as providing object-oriented :backtrace supporting n-levels backward, and :backtrace_includes?,
-  which allows contents of the backtrace to be queried.
+  Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1.
+  
+  Also provides object-oriented :backtrace supporting n-levels backward, :each_backtrace_frame for iteration, :backtrace_includes?, 
+  and :backtrace_includes_one_of? for context inspection, and :backtrace_frame_with and :backtrace_frames_with, which return
+  matching frame information for the frame(s) matching the given description.
 email: 
 - asher@ridiculouspower.com
 executables: []
@@ -160,6 +161,6 @@ rubyforge_project: asher
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1, as well as providing object-oriented :backtrace supporting n-levels backward, and :backtrace_includes?, which allows contents of the backtrace to be queried.
+summary: Adds :__sender__ and :__caller__ to the built-in :__callee__ and :__method__ methods in Ruby 1.9.1
 test_files: 
 - test/test_sender.rb