lemon 0.8.1 → 0.8.2

data/lib/lemon/model/test_context.rb

@@ -0,0 +1,90 @@
+module Lemon
+
+  # Test Instances are used to organize unit tests into groups, so as to address
+  # specific scenarios for a given class.
+  class TestContext
+
+    # The test case to which this concern belongs.
+    attr :testcase
+
+    # The description of this concern. Make this
+    # as detailed as you wish.
+    attr :description
+
+    # New case instance.
+    def initialize(testcase, description, options={}, &block)
+      @testcase    = testcase
+      @description = description.to_s
+      @function    = options[:function] || options[:singleton]
+      @type        = options[:type] || :context
+      @block       = block
+    end
+
+    #
+    def teardown=(procedure)
+       @teardown = procedure
+    end
+
+    # Teardown instance.
+    def teardown(scope=nil)
+      if scope
+        scope.instance_eval(&@teardown) if @teardown
+      else
+        @teardown
+      end
+    end
+
+    # Create instance.
+    def setup(scope)
+      if @block
+        ins = scope.instance_eval(&@block)
+      end
+      ins
+    end
+
+    def function? ; false ; end
+    alias_method :meta?, :function?
+
+    # Returns the description with newlines removed.
+    def to_s
+      description.gsub(/\n/, ' ')
+    end
+  end
+
+  ##
+  #class TestInstance < TestContext
+  #
+  #  # Create instance.
+  #  def setup(scope)
+  #    if @block
+  #      ins = scope.instance_eval(&@block)
+  #      raise "target type mismatch" unless testcase.target === ins
+  #    end
+  #    ins
+  #  end
+  #
+  #end
+
+=begin
+  #
+  class TestSingleton < TestContext
+
+    # Create instance.
+    def setup(scope)
+      if @block
+        ins = scope.instance_eval(&@block)
+        raise "target type mismatch" unless testcase.target == ins
+      else
+        ins = @testcase.target
+      end
+      ins
+    end
+
+    def function? ; true ; end
+    alias_method :meta?, :function?
+
+  end
+=end
+
+end
+

data/lib/lemon/model/test_suite.rb

@@ -0,0 +1,216 @@
+require 'lemon/model/test_case'
+require 'lemon/model/snapshot'
+#require 'lemon/model/main'
+
+module Lemon
+
+  # Current suite being defined. This is used
+  # to define a Suite object via the toplevel DSL.
+  def self.suite
+    $lemon_suite #@suite ||= Lemon::TestSuite.new([])
+  end
+
+  #
+  def self.suite=(suite)
+    $lemon_suite = suite
+  end
+
+  # Test Suites encapsulate a set of test cases.
+  #
+  class TestSuite
+
+    # Files from which the suite is loaded.
+    attr :files
+
+    # Test cases in this suite.
+    attr :testcases
+
+    # List of pre-test procedures that apply suite-wide.
+    attr :before
+
+    # List of post-test procedures that apply suite-wide.
+    attr :after
+
+    # A snapshot of the system before the suite is loaded.
+    # Only set if +cover+ option is true.
+    #attr :canonical
+
+    # List of files to be covered. This primarily serves
+    # as a means for allowing one test to load another
+    # and ensuring converage remains accurate.
+    #attr :subtest
+
+    #attr :current_file
+
+    #def coverage
+    #  @final_coveage ||= @coverage - @canonical
+    #end
+
+    #
+    #attr :options
+
+    attr :dsl
+
+    #
+    def initialize(files, options={})
+      @files   = files.flatten
+      @options = options
+
+      @testcases = []
+
+      @before    = {}
+      @after     = {}
+
+      #load_helpers
+
+      #if cover? or cover_all?
+      #  @coverage  = Snapshot.new
+      #  @canonical = Snapshot.capture
+      #end
+
+      @dsl = DSL.new(self) #, files)
+
+      load_files
+    end
+
+    #
+    #class Scope < Module
+    #  def initialize
+    #    extend self
+    #  end
+    #end
+
+    # Iterate through this suite's test cases.
+    def each(&block)
+      @testcases.each(&block)
+    end
+
+    #
+    def cover?
+      @options[:cover]
+    end
+
+    #
+    def cover_all?
+      @options[:cover_all]
+    end
+
+    # TODO: automatic helper loading ?
+    #def load_helpers(*files)
+    #  helpers = []
+    #  filelist.each do |file|
+    #    dir = File.dirname(file)
+    #    hlp = Dir[File.join(dir, '{test_,}helper.rb')]
+    #    helpers.concat(hlp)
+    #  end
+    #
+    #  helpers.each do |hlp|
+    #    require hlp
+    #  end
+    #end
+
+    #
+    def load_files #(*files)
+      s = Lemon.suite || self
+      Lemon.suite = self
+
+      filelist.each do |file|
+        #load_file(file)
+        load file #require file
+      end
+
+      Lemon.suite = s
+
+      #if cover?
+      #  $stdout << "\n"
+      #  $stdout.flush
+      #end
+
+      self #return Lemon.suite
+    end
+
+    #
+    #def load_file(file)
+    #  #@current_file = file
+    #  #if cover_all?
+    #  #  Covers(file)
+    #  #else
+    #    file = File.expand_path(file)
+    #    @dsl.module_eval(File.read(file), file)
+    #    #require(file) #load(file)
+    #  #end
+    #end
+
+    # Directories glob *.rb files.
+    def filelist
+      @filelist ||= (
+        files = @files
+        files = files.map{ |f| Dir[f] }.flatten
+        files = files.map do |file|
+          if File.directory?(file)
+            Dir[File.join(file, '**', '*.rb')]
+          else
+            file
+          end
+        end.flatten
+        #files = files.map{ |f| File.expand_path(f) }
+        files.uniq
+      )
+    end
+
+    class DSL < Module
+      #
+      def initialize(test_suite)
+        @test_suite = test_suite
+        #module_eval(&code)
+      end
+
+      # TODO: need require_find() to avoid first snapshot ?
+      def covers(file)
+        #if @test_suite.cover?
+        #  #return if $".include?(file)
+        #  s = Snapshot.capture
+        #  if require(file)
+        #    z = Snapshot.capture
+        #    @test_suite.coverage << (z - s)
+        #  end
+        #else
+          require file
+        #end
+      end
+      alias_method :Covers, :covers
+
+      # Define a test case belonging to this suite.
+      def testcase(target_class, &block)
+        raise "lemon: case target must be a class or module" unless Module === target_class
+        @test_suite.testcases << TestCase.new(@test_suite, target_class, &block)
+      end
+
+      #
+      alias_method :TestCase, :testcase
+      alias_method :tests, :testcase
+
+      # Define a pre-test procedure to apply suite-wide.
+      def before(*matches, &block)
+        @test_suite.before[matches] = block #<< Advice.new(match, &block)
+      end
+      alias_method :Before, :before
+
+      # Define a post-test procedure to apply suite-wide.
+      def after(*matches, &block)
+        @test_suite.after[matches] = block #<< Advice.new(match, &block)
+      end
+      alias_method :After, :after
+
+      # Includes at the suite level are routed to the toplevel.
+      #def include(*mods)
+      #  TOPLEVEL_BINDING.eval('self').instance_eval do
+      #    include(*mods)
+      #  end
+      #end
+
+    end
+
+  end
+
+end

data/lib/lemon/{test/unit.rb → model/test_unit.rb}

@@ -1,54 +1,58 @@
-module Lemon::Test
+module Lemon
 
   #
-  class Unit
+  class TestUnit
 
     # The test case to which this unit test belongs.
     attr :testcase
 
-    # The concern which this test helps ensure.
-    attr :concern
+    # The context to use for this test.
+    attr :context
 
     # A test unit +target+ is a method.
     attr :target
 
