citron 0.1.0

data/.gemspec

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gemspec|
+
+  manifest = Dir.glob('manifest{,.txt)', File::FNM_CASEFOLD).first
+
+  scm = case
+        when File.directory?('.git')
+          :git
+        end
+
+  files = case
+          when manifest
+           File.readlines(manifest).
+             map{ |line| line.srtip }.
+             reject{ |line| line.empty? || line[0,1] == '#' }
+          when scm == :git
+           `git ls-files -z`.split("\0")
+          else
+            Dir.glob('{**/}{.*,*}')  # TODO: be more specific using standard locations ?
+          end.select{ |path| File.file?(path) }
+
+  patterns = {
+    :bin_files  => 'bin/*',
+    :lib_files  => 'lib/{**/}*.rb',
+    :ext_files  => 'ext/{**/}extconf.rb',
+    :doc_files  => '*.{txt,rdoc,md,markdown,tt,textile}',
+    :test_files => '{test/{**/}*_test.rb,spec/{**/}*_spec.rb}'
+  }
+
+  glob_files = lambda { |pattern|
+    Dir.glob(pattern).select { |path|
+      File.file?(path) && files.include?(path)
+    }
+  }
+
+  #files = glob_files[patterns[:files]]
+
+  executables = glob_files[patterns[:bin_files]].map do |path|
+                  File.basename(path)
+                end
+
+  extensions = glob_files[patterns[:ext_files]].map do |path|
+                 File.basename(path)
+               end
+
+  metadata = YAML.load_file('.ruby')
+
+  # build-out the gemspec
+
+  case metadata['revision']
+  when 0
+    gemspec.name        = metadata['name']
+    gemspec.version     = metadata['version']
+    gemspec.summary     = metadata['summary']
+    gemspec.description = metadata['description']
+
+    metadata['authors'].each do |author|
+      gemspec.authors << author['name']
+
+      if author.has_key?('email')
+        if gemspec.email
+          gemspec.email << author['email']
+        else
+          gemspec.email = [author['email']]
+        end
+      end
+    end
+
+    gemspec.licenses = metadata['licenses']
+
+    metadata['requirements'].each do |req|
+      name    = req['name']
+      version = req['version']
+      groups  = req['groups'] || []
+
+      if md = /^(.*?)([+-~])$/.match(version)
+        version = case md[2]
+                    when '+' then ">= #{$1}"
+                    when '-' then "< #{$1}"
+                    when '~' then "~> #{$1}"
+                    else version
+                  end
+      end
+
+      #development = req['development']
+      #if development
+      #  # populate development dependencies
+      #  if gemspec.respond_to?(:add_development_dependency)
+      #    gemspec.add_development_dependency(name,*version)
+      #  else
+      #    gemspec.add_dependency(name,*version)
+      #  end
+      #else
+      #  # populate runtime dependencies  
+      #  if gemspec.respond_to?(:add_runtime_dependency)
+      #    gemspec.add_runtime_dependency(name,*version)
+      #  else
+      #    gemspec.add_dependency(name,*version)
+      #  end
+      #end
+
+      if groups.empty? or groups.include?('runtime')
+        # populate runtime dependencies  
+        if gemspec.respond_to?(:add_runtime_dependency)
+          gemspec.add_runtime_dependency(name,*version)
+        else
+          gemspec.add_dependency(name,*version)
+        end
+      else
+        # populate development dependencies
+        if gemspec.respond_to?(:add_development_dependency)
+          gemspec.add_development_dependency(name,*version)
+        else
+          gemspec.add_dependency(name,*version)
+        end
+      end
+    end
+
+    # convert external dependencies into a requirements
+    if metadata['external_dependencies']
+      ##gemspec.requirements = [] unless metadata['external_dependencies'].empty?
+      metadata['external_dependencies'].each do |req|
+        gemspec.requirements << req.to_s
+      end
+    end
+
+    # determine homepage from resources
+    homepage = metadata['resources'].find{ |key, url| key =~ /^home/ }
+    gemspec.homepage = homepage.last if homepage
+
+    gemspec.require_paths        = metadata['load_path'] || ['lib']
+    gemspec.post_install_message = metadata['install_message']
+
+    # RubyGems specific metadata
+    gemspec.files       = files
+    gemspec.extensions  = extensions
+    gemspec.executables = executables
+
+    if Gem::VERSION < '1.7.'
+      gemspec.default_executable = gemspec.executables.first
+    end
+
+    gemspec.test_files = glob_files[patterns[:test_files]]
+
+    unless gemspec.files.include?('.document')
+      gemspec.extra_rdoc_files = glob_files[patterns[:doc_files]]
+    end
+  end
+end

