busted 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d498f85fa66fcf216da0200686a591694f7378a
-  data.tar.gz: a486884726f18969c55dfe0f0961e9b07a6dd79e
+  metadata.gz: ca3f17fb6e19fab0e2e5604ff88570507f8c1224
+  data.tar.gz: 15884ecda376d2f29feabd868d7d41de6bc25024
 SHA512:
-  metadata.gz: 412b16c7e7729d9b41aed435d9fd072ed0ce4723fcf202288d2ddc391eebb7f1fe6a08b0f33f8825c83b0d7230b7463d8c102351076902ae106bd10b2a110135
-  data.tar.gz: 7bd33efe42c6717c8395cb5be99242d4eeaafeab2cc8ee4e4f83a376c5ddb189b25d543e3c253328c173dbe96f865f52ae35c38699249271083b7f332544dde1
+  metadata.gz: d76855a302daf921cc84681c5a006872616671aa0ca0eb6e4490ef967c738112191f25a1efcbea25496e5c6d2e4e545ff769bffe85561be84a9c1d1fc33a0625
+  data.tar.gz: 95305e22d2ad4168d506ca83d501e7cb55a0ab90337c0dbd8a2e1843f8661c1f8adccc83f28570f1f9e07138d4577de05614d440a702f5fab5496def07ae1c38

data/CONTRIBUTING.md

@@ -8,6 +8,8 @@ welcome.
 
 ## Running the Tests
 
