unroller 0.0.10 → 0.0.11

data/lib/unroller.rb

@@ -49,7 +49,15 @@ class Unroller
   @@instance = nil
 
   def self.trace(options = {}, &block)
-    @@instance = Unroller.new(options)
+    #puts 'called self.trace'
+    if @@instance and @@instance.tracing
+      # In case they try to turn tracing on when it's already on... Assume it was an accident and don't do anything.
+      #puts "@@instance.tracing=#{@@instance.tracing}"
+      #return if @@instance and @@instance.tracing       
+      #yield if block_given?
+    else
+      @@instance = Unroller.new(options)
+    end
     @@instance.trace &block
   end
 
@@ -135,7 +143,10 @@ class Unroller
   end
 
   def self.exclude(*args, &block)
-    @@instance.exclude(*args, &block)
+    @@instance.exclude(*args, &block) unless @@instance.nil?
+  end
+  def self.suspend(*args, &block)
+    @@instance.exclude(*args, &block) unless @@instance.nil?
   end
   def exclude(&block)
     old_tracing = @tracing
@@ -145,14 +156,18 @@ class Unroller
   end
 
   def trace(&block)
-    (puts 'Already tracing!'; return) if @tracing     # This does not work. :fixme:
-    @tracing = true
+    if @tracing
+      yield if block_given?
+      return
+    end
 
+    begin
+      @tracing = true
 
-    if @condition.call
 
-      trap_chain("INT") { set_trace_func(nil) }
+      if @condition.call
 
+        trap_chain("INT") { set_trace_func(nil) }
 
 
 
@@ -161,124 +176,124 @@ class Unroller
 
 
 
