flatware 0.0.1

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Brian Dunn
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,79 @@
+= Flatware
+
+Flatware is a a distributed cucumber runner.
+
+== Requirements
+
+* ZeroMQ ~> 2.1
+
+== Installation
+
+Add this to your Gemfile:
+
+    gem 'flatware'
+
+and `bundle install`.
+
+== Usage
+
+To run your entire suite with the default cucumber options, just:
+
+    flatware
+
+If you'd like to limit the number of forked workers, you can pass the 'w' flag:
+
+    flatware -w 3
+
+You can also pass most cucumber options to flatware. For example, to run only features that are not tagged 'javascript', you can:
+
+    flatware cucumber -t ~@javascript
+
+
+== Planned Features
+
+* Reliable enough to use as part of your Continuous Integration system
+* Always accounts for every feature you ask it to run
+* Use heuristics to run your slowest tests first
+* speak Cucumber's DRB protocol; if you know how to use Spork you know how to use Flatware
+
+== Design Goals
+
+=== Maintainable
+
+* Fully test at an integration level. Don't be afraid to change the code. If you break it you'll know.
+* Couple as loosely as possible, and only to the most stable/public bits of Cucumber.
+
+=== Minimal
+
+* Projects define their own preperation scripts
+* Only distribute to local cores (for now)
+* Only handle cucumber
+
+=== Robust
+
+* Depend on a dedicated messaging library
+* Be acountable for completed work; provide progress report regardless of completing the suite.
+
+== Tinkering
+
+Flatware is tested with aruba. In order to get a demo cucumber project you can add the `@no-clobber` tag to `features/flatware.feature` and run the test with `cucumber features/flatware.feature`. Now you should have a `./tmp/aruba` directory. CD there and you can run the `worker` and `dispatcher` binaries, like `../../bin/worker` and `../../bin/dispatcher`
+
+== Resources
+
+The excellent ZeroMQ guide: http://zguide.zeromq.org/page:all
+
+== Contributing to Flatware
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011-2012 Brian Dunn. See LICENSE.txt for
+further details.
+

data/bin/flatware

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../../lib', __FILE__)
+$:.unshift lib unless $:.include? lib
+
+require 'flatware'
+Flatware::CLI.start

data/lib/flatware.rb

@@ -0,0 +1,50 @@
+require 'zmq'
+
+module Flatware
+  autoload :CLI, 'flatware/cli'
+  autoload :Cucumber, 'flatware/cucumber'
+  autoload :Dispatcher, 'flatware/dispatcher'
+  autoload :Fireable, 'flatware/fireable'
+  autoload :Result, 'flatware/result'
+  autoload :ScenarioResult, 'flatware/scenario_result'
+  autoload :Sink, 'flatware/sink'
+  autoload :StepResult, 'flatware/step_result'
+  autoload :Summary, 'flatware/summary'
+  autoload :Worker, 'flatware/worker'
+
+  Job = Struct.new :id, :args
+
+  extend self
+  def socket(*args)
+    context.socket(*args).tap do |socket|
+      sockets.push socket
+    end
+  end
+
+  def close
+    sockets.each &:close
+    context.close
+    @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
+end

data/lib/flatware/cli.rb

@@ -0,0 +1,71 @@
+require 'thor'
+module Flatware
+  class CLI < Thor
+
+    def self.processors
+      @processors ||= `hostinfo`.match(/^(?<processors>\d+) processors are logically available\.$/)[:processors].to_i
+    end
+
+    def self.worker_option
+      method_option :workers, aliases: "-w", type: :numeric, default: processors, desc: "Number of concurent processes to run"
+    end
+
+    class_option :log, aliases: "-l", type: :boolean, desc: "Print debug messages to $stderr"
+
+    default_task :default
+    worker_option
+    desc "default", "parallelizes cucumber with default arguments"
+    def default
+      cucumber
+    end
+
+    worker_option
+    desc "cucumber [CUCUMBER_ARGS]", "parallelizes cucumber with custom arguments"
+    def cucumber(*)
+      Flatware.verbose = options[:log]
+      Worker.spawn workers
+      jobs = Cucumber.extract_jobs_from_args args
+      fork do
+        log "dispatch"
+        $0 = 'flatware dispatcher'
+        Dispatcher.start jobs
+      end
+      log "bossman"
+      $0 = 'flatware sink'
+      Sink.start_server jobs
+      Process.waitall
+    end
+
+    worker_option
+    desc "fan [COMMAND]", "executes the given job on all of the workers"
+    def fan(*command)
+      Flatware.verbose = options[:log]
+
+      command = command.join(" ")
+      puts "Running '#{command}' on #{workers} workers"
+
+      workers.times do |i|
+        fork do
+          exec({"TEST_ENV_NUMBER" => i.to_s}, command)
+        end
+      end
+      Process.waitall
+    end
+
+
+    desc "clear", "kills all flatware processes"
+    def clear
+      `ps -c -opid,command | grep flatware | cut -f 1 -d ' ' | xargs kill -6`
+    end
+
+    private
+
+    def log(*args)
+      Flatware.log(*args)
+    end
+
+    def workers
+      options[:workers]
+    end
+  end
+end

data/lib/flatware/cucumber.rb

@@ -0,0 +1,38 @@
+require 'cucumber'
+require_relative '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
+
+    attr_reader :jobs
+
+    def extract_jobs_from_args(args=[], out_stream=$stdout, error_stream=$stderr)
+      raw_args = args.dup
+      config = ::Cucumber::Cli::Configuration.new(out_stream, error_stream)
+      config.parse! args
+      options = raw_args - args
+      @jobs = config.feature_files.map { |file| Job.new file, options }
+    end
+
+    def run(feature_files=[], options=[])
+      runtime.run feature_files, options
+    end
+
+    def runtime
+      @runtime ||= Runtime.new
+    end
+  end
+end

data/lib/flatware/cucumber/formatter.rb

@@ -0,0 +1,151 @@
+require 'cucumber/formatter/console'
+module Flatware
+  module Cucumber
+    class Formatter
+      def initialize(step_mother, *)
+        @step_mother = step_mother
+      end
+
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        @current_scenario = file_colon_line
+      end
+
+      def before_feature_element(feature_element)
+        case feature_element
+        when ::Cucumber::Ast::ScenarioOutline
+          @outline_steps = feature_element
+        end
+      end
+
+      def after_feature_element(feature_element)
+        @outline_steps = nil
+      end
+
+      def after_feature(*)
+        background_steps.each do |step|
+          Sink.push step
+        end unless current_scenario
+      end
+
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        result = if status_only? background
+          background_steps << Result.background(status, exception)
+          Result.status status
+        else
+          Result.step status, exception, current_scenario
+        end
+
+        Sink.push result
+      end
+
+      def before_outline_table(outline_table)
+        @outline_table = outline_table
+      end
+
+      def after_outline_table(outline_table)
+        @outline_table = nil
+      end
+
+      def before_table_row(table_row)
+        if example_row? table_row
+          @step_collector = StepCollector.new(step_mother)
+        end
+      end
+
+      def after_table_row(table_row)
+        if example_row? table_row
+          step_collector.stop table_row
+          Sink.push Result.new step_collector.progress, step_collector.steps
+        end
+      end
+
+      def table_cell_value(_, status)
+        Sink.push Result.status status if example_cell? status
+      end
+
+      private
+
+      attr_reader :step_mother, :step_collector, :current_scenario
+
+      def background_steps
+        @background_steps ||= []
+      end
+
+      def status_only?(background)
+        scenario_outline? or (background and not current_scenario)
+      end
+
+      def scenario_outline?
+        !!@outline_steps
+      end
+
+      def example_row?(table_row)
+        outline_table? and not table_header_row? table_row
+      end
+
+      def example_cell?(status)
+        outline_table? and not table_header_cell? status
+      end
+
+      def table_header_cell?(status)
+        status == :skipped_param
+      end
+
+      def outline_table?
+        !!@outline_table
+      end
+
+      def table_header_row?(table_row)
+        table_row.failed?
+      rescue ::Cucumber::Ast::OutlineTable::ExampleRow::InvalidForHeaderRowError
+        true
+      else
+        false
+      end
+
+      class StepCollector
+        attr_reader :step_mother
+        def initialize(step_mother)
+          @step_mother = step_mother
+          snapshot_steps
+        end
+
+        def stop(table_row)
+          @scenario_id = extract_scenario(table_row)
+          @example_row_steps = step_mother.steps - ran_steps
+        end
+
+        def steps
+          example_row_steps or raise('stop collecting first')
+          example_row_steps.map do |step|
+            StepResult.new(step.status, step.exception, scenario_id)
+          end
+        end
+
+        def progress
+          ''
+        end
+
+        private
+
+        attr_reader :example_row_steps, :scenario_id, :ran_steps
+
+        def extract_scenario(table_row)
+          table_row.scenario_outline.file_colon_line(table_row.line)
+        end
+
+        def snapshot_steps
+          @ran_steps = step_mother.steps.dup
+        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/cucumber/runtime.rb

@@ -0,0 +1,36 @@
+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/dispatcher.rb

@@ -0,0 +1,38 @@
+module Flatware
+  class Dispatcher
+    DISPATCH_PORT = 'ipc://dispatch'
+
+    def self.start(jobs=Cucumber.jobs)
+      new(jobs).dispatch!
+    end
+
+    def initialize(jobs)
+      @jobs = jobs
+    end
+
+    def dispatch!
+      return Flatware.close if jobs.empty?
+      fireable.until_fired dispatch do |request|
+        if job = jobs.pop
+          dispatch.send Marshal.dump job
+        else
+          dispatch.send 'seppuku'
+        end
+      end
+    end
+
+    private
+
+    attr_reader :jobs
+
+    def fireable
+      @fireable ||= Fireable.new
+    end
+
+    def dispatch
+      @dispatch ||= Flatware.socket(ZMQ::REP).tap do |socket|
+        socket.bind DISPATCH_PORT
+      end
+    end
+  end
+end

data/lib/flatware/fireable.rb

@@ -0,0 +1,22 @@
+module Flatware
+  class Fireable
+    def initialize
+      @die = Flatware.socket(ZMQ::SUB).tap do |die|
+        die.connect 'ipc://die'
+        die.setsockopt ZMQ::SUBSCRIBE, ''
+      end
+    end
+
+    attr_reader :die
+
+    def until_fired(sockets=[], &block)
+      while ready = ZMQ.select(Array(sockets) + [die])
+        messages = ready.flatten.compact.map(&:recv)
+        break if messages.include? 'seppuku'
+        messages.each &block
+      end
+    ensure
+      Flatware.close
+    end
+  end
+end

data/lib/flatware/result.rb

@@ -0,0 +1,24 @@
+module Flatware
+  class Result
+    attr_reader :progress, :steps
+
+    def initialize(progress, steps=nil)
+      @progress, @steps = progress, steps || []
+    end
+
+    class << self
+      def step(*args)
+        step = StepResult.new *args
+        new step.progress, [step]
+      end
+
+      def status(status)
+        new Cucumber::ProgressString.format status
+      end
+
+      def background(status, exception)
+        new '', [StepResult.new(status, exception)]
+      end
+    end
+  end
+end

data/lib/flatware/scenario_result.rb

@@ -0,0 +1,24 @@
+module Flatware
+  class ScenarioResult
+    attr_reader :id, :steps
+
+    def initialize(id, steps=[])
+      @id = id
+      @steps = steps
+    end
+
+    def status
+      first(:failed) || first(:undefined) || :passed
+    end
+
+    private
+
+    def first(status)
+      statuses.detect {|s| s == status}
+    end
+
+    def statuses
+      steps.map &:status
+    end
+  end
+end

data/lib/flatware/sink.rb

@@ -0,0 +1,136 @@
+require 'flatware'
+require 'flatware/cucumber/formatter'
+module Flatware
+  class Sink
+    class << self
+      def push(message)
+        client.push Marshal.dump message
+      end
+
+      def finished(job)
+        push job
+      end
+
+      def start_server(jobs=Cucumber.jobs, out_stream=$stdout, error_stream=$stderr)
+        Server.new(jobs, out_stream, error_stream).start
+      end
+
+      def client
+        @client ||= Client.new
+      end
+    end
+
+    class Server
+      def initialize(jobs, out, error)
+        @jobs, @out, @error = jobs, out, error
+      end
+
+      def start
+        trap 'INT' do
+          summarize
+          summarize_remaining
+        end
+
+        before_firing { listen }
+        Flatware.close
+      end
+
+      def listen
+        until done?
+          message = socket.recv
+          case (result = Marshal.load message)
+          when Result
+            print result.progress
+            steps.push *result.steps
+          when Job
+            completed_jobs << result
+            log "COMPLETED SCENARIO"
+          else
+            log "i don't know that message, bro."
+          end
+        end
+        summarize
+      rescue ZMQ::Error => e
+        raise unless e.message == "Interrupted system call"
+      end
+
+      private
+
+      attr_reader :out, :jobs
+
+      def print(*args)
+        out.print *args
+      end
+
+      def puts(*args)
+        out.puts *args
+      end
+
+      def summarize
+        Summary.new(steps, out).summarize
+      end
+
+      def summarize_remaining
+        return if remaining_work.empty?
+        puts
+        puts "The following features have not been run:"
+        for job in remaining_work
+          puts job.id
+        end
+      end
+
+      def log(*args)
+        Flatware.log *args
+      end
+
+      def before_firing(&block)
+        die = Flatware.socket(ZMQ::PUB).tap do |socket|
+          socket.bind 'ipc://die'
+        end
+        block.call
+        die.send 'seppuku'
+      end
+
+      def steps
+        @steps ||= []
+      end
+
+      def completed_jobs
+        @completed_jobs ||= []
+      end
+
+      def done?
+        log remaining_work
+        remaining_work.empty?
+      end
+
+      def remaining_work
+        jobs - completed_jobs
+      end
+
+      def fireable
+        @fireable ||= Fireable.new
+      end
+
+      def socket
+        @socket ||= Flatware.socket(ZMQ::PULL).tap do |socket|
+          socket.bind 'ipc://sink'
+        end
+      end
+    end
+
+    class Client
+      def push(message)
+        socket.send message
+      end
+
+      private
+
+      def socket
+        @socket ||= Flatware.socket(ZMQ::PUSH).tap do |socket|
+          socket.connect 'ipc://sink'
+        end
+      end
+    end
+  end
+end

data/lib/flatware/step_result.rb

@@ -0,0 +1,44 @@
+module Flatware
+  class StepResult
+    attr_reader :status, :exception, :scenario_id
+
+    def initialize(status, exception, scenario_id=nil)
+      @status, @exception, @scenario_id = status, serialized(exception), scenario_id
+    end
+
+    def passed?
+      status == :passed
+    end
+
+    def failed?
+      status == :failed
+    end
+
+    def progress
+      Cucumber::ProgressString.format(status)
+    end
+
+    private
+    def serialized(e)
+      SerializedException.new(e.class, e.message, e.backtrace) if e
+    end
+
+    class SerializedException
+      attr_reader :class, :message, :backtrace
+      def initialize(klass, message, backtrace)
+        @class, @message, @backtrace = serialized(klass), message, backtrace
+      end
+
+      private
+      def serialized(klass)
+        SerializedClass.new(klass.to_s)
+      end
+    end
+
+    class SerializedClass
+      attr_reader :name
+      alias to_s name
+      def initialize(name); @name = name end
+    end
+  end
+end

data/lib/flatware/summary.rb

@@ -0,0 +1,61 @@
+require 'cucumber/formatter/console'
+module Flatware
+  class Summary
+    include ::Cucumber::Formatter::Console
+    attr_reader :io, :steps
+
+    def initialize(steps, io=StringIO.new)
+      @io = io
+      @steps = steps
+    end
+
+    def scenarios
+      @scenarios ||= scenario_steps.group_by(&:scenario_id).map do |scenario, steps|
+        ScenarioResult.new(scenario, steps)
+      end
+    end
+
+    def summarize
+      2.times { io.puts }
+      print_steps :failed
+      print_counts 'scenario', scenarios
+      print_counts 'step', steps
+    end
+
+    private
+
+    def scenario_steps
+      steps.select &:scenario_id
+    end
+
+    def print_steps(status)
+      print_elements steps.select(&with_status(status)), status, 'steps'
+    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 = Cucumber::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
+
+    def count(status)
+      completed_scenarios.select {|scenario| scenario.status == status}.count
+    end
+  end
+end

data/lib/flatware/worker.rb

@@ -0,0 +1,55 @@
+require 'benchmark'
+module Flatware
+  class Worker
+
+    def self.listen!
+      new.listen
+    end
+
+    def self.spawn(worker_count)
+      worker_count.times do |i|
+        fork do
+          $0 = "flatware worker #{i}"
+          ENV['TEST_ENV_NUMBER'] = i.to_s
+          listen!
+        end
+      end
+    end
+
+    def listen
+      time = Benchmark.realtime do
+        fireable
+        report_for_duty
+        fireable.until_fired task do |work|
+          job = Marshal.load work
+          log 'working!'
+          Cucumber.run job.id, job.args
+          Sink.finished job
+          report_for_duty
+          log 'waiting'
+        end
+      end
+      log time
+    end
+
+    private
+
+    def log(*args)
+      Flatware.log *args
+    end
+
+    def fireable
+      @fireable ||= Fireable.new
+    end
+
+    def task
+      @task ||= Flatware.socket(ZMQ::REQ).tap do |task|
+        task.connect Dispatcher::DISPATCH_PORT
+      end
+    end
+
+    def report_for_duty
+      task.send 'ready'
+    end
+  end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: flatware
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Brian Dunn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zmq
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.15.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.15.0
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A distributed cucumber runner
+email: brian@hashrocket.com
+executables:
+- flatware
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- lib/flatware.rb
+- lib/flatware/cli.rb
+- lib/flatware/cucumber.rb
+- lib/flatware/cucumber/formatter.rb
+- lib/flatware/cucumber/runtime.rb
+- lib/flatware/dispatcher.rb
+- lib/flatware/fireable.rb
+- lib/flatware/result.rb
+- lib/flatware/scenario_result.rb
+- lib/flatware/sink.rb
+- lib/flatware/step_result.rb
+- lib/flatware/summary.rb
+- lib/flatware/worker.rb
+- LICENSE.txt
+- README.rdoc
+- bin/flatware
+homepage: http://github.com/briandunn/flatware
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A distributed cucumber runner
+test_files: []