spekmachine 0.1.1 → 0.2.0

data/Rakefile

@@ -7,7 +7,7 @@ require 'rake/testtask'
 require 'rake/rdoctask'
 
 PKG_NAME = "spekmachine"
-PKG_VERSION   = '0.1.1'
+PKG_VERSION   = '0.2.0'
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 PKG_FILES = FileList[ '[A-Z]*', 'lib/**/*.rb' ]
 
@@ -31,7 +31,7 @@ spec = Gem::Specification.new do |s|
   s.author = "Michiel de Mare"
   s.homepage = "http://persia.rubyforge.org"
   s.rubyforge_project = "persia"
-  s.add_dependency 'rspec' , '= 0.6.3'
+  s.add_dependency 'rspec' , '= 0.7.5'
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/bin/spekm

@@ -1,20 +1,4 @@
 #!/usr/bin/env ruby
-require 'rubygems'
-require_gem 'rspec', '= 0.6.3'
-require File.expand_path(File.dirname(__FILE__) + "/../lib/spekmachine") # better stack traces this way
-
-$context_runner = ::Spec::Runner::OptionParser.create_context_runner(ARGV, false, STDERR, STDOUT)
-
-# If ARGV is a glob, it will actually each over each one of the matching files.
-ARGV.each do |file_or_dir|
-  if File.directory?(file_or_dir)
-    Dir["#{file_or_dir}/**/*.rb"].each do |file| 
-      require file
-    end
-  else
-    require file_or_dir
-  end
-end
-
-$context_runner.run(true)
-
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+require 'spekmachine'
+::Spec::Runner::CommandLine.run(ARGV, STDERR, STDOUT, true, true)

data/lib/spekmachine.rb

@@ -1,5 +1,7 @@
+require 'rubygems'
+require_gem 'rspec', '= 0.7.5'
 require 'spekmachine/runner/context'
 require 'spekmachine/runner/context_eval'
 require 'spekmachine/runner/context_runner'
-require 'spekmachine/runner/kernel_ext'
+require 'spekmachine/runner/extensions/kernel'
 require 'spekmachine/runner/path'

data/lib/spekmachine/runner/context.rb

@@ -17,33 +17,10 @@ module Spec
           @context_id
         end
 
-        def before_context_eval
-        end
-
-        def inherit(klass)
-          @context_eval_module.inherit klass
-        end
-
-        def include(mod)
-          @context_eval_module.include mod
-        end
-
         def goto(name, &block)
           @context_eval_module.goto(name, &block)
         end
 
-        def setup(&block)
-          @context_eval_module.setup(&block)
-        end
-
-        def teardown(&block)
-          @context_eval_module.teardown(&block)
-        end
-
-        def specify(spec_name, &block)
-          @context_eval_module.specify(spec_name, &block)
-        end
-
         def jump_to(name)
           goto_parts[name].call
         end
@@ -54,98 +31,21 @@ module Spec
 
         def run(reporter, dry_run=false)
           reporter.add_context(@name)
-
           prepare_execution_context_class
-          specifications.each do |specification|
-            execution_context = execution_context_class.new(specification)
-           #@exec_context.instance_variables.each {|v|
-           #  val = @exec_context.instance_variable_get(v)
-           #  execution_context.instance_variable_set v, val
-           #}
-            specification.run(reporter, nil, nil, dry_run, execution_context)
-          end
-        end
-
-        def number_of_specs
-          specifications.length
-        end
-
-        def matches? name, matcher=nil
-          matcher ||= SpecMatcher.new name, @name
-          specifications.each do |spec|
-            return true if spec.matches_matcher? matcher
-          end
-          return false
-        end
-
-        def run_single_spec name
-          return if @name == name
-          matcher = SpecMatcher.new name, @name
-          specifications.reject! do |spec|
-            !spec.matches_matcher? matcher
-          end
-        end
-
-        def methods
-          my_methods = super
-          my_methods |= @context_eval_module.methods
-          my_methods
-        end
+          errors = run_context_setup(reporter, dry_run)
 
