lemon 0.6 → 0.7.0

data/lib/lemon/snapshot.rb

@@ -0,0 +1,185 @@
+module Lemon
+
+  #
+  class Snapshot
+    include Enumerable
+
+    #
+    def self.capture
+      o = new
+      o.capture
+      o
+    end
+
+    #
+    attr :modules
+
+    #
+    def initialize
+      @modules = {}
+    end
+
+    #
+    def each(&block)
+      modules.values.each(&block)
+    end
+
+    #
+    def size
+      modules.size
+    end
+
+    #
+    def [](mod)
+      @modules[mod]
+    end
+
+    #
+    def []=(mod, ofmod)
+      @modules[mod] = ofmod
+    end
+
+    #
+    def capture
+      @modules = {}
+      ObjectSpace.each_object(Module) do |mod|
+        next if mod.name.empty?
+        @modules[mod] = OfModule.new(mod)
+      end
+    end
+
+    #
+    def to_a(public_only=true)
+      modules.values.map{ |m| m.to_a(public_only) }.flatten
+    end
+
+    # Produce a hash based checklist thap mod #.namet Coverage uses
+    # to compare against tests and create a coverage report.
+    def checklist(public_only=true)
+      h = Hash.new{|h,k|h[k]={}}
+      modules.values.each do |mod|
+        mod.class_methods(public_only).each do |meth|
+          h[mod.name]["::#{meth}"] = false
+        end
+        mod.instance_methods(public_only).each do |meth|
+          h[mod.name]["#{meth}"] = false
+        end
+      end
+      h
+    end
+
+    #
+    def -(other)
+      c = Snapshot.new
+      modules.each do |mod, ofmod|
+        c[mod] = ofmod.dup
+      end
+      other.modules.each do |mod, ofmod|
+        if c[mod]
+          c[mod].public_instance_methods -= ofmod.public_instance_methods
+          c[mod].private_instance_methods -= ofmod.private_instance_methods
+          c[mod].protected_instance_methods -= ofmod.protected_instance_methods
+
+          c[mod].public_class_methods -= ofmod.public_class_methods
+          c[mod].private_class_methods -= ofmod.private_class_methods
+          c[mod].protected_class_methods -= ofmod.protected_class_methods
+        end
+      end
+      c.clean!
+      return c
+    end
+
+    #
+    def <<(other)
+      other.modules.each do |mod, ofmod|
+        if self[mod]
+          self[mod].public_instance_methods += ofmod.public_instance_methods
+          self[mod].private_instance_methods += ofmod.private_instance_methods
+          self[mod].protected_instance_methods += ofmod.protected_instance_methods
+
+          self[mod].public_class_methods += ofmod.public_class_methods
+          self[mod].private_class_methods += ofmod.private_class_methods
+          self[mod].protected_class_methods += ofmod.protected_class_methods
+        else
+          self[mod] = ofmod.dup
+        end
+      end     
+    end
+
+    #
+    def clean!
+      modules.each do |mod, ofmod|
+        if ofmod.class_methods(false).empty? && ofmod.instance_methods(false).empty?
+          modules.delete(mod)
+        end
+      end
+    end
+
+    #
+    def filter(&block)
+      c = Snapshot.new
+      modules.each do |mod, ofmod|
+        if block.call(ofmod)
+          c[mod] = ofmod
+        end
+      end
+      c
+    end
+
+    #
+    class OfModule
+      attr :base
+
+      attr_accessor :public_instance_methods
+      attr_accessor :protected_instance_methods
+      attr_accessor :private_instance_methods
+
+      attr_accessor :public_class_methods
+      attr_accessor :protected_class_methods
+      attr_accessor :private_class_methods
+
+      #
+      def initialize(base)
+        @base = base
+
+        @public_instance_methods    = base.public_instance_methods(false)
+        @protected_instance_methods = base.protected_instance_methods(false)
+        @private_instance_methods   = base.private_instance_methods(false)
+
+        @public_class_methods    = base.methods(false)
+        @protected_class_methods = base.protected_methods(false)
+        @private_class_methods   = base.private_methods(false)
+      end
+
+      #
+      def name
+        @base.name
+      end
+
+      #
+      def instance_methods(public_only=true)
+        if public_only
+          public_instance_methods
+        else
+          public_instance_methods + private_instance_methods + protected_instance_methods
+        end
+      end
+
+      #
+      def class_methods(public_only=true)
+        if public_only
+          public_class_methods
+        else
+          public_class_methods + private_class_methods + protected_class_methods
+        end
+      end
+
+      #
+      def to_a(public_only=true)
+        class_methods(public_only).map{ |m| "#{name}.#{m}" } + instance_methods(public_only).map{ |m| "#{name}##{m}" }
+      end
+    end
+
+  end
+
+end

