unroller 0.0.17 → 0.0.18

data/lib/unroller.rb

@@ -99,6 +99,7 @@ class Unroller
 
   def initialize(options = {})
     # Defaults
+    @@display_style ||= :show_entire_method_body
     @condition = Proc.new { true }  # Only trace if this condition is true. Useful if the place where you put your trace {} statement gets called a lot and you only want it to actually trace for some of those calls.
     @initial_depth = 1              # ("Call stack") depth to start at. Actually, you'll probably want this set considerably lower than the current call stack depth, so that the indentation isn't way off the screen.
     @max_lines = nil                # Stop tracing (permanently) after we have produced @max_lines lines of output. If you don't know where to place the trace(false) and you just want it to stop on its own after so many lines, you could use this...
@@ -121,6 +122,8 @@ class Unroller
     @column_separator = '  ' + '|'.yellow.bold + ' '
     @always_show_raise_events = false
     @show_file_load_errors = false
+    @interactive = false   # Set to true to make it more like an interactive debugger.
+      # (In the future, might add "break out of this call" option to stop watching anything until we return from the current method... etc.)
     instance_variables.each do |v|
       self.class.class_eval do
         attr_accessor v.gsub!(/^@/, '')
@@ -201,14 +204,14 @@ class Unroller
                             # Also using it to store line numbers, so that we can show the entire method definition each time we process a line,
                             # rather than just the current line itself.
                             # Its members are of type Call
-    @internal_depth = 0     # This is the "true" depth. It is incremented/decremented for *every* call/return, even those that we're not displaying. It is necessary for the implementation of "excluding_calls_made_within_unintersting_call", to detect when we get back to interesting land.
+    @internal_depth = 0     # This is the "true" depth. It is incremented/decremented for *every* call/return, even those that we're not displaying. It is necessary for the implementation of "silent_until_return_to_this_depth", to detect when we get back to interesting land.
     @depth = @initial_depth # This is the user-friendly depth. It only counts calls/returns that we *display*; it does not change when we enter into a call that we're not displaying (a "hidden" call).
     @output_line = ''
     @column_counter = 0
     @tracing = false
     @files = {}
     @lines_output = 0
-    @excluding_calls_made_within_unintersting_call = nil
+    @silent_until_return_to_this_depth = nil
   end
 
   def self.exclude(*args, &block)
@@ -259,7 +262,7 @@ class Unroller
             #puts 'false!!!!!!!'+klass.inspect if klass.to_s == 'false'
 
             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*.
+            #(puts 'exclude') if @silent_until_return_to_this_depth 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)
 
             if too_far?
@@ -270,7 +273,7 @@ class Unroller
 
             case @@display_style
 
-            # To do: remove massive duplication with default display style
+            # To do: remove massive duplication with the other (:concise) display style
             when :show_entire_method_body
 
               case event
@@ -285,7 +288,8 @@ class Unroller
                     puts
                     header_before_code_for_entire_method(file, line_num)
                     do_show_locals if show_args
-                    puts code_for_entire_method(file, line, @klass, @id, line, 0)
+                    ret = code_for_entire_method(file, line, klass, id, line, 0)
+                    puts ret unless ret.nil?
                     puts
 
                     @lines_output += 1
@@ -302,14 +306,16 @@ class Unroller
                 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
 
                     inside_of = @call_stack.last
+                    #puts "inside_of=#{inside_of.inspect}"
                     if inside_of
                       unless @last_call == current_call  # Without this, I was seeing two consecutive events for the exact same line. This seems to be necessary because 'if foo()' is treated as two 'line' events: one for 'foo()' and one for 'if' (?)...
                         puts
                         header_before_code_for_entire_method(file, line_num)
-                        puts code_for_entire_method(inside_of.file, inside_of.line_num, @klass, @id, line, -1)
+                        do_show_locals if show_locals
+                        ret = code_for_entire_method(inside_of.file, inside_of.line_num, @klass, @id, line, -1)
+                        puts ret unless ret.nil?
                         puts
                       end
                     else
