specjour 0.1.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/MIT_LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Sandro Turriate
+
+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.markdown

@@ -0,0 +1,47 @@
+# Specjour
+
+_Distribute your spec suite amongst your LAN via Bonjour._
+
+1. Start a dispatcher in your project directory.
+2. Spin up a manager on each remote machine.
+3. Say "goodbye" to your long coffee breaks.
+
+## Requirements
+
+* Bonjour or DNSSD (the capability and the gem)
+* Rsync (system command used)
+* Rspec (officially v1.3.0)
+
+## Installation
+    gem install specjour
+
+## Start a manager
+Running `specjour` on the command-line will start a manager which advertises that it's ready to run tests. By default, the manager will only use one worker to run the tests. If you had 4 cores however, you could use `specjour --workers 4` to run 4 sets of tests at once.
+
+    $ specjour
+
+## Setup the dispatcher
+Add the rake task to the `Rakefile` in your project's directory.
+
+    require 'specjour/tasks/specjour'
+
+## Distribute the tests
+Run the rake task in your project directory to start the test suite.
+
+    $ rake specjour
+
+The worker reports passes/failures in batches of 25 so you won't get immediate feedback, override the batch size via `specjour --batch-size 1`
+
+## Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2010 Sandro Turriate. See MIT_LICENSE for details.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "specjour"
+    gem.summary = %Q{Distribute your spec suite amongst your LAN via Bonjour.}
+    gem.description = %Q{Distribute your spec suite amongst your LAN via Bonjour.}
+    gem.email = "sandro.turriate@gmail.com"
+    gem.homepage = "http://github.com/sandro/specjour"
+    gem.authors = ["Sandro Turriate"]
+    gem.add_dependency "dnssd", "1.3.1"
+    gem.add_dependency "rspec"
+    gem.add_development_dependency "rspec", "1.3.0"
+    gem.add_development_dependency "yard", "0.5.3"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end
+
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'specjour/tasks/specjour'

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/bin/specjour

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'specjour'
+
+options = {:worker_size => 1, :batch_size => 25}
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: specjour [options]"
+
+  opts.on('-w', '--workers [WORKERS]', Numeric, "Number of WORKERS to spin up, defaults to #{options[:worker_size]}") do |n|
+    options[:worker_size] = n
+  end
+
+  opts.on('-b', '--batch-size [SIZE]', Integer, "Number of specs to run before reporting back to the dispatcher, defaults to #{options[:batch_size]}") do |n|
+    options[:batch_size] = n
+  end
+
+  opts.on('--do-work OPTIONS', Array, 'INTERNAL USE ONLY') do |args|
+    specs_to_run = args[3..-1]
+    options[:worker_args] = args[0], args[1], args[2], specs_to_run
+  end
+
+  opts.on_tail('-v', '--version', 'Show the version of specjour') do
+    abort Specjour::VERSION
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    summary = opts.to_a
+    summary.first << "\n"
+    abort summary.reject {|s| s =~ /INTERNAL/}.join
+  end
+end
+
+optparse.parse!
+
+if options[:worker_args]
+  options[:worker_args] << options[:batch_size]
+  Specjour::Worker.new(*options[:worker_args]).run
+else
+  Specjour::Manager.new(options[:worker_size], options[:batch_size]).start
+end

data/lib/specjour/core_ext/array.rb

@@ -0,0 +1,15 @@
+module Specjour
+  module Among
+    def among(group_size)
+      group_size = 1 if group_size.zero?
+      groups = Array.new(group_size) { [] }
+      offset = 0
+      each do |item|
+        groups[offset] << item
+        offset = (offset == group_size - 1) ? 0 : offset + 1
+      end
+      groups
+    end
+  end
+end
+::Array.send(:include, Specjour::Among)

data/lib/specjour/db_scrub.rb

@@ -0,0 +1,23 @@
+module Specjour
+  module DbScrub
+    extend self
+
+    def scrub
+      begin
+        ActiveRecord::Base.connection
+      rescue # assume the database doesn't exist
+        create_db_and_schema
+      else
+        ActiveRecord::Base.connection.tables.each do |table|
+          ActiveRecord::Base.connection.delete "delete from #{table}"
+        end
+      end
+    end
+
+    def create_db_and_schema
+      load 'Rakefile'
+      Rake::Task['db:create'].invoke
+      Rake::Task['db:schema:load'].invoke
+    end
+  end
+end

data/lib/specjour/dispatcher.rb

@@ -0,0 +1,113 @@
+module Specjour
+  class Dispatcher
+    require 'dnssd'
+    Thread.abort_on_exception = true
+
+    attr_reader :project_path, :managers, :manager_threads, :hosts
+    attr_accessor :worker_size
+
+    def initialize(project_path)
+      @project_path = project_path
+      @managers = []
+      @worker_size = 0
+      reset_manager_threads
+    end
+
+    def start
+      rsync_daemon.start
+      gather_managers
+      sync_managers
+      dispatch_work
+      printer.join
+    end
+
+    protected
+
+    def all_specs
+      @all_specs ||= Dir.chdir(project_path) do
+        Dir["spec/**/**/*_spec.rb"].partition {|f| f =~ /integration/}.flatten
+      end
+    end
+
+    def dispatch_work
+      distributable_specs = all_specs.among(worker_size)
+      last_index = 0
+      managers.each_with_index do |manager, index|
+        manager.specs_to_run = Array.new(manager.worker_size) do |i|
+          distributable_specs[last_index + i]
+        end
+        last_index += manager.worker_size
+        manager_threads << Thread.new(manager) {|m| m.dispatch}
+      end
+    end
+
+    def drb_start
+      DRb.start_service nil, self
+      at_exit { puts 'shutting down DRb client'; DRb.stop_service }
+    end
+
+    def fetch_manager(uri)
+      manager = DRbObject.new_with_uri(uri.to_s)
+      unless managers.include?(manager)
+        set_up_manager(manager, uri)
+        managers << manager
+        self.worker_size += manager.worker_size
+      end
+    end
+
+    def gather_managers
+      puts "Waiting for managers"
+      Signal.trap('INT') { exit }
+      browser = DNSSD::Service.new
+      browser.browse '_druby._tcp' do |reply|
+        if reply.flags.add?
+          resolve_reply(reply)
+        end
+        browser.stop unless reply.flags.more_coming?
+      end
+      puts "Managers found: #{managers.size}"
+      printer.worker_size = worker_size
+    end
+
+    def printer
+      @printer ||= Printer.new.start
+    end
+
+    def project_name
+      @project_name ||= File.basename(project_path)
+    end
+
+    def reset_manager_threads
+      @manager_threads = []
+    end
+
+    def resolve_reply(reply)
+      DNSSD.resolve!(reply) do |resolved|
+        uri = URI::Generic.build :scheme => reply.service_name, :host => resolved.target, :port => resolved.port
+        fetch_manager(uri)
+        resolved.service.stop if resolved.service.started?
+      end
+    end
+
+    def rsync_daemon
+      @rsync_daemon ||= RsyncDaemon.new(project_path, project_name)
+    end
+
+    def set_up_manager(manager, uri)
+      manager.project_name = project_name
+      manager.dispatcher_uri = URI::Generic.build :scheme => "specjour", :host => printer.host, :port => printer.port
+    end
+
+    def sync_managers
+      managers.each do |manager|
+        manager_threads << Thread.new(manager) { |manager| manager.sync }
+      end
+      wait_on_managers
+    end
+
+    def wait_on_managers
+      manager_threads.each {|t| t.join; t.exit}
+      reset_manager_threads
+    end
+  end
+end

data/lib/specjour/distributed_formatter.rb