data/.gitignore

@@ -0,0 +1,6 @@
+.yardoc
+doc
+log
+pkg
+site
+tmp

data/.ruby

@@ -0,0 +1,50 @@
+--- 
+authors: 
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+copyrights: 
+- holder: Thomas Sawyer
+  year: "2011"
+  license: BSD-2-Clause
+replacements: []
+
+conflicts: []
+
+requirements: 
+- name: test
+- name: ae
+- name: detroit
+  groups: 
+  - build
+  development: true
+- name: reap
+  groups: 
+  - build
+  development: true
+- name: qed
+  groups: 
+  - test
+  development: true
+dependencies: []
+
+repositories: 
+- uri: git://github.com/proutils/citron.git
+  scm: git
+  name: upstream
+resources: 
+  home: http://rubyworks.github.com/citron
+  code: http://github.com/rubyworks/citron
+load_path: 
+- lib
+extra: 
+  manifest: MANIFEST
+alternatives: []
+
+revision: 0
+name: citron
+title: Citron
+suite: RubyWorks
+summary: Classic Unit-style Test Framework
+description: Citron is a unit testing framework with a classic test-case/test-unit style.
+version: 0.1.0
+date: "2011-07-29"

data/.yardopts

@@ -0,0 +1,7 @@
+--output-dir site
+--protected
+--readme README.md
+lib
+-
+[A-Z]*.*
+

data/Assembly

@@ -0,0 +1,46 @@
+---
+github:
+  active: true
+
+gem:
+  active: true
+
+dnote:
+  labels: ~
+  output: log/NOTES.rdoc
+
+yard:
+  yardopts: true
+
+qed:
+  files    : ~
+  #exclude : ~
+  #loadpath: ~
+  #requires: ~
+  #live    : false   
+  active   : false
+
+qedoc:
+  files : spec/
+  output: QED.rdoc
+  active: false
+
+vclog:
+  output: log/ChangeLog.rdoc
+  active: false
+
+email:
+  service: Email
+  file   : ~
+  subject: ~
+  mailto : 
+    - ruby-talk@ruby-lang.org
+    - rubyworks-mailinglist@googlegroups.com
+  from   : <%= ENV['EMAIL_ACCOUNT'] %>
+  server : <%= ENV['EMAIL_SERVER'] %>
+  port   : <%= ENV['EMAIL_PORT'] %>
+  account: <%= ENV['EMAIL_ACCOUNT'] %>
+  domain : <%= ENV['EMAIL_DOMAIN'] %>
+  login  : <%= ENV['EMAIL_LOGIN'] %>
+  secure : <%= ENV['EMAIL_SECURE'] %>
+

data/COPYING.rdoc

@@ -0,0 +1,31 @@
+= COPYRIGHT NOTICES
+
+== Citron
+
+Copyright:: (c) 2011 Thomas Sawyer, RubyWorks
+License:: BSD-2-Clause
+Website:: http://rubyworks.github.com/citron
+
+    Copyright 2011 Thomas Sawyer. All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+       1. Redistributions of source code must retain the above copyright notice,
+          this list of conditions and the following disclaimer.
+
+       2. Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+    OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+    EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/LICENSE.txt

@@ -0,0 +1,25 @@
+BSD 2 Clause License
+
+Copyright 2011 Thomas Sawyer. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/MANIFEST

@@ -0,0 +1,12 @@
+#!mast .ruby .yaropts bin lib spec test [A-Z][A-Z]*
+.ruby
+lib/citron/test_advice.rb
+lib/citron/test_case.rb
+lib/citron/test_setup.rb
+lib/citron/test_unit.rb
+lib/citron.rb
+PROFILE
+LICENSE.txt
+README.md
+VERSION
+COPYING.rdoc

data/PROFILE

@@ -0,0 +1,29 @@
+--- 
+name   : citron
+title  : Citron
+suite  : RubyWorks
+summary: Classic Unit-style Test Framework
+authors:
+  - Thomas Sawyer <transfire@gmail.com>
+
+description:
+  Citron is a unit testing framework with a classic
+  test-case/test-unit style.
+
+resources:
+  home: http://rubyworks.github.com/citron
+  code: http://github.com/rubyworks/citron
+
+repositories:
+  upstream: git://github.com/proutils/citron.git
+
+copyrights:
+  - 2011 Thomas Sawyer (BSD-2-Clause)
+
+requirements:
+  - test
+  - ae
+  - detroit  (build)
+  - reap     (build)
+  - qed      (test)
+

data/README.md

@@ -0,0 +1,58 @@
+# Citron
+
+<table>
+<tr><td><b>Author   </b></td><td>Thomas Sawyer</td></tr>
+<tr><td><b>License  </b></td><td>FreeBSD</td></tr>
+<tr><td><b>Copyright</b></td><td>(c) 2011 Thomas Sawyer, Rubyworks</td></tr>
+</table>
+
+## Description
+
+Citron is a classic unit test framework. It defines a simple
+domain language for create classic-style tests.
+
+## Example
+
+Here's a fun example.
+
+``` ruby
+TestCase "Show them how to Beat It" do
+
+  # fail
+  test "show them how to funky" do
+    "funky".assert != "funky"
+  end
+
+  # pass
+  test "show them what's right" do
+    "right".assert == "right"
+  end
+
+  # error
+  test "no one wants to be defeated" do
+    raise SyntaxError
+  end
+
+  # todo
+  test "better do what you can" do
+    raise NotImplementedError
+  end
+
+  # omit
+  test "just beat it" do
+    e = NotImplementedError.new
+    e.set_assertion(true)
+    raise e
+  end
+
+end
+```
+
+## License
+
+Copyright (c) 2011 Thomas Sawyer, Rubyworks
+
+Citron is distributed according to the terms of the FreeBSD license.
+
+See COPYING.rd for details.
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/citron.rb

@@ -0,0 +1,23 @@
+module Citron
+  $TEST_SUITE ||= []
+
+  require 'citron/test_case'
+  require 'citron/test_unit'
+  require 'citron/test_advice'
+  require 'citron/test_setup'
+end
+
+module Test
+  extend self
+
+  # Define a general test case.
+  def Case(label, &block)
+    $TEST_SUITE << Citron::TestCase.new(nil, :label=>label, &block)
+  end
+
+  alias :TestCase  :Case
+  alias :test_case :Case
+  alias :case :Case
+end
+
+extend Test

data/lib/citron/test_advice.rb

@@ -0,0 +1,59 @@
+module Citron
+
+  # Test Advice
+  class TestAdvice
+
+    # The test case to which this advice belongs.
+    #attr :context
+
+    #
+    attr :table
+
+    # New case instance.
+    def initialize
+      @table = Hash.new{ |h,k| h[k] = {} }
+    end
+
+    #
+    def initialize_copy(original)
+      @table = original.table.clone
+    end
+
+    #
+    def [](type)
+      @table[type.to_sym]
+    end
+
+=begin
+    #
+    #def teardown=(procedure)
+    #   @teardown = procedure
+    #end
+
+    # Setup.
+    def setup(scope=nil)
+      if scope
+        scope.instance_eval(&@setup)
+      else
+        @setup
+      end
+    end
+
+    # Teardown.
+    def teardown(scope=nil)
+      if scope
+        scope.instance_eval(&@teardown) if @teardown
+      else
+        @teardown
+      end
+    end
+
+    # Returns the description with newlines removed.
+    def to_s
+      description.gsub(/\n/, ' ')
+    end
+=end
+
+  end
+
+end

