pangel-testy 0.5.0

data/README

@@ -0,0 +1,296 @@
+NAME
+  testy.rb
+
+DESCRIPTION
+  a minimalist BDD testing framework for ruby that's mad at the world and
+  plans to kick its ass by ruthlessly removing lines of testing framework
+  code
+
+SYNOPSIS
+  Testy.testing 'your code' do
+    test 'some behaviour' do |t|
+      ultimate = Ultimate.new
+      t.check :name, :expect => 42, :actual => ultimate.answer
+    end
+  end
+
+GIT
+  open http://github.com/ahoward/testy/tree/master
+  git clone git://github.com/ahoward/testy.git
+
+PRINCIPLES AND GOALS
+  . it.should.not.merely.be.a.unit.testing.with.a.clever.dsl
+
+  . testing should not require learning a framework.  ruby is a great
+  framework so testy uses it instead, requiring programmers learn exactly 2
+  new method calls
+
+  . testing loc should not dwarf those of the application
+
+  . testing framework loc should not dwarf those of the application
+
+  . testing frameworks should *never* alter ruby built-ins nor add methods to
+  Object, Kernel, .et al
+
+  . the output of tests should be machine parsable for reporting and ci tools
+  to easily integrate with
+
+  . the output of tests should be beautiful so that humans can read it
+
+  . the shape of the test file should not insult the programmer so that tests
+  can double as sample code
+
+  . the testing framework should never alter exception semantics
+
+  . hi-jacking at_exit sucks ass
+
+  . the exit status of running a test suite should indicate the degree of its
+  failure state (testy returns the percent of failed tests using a non-zero
+  exit status)
+
+  . sample code should easily be able to double as a test suite, including
+  its output
+
+  . testing should improve your code and help your users, not make you want to
+  kill yourself
+
+  . using a format that aligns in terminal is sanity saving when comparing
+  output
+
+  . testing frameworks should provide as few shortcuts for making brittle
+  tightly coupled tests as possible
+
+  . test suites should be able to be created, manipulated, have their output
+  streamed to different ports, and even tested themselves - they should be
+  plain ol objects under the hood
+  
+SAMPLES
+
+  <========< samples/a.rb >========>
+
+  ~ > cat samples/a.rb
+
+    # simple use of testy involves simply writing code, and recording the result
+    # you expect against the actual result
+    #
+    # notice that the output is very pretty and that the exitstatus is 0 when all
+    # tests pass
+    #
+      require 'testy'
+    
+      Testy.testing 'the kick-ass-ed-ness of testy' do
+    
+        test 'the ultimate answer to life' do |result|
+          list = []
+    
+          list << 42
+          result.check :a, :expect => 42, :actual => list.first
+    
+          list << 42.0
+          result.check :b, 42.0, list.last
+        end
+    
+      end
+
+  ~ > ruby samples/a.rb #=> exitstatus=0
+
+    --- 
+    the kick-ass-ed-ness of testy: 
+      the ultimate answer to life: 
+        success: 
+          a: 42
+          b: 42.0
+
+
+  <========< samples/b.rb >========>
+
+  ~ > cat samples/b.rb
+
+    # testy will handle unexpected results and exceptions thrown in your code in
+    # exactly the same way - by reporting on them in a beautiful fashion and
+    # continuing to run other tests.  notice, however, that an unexpected result
+    # or raised exception will cause a non-zero exitstatus (the percent of tests
+    # that failed) for the suite as a whole.  also note that previously
+    # accumulated expect/actual pairs are still reported on in the error report.
+    #
+      require 'testy'
+    
+      Testy.testing 'the exception handling of testy' do
+    
+        test 'raising an exception' do |result|
+          list = []
+    
+          list << 42
+          result.check :a, :expect => 42, :actual => list.first
+    
+          list.method_that_does_not_exist
+        end
+    
+        test 'returning unexpected results' do |result|
+          result.check 'a', 42, 42
+          result.check :b, :expect => 'forty-two', :actual => 42.0
+        end
+    
+      end
+
+  ~ > ruby samples/b.rb #=> exitstatus=100
+
+    --- 
+    the exception handling of testy: 
+      raising an exception: 
+        failure: 
+          error: 
+            class: NoMethodError
+            message: undefined method `method_that_does_not_exist' for [42]:Array
+            backtrace: 
+            - samples/b.rb:18:in `call'
+            - ./lib/testy.rb:130
+            - ./lib/testy.rb:113:in `instance_eval'
+            - ./lib/testy.rb:113
+            - /home/adri/.rvm/gems/ruby-1.8.7-p249/gems/orderedhash-0.0.6/lib/orderedhash.rb:65:in `each'
+            - /home/adri/.rvm/gems/ruby-1.8.7-p249/gems/orderedhash-0.0.6/lib/orderedhash.rb:65:in `each'
+            - ./lib/testy.rb:108
+            - ./lib/testy.rb:78:in `call'
+            - ./lib/testy.rb:78:in `context'
+            - ./lib/testy.rb:102:in `run'
+            - ./lib/testy.rb:167:in `testing'
+            - samples/b.rb:10
+          expect: 
+            a: 42
+          actual: 
+            a: 42
+      returning unexpected results: 
+        failure: 
+          expect: 
+            a: 42
+            b: forty-two
+          actual: 
+            a: 42
+            b: 42.0
+
+
+  <========< samples/c.rb >========>
+
+  ~ > cat samples/c.rb
+
+    # in some cases you may not even want to make test assertions and simply
+    # provide example code which should run without error, with testy it's not
+    # only easy to do this but the commanline supports --list to see which samples
+    # can be run and running a single or multiple tests based on name or pattern.
+    # notice that, when no assertions are made using 'result.check' the output of
+    # the test becomes the expected *and* actual and is therefore shown in the
+    # output as yaml.  of course, if your samples have errors they are reported in
+    # the normal fashion and the tests will fail.
+    #
+    #
+      require 'testy'
+    
+      Testy.testing 'some samplz for you' do
+        test 'foo sample' do
+          list = 1,2
+          list.last + list.first
+        end
+    
+        test 'bar sample' do
+          list = 1,2
+          list.shift * list.pop
+        end
+    
+        test 'foobar sample' do
+          list = 1,2
+          eval(list.reverse.join) * 2
+        end
+      end
+    
+    # here are some examples of using the command line arguments on the above test
+    #
+    # cfp:~/src/git/testy > ruby samples/c.rb --list
+    # --- 
+    # - foo sample
+    # - bar sample
+    # - foobar sample
+    #
+    # cfp:~/src/git/testy > ruby samples/c.rb foobar
+    # --- 
+    # some samplz for you: 
+    #   foobar sample: 
+    #     success: 42
+    #
+    # cfp:~/src/git/testy > ruby samples/c.rb foo
+    # --- 
+    # some samplz for you: 
+    #   foo sample: 
+    #     success: 3
+    #   foobar sample: 
+    #     success: 42
+    #
+    # cfp:~/src/git/testy > ruby samples/c.rb bar
+    # --- 
+    # some samplz for you: 
+    #   bar sample: 
+    #     success: 2
+
+  ~ > ruby samples/c.rb #=> exitstatus=0
+
+    --- 
+    some samplz for you: 
+      foo sample: 
+        success: 3
+      bar sample: 
+        success: 2
+      foobar sample: 
+        success: 42
+
+
+  <========< samples/d.rb >========>
+
+  ~ > cat samples/d.rb
+
+    # of course testy includes smartly inherited contexts and context sensitive
+    # setup and teardown methods which stack as well.
+    #
+      require 'testy'
+    
+      Testy.testing 'your bitchin lib' do
+        context 'A' do
+          setup{ @list = [40] }
+    
+          test 'foo' do
+            @list << 2
+            @list.first + @list.last
+          end
+    
+          test 'bar' do |t|
+            t.check :list, @list, [40]
+          end
+    
+          context 'B' do
+            setup{ @list << 2 }
+            test(:bar){ @list.join.delete('0') }
+          end
+        end
+      end
+    
+    
+    # the context name is applied to the test name, so you can selectively run
+    # groups of tests from the command line
+    #
+    # cfp:~/src/git/testy > ruby -I lib samples/d.rb 'A - B'
+    # --- 
+    # your bitchin lib: 
+    #   A - B - bar: 
+    #       success: "42"
+
+  ~ > ruby samples/d.rb #=> exitstatus=0
+
+    --- 
+    your bitchin lib: 
+      A - foo: 
+        success: 42
+      A - bar: 
+        success: 
+          list: 
+          - 40
+      A - B - bar: 
+        success: "42"
+

data/README.tmpl

@@ -0,0 +1,68 @@
+NAME
+  testy.rb
+
+DESCRIPTION
+  a minimalist BDD testing framework for ruby that's mad at the world and
+  plans to kick its ass by ruthlessly removing lines of testing framework
+  code
+
+SYNOPSIS
+  Testy.testing 'your code' do
+    test 'some behaviour' do |t|
+      ultimate = Ultimate.new
+      t.check :name, :expect => 42, :actual => ultimate.answer
+    end
+  end
+
+GIT
+  open http://github.com/ahoward/testy/tree/master
+  git clone git://github.com/ahoward/testy.git
+
+PRINCIPLES AND GOALS
+  . it.should.not.merely.be.a.unit.testing.with.a.clever.dsl
+
+  . testing should not require learning a framework.  ruby is a great
+  framework so testy uses it instead, requiring programmers learn exactly 2
+  new method calls
+
+  . testing loc should not dwarf those of the application
+
+  . testing framework loc should not dwarf those of the application
+
+  . testing frameworks should *never* alter ruby built-ins nor add methods to
+  Object, Kernel, .et al
+
+  . the output of tests should be machine parsable for reporting and ci tools
+  to easily integrate with
+
+  . the output of tests should be beautiful so that humans can read it
+
+  . the shape of the test file should not insult the programmer so that tests
+  can double as sample code
+
+  . the testing framework should never alter exception semantics
+
+  . hi-jacking at_exit sucks ass
+
+  . the exit status of running a test suite should indicate the degree of its
+  failure state (testy returns the percent of failed tests using a non-zero
+  exit status)
+
+  . sample code should easily be able to double as a test suite, including
+  its output
+
+  . testing should improve your code and help your users, not make you want to
+  kill yourself
+
+  . using a format that aligns in terminal is sanity saving when comparing
+  output
+
+  . testing frameworks should provide as few shortcuts for making brittle
+  tightly coupled tests as possible
+
+  . test suites should be able to be created, manipulated, have their output
+  streamed to different ports, and even tested themselves - they should be
+  plain ol objects under the hood
+  
+SAMPLES
+  @samples

data/Rakefile

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "pangel-testy"
+    gem.version = "0.5.0"
+    gem.platform = Gem::Platform::RUBY
+    gem.summary = %Q{testy}
+    gem.description = %Q{a minimalist BDD testing framework for ruby that's mad at the world and plans to kick its ass by ruthlessly removing lines of testing framework code.}
+
+    gem.has_rdoc = true
+    gem.add_dependency 'orderedhash'
+
+    gem.email = "ara.t.howard@gmail.com"
+    gem.homepage = "http://github.com/pangel/testy"
+    gem.authors = ["Ara T. Howard"]
+
+    # gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "mygem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO

@@ -0,0 +1,4 @@
+. holy crap i need to re-factor before the code gets any fuglier!
+
+. make sure contexts stack
+. make sure contexts start out clean

data/gen_readme.rb

@@ -0,0 +1,43 @@
+#! /usr/bin/env ruby
+
+require 'pathname'
+
+$VERBOSE=nil
+
+def indent s, n = 2
+  ws = ' ' * n
+  s.gsub %r/^/, ws 
+end
+
+template = IO::read 'README.tmpl'
+
+samples = ''
+prompt = '~ > '
+
+Dir['sample*/*'].sort.each do |sample|
+  samples << "\n" << "  <========< #{ sample } >========>" << "\n\n"
+
+  cmd = "cat #{ sample }" 
+  samples << indent(prompt + cmd, 2) << "\n\n" 
+  samples << indent(`#{ cmd }`, 4) << "\n" 
+
+  cmd = "ruby #{ sample }" 
+  #samples << indent(prompt + cmd, 2) << "\n\n" 
+
+  cmd = "ruby -e'STDOUT.sync=true; exec %(ruby -Ilib #{ sample })'" 
+  out = `#{ cmd } 2>&1`
+  #samples << indent(`#{ cmd } 2>&1`, 4) << "\n" 
+
+  exitstatus = " #=> exitstatus=#{ $?.exitstatus }"
+  cmd = "ruby #{ sample }" 
+  samples << indent(prompt + cmd + exitstatus, 2) << "\n\n" 
+  samples << indent(out, 4) << "\n" 
+
+  #samples << indent("\n#{ prompt } #{ $?.exitstatus } ### exitstatus\n")
+end
+
+#samples.gsub! %r/^/, '  '
+
+readme  = template.gsub %r/^\s*@samples\s*$/, samples
+open('README', 'w'){|fd| fd.write readme}
+print readme 

data/lib/testy.rb

@@ -0,0 +1,173 @@
+require 'rubygems'
+require 'orderedhash'
+require 'yaml'
+
+module Testy
+  def Testy.version() '0.5.0' end
+
+  class Test
+    class BadResult < StandardError
+    end
+
+    class OrderedHash < ::OrderedHash
+      def with_string_keys
+        oh = self.class.new
+        each_pair{|key, val| oh[key.to_s] = val}
+        oh
+      end
+    end
+
+    class Result
+      attr_accessor :expect
+      attr_accessor :actual
+
+      def initialize
+        @expect = OrderedHash.new
+        @actual = OrderedHash.new
+      end
+
+      def check(name, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        value = args.size==0 ? (options[:expect]||options['expect']) : args.shift
+        expect[name.to_s] = value
+        value = args.size==0 ? (options[:actual]||options['actual']) : args.shift
+        actual[name.to_s] = value
+      end
+
+      def ok?
+        expect === actual
+      end
+
+      def empty?
+        expect.empty? and actual.empty?
+      end
+    end
+
+    attr_accessor :name
+    attr_accessor :tests
+    attr_accessor :block
+    attr_accessor :contexts
+
+    def initialize(*args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      @name = args.first || options[:name] || options['name']
+      @tests = OrderedHash.new
+      @contexts = OrderedHash.new
+      @block = block
+    end
+
+    def test(name, &block)
+      name = [contexts.values.map{|context| context.name}, name].flatten.compact.join(' - ')
+      @tests[name] = [context, block]
+    end
+
+    def size
+      @tests.size
+    end
+
+    class Context
+      [:name, :block, :setup, :teardown].each{|name| attr_accessor name}
+      def initialize(name = nil, setup = lambda{}, teardown = lambda{}, &block)
+        @name, @setup, @teardown, @block = name, setup, teardown, block
+      end
+    end
+
+    def context(name = nil, &block)
+      if block
+        @contexts[name] = Context.new(name, &block)
+        block.call
+      else
+        @contexts.values.last
+      end
+    end
+
+    def setup(&block)
+      context.setup = block
+    end
+
+    def teardown(&block)
+      context.teardown = block
+    end
+
+    def list
+      instance_eval(&@block) if @block
+      tests.map{|kv| kv.first.to_s}
+    end
+
+    def run(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      port = options[:port]||options['port']||STDOUT
+      selectors = options[:selectors]||options['selectors']||[]
+
+      context do
+        instance_eval(&@block) if @block
+
+        report = OrderedHash.new
+        failures = 0
+
+        tests.each do |name, context_and_block|
+          next unless selectors.any?{|selector| selector===name} unless selectors.empty?
+
+          result = Result.new
+
+          dup.instance_eval do
+            context, block = context_and_block
+
+            contexts = []
+            tests.each do |n, cb|
+              c, b = cb
+              break if context==c
+              contexts << c
+            end
+            contexts << context
+
+            report[name] =
+              begin
+                value =
+                  begin
+                    contexts.each{|context| instance_eval(&context.setup)}
+                    (class << self;self;end).module_eval{ define_method(:call, &block) }
+                    call(result)
+                  ensure
+                    contexts.reverse.each{|context| instance_eval(&context.teardown)}
+                  end
+                raise BadResult, name unless result.ok?
+                value = result.actual.with_string_keys unless result.empty?
+                begin; value.to_yaml; rescue; value=true; end
+                {'success' => value}
+              rescue Object => e
+                failures += 1
+                failure = OrderedHash.new
+                unless e.is_a?(BadResult)
+                  error = OrderedHash.new
+                  error['class'] = e.class.name
+                  error['message'] = e.message.to_s
+                  error['backtrace'] = e.backtrace||[]
+                  failure['error'] = error
+                end
+                failure['expect'] = result.expect.with_string_keys
+                failure['actual'] = result.actual.with_string_keys
+                {'failure' => failure}
+              end
+          end
+        end
+        port << {name => report}.to_yaml
+        failures
+      end
+    end
+  end
+    
+  def Testy.testing(*args, &block)
+    list = ARGV.delete('--list')||ARGV.delete('-l')
+    selectors = ARGV.map{|arg| eval(arg =~ %r|^/.*| ? arg : "/^#{ Regexp.escape(arg) }/")}
+    test = Test.new(*args, &block)
+    if list
+      y test.list
+    else
+      failures = test.run(:selectors => selectors)
+      size = test.size
+      pct_failed = size==0 || failures==0 ? 0 : [ ((failures/size.to_f)*100).to_i, 1 ].max
+      exit(pct_failed)
+    end
+  end
+end

data/pangel-testy.gemspec

@@ -0,0 +1,52 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{pangel-testy}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ara T. Howard"]
+  s.date = %q{2010-03-17}
+  s.description = %q{a minimalist BDD testing framework for ruby that's mad at the world and plans to kick its ass by ruthlessly removing lines of testing framework code.}
+  s.email = %q{ara.t.howard@gmail.com}
+  s.extra_rdoc_files = [
+    "README",
+     "README.tmpl",
+     "TODO"
+  ]
+  s.files = [
+    "README",
+     "README.tmpl",
+     "Rakefile",
+     "TODO",
+     "gen_readme.rb",
+     "lib/testy.rb",
+     "pangel-testy.gemspec",
+     "samples/a.rb",
+     "samples/b.rb",
+     "samples/c.rb",
+     "samples/d.rb"
+  ]
+  s.homepage = %q{http://github.com/pangel/testy}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{testy}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<orderedhash>, [">= 0"])
+    else
+      s.add_dependency(%q<orderedhash>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<orderedhash>, [">= 0"])
+  end
+end
+

data/samples/a.rb

@@ -0,0 +1,21 @@
+# simple use of testy involves simply writing code, and recording the result
+# you expect against the actual result
+#
+# notice that the output is very pretty and that the exitstatus is 0 when all
+# tests pass
+#
+  require 'testy'
+
+  Testy.testing 'the kick-ass-ed-ness of testy' do
+
+    test 'the ultimate answer to life' do |result|
+      list = []
+
+      list << 42
+      result.check :a, :expect => 42, :actual => list.first
+
+      list << 42.0
+      result.check :b, 42.0, list.last
+    end
+
+  end

data/samples/b.rb

@@ -0,0 +1,26 @@
+# testy will handle unexpected results and exceptions thrown in your code in
+# exactly the same way - by reporting on them in a beautiful fashion and
+# continuing to run other tests.  notice, however, that an unexpected result
+# or raised exception will cause a non-zero exitstatus (the percent of tests
+# that failed) for the suite as a whole.  also note that previously
+# accumulated expect/actual pairs are still reported on in the error report.
+#
+  require 'testy'
+
+  Testy.testing 'the exception handling of testy' do
+
+    test 'raising an exception' do |result|
+      list = []
+
+      list << 42
+      result.check :a, :expect => 42, :actual => list.first
+
+      list.method_that_does_not_exist
+    end
+
+    test 'returning unexpected results' do |result|
+      result.check 'a', 42, 42
+      result.check :b, :expect => 'forty-two', :actual => 42.0
+    end
+
+  end

data/samples/c.rb

@@ -0,0 +1,56 @@
+# in some cases you may not even want to make test assertions and simply
+# provide example code which should run without error, with testy it's not
+# only easy to do this but the commanline supports --list to see which samples
+# can be run and running a single or multiple tests based on name or pattern.
+# notice that, when no assertions are made using 'result.check' the output of
+# the test becomes the expected *and* actual and is therefore shown in the
+# output as yaml.  of course, if your samples have errors they are reported in
+# the normal fashion and the tests will fail.
+#
+#
+  require 'testy'
+
+  Testy.testing 'some samplz for you' do
+    test 'foo sample' do
+      list = 1,2
+      list.last + list.first
+    end
+
+    test 'bar sample' do
+      list = 1,2
+      list.shift * list.pop
+    end
+
+    test 'foobar sample' do
+      list = 1,2
+      eval(list.reverse.join) * 2
+    end
+  end
+
+# here are some examples of using the command line arguments on the above test
+#
+# cfp:~/src/git/testy > ruby samples/c.rb --list
+# --- 
+# - foo sample
+# - bar sample
+# - foobar sample
+#
+# cfp:~/src/git/testy > ruby samples/c.rb foobar
+# --- 
+# some samplz for you: 
+#   foobar sample: 
+#     success: 42
+#
+# cfp:~/src/git/testy > ruby samples/c.rb foo
+# --- 
+# some samplz for you: 
+#   foo sample: 
+#     success: 3
+#   foobar sample: 
+#     success: 42
+#
+# cfp:~/src/git/testy > ruby samples/c.rb bar
+# --- 
+# some samplz for you: 
+#   bar sample: 
+#     success: 2

data/samples/d.rb

@@ -0,0 +1,34 @@
+# of course testy includes smartly inherited contexts and context sensitive
+# setup and teardown methods which stack as well.
+#
+  require 'testy'
+
+  Testy.testing 'your bitchin lib' do
+    context 'A' do
+      setup{ @list = [40] }
+
+      test 'foo' do
+        @list << 2
+        @list.first + @list.last
+      end
+
+      test 'bar' do |t|
+        t.check :list, @list, [40]
+      end
+
+      context 'B' do
+        setup{ @list << 2 }
+        test(:bar){ @list.join.delete('0') }
+      end
+    end
+  end
+
+
+# the context name is applied to the test name, so you can selectively run
+# groups of tests from the command line
+#
+# cfp:~/src/git/testy > ruby -I lib samples/d.rb 'A - B'
+# --- 
+# your bitchin lib: 
+#   A - B - bar: 
+#       success: "42"

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: pangel-testy
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Ara T. Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-17 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: orderedhash
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: a minimalist BDD testing framework for ruby that's mad at the world and plans to kick its ass by ruthlessly removing lines of testing framework code.
+email: ara.t.howard@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- README.tmpl
+- TODO
+files: 
+- README
+- README.tmpl
+- Rakefile
+- TODO
+- gen_readme.rb
+- lib/testy.rb
+- pangel-testy.gemspec
+- samples/a.rb
+- samples/b.rb
+- samples/c.rb
+- samples/d.rb
+has_rdoc: true
+homepage: http://github.com/pangel/testy
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: testy
+test_files: []
+