-      # (This is the meat of the library right here, so let's set it off with at least 5 blank lines.)
-      set_trace_func( proc do |event, file, line, id, binding, klass|
-        begin # begin/rescue block
-          @event, @file, @line, @id, @binding, @klass =
-            event, file, line, id, binding, klass
 
-          # Sometimes klass is false and id is nil. Not sure why, but that's the way it is.
-          #printf "- (event=%8s) (klass=%10s) (id=%10s) (%s:%-2d)\n", event, klass, id, file, line #if klass.to_s == 'false'
-          #puts 'false!!!!!!!'+klass.inspect if klass.to_s == 'false'
+        # (This is the meat of the library right here, so let's set it off with at least 5 blank lines.)
+        set_trace_func( proc do |event, file, line, id, binding, klass|
+          begin # begin/rescue block
+            @event, @file, @line, @id, @binding, @klass =
+              event, file, line, id, binding, klass
 
-          return if ['c-call', 'c-return'].include? event unless include_c_calls
-          #(puts 'exclude') if @excluding_calls_made_within_unintersting_call unless event == 'return' # Until we hit a return and can break out of this uninteresting call, we don't want to do *anything*.
-          #return if uninteresting_class?(klass.to_s) unless (klass == false)
+            # Sometimes klass is false and id is nil. Not sure why, but that's the way it is.
+            #printf "- (event=%8s) (klass=%10s) (id=%10s) (%s:%-2d)\n", event, klass, id, file, line #if klass.to_s == 'false'
+            #puts 'false!!!!!!!'+klass.inspect if klass.to_s == 'false'
 
-          if too_far?
-            puts "We've read #{@max_lines} (@max_lines) lines now. Turning off tracing..."
-            trace_off
-            return
-          end
+            return if ['c-call', 'c-return'].include? event unless include_c_calls
+            #(puts 'exclude') if @excluding_calls_made_within_unintersting_call unless event == 'return' # Until we hit a return and can break out of this uninteresting call, we don't want to do *anything*.
+            #return if uninteresting_class?(klass.to_s) unless (klass == false)
 
-          case event
+            if too_far?
+              puts "We've read #{@max_lines} (@max_lines) lines now. Turning off tracing..."
+              trace_off
+              return
+            end
 
+            case event
 
 
-            when 'call'
-              unless skip_line?
-                # :todo: use # instead of :: if klass.constantize.instance_methods.include?(id)
-                column sprintf(' ' + '+'.cyan + ' calling'.cyan + ' ' + '%s'.underline.cyan, fully_qualified_method), @column_widths[0]
-                newline
 
-                column code_for(file, line, '/'.magenta, :green), @column_widths[0]
-                file_column file, line
-                newline
+              when 'call'
+                unless skip_line?
+                  # :todo: use # instead of :: if klass.constantize.instance_methods.include?(id)
+                  column sprintf(' ' + '+'.cyan + ' calling'.cyan + ' ' + '%s'.underline.cyan, fully_qualified_method), @column_widths[0]
+                  newline
 
-                @lines_output += 1
+                  column code_for(file, line, '/'.magenta, :green), @column_widths[0]
+                  file_column file, line
+                  newline
 
-                @call_stack.push fully_qualified_method
+                  @lines_output += 1
 
-                @depth += 1
-                #puts "++ Increased depth to #{depth}"
+                  @call_stack.push fully_qualified_method
 
-                # The locals at this point will be simply be the arguments that were passed in to this method.
-                do_show_locals if show_args
-              end
-              @internal_depth += 1
+                  @depth += 1
+                  #puts "++ Increased depth to #{depth}"
 
+                  # The locals at this point will be simply be the arguments that were passed in to this method.
+                  do_show_locals if show_args
+                end
+                @internal_depth += 1
 
-            when 'class'
-            when 'end'
-            when 'line'
-              unless skip_line?
-                # Show the state of the locals *before* executing the current line. (I might add the option to show it after instead/as well, but I don't think that would be easy...)
-                do_show_locals if show_locals
 
-                column code_for(file, line, ' ', :bold), @column_widths[0]
-                file_column file, line
-                newline
+              when 'class'
+              when 'end'
+              when 'line'
+                unless skip_line?
+                  # Show the state of the locals *before* executing the current line. (I might add the option to show it after instead/as well, but I don't think that would be easy...)
+                  do_show_locals if show_locals
 
-                @lines_output += 1
-              end
+                  column code_for(file, line, ' ', :bold), @column_widths[0]
+                  file_column file, line
+                  newline
 
+                  @lines_output += 1
+                end
 
 
-            when 'return'
 
-              @internal_depth -= 1
-              unless skip_line?
-                puts "Warning: @depth < 0. You may wish to call trace with a :depth => depth value greater than #{@initial_depth}" if @depth-1 < 0
-                @depth -= 1 unless @depth == 0
-                #puts "-- Decreased depth to #{depth}"
-                returning_from = @call_stack.pop
+              when 'return'
 
-                code = code_for(file, line, '\\'.magenta, :green, suffix = " (returning from #{returning_from})".green)
-                code = code_for(file, line, '\\'.magenta + " (returning from #{returning_from})".green, :green) unless code =~ /return|end/
-                  # I've seen some really weird statements listed as "return" statements.
-                  # I'm not really sure *why* it thinks these are returns, but let's at least identify those lines for the user. Examples:
-                  # * must_be_open!
-                  # * @db = db
-                  # * stmt = @statement_factory.new( self, sql )
-                  # I think some of the time this happens it might be because people pass the wrong line number to eval (__LINE__ instead of __LINE__ + 1, for example), so the line number is just not accurate.
-                  # But I don't know if that explains all such cases or not...
-                column code, @column_widths[0]
-                file_column file, line
-                newline
+                @internal_depth -= 1
+                unless skip_line?
+                  puts "Warning: @depth < 0. You may wish to call trace with a :depth => depth value greater than #{@initial_depth}" if @depth-1 < 0
+                  @depth -= 1 unless @depth == 0
+                  #puts "-- Decreased depth to #{depth}"
+                  returning_from = @call_stack.pop
 
-                @lines_output += 1
-              end
+                  code = code_for(file, line, '\\'.magenta, :green, suffix = " (returning from #{returning_from})".green)
+                  code = code_for(file, line, '\\'.magenta + " (returning from #{returning_from})".green, :green) unless code =~ /return|end/
+                    # I've seen some really weird statements listed as "return" statements.
+                    # I'm not really sure *why* it thinks these are returns, but let's at least identify those lines for the user. Examples:
+                    # * must_be_open!
+                    # * @db = db
+                    # * stmt = @statement_factory.new( self, sql )
+                    # I think some of the time this happens it might be because people pass the wrong line number to eval (__LINE__ instead of __LINE__ + 1, for example), so the line number is just not accurate.
+                    # But I don't know if that explains all such cases or not...
+                  column code, @column_widths[0]
+                  file_column file, line
+                  newline
 
-              # Did we just get out of an uninteresting call?? Are we back in interesting land again??
-              if  @excluding_calls_made_within_unintersting_call and 
-                  @excluding_calls_made_within_unintersting_call == @internal_depth
-                puts "Yay, we're back in interesting land!"
-                @excluding_calls_made_within_unintersting_call = nil
-              end
+                  @lines_output += 1
+                end
 
+                # Did we just get out of an uninteresting call?? Are we back in interesting land again??
+                if  @excluding_calls_made_within_unintersting_call and 
+                    @excluding_calls_made_within_unintersting_call == @internal_depth
+                  puts "Yay, we're back in interesting land!"
+                  @excluding_calls_made_within_unintersting_call = nil
+                end
 
 
-            when 'raise'
-              # We probably always want to see these (?)... Never skip displaying them, even if we are "too deep".
-              column "Raising an error (#{$!}) from #{klass}".red.bold, @column_widths[0]
-              newline
 
-              column code_for(file, line, ' ').red, @column_widths[0]
-              file_column file, line
-              newline
+              when 'raise'
+                # We probably always want to see these (?)... Never skip displaying them, even if we are "too deep".
+                column "Raising an error (#{$!}) from #{klass}".red.bold, @column_widths[0]
+                newline
 
-            else
-              column sprintf("- (%8s) %10s %10s (%s:%-2d)", event, klass, id, file, line)
-              newline
-          end
+                column code_for(file, line, ' ').red, @column_widths[0]
+                file_column file, line
+                newline
 
+              else
+                column sprintf("- (%8s) %10s %10s (%s:%-2d)", event, klass, id, file, line)
+                newline
+            end
 
-        rescue Exception => exception
-          puts exception.inspect
-          raise
-        end # begin/rescue block
-      end) # set_trace_func
 
+          rescue Exception => exception
+            puts exception.inspect
+            raise
+          end # begin/rescue block
+        end) # set_trace_func
 
 
 