data/lib/lemon/test/case.rb

@@ -50,8 +50,9 @@ module Lemon::Test
     end
 
     # Define a new test concern for this case.
-    def Concern(*description)
-      concern = Concern.new(self, description)
+    # TODO: Probably will deprecate the &setup procedure (YAGNI).
+    def Concern(*description, &setup)
+      concern = Concern.new(self, description, &setup)
       @concerns << concern
     end
 
@@ -74,7 +75,7 @@ module Lemon::Test
     def Unit(*targets, &block)
       targets_hash = Hash===targets.last ? targets.pop : {}
       targets_hash.each do |target_method, target_concern|
-        @testunits << Unit.new(current_concern, target_method, target_concern, &block)
+        @testunits << Unit.new(current_concern, target_method, :aspect=>target_concern, &block)
       end
       targets.each do |target_method|
         @testunits << Unit.new(current_concern, target_method, &block)
@@ -82,16 +83,36 @@ module Lemon::Test
     end
     alias_method :unit, :Unit
 
+    # Define a meta-method unit test for this case.
+    def MetaUnit(*targets, &block)
+      targets_hash = Hash===targets.last ? targets.pop : {}
+      targets_hash.each do |target_method, target_concern|
+        @testunits << Unit.new(current_concern, target_method, :aspect=>target_concern, :metaclass=>true, &block)
+      end
+      targets.each do |target_method|
+        @testunits << Unit.new(current_concern, target_method, :metaclass=>true, &block)
+      end
+    end
+    alias_method :metaunit, :MetaUnit
+
     # Define a before procedure for this case.
-    def Before(match=nil, &block)
-      @before_clauses[match] = block #<< Advice.new(match, &block)
+    def Before(*matches, &block)
+      matches == [nil] if matches.empty?
+      matches.each do |match|
+        @before_clauses[match] = block #<< Advice.new(match, &block)
+      end
     end
+
     alias_method :before, :Before
 
     # Define an after procedure for this case.
-    def After(match=nil, &block)
-      @after_clauses[match] = block #<< Advice.new(match, &block)
+    def After(*matches, &block)
+      matches == [nil] if matches.empty?
+      matches.each do |match|
+        @after_clauses[match] = block #<< Advice.new(match, &block)
+      end
     end
+
     alias_method :after, :After
 
     # Define a concern procedure to apply case-wide.
@@ -100,9 +121,9 @@ module Lemon::Test
     end
 
     #
-    def pending
-      raise PendingAssertion
-    end
+    #def pending
+    #  raise Pending
+    #end
 
     #
     def to_s
@@ -112,6 +133,7 @@ module Lemon::Test
 
 end
 
-class PendingAssertion < Assertion
+class Pending < Assertion
+  def self.to_proc; lambda{ raise self }; end
 end
 

data/lib/lemon/test/concern.rb

@@ -15,10 +15,14 @@ module Lemon::Test
     # Unit tests that belong to this concern.
     attr :testunits
 
+    # Setup procedure for concern.
+    attr :setup
+
     # New concern.
-    def initialize(testcase, *description)
+    def initialize(testcase, *description, &setup)
       @testcase    = testcase
       @description = description.join("\n")
+      @setup       = setup
       @testunits   = []
     end
 
@@ -38,6 +42,11 @@ module Lemon::Test
       description.gsub(/\n/, ' ')
     end
 
+    #
+    def call
+      setup.call if setup
+    end
+
   end
 
 end

data/lib/lemon/test/suite.rb

@@ -8,6 +8,9 @@ module Test
   #
   class Suite
 
+    # Files from which the suite is loaded.
+    attr :files
+
     # Test cases in this suite.
     attr :testcases
 
@@ -20,46 +23,120 @@ module Test
     # List of post-test procedures that apply suite-wide.
     attr :after_clauses
 
+    ## A snapshot of the system before the suite is loaded.
+    #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
+
+    def coverage
+      @final_coveage ||= @coverage - @canonical
+    end
+
     #
-    def initialize(*files)
+    #attr :options
+
+    #
+    def initialize(files, options={})
+      @files          = files.flatten
+      @options        = options
+
+      #@subtest        = []
       @testcases      = []
       @before_clauses = {}
       @after_clauses  = {}
       @when_clauses   = {}
 
-      loadfiles(*files)
+      #load_helpers
+
+      @coverage  = Snapshot.new
+      @canonical = Snapshot.capture
+
+      load_files
+      #load_subtest_helpers
     end
 
     #
-    def loadfiles(*files)
-      Lemon.suite = self
+    def cover?
+      @options[:cover]
+    end
 
-      # directories glob *.rb files
-      files = files.flatten.map do |file|
-        if File.directory?(file)
-          Dir[File.join(file, '**', '*.rb')]
-        else
-          file
-        end
-      end.flatten.uniq
+    #
+    #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
 
-      files.each do |file|
+    #def load_subtest_helpers
+    #  helpers = []
+    #  @subtest.each do |file|
+    #    dir = File.dirname(file)
+    #    hlp = Dir[File.join(dir, '{test_,}helper.rb')]
+    #    helpers.concat(hlp)
+    #  end
+    #
+    #  #s = Snapshot.capture
+    #  helpers.each do |hlp|
+    #    require hlp
+    #  end
+    #  #z = Snapshot.capture
+    #  #d = z - s
+    #  #@canonical << d
+    #end
+
+    #
+    def load_files #(*files)
+      #if cover?
+      #  $stdout << "Load: "
+      #end
+
+      Lemon.suite = self
+      filelist.each do |file|
+        #@current_file = file
         #file = File.expand_path(file)
         #instance_eval(File.read(file), file)
-        load(file)
+        require(file) #load(file)
       end
 
+      #if cover?
+      #  $stdout << "\n"
+      #  $stdout.flush
+      #end
+
       return Lemon.suite
     end
 
-    # Load a helper. This method must be used when loading local
-    # suite support. The usual #require or #load can only be used
-    # for extenal support libraries (such as a test mock framework).
-    # This is so because suite code is not evaluated at the toplevel.
-    def helper(file)
-      instance_eval(File.read(file), file)
+    # Directories glob *.rb files.
+    def filelist
+      @filelist ||= (
+        @files.flatten.map do |file|
+          if File.directory?(file)
+            Dir[File.join(file, '**', '*.rb')]
+          else
+            file
+          end
+        end.flatten.uniq
+      )
     end
 
+    ## Load a helper. This method must be used when loading local
+    ## suite support. The usual #require or #load can only be used
+    ## for extenal support libraries (such as a test mock framework).
+    ## This is so because suite code is not evaluated at the toplevel.
+    #def helper(file)
+    #  instance_eval(File.read(file), file)
+    #end
+
     #
     #def load(file)
     #  instance_eval(File.read(file), file)
@@ -74,13 +151,12 @@ module Test
 
     # Define a test case belonging to this suite.
     def Case(target_class, &block)
+      raise "lemon: case target must be a class or module" unless Module === target_class
       testcases << Case.new(self, target_class, &block)
     end
 
     #
     alias_method :TestCase, :Case
-
-    #
     #alias_method :testcase, :Case
 
     # Define a pre-test procedure to apply suite-wide.
@@ -102,6 +178,36 @@ module Test
       @when_clauses[match] = block #<< Advice.new(match, &block)
     end
 
+    # TODO: need require_find() to avoid first snapshot
+    def Covers(file)
+      if cover?
+        #return if $".include?(file)
+        s = Snapshot.capture
+        if require(file)
+          z = Snapshot.capture
+          @coverage << (z - s)
+        end
+      else
+        require file
+      end
+    end
+
+    #
+    def Helper(file)
+      local = File.join(File.dirname(caller[1]), file.to_str + '.rb')
+      if File.exist?(local)
+        require local
+      else
+        require file
+      end
+    end
+
+    #
+    #def Subtest(file)
+    #  @subtest << file
+    #  require file
+    #end
+
     # Iterate through this suite's test cases.
     def each(&block)
       @testcases.each(&block)