unroller 0.0.11 → 0.0.12

data/Readme

@@ -225,7 +225,7 @@ I've also heard rumors that Ruby comes standard with some kind of debugger (?) .
 
 ==To do
 
-You're welcome to submit comments and/or patches.
+You're welcome to submit comments, ideas, and/or patches.
 
 * Make a GUI interface that lets you quickly collapse/nodes nodes of the tree.
 * :include_classes option in addition to :exclude_classes?
@@ -235,4 +235,26 @@ You're welcome to submit comments and/or patches.
   * :preset => :'ActiveRecord high level' : excludes the lowel-level database stuff (like the individual adapter (SQLite, MySQL, ...).
   * :preset => :'ActiveRecord low level'
 
+==="Watch for" conditions===
+
+Only traces / shows you when/if a certain condition is met.
+
+You could use it, for example, to answer the question, "When did this method get added?? I don't remember adding that?!"
+
+Useful when you see evidence that something *is* happening but you just can't figure out *where* it's happening or *why*.
+
+You'd just start the tracer at the very beginning of your application and tell it to watch for lines that might have caused it to be added.
+
+It wouldn't be perfect by any means, but it it might be better than nothing...
+
+* You'd kind of have to know a lot about Ruby and the various ways methods can get added. (Normal def statements or alias or alias_method or alias_method_chain, etc.)
+* It would be a rather inexact test, as it would probably use string/Regexp matching, which can easily be too broad or too strict
+* It wouldn't work for stuff that happens during c-calls or if people don't specify the correct file/line for their evals (because if they don't do that, we can't read the source code)
+
+Might look something like this...
+
+Unroller::trace, :watch_for => proc {|event| event.type =~ /line/ && (event.code =~ /def/ || event.method =~ /method/) }
+end
+
+Other name ideas: :match_code, :match_event, :event_match, :only_events
 

data/lib/unroller.rb

@@ -71,6 +71,7 @@ class Unroller
     @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...
     @max_depth = nil                # Don't trace anything when the depth is greater than this threshold. (This is *relative* to the starting depth, so whatever level you start at is considered depth "1".)
     @exclude_classes = []
+    @include_classes = []           # These will override classes that have been excluded via exclude_classes. So if you both exclude and include a class, it will be included.
     @show_args   = true
     @show_locals = false
     @show_filename_and_line_numbers = true
@@ -121,9 +122,13 @@ class Unroller
     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)
+      # Coerce it into an arry of Regexp's, if possible
       options[:exclude_classes] = [options[:exclude_classes]] if options[:exclude_classes].is_a?(Regexp)
       raise ArgumentError if !options[:exclude_classes].is_a?(Array)
     end
+    if options.has_key?(:include_classes)
+      # :todo:
+    end
     set_with(options)
 
     # Private

metadata

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