@@ -286,15 +301,17 @@ class Unroller
 
 
 
-    end # if @condition.call
 
-    if block_given?
-      yield
-    end
+      end # if @condition.call
 
-  ensure
-    trace_off if block_given?
-  end
+      if block_given?
+        yield
+      end
+
+    ensure
+      trace_off if block_given?
+    end # rescue/ensure block
+  end # def trace(&block)
 
   def self.trace_off
     if @@instance and @@instance.tracing
@@ -317,7 +334,7 @@ protected
     variables = Variables.new(:local, @binding)
     # puts "In do_show_locals at depth #{depth}; event = #{@event}"
     if variables.any?
-      column variables.to_s
+      column variables.to_s, nil, :allow, :yellow
       newline
     end
   end
@@ -464,11 +481,33 @@ end
 
 
 
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# :todo: These tests seriously need to be converted into automated tests. But I was lazy/in a hurry when I wrote this...
+
 if $0 == __FILE__
+  require 'test/unit'
+
+  class TheTest < Test::Unit::TestCase
+    def test_1
+    end
+
+  end
+
+
+
   puts '-----------------------------------------------------------'
   puts 'Can call trace_off even if not tracing'
   Unroller::trace_off
 
+  puts '-----------------------------------------------------------'
+  puts 'Can call exclude even if not tracing'
+  Unroller::exclude
+
   puts '-----------------------------------------------------------'
   puts 'Testing return value (should print 3 in this case)'
   puts Unroller::trace { 1 + 2 }
@@ -506,6 +545,21 @@ if $0 == __FILE__
     method3
   end
 
+  puts '-----------------------------------------------------------'
+  puts "Testing that we can try to turn tracing on even if it's already on"
+  def method1
+    Unroller::trace
+    v = 'in method1'
+  end
+  Unroller::trace do
+    Unroller::trace do
+      v = 'about to call method1'
+      method1
+    end
+    v = "We've exited out of one trace block, but we're still within a trace block, so this line should be traced."
+  end
+
+
   puts '-----------------------------------------------------------'
   puts 'Test with block; very deep (test for over-wide columns)'
   ('a'..last='y').each do |method_name|

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: unroller
 version: !ruby/object:Gem::Version 
-  version: 0.0.10
+  version: 0.0.11
 date: 2007-04-23 00:00:00 -07:00
 summary: A tool for generating human-readable "execution traces"
 require_paths: