spekmachine 0.1

data/Rakefile

@@ -0,0 +1,40 @@
+$:.unshift('lib')
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+PKG_NAME = "spekmachine"
+PKG_VERSION   = '0.1'
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILES = FileList[ '[A-Z]*', 'lib/**/*.rb' ]
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.summary = "Stateful specs"
+  s.version = PKG_VERSION
+  s.description = <<-EOF
+    spekmachine is a modification of RSpec, (http://rspec.rubyforge.org/) which
+    uses a state machine to test all transitions. It uses the Chinese Postman 
+    algorithm to find the shortest way through all transitions.
+  EOF
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+  s.has_rdoc = false
+  
+  s.require_path = 'lib'
+  s.autorequire = 'spekmachine'
+  s.bindir = "bin"
+  s.executables = ["spekm"]
+  s.author = "Michiel de Mare"
+  s.homepage = "http://persia.rubyforge.org"
+  s.rubyforge_project = "persia"
+  s.add_dependency 'rspec' , '>= 0.6.3'
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/bin/spekm

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require_gem 'rspec'
+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)
+

data/lib/spekmachine/rake/spectask.rb

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+
+# Define a task library for running RSpec contexts.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Spec
+  module Rake
+
+    # A Rake task that runs a set of RSpec contexts.
+    #
+    # Example:
+    #  
+    #   Rake::SpecTask.new do |t|
+    #     t.warning = true
+    #   end
+    #
+    # This will create a task that can be run with:
+    #
+    #   rake spec
+    #
+    class SpecTask < ::Rake::TaskLib
+
+      # Name of spec task. (default is :spec)
+      attr_accessor :name
+
+      # Array of directories to be added to $LOAD_PATH before running the
+      # specs. Defaults to ['<the absolute path to RSpec's lib directory>']
+      attr_accessor :libs
+
+      # If true, requests that the specs be run with the warning flag set.
+      # E.g. warning=true implies "ruby -w" used to run the specs. Defaults to false.
+      attr_accessor :warning
+
+      # Glob pattern to match spec files. (default is 'spec/spec*.rb')
+      attr_accessor :pattern
+
+      # Array of commandline options to pass to RSpec. Defaults to [].
+      attr_accessor :spec_opts
+
+      # Where RSpec's output is written. Defaults to STDOUT.
+      attr_accessor :out
+
+      # Whether or not to use RCov (default is false)
+      # See http://eigenclass.org/hiki.rb?rcov
+      attr_accessor :rcov
+      
+      # Array of commandline options to pass to RCov. Defaults to ['--exclude', 'lib\/spec,bin\/spec'].
+      # Ignored if rcov=false
+      attr_accessor :rcov_opts
+
+      # Directory where the RCov report is written. Defaults to "coverage"
+      # Ignored if rcov=false
+      attr_accessor :rcov_dir
+
+      # Array of commandline options to pass to ruby. Defaults to [].
+      attr_accessor :ruby_opts
+
+      # Whether or not to fail Rake when an error occurs (typically when specs fail).
+      # Defaults to true.
+      attr_accessor :fail_on_error
+
+      # A message to print to stdout when there are failures.
+      attr_accessor :failure_message
+
+      # Explicitly define the list of spec files to be included in a
+      # spec.  +list+ is expected to be an array of file names (a
+      # FileList is acceptable).  If both +pattern+ and +spec_files+ are
+      # used, then the list of spec files is the union of the two.
+      def spec_files=(list)
+        @spec_files = list
+      end
+
+      # Create a specing task.
+      def initialize(name=:spec)
+        @name = name
+        @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
+        @pattern = nil
+        @spec_files = nil
+        @spec_opts = []
+        @warning = false
+        @ruby_opts = []
+        @out = nil
+        @fail_on_error = true
+        @rcov = false
+        @rcov_opts = ['--exclude', 'lib\/spec,bin\/spec']
+        @rcov_dir = "coverage"
+
+        yield self if block_given?
+        @pattern = 'spec/**/*_spek.rb' if @pattern.nil? && @spec_files.nil?
+        define
+      end
+
+      def define
+        #raise "No spec files found." if file_list.empty?
+        spec_script = File.expand_path(File.dirname(__FILE__) + '/../../../bin/spekm')
+
+        lib_path = @libs.join(File::PATH_SEPARATOR)
+        actual_name = Hash === name ? name.keys.first : name
+        unless ::Rake.application.last_comment
+          desc "Run RSpec for #{actual_name}" + (@rcov ? " using RCov" : "")
+        end
+        task @name do
+          RakeFileUtils.verbose(@verbose) do
+            ruby_opts = @ruby_opts.clone
+            ruby_opts.push( "-I\"#{lib_path}\"" )
+            ruby_opts.push( "-S rcov" ) if @rcov
+            ruby_opts.push( "-w" ) if @warning
+
+            redirect = @out.nil? ? "" : " > #{@out}"
+            # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- [spec_opts] examples
+            # or
+            # ruby [ruby_opts] -Ilib bin/spec [spec_opts] examples
+            begin
+              ruby(
+                ruby_opts.join(" ") + " " + 
+                rcov_option_list +
+                (@rcov ? %[ -o "#{@rcov_dir}" ] : "") + 
+                '"' + spec_script + '"' + " " +
+                (@rcov ? "-- " : "") + 
+                spec_option_list + " " +
+                file_list.collect { |fn| %["#{fn}"] }.join(' ') + " " + 
+                redirect
+              )
+            rescue => e
+               puts @failure_message if @failure_message
+               raise e if @fail_on_error
+            end
+          end
+        end
+
+        if @rcov
+          desc "Remove rcov products for #{actual_name}"
+          task paste("clobber_", actual_name) do
+            rm_r @rcov_dir rescue nil
+          end
+
+          clobber_task = paste("clobber_", actual_name)
+          task :clobber => [clobber_task]
+
+          task actual_name => clobber_task
+        end
+        self
+      end
+
+      def rcov_option_list # :nodoc:
+        return "" unless @rcov
+        ENV['RCOVOPTS'] || @rcov_opts.join(" ") || ""
+      end
+
+      def spec_option_list # :nodoc:
+        ENV['RSPECOPTS'] || @spec_opts.join(" ") || ""
+      end
+
+      def file_list # :nodoc:
+        if ENV['SPEC']
+          FileList[ ENV['SPEC'] ]
+        else
+          result = []
+          result += @spec_files.to_a if @spec_files
+          result += FileList[ @pattern ].to_a if @pattern
+          FileList[result]
+        end
+      end
+
+    end
+  end
+end
+