+**Process must have root privileges, and [`dtrace`](http://en.wikipedia.org/wiki/DTrace) must be installed.**
+
 To run the full suite:
 
   `$ bundle exec rake`
@@ -18,7 +20,7 @@ To run a specific test file:
 
 To run a specific test:
 
-  `$ bundle exec ruby -Itest test/busted_test.rb -n test_cache_with_new_constant`
+  `$ bundle exec ruby -Itest test/busted_test.rb -n test_cache_invalidations_with_new_constant`
 
 [issues]: https://github.com/simeonwillbanks/busted/issues
 [pr]: https://help.github.com/articles/using-pull-requests

data/README.md

@@ -1,8 +1,11 @@
-# Busted
+# Busted  [![Build Status](https://travis-ci.org/simeonwillbanks/busted.png?branch=master)](https://travis-ci.org/simeonwillbanks/busted) [![Code Climate](https://codeclimate.com/github/simeonwillbanks/busted.png)](https://codeclimate.com/github/simeonwillbanks/busted)
 
-***Requires MRI Ruby 2.1.0dev***
+#### Disclaimers
+- Requires MRI Ruby 2.1.0dev at [trunk](https://github.com/ruby/ruby/tree/trunk)
+
+--
 
-Find code that busts the Ruby cache.
+Find code that busts the Ruby 2.1+ cache.
 
 - Report when code invalidates Ruby's internal cache
 - Uses [RubyVM.stat](https://github.com/ruby/ruby/commit/cc1063092b366a0a8449528ab6bf67a72f5ce027)
@@ -13,39 +16,46 @@ Find code that busts the Ruby cache.
 
 ```ruby
 Busted.cache? do
-  class Pizza
+  class Beer
   end
 end
 #=> true
+
+Busted.run do
+  class Pizza
+  end
+end
+#=> {:invalidations=>{:method=>0, :constant=>1}}
 ```
 
 *Method Cache*
 
 ```ruby
 Busted.method_cache? do
-  def pizza
+  def beer
   end
 end
 #=> true
+
+Busted.method_cache_invalidations do
+  def pizza
+  end
+end
+#=> 3
 ```
 
 *Constant Cache*
 
 ```ruby
 Busted.constant_cache? do
-  PIZZA = "pizza"
+  STOUT = "stout"
 end
 #=> true
-```
-
-*Class Cache*
 
-```ruby
-Busted.class_cache? do
-  class Beer
-  end
+Busted.constant_cache_invalidations do
+  CHEESE = "cheese"
 end
-#=> true
+#=> 1
 ```
 
 *No Cache Busted*
@@ -55,8 +65,51 @@ Busted.cache? do
   beer = "beer"
 end
 #=> false
+
+Busted.run do
+  pizza = "pizza"
+end
+#=> {:invalidations=>{:method=>0, :constant=>0}}
 ```
 
+## Advanced Usage
+Busted can report method cache invalidation locations via [`dtrace`](http://en.wikipedia.org/wiki/DTrace). The running process must have root privileges, and `dtrace` must be installed.
+
+*trace.rb*
+```ruby
+require "busted"
+require "pp"
+
+report = Busted.run(trace: true) do
+  def cookie; end
+end
+pp report
+```
+
+```bash
+$ whoami
+simeon
+
+$ id simeon
+uid=501(simeon) gid=20(staff) groups=20(staff),80(admin)
+
+# simeon is an admin; sudo does not require a password
+$ sudo grep admin /etc/sudoers
+%admin	ALL=(ALL) NOPASSWD: ALL
+
+$ sudo dtrace -V
+dtrace: Sun D 1.6.2
+
+# No need to sudo
+# Busted runs dtrace in a child process with root privileges
+$ ruby trace.rb
+{:invalidations=>{:method=>1, :constant=>0},
+ :traces=>
+  {:method=>[{:class=>"global", :sourcefile=>"trace.rb", :lineno=>"5"}]}}
+```
+
+Busted includes an [example `dtrace` probe](/dtrace/probes/examples/method-cache-clear.d) for use on the command line or an application.  See the [probe](/dtrace/probes/examples/method-cache-clear.d) for usage.
+
 ## Installation
 
 ***Requires MRI Ruby 2.1.0dev***

data/Rakefile

@@ -3,7 +3,7 @@ require "rake/testtask"
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.pattern = "test/*_test.rb"
+  t.pattern = "test/**/*_test.rb"
 end
 
 task default: :test

data/busted.gemspec

@@ -8,19 +8,38 @@ Gem::Specification.new do |spec|
   spec.version       = Busted::VERSION
   spec.authors       = ["Simeon F. Willbanks"]
   spec.email         = ["sfw@simeonfosterwillbanks.com"]
-  spec.description   = %q{Find code that busts the Ruby cache.}
+  spec.description   = "Find code that busts the Ruby 2.1+ cache."
   spec.summary       = <<-DESC
     MRI Ruby defines RubyVM.stat which accesses internal cache counters.
-    Busted reports when code increments these counters thereby busting the cache.
+    When the cache counters are incremented, the internal cache is invalidated.
+    Busted reports when code increments these counters.
   DESC
   spec.homepage      = "https://github.com/simeonwillbanks/busted"
   spec.license       = "MIT"
 
-  spec.files         = [".ruby-version", "CONTRIBUTING.md", "Gemfile",
-                        "LICENSE.txt", "README.md", "Rakefile",
-                        "busted.gemspec", "lib/busted.rb",
-                        "lib/busted/version.rb", "test/busted_test.rb",
-                        "test/test_helper.rb"]
+  spec.files         = %w(
+    .ruby-version
+    CONTRIBUTING.md
+    Gemfile
+    LICENSE.txt
+    README.md
+    Rakefile
+    busted.gemspec
+    dtrace/probes/busted/method-cache-clear.d
+    dtrace/probes/examples/method-cache-clear.d
+    lib/busted.rb
+    lib/busted/countable.rb
+    lib/busted/counter.rb
+    lib/busted/current_process.rb
+    lib/busted/profiler.rb
+    lib/busted/profiler/default.rb
+    lib/busted/traceable.rb
+    lib/busted/tracer.rb
+    lib/busted/version.rb
+    test/busted/current_process_test.rb
+    test/busted_test.rb
+    test/test_helper.rb
+  )
   spec.test_files    = spec.files.grep(%r{^test/})
   spec.require_paths = ["lib"]
 

data/dtrace/probes/busted/method-cache-clear.d

@@ -0,0 +1,14 @@
+dtrace:::BEGIN
+{
+	printf("Busted Trace Started.\n");
+}
+ruby$target:::method-cache-clear
+/arg1/
+{
+    printf("%s %s %d\n", copyinstr(arg0), copyinstr(arg1), arg2);
+}
+ruby$target:::raise
+/arg1/
+{
+    printf("%s %s %d\n", copyinstr(arg0), copyinstr(arg1), arg2);
+}

data/dtrace/probes/examples/method-cache-clear.d

@@ -0,0 +1,24 @@
+/*
+ * method-cache-clear.d dtrace probe
+ *
+ * Prints invalidation Class, Source File, and Line Number to STDOUT.
+ *
+ * Example Usage:
+ *
+ * $ sudo dtrace -q -s ./method-cache-clear.d -p <pid of running ruby process>
+ * global test/busted_test.rb 78
+ * Hello test/busted_test.rb 66
+ *
+ * More DTrace/Ruby Examples:
+ *
+ * http://magazine.rubyist.net/?Ruby200SpecialEn-dtrace
+ *
+ * Documentation:
+ *
+ * https://github.com/ruby/ruby/blob/trunk/doc/dtrace_probes.rdoc
+ */
+ruby$target:::method-cache-clear
+/arg1/
+{
+    printf("%s %s %d\n", copyinstr(arg0), copyinstr(arg1), arg2);
+}

data/lib/busted.rb

@@ -1,40 +1,34 @@
-require "busted/version"
+require "busted/profiler"
 
 module Busted
   extend self
 
-  def cache?(serial = nil, &blk)
-    starting = count serial
-    yield
-    ending = count serial
-    ending > starting
+  def run(options = {}, &block)
+    Profiler.run options, &block
   end
 
-  def method_cache?(&blk)
-    cache? :method, &blk
+  def method_cache_invalidations(&block)
+    run(&block)[:invalidations][:method]
   end
 
-  def constant_cache?(&blk)
-    cache? :constant, &blk
+  def constant_cache_invalidations(&block)
+    run(&block)[:invalidations][:constant]
   end
 
-  def class_cache?(&blk)
-    cache? :class, &blk
+  def cache?(counter = nil, &block)
+    total = if counter
+              send :"#{counter}_cache_invalidations", &block
+            else
+              run(&block)[:invalidations].values.inject :+
+            end
+    total > 0
   end
 
-  private
+  def method_cache?(&block)
+    cache? :method, &block
+  end
 
-  def count(serial)
-    stat = RubyVM.stat
-    case serial
-    when :method
-      stat[:method_serial]
-    when :constant
-      stat[:constant_serial]
-    when :class
-      stat[:class_serial]
-    else
-      stat[:method_serial] + stat[:constant_serial] + stat[:class_serial]
-    end
+  def constant_cache?(&block)
+    cache? :constant, &block
   end
 end

data/lib/busted/countable.rb

@@ -0,0 +1,19 @@
+module Busted
+  module Countable
+
+    attr_reader :counter
+    attr_writer :report
+
+    def start_counter
+      @counter = Counter.new
+
+      counter.start
+    end
+
+    def finish_counter
+      counter.finish
+
+      report[:invalidations] = counter.report
+    end
+  end
+end

data/lib/busted/counter.rb

@@ -0,0 +1,30 @@
+module Busted
+  class Counter
+
+    def start
+      @started = counts
+    end
+
+    def finish
+      @finished = counts
+    end
+
+    def report
+      [:method, :constant].each_with_object({}) do |counter, result|
+        result[counter] = finished[counter] - started[counter]
+      end
+    end
+
+    private
+
+    attr_reader :started, :finished
+
+    def counts
+      stat = RubyVM.stat
+      {
+        method:   stat[:global_method_state],
+        constant: stat[:global_constant_state]
+      }
+    end
+  end
+end

data/lib/busted/current_process.rb

@@ -0,0 +1,23 @@
+module Busted
+  module CurrentProcess
+    extend self
+
+    def privileged?
+      if root? || sudoer?
+        true
+      else
+        false
+      end
+    end
+
+    def root?
+      Process.euid == 0
+    end
+
+    def sudoer?
+      system "sudo echo ok > /dev/null 2>&1"
+    rescue Errno::EPERM
+      false
+    end
+  end
+end

data/lib/busted/profiler.rb

@@ -0,0 +1,23 @@
+require "busted/counter"
+require "busted/countable"
+require "busted/tracer"
+require "busted/traceable"
+require "busted/profiler/default"
+
+module Busted
+  module Profiler
+    extend self
+
+    def run(options, &block)
+      klass(options.fetch :profiler, :default).new(options, &block).run
+    end
+
+    private
+
+    def klass(profiler)
+      Profiler.const_get profiler.capitalize
+    rescue NameError
+      fail ArgumentError, "profiler `#{profiler}' does not exist"
+    end
+  end
+end

data/lib/busted/profiler/default.rb

@@ -0,0 +1,31 @@
+module Busted
+  module Profiler
+    class Default
+
+      include Busted::Traceable
+      include Busted::Countable
+
+      attr_reader :trace, :block, :report
+
+      def initialize(options = {}, &block)
+        fail LocalJumpError, "no block given" unless block
+
+        @trace = options.fetch :trace, false
+        @block = block
+        @report = {}
+      end
+
+      def run
+        start_tracer
+        start_counter
+
+        block.call
+
+        finish_counter
+        finish_tracer
+
+        report
+      end
+    end
+  end
+end

data/lib/busted/traceable.rb

@@ -0,0 +1,37 @@
+require "busted/current_process"
+
+module Busted
+  module Traceable
+
+    attr_reader :trace, :tracer
+    attr_writer :report
+
+    def trace?
+      trace
+    end
+
+    def start_tracer
+      return unless trace?
+
+      unless Tracer.exists?
+        fail Tracer::MissingCommandError, "tracer requires dtrace"
+      end
+
+      unless CurrentProcess.privileged?
+        fail Errno::EPERM, "dtrace requires root privileges"
+      end
+
+      @tracer = Tracer.new
+
+      tracer.start
+    end
+
+    def finish_tracer
+      return unless trace?
+
+      tracer.finish
+
+      report[:traces] = tracer.report
+    end
+  end
+end

data/lib/busted/tracer.rb

@@ -0,0 +1,88 @@
+require "tempfile"
+
+module Busted
+  class Tracer
+
+    class FinishedException < Exception; end
+    class MissingCommandError < StandardError; end
+
+    def self.exists?
+      system "hash dtrace 2>/dev/null"
+    end
+
+    def initialize
+      @lines = ""
+    end
+
+    def start
+      spawn
+      wait until started?
+    end
+
+    def finish
+      final_probe
+      wait until finished?
+      kill
+    ensure
+      clean_up
+    end
+
+    def report
+      lines.split("\n").each_with_object({method: []}) do |line, result|
+        next if line =~ /\ABusted/
+        trace = line.split
+        result[:method] << { class: trace[0], sourcefile: trace[1], lineno: trace[2] }
+      end
+    end
+
+    private
+
+    attr_accessor :lines
+    attr_reader :child_pid
+
+    def wait
+      sleep 0.1
+    end
+
+    def started?
+      !(lines << log.read).empty?
+    end
+
+    def finished?
+      (lines << log.read) =~ /Busted::Tracer::FinishedException/
+    end
+
+    def final_probe
+      raise FinishedException
+    rescue FinishedException
+    end
+
+    def spawn
+      @child_pid = Process.spawn command, STDERR => STDOUT
+    end
+
+    def kill
+      `sudo kill -TERM #{child_pid}`
+    end
+
+    def parent_pid
+      Process.pid
+    end
+
+    def probe
+      File.expand_path "../../../dtrace/probes/busted/method-cache-clear.d", __FILE__
+    end
+
+    def log
+      @log ||= Tempfile.new "busted-dtrace.log"
+    end
+
+    def clean_up
+      log.close!
+    end
+
+    def command
+      "sudo dtrace -q -o #{log.path} -s #{probe} -p #{parent_pid}"
+    end
+  end
+end

data/lib/busted/version.rb

@@ -1,3 +1,3 @@
 module Busted
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/test/busted/current_process_test.rb

@@ -0,0 +1,30 @@
+require "test_helper"
+
+class Busted::CurrentProcessTest < MiniTest::Unit::TestCase
+
+  def test_privileged_because_root
+    Process.stub :euid, 0 do
+      assert Busted::CurrentProcess.privileged?
+    end
+  end
+
+  def test_privileged_because_sudoer
+    Process.stub :euid, 1980 do
+      # TODO
+      # Reliably stub Object#system
+      Busted::CurrentProcess.stub :sudoer?, true do
+        assert Busted::CurrentProcess.privileged?
+      end
+    end
+  end
+
+  def test_not_privileged
+    Process.stub :euid, 1980 do
+      # TODO
+      # Reliably stub Object#system
+      Busted::CurrentProcess.stub :sudoer?, false do
+        refute Busted::CurrentProcess.privileged?
+      end
+    end
+  end
+end

data/test/busted_test.rb

@@ -1,91 +1,226 @@
 require "test_helper"
 
 class BustedTest < MiniTest::Unit::TestCase
-  def test_responds_to_cache?
-    assert Busted.respond_to? :cache?
+  def test_invalid_profiler_exception
+    error = assert_raises ArgumentError do
+      Busted.run profiler: :pizza
+    end
+    assert_equal "profiler `pizza' does not exist", error.message
   end
 
-  def test_responds_to_method_cache?
-    assert Busted.respond_to? :method_cache?
+  def test_cache_invalidations_requires_block
+    assert_raises LocalJumpError do
+      Busted.run
+    end
   end
 
-  def test_responds_to_constant_cache?
-    assert Busted.respond_to? :constant_cache?
+  def test_method_cache_invalidations_requires_block
+    assert_raises LocalJumpError do
+      Busted.method_cache_invalidations
+    end
   end
 
-  def test_block_required
+  def test_constant_cache_invalidations_requires_block
+    assert_raises LocalJumpError do
+      Busted.constant_cache_invalidations
+    end
+  end
+
+  def test_cache_invalidations_with_empty_block
+    report = Busted.run { }
+    assert_equal 0, report[:invalidations][:method]
+    assert_equal 0, report[:invalidations][:constant]
+  end
+
+  def test_method_cache_invalidations_with_empty_block
+    assert_equal 0, Busted.method_cache_invalidations { }
+  end
+
+  def test_constant_cache_invalidations_with_empty_block
+    assert_equal 0, Busted.constant_cache_invalidations { }
+  end
+
+  def test_cache_invalidations_with_addition
+    report = Busted.run { 1 + 1 }
+    assert_equal 0, report[:invalidations][:method]
+    assert_equal 0, report[:invalidations][:constant]
+  end
+
+  def test_method_cache_invalidations_with_addition
+    assert_equal 0, Busted.method_cache_invalidations { 1 + 1 }
+  end
+
+  def test_constant_cache_invalidations_with_addition
+    assert_equal 0, Busted.constant_cache_invalidations { 1 + 1 }
+  end
+
+  def test_cache_invalidations_with_new_constant
+    report = Busted.run { self.class.const_set :"CHEESE", "cheese" }
+    assert_equal 0, report[:invalidations][:method]
+    assert_equal 1, report[:invalidations][:constant]
+  end
+
+  def test_method_cache_invalidations_with_new_constant
+    invalidations = Busted.method_cache_invalidations do
+      self.class.const_set :"HAWAIIAN", "hawaiian"
+    end
+    assert_equal 0, invalidations
+  end
+
+  def test_constant_cache_invalidations_with_new_constant
+    invalidations = Busted.constant_cache_invalidations do
+      self.class.const_set :"VEGETABLE", "vegetable"
+    end
+    assert_equal 1, invalidations
+  end
+
+  def test_cache_invalidations_with_new_method
+    report = Busted.run { Object.class_exec { def cheese; end } }
+    assert_equal 1, report[:invalidations][:method]
+    assert_equal 0, report[:invalidations][:constant]
+  end
+
+  def test_method_cache_invalidations_with_new_method
+    invalidations = Busted.method_cache_invalidations do
+      Object.class_exec { def hawaiian; end }
+    end
+    assert_equal 1, invalidations
+  end
+
+  def test_constant_cache_invalidations_with_new_method
+    invalidations = Busted.constant_cache_invalidations do
+      Object.class_exec { def vegetable; end }
+    end
+    assert_equal 0, invalidations
+  end
+
+  def test_cache_invalidations_with_new_class
+    report = Busted.run { Object.class_eval "class ThreeCheese; end" }
+    assert_equal 0, report[:invalidations][:method]
+    assert_equal 1, report[:invalidations][:constant]
+  end
+
+  def test_method_cache_invalidations_with_new_class
+    invalidations = Busted.method_cache_invalidations do
+      Object.class_eval "class SweetHawaiian; end"
+    end
+    assert_equal 0, invalidations
+  end
+
+  def test_constant_cache_invalidations_with_new_class
+    invalidations = Busted.constant_cache_invalidations do
+      Object.class_eval "class Veggie; end"
+    end
+    assert_equal 1, invalidations
+  end
+
+  def test_cache_predicate_requires_block
     assert_raises LocalJumpError do
       Busted.cache?
     end
   end
 
-  def test_empty_block
+  def test_method_cache_predicate_requires_block
+    assert_raises LocalJumpError do
+      Busted.method_cache?
+    end
+  end
+
+  def test_constant_cache_predicate_requires_block
+    assert_raises LocalJumpError do
+      Busted.constant_cache?
+    end
+  end
+
+  def test_cache_predicate_with_empty_block
     refute Busted.cache? { }
+  end
+
+  def test_method_cache_predicate_with_empty_block
     refute Busted.method_cache? { }
+  end
+
+  def test_constant_cache_predicate_with_empty_block
     refute Busted.constant_cache? { }
   end
 
-  def test_cache_with_addition
+  def test_cache_predicate_with_addition
     refute Busted.cache? { 1 + 1 }
   end
 
-  def test_method_cache_with_addition
+  def test_method_cache_predicate_with_addition
     refute Busted.method_cache? { 1 + 1 }
   end
 
-  def test_constant_cache_with_addition
+  def test_constant_cache_predicate_with_addition
     refute Busted.constant_cache? { 1 + 1 }
   end
 
-  def test_class_cache_with_addition
-    refute Busted.class_cache? { 1 + 1 }
+  def test_cache_predicate_with_new_constant
+    assert Busted.cache? { self.class.const_set :"PORTER", "porter" }
   end
 
-  def test_cache_with_new_constant
-    assert Busted.cache? { self.class.const_set :"FOO", "foo"  }
+  def test_method_cache_predicate_with_new_constant
+    refute Busted.method_cache? { self.class.const_set :"SCHWARZBIER", "schwarzbier" }
   end
 
-  def test_method_cache_with_new_constant
-    refute Busted.method_cache? { self.class.const_set :"BAR", "bar"  }
+  def test_constant_cache_predicate_with_new_constant
+    assert Busted.constant_cache? { self.class.const_set :"STOUT", "stout" }
   end
 
-  def test_constant_cache_with_new_constant
-    assert Busted.constant_cache? { self.class.const_set :"BAZ", "baz"  }
+  def test_cache_predicate_with_new_method
+    assert Busted.cache? { Object.class_exec { def porter; end } }
   end
 
-  def test_class_cache_with_new_constant
-    refute Busted.class_cache? { self.class.const_set :"BEER", "beer"  }
+  def test_method_cache_predicate_with_new_method
+    assert Busted.method_cache? { Object.class_exec { def schwarzbier; end } }
   end
 
-  def test_cache_with_new_method
-    assert Busted.cache? { Object.class_exec { def foo; end } }
+  def test_constant_cache_predicate_with_new_method
+    refute Busted.constant_cache? { Object.class_exec { def stout; end } }
   end
 
-  def test_method_cache_with_new_method
-    assert Busted.method_cache? { Object.class_exec { def bar; end } }
+  def test_cache_predicate_with_new_class
+    assert Busted.cache? { Object.class_eval "class PierRatPorter; end" }
   end
 
-  def test_constant_cache_with_new_method
-    refute Busted.constant_cache? { Object.class_exec { def baz; end } }
+  def test_method_cache_predicate_with_new_class
+    refute Busted.method_cache? { Object.class_eval "class MidnightExpression; end" }
   end
 
-  def test_class_cache_with_new_method
-    refute Busted.class_cache? { Object.class_exec { def beer; end } }
+  def test_constant_cache_predicate_with_new_class
+    assert Busted.constant_cache? { Object.class_eval "class SantasLittleHelper; end" }
   end
 
-  def test_cache_with_new_class
-    assert Busted.cache? { Object.class_eval %q{class PierRatPorter; end} }
-  end
+  if Busted::Tracer.exists? && Busted::CurrentProcess.privileged?
 
-  def test_method_cache_with_new_class
-    refute Busted.method_cache? { Object.class_eval %q{class MidnightExpression; end} }
+    def test_cache_invalidations_and_traces_with_new_method
+      report = Busted.run(trace: true) { Object.class_exec { def cookie; end } }
+      assert_equal 1, report[:invalidations][:method]
+      assert_equal 0, report[:invalidations][:constant]
+      assert_equal "global", report[:traces][:method][0][:class]
+      assert_match /test\/busted_test.rb\z/, report[:traces][:method][0][:sourcefile]
+      assert_equal "198", report[:traces][:method][0][:lineno]
+    end
   end
 
-  def test_constant_cache_with_new_class
-    assert Busted.constant_cache? { Object.class_eval %q{class SantasLittleHelper; end} }
+  def test_trace_without_root_privileges
+    Busted::Tracer.stub :exists?, true do
+      Busted::CurrentProcess.stub :privileged?, false do
+        error = assert_raises Errno::EPERM do
+          Busted.run(trace: true) { Object.class_exec { def ice_cream; end } }
+        end
+        assert_equal "Operation not permitted - dtrace requires root privileges", error.message
+      end
+    end
   end
 
-  def test_class_cache_with_new_class
-    assert Busted.class_cache? { Object.class_eval %q{class TStreetWheat; end} }
+  def test_trace_without_dtrace_installed
+    Busted::Tracer.stub :exists?, false do
+      error = assert_raises Busted::Tracer::MissingCommandError do
+        Busted.run(trace: true) { Object.class_exec { def pie; end } }
+      end
+      assert_equal "tracer requires dtrace", error.message
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: busted
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Simeon F. Willbanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-08 00:00:00.000000000 Z
+date: 2013-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,7 +38,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Find code that busts the Ruby cache.
+description: Find code that busts the Ruby 2.1+ cache.
 email:
 - sfw@simeonfosterwillbanks.com
 executables: []
@@ -52,8 +52,18 @@ files:
 - README.md
 - Rakefile
 - busted.gemspec
+- dtrace/probes/busted/method-cache-clear.d
+- dtrace/probes/examples/method-cache-clear.d
 - lib/busted.rb
+- lib/busted/countable.rb
+- lib/busted/counter.rb
+- lib/busted/current_process.rb
+- lib/busted/profiler.rb
+- lib/busted/profiler/default.rb
+- lib/busted/traceable.rb
+- lib/busted/tracer.rb
 - lib/busted/version.rb
+- test/busted/current_process_test.rb
 - test/busted_test.rb
 - test/test_helper.rb
 homepage: https://github.com/simeonwillbanks/busted
@@ -79,8 +89,10 @@ rubyforge_project:
 rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
-summary: MRI Ruby defines RubyVM.stat which accesses internal cache counters. Busted
-  reports when code increments these counters thereby busting the cache.
+summary: MRI Ruby defines RubyVM.stat which accesses internal cache counters. When
+  the cache counters are incremented, the internal cache is invalidated. Busted reports
+  when code increments these counters.
 test_files:
+- test/busted/current_process_test.rb
 - test/busted_test.rb
 - test/test_helper.rb