polyamory 0.0.5 → 0.6.0

data/README.md

@@ -1,35 +1,43 @@
-# Polyamory
+# Polyamory – the promiscuous test runner
 
-Polyamory loves *all* of your testing frameworks. It is a command-line tool that is able to run your test files regardless of the framework being used.
+Polyamory is a command-line tool that knows how to run your tests regardless of
+the framework. It can either run the whole test suite or filter by keywords,
+test case names, or tags. It remembers the differences between arguments for
+different testing frameworks so you don't have to.
+
+Frameworks supported:
+
+* Cucumber in `features/**/*.feature`
+* RSpec + Shoulda in `spec/**/*_spec.rb`
+* test/unit, Shoulda, or anything else in `test/**/*_test.rb` or `test/**/test*.rb`
 
 Features:
 
-* easily run the full test suite for any project: just type `polyamory`
-* use a directory name on the command line to run everything inside that directory
-* use a keyword to run all test files which contain that word
-* Bundler support
+*   `polyamory` - Runs the full test suite for any project. For example, it will
+    run all of the following:
 
-Frameworks supported:
+        rspec spec
+        cucumber features
+        ruby -e 'ARGV.each {|f| require f }' test/**/*_test.rb
+
+*   `polyamory <dirname>` - Runs all tests inside a subdirectory. For example:
+
+        polyamory models
+        -> runs test/models/**/*_test.rb
+        -> runs spec/models/**/*_spec.rb
+
+*   `polyamory <keyword>` - Runs all test files that match a keyword. For example:
+
+        polyamory search
+        -> runs test/models/user_search_test.rb
+        -> runs spec/controllers/search_controller_spec.rb
+        -> runs features/site_search.feature
+
+*   `polyamory <file>:<line>` - Runs focused test. Provides this feature for
+    test/unit and minitest which don't support it.
+
+*   `polyamory -n <pattern>` - Runs only tests whose names match given patterns.
 
-* Cucumber in `"features/**/*.feature"`
-* RSpec + Shoulda in `"spec/**/*_spec.rb"`
-* test/unit, Shoulda, or anything else in `"test/**/*_test.rb"`
-
-## Examples
-
-Here, `polyamory` is aliased as `pam` for brevity.
-
-    # run everything
-    $ pam
-    > rspec spec &&
-      cucumber -f progress -t ~@wip features &&
-      polyamory -t test
-    
-    # everyting inside a single directory
-    $ pam test/unit
-    > polyamory -t test/unit
-    
-    # run test files matching keyword
-    $ pam user
-    > polyamory -t spec/models/user_spec.rb spec/controllers/user_controller.rb &&
-      cucumber -f progress -t ~@wip features/user_registration.feature 
+*   `polyamory -t <tag>` - Runs RSpec/Cucumber tests that match given tags.
+    Tag exclusion is done with `~<tag>`. Tag names are normalized for Cucumber
+    (which expects them in form of `@<tag>`).

data/bin/polyamory

@@ -1,24 +1,31 @@
 #!/usr/bin/env ruby
+require 'polyamory'
+
 if ARGV.delete '-t'
