lemon 0.6 → 0.7.0

data/lib/lemon/reporter.rb

@@ -1,52 +1,22 @@
-module Lemon
-
-  # = Reporter Base Class
-  class Reporter
-
-    #
-    def self.factory(format, runner)
-      format = format.to_sym if format
-      case format
-      when :verbose
-        Reporters::Verbose.new(runner)
-      else
-        Reporters::DotProgress.new(runner)
-      end
-    end
-
-    def initialize(runner)
-      @runner = runner
-    end
-
-    #
-    attr :runner
-
-    #
-    def report_start(suite)
-    end
-
-    def report_concern(concern)
-    end
+require 'lemon/reporter/dotprogress'
+require 'lemon/reporter/outline'
+require 'lemon/reporter/verbose'
 
-    def report_success(testunit)
-    end
-
-    def report_failure(testunit, exception)
-    end
-
-    def report_error(testunit, exception)
-    end
-
-    def report_finish
+module Lemon
+module Reporter
+
+  # TODO: make Reporter#factory more dynamic
+  def self.factory(format, runner)
+    format = format.to_s if format
+    case format
+    when 'v', 'verb', 'verbose'
+      Reporter::Verbose.new(runner)
+    when 'o', 'out', 'outline'
+      Reporter::Outline.new(runner)
+    else
+      Reporter::DotProgress.new(runner)
     end
-
-    private
-
-    def successes ; runner.successes ; end
-    def failures  ; runner.failures  ; end
-    def errors    ; runner.errors    ; end
-    def pendings  ; runner.pendings  ; end
-
   end
 
 end
+end

data/lib/lemon/reporter/abstract.rb

@@ -0,0 +1,92 @@
+module Lemon
+module Reporter
+
+  # = Reporter Base Class
+  class Abstract
+
+    # Supports ANSI Codes?
+    ANSI_SUPPORT = (
+      begin
+        require 'ansi/code'
+        true
+      rescue LoadError
+        false
+      end
+    )
+
+    def initialize(runner)
+      @runner    = runner
+      @ansicolor = ANSI_SUPPORT
+    end
+
+    #
+    attr :runner
+
+    #
+    def report_start(suite)
+    end
+
+    def report_concern(concern)
+    end
+
+    def report_success(testunit)
+    end
+
+    def report_failure(testunit, exception)
+    end
+
+    def report_error(testunit, exception)
+    end
+
+    def report_finish
+    end
+
+    private
+
+    def successes ; runner.successes ; end
+    def failures  ; runner.failures  ; end
+    def errors    ; runner.errors    ; end
+    def pendings  ; runner.pendings  ; end
+
+    def uncovered_cases ; runner.uncovered_cases ; end
+    def uncovered_units ; runner.uncovered_units ; end
+    def undefined_units ; runner.undefined_units ; end
+
+    #def uncovered ; runner.uncovered ; end
+    #def undefined ; runner.undefined ; end
+
+    # Is coverage information requested?
+    def cover? ; runner.cover? ; end
+
+    #
+    def red(string)
+      @ansicolor ? ANSI::Code.red{ string } : string
+    end
+
+    #
+    def yellow(string)
+      @ansicolor ? ANSI::Code.yellow{ string } : string
+    end
+
+    #
+    def green(string)
+      @ansicolor ? ANSI::Code.green{ string } : string
+    end
+
+    #
+    def total
+      successes.size + failures.size + errors.size + pendings.size
+    end
+
+    #
+    def tally
+      s = "#{total} tests: #{successes.size} pass, #{failures.size} fail, #{errors.size} err, #{pendings.size} pending "
+      s += "(#{uncovered_units.size} uncovered, #{undefined_units.size} undefined)" if cover?
+      s
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/{reporters → reporter}/dotprogress.rb

@@ -1,10 +1,9 @@
 module Lemon
-module Reporters
-
-  require 'lemon/reporter'
+module Reporter
+  require 'lemon/reporter/abstract'
 
   # Generic Reporter
-  class DotProgress < Reporter
+  class DotProgress < Abstract
 
     def report_start(suite)
     end
@@ -13,7 +12,7 @@ module Reporters
     end
 
     def report_success(testunit)
-      print "."
+      print "."; $stdout.flush
     end
 
     def report_failure(testunit, exception)
@@ -59,8 +58,7 @@ module Reporters
         puts
       end
 
-      total = successes.size + failures.size + errors.size + pendings.size
-      puts "#{total} tests, #{successes.size} pass, #{failures.size} failures, #{errors.size} errors, #{pendings.size} pending"
+      puts tally
     end
 
   end

data/lib/lemon/reporter/outline.rb

@@ -0,0 +1,105 @@
+module Lemon
+module Reporter
+  require 'lemon/reporter/abstract'
+
+  # Outline Reporter
+  class Outline < Abstract
+
+    #
+    def report_start(suite)
+    end
+
+    #
+    def report_concern(concern)
+      puts
+      puts "#{concern.description}\n\n" unless concern.description.empty?
+    end
+
+    #
+    def report_success(testunit)
+      puts green("* #{testunit}")
+    end
+
+    #
+    def report_failure(testunit, exception)
+      puts red("* #{testunit} (FAILURE)")
+      #puts
+      #puts "        FAIL #{exception.backtrace[0]}"
+      #puts "        #{exception}"
+      #puts
+    end
+
+    #
+    def report_error(testunit, exception)
+      puts red("* #{testunit} (ERROR)")
+      #puts
+      #puts "        ERROR #{exception.backtrace[0]}"
+      #puts "        #{exception}"
+      #puts
+    end
+
+    #
+    def report_pending(testunit, exception)
+      puts yellow("* #{testunit} (PENDING)")
+      #puts
+      #puts "        PENDING #{exception.backtrace[0]}"
+      #puts
+    end
+
+    #
+    def report_finish
+      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
+
+      #unless pendings.empty?
+      #  puts "PENDING:\n\n"
+      #  pendings.each do |testunit, exception|
+      #    puts "    #{testunit}"
+      #  end
+      #end
+
+      unless uncovered.empty?
+        puts "UNCOVERED:\n\n"
+        unc = uncovered.map do |testunit|
+          yellow("* " +testunit.join('#'))
+        end.join("\n")
+        puts unc
+        puts
+      end
+
+      unless undefined.empty?
+        puts "UNDEFINED:\n\n"
+        unc = undefined.map do |testunit|
+          yellow("* " + testunit.join('#'))
+        end.join("\n")
+        puts unc
+        puts
+      end
+
+      puts tally
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/reporter/verbose.rb

@@ -0,0 +1,127 @@
+module Lemon
+module Reporter
+  require 'lemon/reporter/abstract'
+
+  # Verbose Reporter
+  class Verbose < Abstract
+
+    #
+    def report_start(suite)
+    end
+
+    #
+    def report_concern(concern)
+      puts
+      puts "#{concern.description}\n\n" unless concern.description.empty?
+    end
+
+    #
+    def report_success(testunit)
+      puts green("* #{testunit}")
+    end
+
+    #
+    def report_failure(testunit, exception)
+      puts red("* #{testunit} (FAILURE)")
+      puts
+      puts "        FAIL #{exception.backtrace[0]}"
+      puts "        #{exception}"
+      puts
+    end
+
+    #
+    def report_error(testunit, exception)
+      puts red("* #{testunit} (ERROR)")
+      puts
+      puts "        ERROR #{exception.backtrace[0]}"
+      puts "        #{exception}"
+      puts
+    end
+
+    #
+    def report_pending(testunit, exception)
+      puts yellow("* #{testunit} (PENDING)")
+      #puts
+      #puts "        PENDING #{exception.backtrace[1]}"
+      #puts
+    end
+
+    #
+    def report_finish
+      #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
+
+      #unless pendings.empty?
+      #  puts "PENDING:\n\n"
+      #  pendings.each do |testunit, exception|
+      #    puts "    #{testunit}"
+      #  end
+      #  puts
+      #end
+
+      if cover?
+
+        unless uncovered_cases.empty?
+          unc = uncovered_cases.map do |mod|
+            yellow(mod.name)
+          end.join(", ")
+          puts "\nUncovered Cases: " + unc
+        end
+
+        unless uncovered_units.empty?
+          unc = uncovered_units.map do |unit|
+            yellow(unit)
+          end.join(", ")
+          puts "\nUncovered Units: " + unc
+        end
+
+        #unless uncovered.empty?
+        #  unc = uncovered.map do |unit|
+        #    yellow(unit)
+        #  end.join(", ")
+        #  puts "\nUncovered: " + unc
+        #end
+
+        unless undefined_units.empty?
+          unc = undefined_units.map do |unit|
+            yellow(unit)
+          end.join(", ")
+          puts "\nUndefined Units: " + unc
+        end
+
+      end
+
+      #total = successes.size + failures.size + errors.size + pendings.size
+      #tally = "\n#{total} tests: #{successes.size} pass, #{failures.size} fail, #{errors.size} err, #{pendings.size} pending"
+      #if cover?
+      #  tally += " (#{uncovered.size} uncovered, #{undefined.size} undefined)"
+      #end
+
+      puts
+      puts tally
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/runner.rb