@@ -318,10 +324,22 @@ class Unroller
                       newline
                     end
 
+                    # Interactive debugger!
+                    response = nil
+                    unless @last_call == current_call
+                      (print '(o = Step out of | s = Skip = Step over | default = Step into > '; response = $stdin.gets) if @interactive
+                    end
+                    if response
+                      if response[0].chr == 'out'[0].chr
+                        @silent_until_return_to_this_depth = @internal_depth - 1
+                      elsif response[0].chr == 'skip'[0].chr  # Step over = Ignore anything with a greater depth.
+                        @silent_until_return_to_this_depth = @internal_depth
+                      end
+                    end
+
                     @last_call = current_call
                     @lines_output += 1
-                  end
-
+                  end # unless skip_line?
 
 
                 when 'return'
@@ -331,7 +349,7 @@ class Unroller
                     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
+                    returning_from = @call_stack.last
 
                     column sprintf(' ' + '/'.cyan + ' returning from'.cyan + ' ' + '%s'.cyan, returning_from && returning_from.full_name), @column_widths[0]
                     newline
@@ -340,12 +358,14 @@ class Unroller
                   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
+                  if  @silent_until_return_to_this_depth and 
+                      @silent_until_return_to_this_depth == @internal_depth
                     puts "Yay, we're back in interesting land!"
-                    @excluding_calls_made_within_unintersting_call = nil
+                    @silent_until_return_to_this_depth = nil
                   end
 
+                  @call_stack.pop
+
 
 
                 when 'raise'
@@ -366,7 +386,7 @@ class Unroller
 
             # End when :show_entire_method_body
 
-            else
+            when :concise
               case event
 
 
@@ -416,7 +436,7 @@ class Unroller
                     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
+                    returning_from = @call_stack.last
 
                     code = pretty_code_for(file, line, '\\'.magenta, :green, suffix = " (returning from #{returning_from && returning_from.full_name})".green)
                     code = pretty_code_for(file, line, '\\'.magenta + " (returning from #{returning_from && returning_from.full_name})".green, :green) unless code =~ /return|end/
@@ -435,12 +455,12 @@ class Unroller
                   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
+                  if  @silent_until_return_to_this_depth and 
+                      @silent_until_return_to_this_depth == @internal_depth
                     puts "Yay, we're back in interesting land!"
-                    @excluding_calls_made_within_unintersting_call = nil
+                    @silent_until_return_to_this_depth = nil
                   end
-
+                  @call_stack.pop
 
 
                 when 'raise'
@@ -538,14 +558,14 @@ protected
     end
   end
   def skip_line?
-    @excluding_calls_made_within_unintersting_call or 
+    @silent_until_return_to_this_depth or 
       !calling_method_in_an_interesting_class?(@klass.to_s) or 
       !calling_interesting_method?(@id.to_s) or 
       too_deep? or 
       !calling_interesting_line?
   end
   def too_deep?
-    # The + 1 is because if they're still at the initial depth (@depth - @initial_depth == 0), we want it treated as "depth 1" (1-based, for humans).
+    # The + 1 is because we want it to be 1-based, for humans: if they're still at the initial depth (@depth - @initial_depth == 0), we want it treated as "depth 1".
     @max_depth and (@depth - @initial_depth + 1 > @max_depth)
   end
   def too_far?
@@ -554,9 +574,9 @@ protected
   def calling_method_in_an_interesting_class?(class_name)
     !( @exclude_classes + [ClassExclusion.new(self.class.name)] ).any? do |class_exclusion|
       returning(class_name =~ class_exclusion.regexp) do |is_uninteresting|
-        if is_uninteresting && class_exclusion.recursive? && @excluding_calls_made_within_unintersting_call.nil?
+        if is_uninteresting && class_exclusion.recursive? && @silent_until_return_to_this_depth.nil?
           puts "Turning tracing off until we get back to internal_depth #{@internal_depth} again because we're calling uninteresting #{class_name}:#{@id}"