data/lib/citron/test_case.rb

@@ -0,0 +1,297 @@
+#require 'citron/pending'
+#require 'citron/test_context'
+require 'citron/test_advice'
+require 'citron/test_setup'
+
+module Citron
+
+  # Test Case encapsulates a collection of
+  # unit tests organized into groups of contexts.
+  #
+  class TestCase
+
+    # The parent context in which this case resides.
+    attr :context
+
+    # Brief description of the test case.
+    attr :label
+
+    # List of tests and sub-cases.
+    attr :tests
+
+    # The setup and teardown advice.
+    attr :setup
+
+    # Advice are labeled procedures, such as before
+    # and after advice.
+    attr :advice
+
+    # Module for evaluating tests.
+    attr :scope
+
+    # A test case +target+ is a class or module.
+    #
+    # @param [TestSuite] context
+    #   The parent case to which this case belongs.
+    #
+    def initialize(context, settings={}, &block)
+      if context
+        @context = context
+        @advice  = context.advice.clone
+      else
+        @context = nil
+        @advice  = TestAdvice.new
+      end
+
+      @label = settings[:label]
+      @setup = settings[:setup]
+      @skip  = settings[:skip]
+
+      @tests   = []
+
+      domain = DSL.new(self, &block)
+      @scope = Module.new
+      @scope.extend domain
+    end
+
+    #
+    def <<(test_object)
+      @tests << test_object
+    end
+
+    # Iterate over each test and subcase.
+    def each(&block)
+      tests.each(&block)
+    end
+
+    # Number of tests plus subcases.
+    def size
+      tests.size
+    end
+
+    # Subclasses of TestCase can override this to describe
+    # the type of test case they define.
+    def type
+      'Case'
+    end
+
+    #
+    def to_s
+      "#{type}: " + @label.to_s
+    end
+
+    #
+    def skip?
+      @skip
+    end
+
+    #
+    def skip=(boolean)
+      @skip = !!boolean
+    end
+
+    # Run test in the context of this case.
+    #
+    # @param [TestProc] test
+    #   The test unit to run.
+    #
+    def run(test, &block)
+      advice[:before].each do |matches, block|
+        if matches.all?{ |match| test.match?(match) }
+          scope.instance_exec(test, &block) #block.call(unit)
+        end
+      end
+
+      block.call
+
+      advice[:after].each do |matches, block|
+        if matches.all?{ |match| test.match?(match) }
+          scope.instance_exec(test, &block) #block.call(unit)
+        end
+      end
+    end
+
+    #
+    #--
+    # TODO: Change so that the scope is the DSL
+    #       and ** includes the DSL of the context ** !!!
+    #++
+    #def scope
+    #  @scope ||= (
+    #    scope = Object.new
+    #    scope.extend(domain)
+    #    scope
+    #  )
+    #end
+
+    #
+    class DSL < Module
+
+      #
+      def initialize(testcase, &code)
+        @_case  = testcase
+        @_setup = testcase.setup
+
+        if testcase.context
+          extend(testcase.context.scope)
+        end
+
+        module_eval(&code)
+      end
+
+      # Create a sub-case.
+      #--
+      # @TODO: Instead of resuing TestCase can we have a TestContext
+      #        that more generically mimics it's context context?
+      #++
+      def Context(label, &block)
+        settings = {
+          :label => label,
+          :setup => @_setup
+        }
+        testcase = TestCase.new(@_case, settings, &block)
+        @_case.tests << testcase
+        testcase
+      end
+      alias_method :context, :Context
+
+      # Create a test.
+      def Test(label=nil, &procedure)
+        settings = {
+          :label => label,
+          :setup => @_setup
+        }
+        testunit = TestUnit.new(@_case, settings, &procedure)
+        if procedure.arity == 0
+          @_case.tests << testunit
+        else
+          @_test = testunit
+        end
+        testunit
+      end
+      alias_method :test, :Test
+
+      #
+      #
+      #
+      def Ok(*args)
+        test = @_test
+        test.arguments = args
+        @_case << test
+        @_test = nil
+        return test
+      end
+
+      #
+      #
+      #
+      def No(*args)
+        test = @_test
+        test.arguments = args
+        test.negate    = true
+        @_case << test
+        @_test = nil
+        return test
+      end
+
+      # Setup is used to set things up for each unit test.
+      # The setup procedure is run before each unit.
+      #
+      # @param [String] description
+      #   A brief description of what the setup procedure sets-up.
+      #
+      def Setup(description=nil, &procedure)
+        if procedure
+          @_setup = TestSetup.new(@_case, description, &procedure)
+        end
+      end
+
+      alias_method :setup, :Setup
+
+      #alias_method :Concern, :Setup
+      #alias_method :concern, :Setup
+
+      #alias_method :Subject, :Setup
+      #alias_method :subject, :Setup
+
+      # Teardown procedure is used to clean-up after each unit test.
+      #
+      def Teardown(&procedure)
+        @_setup.teardown = procedure
+      end
+
+      alias_method :teardown, :Teardown
+
+      # Define a _complex_ before procedure. The #before method allows
+      # before procedures to be defined that are triggered by a match
+      # against the unit's target method name or _aspect_ description.
+      # This allows groups of tests to be defined that share special
+      # setup code.
+      #
+      # @example
+      #   Method :puts do
+      #     Test "standard output (@stdout)" do
+      #       puts "Hello"
+      #     end
+      #
+      #     Before /@stdout/ do
+      #       $stdout = StringIO.new
+      #     end
+      #
+      #     After /@stdout/ do
+      #       $stdout = STDOUT
+      #     end
+      #   end
+      #
+      # @param [Array<Symbol,Regexp>] matches
+      #   List of match critera that must _all_ be matched
+      #   to trigger the before procedure.
+      #
+      def Before(*matches, &procedure)
+        @_case.advice[:before][matches] = procedure
+      end
+
+      alias_method :before, :Before
+
+      # Define a _complex_ after procedure. The #before method allows
+      # before procedures to be defined that are triggered by a match
+      # against the unit's target method name or _aspect_ description.
+      # This allows groups of tests to be defined that share special
+      # teardown code.
+      #
+      # @example
+      #   Method :puts do
+      #     Test "standard output (@stdout)" do
+      #       puts "Hello"
+      #     end
+      #
+      #     Before /@stdout/ do
+      #       $stdout = StringIO.new
+      #     end
+      #
+      #     After /@stdout/ do
+      #       $stdout = STDOUT
+      #     end
+      #   end
+      #
+      # @param [Array<Symbol,Regexp>] matches
+      #   List of match critera that must _all_ be matched
+      #   to trigger the after procedure.
+      #
+      def After(*matches, &procedure)
+        @_case.advice[:after][matches] = procedure
+      end
+
+      alias_method :after, :After
+
+      # Mark a test or testcase to be omitted.
+      #
+      def Omit(test_obect)
+        test_object.omit = true
+      end
+
+    end
+
+  end
+
+end