-  test_files = ARGV.map { |arg|
-    unless arg.index('-') == 0
-      if File.directory? arg
-        Dir["#{arg}/**/*_test.rb", "#{arg}/**/test_*.rb"]
-      else
-        arg
-      end
+  root = Pathname.pwd
+
+  if idx = ARGV.index('--')
+    names = ARGV[0...idx]
+    ARGV.slice! 0..idx
+  else
+    names = ARGV.dup
+    ARGV.clear
+  end
+
+  test_files = names.map { |arg|
+    if File.directory? arg
+      locator = Polyamory.new(names, root)
+      locator.find_test_files(root + arg)
+    else
+      arg
     end
   }.compact.flatten
-  
+
   if test_files.empty?
-    warn "polyamory: nothing to load"
-    exit 1
+    abort "polyamory: nothing to load"
   else
-    test_files.each { |f| load f }
+    test_files.each { |f| require root + f }
   end
 else
-  require 'polyamory'
-  options = {}
-  options[:noop] = !!ARGV.delete('-n')
-  Polyamory.run ARGV, Dir.pwd, options
+  Polyamory.run ARGV, Dir.pwd
 end

data/lib/polyamory.rb

@@ -1,217 +1,82 @@
-require 'pathname'
+require 'optparse'
+require 'polyamory/runner'
 
-class Polyamory
-  def self.run(*args)
-    new(*args).run
-  end
-  
-  def initialize(names, root, options = {})
-    @names = names
-    @root = Pathname.new(root).expand_path
-    @options = options
-  end
-  
-  def noop?
-    @options[:noop]
-  end
-  
-  def file_exists?(path)
-    (@root + path).exist?
-  end
-  
-  def bundler?
-    file_exists? 'Gemfile'
-  end
-  
-  def test_dir
-    @root + 'test'
-  end
-  
-  def test_glob(dir = test_dir)
-    ["#{dir}/**/*_test.rb", "#{dir}/**/test_*.rb"]
-  end
-  
-  def spec_dir
-    @root + 'spec'
-  end
-  
-  def spec_glob(dir = spec_dir)
-    "#{dir}/**/*_spec.rb"
-  end
-  
-  def features_dir
-    @root + 'features'
-  end
-  
-  def features_glob(dir = features_dir)
-    "#{dir}/**/*.feature"
+module Polyamory
+  VERSION = '0.6.0'
+
+  def self.run(args, dir)
+    options = parse_options! args
+    Runner.new(args, dir, options).run
   end
-  
-  class Pathname < Pathname
-    attr_reader :root
-    
-    def self.glob(patterns, root)
-      patterns = Array(patterns)
-      Dir[*patterns].map do |path|
-        self.new(path, root)
+
+  def self.parse_options!(args)
+    options = {
+      :warnings     => false,
+      :verbose      => false,
+      :backtrace    => nil,
+      :test_seed    => nil,
+      :bundler      => nil,
+      :name_filters => [],
+      :tag_filters  => [],
+      :load_paths   => [],
+    }
+
+    OptionParser.new do |opts|
+      opts.banner  = 'Usage: polyamory [<dirname>] [<file>[:<line>]] [-n <pattern>] [-t <tag>]'
+      opts.version = VERSION
+
+      opts.summary_indent = " " * 4
+
+      opts.separator "\n  Ruby options:"
+
+      opts.on '-w', "Turn on Ruby warnings" do
+        options[:warnings] = true
       end
-    end
-    
-    def initialize(path, root_path = nil)
-      super(path)
-      self.root = root_path
-    end
-    
-    def root=(path)
-      @relativized = nil
-      @root = path
-    end
-    
-    def relative
-      @relativized ||= relative_path_from root
-    end
-    
-    def =~(pattern)
-      relative.to_s =~ pattern
-    end
-    
-    def +(other)
-      result = self.class.new(plus(@path, other.to_s))
-      result.root ||= self
-      result
-    end
-  end
-  
-  def find_files
-    all_paths = Pathname.glob([test_glob, spec_glob, features_glob].flatten, @root)
-    
-    if @names.any?
-      @names.map { |name|
-        path = @root + name
-        pattern = /\b#{Regexp.escape name}(\b|_)/
-        
-        if path.directory? or not path.extname.empty?
-          path
-        else
-          all_paths.select { |p| p =~ pattern }
-        end
-      }.flatten
-    else
-      [test_dir, spec_dir, features_dir].select { |p| p.directory? }
-    end
-  end
-  
-  def relativize(paths)
-    Array(paths).map { |p| p.relative }
-  end
-  
-  def run
-    paths = relativize(find_files)
-    if paths.empty?
-      warn "nothing found to run"
-      exit 1
-    end
-    
-    jobs = index_by_path_prefix(paths).map do |prefix, files|
-      [runner_for_prefix(prefix), *files].flatten
-    end
-    
-    prepare_env
-    execute_jobs jobs
-  end
-  
-  def runner_for_prefix(prefix)
-    case prefix
-    when 'features' then %w[cucumber -f progress -t ~@wip]
-    when 'spec' then detect_rspec_version
-    when 'test' then %w[polyamory -t]
-    else
-      raise ArgumentError, "don't know a runner for #{prefix}"
-    end
-  end
-  
-  def detect_rspec_version
-    helper = 'spec/spec_helper.rb'
-    
-    if file_exists? 'spec/spec.opts' or file_exists? 'lib/tasks/rspec.rake'
-      'spec'
-    elsif file_exists? '.rspec'
-      'rspec'
-    elsif file_exists? helper
-      File.open(helper) do |file|
-        while file.gets
-          return $&.downcase if $_ =~ /\bR?Spec\b/
-        end
+
+      opts.on '-I PATH', "Directory to load on $LOAD_PATH" do |str|
+        options[:load_paths] << str
       end
-      'rspec'
-    else
-      'rspec'
-    end
-  end
-  
-  def index_by_path_prefix(paths)
-    paths.inject(Hash.new {|h,k| h[k] = [] }) do |index, path|
-      prefix = path.to_s.split('/', 2).first
-      index[prefix] << path
-      index
-    end
-  end
-  
-  def execute_jobs(jobs)
-    if jobs.size > 1
-      jobs.each { |j| cmd(j, true) }
-    else
-      cmd(jobs.first)
-    end
-  end
-  
-  def prepare_cmdline(args)
-    args = args.map { |p| p.to_s }
-    args = %w[bundle exec] + args if bundler?
-    args
-  end
-  
-  def cmd(args, many = false)
-    args = prepare_cmdline(args)
-    puts args.join(' ')
-
-    unless noop?
-      # TODO: hack; make this configurable, use bundler
-      with_rubyopt(!bundler? ? '-rubygems' : nil) do
-        with_rubylib('lib', args.include?('polyamory') ? 'test' : nil) do
-          if many
-            system(*args)
-            exit $?.exitstatus unless $?.success?
-          else
-            exec(*args)
-          end
-        end
+
+      opts.separator "\n  Test options:"
+
+      opts.on '-s', '--seed SEED', Integer, "Set random seed" do |m|
+        options[:test_seed] = m.to_i
+      end
+
+      opts.on '-b', '--[no-]backtrace', "Show full backtrace" do |set|
+        options[:backtrace] = set
+      end
+
+      opts.on '-n', '--name PATTERN', "Filter test names on pattern" do |str|
+        options[:name_filters] << str
+      end
+
+      opts.on '-t', '--tag TAG', "Filter tests on tag" do |str|
+        options[:tag_filters] << str
+      end
+
+      opts.on '-v', '--verbose', "Show progress processing files" do
+        options[:verbose] = true
+      end
+
+      opts.on '--[no-]bundler', "Use `bundle exec' for running tests" do |set|
+        options[:bundler] = set
+      end
+
+      opts.separator "\n  Other options:"
+
+      opts.on_tail '-h', '--help', 'Display this help' do
+        puts opts
+        exit
+      end
+
+      begin
+        opts.parse! args
+      rescue OptionParser::InvalidOption
+        abort opts.banner
       end
     end
+
+    options
   end
-  
-  def with_rubyopt(value)
-    with_env('RUBYOPT', "#{value} %s") { yield }
-  end
-  
-  def with_rubylib(*values)
-    value = values.flatten.compact.join(':')
-    with_env('RUBYLIB', "#{value}:%s") { yield }
-  end
-  
-  def with_env(key, value)
-    old_value = ENV[key]
-    ENV[key] = value % old_value
-    
-    begin
-      yield
-    ensure
-      ENV[key] = old_value
-    end
-  end
-  
-  def prepare_env
-    # TODO: make this per-job
-    ENV['RUBYOPT'] = ENV['RUBYOPT'].gsub(/(^| )-w( |$)/, '\1\2') if ENV['RUBYOPT']
-  end
-end
+end

data/lib/polyamory/command.rb

@@ -0,0 +1,25 @@
+require 'forwardable'
+
+module Polyamory
+  # Internal: Represents a single command to run.
+  class Command
+    attr_reader :env
+
+    def initialize cmd
+      @args = Array(cmd)
+      @env  = Hash.new
+      yield self if block_given?
+    end
+
+    extend Forwardable
+    def_delegators :@args, :<<, :concat
+
+    def to_exec
+      @args.map {|a| a.to_s }
+    end
+
+    def to_s
+      to_exec.join(' ')
+    end
+  end
+end

data/lib/polyamory/cucumber.rb

@@ -0,0 +1,50 @@
+require 'polyamory/rspec'
+require 'polyamory/command'
+
+module Polyamory
+  # Internal: Deals with finding specs to test
+  class Cucumber < RSpec
+    def test_dir_name
+      'features'
+    end
+
+    def file_pattern dir
+      "#{dir}/**/*.feature"
+    end
+
+    def test_command paths
+      Command.new 'cucumber' do |test_job|
+        add_ruby_options test_job
+        test_job.concat cucumber_options
+        test_job.concat paths.map {|p| p.relative }
+      end
+    end
+
+    def add_ruby_options cmd
+      opts = []
+      opts << '-w' if context.warnings?
+      for path in context.load_paths
+        opts << "-I#{path}"
+      end
+      opts << '%'
+      cmd.env['RUBYOPT'] = opts.join(' ')
+    end
+
+    def cucumber_options
+      opts = []
+      opts << '-b' if context.full_backtrace?
+      for filter in context.name_filters
+        opts << '-n' << filter
+      end
+      for tag in context.tag_filters
+        opts << '-t' << normalize_tag(tag)
+      end
+      opts
+    end
+
+    def normalize_tag tag
+      tag = "#$1@#$2" if tag =~ /^(~)?(\w+)$/
+      tag
+    end
+  end
+end

data/lib/polyamory/rooted_pathname.rb

@@ -0,0 +1,51 @@
+require 'pathname'
+
+module Polyamory
+  # A kind of Pathname that keeps a reference to a root directory and is able to
+  # return a relativized pathname from that particular root.
+  class RootedPathname < ::Pathname
+    attr_reader :root
+
+    # Find pathnames matching the glob pattern and assign to them a root
+    def self.glob(patterns, root)
+      patterns = Array(patterns)
+      Dir[*patterns].map do |path|
+        self.new(path, root)
+      end
+    end
+
+    def initialize(path, root_path = nil)
+      super(path)
+      self.root = root_path
+    end
+
+    def root=(path)
+      @relativized = nil
+      @root = path
+    end
+
+    # Return the relative portion of the path from root
+    def relative
+      return self if relative?
+      @relativized ||= relative_path_from root
+    end
+
+    # Check if current path is contained in directory
+    def in_dir? dir
+      self == dir or
+        self.to_s.index(File.join(dir, '')) == 0
+    end
+
+    # Perform a regex match only on the relative portion of the path
+    def =~(pattern)
+      relative.to_s =~ pattern
+    end
+
+    # Add to the current path; the result has the current path as root
+    def +(other)
+      result = self.class.new(plus(@path, other.to_s))
+      result.root ||= self
+      result
+    end
+  end
+end

data/lib/polyamory/rspec.rb

@@ -0,0 +1,137 @@
+require 'polyamory/rooted_pathname'
+require 'polyamory/command'
+
+module Polyamory
+  # Internal: Deals with finding specs to test
+  class RSpec
+    attr_reader :context
+
+    def initialize context
+      @context = context
+    end
+
+    def test_dir_name
+      'spec'
+    end
+
+    def test_dir
+      @test_dir ||= context.root + test_dir_name
+    end
+
+    def file_pattern dir
+      "#{dir}/**/*_spec.rb"
+    end
+
+    # Internal: Finds test files matching glob pattern
+    def find_files dir = test_dir
+      glob file_pattern(dir)
+    end
+
+    # Internal: Memoized find_files in primary dir
+    def all_matching_files
+      @all_matching_files ||= find_files
+    end
+
+    # Public: Resolve a set of files, directories, and patterns to a list of
+    # paths to test.
+    def resolve_paths names
+      if names.any?
+        paths = []
+        for name in names
+          paths.concat Array(resolve_name name)
+        end
+        paths
+      else
+        Array(resolve_as_directory test_dir_name)
+      end
+    end
+
+    def handle? path
+      path.in_dir? test_dir
+    end
+
+    def resolve_name name
+      resolve_as_directory(name) or
+        resolve_as_filename(name) or
+        resolve_as_file_pattern(name) or
+        raise "nothing resolved from #{name}"
+    end
+
+    # "functional" => "test/functional/**"
+    # "test/functional" => "test/functional/**"
+    def resolve_as_directory name
+      [test_dir + name, context.root + name].detect { |dir|
+        dir.directory? and handle? dir
+      }
+    end
+
+    # "test/unit/test_user.rb:42"
+    def resolve_as_filename name
+      filename = name.sub(/:(\d+)$/, '')
+      file = context.root + filename
+
+      if file.file? and handle? file
+        context.root + name
+      end
+    end
+
+    # "word" => "test/**" that match "word"
+    def resolve_as_file_pattern name
+      pattern = /(?:\b|_)#{Regexp.escape name}(?:\b|_)/
+      all_matching_files.select {|p| p =~ pattern }
+    end
+
+    # Public: From a list of paths, yank the ones that this knows how to handle,
+    # and build test jobs from it.
+    def pick_jobs paths
+      to_test = []
+      paths.reject! do |path|
+        if handle? path
+          to_test << path
+          true
+        end
+      end
+
+      unless to_test.empty?
+        [test_command(to_test)]
+      else
+        []
+      end
+    end
+
+    def test_command paths
+      Command.new 'rspec' do |test_job|
+        add_ruby_options test_job
+        test_job.concat rspec_options
+        test_job.concat paths.map {|p| p.relative }
+      end
+    end
+
+    def glob pattern
+      RootedPathname.glob pattern, context.root
+    end
+
+    def add_ruby_options cmd
+      opts = []
+      opts << '-w' if context.warnings?
+      opts << '%'
+      cmd.env['RUBYOPT'] = opts.join(' ')
+    end
+
+    def rspec_options
+      opts = []
+      opts << '-b' if context.full_backtrace?
+      opts << '--seed' << context.test_seed if context.test_seed
+      for path in context.load_paths
+        opts << "-I#{path}"
+      end
+      for filter in context.name_filters
+        opts << '-e' << filter
+      end
+      for tag in context.tag_filters
+        opts << '-t' << tag
+      end
+      opts
+    end
+  end
+end

data/lib/polyamory/runner.rb

@@ -0,0 +1,135 @@
+require 'polyamory/rooted_pathname'
+require 'polyamory/test_unit'
+require 'polyamory/rspec'
+require 'polyamory/cucumber'
+
+module Polyamory
+  # Public: Collects test jobs in the root directory and runs them.
+  class Runner
+    attr_reader :root, :options
+
+    def initialize(names, root, options = {})
+      @names   = names
+      @root    = RootedPathname.new(root).expand_path
+      @options = options
+    end
+
+    def warnings?
+      options.fetch(:warnings)
+    end
+
+    def verbose?
+      options.fetch(:verbose)
+    end
+
+    def full_backtrace?
+      options.fetch(:backtrace)
+    end
+
+    def name_filters
+      options.fetch(:name_filters)
+    end
+
+    def tag_filters
+      options.fetch(:tag_filters)
+    end
+
+    def load_paths
+      options.fetch(:load_paths)
+    end
+
+    def test_seed
+      options.fetch(:test_seed)
+    end
+
+    def bundle_exec?
+      return @bundle_exec if defined? @bundle_exec
+      if (setting = options.fetch(:bundler)).nil?
+        setting = !ENV['BUNDLE_GEMFILE'].to_s.empty? ||
+                  (root + 'Gemfile').exist?
+      end
+      @bundle_exec = setting
+    end
+
+    BundlerJob = Struct.new(:job) do
+      def env() job.env end
+      def to_exec() ['bundle', 'exec', *job.to_exec] end
+      def to_s() "bundle exec #{job.to_s}" end
+    end
+
+    def run
+      jobs = collect_jobs
+
+      unless jobs.empty?
+        for job in jobs
+          job = BundlerJob.new(job) if bundle_exec?
+          exec_job job
+        end
+      else
+        abort "nothing to run."
+      end
+    end
+
+    def collect_jobs
+      [TestUnit, RSpec, Cucumber].inject([]) do |jobs, klass|
+        framework = klass.new self
+        paths = framework.resolve_paths @names
+        jobs.concat framework.pick_jobs(paths)
+      end
+    end
+
+    def exec_job job
+      with_env job.env do |env_keys|
+        display_job job, env_keys
+        system(*job.to_exec)
+        exit $?.exitstatus unless $?.success?
+      end
+    end
+
+    def display_job job, env_keys
+      display_env env_keys
+      puts job
+    end
+
+    def display_env env_keys
+      env_keys.each do |name|
+        value = ENV[name].strip
+        next if value.empty?
+        value = %("#{value}") if value.index(' ')
+        print "#{name}=#{value} "
+      end
+    end
+
+    def rbenv_clear
+      rbenv_root = `rbenv root 2>/dev/null`.chomp
+      unless rbenv_root.empty?
+        re = /^#{Regexp.escape rbenv_root}\/(versions|plugins|libexec)\b/
+        paths = ENV["PATH"].split(":")
+        paths.reject! {|p| p =~ re }
+        update_env 'PATH' => paths.join(":")
+      end
+    end
+
+    def with_env env
+      rbenv_clear
+      saved = update_env env
+      begin
+        yield saved.keys
+      ensure
+        restore_env saved
+      end
+    end
+
+    def update_env env
+      env.inject({}) { |saved, (name, value)|
+        saved[name] = ENV[name]
+        ENV[name] = value.sub('%', saved[name].to_s)
+        saved
+      }
+    end
+
+    def restore_env env
+      env.each {|name, value| ENV[name] = value }
+    end
+  end
+end

data/lib/polyamory/test_unit.rb

@@ -0,0 +1,196 @@
+require 'polyamory/rooted_pathname'
+require 'polyamory/command'
+
+module Polyamory
+  # Internal: Deals with finding Test::Unit or MiniTest files to test.
+  class TestUnit
+    attr_reader :context, :test_filters
+
+    def initialize context
+      @context = context
+      @test_filters = context.name_filters.dup
+    end
+
+    def test_dir
+      @test_dir ||= context.root + 'test'
+    end
+
+    def file_pattern dir
+      "#{dir}/**/*_test.rb"
+    end
+
+    def file_pattern_alt dir
+      "#{dir}/**/test*.rb"
+    end
+
+    # Internal: Finds test files with one glob pattern or the other. The pattern
+    # that matches the most files wins.
+    def find_files dir = test_dir
+      paths = glob file_pattern(dir)
+      paths_alt = glob file_pattern_alt(dir)
+      paths.size > paths_alt.size ? paths : paths_alt
+    end
+
+    # Internal: Memoized find_files in primary dir
+    def all_matching_files
+      @all_matching_files ||= find_files
+    end
+
+    # Public: Resolve a set of files, directories, and patterns to a list of
+    # paths to test.
+    def resolve_paths names
+      if context.tag_filters.any?
+        # test/unit and minitest don't support tags
+        []
+      elsif names.any?
+        paths = []
+        for name in names
+          paths.concat Array(resolve_name name)
+        end
+        paths
+      else
+        all_matching_files
+      end
+    end
+
+    def handle? path
+      path.in_dir? test_dir
+    end
+
+    def resolve_name name
+      resolve_as_directory(name) or
+        resolve_as_filename(name) or
+        resolve_as_file_pattern(name) or
+        raise "nothing resolved from #{name}"
+    end
+
+    # "functional" => "test/functional/**"
+    # "test/functional" => "test/functional/**"
+    def resolve_as_directory name
+      dir = [test_dir + name, context.root + name].detect { |dir|
+        dir.directory? and handle? dir
+      }
+      find_files(dir) if dir
+    end
+
+    # "test/unit/test_user.rb:42"
+    def resolve_as_filename name
+      filename = name.sub(/:(\d+)$/, '')
+      line_number = $1
+      file = context.root + filename
+
+      if file.file? and handle? file
+        add_test_filter_for_line(file, line_number) if line_number
+        file
+      end
+    end
+
+    # "word" => "test/**" that match "word"
+    def resolve_as_file_pattern name
+      pattern = /(?:\b|_)#{Regexp.escape name}(?:\b|_)/
+      all_matching_files.select {|p| p =~ pattern }
+    end
+
+    # Public: From a list of paths, yank the ones that this knows how to handle,
+    # and build test jobs from it.
+    def pick_jobs paths
+      to_test = []
+      paths.reject! do |path|
+        if handle? path
+          to_test << path
+          true
+        end
+      end
+
+      unless to_test.empty?
+        [test_command(to_test)]
+      else
+        []
+      end
+    end
+
+    def test_command paths
+      Command.new %w'polyamory -t' do |test_job|
+        add_ruby_options test_job
+        test_job.concat paths.map {|p| p.relative }
+
+        tunit_opts = testunit_options
+        if tunit_opts.any?
+          test_job << '--'
+          test_job.concat tunit_opts
+        end
+      end
+    end
+
+    def glob pattern
+      RootedPathname.glob pattern, context.root
+    end
+
+    def add_ruby_options cmd
+      opts = []
+      opts << '-w' if context.warnings?
+      opts << '-Ilib:test'
+      for path in context.load_paths
+        opts << "-I#{path}"
+      end
+      opts << '%'
+      cmd.env['RUBYOPT'] = opts.join(' ')
+    end
+
+    def testunit_options
+      opts = []
+      opts << '-n' << test_filter_regexp(test_filters) if test_filters.any?
+      opts << '-s' << context.test_seed if context.test_seed
+      opts << '-v' if context.verbose?
+      opts
+    end
+
+    def test_filter_regexp filters
+      if filters.size == 1
+        '/%s/' % filters.first
+      else
+        '/(%s)/' % filters.join('|')
+      end
+    end
+
+    def add_test_filter_for_line file, linenum
+      @test_filters << find_test_filter_for_line(file, linenum)
+    end
+
+    def find_test_filter_for_line file, linenum
+      focused_test_finder.call(file, linenum) or
+        raise "test method not found (#{file.relative}:#{linenum})"
+    end
+
+    def focused_test_finder() FocusedTestFinder end
+
+    FocusedTestFinder = Struct.new(:file, :line) do
+      def self.call *args
+        new(*args).scan
+      end
+
+      def readlines
+        file.readlines[0, line.to_i]
+      end
+
+      def scan
+        readlines.reverse.each do |line|
+          found = test_from_line line
+          return found if found
+        end
+        nil
+      end
+
+      def test_from_line line
+        case line
+        when /^\s*def\s+(test_\w+)/
+          $1
+        when /^\s*(test|it|specify)[\s(]+(['"])((.*?)[^\\])\2/
+          if 'test' == $1 then $3.gsub(/\s+/, '_')  # ActiveSupport::TestCase
+          else $3  # minitest/spec
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_runner.rb

@@ -0,0 +1,250 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'polyamory/runner'
+require 'fileutils'
+
+describe Polyamory::Runner do
+
+  let(:default_options) {
+    options = {
+      :warnings     => false,
+      :verbose      => false,
+      :backtrace    => false,
+      :test_seed    => nil,
+      :name_filters => [],
+      :tag_filters  => [],
+      :load_paths   => [],
+    }
+  }
+  subject { Polyamory::Runner.new(names, root, default_options.merge(options)) }
+
+  let(:options) { Hash.new }
+  let(:names)   { [] }
+  let(:root)    { File.join(ENV['TMPDIR'] || '/tmp', 'polyamory') }
+
+  before { FileUtils.rm_rf root }
+
+  it "finds no jobs when directory doesn't exist" do
+    subject.collect_jobs.must_be_empty
+  end
+
+  describe "test/unit project" do
+    before {
+      %w[ app/models/user.rb
+          lib/sync.rb
+          test/unit/user_test.rb
+          test/unit/blog_test.rb
+          test/functional/lib_user_test.rb
+      ].each do |path|
+        file = File.join(root, path)
+        FileUtils.mkdir_p File.dirname(file)
+        FileUtils.touch file
+      end
+    }
+
+    let(:job) { subject.collect_jobs.first }
+    let(:job_files) {
+      files = job.to_exec
+      end_at = files.index('--').to_i - 1
+      files[2..end_at]
+    }
+
+    it "finds one job" do
+      subject.collect_jobs.size.must_equal 1
+    end
+
+    it "tests all files" do
+      job_files.must_equal %w[
+        test/functional/lib_user_test.rb
+        test/unit/blog_test.rb
+        test/unit/user_test.rb
+      ]
+    end
+
+    it "sets ruby options" do
+      job.env['RUBYOPT'].must_equal "-Ilib:test %"
+    end
+
+    describe "with verbose" do
+      let(:options) { {:warnings => true} }
+
+      it "sets warning option" do
+        job.env['RUBYOPT'].must_equal "-w -Ilib:test %"
+      end
+    end
+
+    describe "with pattern" do
+      let(:names) { %w[user] }
+
+      it "finds files by pattern" do
+        job_files.must_equal %w[
+          test/functional/lib_user_test.rb
+          test/unit/user_test.rb
+        ]
+      end
+    end
+
+    describe "with directory" do
+      let(:names) { %w[unit] }
+
+      it "finds files in dir" do
+        job_files.must_equal %w[
+          test/unit/blog_test.rb
+          test/unit/user_test.rb
+        ]
+      end
+    end
+
+    describe "with non-matching name" do
+      let(:names) { %w[nonexist] }
+
+      it "finds no jobs" do
+        subject.collect_jobs.must_be_empty
+      end
+    end
+
+    describe "test filters" do
+      describe "from option" do
+        let(:options) { {:name_filters => %w'filly'} }
+
+        it "generates test/unit argument" do
+          job.to_s.must_include "-- -n /filly/"
+        end
+      end
+
+      describe "from line numbers" do
+        before {
+          File.open(File.join(root, 'test/unit/blog_test.rb'), 'w') do |file|
+            file.write <<-RUBY
+              require 'moo'
+              def test_blog
+                # normal
+              test "has feed"
+                # ActiveSupport::TestCase
+              it "needs posts" do
+                # minitest/spec
+              end
+              specify('no comments') { ... }
+            RUBY
+          end
+        }
+
+        describe "normal syntax" do
+          let(:names) { %w[ test/unit/blog_test.rb:3 ] }
+          it("finds method") { job.to_s.must_include "-n /test_blog/" }
+        end
+
+        describe "ActiveSupport syntax" do
+          let(:names) { %w[ test/unit/blog_test.rb:5 ] }
+          it("finds method") { job.to_s.must_include "-n /has_feed/" }
+        end
+
+        describe "normal syntax" do
+          let(:names) { %w[ test/unit/blog_test.rb:7 ] }
+          it("finds method") { job.to_s.must_include "-n /needs posts/" }
+        end
+
+        describe "normal syntax" do
+          let(:names) { %w[ test/unit/blog_test.rb:9 ] }
+          it("finds method") { job.to_s.must_include "-n /no comments/" }
+        end
+      end
+    end
+  end
+
+  describe "RSpec project" do
+    before {
+      %w[ app/models/user.rb
+          lib/sync.rb
+          spec/models/user_spec.rb
+          spec/models/blog_spec.rb
+          spec/integration/sync_spec.rb
+      ].each do |path|
+        file = File.join(root, path)
+        FileUtils.mkdir_p File.dirname(file)
+        FileUtils.touch file
+      end
+    }
+
+    let(:job) { subject.collect_jobs.first }
+    let(:job_files) {
+      files = job.to_exec
+      files[1..-1]
+    }
+
+    it "finds one job" do
+      subject.collect_jobs.size.must_equal 1
+    end
+
+    it "tests all files" do
+      job_files.must_equal %w[spec]
+    end
+
+    describe "name args" do
+      let(:names) { %w[user blog] }
+
+      it "tests some files" do
+        job_files.must_equal %w[
+          spec/models/user_spec.rb
+          spec/models/blog_spec.rb
+        ]
+      end
+    end
+
+    it "sets no ruby options" do
+      job.env['RUBYOPT'].must_equal "%"
+    end
+
+    describe "example filters" do
+      let(:options) { {:name_filters => %w'willy filly'} }
+
+      it "generates arguments" do
+        job.to_s.must_include " -e willy -e filly "
+      end
+    end
+
+    describe "tag filters" do
+      let(:options) { {:tag_filters => %w'willy filly'} }
+
+      it "generates arguments" do
+        job.to_s.must_include " -t willy -t filly "
+      end
+    end
+  end
+
+  describe "mixed project" do
+    before {
+      %w[ app/models/user.rb
+          lib/sync.rb
+          test/unit/test_user.rb
+          spec/models/blog_spec.rb
+          features/sync.feature
+      ].each do |path|
+        file = File.join(root, path)
+        FileUtils.mkdir_p File.dirname(file)
+        FileUtils.touch file
+      end
+    }
+
+    let(:jobs) { subject.collect_jobs }
+
+    it "finds three jobs" do
+      jobs.map {|j| j.to_s }.must_equal [
+        'polyamory -t test/unit/test_user.rb',
+        'rspec spec',
+        'cucumber features',
+      ]
+    end
+
+    describe "with tags" do
+      let(:options) { {:tag_filters => %w[willy ~nilly]} }
+      it "is filtered by tags" do
+        jobs.map {|j| j.to_s }.must_equal [
+          'rspec -t willy -t ~nilly spec',
+          'cucumber -t @willy -t ~@nilly features',
+        ]
+      end
+    end
+  end
+
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: polyamory
 version: !ruby/object:Gem::Version
-  version: 0.0.5
   prerelease: 
+  version: 0.6.0
 platform: ruby
 authors:
 - Mislav Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-08 00:00:00.000000000 Z
+date: 2013-03-08 00:00:00.000000000 Z
 dependencies: []
-description: A tool that knows how to run your tests regardless of framework
+description: A cli runner for all tests regardless of framework
 email: mislav.marohnic@gmail.com
 executables:
 - polyamory
@@ -19,9 +19,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/polyamory
+- lib/polyamory/command.rb
+- lib/polyamory/cucumber.rb
+- lib/polyamory/rooted_pathname.rb
+- lib/polyamory/rspec.rb
+- lib/polyamory/runner.rb
+- lib/polyamory/test_unit.rb
 - lib/polyamory.rb
+- test/test_runner.rb
 - README.md
-homepage: https://github.com/mislav/polyamory
+homepage: https://github.com/mislav/polyamory#readme
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -41,8 +48,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Runs your tests
+summary: The promiscuous test runner
 test_files: []