@@ -0,0 +1,84 @@
+module Specjour
+  class DistributedFormatter < Spec::Runner::Formatter::BaseTextFormatter
+    require 'specjour/marshalable_rspec_failure'
+
+    class << self
+      attr_accessor :batch_size
+    end
+    @batch_size = 1
+
+    attr_reader :failing_messages, :passing_messages, :pending_messages, :output
+    attr_reader :duration, :example_count, :failure_count, :pending_count, :pending_examples, :failing_examples
+
+    def initialize(options, output)
+      @options = options
+      @output = output.extend Specjour::Protocol
+      @failing_messages = []
+      @passing_messages = []
+      @pending_messages = []
+      @pending_examples = []
+      @failing_examples = []
+    end
+
+    def example_failed(example, counter, failure)
+      failing_messages << colorize_failure('F', failure)
+      batch_print(failing_messages)
+    end
+
+    def example_passed(example)
+      passing_messages << green('.')
+      batch_print(passing_messages)
+    end
+
+    def example_pending(example, message, deprecated_pending_location=nil)
+      super
+      pending_messages << yellow('*')
+      batch_print(pending_messages)
+    end
+
+    def dump_summary(duration, example_count, failure_count, pending_count)
+      @duration = duration
+      @example_count = example_count
+      @failure_count = failure_count
+      @pending_count = pending_count
+      output.puts [:worker_summary=, to_hash]
+      output.flush
+    end
+
+    def dump_pending
+      #noop
+    end
+
+    def dump_failure(counter, failure)
+      failing_examples << failure
+    end
+
+    def start_dump
+      print_and_flush failing_messages
+      print_and_flush passing_messages
+      print_and_flush pending_messages
+    end
+
+    def to_hash
+      h = {}
+      [:duration, :example_count, :failure_count, :pending_count, :pending_examples, :failing_examples].each do |key|
+        h[key] = send(key)
+      end
+      h
+    end
+
+    protected
+
+    def batch_print(messages)
+      if messages.size == self.class.batch_size
+        print_and_flush(messages)
+      end
+    end
+
+    def print_and_flush(messages)
+      output.print messages.to_s
+      output.flush
+      messages.replace []
+    end
+  end
+end

data/lib/specjour/final_report.rb

@@ -0,0 +1,60 @@
+module Specjour
+  class FinalReport
+    require 'specjour/marshalable_rspec_failure'
+    attr_reader :duration, :example_count, :failure_count, :pending_count, :pending_examples, :failing_examples
+
+    def initialize
+      @duration = 0.0
+      @example_count = 0
+      @failure_count = 0
+      @pending_count = 0
+      @pending_examples = []
+      @failing_examples = []
+    end
+
+    def add(stats)
+      stats.each do |key, value|
+        if key == :duration
+          @duration = value.to_f if duration < value.to_f
+        else
+          increment(key, value)
+        end
+      end
+    end
+
+    def increment(key, value)
+      current = instance_variable_get("@#{key}")
+      instance_variable_set("@#{key}", current + value)
+    end
+
+    def formatter_options
+      @formatter_options ||= OpenStruct.new(
+        :colour   => true,
+        :autospec => false,
+        :dry_run  => false
+      )
+    end
+
+    def formatter
+      @formatter ||= begin
+        f = MarshalableFailureFormatter.new(formatter_options, $stdout)
+        f.instance_variable_set(:@pending_examples, pending_examples)
+        f
+      end
+    end
+
+    def summarize
+      if example_count > 0
+        formatter.dump_pending
+        dump_failures
+        formatter.dump_summary(duration, example_count, failure_count, pending_count)
+      end
+    end
+
+    def dump_failures
+      failing_examples.each_with_index do |failure, index|
+        formatter.dump_failure index + 1, failure
+      end
+    end
+  end
+end

data/lib/specjour/manager.rb

@@ -0,0 +1,67 @@
+module Specjour
+  class Manager
+    require 'dnssd'
+    include DRbUndumped
+
+    attr_accessor :project_name, :specs_to_run, :dispatcher_uri, :worker_size, :bonjour_service, :batch_size
+
+    def initialize(worker_size = 1, batch_size = 25)
+      @worker_size = worker_size
+      @batch_size = 25
+    end
+
+    def project_path=(name)
+      @project_path = name
+    end
+
+    def project_path
+      @project_path ||= File.join("/tmp", project_name)
+    end
+
+    def dispatch
+      bonjour_service.stop
+      pids = []
+      (1..worker_size).each do |index|
+        pids << fork do
+          exec("specjour --batch-size #{batch_size} --do-work #{project_path},#{dispatcher_uri},#{index},#{specs_to_run[index - 1].join(',')}")
+          Kernel.exit!
+        end
+      end
+      at_exit { Process.kill('KILL', *pids) rescue nil }
+      Process.waitall
+      bonjour_announce
+    end
+
+    def start
+      drb_start
+      bonjour_announce
+      Signal.trap('INT') { puts; puts "Shutting down manager..."; exit }
+      DRb.thread.join
+    end
+
+    def drb_start
+      DRb.start_service nil, self
+      Kernel.puts "Manager started at #{drb_uri}"
+      at_exit { DRb.stop_service }
+    end
+
+    def sync
+      cmd "rsync -a --port=8989 #{dispatcher_uri.host}::#{project_name} #{project_path}"
+    end
+
+    protected
+
+    def cmd(command)
+      Kernel.puts command
+      system command
+    end
+
+    def drb_uri
+      @drb_uri ||= URI.parse(DRb.uri)
+    end
+
+    def bonjour_announce
+      @bonjour_service = DNSSD.register! "specjour_manager_#{object_id}", "_#{drb_uri.scheme}._tcp", nil, drb_uri.port
+    end
+  end
+end

data/lib/specjour/marshalable_failure_formatter.rb

@@ -0,0 +1,11 @@
+module Specjour
+  class MarshalableFailureFormatter < Spec::Runner::Formatter::BaseTextFormatter
+    def dump_failure(counter, failure)
+      @output.puts
+      @output.puts "#{counter.to_s})"
+      @output.puts colorize_failure("#{failure.header}\n#{failure.message}", failure)
+      @output.puts format_backtrace(failure.backtrace)
+      @output.flush
+    end
+  end
+end

data/lib/specjour/marshalable_rspec_failure.rb

@@ -0,0 +1,33 @@
+module Specjour
+  class Spec::Runner::Reporter::Failure
+    attr_reader :backtrace, :message, :header, :exception_class_name
+
+    def initialize(group_description, example_description, exception)
+      @example_name = "#{group_description} #{example_description}"
+      @message = exception.message
+      @backtrace = exception.backtrace
+      @exception_class_name = exception.class.name
+      @pending_fixed = exception.is_a?(Spec::Example::PendingExampleFixedError)
+      @exception_not_met = exception.is_a?(Spec::Expectations::ExpectationNotMetError)
+      set_header
+    end
+
+    def set_header
+      if expectation_not_met?
+        @header = "'#{@example_name}' FAILED"
+      elsif pending_fixed?
+        @header = "'#{@example_name}' FIXED"
+      else
+        @header = "#{exception_class_name} in '#{@example_name}'"
+      end
+    end
+
+    def pending_fixed?
+      @pending_fixed
+    end
+
+    def expectation_not_met?
+      @exception_not_met
+    end
+  end
+end

data/lib/specjour/printer.rb

@@ -0,0 +1,65 @@
+module Specjour
+  class Printer < GServer
+    include Protocol
+    RANDOM_PORT = 0
+
+    attr_reader :completed_workers
+    attr_accessor :worker_size
+
+    def initialize
+      super(
+        port = RANDOM_PORT,
+        host = hostname,
+        max_connections = 100,
+        stdlog = $stderr,
+        audit = true,
+        debug = true
+      )
+      @completed_workers = 0
+    end
+
+    def serve(client)
+      client.each(TERMINATOR) do |data|
+        process load_object(data)
+      end
+    end
+
+    def worker_summary=(summary)
+      report.add(summary)
+    end
+
+    protected
+
+    def disconnecting(client_port)
+      @completed_workers += 1
+      if completed_workers == worker_size
+        stop
+      end
+    end
+
+    def hostname
+      @hostname ||= Socket.gethostname
+    end
+
+    def log(msg)
+      #noop
+    end
+
+    def process(message)
+      if message.is_a?(String)
+        $stdout.print message
+        $stdout.flush
+      elsif message.is_a?(Array)
+        send(message.first, message[1])
+      end
+    end
+
+    def report
+      @report ||= FinalReport.new
+    end
+
+    def stopping
+      report.summarize
+    end
+  end
+end

data/lib/specjour/protocol.rb

