tconsole 1.1.0pre8 → 1.1.0pre9

data/README.md

@@ -29,9 +29,9 @@ willing to merge it in, though.
 Installing tconsole
 ------
 	gem install tconsole
-	
+
 Prereleases of tconsole come out pretty frequently. You can install the latest prerelease version with:
-	
+
 	gem installt console --pre
 
 How to use tconsole
@@ -39,68 +39,55 @@ How to use tconsole
 In your shell of choice, cd into your Rails project's directory and then run `bundle exec tconsole` to fire up the console. You should see something like this:
 
 	bundle exec tconsole
-	
+
 	Loading your Rails environment...
 	Environment loaded in 7.160264s.
-	
-	> 
-	
+
+	>
+
 Now that you're in the console, let's test out the all command! Running all from the console runs all of your unit, functional, and integration tests:
 
 	> all
 	Running tests...
-	
-	Run options: 
+
+	Run options:
 
 	# Running tests:
 
 	....................................................................................
-	
+
 	Finished tests in 6.054574s, 6.4999 tests/s, 10.5822 assertions/s.
 
 	39 tests, 45 assertions, 0 failures, 0 errors, 0 skips
 
 	Test time (including load): 82.806741s
-	
-	> 
-	
-If you want to focus in on a particular subset of your tests, like units, functionals, or integration, just enter that keyword:
 
-	> units
-         
-	> functionals
-         
-	> integration
-         
+	>
 
-If you'd like to just run the tests that are related to recent changes
-you've made:
+If you want to focus in on a particular subset of your tests, like units, functionals, or integration, just enter that keyword:
 
-	> recent
+	> units
 
-Or if you'd like to run the tests for changes you've made since your
-last commit:
+	> functionals
 
-	> uncommitted
+	> integration
 
-You can also focus in on just the tests in a given filename by entering a test file name into tconsole:
+You can also specify to run all tests in a specific class:
 
-	> test/unit/user_test.rb
+	> UserTest
 
-You can go one bit deeper and just run a particular test in that file
-with an extra argument:
+You can go one bit deeper and just run a particular test in that file as
+well:
 
-	> test/unit/user_test.rb test_that_user_is_healthy
+	> UserTest#test_that_user_is_healthy
 
-That command will load up the user_test.rb file and then only run the
-test named test_that_user_is_healthy. You can add a specific test name
-argument to any tconsole command that runs tests.
+You can list more than just one class or class and method to run, and
+tconsole will run them all.
 
-There are a few special ! commands that use data from past test runs. The `!failed` command will rerun all of your files
-that included failing tests in the last test run:
+There are a few special ! commands that use data from past test runs. The `!failed` command will rerun the set of tests that failed during the last run:
 
 	> !failed
-	
+
 There's also a `!timings` command that will show you a listing of your last test run's test times, sorted to help you
 improve slow tests:
 
@@ -125,11 +112,11 @@ improve slow tests:
 If you update your environment, maybe by editing your Gemfile or changing one of your application's configuration files, you can use the `reload` command to reload the entire environment:
 
 	> reload
-	
+
 And then finally, you can run the `exit` command to quit:
 
 	> exit
-	
+
 Reporting Issues and Contributing
 ------
 

data/drb_connection_test.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require "drb/drb"
+
+class Server
+  def connected?
+    true
+  end
+
+  def load_environment
+    ENV['RAILS_ENV'] ||= "test"
+
+    require './config/application'
+
+    ::Rails.application
+    ::Rails::Engine.class_eval do
+      def eager_load!
+        # turn off eager_loading
+      end
+    end
+
+    true
+  end
+
+  def stop
+    DRb.stop_service
+  end
+end
+
+socket = "/tmp/test.#{Process.pid}"
+
+server_pid = fork do
+  server = Server.new
+
+  drb_server = DRb.start_service("drbunix:#{socket}", server)
+  DRb.thread.join
+end
+
+wait_until = Time.now + 10
+DRb.start_service
+
+loaded = false
+until loaded || Time.now > wait_until
+  begin
+    puts "Trying to load environment"
+    server = DRbObject.new_with_uri("drbunix:#{socket}")
+    loaded = server.connected?
+  rescue
+    puts "Couldn't connect. Waiting."
+    sleep(1)
+  end
+end
+
+if !loaded
+  puts "Wasn't able to connect"
+end
+
+puts "Connected! Attempting to load environment"
+server.load_environment
+puts "Environment loaded!"
+
+# Clean it all up
+server.stop

data/lib/tconsole.rb

@@ -1,5 +1,6 @@
 require "tconsole/version"
 require "tconsole/config"
+require "tconsole/console"
 require "tconsole/server"
 require "tconsole/test_result"
 require "tconsole/util"
@@ -8,24 +9,7 @@ require "readline"
 require "benchmark"
 require "drb/drb"
 require "term/ansicolor"
-
-Readline.completion_append_character = ""
-
-# Proc for helping us figure out autocompletes
-Readline.completion_proc = Proc.new do |str|
-  known_commands = TConsole::Console::KNOWN_COMMANDS.grep(/^#{Regexp.escape(str)}/)
-
-  files = Dir[str+'*'].grep(/^#{Regexp.escape(str)}/)
-  formatted_files = files.collect do |filename| 
-    if File.directory?(filename)
-      filename + File::SEPARATOR
-    else
-      filename
-    end
-  end
-
-  known_commands.concat(formatted_files)
-end
+require "shellwords"
 
 module TConsole
   class Runner
@@ -42,14 +26,12 @@ module TConsole
       puts
       puts "Welcome to tconsole (v#{TConsole::VERSION}). Type 'help' for help or 'exit' to quit."
 
-      # Set up our console input handling and history
-      console = Console.new
-
       # set up the config
       config = Config.configure
       config.trace_execution = true if argv.include?("--trace")
 
-      port = "1233"
+      # Set up our console input handling and history
+      console = Console.new(config)
 
       # Start the server
       while running
@@ -60,7 +42,7 @@ module TConsole
           begin
             server = Server.new(config)
 
-            drb_server = DRb.start_service("druby://localhost:#{port}", server)
+            drb_server = DRb.start_service("drbunix:/tmp/tconsole.#{Process.pid}", server)
             DRb.thread.join
           rescue Interrupt
             # do nothing here since the outer process will shut things down for us
@@ -72,34 +54,41 @@ module TConsole
         # Set up our client connection to the server
         config.trace("Connecting to testing server.")
         DRb.start_service
-        server = DRbObject.new_with_uri("druby://localhost:#{port}")
+        server = nil
 
         loaded = false
         until loaded || Time.now > wait_until
           begin
-            config.trace("Attempting to load environment.")
-            running = server.load_environment
-            loaded = true
-          rescue => e
-            config.trace("Could not load environment: #{e.message}")
-            config.trace("==== Backtrace ====")
-            config.trace(e.backtrace.join("\n"))
-            config.trace("==== End Backtrace ====")
-            loaded = false
-          rescue Interrupt
-            # do nothing if we get an interrupt
-            puts "Interrupted in client"
+            server = DRbObject.new_with_uri("drbunix:/tmp/tconsole.#{server_pid}")
+
+            config.trace("Testing connection to test server.")
+            loaded = server.connected?
+          rescue
+            # do nothing
+            config.trace("Not connected to server yet. Retrying.")
+            sleep(1)
           end
-
-          # Give drb a second to get set up
-          sleep(1)
         end
 
-        if !loaded
+        unless loaded
           puts
-          puts "Couldn't connect to test environment. Exiting."
+          puts "Couldn't connect to the test environment. Exiting."
           exit(1)
         end
+
+        begin
+          config.trace("Attempting to load environment.")
+          running = server.load_environment
+        rescue => e
+          config.trace("Could not load environment: #{e.message}")
+          config.trace("==== Backtrace ====")
+          config.trace(e.backtrace.join("\n"))
+          config.trace("==== End Backtrace ====")
+
+          puts "Couldn't load the test environment. Exiting."
+          exit(1)
+        end
+
         config.trace("Environment loaded successfully.")
 
         running = console.read_and_execute(server) if running
@@ -115,119 +104,6 @@ module TConsole
       system("stty", stty_save);
     end
   end
-
-  class Console
-    KNOWN_COMMANDS = ["exit", "reload", "help", "units", "functionals", "integration", "recent", "uncommitted", "all", "info", "!failed", "!timings", "set"]
-
-    def initialize
-      read_history
-    end
-
-    # Returns true if the app should keep running, false otherwise
-    def read_and_execute(server)
-      while line = Readline.readline("tconsole> ", false)
-        # TODO: Avoid pushing duplicate commands onto the history
-        Readline::HISTORY << line
-
-        line.strip!
-        args = line.split(/\s/)
-
-        if line == ""
-          # do nothing
-        elsif args[0] == "exit"
-          return false
-        elsif args[0] == "reload"
-          return true
-        elsif args[0] == "help"
-          print_help
-        elsif args[0] == "units" || args[0] == "unit"
-          server.run_tests(["test/unit/**/*_test.rb"], args[1])
-        elsif args[0] == "functionals" || args[0] == "functional"
-          server.run_tests(["test/functional/**/*_test.rb"], args[1])
-        elsif args[0] == "integration"
-          server.run_tests(["test/integration/**/*_test.rb"], args[1])
-        elsif args[0] == "recent"
-          server.run_recent(args[1])
-        elsif args[0] == "uncommitted"
-          server.run_uncommitted(args[1])
-        elsif args[0] == "all"
-          server.run_tests(["test/unit/**/*_test.rb", "test/functional/**/*_test.rb", "test/integration/**/*_test.rb"], args[1])
-        elsif args[0] == "!failed"
-          server.run_failed
-        elsif args[0] == "!timings"
-          server.show_performance(args[1])
-        elsif args[0] == "info"
-          server.run_info
-        elsif args[0] == "set"
-          server.set(args[1], args[2])
-        else
-          server.run_tests([args[0]], args[1])
-        end
-      end
-
-      true
-    end
-
-    # Prints a list of available commands
-    def print_help
-      puts
-      puts "Available commands:"
-      puts
-      puts "all [test_pattern]          # Run all test types (units, functionals, integration)"
-      puts "units [test_pattern]        # Run unit tests"
-      puts "functionals [test_pattern]  # Run functional tests"
-      puts "integration [test_pattern]  # Run integration tests"
-      puts "recent [test_pattern]       # Run tests for recently changed files"
-      puts "uncommitted [test_pattern]  # Run tests for uncommitted changes"
-      puts "!failed                     # Runs the last set of failing tests"
-      puts "!timings [limit]            # Lists the timings for the last test run, sorted."
-      puts "[filename] [test_pattern]   # Run the tests contained in the given file"
-      puts "reload                      # Reload your Rails environment"
-      puts "set [variable] [value]      # Sets a runtime variable (see below for details)"
-      puts "exit                        # Exit the console"
-      puts
-      puts "Working with test patterns:"
-      puts
-      puts "All of the test execution commands include an optional test_pattern argument. A"
-      puts "test pattern can be given to filter the executed tests to only those tests whose"
-      puts "name matches the pattern given. This is especially useful when rerunning a failing"
-      puts "test."
-      puts
-      puts "Runtime Variables"
-      puts
-      puts "You can set runtime variables with the set command. This helps out with changing"
-      puts "features of TConsole that you may want to change at runtime. At present, the"
-      puts "following runtime variables are available:"
-      puts
-      puts "fast        # Turns on fail fast mode. Values: on, off"
-      puts
-
-    end
-
-    def history_file
-      File.join(ENV['HOME'], ".tconsole_history")
-    end
-
-    # Stores last 50 items in history to $HOME/.tconsole_history
-    def store_history
-      if ENV['HOME']
-        File.open(history_file, "w") do |f|
-          Readline::HISTORY.to_a.reverse[0..49].each do |item|
-            f.puts(item)
-          end
-        end
-      end
-    end
-
-    # Loads history from past sessions
-    def read_history
-      if ENV['HOME'] && File.exist?(history_file)
-        File.readlines(history_file).reverse.each do |line|
-          Readline::HISTORY << line
-        end
-      end
-    end
-  end
 end
 
 

data/lib/tconsole/config.rb

@@ -22,16 +22,31 @@ module TConsole
     # test fails. Defaults to false.
     attr_accessor :fail_fast
 
+    # Defines the file set commands that are available
+    attr_accessor :file_sets
+
+    # Counts of tests in suites
+    attr_accessor :cached_suite_counts
+
+    # Element names we know
+    attr_accessor :cached_elements
+
     def initialize
       self.trace_execution = false
       self.test_dir = "./test"
       self.include_paths = ["./test", "./lib"]
       self.preload_paths = []
       self.fail_fast = false
+      self.file_sets = {
+        "all" => ["#{test_dir}/**/*_test.rb"]
+      }
 
       @after_load = nil
       @before_load = nil
       @before_test_run = nil
+
+      @cached_suite_counts = {}
+      @cached_elements = {}
     end
 
     def trace?
@@ -71,12 +86,27 @@ module TConsole
       @before_test_run.call unless @before_test_run.nil?
     end
 
+    def cache_test_ids(result)
+      self.cached_suite_counts = result.suite_counts
+      self.cached_elements = result.elements
+    end
+
     # Returns an appropriate tconsole config based on the environment
     def self.configure
       if is_rails?
         config = Config.new
         config.preload_paths = ["./config/application"]
         config.include_paths = ["./test"]
+        config.file_sets = {
+          "all" => ["#{config.test_dir}/unit/**/*_test.rb", "#{config.test_dir}/functional/**/*_test.rb",
+            "#{config.test_dir}/integration/**/*_test.rb"],
+          "units" => ["#{config.test_dir}/unit/**/*_test.rb"],
+          "unit" => ["#{config.test_dir}/unit/**/*_test.rb"],
+          "functionals" => ["#{config.test_dir}/functional/**/*_test.rb"],
+          "functional" => ["#{config.test_dir}/functional/**/*_test.rb"],
+          "integration" => ["#{config.test_dir}/integration/**/*_test.rb"]
+        }
+
 
         config.before_load do
           ENV["RAILS_ENV"] ||= "test"

data/lib/tconsole/console.rb

@@ -0,0 +1,136 @@
+module TConsole
+  class Console
+    KNOWN_COMMANDS = ["exit", "reload", "help", "info", "!failed", "!timings", "set"]
+
+    def initialize(config)
+      @config = config
+      read_history
+
+      define_autocomplete
+    end
+
+    def define_autocomplete
+      Readline.completion_append_character = ""
+
+      # Proc for helping us figure out autocompletes
+      Readline.completion_proc = Proc.new do |str|
+        known_commands = KNOWN_COMMANDS.grep(/^#{Regexp.escape(str)}/)
+
+        files = Dir[str+'*'].grep(/^#{Regexp.escape(str)}/)
+        formatted_files = files.collect do |filename|
+          if File.directory?(filename)
+            filename + File::SEPARATOR
+          else
+            filename
+          end
+        end
+
+        known_commands.concat(formatted_files).concat(@config.file_sets.keys)
+      end
+    end
+
+    # Returns true if the app should keep running, false otherwise
+    def read_and_execute(server)
+      while line = Readline.readline("tconsole> ", false)
+        line.strip!
+        args = Shellwords.shellwords(line)
+
+        # save the line unless we're exiting or repeating the last command
+        unless args[0] == "exit" || Readline::HISTORY[Readline::HISTORY.length - 1] == line
+          Readline::HISTORY << line
+        end
+
+        if line == ""
+          # do nothing
+        elsif args[0] == "exit"
+          return false
+        elsif args[0] == "reload"
+          return true
+        elsif args[0] == "help"
+          print_help
+        elsif args[0] == "!failed"
+          server.run_failed
+        elsif args[0] == "!timings"
+          server.show_performance(args[1])
+        elsif args[0] == "info"
+          server.run_info
+        elsif args[0] == "set"
+          server.set(args[1], args[2])
+        elsif @config.file_sets.has_key?(args[0])
+          server.run_file_set(args[0])
+        else
+          server.run_all_tests(args)
+        end
+      end
+
+      true
+    end
+
+    # Prints a list of available commands
+    def print_help
+      puts
+      puts "Available commands:"
+      puts
+      puts "reload                      # Reload your Rails environment"
+      puts "set [variable] [value]      # Sets a runtime variable (see below for details)"
+      puts "exit                        # Exit the console"
+      puts "!failed                     # Runs the last set of failing tests"
+      puts "!timings [limit]            # Lists the timings for the last test run, sorted."
+      puts "[filename] [test_pattern]   # Run the tests contained in the given file"
+      puts
+      puts "Running file sets"
+      puts
+      puts "File sets are sets of files that are typically run together. For example,"
+      puts "in Rails projects it's common to run `rake test:units` to run all of the"
+      puts "tests under the units directory."
+      puts
+      puts "Available file sets:"
+
+      @config.file_sets.each do |set, paths|
+        puts set
+      end
+
+      puts
+      puts "Working with test patterns:"
+      puts
+      puts "All of the test execution commands include an optional test_pattern argument. A"
+      puts "test pattern can be given to filter the executed tests to only those tests whose"
+      puts "name matches the pattern given. This is especially useful when rerunning a failing"
+      puts "test."
+      puts
+      puts "Runtime Variables"
+      puts
+      puts "You can set runtime variables with the set command. This helps out with changing"
+      puts "features of TConsole that you may want to change at runtime. At present, the"
+      puts "following runtime variables are available:"
+      puts
+      puts "fast        # Turns on fail fast mode. Values: on, off"
+      puts
+
+    end
+
+    def history_file
+      File.join(ENV['HOME'], ".tconsole_history")
+    end
+
+    # Stores last 50 items in history to $HOME/.tconsole_history
+    def store_history
+      if ENV['HOME']
+        File.open(history_file, "w") do |f|
+          Readline::HISTORY.to_a.reverse[0..49].each do |item|
+            f.puts(item)
+          end
+        end
+      end
+    end
+
+    # Loads history from past sessions
+    def read_history
+      if ENV['HOME'] && File.exist?(history_file)
+        File.readlines(history_file).reverse.each do |line|
+          Readline::HISTORY << line
+        end
+      end
+    end
+  end
+end

data/lib/tconsole/minitest_handler.rb

@@ -1,21 +1,16 @@
 module TConsole
   class MiniTestHandler
-    def self.run(name_pattern, config)
-      args = []
-      unless name_pattern.nil?
-        args = ["--name", name_pattern]
-      end
-
+    def self.run(match_patterns, config)
       # Make sure we have a recent version of minitest, and use it
       if ::MiniTest::Unit.respond_to?(:runner=)
-        ::MiniTest::Unit.runner = TConsole::MiniTestUnit.new(config)
+        ::MiniTest::Unit.runner = TConsole::MiniTestUnit.new(match_patterns, config)
       else
         raise "MiniTest v#{MiniTest::Unit::VERSION} is not compatible with tconsole. Please load a more recent version of MiniTest"
       end
 
       # Run it
       runner = MiniTest::Unit.runner
-      runner.run(args)
+      runner.run
 
       # Make sure that minitest doesn't run automatically when the process exits
       patch_minitest
@@ -48,12 +43,18 @@ module TConsole
       "P" => ::Term::ANSIColor.green
     }
 
-    attr_accessor :config, :results
+    attr_accessor :match_patterns, :config, :results
+
+    def initialize(match_patterns, config)
+      self.match_patterns = match_patterns
+      self.match_patterns = [] unless self.match_patterns.is_a?(Array)
 
-    def initialize(config)
       self.config = config
       self.results = TConsole::TestResult.new
 
+      results.suite_counts = config.cached_suite_counts
+      results.elements = config.cached_elements
+
       super()
     end
 
@@ -96,21 +97,39 @@ module TConsole
     end
 
     def _run_suite(suite, type)
+      @last_suite ||= nil
       @failed_fast ||= false
 
-      filter = options[:filter] || '/./'
-      filter = Regexp.new $1 if filter =~ /\/(.*)\//
+      assertions = suite.send("#{type}_methods").map do |method|
+        skip = false
+
+        # Get our unique id for this particular element
+        id = results.add_element(suite, method)
+        suite_id = results.elements[suite.to_s]
+
+        # If we're using failed fast mode and we already failed, just return
+        skip = true if @failed_fast
 
-      assertions = suite.send("#{type}_methods").grep(filter).map do |method|
-        if @failed_fast
+        # If we've got match patterns, see if this matches them
+        if !match_patterns.empty?
+          match = match_patterns.find do |pattern|
+            pattern == suite.to_s || pattern == "#{suite.to_s}##{method.to_s}" || pattern == suite_id || pattern == id
+          end
+
+          skip = true unless match
+        end
+
+        if skip
           0
         else
           inst = suite.new method
           inst._assertions = 0
 
           # Print the suite name if needed
-          if results.add_suite(suite)
-            print("\n\n", ::Term::ANSIColor.cyan, suite, ::Term::ANSIColor.reset, "\n")
+          unless @last_suite == suite
+            print("\n\n", ::Term::ANSIColor.cyan, suite, ::Term::ANSIColor.reset,
+                  ::Term::ANSIColor.magenta, " #{suite_id}", ::Term::ANSIColor.reset, "\n")
+            @last_suite = suite
           end
 
           @start_time = Time.now
@@ -120,13 +139,16 @@ module TConsole
 
           result = "P" if result == "."
 
+          results.failures << id unless result == "P"
+
           if config.fail_fast && result != "P"
             @failed_fast = true
           end
 
           output = "#{result} #{method}"
 
-          print COLOR_MAP[result], " #{output}", ::Term::ANSIColor.reset, " #{time}s\n"
+          print COLOR_MAP[result], " #{output}", ::Term::ANSIColor.reset, " #{time}s ",
+            ::Term::ANSIColor.magenta, "#{id}", ::Term::ANSIColor.reset, "\n"
 
           if @failed_fast
             print "\n", COLOR_MAP["E"], "Halting tests because of failure.", ::Term::ANSIColor.reset, "\n"
@@ -149,12 +171,10 @@ module TConsole
           when MiniTest::Assertion then
             @failures += 1
             results.failures += 1
-            results.append_failure_details(klass, meth)
             "Failure:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
           else
             @errors += 1
             results.errors += 1
-            results.append_failure_details(klass, meth)
             bt = MiniTest::filter_backtrace(e.backtrace).join "\n    "
             "Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n    #{bt}\n"
           end

data/lib/tconsole/server.rb

@@ -7,6 +7,11 @@ module TConsole
       self.last_result = TConsole::TestResult.new
     end
 
+    # Basically just a noop that helps us figure out if we're connected or not
+    def connected?
+      true
+    end
+
     def stop
       DRb.stop_service
     end
@@ -51,7 +56,9 @@ module TConsole
       result
     end
 
-    def run_tests(globs, name_pattern, message = "Running tests...")
+    # Loads the files that match globs and then executes tests against them. Limit tests
+    # with class names, method names, and test ids using match_patterns.
+    def run_tests(globs, match_patterns, message = "Running tests...")
       time = Benchmark.realtime do
         # Pipe for communicating with child so we can get its results back
         read, write = IO.pipe
@@ -81,7 +88,7 @@ module TConsole
             require File.join(File.dirname(__FILE__), "minitest_handler")
 
             config.trace("Running tests.")
-            result = MiniTestHandler.run(name_pattern, config)
+            result = MiniTestHandler.run(match_patterns, config)
             config.trace("Finished running tests.")
 
             config.trace("Writing test results back to server.")
@@ -102,6 +109,7 @@ module TConsole
         begin
           config.trace("Reading test results from console.")
           self.last_result = Marshal.load(response.unpack("m")[0])
+          config.cache_test_ids(self.last_result)
           config.trace("Finished reading test results from console.")
         rescue => e
           config.trace("Exception: #{e.message}")
@@ -109,7 +117,6 @@ module TConsole
           config.trace(e.backtrace.join("\n"))
           config.trace("==== End Backtrace ====")
 
-
           puts "ERROR: Unable to process test results."
           puts
 
@@ -127,68 +134,18 @@ module TConsole
       puts
     end
 
-    # This code is from the rails test:recents command
-    def run_recent(test_pattern)
-      touched_since = Time.now - 600 # 10 minutes ago
-      files = recent_files(touched_since, "app/models/**/*.rb", "test/unit")
-      files.concat(recent_files(touched_since, "app/controllers/**/*.rb", "test/functional"))
-
-      message = "Running #{files.length} #{files.length == 1 ? "test file" : "test files"} based on changed files..."
-      run_tests(files, test_pattern, message)
-    end
-
-    def run_failed
-      file_names = last_result.failure_details.map { |detail| filenameify(detail[:class]) }
-      files_to_rerun = []
-
-      files_to_rerun << file_names.map {|file| (file.match(/controller/)) ? "test/functional/#{file}.rb" : "test/unit/#{file}.rb"}
-      run_tests(files_to_rerun, nil, "Running last failed tests: #{files_to_rerun.join(", ")}")
+    # Runs all tests against the match patterns given
+    def run_all_tests(match_patterns = nil)
+      run_tests(config.file_sets["all"], match_patterns)
     end
 
-    def recent_files(touched_since, source_pattern, test_path)
-      Dir.glob(source_pattern).map do |path|
-        if File.mtime(path) > touched_since
-          tests = []
-          source_dir = File.dirname(path).split("/")
-          source_file = File.basename(path, '.rb')
-
-          # Support subdirs in app/models and app/controllers
-          modified_test_path = source_dir.length > 2 ? "#{test_path}/" << source_dir[1..source_dir.length].join('/') : test_path
-
-          # For modified files in app/ run the tests for it. ex. /test/functional/account_controller.rb
-          test = "#{modified_test_path}/#{source_file}_test.rb"
-          tests.push test if File.exist?(test)
-
-          # For modified files in app, run tests in subdirs too. ex. /test/functional/account/*_test.rb
-          test = "#{modified_test_path}/#{File.basename(path, '.rb').sub("_controller","")}"
-          File.glob("#{test}/*_test.rb").each { |f| tests.push f } if File.exist?(test)
-
-          return tests
-
-        end
-      end.flatten.compact
+    # Runs a file set out of the config
+    def run_file_set(set)
+      run_tests(config.file_sets[set], nil)
     end
 
-    # Based on the code from rake test:uncommitted in Rails
-    def run_uncommitted(test_pattern)
-      if File.directory?(".svn")
-        changed_since_checkin = silence_stderr { `svn status` }.split.map { |path| path.chomp[7 .. -1] }
-      elsif File.directory?(".git")
-        changed_since_checkin = silence_stderr { `git ls-files --modified --others` }.split.map { |path| path.chomp }
-      else
-        puts "Not a Subversion or Git checkout."
-        return
-      end
-
-      models      = changed_since_checkin.select { |path| path =~ /app[\\\/]models[\\\/].*\.rb$/ }
-      controllers = changed_since_checkin.select { |path| path =~ /app[\\\/]controllers[\\\/].*\.rb$/ }
-
-      unit_tests       = models.map { |model| "test/unit/#{File.basename(model, '.rb')}_test.rb" }
-      functional_tests = controllers.map { |controller| "test/functional/#{File.basename(controller, '.rb')}_test.rb" }
-      files = (unit_tests + functional_tests).uniq.select { |file| File.exist?(file) }
-
-      message = "Running #{files.length} #{files.length == 1 ? "test file" : "test files"} based on uncommitted changes..."
-      run_tests(files, test_pattern, message)
+    def run_failed
+      run_tests(config.file_sets["all"], last_result.failures)
     end
 
     def run_info

data/lib/tconsole/test_result.rb

@@ -18,29 +18,44 @@ module TConsole
     # The timings for the tests we've run
     attr_accessor :timings
 
+    # The element id lookup hash
+    attr_accessor :elements
+
+    # Test counts within various suites
+    attr_accessor :suite_counts
+
     def initialize
       self.failures = 0
       self.errors = 0
       self.skips = 0
-      self.failure_details = []
+      self.failures = []
       self.suites = {}
       self.timings = []
-    end
 
-    # Adds to the failure details that we know about
-    def append_failure_details(klass, meth)
-      self.failure_details << { :class => klass.to_s, :method => meth.to_s }
+      self.suite_counts = {}
+      self.elements = {}
     end
 
-    # Records that we've encountered a particular suite. Returns true
-    # if it's new or false otherwise.
-    def add_suite(suite)
-      if suites.has_key?(suite.to_s)
-        false
-      else
-        suites[suite.to_s] = true
-        true
+    def add_element(suite, method)
+      canonical_name = "#{suite}##{method}"
+
+      # Just return the id if we already know about this
+      if id = elements[canonical_name]
+        return id
       end
+
+      # See if we know about this suite already
+      unless suite_id = elements[suite.to_s]
+        suite_id = self.suite_counts.length + 1
+        elements[suite.to_s] = suite_id
+        suite_counts[suite.to_s] ||= 0
+      end
+
+      suite_counts[suite.to_s] += 1
+      id = "#{suite_id}-#{suite_counts[suite.to_s]}"
+      elements[canonical_name] = id
+
+      id
     end
 
     def add_timing(suite, method, time)

data/lib/tconsole/version.rb

@@ -1,3 +1,3 @@
 module TConsole
-  VERSION = "1.1.0pre8"
+  VERSION = "1.1.0pre9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tconsole
 version: !ruby/object:Gem::Version
-  version: 1.1.0pre8
+  version: 1.1.0pre9
   prerelease: 5
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-17 00:00:00.000000000 Z
+date: 2012-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: term-ansicolor
-  requirement: &70230844589280 !ruby/object:Gem::Requirement
+  requirement: &70167646243500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 1.0.7
   type: :runtime
   prerelease: false
-  version_requirements: *70230844589280
+  version_requirements: *70167646243500
 description: ! "    tconsole allows Rails developers to easily and quickly run their
   tests as a whole or in subsets. It forks the testing processes from\n    a preloaded
   test environment to ensure that developers don't have to reload their entire Rails
@@ -39,8 +39,10 @@ files:
 - README.md
 - Rakefile
 - bin/tconsole
+- drb_connection_test.rb
 - lib/tconsole.rb
 - lib/tconsole/config.rb
+- lib/tconsole/console.rb
 - lib/tconsole/minitest_handler.rb
 - lib/tconsole/server.rb
 - lib/tconsole/test_result.rb