parallelized_specs 0.0.5 → 0.0.6

data/lib/tasks/parallelized_specs.rake

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "/../parallelized_specs/tasks")

data/parallelized_specs.gemspec

@@ -5,13 +5,13 @@
 
 Gem::Specification.new do |s|
   s.name = "parallelized_specs"
-  s.version = "0.0.5"
+  s.version = "0.0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jake Sorce, Bryan Madsen"]
-  s.date = "2012-04-18"
+  s.date = "2012-04-19"
   s.email = "jake@instructure.com"
-  s.executables = ["parallelized_spec", "parallelized_test"]
+  s.executables = ["parallelized_spec"]
   s.files = [
     "Gemfile",
     "Gemfile.lock",
@@ -19,8 +19,10 @@ Gem::Specification.new do |s|
     "Readme.md",
     "VERSION",
     "bin/parallelized_spec",
-    "bin/parallelized_test",
     "lib/parallelized_specs.rb",
+    "lib/parallelized_specs/grouper.rb",
+    "lib/parallelized_specs/railtie.rb",
+    "lib/parallelized_specs/runtime_logger.rb",
     "lib/parallelized_specs/spec_error_count_logger.rb",
     "lib/parallelized_specs/spec_error_logger.rb",
     "lib/parallelized_specs/spec_failures_logger.rb",
@@ -28,20 +30,13 @@ Gem::Specification.new do |s|
     "lib/parallelized_specs/spec_runtime_logger.rb",
     "lib/parallelized_specs/spec_start_finish_logger.rb",
     "lib/parallelized_specs/spec_summary_logger.rb",
-    "lib/parallelized_tests.rb",
-    "lib/parallelized_tests/grouper.rb",
-    "lib/parallelized_tests/railtie.rb",
-    "lib/parallelized_tests/runtime_logger.rb",
-    "lib/parallelized_tests/tasks.rb",
-    "lib/tasks/parallelized_tests.rake",
+    "lib/parallelized_specs/tasks.rb",
+    "lib/tasks/parallelized_specs.rake",
     "parallelized_specs.gemspec",
-    "spec/integration_spec.rb",
     "spec/parallelized_specs/spec_failure_logger_spec.rb",
     "spec/parallelized_specs/spec_runtime_logger_spec.rb",
     "spec/parallelized_specs/spec_summary_logger_spec.rb",
     "spec/parallelized_specs_spec.rb",
-    "spec/parallelized_tests/runtime_logger_spec.rb",
-    "spec/parallelized_tests_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/jakesorce/parallelized_specs"
@@ -53,12 +48,9 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<parallel>, [">= 0"])
     else
-      s.add_dependency(%q<parallel>, [">= 0"])
     end
   else
-    s.add_dependency(%q<parallel>, [">= 0"])
   end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: parallelized_specs
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Jake Sorce, Bryan Madsen
@@ -15,27 +15,13 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-18 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: parallel
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id001
+date: 2012-04-19 00:00:00 Z
+dependencies: []
+
 description: 
 email: jake@instructure.com
 executables: 
 - parallelized_spec
-- parallelized_test
 extensions: []
 
 extra_rdoc_files: []
@@ -47,8 +33,10 @@ files:
 - Readme.md
 - VERSION
 - bin/parallelized_spec
-- bin/parallelized_test
 - lib/parallelized_specs.rb
+- lib/parallelized_specs/grouper.rb
+- lib/parallelized_specs/railtie.rb
+- lib/parallelized_specs/runtime_logger.rb
 - lib/parallelized_specs/spec_error_count_logger.rb
 - lib/parallelized_specs/spec_error_logger.rb
 - lib/parallelized_specs/spec_failures_logger.rb
@@ -56,20 +44,13 @@ files:
 - lib/parallelized_specs/spec_runtime_logger.rb
 - lib/parallelized_specs/spec_start_finish_logger.rb
 - lib/parallelized_specs/spec_summary_logger.rb
-- lib/parallelized_tests.rb
-- lib/parallelized_tests/grouper.rb
-- lib/parallelized_tests/railtie.rb
-- lib/parallelized_tests/runtime_logger.rb
-- lib/parallelized_tests/tasks.rb
-- lib/tasks/parallelized_tests.rake
+- lib/parallelized_specs/tasks.rb
+- lib/tasks/parallelized_specs.rake
 - parallelized_specs.gemspec
-- spec/integration_spec.rb
 - spec/parallelized_specs/spec_failure_logger_spec.rb
 - spec/parallelized_specs/spec_runtime_logger_spec.rb
 - spec/parallelized_specs/spec_summary_logger_spec.rb
 - spec/parallelized_specs_spec.rb
-- spec/parallelized_tests/runtime_logger_spec.rb
-- spec/parallelized_tests_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/jakesorce/parallelized_specs
 licenses: []

data/bin/parallelized_test

@@ -1,96 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-require 'optparse'
-require 'parallel'
-raise "please ' gem install parallel '" if Gem::Version.new(Parallel::VERSION) < Gem::Version.new('0.4.2')
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
-require "parallelized_tests"
-
-options = {}
-OptionParser.new do |opts|
-  opts.banner = <<BANNER
-Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2', '3', ...)
-
-[optional] Only run selected files & folders:
-    parallelized_test test/bar test/baz/xxx_text.rb
-
-Options are:
-BANNER
-  opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs"){|n| options[:count] = n }
-  opts.on("-p", '--pattern [PATTERN]', "run tests matching this pattern"){|pattern| options[:pattern] = pattern }
-  opts.on("--no-sort", "do not sort files before running them"){ |no_sort| options[:no_sort] = no_sort }
-  opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run"){ |multiply| options[:multiply] = multiply }
-  opts.on("-r", '--root [PATH]', "execute test commands from this path"){|path| options[:root] = path }
-  opts.on("-s [PATTERN]", "--single [PATTERN]", "Run all matching files in only one process") do |pattern|
-    options[:single_process] ||= []
-    options[:single_process] << /#{pattern}/
-  end
-  opts.on("-e", '--exec [COMMAND]', "execute this code parallel and with ENV['TEST_ENV_NUM']"){|path| options[:execute] = path }
-  opts.on("-o", "--test-options '[OPTIONS]'", "execute test commands with those options"){|arg| options[:test_options] = arg }
-  opts.on("-t", "--type [TYPE]", "which type of tests to run? test, spec or features"){|type| options[:type] = type }
-  opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec"){ options[:non_parallel] = true }
-  opts.on("--chunk-timeout [TIMEOUT]", "timeout before re-printing the output of a child-process"){|timeout| options[:chunk_timeout] = timeout.to_f }
-  opts.on('-v', '--version', 'Show Version'){ puts ParallelizedTests::VERSION; exit}
-  opts.on("-h", "--help", "Show this.") { puts opts; exit }
-end.parse!
-
-raise "--no-sort and --single-process are not supported" if options[:no_sort] and options[:single_process]
-
-# get files to run from arguments
-options[:files] = ARGV if ARGV.size > 0
-
-num_processes = options[:count] || Parallel.processor_count
-num_processes = num_processes * (options[:multiply] || 1)
-
-if options[:execute]
-  runs = (0...num_processes).to_a
-  results = if options[:non_parallel]
-    runs.map do |i|
-      ParallelizedTests.execute_command(options[:execute], i, options)
-    end
-  else
-    Parallel.map(runs, :in_processes => num_processes) do |i|
-      ParallelizedTests.execute_command(options[:execute], i, options)
-    end
-  end.flatten
-  abort if results.any?{|r| r[:exit_status] != 0 }
-else
-  lib, name, task = {
-    'test' => ["tests", "test", "test"],
-    'spec' => ["specs", "spec", "spec"],
-  }[options[:type]||'test']
-
-  require "parallelized_#{lib}"
-  klass = eval("Parallelized#{lib.capitalize}")
-
-  start = Time.now
-
-  tests_folder = task
-  tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
-
-  groups = klass.tests_in_groups(options[:files] || tests_folder, num_processes, options)
-  num_processes = groups.size
-
-  #adjust processes to groups
-  abort "no #{name}s found!" if groups.size == 0
-
-  num_tests = groups.inject(0){|sum,item| sum + item.size }
-  puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
-
-  test_results = Parallel.map(groups, :in_processes => num_processes) do |group|
-    klass.run_tests(group, groups.index(group), options)
-  end
-
-  #parse and print results
-  results = klass.find_results(test_results.map{|result| result[:stdout] }*"")
-  puts ""
-  puts klass.summarize_results(results)
-
-  #report total time taken
-  puts ""
-  puts "Took #{Time.now - start} seconds"
-
-  #exit with correct status code so rake parallel:test && echo 123 works
-  failed = test_results.any?{|result| result[:exit_status] != 0 }
-  abort "#{name.capitalize}s Failed" if failed
-end

