lemon 0.8.1 → 0.8.2

data/lib/lemon/coverage.rb

@@ -1,260 +0,0 @@
-require 'lemon/snapshot'
-require 'lemon/coversheet/outline'
-
-module Lemon
-
-  #
-  class Coverage
-
-    #
-    attr :suite
-
-    # 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 :canonical
-
-    #
-    attr :namespaces
-
-    ## New Coverage object.
-    ##
-    ##   Coverage.new('lib/', :MyApp, :public => true)
-    ##
-    #def initialize(suite_or_files, namespaces=nil, options={})
-    #  @namespaces = namespaces || []
-    #  case suite_or_files
-    #  when Test::Suite
-    #    @suite = suite_or_files
-    #    @files = suite_or_files.files
-    #  else
-    #    @suite = Test::Suite.new(suite_or_files)
-    #    @files = suite_or_files
-    #  end
-    #  #@canonical = @suite.canonical
-    #  @public    = options[:public]
-    #end
-
-    # New Coverage object.
-    #
-    #   Coverage.new('lib/', :MyApp, :public => true)
-    #
-    def initialize(suite, namespaces=nil, options={})
-      @namespaces = [namespaces].flatten.compact
-      @suite = suite
-      @files = suite.files
-      #@canonical = @suite.canonical
-      @public = options[:public]
-    end
-
-    ##
-    #def canonical!
-    #  @canonical = Snapshot.capture
-    #end
-
-    #
-    def suite=(suite)
-      raise ArgumentError unless Test::Suite === suite
-      @suite = suite
-    end
-
-    # Over use public methods for coverage.
-    def public_only?
-      @public
-    end
-
-    #
-    def each(&block)
-      checklist.each(&block)
-    end
-
-    # Produce a coverage map.
-    #def checklist
-    #  list = system.checklist
-    #  suite.each do |testcase|
-    #    testcase.testunits.each do |testunit|
-    #      list[testcase.target.name][testunit.key] = true
-    #    end
-    #  end
-    #  list
-    #end
-
-    # Produce a coverage checklist.
-    def checklist
-      list = system.checklist
-      suite.each do |testcase|
-        testcase.testunits.each do |testunit|
-          list[testcase.target.name][testunit.key] = true
-        end
-      end
-      list
-    end
-
-    #
-    def format(type)
-      coversheet = nil
-      case type
-      when :verbose
-        puts checklist.to_yaml
-      else
-        coversheet = CoverSheet::Outline.new(self)
-        coversheet.coverage_finished
-      end
-    end
-
-    #def load_covered_files
-    #  suite.load_covered_files
-    #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
-
-    #    # Snapshot of System to be covered. This takes a current snapshot
-    #    # of the system and removes the canonical snapshot or filters out
-    #    # everything but the selected namespace.
-    #    def system
-    #      if namespaces.empty?
-    #        snapshot - canonical
-    #      else
-    #        (snapshot - canonical).filter do |ofmod|
-    #          namespaces.any?{ |n| ofmod.name.start_with?(n.to_s) }
-    #        end
-    #      end
-    #    end
-
-    # List of modules/classes not covered.
-    def uncovered_cases
-      c = suite.coverage.map{ |ofmod| ofmod.base }
-      a = suite.testcases.map{ |tc| tc.target }
-      c - a
-    end
-
-    # List of methods not covered by covered cases.
-    def uncovered_units
-      @calculated ||= calculate_coverage
-      @uncovered_units
-    end
-
-    #
-    def undefined_units
-      @calculated ||= calculate_coverage
-      @undefined_units
-    end
-
-    #
-    def calculate_coverage
-      clist = []
-      tlist = []
-      suite.testcases.each do |tc|
-        mod = tc.target
-
-        metaunits, units = *tc.testunits.partition{ |u| u.meta? }
-
-        units.map!{ |u| u.fullname }
-        metaunits.map!{ |u| u.fullname }
-
-        tlist = tlist | units
-        tlist = tlist | metaunits
-
-        if system[mod]
-          meths = system[mod].instance_methods.map{ |m| "#{mod}##{m}" }
-          metameths = system[mod].class_methods.map{ |m| "#{mod}.#{m}" }
-
-          clist = clist | meths
-          clist = clist | metameths
-        end
-      end
-
-      @uncovered_units = clist - tlist
-      @undefined_units = tlist - clist
-    end
-
-    #
-    def system
-      if namespaces.empty?
-        suite.coverage
-      else
-        suite.coverage.filter do |ofmod|
-          namespaces.any?{ |n| ofmod.name.start_with?(n.to_s) }
-        end
-      end
-    end
-
-    # Generate code template.
-    #
-    # TODO: support output
-    def generate(output=nil)
-      code = []
-
-      system.each do |ofmod|
-        next if ofmod.base.is_a?(Lemon::Test::Suite)
-
-        code << "TestCase #{ofmod.base} do"
-
-        ofmod.class_methods(public_only?).each do |meth|
-          code << "\n  MetaUnit :#{meth} => '' do\n    raise Pending\n  end"
-        end
-
-        ofmod.instance_methods(public_only?).each do |meth|
-          code << "\n  Unit :#{meth} => '' do\n    raise Pending\n  end"
-        end
-
-        code << "\nend\n"
-      end
-
-      code.join("\n")
-    end
-
-    #
-    def generate_uncovered(output=nil)
-      code = []
-      checklist.each do |base, methods|
-        next if /Lemon::Test::Suite/ =~ base.to_s
-        code << "TestCase #{base} do"
-        methods.each do |meth, covered|
-          next if covered
-          if meth.to_s =~ /^\:\:/
-            meth = meth.sub('::','')
-            code << "\n  MetaUnit :#{meth} => '' do\n    raise Pending\n  end"
-          else
-            code << "\n  Unit :#{meth} => '' do\n    raise Pending\n  end"
-          end
-        end
-        #base.public_instance_methods(false).each do |meth|
-        #  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"
-        #  end
-        #  base.protected_instance_methods(false).each do |meth|
-        #    code << "\n  Unit :#{meth} => '' do\n    Pending\n  end"
-        #  end
-        #end
-        code << "\nend\n"
-      end
-      code.join("\n")
-    end
-
-    # Get a snapshot of the system.
-    def snapshot
-      Snapshot.capture
-    end
-
-  end#class Coverage
-
-end#module Lemon
-

