lemon 0.5 → 0.6

data/MANIFEST

@@ -1,12 +1,18 @@
 COPYING
 COPYING.LESSER
 HISTORY
+MANIFEST
 README.rdoc
 bin/lemon
 lib/lemon
 lib/lemon.rb
 lib/lemon/command.rb
+lib/lemon/commands
+lib/lemon/commands/coverage.rb
+lib/lemon/commands/generate.rb
+lib/lemon/commands/test.rb
 lib/lemon/coverage.rb
+lib/lemon/dsl.rb
 lib/lemon/kernel.rb
 lib/lemon/reporter.rb
 lib/lemon/reporters

data/lib/lemon/command.rb

@@ -1,125 +1,45 @@
-#!/usr/bin/env ruby
-
-require 'lemon'
-require 'lemon/coverage'
 require 'optparse'
-require 'yaml'
+
+#require 'lemon'
+#require 'yaml'
 
 module Lemon
 
-  # Lemon Command-line tool.
+  # Lemon Command-line tool base class.
   class Command
 
-    # Initialize and run.
-    def self.run
-      new.run
-    end
-
-    attr_accessor :command
-    attr_accessor :format
-    attr_accessor :requires
-    attr_accessor :includes
-    attr_accessor :public_only
-
-    # New Command instance.
-    def initialize
-      @format   = nil
-      @requires = []
-      @includes = []
-      @public_only = false
-    end
-
-    # Instance of OptionParser.
-    def parser
-      @parser ||= OptionParser.new do |opt|
-        opt.on('--verbose', '-v', "select verbose report format") do |type|
-          self.format = :verbose
-        end
-        #opt.on('--format', '-f [TYPE]', "select alternate report format") do |type|
-        #  self.format = type
-        #end
-        opt.on('--coverage', '-c', 'produce a coverage report') do
-          self.command = :coverage
-        end
-        opt.on('--generate', '-g', 'generate test skeletons') do
-          self.command = :generate
-        end
-        opt.on('--public', '-p', "only include public methods (for -c and -g)") do
-          self.public_only = true
-        end
-        opt.on("-I [PATH]" , 'include in $LOAD_PATH') do |path|
-          self.includes = path
-        end
-        opt.on("-r [FILES]" , 'library files to require') do |files|
-          self.requires = files
-        end
-        opt.on("--debug" , 'turn on debugging mode') do
-          $DEBUG = true
-        end
-        opt.on_tail('--help', '-h', 'show this help message') do
-          puts opt
-          exit
-        end
-      end
+    # Used to map command-line options to command classes.
+    # This must be overridden in subclasses, and return an
+    # array of of options, e.g. [ '-g', '--generate'].
+    def self.options
+      raise "not implemented"
     end
 
-    #
-    def public_only?
-      @public_only
+    # Stores a list of command classes.
+    def self.commands
+      @commands ||= []
     end
 
-    #
-    def requires=(paths)
-      @requires = paths.split(/[:;]/)
+    # When this class is inherited, it is registered to the commands list.
+    def self.inherited(command_class)
+      commands << command_class
     end
 
-    #
-    def includes=(paths)
-      @includes = paths.split(/[:;]/)
-    end
-
-    #
-    def run
-      parser.parse!
-
-      includes.each do |path|
-        $LOAD_PATHS.unshift(path)
-      end
-
-      tests = ARGV
-
-      case command
-      when :coverage
-        coverage(tests)
-      when :generate
-        generate(tests)
-      else
-        test(tests)
+    # Factory method to initialize and run choosen sub-command.
+    def self.run
+      cmd = commands.find do |command_class|
+        [command_class.options].flatten.find do |opt|
+          ARGV.delete(opt)
+        end
       end
-    end
-
-    # Check test coverage.
-    def coverage(tests)
-      cover  = Lemon::Coverage.new(requires, :public => public_only?)
-      suite  = Lemon::Test::Suite.new(tests)
-      puts cover.coverage(suite).to_yaml
-    end
-
-    # Generate test skeletons.
-    def generate(tests)
-      cover  = Lemon::Coverage.new(requires, :public => public_only?)
-      #suite  = Lemon::Test::Suite.new(tests)
-      puts cover.generate #(suite).to_yaml
-    end
-
-    # Run unit tests.
-    def test(tests)
-      requires.each{ |path| require(path) }
-      suite  = Lemon::Test::Suite.new(tests)
-      runner = Lemon::Runner.new(suite, format)
-      runner.run
+      cmd ? cmd.run : Commands::Test.run
     end
 
   end
 
 end
+
+require 'lemon/commands/test'
+require 'lemon/commands/coverage'
+require 'lemon/commands/generate'
+

data/lib/lemon/commands/coverage.rb

@@ -0,0 +1,103 @@
+module Lemon
+module Commands
+
+  # Lemon Coverage Command-line tool.
+  class Coverage < Command
+    require 'yaml'
+    require 'lemon/coverage'
+
+    def self.options
+      ['-c', '--coverage']
+    end
+
+    # Initialize and run.
+    def self.run
+      new.run
+    end
+
+    # New Command instance.
+    def initialize
+      @requires    = []
+      @includes    = []
+      @namespaces  = []
+      @public_only = false
+    end
+
+    #
+    attr_accessor :public_only
+
+    #
+    def public_only?
+      @public_only
+    end
+
+    # Get or set librarires to pre-require.
+    def requires(*paths)
+      @requires.concat(paths) unless paths.empty?
+      @requires
+    end
+
+    # Get or set paths to include in $LOAD_PATH.
+    def includes(*paths)
+      @includes.concat(paths) unless paths.empty?
+      @includes
+    end
+
+    # Get or set paths to include in $LOAD_PATH.
+    def namespaces(*names)
+      @namespaces.concat(names) unless names.empty?
+      @namespaces
+    end
+
+    # Instance of OptionParser.
+    def parser
+      @parser ||= OptionParser.new do |opt|
+        opt.banner = "lemon -c [OPTIONS]"
+        opt.separator("Produce test coverage reports.")
+        opt.on('--namespace', '-n [NAME]', "include namespace") do |name|
+          namespaces(name)
+        end
+        opt.on('--public', '-p', "only include public methods") do
+          self.public_only = true
+        end
+        opt.on("-r [FILES]" , 'library files to require') do |files|
+          files = files.split(/[:;]/)
+          requires(*files)
+        end
+        opt.on("-I [PATH]" , 'include in $LOAD_PATH') do |path|
+          path = path.split(/[:;]/)
+          includes(*path)
+        end
+        opt.on("--debug" , 'turn on debugging mode') do
+          $DEBUG = true
+        end
+        opt.on_tail('--help', '-h', 'show this help message') do
+          puts opt
+          exit
+        end
+      end
+    end
+
+    #
+    def run
+      parser.parse!
+
+      test_files = ARGV.dup
+      load_files = []
+
+      includes.each do |path|
+        $LOAD_PATHS.unshift(path)
+      end
+
+      requires.each{ |path| require(path) }
+
+      cover  = Lemon::Coverage.new(load_files, namespaces, :public => public_only?)
+      suite  = Lemon::Test::Suite.new(test_files)
+      puts cover.coverage(suite).to_yaml
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/commands/generate.rb

@@ -0,0 +1,108 @@
+module Lemon
+module Commands
+
+  # Lemon Generate Command-line tool.
+  class Generate < Command
+    require 'lemon/coverage'
+
+    #
+    def self.options
+      ['-g', '--generate']
+    end
+
+    # Initialize and run.
+    def self.run
+      new.run
+    end
+
+    # New Command instance.
+    def initialize
+      @requires    = []
+      @includes    = []
+      @namespaces  = []
+      @public_only = false
+    end
+
+    #
+    attr_accessor :output
+
+    #
+    attr_accessor :public_only
+
+    #
+    def public_only?
+      @public_only
+    end
+
+    # Get or set librarires to pre-require.
+    def requires(*paths)
+      @requires.concat(paths) unless paths.empty?
+      @requires
+    end
+
+    # Get or set paths to include in $LOAD_PATH.
+    def includes(*paths)
+      @includes.concat(paths) unless paths.empty?
+      @includes
+    end
+
+    # Get or set paths to include in $LOAD_PATH.
+    def namespaces(*names)
+      @namespaces.concat(names) unless names.empty?
+      @namespaces
+    end
+
+    # Instance of OptionParser.
+    def parser
+      @parser ||= OptionParser.new do |opt|
+        opt.banner = "lemon -g [OPTIONS]"
+        opt.separator("Generate test scaffolding.")
+        opt.on("--namespace", "-n [NAME]", "include namespace") do |name|
+          namespaces(name)
+        end
+        opt.on("--public", "-p", "only include public methods") do
+          self.public_only = true
+        end
+        opt.on("--output", "-o [PATH]", "output directory") do |path|
+          self.output = path
+        end
+        opt.on("-r [FILES]" , "library files to require") do |files|
+          files = files.split(/[:;]/)
+          requires(*files)
+        end
+        opt.on("-I [PATH]" , "include in $LOAD_PATH") do |path|
+          path = path.split(/[:;]/)
+          includes(*path)
+        end
+        opt.on("--debug" , "turn on debugging mode") do
+          $DEBUG = true
+        end
+        opt.on_tail("--help", "-h", "show this help message") do
+          puts opt
+          exit
+        end
+      end
+    end
+
+    # Generate test skeletons.
+    def run
+      parser.parse!
+
+      test_files = ARGV.dup
+
+      includes.each do |path|
+        $LOAD_PATHS.unshift(path)
+      end
+
+      requires.each{ |path| require(path) }
+
+      cover  = Lemon::Coverage.new([], namespaces, :public=>public_only?)
+      suite  = Lemon::Test::Suite.new(*test_files)
+      puts cover.generate(output) #(suite).to_yaml
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/commands/test.rb

@@ -0,0 +1,88 @@
+module Lemon
+module Commands
+
+  # Lemon Test Command-line tool.
+  class Test < Command
+    require 'lemon/runner'
+
+    def self.options
+      []
+    end
+
+    # Initialize and run.
+    def self.run
+      new.run
+    end
+
+    # New Command instance.
+    def initialize
+      @format      = nil
+      @requires    = []
+      @includes    = []
+    end
+
+    #
+    attr_accessor :format
+
+    # Get or set librarires to pre-require.
+    def requires(*paths)
+      @requires.concat(paths) unless paths.empty?
+      @requires
+    end
+
+    # Get or set paths to include in $LOAD_PATH.
+    def includes(*paths)
+      @includes.concat(paths) unless paths.empty?
+      @includes
+    end
+
+    # Instance of OptionParser.
+    def parser
+      @parser ||= OptionParser.new do |opt|
+        opt.separator("Run unit tests.")
+        opt.on('--verbose', '-v', "select verbose report format") do |type|
+          self.format = :verbose
+        end
+        #opt.on('--format', '-f [TYPE]', "select alternate report format") do |type|
+        #  self.format = type
+        #end
+        opt.on("-r [FILES]" , 'library files to require') do |files|
+          files = files.split(/[:;]/)
+          requires(*files)
+        end
+        opt.on("-I [PATH]" , 'include in $LOAD_PATH') do |path|
+          paths = path.split(/[:;]/)
+          includes(*paths)
+        end
+        opt.on("--debug" , 'turn on debugging mode') do
+          $DEBUG = true
+        end
+        opt.on_tail('--help', '-h', 'show this help message') do
+          puts opt
+          exit
+        end
+      end
+    end
+
+    # Run unit tests.
+    def run
+      parser.parse!
+
+      files = ARGV.dup
+
+      includes.each do |path|
+        $LOAD_PATHS.unshift(path)
+      end
+
+      requires.each{ |path| require(path) }
+
+      suite  = Lemon::Test::Suite.new(*files)
+      runner = Lemon::Runner.new(suite, format)
+      runner.run
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/coverage.rb

@@ -3,23 +3,31 @@ module Lemon
   #
   class Coverage
 
-    # Paths of ruby scripts to be covered.
-    attr :paths
+    # Paths of lemon tests and/or ruby scripts to be compared and covered.
+    # This can include directories too, in which case all .rb scripts below
+    # then directory will be included.
+    attr :files
 
     # Conical snapshot of system (before loading libraries to be covered).
     attr :conical
 
+    #
+    attr :namespaces
+
     # New Coverage object.
     #
-    #   Coverage.new('lib/', :public => true)
+    #   Coverage.new('lib/', :MyApp, :public => true)
     #
-    def initialize(paths, options={})
-      @public = options[:public]
+    def initialize(files, namespaces=nil, options={})
+      @namespaces = namespaces || []
 
-      @paths   = paths
+      @files   = files
       @conical = snapshot
 
-      load_system
+      @public  = options[:public]
+
+      # this must come after concial snapshot
+      @suite   = Test::Suite.new(files)
     end
 
     # Over use public methods for coverage.
@@ -60,22 +68,31 @@ module Lemon
     end
 
     # Iterate over +paths+ and use #load to bring in all +.rb+ scripts.
-    def load_system
-      files = []
-      paths.map do |path|
-        if File.directory?(path)
-          files.concat(Dir[File.join(path, '**', '*.rb')])
-        else
-          files.concat(Dir[path])
-        end
-      end
-      files.each{ |file| load(file) }
-    end
+    #def load_system
+    #  files = []
+    #  paths.map do |path|
+    #    if File.directory?(path)
+    #      files.concat(Dir[File.join(path, '**', '*.rb')])
+    #    else
+    #      files.concat(Dir[path])
+    #    end
+    #  end
+    #  files.each{ |file| load(file) }
+    #end
 
     # System to be covered. This takes a sanpshot of the system
-    # and then removes the conical snapshot.
+    # and then removes the conical snapshot, and then filters out
+    # the namespace.
+    #
+    # TODO: Perhaps get rid of the conical subtraction and require a namespace?
     def system
-      snapshot - conical
+      if namespaces.empty?
+        snapshot - conical
+      else
+        snapshot.select do |m|
+          namespaces.any?{ |n| m.name.start_with?(n) }
+        end
+      end
     end
 
     # Produces a list of all existent Modules and Classes.
@@ -90,21 +107,23 @@ module Lemon
       sys
     end
 
-    # TODO: option to do only do what hasn't been covered thus far
-    def generate(opts={})
+    # TODO: combine with coverage to provided option to do only do what hasn't been covered thus far.
+    # TODO: support output directory
+
+    def generate(output=nil)
       code = []
       system.each do |base|
         next if base.is_a?(Lemon::Test::Suite)
-        code << "testcase #{base}"
+        code << "TestCase #{base} do"
         base.public_instance_methods(false).each do |meth|
-          code << "\n  unit :#{meth} => '' do\n    pending\n  end"
+          code << "\n  Unit :#{meth} => '' do\n    pending\n  end"
         end
         unless public_only?
           base.private_instance_methods(false).each do |meth|
-            code << "\n  unit :#{meth} => '' do\n    pending\n  end"
+            code << "\n  Unit :#{meth} => '' do\n    pending\n  end"
           end
           base.protected_instance_methods(false).each do |meth|
-            code << "\n  unit :#{meth} => '' do\n    pending\n  end"
+            code << "\n  Unit :#{meth} => '' do\n    pending\n  end"
           end
         end
         code << "\nend\n"

data/lib/lemon/dsl.rb

@@ -0,0 +1,59 @@
+# Current suite being defined. This is used
+# to define a Suite object via the toplevel DSL.
+def Lemon.suite
+  @suite
+end
+
+#
+def Lemon.suite=(suite)
+  @suite = suite
+end
+
+#
+def Before(match=nil, &block)
+  Lemon.suite.Before(match, &block)
+end
+
+#
+def After(match=nil, &block)
+  Lemon.suite.After(match, &block)
+end
+
+#
+def When(match=nil, &block)
+  Lemon.suite.When(match, &block)
+end
+
+#
+def Case(target_class, &block)
+  Lemon.suite.Case(target_class, &block)
+end
+
+alias :TestCase :Case
+
+# FIXME: This is a BIG FAT HACK! For the life of me I cannot find
+# a way to resolve module constants included in the test cases.
+# Becuase of closure, the constant lookup goes through here, and not
+# the Case singleton class. So to work around we must note each test
+# before it is run, and reroute the missing constants.
+#
+# This sucks and it is not thread safe. If anyone know how to fix,
+# please let me know. See Unit#call for the other end of this hack.
+
+def Object.const_missing(name)
+  if unit = Lemon.test_stack.last
+    begin
+      (class << unit.testcase; self; end).const_get(name)
+    rescue NameError
+      super(name)
+    end
+  else
+    super(name)
+  end
+end
+
+# Get current running test. Used for the BIG FAT HACK.
+def Lemon.test_stack
+  @@test_stack ||= []
+end
+

data/lib/lemon/reporter.rb

@@ -1,19 +1,27 @@
 module Lemon
 
-  # Generic Reporter
+  # = Reporter Base Class
   class Reporter
 
     #
-    def self.factory(format)
+    def self.factory(format, runner)
       format = format.to_sym if format
       case format
       when :verbose
