cordon 0.2.2

data/LICENSE.txt

@@ -0,0 +1,13 @@
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                   Version 2, December 2004
+
+License copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. You just DO WHAT THE FUCK YOU WANT TO.

data/README.markdown

@@ -0,0 +1,72 @@
+# Cordon Sanitaire
+
+From Wikipedia:
+
+> Cordon sanitaire -- or quarantine line -- is a French phrase that, literally
+> translated, means "sanitary cordon". Though in French it originally denoted a barrier
+> implemented to stop the spread of disease, it has often been used in English in a
+> metaphorical sense to refer to attempts to prevent the spread of an ideology deemed
+> unwanted or dangerous, such as the containment policy adopted by George F. Kennan
+> against the Soviet Union.
+
+I've never been a big fan of the way RSpec adds <code>#should</code> and <code>#should_not</code> to Kernel, but until recently I'd never been able to articulate why.  Then I worked on a project that became <a href="https://github.com/geeksam/kookaburra/">Kookaburra</a>, and I found a specific reason to be annoyed.
+
+Basically, putting <code>#should</code> on all objects gives you the freedom to <s>shoot yourself in the foot</s> put RSpec expectations *anywhere*, not just inside an <code>#it</code> block.  So, I went looking for a way to make <code>#should</code> explode if it was called outside a specific context.
+
+After several false starts and horrible ideas, I've got something that actually isn't too bad.
+
+Cordon makes specs look like this:
+
+<pre><code lang="ruby">describe "a toggle switch" do
+  it "should be on when flipped up" do
+    toggle = ToggleSwitch.new
+    toggle.flip_up
+    <em><strong>assert_that</strong></em>(toggle).should be_on
+  end
+end</code></pre>
+
+Cordon lets you declare certain methods as "off-limits" to casual code.  Any calls to blacklisted methods will raise a Cordon::Violation exception -- <em>unless</em> they're called on the object thats passed as the single argument to <code>Object#assert\_that</code>, as shown above.  What <code>#assert\_that</code> does is temporarily add its argument to a whitelist.  This effectively gives that object permission to call any blacklisted method once (and only once!).
+
+## Quick setup for popular testing frameworks
+
+Currently, Cordon ships with shorthand configuration items for RSpec and MiniTest::Spec.  You can set these up like so:
+
+### RSpec
+<pre><code lang="ruby">require 'rspec'
+Cordon.embargo :rspec</code></pre>
+
+### MiniTest::Spec
+<pre><code lang="ruby">require 'minitest/autorun'
+Cordon.embargo :minitest_spec</code></pre>
+
+In both examples, note that Cordon's <code>.embargo</code> method must be called *after* the test framework has been loaded.
+
+
+## TODO
+
+- Write integration macros (and tests, obviously) for various spec frameworks:
+  - <s>RSpec</s>
+  - <s>MiniTest::Spec</s>
+  - <s>Yoda</s> <em>(Actually, Yoda appears to abuse Ruby syntax badly enough that it may not work with Cordon.)</em>
+  - ?
+- <s>Add a declarative API to customize the name of the function that wraps assertions</s>
+- probably some other stuff I can't think of at the moment
+
+
+
+## Contributing to Cordon
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+
+
+## Copyright
+
+Copyright (c) 2012 Sam Livingston-Gray. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "cordon"
+  gem.homepage = "http://github.com/geeksam/cordon"
+  gem.license = "WTFPL"
+  gem.summary = %Q{Cordon Sanitaire: hygienic handling of infectious methods}
+  gem.description = %Q{A bit of an experiment, really}
+  gem.email = "geeksam@gmail.com"
+  gem.authors = ["Sam Livingston-Gray"]
+  # dependencies defined in Gemfile
+
+  gem.files.exclude *%w[ .document .rvmrc Gemfile Gemfile.lock]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+
+
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+namespace :test do
+  desc 'Run all tests'
+  task :all => ['test:integration', 'test:framework_integration']
+
+  desc 'Run integration tests'
+  Rake::TestTask.new(:integration) do |t|
+    t.pattern = 'test/integration/*_test.rb'
+    t.verbose = true
+  end
+
+  desc 'Run all framework integration tests'
+  task :framework_integration => ['test:framework:rspec', 'test:framework:minitest_spec']
+
+  namespace :framework do
+    RSpec::Core::RakeTask.new(:rspec) do |t|
+      t.pattern = 'test/framework_integration/rspec_spec.rb'
+      t.verbose = true
+    end
+
+    Rake::TestTask.new(:minitest_spec) do |t|
+      t.pattern = 'test/framework_integration/minitest_spec_spec.rb'
+      t.verbose = true
+    end
+  end
+
+end
+task :default => ['test:all']
+
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cordon #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+desc 'Quick and dirty SLOC counts'
+task :stats do
+  sloc_count = lambda do |glob_expression|
+    glob_expression = File.join(File.dirname(__FILE__), glob_expression)
+    lines_in_file = lambda { |filename| File.open(filename, 'r').readlines.reject { |line| line =~ /^\s*(#|$)/ }.length }
+    n = Dir.glob(glob_expression).inject(0) { |n, f| n + lines_in_file[f] }
+    n.to_f
+  end
+  lib  = sloc_count['lib/**/*.rb']
+  test = sloc_count['test/**/*_{test,spec}.rb']
+  puts <<-EOF
+    Cordon code stats
+    Lib LOC:  #{ '%3d' % lib }
+    Test LOC: #{ '%3d' % test }
+    Lib/test: #{ '%.1f' % (lib/test) }
+EOF
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.2

data/cordon.gemspec

@@ -0,0 +1,76 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cordon}
+  s.version = "0.2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Sam Livingston-Gray}]
+  s.date = %q{2012-03-09}
+  s.description = %q{A bit of an experiment, really}
+  s.email = %q{geeksam@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = [
+    "LICENSE.txt",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "cordon.gemspec",
+    "lib/cordon.rb",
+    "lib/cordon/blacklist.rb",
+    "lib/cordon/sanitaire.rb",
+    "lib/cordon/violation.rb",
+    "lib/cordon/whitelist.rb",
+    "test/framework_integration/minitest_spec_spec.rb",
+    "test/framework_integration/rspec_spec.rb",
+    "test/helper.rb",
+    "test/integration/backtrace_cleaning_test.rb",
+    "test/integration/cordon_basic_examples_test.rb",
+    "test/integration/cordon_customization_test.rb",
+    "test/integration/cordon_default_behavior_test.rb",
+    "test/integration/cordon_edge_cases_test.rb",
+    "test/integration/integration_test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/geeksam/cordon}
+  s.licenses = [%q{WTFPL}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{Cordon Sanitaire: hygienic handling of infectious methods}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<mocha>, ["~> 0.10.3"])
+      s.add_development_dependency(%q<ruby-debug19>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<minitest>, [">= 0"])
+    else
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<mocha>, ["~> 0.10.3"])
+      s.add_dependency(%q<ruby-debug19>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<minitest>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<mocha>, ["~> 0.10.3"])
+    s.add_dependency(%q<ruby-debug19>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<minitest>, [">= 0"])
+  end
+end
+

data/lib/cordon.rb

@@ -0,0 +1,52 @@
+# Require ALL the sources!
+Dir.glob(File.join(File.dirname(__FILE__), 'cordon/*.rb')).each { |f| require f }
+
+
+# Protect ALL the objects!
+class Object
+  include Cordon::Sanitaire
+end
+
+
+# Patch ALL the monkeys!
+module Kernel
+  # This bit of metaprogramming replaces a blacklisted method with a hook that calls back
+  # into the #__cordon__call_method__ defined in Cordon::Sanitaire (and, therefore, mixed in to Object)
+  def __cordon__wrap_method__(method)
+    # Take advantage of the fact that the block passed to define_method is a closure,
+    # so we can find the blacklisted method quickly.
+    # Use a name unlikely to collide in the object's own binding.
+    __cordon__receiver__ = self
+    define_method(method) do |*args, &b|
+      subject = __cordon__receiver__
+      __cordon__call_method__(subject, method, *args, &b)
+    end
+  end
+end
+
+
+module Cordon
+  # Declare specific methods as off-limits
+  def self.blacklist(subject, methods)
+    methods.each do |method|
+      Blacklist.blacklist_method(subject, method.to_sym)
+    end
+  end
+
+  # Shorthand for blacklisting the undesirable methods in specific frameworks
+  def self.embargo(framework)
+    case framework
+    when :rspec
+      blacklist Kernel, [:should, :should_not]
+    when :minitest_spec
+      must_and_wont = MiniTest::Expectations.instance_methods.map(&:to_s).select {|e| e =~ /^(must|wont)_/}
+      blacklist MiniTest::Expectations, must_and_wont
+    else
+      raise "I don't know how to embargo #{framework}!"
+    end
+  end
+
+  def self.wrap_assertions_with(custom_method_name)
+    Sanitaire.wrap_assertions_with(custom_method_name)
+  end
+end

data/lib/cordon/blacklist.rb

@@ -0,0 +1,30 @@
+module Cordon
+  module Blacklist
+    TheList = {}
+
+    def self.blacklist_method(subject, method)
+      return if unbound_method(subject, method)  # be idempotent
+
+      # Unbind the original method, and replace it with a wrapper that
+      # checks for permission before binding and calling the original
+      Blacklist.unbind_method(subject, method)
+      subject.__cordon__wrap_method__(method)
+    end
+
+    def self.invoke_method(instance, subject, method, *args, &b)
+      um = unbound_method(subject, method)
+      um.bind(instance).call(*args, &b)
+    end
+
+  protected
+
+    def self.unbind_method(subject, method)
+      um = subject.instance_method(method) # will raise NameError if the method doesn't exist
+      TheList[[subject, method]] = um
+    end
+
+    def self.unbound_method(subject, method)
+      TheList[[subject, method]]
+    end
+  end
+end

data/lib/cordon/sanitaire.rb

@@ -0,0 +1,21 @@
+module Cordon
+  module Sanitaire
+
+    def __cordon__assertion_wrapper__(predicate)
+      ::Cordon::Whitelist.admit_one(predicate)
+      return predicate
+    end
+
+    def self.wrap_assertions_with(custom_method_name)
+      alias_method custom_method_name, :__cordon__assertion_wrapper__
+    end
+    wrap_assertions_with :assert_that
+
+  protected
+
+    def __cordon__call_method__(subject, method, *args, &b)
+      ::Cordon::Whitelist.check_permissions(self, subject, method, *args)
+      ::Cordon::Blacklist.invoke_method(self, subject, method, *args, &b)
+    end
+  end
+end

data/lib/cordon/violation.rb

@@ -0,0 +1,9 @@
+module Cordon
+  class Violation < Exception
+    def backtrace
+      bt = super
+      bt.shift while bt && bt.first =~ /cordon\.rb\:\d+\:in/
+      bt
+    end
+  end
+end

data/lib/cordon/whitelist.rb

@@ -0,0 +1,16 @@
+module Cordon
+  module Whitelist
+    TheList = []
+
+    def self.admit_one(object)
+      TheList << object
+    end
+
+    def self.check_permissions(instance, subject, method, *args)
+      allowed = !! TheList.delete(instance)
+      return if allowed
+      message = '%s#%s(%s)' % [subject, method, args.map(&:inspect).join(', ')]
+      raise ::Cordon::Violation, message
+    end
+  end
+end

data/test/framework_integration/minitest_spec_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. helper]))
+require 'minitest/autorun'
+
+Cordon.embargo :minitest_spec
+
+describe "MiniTest::Spec integration" do
+  it 'works just fine if you adhere to the rules' do
+    assert_that(42).must_equal 42
+  end
+
+  it 'explodes if you use standard^H^H evil MiniTest::Spec idiom' do
+    begin
+      42.must_equal 6*9
+      flunk "This line should not be executed"
+    rescue Cordon::Violation
+      # all is well; carry on
+    end
+  end
+end

data/test/framework_integration/rspec_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. helper]))
+require 'rspec'
+
+Cordon.embargo :rspec
+
+describe "RSpec integration" do
+  it 'works just fine if you adhere to the rules' do
+    assert_that(42).should == 42
+  end
+
+  it 'explodes if you use standard^H^H evil RSpec idiom' do
+    begin
+      42.should == 6*9
+      raise "This line should not be executed"
+    rescue Cordon::Violation
+      # all is well; carry on
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'ruby-debug'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'cordon'

data/test/integration/backtrace_cleaning_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), 'integration_test_helper')
+
+module Kernel
+  def verboten_method_for_backtrace
+    raise VerbotenMethodCallReachedKernel
+  end
+end
+
+Cordon.blacklist Kernel, [:verboten_method_for_backtrace]
+
+# Cordon will remove its own method calls from the backtrace; hopefully this will reduce confusion somewhat
+class BacktraceCleaningUnitTest < CordonUnitTest
+  def test_cordon_lines_are_removed_from_violation_backtrace
+    foo.verboten_method_for_backtrace
+  rescue Cordon::Violation => e
+    failure_message = "cordon.rb appears in first line of backtrace:\n"
+    failure_message << (e.backtrace[0..3] + ['(rest of backtrace omitted)']).map { |e| '  ' + e }.join("\n")
+    refute e.backtrace.first.include?('cordon.rb:'), failure_message
+  end
+end

data/test/integration/cordon_basic_examples_test.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), 'integration_test_helper')
+
+module Kernel
+  def verboten_method
+    raise VerbotenMethodCallReachedKernel
+  end
+end
+
+# You can tell Cordon to blacklist certain methods on all objects.
+Cordon.blacklist Kernel, [:verboten_method]
+
+class CordonBasicExamples < CordonUnitTest
+  # Calling #verboten_method on an object will raise an exception...
+  def test_raises_exception_when_calling__verboten_method
+    assert_raise(Cordon::Violation) do
+      foo.verboten_method
+    end
+  end
+
+  # ...unless you explicitly wrap that object in an #assert_that call
+  def test_allows_explicit_calls_to__verboten_method
+    assert_raises(VerbotenMethodCallReachedKernel) do
+      assert_that(foo).verboten_method
+    end
+  end
+
+  # ...every time!
+  def test_permission_provided_by_assert_that_only_works_once
+    assert_raise(Cordon::Violation) do
+      begin
+        assert_that(foo).verboten_method
+      rescue VerbotenMethodCallReachedKernel
+        # carry on
+      end
+      foo.verboten_method
+    end
+  end
+end
+

data/test/integration/cordon_customization_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), 'integration_test_helper')
+
+module Kernel
+  def should_probably(*_)
+    raise VerbotenMethodCallReachedKernel
+  end
+end
+
+Cordon.blacklist Kernel, [:should_probably]
+
+
+# You can specify a different method than #assert_that as your custom assertion wrapper
+Cordon.wrap_assertions_with :if_you_would_be_so_kind
+
+class CordonCustomizationExamples < CordonUnitTest
+  def test_raises_exception_when_calling__verboten_method
+    assert_raise(Cordon::Violation) do
+      foo.should_probably :explode
+    end
+  end
+
+  # ...unless you explicitly wrap that object in an #assert_that call
+  def test_allows_explicit_calls_to__verboten_method
+    assert_raises(VerbotenMethodCallReachedKernel) do
+      if_you_would_be_so_kind(foo).should_probably :work # but only if you feel like it
+    end
+  end
+end
+