data/lib/parallelized_tests.rb

@@ -1,163 +0,0 @@
-require 'parallel'
-require 'parallelized_tests/grouper'
-require 'parallelized_tests/railtie'
-
-class ParallelizedTests
-  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
-
-  # parallel:spec[:count, :pattern, :options]
-  def self.parse_rake_args(args)
-    # order as given by user
-    args = [args[:count], args[:pattern], args[:options]]
-
-    # count given or empty ?
-    # parallel:spec[2,models,options]
-    # parallel:spec[,models,options]
-    count = args.shift if args.first.to_s =~ /^\d*$/
-    num_processes = count.to_i unless count.to_s.empty?
-    num_processes ||= ENV['PARALLEL_TEST_PROCESSORS'].to_i if ENV['PARALLEL_TEST_PROCESSORS']
-    num_processes ||= Parallel.processor_count
-
-    pattern = args.shift
-    options = args.shift
-
-    [num_processes.to_i, pattern.to_s, options.to_s]
-  end
-
-  # finds all tests and partitions them into groups
-  def self.tests_in_groups(root, num_groups, options={})
-    tests = find_tests(root, options)
-    if options[:no_sort] == true
-      Grouper.in_groups(tests, num_groups)
-    else
-      tests = with_runtime_info(tests)
-      Grouper.in_even_groups_by_size(tests, num_groups, options)
-    end
-  end
-
-  def self.run_tests(test_files, process_number, options)
-    require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
-    cmd = "ruby -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
-    execute_command(cmd, process_number, options)
-  end
-
-  def self.execute_command(cmd, process_number, options)
-    cmd = "TEST_ENV_NUMBER=#{test_env_number(process_number)} ; export TEST_ENV_NUMBER; #{cmd}"
-    f = open("|#{cmd}", 'r')
-    output = fetch_output(f, options)
-    f.close
-    {:stdout => output, :exit_status => $?.exitstatus}
-  end
-
-  def self.find_results(test_output)
-    test_output.split("\n").map {|line|
-      line = line.gsub(/\.|F|\*/,'')
-      next unless line_is_result?(line)
-      line
-    }.compact
-  end
-
-  def self.test_env_number(process_number)
-    process_number == 0 ? '' : process_number + 1
-  end
-
-  def self.runtime_log
-    'tmp/parallelized_runtime_test.log'
-  end
-
-  def self.summarize_results(results)
-    results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
-    counts = results.scan(/(\d+) (\w+)/)
-    sums = counts.inject(Hash.new(0)) do |sum, (number, word)|
-      sum[word] += number.to_i
-      sum
-    end
-    sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
-  end
-
-  protected
-
-  # read output of the process and print in in chucks
-  def self.fetch_output(process, options)
-    all = ''
-    buffer = ''
-    timeout = options[:chunk_timeout] || 0.2
-    flushed = Time.now.to_f
-
-    while char = process.getc
-      char = (char.is_a?(Fixnum) ? char.chr : char) # 1.8 <-> 1.9
-      all << char
-
-      # print in chunks so large blocks stay together
-      now = Time.now.to_f
-      buffer << char
-      if flushed + timeout < now
-        print buffer
-        STDOUT.flush
-        buffer = ''
-        flushed = now
-      end
-    end
-
-    # print the remainder
-    print buffer
-    STDOUT.flush
-
-    all
-  end
-
-  # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
-  def self.bundler_enabled?
-    return true if Object.const_defined?(:Bundler)
-
-    previous = nil
-    current = File.expand_path(Dir.pwd)
-
-    until !File.directory?(current) || current == previous
-      filename = File.join(current, "Gemfile")
-      return true if File.exists?(filename)
-      current, previous = File.expand_path("..", current), current
-    end
-
-    false
-  end
-
-  def self.line_is_result?(line)
-    line =~ /\d+ failure/
-  end
-
-  def self.test_suffix
-    "_test.rb"
-  end
-
-  def self.with_runtime_info(tests)
-    lines = File.read(runtime_log).split("\n") rescue []
-
-    # use recorded test runtime if we got enough data
-    if lines.size * 1.5 > tests.size
-      puts "Using recorded test runtime"
-      times = Hash.new(1)
-      lines.each do |line|
-        test, time = line.split(":")
-        next unless test and time
-        times[File.expand_path(test)] = time.to_f
-      end
-      tests.sort.map{|test| [test, times[test]] }
-    else # use file sizes
-      tests.sort.map{|test| [test, File.stat(test).size] }
-    end
-  end
-
-  def self.find_tests(root, options={})
-    if root.is_a?(Array)
-      root
-    else
-      # follow one symlink and direct children
-      # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
-      files = Dir["#{root}/**{,/*/**}/*#{test_suffix}"].uniq
-      files = files.map{|f| f.sub(root+'/','') }
-      files = files.grep(/#{options[:pattern]}/)
-      files.map{|f| "#{root}/#{f}" }
-    end
-  end
-end

data/lib/parallelized_tests/runtime_logger.rb

@@ -1,78 +0,0 @@
-class ParallelizedTests::RuntimeLogger
-  @@has_started = false
-
-  def self.log(test, start_time, end_time)
-    return if test.is_a? Test::Unit::TestSuite  # don't log for suites-of-suites
-
-    if !@@has_started # make empty log file 
-      File.open(ParallelizedTests.runtime_log, 'w') do end
-      @@has_started = true
-    end
-
-    File.open(ParallelizedTests.runtime_log, 'a') do |output|
-      begin
-        output.flock File::LOCK_EX
-        output.puts(self.message(test, start_time, end_time))
-      ensure
-        output.flock File::LOCK_UN
-      end
-    end
-  end
-
-  def self.message(test, start_time, end_time)
-    delta="%.2f" % (end_time.to_f-start_time.to_f)
-    filename=class_directory(test.class) + class_to_filename(test.class) + ".rb"
-    message="#{filename}:#{delta}"
-  end
-
-  # Note: this is a best guess at conventional test directory structure, and may need
-  # tweaking / post-processing to match correctly for any given project
-  def self.class_directory(suspect)
-    result = "test/"
-
-    if defined?(Rails)
-      result += case suspect.superclass.name
-                when "ActionDispatch::IntegrationTest"
-                  "integration/"
-                when "ActionDispatch::PerformanceTest"
-                  "performance/"
-                when "ActionController::TestCase"
-                  "functional/"
-                when "ActionView::TestCase"
-                  "unit/helpers/"
-                else
-                  "unit/"
-                end
-    end
-    result
-  end
-
-  # based on https://github.com/grosser/single_test/blob/master/lib/single_test.rb#L117
-  def self.class_to_filename(suspect)
-    word = suspect.to_s.dup
-    return word unless word.match /^[A-Z]/ and not word.match %r{/[a-z]}
-
-    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-    word.gsub!(/\:\:/,'/')
-    word.tr!("-", "_")
-    word.downcase!
-    word
-  end
-
-end
-
-require 'test/unit/testsuite'
-class Test::Unit::TestSuite
-
-  alias :run_without_timing :run unless defined? @@timing_installed
-
-  def run(result, &progress_block)
-    start_time=Time.now
-    run_without_timing(result, &progress_block)
-    end_time=Time.now
-    ParallelizedTests::RuntimeLogger.log(self.tests.first, start_time, end_time)
-  end
-  @@timing_installed = true
-
-end