polyamory 0.0.2

data/README.md

@@ -0,0 +1,35 @@
+# Polyamory
+
+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.
+
+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
+
+Frameworks supported:
+
+* 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 

data/bin/polyamory

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

data/lib/polyamory.rb

@@ -0,0 +1,204 @@
+require 'pathname'
+
+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"
+  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"
+  end
+  
+  class Pathname < Pathname
+    attr_reader :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
+    
+    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], @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 helper.exist?
+      File.open(helper) do |file|
+        while file.gets
+          return $&.downcase if $_ =~ /\bR?Spec\b/
+        end
+      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 args.first != 'polyamory' and bundler?
+    args
+  end
+  
+  def cmd(args, many = false)
+    args = prepare_cmdline(args)
+    puts args.join(' ')
+
+    # TODO: hack; make this configurable, use bundler
+    with_rubyopt(args.first == 'polyamory' ? '-rubygems' : nil) do
+      if many
+        system(*args)
+        exit $?.exitstatus unless $?.success?
+      else
+        exec(*args)
+      end
+    end unless noop?
+  end
+  
+  def with_rubyopt(value)
+    old_value = ENV['RUBYOPT']
+    ENV['RUBYOPT'] = "#{value} #{old_value}"
+    
+    begin
+      yield
+    ensure
+      ENV['RUBYOPT'] = 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

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: polyamory
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- "Mislav Marohni\xC4\x87"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-30 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: A tool that knows how to run your tests regardless of framework
+email: mislav.marohnic@gmail.com
+executables: 
+- polyamory
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/polyamory
+- lib/polyamory.rb
+- README.md
+has_rdoc: true
+homepage: http://github.com/mislav/polyamory
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Runs your tests
+test_files: []
+