flatware 0.4.0 → 2.0.0.rc1

data/lib/flatware-cucumber.rb

@@ -1 +0,0 @@
-require 'flatware/cucumber'

data/lib/flatware-rspec.rb

@@ -1 +0,0 @@
-require 'flatware/rspec'

data/lib/flatware/cucumber.rb

@@ -1,51 +0,0 @@
-require 'cucumber'
-require 'flatware/cucumber/checkpoint'
-require 'flatware/cucumber/formatter'
-require 'flatware/cucumber/result'
-require 'flatware/cucumber/scenario_result'
-require 'flatware/cucumber/step_result'
-require 'flatware/cucumber/formatters/console'
-require 'flatware/cucumber/cli'
-
-module Flatware
-  module Cucumber
-    class Config
-      attr_reader :config, :args
-      def initialize(cucumber_config, args)
-        @config, @args = cucumber_config, args
-      end
-
-      def feature_dir
-        @config.feature_dirs.first
-      end
-
-      def jobs
-        feature_files.map { |file| Job.new file, args }.to_a
-      end
-
-      private
-
-      def feature_files
-        config.feature_files - config.feature_dirs
-      end
-    end
-
-    extend self
-
-    def configure(args, out_stream=$stdout, error_stream=$stderr)
-      raw_args = args.dup
-      cli_config = ::Cucumber::Cli::Configuration.new(out_stream, error_stream)
-      cli_config.parse! args + %w[--format Flatware::Cucumber::Formatter]
-      cucumber_config = ::Cucumber::Configuration.new cli_config
-      Config.new cucumber_config, raw_args
-    end
-
-    def run(feature_files, options)
-      runtime(Array(feature_files) + options).run!
-    end
-
-    def runtime(args)
-      ::Cucumber::Runtime.new(configure(args).config)
-    end
-  end
-end

data/lib/flatware/cucumber/checkpoint.rb

@@ -1,28 +0,0 @@
-module Flatware
-  module Cucumber
-    class Checkpoint
-      attr_reader :steps, :scenarios
-      def initialize(steps, scenarios)
-        @steps, @scenarios = serialize_steps(steps), serialize_scenarios(scenarios)
-      end
-
-      def failures?
-        scenarios.any? &:failed?
-      end
-
-      private
-
-      def serialize_steps(steps)
-        steps.map do |step|
-          StepResult.new step.status, step.exception
-        end
-      end
-
-      def serialize_scenarios(scenarios)
-        scenarios.map do |scenario|
-          ScenarioResult.new scenario.status, scenario.file_colon_line, scenario.name, scenario.exception
-        end
-      end
-    end
-  end
-end

data/lib/flatware/cucumber/cli.rb

@@ -1,22 +0,0 @@
-require 'flatware/cli'
-
-module Flatware
-  class CLI
-    worker_option
-    method_option 'dispatch-endpoint', type: :string, default: 'ipc://dispatch'
-    method_option 'sink-endpoint', type: :string, default: 'ipc://task'
-    desc "cucumber [FLATWARE_OPTS] [CUCUMBER_ARGS]", "parallelizes cucumber with custom arguments"
-    def cucumber(*args)
-      config = Cucumber.configure args
-
-      unless config.jobs.any?
-        puts "Please create some feature files in the #{config.feature_dir} directory."
-        exit 1
-      end
-
-      Flatware.verbose = options[:log]
-      Worker.spawn count: workers, runner: Cucumber, dispatch: options['dispatch-endpoint'], sink: options['sink-endpoint']
-      start_sink jobs: config.jobs, workers: workers, formatter: Flatware::Cucumber::Formatters::Console.new($stdout, $stderr)
-    end
-  end
-end

data/lib/flatware/cucumber/formatter.rb