@@ -6,7 +6,7 @@ module Lemon
 
   require 'lemon/kernel'
   require 'lemon/test/suite'
-  require 'lemon/reporters'
+  require 'lemon/reporter'
 
   #
   class Runner
@@ -30,29 +30,51 @@ module Lemon
     attr :pendings
 
     # New Runner.
-    def initialize(suite, format)
+    def initialize(suite, options={})
       @suite     = suite
-      @format    = format
+      @options   = options
+
       @successes = []
       @failures  = []
       @errors    = []
       @pendings  = []
     end
 
+    #
+    def format
+      @options[:format]
+    end
+
+    #
+    def cover?
+      @options[:cover]
+    end
+
+    # Namespaces option specifies the selection of test cases
+    # to run. Is is an array of strings which are matched 
+    # against the module/class names using #start_wtih?
+    def namespaces
+      @options[:namespaces] || []
+    end
+
     # Run tests.
     def run
+      #prepare
+
       reporter.report_start(suite)
-      suite.each do |testcase|
+
+      each do |testcase|
         testcase.each do |concern|
           reporter.report_concern(concern)
           run_concern_procedures(concern, suite, testcase)
           concern.each do |testunit|
+            #mark_coverage(testcase, testunit)
             run_pretest_procedures(testunit, suite, testcase)
             begin
               testunit.call
               reporter.report_success(testunit)
               successes << testunit
-            rescue PendingAssertion => exception
+            rescue Pending => exception
               reporter.report_pending(testunit, exception)
               pendings << [testunit, exception]
             rescue Assertion => exception
@@ -66,15 +88,121 @@ module Lemon
           end
         end
       end
+
       reporter.report_finish #(successes, failures, errors, pendings)
     end
 
+    # Iterate overs suite testcases, filtering out unselected testcases
+    # if any namespaces are provided.
+    def each(&block)
+      if namespaces.empty?
+        suite.each do |testcase|
+          block.call(testcase)
+        end
+      else
+        suite.each do |testcase|
+          next unless namespaces.any?{ |n| testcase.target.name.start_with?(n) }
+          block.call(testcase)
+        end
+      end
+    end
+
     # All output is handled by a reporter.
     def reporter
       @reporter ||= Reporter.factory(format, self)
     end
 
-    private
+    #
+    #def uncovered
+    #  c = []
+    #  @testcase_coverage.each do |testcase, testunits|
+    #    testunits.each do |testunit, coverage|
+    #      c << [testcase, testunit] if coverage == false
+    #    end
+    #  end
+    #  c
+    #end
+
+=begin
+    #
+    def prepare
+      if cover?
+        coverage.canonical!
+      end
+
+      suite.load_covered_files
+
+      if cover?
+        @uncovered = calculate_uncovered
+        @undefined = calculate_undefined
+      end
+    end
+=end
+
+    #
+    def uncovered_cases
+      @uncovered_cases ||= coverage.uncovered_cases
+    end
+
+    #
+    def uncovered_units
+      @uncovered_units ||= coverage.uncovered_units
+    end
+
+    #
+    def undefined_units
+      @undefined_units ||= coverage.undefined_units
+    end
+
+=begin
+    #
+    def uncovered
+      @uncovered ||= calculate_uncovered
+    end
+
+    #
+    def undefined
+      @undefined ||= calculate_undefined
+    end
+
+    #
+    def calculate_uncovered
+      uncovered_targets = []
+      coverage.checklist.each do |mod, meths|
+        meths.each do |meth, covered|
+          if !covered
+            if /^::/ =~ meth.to_s
+              uncovered_targets << "#{mod}#{meth}"
+            else
+              uncovered_targets << "#{mod}##{meth}"
+            end
+          end
+        end
+      end
+      uncovered_targets
+    end
+
+    #
+    def calculate_undefined
+      covered_testunits = successes + (failures + errors + pendings).map{ |tu, e| tu }
+      covered_targets = covered_testunits.map{ |tu| tu.fullname }
+
+      targets = []
+      coverage.each do |mod, meths|
+        meths.each do |meth, cov|
+          if /^::/ =~ meth.to_s
+            targets << "#{mod}#{meth}"
+          else
+            targets << "#{mod}##{meth}"
+          end
+        end
+      end
+
+      covered_targets - targets
+    end
+=end
+
+  private
 
     #
     def run_concern_procedures(concern, suite, testcase)
@@ -88,36 +216,91 @@ module Lemon
           block.call(testcase) if match === concern.to_s
         end
       end
+      concern.call
     end
 
-    #
+    # Run pre-test advice.
     def run_pretest_procedures(testunit, suite, testcase)
       suite.before_clauses.each do |match, block|
-        if match.nil? or match === testunit.aspect
+        if match.nil? or testunit.match?(match)
           block.call(testunit)
         end
       end
       testcase.before_clauses.each do |match, block|
-        if match.nil? or match === testunit.aspect
+        if match.nil? or testunit.match?(match)
           block.call(testunit)
         end
       end
     end
 
-    #
+    # Run post-test advice.
     def run_postest_procedures(testunit, suite, testcase)
       testcase.after_clauses.each do |match, block|
-        if match.nil? or match === testunit.aspect
+        if match.nil? or testunit.match?(match)
           block.call(testunit)
         end
       end
       suite.after_clauses.each do |match, block|
-        if match.nil? or match === testunit.aspect
+        if match.nil? or testunit.match?(match)
           block.call(testunit)
         end
       end
     end
 
+    #
+    def coverage
+      @coverage ||= Lemon::Coverage.new(suite, namespaces) #, :public => public_only?)
+    end
+
+=begin
+    # TODO: I would think all this should be gained form the Coverage class.
+
+    # TODO: options to include non-public and superclasses less Object and Kernel.
+    def mark_coverage(testcase, testunit)
+      testunit = testunit.target.to_sym
+      profile  = testcase_profile(testcase)
+      coverage = testcase_coverage(testcase)
+
+      if profile[:public].include?(testunit) || profile[:meta_public].include?(testunit)
+        coverage[testunit] = :public
+      elsif profile[:private].include?(testunit) || profile[:meta_private].include?(testunit)
+        coverage[testunit] = :private
+      elsif profile[:protected].include?(testunit) || profile[:meta_protected].include?(testunit)
+        coverage[testunit] = :protected
+      else
+        coverage[testunit] = nil # nil means does not exist, while false means not covered.
+      end
+    end
+
+    #
+    def testcase_coverage(testcase)
+      target = testcase.target
+      @testcase_coverage ||= {}
+      @testcase_coverage[target] ||= (
+        h = {}
+        target.public_instance_methods(false).each{|unit| h[unit] = false }
+        (target.public_methods(false) - Object.public_methods(false)).each{|unit| h[unit] = false }
+        #target.private_instance_method(false)
+        #target.protected_instance_method(false)
+        h
+      )
+    end
+
+    #
+    def testcase_profile(testcase)
+      target = testcase.target
+      @testcase_profile ||= {}
+      @testcase_profile[target] ||= {
+        :public    => target.public_instance_methods(false).map{|s|s.to_sym},
+        :private   => target.private_instance_methods(false).map{|s|s.to_sym},
+        :protected => target.protected_instance_methods(false).map{|s|s.to_sym},
+        :meta_public    => (target.public_methods(false) - Object.public_methods(false)).map{|s|s.to_sym},
+        :meta_private   => (target.private_methods(false) - Object.private_methods(false)).map{|s|s.to_sym},
+        :meta_protected => (target.protected_methods(false)- Object.protected_methods(false)).map{|s|s.to_sym}
+      }
+    end
+=end
+
   end
 
 end