flatware 0.2.0 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 004764c1a65d325a871a4e5dc10959436dbe7b11
+  data.tar.gz: 6fde0c535fa7868237c65bc066d449db2fe506ed
+SHA512:
+  metadata.gz: ccdef8b34f2425936014ad0fbb9a53bad94c29df3c72f770e46aae3d75cafcd9659e8c1533624783667c4238f1a1a0fedaaf82ce2595f3d0bed409ec7c542ad2
+  data.tar.gz: 55b5196a2d5a08231d5440bc683c249b3508356666f719bfa566302b558978e5c3c5fdeae35e6c801800913de0c8d084818ceffe7db29c43dae2a8aa97519f19

data/lib/flatware.rb

@@ -1,86 +1,17 @@
-require 'forwardable'
-require 'ffi-rzmq'
-
 module Flatware
+  require 'flatware/checkpoint'
   require 'flatware/checkpoint_handler'
   require 'flatware/processor_info'
   require 'flatware/cli'
   require 'flatware/cucumber'
   require 'flatware/dispatcher'
   require 'flatware/fireable'
+  require 'flatware/formatters'
   require 'flatware/result'
+  require 'flatware/scenario_decorator'
   require 'flatware/scenario_result'
   require 'flatware/sink'
+  require 'flatware/socket'
   require 'flatware/step_result'
-  require 'flatware/summary'
   require 'flatware/worker'
-  require 'flatware/scenario_decorator'
-
-  Error = Class.new StandardError
-
-  Job = Struct.new :id, :args
-
-  extend self
-  def socket(type, options={})
-    Socket.new(context.socket(type)).tap do |socket|
-      sockets.push socket
-      if port = options[:connect]
-        socket.connect port
-      end
-      if port = options[:bind]
-        socket.bind port
-      end
-      #FIXME: figure out how to do this without waiting
-      sleep 0.05
-    end
-  end
-
-  def close
-    sockets.each &:close
-    context.terminate
-    @context = nil
-  end
-
-  def log(*message)
-    if verbose?
-      $stderr.print "#{$$} "
-      $stderr.puts *message
-    end
-  end
-
-  attr_writer :verbose
-  def verbose?
-    !!@verbose
-  end
-
-  private
-  def context
-    @context ||= ZMQ::Context.new
-  end
-
-  def sockets
-    @sockets ||= []
-  end
-
-  Socket = Struct.new :s do
-    extend Forwardable
-    def_delegators :s, :bind, :connect, :setsockopt
-    def send(message)
-      result = s.send_string(Marshal.dump(message))
-      raise Error, ZMQ::Util.error_string, caller if result == -1
-      message
-    end
-
-    def close
-      s.setsockopt(ZMQ::LINGER, 1)
-      s.close
-    end
-
-    def recv
-      message = ''
-      result = s.recv_string(message)
-      raise Error, ZMQ::Util.error_string, caller if result == -1
-      Marshal.load message
-    end
-  end
 end

data/lib/flatware/checkpoint.rb

@@ -20,7 +20,7 @@ module Flatware
 
     def serialize_scenarios(scenarios)
       scenarios.map do |scenario|
-        ScenarioResult.new scenario.status, scenario.file_colon_line, scenario.name
+        ScenarioResult.new scenario.status, scenario.file_colon_line, scenario.name, scenario.exception
       end
     end
 

data/lib/flatware/checkpoint_handler.rb

@@ -1,14 +1,16 @@
 module Flatware
   class CheckpointHandler
-    def initialize(out, fails_fast)
+    attr_reader :formatter, :checkpoints
+
+    def initialize(formatter, fails_fast)
       @fail_fast = fails_fast
-      @out = out
+      @formatter = formatter
       @checkpoints = []
     end
 
     def handle!(checkpoint)
-      @checkpoints << checkpoint
-      if checkpoint.failures? && @fail_fast
+      checkpoints << checkpoint
+      if checkpoint.failures? && fail_fast?
         Fireable::kill # Killing everybody
         @done = true
       end
@@ -18,10 +20,26 @@ module Flatware
       @done
     end
 
+    def fail_fast?
+      @fail_fast
+    end
+
     def summarize
-      steps = @checkpoints.map(&:steps).flatten
-      scenarios = @checkpoints.map(&:scenarios).flatten
-      Summary.new(steps, scenarios, @out).summarize
+      formatter.summarize(steps, scenarios)
+    end
+
+    def had_failures?
+      checkpoints.any? &:failures?
+    end
+
+    private
+
+    def steps
+      checkpoints.map(&:steps).flatten
+    end
+
+    def scenarios
+      checkpoints.map(&:scenarios).flatten
     end
   end
 end

data/lib/flatware/cli.rb

@@ -1,4 +1,5 @@
 require 'thor'
+require 'flatware/pids'
 module Flatware
   class CLI < Thor
 
@@ -21,22 +22,23 @@ module Flatware
 
     worker_option
     method_option 'fail-fast', type: :boolean, default: false, desc: "Abort the run on first failure"
+    method_option 'formatters', aliases: "-f", type: :array, default: %w[console], desc: "The formatters to use for output"
     desc "[FLATWARE_OPTS] cucumber [CUCUMBER_ARGS]", "parallelizes cucumber with custom arguments"
     def cucumber(*)
+      Process.setpgrp
       Flatware.verbose = options[:log]
-      Worker.spawn workers
       log "flatware options:", options
       log "cucumber options:", cucumber_args
       jobs = Cucumber.extract_jobs_from_args cucumber_args
+      Worker.spawn workers
       fork do
-        log "dispatch"
         $0 = 'flatware dispatcher'
         Dispatcher.start jobs
       end
-      log "bossman"
       $0 = 'flatware sink'
-      Sink.start_server jobs, $stdout, $stderr, options['fail-fast']
+      passed = Sink.start_server jobs, Formatters.load_by_name(options['formatters']), fail_fast: options['fail-fast']
       Process.waitall
+      exit passed ? 0 : 1
     end
 
     worker_option
@@ -58,9 +60,7 @@ module Flatware
 
     desc "clear", "kills all flatware processes"
     def clear
-      `ps -c -opid,command`.split("\n").map do |row|
-        row =~ /(\d+).*flatware/ and $1.to_i
-      end.compact.each do |pid|
+      (Flatware.pids - [$$]).each do |pid|
         Process.kill 6, pid
       end
     end

data/lib/flatware/cucumber.rb

@@ -1,19 +1,7 @@
 require 'cucumber'
-require_relative 'cucumber/runtime'
+require 'flatware/cucumber/runtime'
 module Flatware
   module Cucumber
-    autoload :Formatter, 'flatware/cucumber/formatter'
-    autoload :ProgressString, 'flatware/cucumber/formatter'
-
-    FORMATS = {
-      :passed    => '.',
-      :failed    => 'F',
-      :undefined => 'U',
-      :pending   => 'P',
-      :skipped   => '-'
-    }
-
-    STATUSES = FORMATS.keys
 
     extend self
 

data/lib/flatware/cucumber/formatter.rb

@@ -1,15 +1,26 @@
-require 'cucumber/formatter/console'
 require 'flatware/checkpoint'
 require 'flatware/scenario_decorator'
+require 'flatware/sink'
+require 'ostruct'
 module Flatware
   module Cucumber
     class Formatter
+
       def initialize(step_mother, *)
         @collector = Collector.new step_mother
+        @scenarios = []
+        @in_a_step = false
       end
 
       def after_features(*)
-        Sink.push collector.checkpoint
+        checkpoint = collector.checkpoint
+        scenarios.select(&:exception).map(&:file_colon_line).each do |file_colon_line|
+          scenario = checkpoint.scenarios.detect do |scenario|
+            scenario.file_colon_line == file_colon_line
+          end
+          scenario.failed_outside_step!(file_colon_line) if scenario
+        end
+        Sink.checkpoint checkpoint
       end
 
       def after_step_result(_, _, _, status, *)
@@ -20,11 +31,58 @@ module Flatware
         send_progress(status) if status
       end
 
+      def exception(exception, status)
+        unless @in_a_step
+          current_scenario.exception = exception
+          send_progress(status)
+        end
+      end
+
+      def respond_to?(x)
+        super
+      end
+
+      def before_outline_table(*)
+        @in_examples = true
+      end
+
+      def after_outline_table(*)
+        @in_examples = false
+      end
+
+      def before_table_cell(*)
+        @in_a_step = @in_examples
+      end
+
+      def after_table_cell(*)
+        @in_a_step = ! @in_examples
+      end
+
+      def after_table_row(table_row)
+        exception(table_row.exception, :failed) if table_row.exception
+      end
+
+      def before_step(*)
+        @in_a_step = true
+      end
+
+      def after_step(*)
+        @in_a_step = false
+      end
+
+      def scenario_name(_, name, file_colon_line, *)
+        scenarios.push OpenStruct.new file_colon_line: file_colon_line, name: name
+      end
+
       private