@@ -1,66 +0,0 @@
-require 'cucumber'
-require 'flatware/sink'
-require 'ostruct'
-module Flatware
-  module Cucumber
-    class Formatter
-      Checkpoint = Struct.new :steps, :scenarios do
-        def failures?
-          scenarios.any? &:failed?
-        end
-      end
-
-      Scenario = Struct.new :name, :file_colon_line, :status do
-        def failed?
-          status == :failed
-        end
-
-        def failed_outside_step?
-          false
-        end
-      end
-
-      def initialize(config)
-        config.on_event :after_test_case,  &method(:on_after_test_case)
-        config.on_event :after_test_step,  &method(:on_after_test_step)
-        config.on_event :finished_testing, &method(:on_finished_testing)
-        config.on_event :step_match,       &method(:on_step_match)
-        reset
-      end
-
-      private
-
-      def reset
-        @steps = []
-        @scenarios = []
-        @matched_steps = Set.new
-      end
-
-      attr_reader :steps, :scenarios, :matched_steps
-
-      def on_after_test_case(event)
-        scenarios << Scenario.new(event.test_case.name, event.test_case.location.to_s, event.result.to_sym)
-      end
-
-      def on_step_match(event)
-        @matched_steps << event.step_match.location.to_s
-      end
-
-      def on_after_test_step(event)
-        if really_a_step?(event.test_step) or event.result.undefined?
-          steps << StepResult.new(event.result.to_sym, event.result.failed? && event.result.exception)
-          Sink::client.progress Result.new event.result.to_sym
-        end
-      end
-
-      def on_finished_testing(*)
-        Sink::client.checkpoint Checkpoint.new steps, scenarios
-        reset
-      end
-
-      def really_a_step?(step)
-        matched_steps.include?(step.action_location.to_s)
-      end
-    end
-  end
-end

data/lib/flatware/cucumber/formatters/console.rb