-        protected
-
-        def method_missing(*args)
-          @context_eval_module.method_missing(*args)
-        end
-
-        def specifications
-          @context_eval_module.send :specifications
-        end
-
-        def setup_block
-          @context_eval_module.send :setup_block
-        end
-
-        def teardown_block
-          @context_eval_module.send :teardown_block
-        end
-
-        def setup_parts
-          @context_eval_module.send :setup_parts
-        end
-
-        def teardown_parts
-          @context_eval_module.send :teardown_parts
-        end
-
-        def prepare_execution_context_class
-          weave_in_context_modules
-          execution_context_class
-        end
-
-        def weave_in_context_modules
-          mods = context_modules
-          context_eval_module = @context_eval_module
-          execution_context_class.class_eval do
-            include context_eval_module
-            mods.each do |mod|
-              include mod
-            end
-          end
-        end
-
-        def context_modules
-          @context_eval_module.send :context_modules
-        end
-
-        def execution_context_class
-          @context_eval_module.send :execution_context_class
+          specifications.each do |specification|
+            specification_execution_context = execution_context(specification)
+            specification_execution_context.copy_instance_variables_from(@once_only_execution_context_instance, [:@spec]) unless context_setup_block.nil?
+            # only modification: setup_block & teardown_block are nil
+            specification.run(reporter, nil, nil, dry_run, specification_execution_context)
+          end unless errors.length > 0
+          
+          run_context_teardown(reporter, dry_run)
         end
 
-        def context_superclass
-          @context_eval_module.send :context_superclass
-        end
       end
+
       include InstanceMethods
     end
   end

data/lib/spekmachine/runner/context_eval.rb

@@ -2,119 +2,13 @@ module Spec
   module Runner
     module ContextEval
       module ModuleMethods
-        def inherit(klass)
-          @context_superclass = klass
-          derive_execution_context_class_from_context_superclass
-        end
-
-        def include(mod)
-          context_modules << mod
-        end
-
-        def setup(&block)
-          setup_parts << block
-        end
-
-        def teardown(&block)
-          teardown_parts << block
-        end
-
         def goto(name, &block)
           goto_parts[name] = block
         end
 
-        def specify(spec_name, &block)
-          specifications << Specification.new(spec_name, &block)
-        end
-
-        def methods
-          my_methods = super
-          my_methods |= context_superclass.methods
-          my_methods
-        end
-
         def goto_parts
           @goto_parts ||= {}
         end
-        
-        protected
-
-        def method_missing(method_name, *args)
-          if context_superclass.respond_to?(method_name)
-            return execution_context_class.send(method_name, *args)
-          end
-          super
-        end
-
-        def specifications
-          @specifications ||= []
-        end
-
-        def setup_parts
-          @setup_parts ||= []
-        end
-
-        def teardown_parts
-          @teardown_parts ||= []
-        end
-
-        def setup_block
-          parts = setup_parts.dup
-
-          setup_method = begin
-            context_superclass.instance_method(:setup)
-          rescue
-            nil
-          end
-          parts.unshift setup_method if setup_method
-          create_block_from_parts(parts)
-        end
-
-        def teardown_block
-          parts = teardown_parts.dup
-
-          teardown_method = begin
-            context_superclass.instance_method(:teardown)
-          rescue
-            nil
-          end
-          parts.unshift teardown_method if teardown_method
-          create_block_from_parts(parts)
-        end
-
-        def create_block_from_parts(parts)
-          proc do
-            parts.each do |part|
-              if part.is_a?(UnboundMethod)
-                puts part.inspect
-                part.bind(self).call
-              else
-                instance_exec(&part)
-              end
-            end
-          end
-        end
-
-        def execution_context_class
-          @execution_context_class ||= derive_execution_context_class_from_context_superclass
-        end
-
-        def derive_execution_context_class_from_context_superclass
-          @execution_context_class = Class.new(context_superclass)
-          @execution_context_class.class_eval do
-            include ::Spec::Runner::ExecutionContext::InstanceMethods
-          end
-        end
-
-        def context_superclass
-          @context_superclass ||= Object
-        end
-
-        def context_modules
-          @context_modules ||= []
-        end
-      end
-      module InstanceMethods
       end
     end
   end

data/lib/spekmachine/runner/context_runner.rb

@@ -3,26 +3,10 @@
 module Spec
   module Runner
     class ContextRunner
-      attr_reader :standalone
-      
-      def initialize(reporter, standalone, dry_run, single_spec=nil)
-        @contexts = []
-        @reporter = reporter
-        @standalone = standalone
-        @dry_run = dry_run
-        @single_spec = single_spec
-      end
-
       def set_start(name, block)
         @start_name = name
         @setup = block
       end
-    
-      def add_context(context)
-        return if !@single_spec.nil? unless context.matches?(@single_spec)
-        context.run_single_spec @single_spec if context.matches?(@single_spec)
-        @contexts << context
-      end
       
       def create_path(ctxMap)
         g = CPP.new
@@ -39,24 +23,33 @@ module Spec
         @setup.call
         cm = {}
         @contexts.each {|c| cm[c.context_id] = c }
-        @reporter.start(number_of_specs)
-        path = create_path(cm)
-        path.each do |ctx, dest|
-          ctx.run(@reporter, @dry_run)
-          ctx.jump_to dest
+        @options.reporter.start(number_of_specs)
+        begin
+          path = create_path(cm)
+          path.each do |ctx, dest|
+            ctx.run(@options.reporter, @options.dry_run)
+            ctx.jump_to dest
+          end
+        rescue Interrupt
+        ensure
+          @options.reporter.end
         end
-        @reporter.end
-        failure_count = @reporter.dump
+        failure_count = @options.reporter.dump
+        
+        if(failure_count == 0 && !@options.heckle_runner.nil?)
+          heckle_runner = @options.heckle_runner
+          @options.heckle_runner = nil
+          context_runner = self.class.new(@options)
+          context_runner.instance_variable_set(:@contexts, @contexts)
+          heckle_runner.heckle_with(context_runner)
+        end
+        
         if(exit_when_done)
           exit_code = (failure_count == 0) ? 0 : 1
           exit(exit_code)
         end
+        failure_count
       end
-    
-      def number_of_specs
-        @contexts.inject(0) {|sum, context| sum + context.number_of_specs}
-      end
-      
     end
   end
 end

data/lib/spekmachine/runner/extensions/kernel.rb

@@ -0,0 +1,14 @@
+require 'spec/runner/extensions/object'
+
+module Kernel
+  def setup(name, &block)
+    runner = context_runner
+    runner.set_start(name, block)
+  end
+
+  def context(name, desc, &block)
+    context = Spec::Runner::Context.new(name, desc, &block)
+    context_runner.add_context(context)
+  end
+end
+

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: spekmachine
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2006-12-22 00:00:00 +01:00
+  version: 0.2.0
+date: 2007-01-09 00:00:00 +01:00
 summary: Stateful specs
 require_paths: 
 - lib
@@ -34,8 +34,8 @@ files:
 - lib/spekmachine/runner/context.rb
 - lib/spekmachine/runner/context_eval.rb
 - lib/spekmachine/runner/context_runner.rb
-- lib/spekmachine/runner/kernel_ext.rb
 - lib/spekmachine/runner/path.rb
+- lib/spekmachine/runner/extensions/kernel.rb
 test_files: []
 
 rdoc_options: []
@@ -56,5 +56,5 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.6.3
+        version: 0.7.5
     version: 

data/lib/spekmachine/runner/kernel_ext.rb

@@ -1,19 +0,0 @@
-module Kernel
-  def setup(name, &block)
-    runner = context_runner
-    runner.set_start(name, block)
-  end
-
-  def context(name, desc, &block)
-    context = Spec::Runner::Context.new(name, desc, &block)
-    runner = context_runner
-    runner.add_context(context)
-    runner.run(false) if runner.standalone
-  end
-  
-private
-  
-  def context_runner
-    $context_runner ||= ::Spec::Runner::OptionParser.create_context_runner(ARGV.dup, true, STDERR, STDOUT)
-  end
-end