@@ -0,0 +1,21 @@
+module Specjour
+  module Protocol
+    TERMINATOR = "|ruojceps|"
+
+    def puts(arg)
+      print(arg << "\n")
+    end
+
+    def print(arg)
+      super dump_object(arg)
+    end
+
+    def dump_object(data)
+      Marshal.dump(data) << TERMINATOR
+    end
+
+    def load_object(data)
+      Marshal.load(data.sub(/#{TERMINATOR}$/, ''))
+    end
+  end
+end

data/lib/specjour/rsync_daemon.rb

@@ -0,0 +1,60 @@
+module Specjour
+  class RsyncDaemon
+    require 'fileutils'
+
+    attr_reader :project_path, :project_name
+    def initialize(project_path, project_name)
+      @project_path = project_path
+      @project_name = project_name
+    end
+
+    def config_file
+      File.join("/tmp", "rsyncd.conf")
+    end
+
+    def start
+      write_config
+      system("rsync", "--daemon", "--config=#{config_file}", "--port=8989")
+      at_exit { puts 'shutting down rsync'; stop }
+    end
+
+    def stop
+      if pid
+        Process.kill("TERM", pid)
+        FileUtils.rm(pid_file)
+      end
+    end
+
+    protected
+
+    def write_config
+      File.open(config_file, 'w') do |f|
+        f.write config
+      end
+    end
+
+    def pid
+      if File.exists?(pid_file)
+        File.read(pid_file).strip.to_i
+      end
+    end
+
+    def pid_file
+      File.join("/tmp", "#{project_name}_rsync_daemon.pid")
+    end
+
+    def config
+      <<-CONFIG
+# global configuration
+use chroot = no
+timeout = 60
+read only = yes
+pid file = #{pid_file}
+
+[#{project_name}]
+  path = #{project_path}
+  exclude = .git* doc tmp/* public log script
+      CONFIG
+    end
+  end
+end

data/lib/specjour/tasks/dispatch.rake

@@ -0,0 +1,13 @@
+require 'specjour'
+
+namespace :specjour do
+  task :dispatch, [:project_path] do |task, args|
+    args.with_defaults :project_path => Rake.original_dir
+    Specjour::Dispatcher.new(args.project_path).start
+  end
+end
+
+desc "Dispatch the [project_path] to listening managers"
+task :specjour, [:project_path] do |task, args|
+  Rake::Task['specjour:dispatch'].invoke(args[:project_path])
+end

data/lib/specjour/tasks/specjour.rb

@@ -0,0 +1 @@
+load File.join(File.dirname(__FILE__), "dispatch.rake")

data/lib/specjour/worker.rb

@@ -0,0 +1,55 @@
+module Specjour
+  class Worker
+    attr_accessor :dispatcher_uri
+    attr_reader :project_path, :specs_to_run, :number, :batch_size
+
+    def initialize(project_path, dispatcher_uri, number, specs_to_run, batch_size)
+      @project_path = project_path
+      @specs_to_run = specs_to_run
+      @number = number.to_i
+      @batch_size = batch_size.to_i
+      self.dispatcher_uri = dispatcher_uri
+    end
+
+    def dispatcher_uri=(val)
+      @dispatcher_uri = URI.parse(val)
+    end
+
+    def run
+      puts "Running #{specs_to_run.size} spec files..."
+      GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
+      DistributedFormatter.batch_size = batch_size
+      Dir.chdir(project_path) do
+        set_env_variables
+        options = Spec::Runner::OptionParser.parse(
+          rspec_options,
+          STDERR,
+          dispatcher
+        )
+        Spec::Runner.use options
+        options.run_examples
+        Spec::Runner.options.instance_variable_set(:@examples_run, true)
+      end
+    end
+
+    protected
+
+    def dispatcher
+      @dispatcher ||= TCPSocket.open dispatcher_uri.host, dispatcher_uri.port
+    end
+
+    def rspec_options
+      %w(--format=Specjour::DistributedFormatter) + specs_to_run
+    end
+
+    def set_env_variables
+      ENV['PREPARE_DB'] = 'true'
+      ENV['RSPEC_COLOR'] = 'true'
+      if number > 1
+        ENV['TEST_ENV_NUMBER'] = number.to_s
+      else
+        ENV['TEST_ENV_NUMBER'] = nil
+      end
+    end
+  end
+end

data/lib/specjour.rb

@@ -0,0 +1,22 @@
+require 'spec'
+require 'spec/runner/formatter/base_text_formatter'
+require 'specjour/protocol'
+require 'specjour/core_ext/array'
+
+autoload :URI, 'uri'
+autoload :DRb, 'drb'
+autoload :Forwardable, 'forwardable'
+autoload :GServer, 'gserver'
+
+module Specjour
+  autoload :Dispatcher, 'specjour/dispatcher'
+  autoload :DistributedFormatter, 'specjour/distributed_formatter'
+  autoload :FinalReport, 'specjour/final_report'
+  autoload :Manager, 'specjour/manager'
+  autoload :MarshalableFailureFormatter, 'specjour/marshalable_failure_formatter'
+  autoload :Printer, 'specjour/printer'
+  autoload :RsyncDaemon, 'specjour/rsync_daemon'
+  autoload :Worker, 'specjour/worker'
+
+  VERSION = "0.1.1".freeze
+end

data/rails/init.rb

@@ -0,0 +1,4 @@
+if ENV['PREPARE_DB']
+  require 'specjour/db_scrub'
+  Specjour::DbScrub.scrub
+end

data/spec/lib/specjour/core_ext/array_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Array splitting among many" do
+  describe "#among" do
+    let(:array) { [1,2,3,4,5] }
+
+    it "splits among 0" do
+      array.among(0).should == [[1,2,3,4,5]]
+    end
+
+    it "splits among by 1" do
+      array.among(1).should == [[1,2,3,4,5]]
+    end
+
+    it "splits among by 2" do
+      array.among(2).should == [[1,3,5],[2,4]]
+    end
+
+    it "splits among by 3" do
+      array.among(3).should == [[1,4],[2,5],[3]]
+    end
+
+    it "splits among by 4" do
+      array.among(4).should == [[1,5],[2],[3],[4]]
+    end
+
+    it "splits among by 5" do
+      array.among(5).should == [[1],[2],[3],[4],[5]]
+    end
+  end
+end

data/spec/lib/specjour/worker_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+class CustomException < RuntimeError
+end
+
+def boo
+  raise CustomException, 'fails'
+end
+
+describe Specjour::Worker do
+  it "fails" do
+    boo
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'specjour'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/specjour_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Specjour do
+  it "lives"
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification 
+name: specjour
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Sandro Turriate
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-20 00:00:00 -04:00
+default_executable: specjour
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dnssd
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 1
+        version: 1.3.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 3
+        version: 0.5.3
+  type: :development
+  version_requirements: *id004
+description: Distribute your spec suite amongst your LAN via Bonjour.
+email: sandro.turriate@gmail.com
+executables: 
+- specjour
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .document
+- .gitignore
+- MIT_LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- bin/specjour
+- lib/specjour.rb
+- lib/specjour/core_ext/array.rb
+- lib/specjour/db_scrub.rb
+- lib/specjour/dispatcher.rb
+- lib/specjour/distributed_formatter.rb
+- lib/specjour/final_report.rb
+- lib/specjour/manager.rb
+- lib/specjour/marshalable_failure_formatter.rb
+- lib/specjour/marshalable_rspec_failure.rb
+- lib/specjour/printer.rb
+- lib/specjour/protocol.rb
+- lib/specjour/rsync_daemon.rb
+- lib/specjour/tasks/dispatch.rake
+- lib/specjour/tasks/specjour.rb
+- lib/specjour/worker.rb
+- rails/init.rb
+- spec/lib/specjour/core_ext/array_spec.rb
+- spec/lib/specjour/worker_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/specjour_spec.rb
+has_rdoc: true
+homepage: http://github.com/sandro/specjour
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Distribute your spec suite amongst your LAN via Bonjour.
+test_files: 
+- spec/lib/specjour/core_ext/array_spec.rb
+- spec/lib/specjour/worker_spec.rb
+- spec/spec_helper.rb
+- spec/specjour_spec.rb