-          @excluding_calls_made_within_unintersting_call = @internal_depth
+          @silent_until_return_to_this_depth = @internal_depth
         end
       end
     end
@@ -564,9 +584,9 @@ protected
   def calling_interesting_method?(name)
     !( @exclude_methods ).any? do |regexp|
       returning(name =~ regexp) do |is_uninteresting|
-        if is_uninteresting && (recursive = implemented = false) && @excluding_calls_made_within_unintersting_call.nil?
+        if is_uninteresting && (recursive = implemented = false) && @silent_until_return_to_this_depth.nil?
           puts "Turning tracing off until we get back to internal_depth #{@internal_depth} again because we're calling uninteresting #{@klass}:#{@id}"
-          @excluding_calls_made_within_unintersting_call = @internal_depth
+          @silent_until_return_to_this_depth = @internal_depth
         end
       end
     end
@@ -610,11 +630,15 @@ protected
     end
 
     if width
-      if column_overflow =~ /chop_/
+      # Handles maximum width
+      max_for_column = width
+      max_for_screen = remaining_width
+      if column_overflow =~ /chop_/   # The column only *has* a max with if column_overflow is chop_ (not if it's allow, obviously)
         #puts "width = #{width}"
-        string = string.code_unroller.make_it_fit(width, column_overflow)
+        string = string.code_unroller.make_it_fit(max_for_column, column_overflow)
+      else
+        string = string.code_unroller.make_it_fit(max_for_screen)
       end
-      string = string.code_unroller.make_it_fit(remaining_width)  # Handles maximum width
 
       string = string.ljust_without_color(width)    # Handles minimum width
     end
@@ -693,13 +717,36 @@ protected
       line_num = [code_for_file.size - 1, line_num].min    # :todo: We should probably just return an error if it's out of range, rather than doing this min junk...
       first_line = code_for_file[line_num]
 
-      raise "Expected #{file}:#{line_num} to match /def.*#{method}/, but it was:\n#{first_line}" unless first_line =~ /(\s+)def/
-      first_line =~ /(\s+)def/  # Normal case (I *think*)
+      if first_line =~ /^(\s+)\S?.*def/
+        # About the regexp:
+        #   It would just be as simple as /^(\s+)def/ except that we want to allow for the (admittedly rare) case where they have it
+        #   *indented* correctly, but they have other junk at the beginning of the line. For example: '  obj.define_method :foo'.
+        #   The ^(\s+) is to capture the initial whitespace. The \S marks the end of the whitespace (the true "beginning of the line").
+        #   The .* is any other junk they want to throw in before we get to the good sweet def that we are looking for!
+
+        # This is the normal case (I *think*).
+        # $1 will be set to the whitespace at the beginning of the line.
+      else
+        # Hmm... Try plan B. Sometimes it is defined like this:
+        #          define_method(reflection.name) do |*params|
+        #            force_reload = params.first unless params.empty?   # <-- And this is the line they claim we started on. (Liars.)
+        # So we have to back up one line and try again...
+        line_num -= 1
+        first_line = code_for_file[line_num]
+        if first_line =~ /^(\s+)\S?.*def/   # (includes define_method)
+          # Good
+        else
+          puts "Warning: Expected #{file}:#{line_num} =~ /def.*#{method}/, but was:" #, but it was:\n#{first_line}"
+          column pretty_code_for(@file, @line, ' ', :bold)
+          newline
+          return
+        end
+      end
       leading_whitespace = $1
 
       # Look for ending 'end'
       lines_containing_method =
-        (line_num .. line_num+30).
+        (line_num .. [code_for_file.size - 1, line_num+30].min).
         map {|i| [i, code_for_file[i]]}.
         select_until(inclusive = true) do |line_num, line|
           line =~ /^#{leading_whitespace}end/
@@ -728,7 +775,7 @@ protected
   end # code_for_entire_method
   
   def header_before_code_for_entire_method(file, line_num)
-    puts '' + "#{fully_qualified_method} (#{file}:#{line_num}):".magenta if show_filename_and_line_numbers
+    puts '' + "#{fully_qualified_method} (#{file}:#{line_num}) (#{@event}):".magenta if show_filename_and_line_numbers
   end
 end # class Unroller
 
@@ -739,13 +786,15 @@ class String
     def make_it_fit(max_width, overflow = :chop_right)
       with(string = self) do
         if string.length_without_color > max_width      # Wider than desired column width; Needs to be chopped.
-          unless max_width < 4                          # Is there even enough room for it if it *is* chopped?
+          unless max_width < 4                          # Is there even enough room for it if it *is* chopped? If not, then don't even bother.
+            #Kernel.p overflow
             if overflow == :chop_left
-              #puts "making string (#{string.length_without_color}) fit within #{max_width}"
+              #puts "making string (#{string.length_without_color}) fit within #{max_width} by doing a :chop_left"
               #puts "chopping '#{string}' at -(#{max_width} - 3) .. -1!"
               chopped_part = string[-(max_width - 3) .. -1]
               string.replace '...' + chopped_part
             elsif overflow == :chop_right
+              #puts "making string (#{string.length_without_color}) fit within #{max_width} by doing a :chop_right"
               chopped_part = string[0 .. (max_width - 3)]
               string.replace chopped_part + '...'
             end
@@ -793,6 +842,9 @@ end
 #   |_|\___||___/\__|
 #
 # :todo: These tests seriously need to be converted into automated tests. But I was lazy/in a hurry when I wrote this...
+# It would be kind of cool if we could simultaneously *capture* the output (for asserting things against in automated tests) and
+# *display* the output (so that we can manually check for *visual*/stylistic/color regression problems that automated tests 
+# couldn't really judge ... and because it's just pretty to look at :) ).
 
 if $0 == __FILE__
   require 'test/unit'
@@ -801,16 +853,14 @@ if $0 == __FILE__
     puts message.ljust(130).bold.white.on_magenta
   end
 
-  Unroller::display_style = nil #:show_entire_method_body
+  Unroller::display_style = :concise #:show_entire_method_body
 
   class TheTest < Test::Unit::TestCase
     def test_1
     end
-
   end
 
 
-
   herald '-----------------------------------------------------------'
   herald 'Can call trace_off even if not tracing'
   herald '(Should see no output)'
@@ -1231,14 +1281,52 @@ if $0 == __FILE__
   end
 
   herald '-----------------------------------------------------------'
-  herald 'Testing :display_style => :show_entire_method_body, :show_filename_and_line_numbers => false'
-  def bagel
+  herald 'Testing :show_filename_and_line_numbers => false'
+  'foo'; def bagel
     '...'
   end
   Unroller::trace :display_style => :show_entire_method_body, :show_filename_and_line_numbers => false do
     bagel
   end
 
+  herald '-----------------------------------------------------------'
+  herald 'Testing that it finds the definition block even when we use define_method instead of the normal def'
+  (class << self; self; end).send :define_method, :big_ol_gaggle do
+    '...'
+  end
+  Unroller::trace :display_style => :show_entire_method_body do
+    big_ol_gaggle
+  end
+
+  herald '-----------------------------------------------------------'
+  herald 'Testing :interactive => true / interactive debugger'
+  def subway
+    question = 'What kind of bread would you like?'
+    bread!
+    question = 'Would you like any cheese?'
+    cheese!
+    question = 'Would you like pickles on that?'
+    pickles!
+  end
+  def bread!
+    _do = nil
+    _do = nil
+    _do = nil
+  end
+  def cheese!
+    _do = nil
+    _do = nil
+    _do = nil
+  end
+  def pickles!
+    _do = nil
+    _do = nil
+    _do = nil
+  end
+  Unroller::trace :display_style => :show_entire_method_body, :interactive => true do
+    subway
+  end
+
   herald 'End of non-automated tests'
   herald '-----------------------------------------------------------'
 

metadata

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