data/lib/spekmachine/runner/context.rb

@@ -0,0 +1,152 @@
+module Spec
+  module Runner
+    class Context
+      module InstanceMethods
+        def initialize(name, desc, &context_block)
+          @context_id = name
+          @name = desc
+
+          @context_eval_module = Module.new
+          @context_eval_module.extend ContextEval::ModuleMethods
+          @context_eval_module.include ContextEval::InstanceMethods
+          before_context_eval
+          @context_eval_module.class_eval(&context_block)
+        end
+
+        def context_id
+          @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
+
+        def goto_parts
+          @context_eval_module.goto_parts
+        end
+
+        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
+
+        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
+        end
+
+        def context_superclass
+          @context_eval_module.send :context_superclass
+        end
+      end
+      include InstanceMethods
+    end
+  end
+end

data/lib/spekmachine/runner/context_eval.rb

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

data/lib/spekmachine/runner/context_runner.rb

@@ -0,0 +1,62 @@
+#require File.dirname(__FILE__) + '/../../spekmachine'
+
+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
+        @contexts.each do |c|
+          c.goto_parts.keys.each {|dest| g.addArc(nil, c.context_id, dest) }
+        end
+        g.solve
+        mp = g.printCPT(g.convert_to_index(@start_name)).map {|arcLabel, from, to| [g.convert(from), g.convert(to)] }
+        mp.map {|from, to| [ctxMap[from], to] }
+      end
+      
+      def run(exit_when_done)
+        raise unless @setup
+        @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
+        end
+        @reporter.end
+        failure_count = @reporter.dump
+        if(exit_when_done)
+          exit_code = (failure_count == 0) ? 0 : 1
+          exit(exit_code)
+        end
+      end
+    
+      def number_of_specs
+        @contexts.inject(0) {|sum, context| sum + context.number_of_specs}
+      end
+      
+    end
+  end
+end

