lemon 0.6 → 0.7.0

data/lib/lemon/{commands → command}/test.rb

@@ -1,12 +1,13 @@
 module Lemon
-module Commands
+module Command
+  require 'lemon/command/abstract'
 
   # Lemon Test Command-line tool.
-  class Test < Command
+  class Test < Abstract
     require 'lemon/runner'
 
-    def self.options
-      []
+    def self.subcommand
+      'test'
     end
 
     # Initialize and run.
@@ -17,13 +18,18 @@ module Commands
     # New Command instance.
     def initialize
       @format      = nil
+      @cover       = false
       @requires    = []
       @includes    = []
+      @namespaces  = []
     end
 
     #
     attr_accessor :format
 
+    #
+    attr_accessor :cover
+
     # Get or set librarires to pre-require.
     def requires(*paths)
       @requires.concat(paths) unless paths.empty?
@@ -36,16 +42,33 @@ module Commands
       @includes
     end
 
+    #
+    def namespaces(*names)
+      @namespaces.concat(names) unless names.empty?
+      @namespaces
+    end
+
     # Instance of OptionParser.
     def parser
       @parser ||= OptionParser.new do |opt|
+        opt.banner = "lemon [options] [test-files ...]"
         opt.separator("Run unit tests.")
+        opt.separator("OPTIONS:")
+        opt.on('--coverage', '-c', "include coverage informarton") do
+          self.cover = true
+        end
         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('--outline', '-o', "select outline report format") do |type|
+          self.format = :outline
+        end
+        opt.on('--format', '-f [TYPE]', "select report format") do |type|
+          self.format = type
+        end
+        opt.on("--namespace", "-n [NAME]", "limit testing to this namespace") do |name|
+          namespaces(name)
+        end
         opt.on("-r [FILES]" , 'library files to require') do |files|
           files = files.split(/[:;]/)
           requires(*files)
@@ -70,14 +93,12 @@ module Commands
 
       files = ARGV.dup
 
-      includes.each do |path|
-        $LOAD_PATHS.unshift(path)
-      end
-
+      includes.each{ |path| $LOAD_PATH.unshift(path) }
       requires.each{ |path| require(path) }
 
-      suite  = Lemon::Test::Suite.new(*files)
-      runner = Lemon::Runner.new(suite, format)
+      suite  = Lemon::Test::Suite.new(files, :cover=>cover)
+      runner = Lemon::Runner.new(suite, :format=>format, :cover=>cover, :namespaces=>namespaces)
+
       runner.run
     end
 

data/lib/lemon/coverage.rb

@@ -1,33 +1,63 @@
+require 'lemon/snapshot'
+
 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 :conical
+    ## 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(files, namespaces=nil, options={})
-      @namespaces = namespaces || []
-
-      @files   = files
-      @conical = snapshot
+    def initialize(suite, namespaces=nil, options={})
+      @namespaces = [namespaces].flatten.compact
+      @suite = suite
+      @files = suite.files
+      #@canonical = @suite.canonical
+      @public = options[:public]
+    end
 
-      @public  = options[:public]
+    ##
+    #def canonical!
+    #  @canonical = Snapshot.capture
+    #end
 
-      # this must come after concial snapshot
-      @suite   = Test::Suite.new(files)
+    #
+    def suite=(suite)
+      raise ArgumentError unless Test::Suite === suite
+      @suite = suite
     end
 
     # Over use public methods for coverage.
@@ -35,37 +65,37 @@ module Lemon
       @public
     end
 
+    #
+    def each(&block)
+      checklist.each(&block)
+    end
+
     # Produce a coverage map.
-    def coverage(suite)
-      checklist = cover()
+    #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|
-          checklist[testcase.target.name][testunit.target.to_s] = true
+          list[testcase.target.name][testunit.key] = true
         end
       end
-      checklist
+      list
     end
 
-    # Coverage template.
-    def cover
-      cover = Hash.new{|h,k|h[k]={}}
-      system.each do |base|
-        next if base.is_a?(Lemon::Test::Suite)
-        cover[base.name] = {}
-        base.public_instance_methods(false).each do |meth|
-          cover[base.name][meth.to_s] = false
-        end
-        unless public_only?
-          base.private_instance_methods(false).each do |meth|
-            cover[base.name][meth.to_s] = false
-          end
-          base.protected_instance_methods(false).each do |meth|
-            cover[base.name][meth.to_s] = false
-          end
-        end
-      end
-      cover
-    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
@@ -80,57 +110,137 @@ module Lemon
     #  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 filters out
-    # the namespace.
+#    # 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
+
     #
-    # TODO: Perhaps get rid of the conical subtraction and require a namespace?
     def system
       if namespaces.empty?
-        snapshot - conical
+        suite.coverage
       else
-        snapshot.select do |m|
-          namespaces.any?{ |n| m.name.start_with?(n) }
+        suite.coverage.filter do |ofmod|
+          namespaces.any?{ |n| ofmod.name.start_with?(n.to_s) }
         end
       end
     end
 
-    # Produces a list of all existent Modules and Classes.
-    def snapshot
-      sys = []
-      #ObjectSpace.each_object(Class) do |c|
-      #  sys << c
-      #end
-      ObjectSpace.each_object(Module) do |m|
-        sys << m
+    # 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
-      sys
-    end
 
-    # TODO: combine with coverage to provided option to do only do what hasn't been covered thus far.
-    # TODO: support output directory
+      code.join("\n")
+    end
 
-    def generate(output=nil)
+    #
+    def generate_uncovered(output=nil)
       code = []
-      system.each do |base|
-        next if base.is_a?(Lemon::Test::Suite)
+      checklist.each do |base, methods|
+        next if /Lemon::Test::Suite/ =~ base.to_s
         code << "TestCase #{base} do"
-        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"
+        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/dsl.rb

@@ -28,12 +28,25 @@ end
 def Case(target_class, &block)
   Lemon.suite.Case(target_class, &block)
 end
-
 alias :TestCase :Case
 
+#
+def Covers(script)
+  Lemon.suite.Covers(script)
+end
+
+#
+def Helper(script)
+  Lemon.suite.Helper(script)
+end
+
+#def Subtest(script)
+#  Lemon.suite.Subtest(script)
+#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
+# Because 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.
 #

data/lib/lemon/kernel.rb

@@ -2,19 +2,23 @@ require 'facets/functor'
 
 $PRY_TABLE = {} #Hash.new{|h,k| h[k]=nil}
 
-# 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.
+module Kernel
 
-def pry
-  $PRY_TABLE[self] ||= Functor.new do |op, *a, &b|
-    __send__(op, *a, &b)
+  # 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