lemon 0.8.1 → 0.8.2

data/lib/lemon/reporter/dotprogress.rb

@@ -1,68 +0,0 @@
-module Lemon
-module Reporter
-  require 'lemon/reporter/abstract'
-
-  # Generic Reporter
-  class DotProgress < Abstract
-
-    def report_start(suite)
-    end
-
-    def report_concern(concern)
-    end
-
-    def report_success(testunit)
-      print "."; $stdout.flush
-    end
-
-    def report_failure(testunit, exception)
-      print "F"
-    end
-
-    def report_error(testunit, exception)
-      print "E"
-    end
-
-    def report_pending(testunit, exception)
-      print "P"
-    end
-
-    def report_finish #(successes, failures, errors, pendings)
-      puts; 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
-
-      puts tally
-    end
-
-  end
-
-end
-end
-

data/lib/lemon/reporter/outline.rb

@@ -1,105 +0,0 @@
-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

@@ -1,143 +0,0 @@
-module Lemon
-module Reporter
-  require 'lemon/reporter/abstract'
-
-  # Verbose Reporter
-  class Verbose < Abstract
-
-    #
-    def report_start(suite)
-      timer_reset
-    end
-
-    #
-    def report_concern(concern)
-      puts
-      puts "== #{concern.description}\n\n" unless concern.description.empty?
-      timer_reset
-    end
-
-    #
-    def report_success(testunit)
-      puts "%12s  %s  %s" % [timer, green("SUCCESS"), green("#{testunit}")]
-    end
-
-    #
-    def report_failure(testunit, exception)
-      puts "%12s  %s  %s" % [timer, red("FAILURE"), red("#{testunit}")]
-      puts
-      puts "        FAIL #{exception.backtrace[0]}"
-      puts "        #{exception}"
-      puts
-    end
-
-    #
-    def report_error(testunit, exception)
-      puts "%12s  %s  %s" % [timer, red("ERRORED"), red("#{testunit}")]
-      puts
-      puts "        ERROR #{exception.backtrace[0]}"
-      puts "        #{exception}"
-      puts
-    end
-
-    #
-    def report_pending(testunit, exception)
-      puts "%12s  %s  %s" % [timer, yellow("PENDING"), yellow("#{testunit}")]
-      #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
-
-=begin
-      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
-=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
-
-    #
-    def timer
-      secs  = Time.now - @time
-      @time = Time.now
-      return "%0.5fs" % [secs.to_s]
-    end
-
-    #
-    def timer_reset
-      @time = Time.now
-    end
-
-  end
-
-end
-end
-

data/lib/lemon/runner.rb

@@ -1,308 +0,0 @@
-module Lemon
-
-  require 'ae'
-  require 'ae/expect'
-  require 'ae/should'
-
-  require 'lemon/kernel'
-  require 'lemon/test/suite'
-  require 'lemon/reporter'
-
-  #
-  class Runner
-
-    # Test suite to run.
-    attr :suite
-
-    # Report format.
-    attr :format
-
-    # Record of successful tests.
-    attr :successes
-
-    # Record of failed tests.
-    attr :failures
-
-    # Record of errors.
-    attr :errors
-
-    # Record of pending tests.
-    attr :pendings
-
-    # New Runner.
-    def initialize(suite, options={})
-      @suite     = suite
-      @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)
-
-      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 Pending => exception
-              reporter.report_pending(testunit, exception)
-              pendings << [testunit, exception]
-            rescue Assertion => exception
-              reporter.report_failure(testunit, exception)
-              failures << [testunit, exception]
-            rescue Exception => exception
-              reporter.report_error(testunit, exception)
-              errors << [testunit, exception]
-            end
-            run_postest_procedures(testunit, suite, testcase)
-          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
-
-    #
-    #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
-
-=begin
-    #
-    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
-=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)
-      suite.when_clauses.each do |match, block|
-        if match.nil? or match === concern.to_s
-          block.call(testcase)
-        end
-      end
-      testcase.when_clauses.each do |match, block|
-        if match.nil? or match === concern.to_s
-          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 testunit.match?(match)
-          block.call(testunit)
-        end
-      end
-      testcase.before_clauses.each do |match, block|
-        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 testunit.match?(match)
-          block.call(testunit)
-        end
-      end
-      suite.after_clauses.each do |match, block|
-        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
-