data/lib/spekmachine/runner/kernel_ext.rb

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

data/lib/spekmachine/runner/path.rb

@@ -0,0 +1,213 @@
+class CPP 
+  attr_reader :c, :path
+  def initialize
+    @delta = Hash.new(0)
+    @defined = Hash.new {|h,k|h[k] = {}}
+    @label = Hash.new {|h,k|h[k] = {}}
+    @c = Hash.new {|h,k|h[k] = Hash.new(0)}
+    @f = Hash.new {|h,k|h[k] = Hash.new(0.0)}
+    @pos = []
+    @neg = []
+    @arcs = Hash.new {|h,k|h[k] = Hash.new(0) }
+    @cheapestLabel = Hash.new {|h,k|h[k] = {}}
+    @path = Hash.new {|h,k|h[k] = {}}
+    @basicCost = 0;
+  end
+  
+  def solve
+    leastCostPaths
+    checkValid
+    findUnbalanced
+    findFeasible
+    loop do break unless improvements end
+  end
+
+  def convert(index)
+    @nodeList[index]
+  end
+
+  def convert_to_index(name)
+    @nodeMap[name]
+  end
+
+  def updateMap(a)
+    @nodeList ||= []
+    @nodeMap ||= {}
+    if @nodeMap[a]
+      u = @nodeMap[a]
+    else
+      u = @nodeList.size
+      @nodeMap[a] = u
+      @nodeList << a
+    end
+    u
+  end
+  
+  def addArc(lab, a, b, cost = 1)
+    u = updateMap a
+    v = updateMap b
+    @n = @nodeList.size
+    @label[u][v] = [] if !@defined[u][v]
+		@label[u][v] << lab
+    @basicCost += cost
+    if !@defined[u][v] or @c[u][v] > cost
+		 	@c[u][v] = cost
+      @cheapestLabel[u][v] = lab
+      @defined[u][v] = true
+      @path[u][v] = v
+    end
+    @arcs[u][v] += 1
+    @delta[u] += 1
+    @delta[v] -= 1;
+		self
+  end
+  
+  def leastCostPaths
+    @n.times do |k|
+      @n.times do |i|
+        if @defined[i][k]
+          @n.times do |j|
+            if @defined[k][j] and (!@defined[i][j] || @c[i][j] > @c[i][k]+@c[k][j])
+              @path[i][j] = @path[i][k];
+              @c[i][j] = @c[i][k]+@c[k][j];
+              @defined[i][j] = true;
+              return if i == j and @c[i][j] < 0
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def checkValid
+    @n.times do |i|
+      @n.times do |j|
+        raise "Graph is not strongly connected for #{i} and #{j}" if !@defined[i][j]
+      end
+      raise "Graph has a negative cycle" if( @c[i][i] < 0 )
+    end
+  end
+
+  def cost
+    @basicCost + phi
+  end
+  
+  def phi
+    phi = 0.0
+    @n.times do |i|
+      @n.times do |j|
+        phi += @c[i][j]*@f[i][j];
+      end
+    end
+    phi
+  end
+    
+  def findUnbalanced
+    nn = np = 0
+    
+    @n.times do |i|
+      nn += 1 if @delta[i] < 0
+      np += 1 if @delta[i] > 0
+    end
+      
+    @neg = []
+    @pos = []
+    nn = np = 0;
+    @n.times do |i|
+      @neg[nn] = i and nn += 1 if @delta[i] < 0
+      @pos[np] = i and np += 1 if @delta[i] > 0
+    end
+  end
+   
+  def findFeasible
+    @neg.length.times do |u|
+      i = @neg[u];
+      @pos.length.times do |v|
+        j = @pos[v];
+        @f[i][j] = -@delta[i] < @delta[j] ? -@delta[i] : @delta[j];
+        @delta[i] += @f[i][j];
+        @delta[j] -= @f[i][j];
+      end
+    end
+  end
+  
+  def improvements
+    residual = CPP.new
+    @neg.length.times do |u|
+      i = @neg[u]
+      @pos.length.times do |v|
+        j = @pos[v]
+        residual.addArc(nil, i, j, @c[i][j])
+        residual.addArc(nil, j, i, -@c[i][j]) if @f[i][j] != 0
+      end
+    end
+    residual.leastCostPaths()
+    @n.times do |i|
+      if residual.c[i][i] < 0 
+        k = 0
+        kunset = true;
+        u = i
+        loop do 
+          v = residual.path[u][i];
+          if residual.c[u][v] < 0 and (kunset || k > @f[v][u])
+            k = @f[v][u]
+            kunset = false
+          end
+          break if (u = v) == i
+        end
+        u = i;
+        loop do
+          v = residual.path[u][i];
+          if residual.c[u][v] < 0 
+            @f[v][u] -= k;
+          else
+            @f[u][v] += k;
+          end
+          return true if (u = v) == i
+        end
+      end
+    end
+    false;
+  end
+  
+  def findPath(from)
+    ((0...@n).detect {|i| @f[from][i] > 0 }) or -1
+  end
+  
+  def printCPT(startVertex)
+    result = []
+    v = startVertex;
+    
+    loop do
+      u = v;
+      if (v = findPath(u)) != -1
+        @f[u][v] -= 1;
+        while u != v do
+          p = @path[u][v];
+          result << [@cheapestLabel[u][p], u, p]
+          u = p
+        end
+      else
+        bridgeVertex = @path[u][startVertex];
+        if @arcs[u][bridgeVertex] == 0
+          return result 
+        end
+        v = bridgeVertex;
+        @n.times do |i|
+          if i != bridgeVertex && @arcs[u][i] > 0
+            v = i;
+            break;
+          end
+        end
+        @arcs[u][v] -= 1;
+        result << [@label[u][v][@arcs[u][v]], u, v]
+      end
+    end
+    raise 'cant get here'
+  end
+end 
+
+# g = CPP.new()
+# g.addArc("a", :a, :b).addArc("b", :a, :c).addArc("c", :b, :c) .addArc("d", :b, :d).addArc("e", :c, :d).addArc("f", :d, :a)
+# g.solve()
+# puts g.printCPT(0).map {|a,b,c| "Take arc #{a} from #{b} to #{c}"}.join("\n")

data/lib/spekmachine.rb

@@ -0,0 +1,5 @@
+require 'spekmachine/runner/context'
+require 'spekmachine/runner/context_eval'
+require 'spekmachine/runner/context_runner'
+require 'spekmachine/runner/kernel_ext'
+require 'spekmachine/runner/path'

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: spekmachine
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2006-09-14 00:00:00 +02:00
+summary: Stateful specs
+require_paths: 
+- lib
+email: 
+homepage: http://persia.rubyforge.org
+rubyforge_project: persia
+description: spekmachine is a modification of RSpec, (http://rspec.rubyforge.org/) which uses a state machine to test all transitions. It uses the Chinese Postman  algorithm to find the shortest way through all transitions.
+autorequire: spekmachine
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Michiel de Mare
+files: 
+- Rakefile
+- lib/spekmachine.rb
+- lib/spekmachine/rake/spectask.rb
+- 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
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- spekm
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.3
+    version: