lemon 0.9.0 → 0.9.1

data/work/deprecated/model/test_suite.rb

@@ -1,297 +0,0 @@
-require 'lemon/model/test_case'
-require 'lemon/model/test_method'
-require 'lemon/model/test_module'
-require 'lemon/model/test_feature'
-require 'lemon/model/snapshot'
-#require 'lemon/model/main'
-require 'lemon/core_ext/kernel'
-
-module Lemon
-
-  # Current suite being defined. This is used
-  # to define a Suite object via the toplevel DSL.
-  def self.suite
-    $lemon_suite #@suite ||= Lemon::TestSuite.new([])
-  end
-
-  #
-  def self.suite=(suite)
-    $lemon_suite = suite
-  end
-
-  # Test Suites encapsulate a set of test cases.
-  #
-  class TestSuite
-
-    # Files from which the suite is loaded.
-    attr :files
-
-    # Test cases in this suite.
-    attr :cases
-
-    # List of pre-test procedures that apply suite-wide.
-    attr :before
-
-    # List of post-test procedures that apply suite-wide.
-    attr :after
-
-    # A snapshot of the system before the suite is loaded.
-    # Only set if +cover+ option is true.
-    #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
-
-    #attr :current_file
-
-    #def coverage
-    #  @final_coveage ||= @coverage - @canonical
-    #end
-
-    #
-    attr :options
-
-    attr :stack
-
-    attr :dsl
-
-    #
-    def initialize(files, options={})
-      @files   = files.flatten
-      @options = options
-
-      @cases   = []
-      @helpers = []
-
-      @before  = {}
-      @after   = {}
-
-      load_helpers
-
-      #if cover? or cover_all?
-      #  @coverage  = Snapshot.new
-      #  @canonical = Snapshot.capture
-      #end
-
-      @dsl = DSL.new(self) #, files)
-
-      load_files
-    end
-
-    #
-    def cover?
-      @options[:cover]
-    end
-
-    #
-    def cover_all?
-      @options[:cover_all]
-    end
-
-    #
-    #class Scope < Module
-    #  def initialize
-    #    extend self
-    #  end
-    #end
-
-    def to_a
-      @cases
-    end
-
-    # Iterate through this suite's test cases.
-    def each(&block)
-      @cases.each(&block)
-    end
-
-    #
-    def advice
-      @advice ||= TestAdvice.new
-    end
-
-    #
-    def subject
-      @subject
-    end
-
-=begin
-    #
-    def start_suite
-    end
-
-    #
-    def finish_suite
-    end
-=end
-
-    #
-    def scope
-      s = Object.new
-      s.extend(dsl)
-      s
-    end
-
-    # Automatically load helpers. Helpers are any *.rb script in
-    # a `helpers` directory, relative to a test script.
-    #
-    # TODO: You can change the file pattern used to automatically
-    # load helper scripts in `.lemon`.
-    #
-    def load_helpers
-      helpers = []
-      filelist.each do |file|
-        dir = File.dirname(file)
-        hlp = Dir[File.join(dir, 'helper{s,}/*.rb')]
-        helpers.concat(hlp)
-      end
-      helpers.uniq!
-      helpers.each do |hlp|
-        require File.expand_path(hlp)
-      end
-      @helpers = helpers
-    end
-
-    #
-    def load_files #(*files)
-      s = Lemon.suite || self
-      Lemon.suite = self
-
-      filelist.each do |file|
-        #load_file(file)
-        load file #require file
-      end
-
-      Lemon.suite = s
-
-      #if cover?
-      #  $stdout << "\n"
-      #  $stdout.flush
-      #end
-
-      self #return Lemon.suite
-    end
-
-    #
-    #def load_file(file)
-    #  #@current_file = file
-    #  #if cover_all?
-    #  #  Covers(file)
-    #  #else
-    #    file = File.expand_path(file)
-    #    @dsl.module_eval(File.read(file), file)
-    #    #require(file) #load(file)
-    #  #end
-    #end
-
-    # Directories glob *.rb files.
-    def filelist
-      @filelist ||= (
-        files = @files
-        files = files.map{ |f| Dir[f] }.flatten
-        files = files.map do |file|
-          if File.directory?(file)
-            Dir[File.join(file, '**', '*.rb')]
-          else
-            file
-          end
-        end.flatten
-        #files = files.map{ |f| File.expand_path(f) }
-        files.uniq
-        files.reject{ |f| /fixture(|s)\/(.*?)\.rb$/ =~ f }
-        files.reject{ |f| /helper(|s)\/(.*?)\.rb$/ =~ f }
-      )
-    end
-
-    # TODO: Note sure about scope creation here
-    def scope
-      @scope ||= (
-        scope = Object.new
-        scope.extend(dsl)
-      )
-    end
-
-    class DSL < Module
-      #
-      def initialize(suite)
-        @suite = suite
-        #module_eval(&code)
-      end
-
-      # TODO: need require_find() to avoid first snapshot ?
-      def covers(file)
-        #if @test_suite.cover?
-        #  #return if $".include?(file)
-        #  s = Snapshot.capture
-        #  if require(file)
-        #    z = Snapshot.capture
-        #    @test_suite.coverage << (z - s)
-        #  end
-        #else
-          require file
-        #end
-      end
-      alias_method :Covers, :covers
-
-      # Define a test case belonging to this suite.
-      def test_case(description, &block)
-        options = {
-         :description => description
-        }
-        @suite.cases << TestCase.new(@suite, options, &block)
-      end
-
-      #
-      alias_method :TestCase, :test_case
-
-      # Define a module test case belonging to this suite.
-      def test_module(target_module, &block)
-        raise "lemon: target must be a module" unless Module === target_module
-        options = {
-          :target => target_module
-        }
-        @suite.cases << TestModule.new(@suite, optios, &block)
-      end
-
-      # Define a class test case belonging to this suite.
-      def test_class(target_class, &block)
-        raise "lemon: case target must be a class" unless Class === target_class
-        options = {
-          :target => target_class
-        }
-        @suite.cases << TestModule.new(@suite, options, &block)
-      end
-
-      # Define a test feature.
-      def test_feature(target, &block)
-        options = {
-          :target => target
-        }
-        @suite.cases << TestFeature.new(@suite, options, &block)
-      end
-
-      # Define a pre-test procedure to apply suite-wide.
-      def before(*matches, &block)
-        @suite.before[matches] = block #<< Advice.new(match, &block)
-      end
-      alias_method :Before, :before
-
-      # Define a post-test procedure to apply suite-wide.
-      def after(*matches, &block)
-        @suite.after[matches] = block #<< Advice.new(match, &block)
-      end
-      alias_method :After, :after
-
-      # Includes at the suite level are routed to the toplevel.
-      #def include(*mods)
-      #  TOPLEVEL_BINDING.eval('self').instance_eval do
-      #    include(*mods)
-      #  end
-      #end
-
-    end
-
-  end
-
-end

data/work/deprecated/rake.rb

@@ -1,103 +0,0 @@
-require 'rake/tasklib'
-
-module Lemon
-
-  module Rake
-
-    # Define a lemon test rake task.
-    #
-    # The `TEST` environment variable can be used to select tests
-    # when using the task.
-    #
-    # TODO: The test task uses #fork. Maybe it should shell out instead?
-    class TestTask < ::Rake::TaskLib
-
-      #
-      DEFAULT_TESTS = [
-        'test/**/case_*.rb',
-        'test/**/*_case.rb',
-        'test/**/test_*.rb',
-        'test/**/*_test.rb'
-      ]
-
-      #
-      attr_accessor :tests
-
-      #
-      attr_accessor :loadpath
-
-      #
-      attr_accessor :requires
-
-      #
-      attr_accessor :namespaces
-
-      #
-      attr_accessor :format
-
-      #
-      def initialize(name='lemon:test', desc="run lemon tests", &block)
-        @name       = name
-        @desc       = desc
-
-        @loadpath   = ['lib']
-        @requires   = []
-        @tests      = [ENV['TEST']] || DEFAULT_TESTS
-        @format     = nil
-        @namespaces = []
-
-        block.call(self)
-
-        define_task
-      end
-
-      #
-      def define_task
-        desc @desc
-        task @name do
-          require 'open3'
-
-          @tests ||= (
-            if ENV['tests']
-              ENV['tests'].split(/[:;]/)
-            else
-              DEFAULT_TESTS
-            end
-          )
-
-          run
-        end
-      end
-
-      #
-      def run
-        fork {
-          #require 'lemon'
-          require 'lemon/controller/test_runner'
-          loadpath.each do |path|
-            $LOAD_PATH.unshift(path)
-          end
-          requires.each do |file|
-            require file
-          end
-          runner = Lemon::TestRunner.new(
-            tests,
-            :format => format,
-            :namespaces => namespaces
-          )
-          success = runner.run
-          exit -1 unless success
-        }
-        Process.wait
-      end
-
-      #
-      #def ruby_command
-      #  File.join(RbConfig::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
-      #end
-
-    end
-
-  end
-
-end

data/work/deprecated/test/case_coverage_analyzer.rb

@@ -1,25 +0,0 @@
-covers 'lemon/controller/coverage_analyzer'
-
-testcase Lemon::CoverageAnalyzer do
-
-  setup "Coverage of public units of an incomplete test" do
-    @memo_instance ||= (
-      files = ['test/fixtures/case_incomplete.rb']
-      Lemon::CoverageAnalyzer.new(files)
-    )
-  end
-
-  unit :covered => 'returns a list of covered units' do |ca|
-    ca.covered.assert.is_a?(Array)
-  end
-
-  unit :uncovered => 'returns a list of uncovered units' do |ca|
-    ca.uncovered.assert.is_a?(Array)
-  end
-
-  unit :current => 'returns a current Snapshot of all units in the system' do |ca|
-    ca.current.assert.is_a?(Lemon::Snapshot)
-  end
-
-end
-

data/work/deprecated/test/case_test_case_dsl.rb

@@ -1,46 +0,0 @@
-testcase Lemon::TestCase::DSL do
-
-  before do
-    @files = ['test/fixtures/case_inclusion.rb']
-  end
-
-  setup "Modules included in a test case are accessible by the unit tests" do
-    ts = Lemon::TestSuite.new(@files)
-    tc = ts.test_cases.first  # the only one
-    tc.dsl
-  end
-
-  unit :include, "allows access to module methods" do |dsl|
-    mod = Module.new{ def x; "x"; end }
-    dsl.include(mod)
-    # how to test?
-  end
-
-  # I do not think it is possible to make this work using dyanmic module
-  # construction. Please correct me if you know otherwise. To fix
-  # would mean turning test cases into classes instead of objects. Maybe
-  # we will do this in the future.
-  omit unit :include, "allows access to nested modules" do |dsl|
-    mod = Module.new{ N = 1 }
-    dsl.include(mod)
-    dsl::N == 1
-  end
-
-  setup "Test cases are augmented by before and afters procedures" do
-    ts = Lemon::TestSuite.new(@files)
-    tc = ts.test_cases.first  # the only one
-    tc.dsl
-  end
-
-  unit :before => "setup a pre-testcase procedure" do |dsl|
-    dsl.before{ }
-    # how to test?
-  end
-
-  unit :after => "setup a post-testcase procedure" do |dsl|
-    dsl.after{ }
-    # how to test?
-  end
-
-end
-