-        Reporters::Verbose.new
+        Reporters::Verbose.new(runner)
       else
-        Reporters::DotProgress.new
+        Reporters::DotProgress.new(runner)
       end
     end
 
+    def initialize(runner)
+      @runner = runner
+    end
+
+    #
+    attr :runner
+
+    #
     def report_start(suite)
     end
 
@@ -21,37 +29,23 @@ module Lemon
     end
 
     def report_success(testunit)
-      print "."
     end
 
     def report_failure(testunit, exception)
-      #puts exception
-      print "F"
     end
 
     def report_error(testunit, exception)
-      #puts exception
-      print "E"
     end
 
-    def report_finish(successes, failures, errors)
-      puts; puts
+    def report_finish
+    end
 
-      failures.each do |testunit, exception|
-        puts "    #{testunit}"
-        puts "    #{exception}"
-        puts
-      end
+    private
 
-      errors.each do |testunit, exception|
-        puts "    #{testunit}"
-        puts "    #{exception}"
-        puts
-      end
-
-      total = successes.size + failures.size + errors.size
-      puts "#{total} tests, #{failures.size} failures, #{errors.size} errors"
-    end
+    def successes ; runner.successes ; end
+    def failures  ; runner.failures  ; end
+    def errors    ; runner.errors    ; end
+    def pendings  ; runner.pendings  ; end
 
   end
 

data/lib/lemon/reporters/dotprogress.rb

@@ -6,16 +6,6 @@ module Reporters
   # Generic Reporter
   class DotProgress < Reporter
 
-    #
-    def self.factory(format)
-      case format.to_sym
-      when :verbose
-        VerboseReporter.new
-      else
-        new
-      end
-    end
-
     def report_start(suite)
     end
 
@@ -27,32 +17,50 @@ module Reporters
     end
 
     def report_failure(testunit, exception)
-      #puts exception
       print "F"
     end
 
     def report_error(testunit, exception)
-      #puts exception
       print "E"
     end
 
-    def report_finish(successes, failures, errors)
+    def report_pending(testunit, exception)
+      print "P"
+    end
+
+    def report_finish #(successes, failures, errors, pendings)
       puts; puts
 
-      failures.each do |testunit, exception|
-        puts "    #{testunit}"
-        puts "    #{exception}"
-        puts
+      unless failures.empty?
+        puts "FAILURES:\n\n"
+        failures.each do |testunit, exception|
+          puts "    #{testunit}"
+          puts "    #{exception}"
+          puts "    #{exception.backtrace[0]}"
+          puts
+        end
+      end
+
+      unless errors.empty?
+        puts "ERRORS:\n\n"
+        errors.each do |testunit, exception|
+          puts "    #{testunit}"
+          puts "    #{exception}"
+          puts "    #{exception.backtrace[0]}"
+          puts
+        end
       end
 
-      errors.each do |testunit, exception|
-        puts "    #{testunit}"
-        puts "    #{exception}"
+      unless pendings.empty?
+        puts "PENDING:\n\n"
+        pendings.each do |testunit, exception|
+          puts "    #{testunit}"
+        end
         puts
       end
 
-      total = successes.size + failures.size + errors.size
-      puts "#{total} tests, #{failures.size} failures, #{errors.size} errors"
+      total = successes.size + failures.size + errors.size + pendings.size
+      puts "#{total} tests, #{successes.size} pass, #{failures.size} failures, #{errors.size} errors, #{pendings.size} pending"
     end
 
   end

data/lib/lemon/reporters/verbose.rb

@@ -13,43 +13,76 @@ module Reporters
     #
     def report_concern(concern)
       puts
-      puts concern.description
+      puts "#{concern.description}\n\n" unless concern.description.empty?
     end
 
     #
     def report_success(testunit)
-      puts "* [PASS] #{testunit}"
+      puts "* #{testunit}"
     end
 
     #
     def report_failure(testunit, exception)
-      puts "* [FAIL] #{testunit.target}"
-      #puts exception
+      puts "* #{testunit}"
+      puts
+      puts "        FAIL #{exception.backtrace[0]}"
+      puts "        #{exception}"
+      puts
     end
 
     #
     def report_error(testunit, exception)
-      puts "* [ERROR] #{testunit.target}"
-      #puts exception
+      puts "* #{testunit}"
+      puts
+      puts "        ERROR #{exception.backtrace[0]}"
+      puts "        #{exception}"
+      puts
+    end
+
+    #
+    def report_pending(testunit, exception)
+      puts "* #{testunit}"
+      puts
+      puts "        PENDING #{exception.backtrace[1]}"
+      puts
     end
 
-    def report_finish(successes, failures, errors)
-      puts; puts
+    #
+    def report_finish
+      puts
 
-      failures.each do |testunit, exception|
-        puts "    #{testunit}"
-        puts "    #{exception}"
-        puts
+=begin
+      unless failures.empty?
+        puts "FAILURES:\n\n"
+        failures.each do |testunit, exception|
+          puts "    #{testunit}"
+          puts "    #{exception}"
+          puts "    #{exception.backtrace[0]}"
+          puts
+        end
+      end
+
+      unless errors.empty?
+        puts "ERRORS:\n\n"
+        errors.each do |testunit, exception|
+          puts "    #{testunit}"
+          puts "    #{exception}"
+          puts "    #{exception.backtrace[0]}"
+          puts
+        end
       end
 
-      errors.each do |testunit, exception|
-        puts "    #{testunit}"
-        puts "    #{exception}"
+      unless pendings.empty?
+        puts "PENDING:\n\n"
+        pendings.each do |testunit, exception|
+          puts "    #{testunit}"
+        end
         puts
       end
+=end
 
-      total = successes.size + failures.size + errors.size
-      puts "#{total} tests, #{failures.size} failures, #{errors.size} errors"
+      total = successes.size + failures.size + errors.size + pendings.size
+      puts "#{total} tests, #{successes.size} pass, #{failures.size} failures, #{errors.size} errors, #{pendings.size} pending"
     end
 
   end

data/lib/lemon/runner.rb

@@ -14,6 +14,9 @@ module Lemon
     # Test suite to run.
     attr :suite
 
+    # Report format.
+    attr :format
+
     # Record of successful tests.
     attr :successes
 
@@ -23,8 +26,8 @@ module Lemon
     # Record of errors.
     attr :errors
 
-    # Report format.
-    attr :format
+    # Record of pending tests.
+    attr :pendings
 
     # New Runner.
     def initialize(suite, format)
@@ -33,6 +36,7 @@ module Lemon
       @successes = []
       @failures  = []
       @errors    = []
+      @pendings  = []
     end
 
     # Run tests.
@@ -48,6 +52,9 @@ module Lemon
               testunit.call
               reporter.report_success(testunit)
               successes << testunit
+            rescue PendingAssertion => exception
+              reporter.report_pending(testunit, exception)
+              pendings << [testunit, exception]
             rescue Assertion => exception
               reporter.report_failure(testunit, exception)
               failures << [testunit, exception]
@@ -59,12 +66,12 @@ module Lemon
           end
         end
       end
-      reporter.report_finish(successes, failures, errors)
+      reporter.report_finish #(successes, failures, errors, pendings)
     end
 
     # All output is handled by a reporter.
     def reporter
-      @reporter ||= Reporter.factory(format)
+      @reporter ||= Reporter.factory(format, self)
     end
 
     private

data/lib/lemon/test/case.rb

@@ -99,6 +99,11 @@ module Lemon::Test
       @when_clauses[match] = block #<< Advice.new(match, &block)
     end
 
+    #
+    def pending
+      raise PendingAssertion
+    end
+
     #
     def to_s
       target.to_s.sub(/^\#\<.*?\>::/, '')
@@ -107,3 +112,6 @@ module Lemon::Test
 
 end
 
+class PendingAssertion < Assertion
+end
+

data/lib/lemon/test/concern.rb

@@ -16,7 +16,7 @@ module Lemon::Test
     attr :testunits
 
     # New concern.
-    def initialize(testcase, description)
+    def initialize(testcase, *description)
       @testcase    = testcase
       @description = description.join("\n")
       @testunits   = []

data/lib/lemon/test/suite.rb

@@ -2,6 +2,7 @@ module Lemon
 module Test
 
   require 'lemon/test/case'
+  require 'lemon/dsl'
 
   # Test Suites encapsulate a set of test cases.
   #
@@ -19,18 +20,22 @@ module Test
     # List of post-test procedures that apply suite-wide.
     attr :after_clauses
 
-    # List of concern procedures that apply suite-wide.
-    attr :when_clauses
-
     #
-    def initialize(*tests)
+    def initialize(*files)
       @testcases      = []
       @before_clauses = {}
       @after_clauses  = {}
       @when_clauses   = {}
 
+      loadfiles(*files)
+    end
+
+    #
+    def loadfiles(*files)
+      Lemon.suite = self
+
       # directories glob *.rb files
-      tests = tests.flatten.map do |file|
+      files = files.flatten.map do |file|
         if File.directory?(file)
           Dir[File.join(file, '**', '*.rb')]
         else
@@ -38,12 +43,13 @@ module Test
         end
       end.flatten.uniq
 
-      @test_files = tests
-
-      tests.each do |file|
+      files.each do |file|
         #file = File.expand_path(file)
-        instance_eval(File.read(file), file)
+        #instance_eval(File.read(file), file)
+        load(file)
       end
+
+      return Lemon.suite
     end
 
     # Load a helper. This method must be used when loading local
@@ -75,21 +81,21 @@ module Test
     alias_method :TestCase, :Case
 
     #
-    alias_method :testcase, :Case
+    #alias_method :testcase, :Case
 
     # Define a pre-test procedure to apply suite-wide.
     def Before(match=nil, &block)
       @before_clauses[match] = block #<< Advice.new(match, &block)
     end
 
-    alias_method :before, :Before
+    #alias_method :before, :Before
 
     # Define a post-test procedure to apply suite-wide.
     def After(match=nil, &block)
       @after_clauses[match] = block #<< Advice.new(match, &block)
     end
 
-    alias_method :after, :After
+    #alias_method :after, :After
 
     # Define a concern procedure to apply suite-wide.
     def When(match=nil, &block)
@@ -101,24 +107,6 @@ module Test
       @testcases.each(&block)
     end
 
-    # FIXME: This is a BIG FAT HACK! For the life of me I cannot find
-    # a way to resolve module constants included in the test cases.
-    # Becuase of closure, the constant lookup goes through here, and not
-    # the Case singleton class. So to work around wemust note each test
-    # before it is run, and reroute the missing constants.
-    #
-    # This sucks and it is not thread safe. If anyone know how to fix,
-    # please let me know. See Unit#call for the other end of this hack.
-
-    def self.const_missing(name)
-      (class << @@test_stack.last.testcase; self; end).const_get(name)
-    end
-
-    # Get current running test. Used for the BIG FAT HACK.
-    def test_stack
-      @@test_stack ||= []
-    end
-
   end
 
 end

data/lib/lemon/test/unit.rb

@@ -32,10 +32,10 @@ module Lemon::Test
 
     # This method has the other end of the BIG FAT HACK. See Suite#const_missing.
     def call
-      suite.test_stack << self  # hack
+      Lemon.test_stack << self  # hack
       procedure.call
     ensure
-      suite.test_stack.pop
+      Lemon.test_stack.pop
     end
 
     # The suite to which this unit test belongs.

data/meta/version

@@ -1 +1 @@
-0.5
+0.6

data/test/cases/testcase_case.rb

@@ -6,7 +6,7 @@ module M
   end
 end
 
-Case(Lemon::Test::Case) do
+TestCase(Lemon::Test::Case) do
 
   Concern "Modules included in a test case are accessible by the unit tests."
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lemon
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: "0.6"
 platform: ruby
 authors: 
 - Thomas Sawyer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-31 00:00:00 -05:00
+date: 2010-01-03 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -32,11 +32,16 @@ files:
 - COPYING
 - COPYING.LESSER
 - HISTORY
+- MANIFEST
 - README.rdoc
 - bin/lemon
 - lib/lemon.rb
 - lib/lemon/command.rb
+- lib/lemon/commands/coverage.rb
+- lib/lemon/commands/generate.rb
+- lib/lemon/commands/test.rb
 - lib/lemon/coverage.rb
+- lib/lemon/dsl.rb
 - lib/lemon/kernel.rb
 - lib/lemon/reporter.rb
 - lib/lemon/reporters.rb
@@ -61,7 +66,6 @@ files:
 - meta/version
 - test/cases/coverage_case.rb
 - test/cases/testcase_case.rb
-- MANIFEST
 - Syckfile
 has_rdoc: true
 homepage: http://proutils.github.com/lemon
@@ -93,4 +97,5 @@ signing_key:
 specification_version: 3
 summary: Pucker-tight Unit Testing
 test_files: 
+- lib/lemon/commands/test.rb
 - test/cases/testcase_case.rb