lemon 0.8.1 → 0.8.2

data/lib/lemon/snapshot.rb

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

@@ -1,139 +0,0 @@
-module Lemon::Test
-
-  require 'lemon/test/concern'
-  require 'lemon/test/unit'
-
-  # Test Case encapsulates a collection of 
-  # unit tests organized into groups of concern.
-  class Case
-
-    # The test suite to which this testcase belongs.
-    attr :suite
-
-    # A testcase +target+ is a class or module.
-    attr :target
-
-    #
-    attr :testunits
-
-    # List of before procedures that apply case-wide.
-    attr :before_clauses
-
-    # List of after procedures that apply case-wide.
-    attr :after_clauses
-
-    # List of concern procedures that apply case-wide.
-    attr :when_clauses
-
-    # A test case +target+ is a class or module.
-    def initialize(suite, target, &block)
-      @suite          = suite
-      @target         = target
-      @testunits      = []
-      @concerns       = []
-      @before_clauses = {}
-      @after_clauses  = {}
-      @when_clauses   = {}
-      instance_eval(&block)
-    end
-
-    # Load a helper script applicable to this test case.
-    def helper(file)
-      instance_eval(File.read(file), file)
-    end
-
-    # NOTE: Due to a limitation in Ruby this does not
-    # provived access to submodules. A hack has been used
-    # to circumvent. See Suite.const_missing.
-    def include(*mods)
-      extend *mods
-    end
-
-    # Define a new test concern for this case.
-    # TODO: Probably will deprecate the &setup procedure (YAGNI).
-    def Concern(*description, &setup)
-      concern = Concern.new(self, description, &setup)
-      @concerns << concern
-    end
-
-    alias_method :concern, :Concern
-
-    # The last defined concern. Used to assign new unit tests.
-    def current_concern
-      if @concerns.empty?
-        @concerns << Concern.new(self)
-      end
-      @concerns.last
-    end
-
-    # Iterate over each test concern.
-    def each(&block)
-      @concerns.each(&block)
-    end
-
-    # Define a unit test for this case.
-    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, :aspect=>target_concern, &block)
-      end
-      targets.each do |target_method|
-        @testunits << Unit.new(current_concern, target_method, &block)
-      end
-    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(*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(*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.
-    def When(match=nil, &block)
-      @when_clauses[match] = block #<< Advice.new(match, &block)
-    end
-
-    #
-    #def pending
-    #  raise Pending
-    #end
-
-    #
-    def to_s
-      target.to_s.sub(/^\#\<.*?\>::/, '')
-    end
-  end
-
-end
-
-class Pending < Assertion
-  def self.to_proc; lambda{ raise self }; end
-end
-

data/lib/lemon/test/concern.rb

@@ -1,52 +0,0 @@
-module Lemon::Test
-
-  # Test Concerns are used to organize unit tests
-  # in groups, so as to address specific quality
-  # assurance objectives.
-  class Concern
-
-    # The test case to which this concern belongs.
-    attr :testcase
-
-    # The description of this concern. Make this
-    # as detailed as you wish.
-    attr :description
-
-    # Unit tests that belong to this concern.
-    attr :testunits
-
-    # Setup procedure for concern.
-    attr :setup
-
-    # New concern.
-    def initialize(testcase, *description, &setup)
-      @testcase    = testcase
-      @description = description.join("\n")
-      @setup       = setup
-      @testunits   = []
-    end
-
-    # Assign a unit test to this concern.
-    def assign(testunit)
-      raise ArgumentError unless Unit === testunit
-      @testunits << testunit
-    end
-
-    # Iterate through each test unit.
-    def each(&block)
-      @testunits.each(&block)
-    end
-
-    # Returns the description with newlines removed.
-    def to_s
-      description.gsub(/\n/, ' ')
-    end
-
-    #
-    def call
-      setup.call if setup
-    end
-
-  end
-
-end

data/lib/lemon/test/suite.rb

@@ -1,229 +0,0 @@
-module Lemon
-module Test
-
-  require 'lemon/test/case'
-  require 'lemon/dsl'
-
-  # Test Suites encapsulate a set of test cases.
-  #
-  class Suite
-
-    # Files from which the suite is loaded.
-    attr :files
-
-    # Test cases in this suite.
-    attr :testcases
-
-    # List of concern procedures that apply suite-wide.
-    attr :when_clauses
-
-    # List of pre-test procedures that apply suite-wide.
-    attr :before_clauses
-
-    # 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
-
-    #
-    #attr :options
-
-    #
-    def initialize(files, options={})
-      @files          = files.flatten
-      @options        = options
-
-      #@subtest        = []
-      @testcases      = []
-      @before_clauses = {}
-      @after_clauses  = {}
-      @when_clauses   = {}
-
-      #load_helpers
-
-      @coverage  = Snapshot.new
-      @canonical = Snapshot.capture
-
-      load_files
-      #load_subtest_helpers
-    end
-
-    #
-    def cover?
-      @options[:cover]
-    end
-
-    #
-    def cover_all?
-      @options[:cover_all]
-    end
-
-    #
-    #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
-
-    #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)
-        if cover_all?
-          Covers(file)
-        else
-          require(file) #load(file)
-        end
-      end
-
-      #if cover?
-      #  $stdout << "\n"
-      #  $stdout.flush
-      #end
-
-      return Lemon.suite
-    end
-
-    # 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)
-    #end
-
-    # Includes at the suite level are routed to the toplevel.
-    def include(*mods)
-      TOPLEVEL_BINDING.eval('self').instance_eval do
-        include(*mods)
-      end
-    end
-
-    # 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.
-    def Before(match=nil, &block)
-      @before_clauses[match] = block #<< Advice.new(match, &block)
-    end
-
-    #alias_method :before, :Before
-
-    # Define a post-test procedure to apply suite-wide.
-    def After(match=nil, &block)
-      @after_clauses[match] = block #<< Advice.new(match, &block)
-    end
-
-    #alias_method :after, :After
-
-    # Define a concern procedure to apply suite-wide.
-    def When(match=nil, &block)
-      @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)
-    end
-
-  end
-
-end
-end
-