-    # The aspect of the concern this test fulfills.
+    # The aspect of the instance this test fulfills.
     attr :aspect
 
     # Test procedure, in which test assertions should be made.
     attr :procedure
 
     # New unit test.
-    def initialize(concern, target, options={}, &procedure)
-      concern.assign(self)
-
-      @concern   = concern
-      @testcase  = concern.testcase
-
+    def initialize(testcase, target, options={}, &procedure)
+      @testcase  = testcase
       @target    = target
 
       @aspect    = options[:aspect]
-      @meta      = options[:metaclass]
+      @function  = options[:function] || options[:metaclass]
+      @context   = options[:context]
+      @omit      = options[:omit]
 
       @procedure = procedure
+
+      @tested    = false
     end
 
-    # Is this unit test for a meta-method?
-    def meta?
-      @meta
+    #
+    attr_accessor :omit
+
+    #
+    def name ; @target ; end
+
+    # Is this unit test for a class or module level method?
+    def function?
+      @function
     end
+    alias_method :meta?, :function?
 
-    # This method has the other end of the BIG FAT HACK. See Suite#const_missing.
-    def call
-      raise Pending unless procedure
-      begin
-        Lemon.test_stack << self  # hack
-        procedure.call
-      ensure
-        Lemon.test_stack.pop
-      end
+    #
+    def omit?
+      @omit
     end
 
+    #
+    attr_accessor :tested
+
     # The suite to which this unit test belongs.
     def suite
       testcase.suite
@@ -74,9 +78,19 @@ module Lemon::Test
     #
     def to_s
       if meta?
-        "#{testcase}.#{target} #{aspect}"
+        "#{testcase}.#{target}"
       else
-        "#{testcase}##{target} #{aspect}"
+        "#{testcase}##{target}"
+      end
+    end
+
+    #
+    def description
+      if meta?
+        "#{testcase} #{instance} .#{target} #{aspect}"
+      else
+        a  = /^[aeiou]/i =~ testcase.to_s ? 'An' : 'A'
+        "#{a} #{testcase} #{instance} receiving ##{target} #{aspect}"
       end
     end
 
@@ -88,5 +102,3 @@ module Lemon::Test
 
 end
 
-
-

data/lib/lemon/{coversheet → view/cover_reports}/abstract.rb

@@ -1,5 +1,4 @@
-module Lemon
-module CoverSheet
+module Lemon::CoverReports
 
   class Abstract
 
@@ -21,40 +20,40 @@ module CoverSheet
     #
     attr :coverage
 
-    def uncovered_cases
-      coverage.uncovered_cases
+    #
+    def render
+    end
+
+    def covered_units
+      coverage.covered
     end
 
     def uncovered_units
-      coverage.uncovered_units
+      coverage.uncovered
     end
 
     def undefined_units
-      coverage.undefined_units
+      coverage.undefined
     end
 
-    #
-    def red(string)
-      @ansicolor ? ANSI::Code.red{ string } : string
+    def uncovered_cases
+      coverage.uncovered_cases
     end
 
     #
-    def yellow(string)
-      @ansicolor ? ANSI::Code.yellow{ string } : string
-    end
+    def tally
+      c = covered_units.size
+      u = uncovered_units.size
+      t = c + u
 
-    #
-    def green(string)
-      @ansicolor ? ANSI::Code.green{ string } : string
-    end
+      pc = c * 100 / t
+      pu = u * 100 / t
 
-    #
-    def tally
-      "#{uncovered_cases.size} uncovered cases, #{uncovered_units.size} uncovered units, #{undefined_units.size} undefined units"
+      "#{pc}% #{c}/#{t} covered, #{pu}% #{u}/#{t} uncovered" + 
+      " (#{undefined_units.size} undefined units, #{uncovered_cases.size} uncovered cases)"
     end
 
   end
 
 end
-end