-      attr_reader :collector
+      attr_reader :collector, :scenarios
+
+      def current_scenario
+        scenarios.last
+      end
 
       def send_progress(status)
-        Sink.push Result.status status
+        Sink.progress Result.new status
       end
 
       class Collector
@@ -52,13 +110,5 @@ module Flatware
         end
       end
     end
-
-    class ProgressString
-      extend ::Cucumber::Formatter::Console
-      def self.format(status)
-        return '' unless status
-        format_string FORMATS[status], status
-      end
-    end
   end
 end

data/lib/flatware/dispatcher.rb

@@ -2,18 +2,23 @@ module Flatware
   class Dispatcher
     PORT = 'ipc://dispatch'
 
-    def self.start(jobs=Cucumber.jobs)
+    def self.start(jobs)
+      trap 'INT' do
+        Flatware.close
+        exit 1
+      end
       new(jobs).dispatch!
     end
 
     def initialize(jobs)
-      @jobs = jobs
+      @jobs     = jobs
+      @fireable = Fireable.new
+      @dispatch = Flatware.socket ZMQ::REP, bind: PORT
     end
 
     def dispatch!
-      return if jobs.empty?
       fireable.until_fired dispatch do |request|
-        if job = jobs.pop
+        if job = jobs.shift
           dispatch.send job
         else
           dispatch.send 'seppuku'
@@ -23,14 +28,6 @@ module Flatware
 
     private
 
-    attr_reader :jobs
-
-    def fireable
-      @fireable ||= Fireable.new
-    end
-
-    def dispatch
-      @dispatch ||= Flatware.socket ZMQ::REP, bind: PORT
-    end
+    attr_reader :jobs, :fireable, :dispatch
   end
 end

data/lib/flatware/fireable.rb

@@ -1,3 +1,5 @@
+require 'flatware/poller'
+
 module Flatware
   class Fireable
     PORT = 'ipc://die'
@@ -20,7 +22,8 @@ module Flatware
 
     def until_fired(socket, &block)
       poller = Poller.new socket, die
-      poller.each do |message|
+      poller.each do |s|
+        message = s.recv
         break if message == 'seppuku'
         block.call message
       end
@@ -28,23 +31,4 @@ module Flatware
       Flatware.close
     end
   end
-
-  class Poller
-    attr_reader :sockets
-    def initialize(*sockets)
-      @sockets = sockets
-    end
-
-    def each(&block)
-      poller = ZMQ::Poller.new
-      for socket in sockets
-        poller.register_readable socket.s
-      end
-      while poller.poll > 0
-        poller.readables.each do |s|
-          block.call Socket.new(s).recv
-        end
-      end
-    end
-  end
 end

data/lib/flatware/formatters.rb

@@ -0,0 +1,26 @@
+module Flatware
+  module Formatters
+    def self.load_by_name(names)
+      formatters = names.map do |name|
+        require "flatware/formatters/#{name}"
+        klass = const_get name.capitalize
+        klass.new $stdout, $stderr
+      end
+      Broadcaster.new formatters
+    end
+  end
+
+  class Broadcaster
+    attr_reader :formatters
+
+    def initialize(formatters)
+      @formatters = formatters
+    end
+
+    def method_missing(name, *args)
+      formatters.each do |formatter|
+        formatter.send name, *args if formatter.respond_to? name
+      end
+    end
+  end
+end

data/lib/flatware/formatters/console.rb

@@ -0,0 +1,48 @@
+require 'flatware/formatters/console/summary'
+require 'cucumber/formatter/console'
+
+module Flatware
+  module Formatters
+    class Console
+      #for format_string
+      include ::Cucumber::Formatter::Console
+
+      FORMATS = {
+        passed:    '.',
+        failed:    'F',
+        undefined: 'U',
+        pending:   'P',
+        skipped:   '-'
+      }
+
+      STATUSES = FORMATS.keys
+
+      attr_reader :out, :err
+
+      def initialize(stdout, stderr)
+        @out, @err = stdout, stderr
+      end
+
+      def progress(result)
+        out.print format result.progress
+      end
+
+      def summarize(steps, scenarios)
+        Summary.new(steps, scenarios, out).summarize
+      end
+
+      def summarize_remaining(remaining_jobs)
+        out.puts
+        out.puts "The following features have not been run:"
+        for job in remaining_jobs
+          out.puts job.id
+        end
+      end
+
+      private
+      def format(status)
+        format_string FORMATS[status], status
+      end
+    end
+  end
+end