data/lib/citron/test_setup.rb

@@ -0,0 +1,51 @@
+module Citron
+
+  # Test Setup/Concern - Setup and Teardown code.
+  class TestSetup
+
+    # The test case to which this advice belong.
+    attr :context
+
+    # A brief description of this concern.
+    attr :label
+
+    # The setup procedure.
+    attr :setup
+
+    # The teardown procedure.
+    attr :teardown
+
+    # New case instance.
+    def initialize(context, label, options={}, &setup)
+      @context   = context
+      @label     = label.to_s
+      @setup     = [setup].flatten
+      @teardown  = []
+    end
+
+    #
+    def teardown=(procedure)
+      @teardown = [procedure]
+    end
+
+    # Setup.
+    def run_setup(scope)
+      setup.each do |proc|
+        scope.instance_eval(&proc)
+      end
+    end
+
+    # Teardown.
+    def run_teardown(scope)
+      teardown.each do |proc|
+        scope.instance_eval(&proc)
+      end
+    end
+
+    # Returns the description with newlines removed.
+    def to_s
+      label.gsub(/\n/, ' ')
+    end
+  end
+
+end

data/lib/citron/test_unit.rb

@@ -0,0 +1,123 @@
+module Citron
+
+  #
+  class TestUnit
+
+    # New unit test procedure.
+    #
+    def initialize(context, options={}, &procedure)
+      @context    = context
+
+      @setup     = options[:setup]
+      @label     = options[:label]
+      @skip      = options[:skip]
+
+      @procedure = procedure
+      @tested    = false
+    end
+
+  public
+
+    # The parent testcase to which this test belongs.
+    attr :context
+
+    #
+    alias :parent :context
+
+    # Setup and teardown procedures.
+    attr :setup
+
+    # Description of test.
+    attr :label
+
+    # Test procedure, in which test assertions should be made.
+    attr :procedure
+
+    # The before and after advice from the context.
+    def advice
+      context.advice
+    end
+
+    #
+    def type
+      'Unit'
+    end
+
+    #
+    def skip? ; @skip ; end
+
+    #
+    def skip=(boolean)
+      @skip = !!boolean
+    end
+
+    #
+    def tested?
+      @tested
+    end
+
+    #
+    def tested=(boolean)
+      @tested = boolean
+    end
+
+    #
+    def to_s
+      label.to_s
+    end
+
+    #
+    def setup
+      @setup
+    end
+
+    #
+    alias :subtext :setup
+
+    #
+    def scope
+      context.scope
+    end
+
+    #
+    def arguments
+      @arguments
+    end
+
+    #
+    def arguments=(args)
+      @arguments = args
+    end
+
+    # TODO: how to handle negated tests?
+    def negate
+      @negate
+    end
+
+    #
+    def negate=(boolean)
+      @negate = !!boolean
+    end
+
+    #
+    def to_proc
+      lambda{ call }
+    end
+
+    #
+    def match?(match)
+      match == target || match === description
+    end
+
+    #
+    def call
+      context.run(self) do
+        setup.run_setup(scope)    if setup
+        scope.instance_exec(*arguments, &procedure)
+        setup.run_teardown(scope) if setup
+      end
+    end
+
+  end
+
+end

data/try/case_example.rb

@@ -0,0 +1,30 @@
+TestCase "Show them how to Beat It" do
+
+  # will fail
+  test "show them how to funky" do
+    "funky".assert != "funky"
+  end
+
+  # will pass
+  test "show them what's right" do
+    "right".assert == "right"
+  end
+
+  # will error
+  test "no one wants to be defeated" do
+    raise SyntaxError
+  end
+
+  # pending
+  test "better do what you can" do
+    raise NotImplementedError
+  end
+
+  # omit
+  test "just beat it" do
+    e = NotImplementedError.new
+    e.set_assertion(true)
+    raise e
+  end
+
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: citron
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-29 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ae
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: detroit
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: reap
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: qed
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Citron is a unit testing framework with a classic test-case/test-unit style.
+email: 
+- transfire@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- COPYING.rdoc
+- README.md
+files: 
+- .gemspec
+- .gitignore
+- .ruby
+- .yardopts
+- Assembly
+- COPYING.rdoc
+- LICENSE.txt
+- MANIFEST
+- PROFILE
+- README.md
+- VERSION
+- lib/citron.rb
+- lib/citron/test_advice.rb
+- lib/citron/test_case.rb
+- lib/citron/test_setup.rb
+- lib/citron/test_unit.rb
+- try/case_example.rb
+homepage: http://rubyworks.github.com/citron
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.2
+signing_key: 
+specification_version: 3
+summary: Classic Unit-style Test Framework
+test_files: []
+