data/lib/lemon/coversheet/outline.rb

@@ -1,47 +0,0 @@
-require 'lemon/coversheet/abstract'
-
-module Lemon
-module CoverSheet
-
-  class Outline < Abstract
-
-    #
-    def coverage_finished
-
-      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
-
-      puts
-      puts tally
-    end
-
-  end
-
-end
-end
-

data/lib/lemon/kernel.rb

@@ -1,24 +0,0 @@
-require 'facets/functor'
-
-$PRY_TABLE = {} #Hash.new{|h,k| h[k]=nil}
-
-module Kernel
-
-  # Pry allows you to test private and protected methods,
-  # via a public-only interface.
-  #
-  # Generally one should avoid testing private and protected
-  # method directly, instead relying on tests of public methods to
-  # indirectly test them, because private and protected methods are
-  # considered implementation details. But sometimes is necessary
-  # to test them directly, or if you wish to achieve *absolute
-  # coverage*, say in mission critical systems.
-
-  def pry
-    $PRY_TABLE[self] ||= Functor.new do |op, *a, &b|
-      __send__(op, *a, &b)
-    end
-  end
-
-end
-

data/lib/lemon/reporter.rb

@@ -1,22 +0,0 @@
-require 'lemon/reporter/dotprogress'
-require 'lemon/reporter/outline'
-require 'lemon/reporter/verbose'
-
-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
-  end
-
-end
-end

data/lib/lemon/reporter/abstract.rb

@@ -1,97 +0,0 @@
-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 cyan(string)
-      @ansicolor ? ANSI::Code.cyan{ 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
-