data/test/integration/cordon_default_behavior_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'integration_test_helper')
+
+module Kernel
+  def verboten_method_not_on_cordon_watch_list
+    raise VerbotenMethodCallReachedKernel
+  end
+end
+
+# By default, Cordon does nothing!
+class CordonDefaultBehaviorUnitTest < CordonUnitTest
+  def test_allows_calls_to__verboten_method_not_on_cordon_watch_list
+    assert_raises(VerbotenMethodCallReachedKernel) { foo.verboten_method_not_on_cordon_watch_list }
+  end
+end

data/test/integration/cordon_edge_cases_test.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), 'integration_test_helper')
+
+module Kernel
+  def verboten_method_with_args(*args)
+    raise "No args given!" if args.empty?
+    raise VerbotenMethodCallReachedKernel, args.inspect
+  end
+
+  def verboten_method_with_block(*_)
+    raise "Block expected!" unless block_given?
+    yield
+    raise VerbotenMethodCallReachedKernel
+  end
+
+  def verboten_method_with_args_and_block_with_args(options = {})
+    raise "No args given!" if options.empty?
+    raise "Block expected!" unless block_given?
+    arg_for_block = options.fetch(:arg_for_block)
+    yield arg_for_block
+    raise VerbotenMethodCallReachedKernel, options.inspect
+  end
+end
+
+Cordon.blacklist Kernel, [:verboten_method, :verboten_method_with_args, :verboten_method_with_block]
+
+class CordonEdgeCaseTests < CordonUnitTest
+  # Arguments to verboten methods are passed along as one might expect
+  def test_raises_exception_when_calling__verboten_method_with_args
+    args = [:foo, :bar, :baz]
+    begin
+      line = __LINE__; foo.verboten_method_with_args(*args)
+    rescue Cordon::Violation => e
+      expected = "Kernel#verboten_method_with_args(#{args.map(&:inspect).join(', ')})"
+      assert_equal expected, e.message
+    rescue VerbotenMethodCallReachedKernel
+      flunk "foo.verboten_method_with_args(#{args.map(&:inspect).join(', ')}) should not be allowed! (See line #{line})"
+    end
+  end
+
+  def test_allows_explicit_calls_to__verboten_method_with_args
+    assert_raises(VerbotenMethodCallReachedKernel) do
+      assert_that(foo).verboten_method_with_args(:foo, :bar, :baz)
+    end
+  end
+
+  # And blocks given to verboten methods are yielded to as one might expect
+  # Calling #verboten_method_with_block should raise an exception 
+  def test_raises_exception_when_calling__verboten_method_with_block
+    block_was_called = false
+    begin
+      line = __LINE__; foo.verboten_method_with_block() { block_was_called = true }
+    rescue Cordon::Violation => e
+      expected = "Kernel#verboten_method_with_block()"
+      assert_equal expected, e.message
+      assert_equal false, block_was_called, "Block was called, but it shouldn't have been!"
+    rescue VerbotenMethodCallReachedKernel
+      flunk "foo.verboten_method_with_block(&b) should not be allowed! (See line #{line})"
+    end
+  end
+
+  def test_allows_explicit_calls_to__verboten_method_with_block
+    block_was_called = false
+    assert_raises(VerbotenMethodCallReachedKernel) do
+      assert_that(foo).verboten_method_with_block() { block_was_called = true }
+    end
+    assert block_was_called, "Block wasn't called when it should have been!"
+  end
+
+  # Blocks with args get passed the args they expect.
+  def test_allows_explicit_calls_to__verboten_method_with_args_and_block_with_args
+    block_was_called = false
+    arg_passed_to_block = nil
+    assert_raises(VerbotenMethodCallReachedKernel) do
+      assert_that(foo).verboten_method_with_args_and_block_with_args(:arg_for_block => 42) do |x|
+        block_was_called = true
+        arg_passed_to_block = x
+      end
+    end
+    assert block_was_called, "Block wasn't called when it should have been!"
+    assert_equal 42, arg_passed_to_block
+  end
+end

data/test/integration/integration_test_helper.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), *%w[.. helper])
+require 'test/unit'
+
+module Kernel
+  VerbotenMethodCallReachedKernel = Class.new(Exception)
+end
+
+class CordonUnitTest < Test::Unit::TestCase
+  def foo
+    @foo ||= Object.new
+  end
+
+  def refute(predicate, *other_args)
+    assert !predicate, *other_args
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: cordon
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+  prerelease: 
+platform: ruby
+authors:
+- Sam Livingston-Gray
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-09 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &2156968780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: *2156968780
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2156967060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2156967060
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &2156964940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *2156964940
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &2156962400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+  type: :development
+  prerelease: false
+  version_requirements: *2156962400
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &2156960720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156960720
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156958500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156958500
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2156956460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156956460
+description: A bit of an experiment, really
+email: geeksam@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.markdown
+files:
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- cordon.gemspec
+- lib/cordon.rb
+- lib/cordon/blacklist.rb
+- lib/cordon/sanitaire.rb
+- lib/cordon/violation.rb
+- lib/cordon/whitelist.rb
+- test/framework_integration/minitest_spec_spec.rb
+- test/framework_integration/rspec_spec.rb
+- test/helper.rb
+- test/integration/backtrace_cleaning_test.rb
+- test/integration/cordon_basic_examples_test.rb
+- test/integration/cordon_customization_test.rb
+- test/integration/cordon_default_behavior_test.rb
+- test/integration/cordon_edge_cases_test.rb
+- test/integration/integration_test_helper.rb
+homepage: http://github.com/geeksam/cordon
+licenses:
+- WTFPL
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2252535489042103113
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: ! 'Cordon Sanitaire: hygienic handling of infectious methods'
+test_files: []