@@ -1,48 +0,0 @@
-require 'flatware/cucumber/formatters/console/summary'
-require 'cucumber/formatter/console'
-
-module Flatware::Cucumber::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(checkpoints)
-      steps = checkpoints.flat_map(&:steps)
-      scenarios = checkpoints.flat_map(&: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

data/lib/flatware/cucumber/formatters/console/summary.rb

@@ -1,66 +0,0 @@
-require 'cucumber/formatter/console'
-require 'flatware/cucumber/formatters/console'
-require 'flatware/cucumber/checkpoint'
-
-module Flatware::Cucumber::Formatters
-  class Console
-    class Summary
-      include ::Cucumber::Formatter::Console
-      attr_reader :io, :steps, :scenarios
-
-      def initialize(steps, scenarios=[], io=StringIO.new)
-        @io = io
-        @steps = steps
-        @scenarios = scenarios
-      end
-
-      def summarize
-        2.times { io.puts }
-        print_failures(steps, 'step')
-        print_failures(scenarios.select(&:failed_outside_step?), 'scenario')
-        print_failed_scenarios scenarios
-        print_counts 'scenario', scenarios
-        print_counts 'step', steps
-      end
-
-      private
-
-      def print_failed_scenarios(scenarios)
-        return unless scenarios.any? &with_status(:failed)
-
-        io.puts format_string "Failing Scenarios:", :failed
-        scenarios.select(&with_status(:failed)).sort_by(&:file_colon_line).each do |scenario|
-          io.puts format_string(scenario.file_colon_line, :failed) + format_string(" # Scenario: " + scenario.name, :comment)
-        end
-        io.puts
-      end
-
-      def print_failures(collection, label)
-        failures = collection.select(&with_status(:failed))
-        print_elements failures, :failed, pluralize(label, failures.size)
-      end
-
-      def print_counts(label, collection)
-        io.puts pluralize(label, collection.size) + count_summary(collection)
-      end
-
-      def pluralize(word, number)
-        "#{number} #{number == 1 ? word : word + 's'}"
-      end
-
-      def with_status(status)
-        proc {|r| r.status == status}
-      end
-
-      def count_summary(results)
-        return "" unless results.any?
-        status_counts = STATUSES.map do |status|
-          count = results.select(&with_status(status)).size
-          format_string "#{count} #{status}", status if count > 0
-        end.compact.join ", "
-
-        " (#{status_counts})"
-      end
-    end
-  end
-end

data/lib/flatware/cucumber/result.rb

@@ -1,27 +0,0 @@
-module Flatware
-  module Cucumber
-    class Result
-      attr_reader :progress, :worker
-
-      def initialize(progress)
-        @progress = progress
-        @worker   = ENV['TEST_ENV_NUMBER'].to_i
-      end
-
-      class << self
-        def step(*args)
-          step = StepResult.new *args
-          new step.progress, [step]
-        end
-
-        def status(status)
-          new status
-        end
-
-        def background(status, exception)
-          new '', [StepResult.new(status, exception)]
-        end
-      end
-    end
-  end
-end

data/lib/flatware/cucumber/runtime.rb

@@ -1,36 +0,0 @@
-require 'cucumber'
-
-module Flatware
-  module Cucumber
-    class Runtime < ::Cucumber::Runtime
-
-      attr_accessor :configuration, :loader
-      attr_reader :out, :err
-      attr_reader :visitor
-
-      def initialize(out=StringIO.new, err=out)
-        @out, @err = out, err
-        super(default_configuration)
-        load_step_definitions
-        @results = Results.new(configuration)
-      end
-
-      def default_configuration
-        config = ::Cucumber::Cli::Configuration.new
-        config.parse! []
-        config
-      end
-
-      def run(feature_files=[], options=[])
-        @loader = nil
-        options = Array(feature_files) + %w[--format Flatware::Cucumber::Formatter] + options
-
-        configure(::Cucumber::Cli::Main.new(options, out, err).configuration)
-
-        self.visitor = configuration.build_tree_walker(self)
-        visitor.visit_features(features)
-        results
-      end
-    end
-  end
-end

data/lib/flatware/cucumber/scenario_result.rb

@@ -1,38 +0,0 @@
-require 'flatware/serialized_exception'
-module Flatware
-  module Cucumber
-    class ScenarioResult
-      attr_reader :status, :file_colon_line, :name
-      def initialize(status, file_colon_line, name, e)
-        @status = status
-        @file_colon_line = file_colon_line
-        @name = name
-        @exception = SerializedException.new(e.class, e.message, e.backtrace) if e
-        @failed_outside_step = false
-      end
-
-      def passed?
-        status == :passed
-      end
-
-      def failed?
-        status == :failed
-      end
-
-      def failed_outside_step!(file_colon_line)
-        @failed_outside_step = file_colon_line
-      end
-
-      def failed_outside_step?
-        !!@failed_outside_step
-      end
-
-      def exception
-        @exception.tap do |e|
-          e.backtrace = e.backtrace.grep(Regexp.new(Dir.pwd)).map { |line| line[Dir.pwd.size..-1] }
-          e.backtrace = e.backtrace + [@failed_outside_step] if failed_outside_step?
-        end
-      end
-    end
-  end
-end

data/lib/flatware/cucumber/step_result.rb

@@ -1,30 +0,0 @@
-require 'flatware/serialized_exception'
-module Flatware
-  module Cucumber
-    class StepResult
-      attr_reader :status, :exception
-
-      def initialize(status, exception)
-        @status, @exception = status, (serialized(exception) if exception)
-      end
-
-      def passed?
-        status == :passed
-      end
-
-      def failed?
-        status == :failed
-      end
-
-      def progress
-        Cucumber::ProgressString.format(status)
-      end
-
-      private
-      def serialized(e)
-        e.backtrace and e.backtrace.unshift e.backtrace.shift.sub(Dir.pwd, '.')
-        SerializedException.new(e.class, e.message, e.backtrace)
-      end
-    end
-  end
-end

data/lib/flatware/pids.rb

@@ -1,25 +0,0 @@
-require 'flatware/processor_info'
-module Flatware
-  extend self
-  # All the pids of all the processes called flatware on this machine
-  def pids
-    pids_command.map do |row|
-      row =~ /(\d+).*flatware/ and $1.to_i
-    end.compact
-  end
-
-  def pids_command
-    case ProcessorInfo.operating_system
-    when 'Darwin'
-      `ps -c -opid,pgid,command`
-    when 'Linux'
-      `ps -opid,pgid,command`
-    end.split("\n")[1..-1]
-  end
-
-  def pids_of_group(group_pid)
-    pids_command.map(&:split).map do |pid, pgid, _|
-      pid.to_i if pgid.to_i == group_pid
-    end.compact
-  end
-end