unroller 0.0.3

data/Readme

@@ -0,0 +1,182 @@
+= <i>Ruby Unroller</i> -- a code tracing tool for Ruby
+
+[<b>Home page</b>:]        http://unroller.rubyforge.org/
+[<b>Project site</b>:]     http://rubyforge.org/projects/unroller/
+[<b>Wiki</b>:]             http://whynotwiki.com/Ruby_Unroller
+[<b>Author</b>:]           Tyler Rick
+[<b>Copyright</b>:]        2007 QualitySmith, Inc.
+[<b>License</b>:]          GPL
+
+==Introduction / What it is
+
+Ruby Unroller is a tool for generating human-readable "execution traces".
+While it is enabled, it will watch every Ruby statement and method call that gets executed and will display the source code on your screen in real-time as it is being executed.
+
+You can use it for...
+
+===Debugging
+
+A very efficient tool for seeing what code actually gets executed... Add it to your toolbox along with the other tricks you already know, like inspecting <tt>caller()</tt> or printing "got here" at various places in your code.
+
+===Learning/Exploring
+
+It's a great tool for exploring 3rd-party source code that you aren't familiar with. If you've ever found yourself wondering "How was that method implemented?" or "What's going on behind the scenes when I call such-and-such?", then this tool is for you!
+
+
+==Usage
+
+Just insert these line before the point you want to start tracing:
+
+  require 'rubygems'
+  require 'unroller'
+  Unroller::trace
+
+And if you want the tracing to stop, just add this line somewhere:
+
+  Unroller::trace_off
+
+You can also pass a block to <tt>Unroller::trace</tt> and it will automatically turn off tracing as soon as the block has been executed.
+
+  Unroller::trace do
+  	...
+  end
+
+===Example
+
+Say I have an ActiveRecord model and want to know exactly what actually goes on behind the scenes when I call model.save! . All I have to do is wrap the method call in a "trace" block, like this:
+
+  Unroller::trace do
+    model.save!
+  end
+
+, start the script, and then watch as the source code is unfolded before my very eyes!
+
+Screenshot[link:include/screenshot1.png]
+
+This is much more efficient and reliable than manually tracing through the execution yourself!  (Trying to guess which file the <tt>save!</tt> method would be defined in, searching for the file in the depths of <tt>/usr/lib/ruby/gems</tt>, scrolling down to the right line number, and repeating a zillion times...)
+
+
+===Reducing verbosity
+
+This can generate some really *verbose* output... A couple options are available to help things under control:
+
+Ignore a section of code that is within the block passed to +trace+.
+
+  Unroller::trace do
+	  stuff_you_care_about
+    Unroller::exclude do
+      stuff_that_you_really_dont_care_about
+	  end
+	  stuff_you_care_about
+  end
+
+You may find that your trace is cluttered/dominated by calls to a small set of methods and classes that you don't care about. These options help you to exclude the worst offenders in a hurry:
+
+<tt>:exclude_classes</tt> ::
+  Unroller won't show a trace for any calls to methods from the given class or classes (regular expressions).
+  Pass [/class_name/, :recursive] to also not show the trace for any calls made *from* those uninteresting methods.
+<tt>:exclude_methods</tt> (not implementd) ::
+  Like <tt>:exclude_classes</tt> only you give it _method_ names instead of class names. Maybe will have the ability to specify a class name as well as a method name if you want to be more specific (f.e., <tt>ThatOneClass#format</tt> if you still want to include calls to other methods named <tt>format<tt>).
+
+These options are for more general overall control:
+
+<tt>:omit_depth_greater_than => depth</tt> ::
+  Use this to prevent from going more than <tt>depth<tt> levels deep if you find that the trace is cluttered by a bunch of really deep calls.
+<tt>:stop_after_lines_output</tt> ::
+  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...
+
+Examples:
+
+  Unroller::trace :stop_after_lines_output => 100, :exclude_classes => /Boring/ { ... }
+
+  Unroller::trace :if => proc{$tracing_enabled}, :omit_depth_greater_than => 9, :exclude_classes =>
+    [
+      /Benchmark/,
+      /Logger/,
+      /MonitorMixin/,
+      /Set/,
+      /HashWithIndifferentAccess/,
+      /ERB/,
+      /ActiveRecord/,
+      /SQLite3/,
+      /Class/,
+      /ActiveSupport/,
+      /ActiveSupport::Deprecation/,
+      /Pathname/
+    ] do
+      ...
+    end
+
+
+
+===How did that method even get *called*?
+
+Some of the time, you may be trying to answer the question "How did that method even get *called*?" This tool can't directly help answer that question unless you're willing to enable tracing really early and wade through pages and pages of output.
+
+If you enable tracing from within that method, it will only show the calls that came *after* the mysterious call to the mystery function, not what came *before*, which is what you're interested in.
+
+So... you could always <tt>p caller(0)</tt> within your mystery function and then put a trace around one of the calls leading up to this call, a little further up the stack...
+
+
+===Usage in Rails
+
+If you want to see all code that gets executed within a certain action in your controller, you can just add this snippet to your controller, request the page, and watch the console where you have Webrick running as pages and pages of ActionController/ActionRecord code go flying by...
+
+  around_filter do |controller, action|
+    Unroller::trace do
+      action.call
+    end
+  end
+
+==Installation
+
+  sudo gem install unroller
+
+==Status
+
+It's pretty much fully functional, but may still have a couple rough edges.
+
+Occasionally it has caused some segmentation faults and other weirdness for me while using it, but maybe I was just doing something stupid. Generally it behaves quite reliably and stably.
+
+(Don't even *think* about leaving this in your production code!)
+
+==About the name
+
+I called it "Ruby Unroller" because it visually "unrolls" a stack trace for you (like a scroll?). (And it sounds cooler than "Ruby Script Execution Tracer".)
+
+If there are method calls (even recursion), it will sort of "unroll" the method definition for you so you can see it.
+
+It also alludes to some ideas from compiler design. Think {"method inlining"}[http://en.wikipedia.org/wiki/Inline_expansion] and {"loop unrolling"}[http://en.wikipedia.org/wiki/Loop_unrolling] in real-time. Not quite the same thing, but close enough.
+
+It takes something that is actually very stack-based (the path that Ruby interpreter takes while executing your source code) and "flattens" it. It still tries to keep things appearing hierarchical (by means of the indent levels), but in essence it takes code from a bunch of different files and merges them into one "flat" output stream.
+
+Phew!
+
+Other name ideas are welcome!
+* Unfolder?
+* ...
+
+==Similarity to debuggers/profilers / What it is not
+
+It's sort of like a cross between a Ruby debugger and a profiler.
+
+It's like a debugger because it lets you step through code execution one line at time (similar to the "step into" / "next" commands in most debuggers). It's not a debugger, though, because it doesn't let you inspect variables, set breakpoints, etc. It lets you *watch* the execution ... and that's it! So it's not as powerful as a real debugger, but it can be a lot *faster*! Rather than pressing F8 (or whatever the shortcut is for the 'step' command) 1000 times, you can just tell it "trace from here to here" and it will.
+
+And like a profiler, it follows every method call, using Ruby's set_trace_func. Like a profiler, it can be helpful for diagnosing performance bottlenecks in your application -- at least those that involve excessive or unwanted method calls or recursion. It's not a profiler, though, because it doesn't _time_ the method calls like a 'real' profiler would.
+
+It's also sort of like a call stack (caller(0)). But unlike the callstack you usually see, which only shows where you've been, this one doesn't show where you've been; it only shows where you _going_ -- or more accurately, where you *go* after you enable the tracing. So while it works equally well for tracing while the call stack is being unwound (returning from calls, which pops that call off the stack), the most common use of the tracer is to see what happens "within" a method call -- that method will in turn call _other_ methods, and the stack will grow temporarily -- but then it will unwind again and you'll get back to the method where you started the trace (hopefully -- eventually?), with a net change in stack size of 0.
+
+(If you _do_ want to watch the trace as the call stack is unwound completely, be sure to pass <tt>:depth => caller(0).size</tt> to the Unroller so that it can start the indenting at an appropriate level...)
+
+==Possibly related projects
+
+* http://rubyforge.org/projects/dev-utils/ : Collects utilities that aid Ruby development, e.g. testing and debugging. Version 1.0 contains simple debug logging, tracing, and escaping to IRB.
+* http://rubyforge.org/projects/ruby-uml/ : Generates uml diagrams by tracing the run of an application for analysation of an existing application and to provide support for refactorisations.
+
+==To do
+
+* Make a GUI interface that lets you quickly collapse/nodes nodes of the tree.
+* It would be nice if we could see what arguments are being passed to each method. This would be technically difficult, but I wonder if it would be possible to just wait for a 'call' event and when you see one, wrap/alias_method_chain the given classname/id with a wrapper method that has variable *args and does whatever you want to do with the args before actually doing the *real* method call....
+* :include_classes option in addition to :exclude_classes?
+
+

data/lib/unroller.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'facets/core/kernel/require_local'
+require_local 'unroller/unroller'

data/lib/unroller/unroller.rb

@@ -0,0 +1,564 @@
+require 'rubygems'
+gem 'facets'
+require 'facets/core/module/namespace'
+require 'facets/core/kernel/with'
+require 'facets/core/kernel/set_with'
+gem 'qualitysmith_extensions'
+require 'qualitysmith_extensions/object/send_if_not_nil'
+require 'qualitysmith_extensions/kernel/trap_chain'
+require 'qualitysmith_extensions/kernel/capture_output'
+require 'qualitysmith_extensions/string/with_knowledge_of_color'
+require 'qualitysmith_extensions/exception/inspect_with_backtrace'
+require 'qualitysmith_extensions/symbol/match'
+gem 'colored'
+require 'colored'
+
+# To disable color, uncomment this:
+#class String
+#  def colorize(string, options = {})
+#    string
+#  end
+#end
+
+#
+class Unroller
+  @@instance = nil
+
+  def self.trace(options = {}, &block)
+    @@instance = Unroller.new(options)
+    @@instance.trace &block
+  end
+
+  attr_accessor :depth
+  attr_reader   :tracing
+
+  def initialize(options = {})
+    # Defaults
+    @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 = 0              # ("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.
+    @stop_after_lines_output = nil  # 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...
+    @omit_depth_greater_than = nil  # Don't go too many levels deep. (This is *relative* to the starting depth, so whatever level you start at is considered depth "1".)
+    @exclude_classes = []
+    @strip_comments = true          # :todo:
+    @use_full_path = false          # :todo:
+    @screen_width = 150
+    @column_widths = [70]
+    @indent_step =       ' ' + '|'.magenta + ' '
+    @column_separator = '  ' + '|'.yellow.bold + ' '
+    instance_variables.each do |v|
+      self.class.class_eval do
+        attr_accessor v.gsub!(/^@/, '')
+      end
+    end
+
+    # Options
+    options[:condition]       = options.delete(:if)       if options.has_key?(:if)
+    options[:initial_depth]   = options.delete(:depth)    if options.has_key?(:depth)
+    options[:initial_depth]   = caller(0).size            if options[:initial_depth] == :use_call_stack_depth
+    if options.has_key?(:exclude_classes)
+      options[:exclude_classes] = [options[:exclude_classes]] if options[:exclude_classes].is_a?(Regexp)
+      raise ArgumentError if !options[:exclude_classes].is_a?(Array)
+    end
+    set_with(options)
+
+    # Private
+    @depth = @initial_depth
+    @output_line = ''
+    @column_counter = 0
+    @tracing = false
+    @files = {}
+    @lines_output = 0
+    @excluding_calls_made_within_unintersting_call = nil
+  end
+
+  def self.exclude(*args, &block)
+    @@instance.exclude(*args, &block)
+  end
+  def exclude(&block)
+    old_tracing = @tracing
+    (trace_off; puts 'Suspending tracing')
+    yield
+    (trace; puts 'Resuming tracing') if old_tracing
+  end
+
+  def trace(&block)
+    (puts 'Already tracing!'; return) if @tracing     # This does not work. :fixme:
+    @tracing = true
+
+
+    if @condition.call
+
+      trap_chain("INT") { set_trace_func(nil) }
+
+
+
+
+
+
+
+
+
+      # (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'
+
+          return if ['c-call', 'c-return'].include? event
+          #(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)
+
+          if too_far?
+            puts "We've read #{@stop_after_lines_output} (@stop_after_lines_output) lines now. Turning off tracing..."
+            trace_off
+            return
+          end
+
+          case event
+
+
+
+            when 'call'
+              unless @excluding_calls_made_within_unintersting_call or calling_method_in_an_uninteresting_class?(klass.to_s) or too_deep?
+                # :todo: use # instead of :: if klass.constantize.instance_methods.include?(id)
+                column sprintf(' ' + '+'.cyan + ' calling'.cyan + ' ' + '%s::%s'.underline.cyan, klass, id), @column_widths[0]
+                newline
+
+                column code_for(file, line, '/'.magenta, :green), @column_widths[0]
+                file_column file, line
+                newline
+
+                @lines_output += 1
+              end
+
+              @depth += 1
+
+
+
+            when 'line'
+              unless @excluding_calls_made_within_unintersting_call or calling_method_in_an_uninteresting_class?(klass.to_s) or too_deep?
+                column code_for(file, line, ' ', :bold), @column_widths[0]
+                file_column file, line
+                newline
+
+                @lines_output += 1
+              end
+
+
+
+            when 'return'
+              puts "Warning: @depth < 0. You may wish to call trace with a :depth => depth value greater than #{@initial_depth}" if @depth < 0
+              @depth -= 1 unless @depth == 0
+
+
+              unless @excluding_calls_made_within_unintersting_call or calling_method_in_an_uninteresting_class?(klass.to_s) or too_deep?
+                code = code_for(file, line, '\\'.magenta,                  :green)
+                code = code_for(file, line, '\\'.magenta + ' (returning)'.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
+
+                @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 == @depth
+                if @excluding_calls_made_within_unintersting_call == @depth
+                  puts "Yay, we're back in interesting land!"
+                  @excluding_calls_made_within_unintersting_call = nil
+                end
+              end
+
+
+
+            when 'raise'
+              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
+
+            else
+              printf "- (%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
+
+
+
+
+
+
+
+
+    end # if @condition.call
+
+    if block_given?
+      yield
+    end
+
+  ensure
+    trace_off if block_given?
+  end
+
+  def self.trace_off
+    @@instance.trace_off
+  end
+  def trace_off
+    @tracing = false
+    set_trace_func(nil)
+  end
+
+protected
+  #----------------------------------------------------------
+  # Helpers
+
+  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).
+    @omit_depth_greater_than and (@depth - @initial_depth + 1 > @omit_depth_greater_than)
+  end
+  def too_far?
+    @stop_after_lines_output and (@lines_output > @stop_after_lines_output)
+  end
+  def calling_method_in_an_uninteresting_class?(class_name)
+    ( @exclude_classes + [/#{self.class.name}/] ).any? do |item|
+      item = item.dup
+      if item.is_a?(Array)
+        # Expect item to be in format [/class_name/, :recursive, any other flags...]
+        regexp = item.shift
+        recursive = item.include?(:recursive)
+      else
+        regexp = item
+        recursive = false
+      end
+
+      returning(class_name =~ regexp) do |uninteresting|
+        if uninteresting && recursive && @excluding_calls_made_within_unintersting_call.nil?
+          puts "Turning tracing off until we get back to depth #{@depth} again because we're calling uninteresting #{class_name}:#{@id}"
+          @excluding_calls_made_within_unintersting_call = @depth
+        end
+      end
+    end
+  end
+
+  #----------------------------------------------------------
+  # Formatting stuff.
+  def indent
+    @indent_step*@depth
+  end
+
+  def remaining_width
+    @screen_width - @output_line.length_without_color
+  end
+
+  # +width+ is the minimum width for this column. It's also a maximum if +column_overflow+ is :chop_left or :chop_right
+  # +color+ is only needed if you plan on doing some chopping, because if you apply the color *before* the chopping, the color code might get chopped off.
+  def column(string, width = nil, column_overflow = :allow, color = nil)
+    raise ArgumentError if ![:allow, :chop_left, :chop_right].include?(column_overflow)
+    raise ArgumentError if width and !(width == :remainder or width.is_a?(Fixnum))
+
+    if @column_counter == 0
+      @output_line << indent
+      width -= indent.length_without_color if width
+    else
+      @output_line << @column_separator      # So the columns won't be squashed up against each other
+    end
+
+    if width == :remainder
+      width = remaining_width()
+    end
+
+    if width
+      if column_overflow =~ /chop_/
+        #puts "width = #{width}"
+        string = string.code_unroller.make_it_fit(width, column_overflow)
+      end
+      string = string.code_unroller.make_it_fit(remaining_width)  # Handles maximum width
+
+      string = string.ljust_without_color(width)    # Handles minimum width
+    end
+
+    @output_line << string.send_if_not_nil(color)
+
+    @column_counter += 1
+  end # def column
+
+  def newline
+    unless @output_line.strip.length_without_color == 0 or @output_line == @last_line_printed
+      Kernel.print @output_line
+      Kernel.puts
+      @last_line_printed = @output_line
+    end
+
+    @output_line = ''
+    @column_counter = 0
+  end
+
+  def file_column(file, line)
+    column "#{file}:#{line}", :remainder, :chop_left, :magenta
+  end
+
+  #----------------------------------------------------------
+
+  def code_for(file, line, prefix, color = nil)
+    if file == '(eval)'
+      # Can't really read the source from the 'eval' file, unfortunately!
+      return ' ' + prefix + ' ' + file.send_if_not_nil(color) + ''
+    end
+
+    line -= 1   # Adjust for the fact that line arg is 0-based, readlines line is 1-based
+    begin
+      @files[file] ||= File.readlines(file)
+      line = [@files[file].size - 1, line].min
+      ' ' + prefix + ' ' + @files[file][line].strip.send_if_not_nil(color) + ''
+    rescue Errno::ENOENT
+      $stderr.puts( message = "Error Could not open #{file}" )
+      message
+    rescue Exception => exception
+      puts "Error while getting code for #{file}:#{line}:"
+      puts exception.inspect
+    end
+  end
+end
+
+
+class String
+  namespace :code_unroller do
+
+    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?
+            if overflow == :chop_left
+              #puts "making string (#{string.length_without_color}) fit within #{max_width}"
+              #puts "chopping '#{string}' at -(#{max_width} - 3) .. -1!"
+              chopped_part = string[-(max_width - 3) .. -1]
+              string.replace '...' + chopped_part
+            elsif overflow == :chop_right
+              chopped_part = string[0 .. (max_width - 3)]
+              string.replace chopped_part + '...'
+            end
+          else
+            string = ''
+          end
+        end
+      end
+    end
+
+  end
+end
+
+
+
+
+if $0 == __FILE__
+  puts '-----------------------------------------------------------'
+  puts 'Simple test'
+  def jump!
+    3.times do
+      'jump!'
+    end
+  end
+  Unroller::trace
+  jump!
+  Unroller::trace_off
+
+  puts '-----------------------------------------------------------'
+  puts "Testing that this doesn't trace anything (condition == false proc)"
+  $trace = false
+  Unroller::trace(:condition => proc { $trace }) do
+    jump!
+  end
+
+  puts '-----------------------------------------------------------'
+  puts "Testing that this doesn't trace the inner method (method2), but does trace method1 and method3 (exclude)"
+  def method1; end
+  def method2
+    'stuff!'
+  end
+  def method3; end
+  Unroller::trace do
+    method1
+    Unroller::exclude do
+      method2
+    end
+    method3
+  end
+
+  puts '-----------------------------------------------------------'
+  puts 'Test with block; very deep (test for over-wide columns)'
+  ('a'..last='y').each do |method_name|
+    next_method_name = method_name.next unless method_name == last
+    eval <<-End, binding, __FILE__, __LINE__ + 1
+      def #{method_name}
+        #{next_method_name}
+      end
+    End
+  end
+  Unroller::trace(:depth => 5) do
+    a
+  end
+
+  puts '-----------------------------------------------------------'
+  puts 'Test watching a call stack unwind (only)'
+  ('a'..last='y').each do |method_name|
+    next_method_name = method_name.next unless method_name == last
+    eval <<-End, binding, __FILE__, __LINE__ + 1
+      def #{method_name}
+        #{next_method_name}
+        #{'Unroller::trace(:depth => caller(0).size)' if method_name == last }
+      end
+    End
+  end
+  a
+  Unroller::trace_off
+
+
+  puts '-----------------------------------------------------------'
+  puts 'Testing :depth => :use_call_stack_depth'
+  def go_to_depth_and_call_1(depth, &block)
+    #puts caller(0).size
+    if caller(0).size == depth
+      puts 'calling a'
+      block.call
+    else
+      go_to_depth_and_call_2(depth, &block)
+    end
+    #puts caller(0).size
+  end
+  def go_to_depth_and_call_2(depth, &block)
+    #puts caller(0).size
+    if caller(0).size == depth
+      puts 'calling a'
+      block.call
+    else
+      go_to_depth_and_call_1(depth, &block)
+    end
+    #puts caller(0).size
+  end
+  ('a'..last='c').each do |method_name|
+    next_method_name = method_name.next unless method_name == last
+    eval <<-End, binding, __FILE__, __LINE__ + 1
+      def #{method_name}
+        #{next_method_name}
+      end
+    End
+  end
+  go_to_depth_and_call_1(14) do
+    Unroller::trace(:depth => :use_call_stack_depth) do
+      a
+    end
+  end
+
+  puts '-----------------------------------------------------------'
+  puts 'Testing without :depth => :use_call_stack_depth (for comparison)'
+  go_to_depth_and_call_1(14) do
+    Unroller::trace() do
+      a
+    end
+  end
+
+  puts '-----------------------------------------------------------'
+  puts "Test omit_depth_greater_than 5: We shouldn't see the calls to f, g, ... because their depth > 5"
+  ('a'..last='y').each do |method_name|
+    next_method_name = method_name.next unless method_name == last
+    eval <<-End, binding, __FILE__, __LINE__ + 1
+      def #{method_name}
+        #{next_method_name}
+      end
+    End
+  end
+  Unroller::trace(:omit_depth_greater_than => 5) do
+    a
+  end
+
+  puts '-----------------------------------------------------------'
+  puts 'Test with long filename (make sure it chops it correctly)'
+  File.open(filename = '_code_unroller_test_with_really_really_really_really_really_really_really_really_really_long_filename.rb', 'w') do |file|
+    file.puts "
+      def sit!
+        jump!
+      end
+    "
+  end
+  load filename
+  Unroller::trace(:depth => 5) do
+    sit!
+  end
+  require 'fileutils'
+  FileUtils.rm filename
+
+  puts '-----------------------------------------------------------'
+  puts 'Test @stop_after_lines_output'
+  ('a'..last='h').each do |method_name|
+    next_method_name = method_name.next unless method_name == last
+    eval <<-End, binding, __FILE__, __LINE__ + 1
+      def #{method_name}
+        #{next_method_name}
+      end
+    End
+  end
+  Unroller::trace(:stop_after_lines_output => 20) do
+    a
+  end
+
+  puts '-----------------------------------------------------------'
+  puts 'Test @exclude_classes'
+  puts 'Should only see calls to Interesting::...'
+  class Interesting # :nodoc: all
+    def self.method
+      '...'
+    end
+    def method
+      '...'
+    end
+  end
+  module Uninteresting # :nodoc: all
+    class ClassThatCluttersUpOnesTraces
+      ('a'..last='h').each do |method_name|
+        next_method_name = method_name.next unless method_name == last
+        eval <<-End, binding, __FILE__, __LINE__ + 1
+          def #{method_name}
+            #{next_method_name}
+            #{'Interesting::method' if method_name == last }
+            #{'Interesting.new.method' if method_name == last }
+          end
+        End
+      end
+    end
+  end
+  def create_an_instance_of_UninterestingClassThatCluttersUpOnesTraces
+    Uninteresting::ClassThatCluttersUpOnesTraces.new.a
+  end
+  Unroller::trace(:exclude_classes => /Uninteresting::ClassThatCluttersUpOnesTraces/) do
+    create_an_instance_of_UninterestingClassThatCluttersUpOnesTraces
+  end
+
+  puts '-----------------------------------------------------------'
+  puts 'Now let\'s be recursive! We should *not* see any calls to Interesting::* this time. But after we return from it, we should see the call to jump!'
+  Unroller::trace(:exclude_classes => [[/Uninteresting/, :recursive]]) do
+    create_an_instance_of_UninterestingClassThatCluttersUpOnesTraces
+    jump!
+  end
+
+
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: unroller
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+date: 2007-04-13 00:00:00 -07:00
+summary: A tool for generating human-readable "execution traces"
+require_paths: 
+- lib
+email: 
+homepage: http://rdoc.qualitysmith.com/unroller
+rubyforge_project: unroller
+description: A debugging/tracing tool for Ruby. While it is enabled, it will watch every Ruby statement and method call that gets executed and will display the source code that is being executed in real time on your screen.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Tyler Rick
+files: 
+- lib/unroller.rb
+- lib/unroller/unroller.rb
+- Readme
+test_files: []
+
+rdoc_options: 
+- --title
+- unroller
+- --main
+- Readme
+- --line-numbers
+extra_rdoc_files: 
+- Readme
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.54
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: qualitysmith_extensions
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.13
+    version: