tconsole 1.2.7 → 1.2.8

data/.gitignore

@@ -3,3 +3,4 @@
 Gemfile.lock
 pkg/*
 .rvmrc
+.rspec

data/Gemfile

@@ -4,4 +4,4 @@ source "http://rubygems.org"
 gemspec
 
 gem "rake"
-gem "nutrasuite"
+gem "rspec"

data/Rakefile

@@ -1,10 +1 @@
 require "bundler/gem_tasks"
-require "rake/testtask"
-
-task :default => [:test]
-
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.test_files = FileList['test/unit/**/*_test.rb']
-  t.verbose = true
-end

data/bin/tconsole

@@ -2,4 +2,4 @@
 
 require File.join(File.dirname(__FILE__), "..", "lib", "tconsole")
 
-TConsole::Runner.run(ARGV)
+TConsole::Runner.new(ARGV).run

data/lib/tconsole.rb

@@ -1,104 +1,19 @@
 require "tconsole/version"
-require "tconsole/config"
-require "tconsole/console"
-require "tconsole/server"
-require "tconsole/pipe_server"
-require "tconsole/test_result"
-require "tconsole/util"
 
+require "chattyproc"
 require "optparse"
 require "readline"
 require "benchmark"
-require "drb/drb"
 require "term/ansicolor"
 require "shellwords"
 
-module TConsole
-  class Runner
-
-    # Spawns a new environment. Looks at the results of the environment to determine whether to stop or
-    # keep running
-    def self.run(argv)
-      stty_save = `stty -g`.chomp
-
-      running = true
-      trap("SIGINT", "IGNORE")
-      trap("SIGTSTP", "IGNORE")
-
-      # A little welcome
-      puts
-      puts "Welcome to tconsole (v#{TConsole::VERSION}). Type 'help' for help or 'exit' to quit."
-
-      # set up the config
-      Config.load_config(File.join(Dir.home, ".tconsole"))
-      Config.load_config(File.join(Dir.pwd, ".tconsole"))
-      config = Config.configure(argv)
-
-      config_errors = config.validation_errors
-      if config_errors.length > 0
-        puts
-        puts config_errors.first
-        exit(1)
-      end
-
-      # Set up our console input handling and history
-      console = Console.new(config)
-
-      # Start the server
-      while running
-        # ignore ctrl-c during load, since things can get kind of messy if we don't
-
-        pipe_server = PipeServer.new
-
-        config.trace("Forking test server.")
-        server_pid = fork do
-          pipe_server.callee!
-
-          server = Server.new(config)
-
-          while message = pipe_server.read
-            config.trace("Server Received Message: #{message[:action]}")
-            begin
-              result = server.handle(message)
-              pipe_server.write(result)
-            rescue => e
-              puts
-              puts "An error occured: #{e.message}"
-              config.trace("===========")
-              config.trace(e.backtrace.join("\n"))
-              config.trace("===========")
-              pipe_server.write(nil)
-            end
-          end
-        end
-
-        pipe_server.caller!
-
-        wait_until = Time.now + 10
-
-        config.trace("Attempting to load environment.")
-        pipe_server.write({:action => "load_environment"})
-
-        unless pipe_server.read
-          puts "Couldn't load the test environment. Exiting."
-          exit(1)
-        end
-        config.trace("Environment loaded successfully.")
-
-        console.pipe_server = pipe_server
-        running = console.read_and_execute
-        console.pipe_server = nil
-
-        Process.waitall
-      end
-
-      console.store_history
+require "tconsole/config"
+require "tconsole/reporter"
+require "tconsole/console"
+require "tconsole/server"
+require "tconsole/test_result"
+require "tconsole/util"
+require "tconsole/runner"
 
-      puts
-      puts "Exiting. Bye!"
-      system("stty", stty_save);
-    end
-  end
-end
 
 

data/lib/tconsole/config.rb

@@ -37,9 +37,9 @@ module TConsole
     # Only runs the command passed on the command line, and then exits
     attr_accessor :once
 
-    def initialize(argv)
+    def initialize(argv = [])
       self.trace_execution = false
-      self.test_dir = "./test"
+      self.test_dir = "test"
       self.include_paths = ["./test", "./lib"]
       self.preload_paths = []
       self.fail_fast = false
@@ -172,7 +172,6 @@ module TConsole
           "integration" => ["#{config.test_dir}/integration/**/*_test.rb"]
         }
 
-
         config.before_load do
           ENV["RAILS_ENV"] ||= "test"
         end
@@ -205,10 +204,5 @@ module TConsole
     def self.is_rails?
       @rails ||= !!File.exist?("./config/application.rb")
     end
-
-    # Outputs trace message if our config allows it
-    def trace(message)
-      puts "[tconsole trace] #{message}" if trace?
-    end
   end
 end

data/lib/tconsole/console.rb

@@ -2,16 +2,15 @@ module TConsole
   class Console
     KNOWN_COMMANDS = ["exit", "reload", "help", "info", "!failed", "!timings", "set"]
 
-    attr_accessor :pipe_server
+    attr_accessor :config, :reporter
 
-    def initialize(config)
-      @config = config
+    def initialize(config, reporter)
+      self.config = config
+      self.reporter = reporter
       read_history
-
-      define_autocomplete
     end
 
-    def define_autocomplete
+    def define_autocomplete(pipe_server)
       Readline.completion_append_character = ""
 
       # Proc for helping us figure out autocompletes
@@ -21,7 +20,7 @@ module TConsole
 
         known_elements = []
         unless pipe_server.nil?
-          known_elements = send_message(:autocomplete, str)
+          known_elements = send_message(pipe_server, :autocomplete, str)
         end
 
         known_commands.concat(known_elements)
@@ -29,12 +28,7 @@ module TConsole
     end
 
     # Returns true if the app should keep running, false otherwise
-    def read_and_execute
-      if pipe_server.nil?
-        puts "No connection to test environment. Exiting."
-        return false
-      end
-
+    def read_and_execute(pipe_server)
       prompt = "tconsole> "
 
       trap("SIGTSTP", "SYSTEM_DEFAULT")
@@ -43,7 +37,7 @@ module TConsole
       end
 
       # Run any commands that have been passed
-      result = process_command(@config.run_command)
+      result = process_command(pipe_server, @config.run_command)
       @config.run_command = ""
       if result == :exit || @config.once
         return false
@@ -51,10 +45,12 @@ module TConsole
         return true
       end
 
+      define_autocomplete(pipe_server)
+
       # The command entry loop
       while command = Readline.readline(prompt, false)
         command.strip!
-        result = process_command(command)
+        result = process_command(pipe_server, command)
 
         if result == :exit
           return false
@@ -69,8 +65,9 @@ module TConsole
 
     # Public: Process a command however it needs to be handled.
     #
+    # pipe_server - The pipe server we're working with
     # command - The command we need to parse and handle
-    def process_command(command)
+    def process_command(pipe_server, command)
       args = Shellwords.shellwords(command)
 
       # save the command unless we're exiting or repeating the last command
@@ -81,80 +78,49 @@ module TConsole
       if command == ""
         # do nothing
       elsif args[0] == "exit"
-        send_message(:stop)
-        self.pipe_server = nil
+        send_message(pipe_server, :stop)
         return :exit
       elsif args[0] == "reload"
-        send_message(:stop)
+        send_message(pipe_server, :stop)
         return :reload
       elsif args[0] == "help"
-        print_help
+        reporter.help_message
       elsif args[0] == "!failed"
-        send_message(:run_failed)
+        send_message(pipe_server, :run_failed)
       elsif args[0] == "!timings"
-        send_message(:show_performance, args[1])
+        send_message(pipe_server, :show_performance, args[1])
       elsif args[0] == "info"
-        send_message(:run_info)
+        send_message(pipe_server, :run_info)
       elsif args[0] == "set"
-        send_message(:set, args[1], args[2])
+        send_message(pipe_server, :set, args[1], args[2])
       elsif args[0].start_with?(".")
-        send_message(:shell, command[1, command.length - 1])
+        shell_command(command[1, command.length - 1])
       elsif @config.file_sets.has_key?(args[0])
-        send_message(:run_file_set, args[0])
+        send_message(pipe_server, :run_file_set, args[0])
       else
-        send_message(:run_all_tests, args)
+        send_message(pipe_server, :run_all_tests, args)
       end
 
       nil
     end
 
-    def send_message(message, *args)
+    def send_message(pipe_server, message, *args)
       pipe_server.write({:action => message.to_sym, :args => args})
       pipe_server.read
     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 ".[command]                  # Executes the given command in a subshell"
-      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
+    # Internal: Runs a shell command on the console and outputs the results.
+    def shell_command(command)
+      system(command)
 
-      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
+      result = $?
 
+      reporter.info
+      if result.exitstatus == 0
+        reporter.exclaim("Command exited with status code: 0")
+      else
+        reporter.error("Command exited with status code: #{result.exitstatus}")
+      end
     end
 
     def history_file

data/lib/tconsole/reporter.rb

@@ -0,0 +1,113 @@
+# Manages all output for TConsole
+module TConsole
+  class Reporter
+    attr_accessor :config
+
+    def initialize(config)
+      self.config = config
+    end
+
+    # Public: Ouptuts an informative message.
+    def info(message = "")
+      puts message
+    end
+
+    # Public: Outputs a positive informative message.
+    # Colors it green if the console supports it.
+    def exclaim(message = "")
+      puts ::Term::ANSIColor.green(message)
+    end
+
+    # Public: Outputs a warning message.
+    def warn(message = "")
+      puts ::Term::ANSIColor.yellow(message)
+    end
+
+    # Public: Outputs an error message.
+    def error(message = "")
+      puts ::Term::ANSIColor.red(message)
+    end
+
+
+    # Public: Outputs a trace message, when needed.
+    def trace(message = "")
+      puts "[tconsole trace] #{message}" if config.trace?
+    end
+
+    # Public: Prints a backtrace out.
+    def trace_backtrace(exception)
+      trace("===========")
+      trace(exception.backtrace.join("\n"))
+      trace("===========")
+    end
+
+    # Public: Outputs a timing for the timings command, using the proper
+    # color logic
+    def timing(timing, test_id)
+      output = "#{"%0.6f" % timing[:time]}s #{timing[:name]}"
+      if timing[:time] > 1
+        print ::Term::ANSIColor.red, output, ::Term::ANSIColor.reset
+      else
+        print ::Term::ANSIColor.green, output, ::Term::ANSIColor.reset
+      end
+
+      print ::Term::ANSIColor.magenta, " #{last_result}", ::Term::ANSIColor.reset, "\n"
+    end
+
+    # Public: Prints a list of available commands
+    def help_message
+      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 ".[command]                  # Executes the given command in a subshell"
+      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
+
+    # Public: Outputs the tconsole welcome message
+    def welcome_message
+      info
+      info("Welcome to tconsole (v#{TConsole::VERSION}). Type 'help' for help or 'exit' to quit.")
+    end
+
+    # Public: Outputs the tconsole exit message
+    def exit_message
+      info
+      info("Exiting. Bye!")
+    end
+  end
+end

data/lib/tconsole/runner.rb

@@ -0,0 +1,127 @@
+module TConsole
+  class Runner
+
+    attr_accessor :config, :reporter, :console, :stty_save
+
+    # Public: Sets up the new runner's config.
+    def initialize(argv = [])
+      # try to load the default configs
+      Config.load_config(File.join(Dir.home, ".tconsole"))
+      Config.load_config(File.join(Dir.pwd, ".tconsole"))
+      self.config = Config.configure(argv)
+      self.reporter = Reporter.new(config)
+    end
+
+    # Spawns a new environment. Looks at the results of the environment to determine whether to stop or
+    # keep running
+    def run
+      prepare_process
+      reporter.welcome_message
+      exit(1) if print_config_errors
+
+      # Set up our console input handling and history
+      console = Console.new(config, reporter)
+
+      # Start the server
+      while console_run_loop(console)
+        # just need to run the loop
+      end
+
+      console.store_history
+
+      cleanup_process
+    end
+
+    # Internal: Set up the process and console.
+    def prepare_process
+      self.stty_save = `stty -g`.chomp
+
+      trap("SIGINT", "IGNORE")
+      trap("SIGTSTP", "IGNORE")
+    end
+
+    # Internal: Cleans up the process at the end of execution.
+    def cleanup_process
+      reporter.exit_message
+      system("stty", self.stty_save);
+    end
+
+    # Internal: Prints config errors, if there are any.
+    #
+    # Returns true if there were errors, false otherwise.
+    def print_config_errors
+      config_errors = @config.validation_errors
+      if config_errors.length > 0
+        reporter.error
+        reporter.error(config_errors.first)
+        true
+      else
+        false
+      end
+    end
+
+    # Internal: Environment reload run loop.
+    #
+    # This run loop handles spawning a new tconsole environment - it's basically
+    # just there to handle reloads. Also calls out to the input loop for the
+    # console.
+    #
+    # Returns false if tconsole needs to stop, true otherwise.
+    def console_run_loop(console)
+      pipe_server = ChattyProc::PipeServer.new
+
+      reporter.trace("Forking test server.")
+      server_pid = fork do
+        server_run_loop(pipe_server)
+      end
+
+      pipe_server.caller!
+      unless load_environment(pipe_server)
+        pipe_server.write({:action => "exit"})
+        return false
+      end
+
+      continue = console.read_and_execute(pipe_server)
+      reporter.trace("Console read loop returned - continue: #{continue}")
+
+      Process.waitall
+
+      continue
+    end
+
+    # Internal: Asks the server to load the environment.
+    #
+    # Returns true if the environment was loaded, or false otherwise.
+    def load_environment(pipe_server)
+      reporter.trace("Attempting to load environment.")
+      pipe_server.write({:action => "load_environment"})
+
+      if pipe_server.read
+        reporter.trace("Environment loaded successfully.")
+        true
+      else
+        reporter.error("Couldn't load the test environment. Exiting.")
+        false
+      end
+    end
+
+    # Internal: Run loop for the server.
+    def server_run_loop(pipe_server)
+      pipe_server.callee!
+      server = Server.new(config, reporter)
+
+      while message = pipe_server.read
+        reporter.trace("Server Received Message: #{message[:action]}")
+        begin
+          result = server.handle(message)
+          pipe_server.write(result)
+        rescue => e
+          reporter.error
+          reporter.error("An error occured: #{e.message}")
+          reporter.trace_backtrace(e)
+          pipe_server.write(nil)
+        end
+      end
+    end
+  end
+end

data/lib/tconsole/server.rb

@@ -1,9 +1,10 @@
 module TConsole
   class Server
-    attr_accessor :config, :last_result
+    attr_accessor :config, :reporter, :last_result
 
-    def initialize(config)
+    def initialize(config, reporter)
       self.config = config
+      self.reporter = reporter
       self.last_result = TConsole::TestResult.new
     end
 
@@ -23,8 +24,8 @@ module TConsole
       result = false
 
       time = Benchmark.realtime do
-        puts
-        puts "Loading environment..."
+        reporter.info
+        reporter.info("Loading environment...")
 
         begin
           # Append our include paths
@@ -43,20 +44,16 @@ module TConsole
 
           result = true
         rescue Exception => e
-          puts "Error - Loading your environment failed: #{e.message}"
-          if config.trace?
-            puts
-            puts "    #{e.backtrace.join("\n    ")}"
-          end
-
+          reporter.error("Error - Loading your environment failed: #{e.message}")
+          reporter.trace_backtrace(e)
           return false
         end
 
         preload_test_ids
       end
 
-      puts "Environment loaded in #{"%0.6f" % time}s."
-      puts
+      reporter.info("Environment loaded in #{"%0.6f" % time}s.")
+      reporter.info
 
       result
     end
@@ -86,11 +83,11 @@ module TConsole
       Process.wait(pid)
 
       begin
-        config.trace("Reading result from fork.")
+        reporter.trace("Reading result from fork.")
         Marshal.load(response.unpack("m")[0])
       rescue => e
-        config.trace("Problem reading result from fork. Returning nil.")
-        config.trace(e.message)
+        reporter.trace("Problem reading result from fork. Returning nil.")
+        reporter.trace(e.message)
         nil
       end
     end
@@ -99,8 +96,8 @@ module TConsole
     # with class names, method names, and test ids using match_patterns.
     def run_tests(globs, match_patterns, message = "Running tests...")
       time = Benchmark.realtime do
-        puts message
-        puts
+        reporter.info(message)
+        reporter.info
 
         paths = []
         globs.each do |glob|
@@ -108,34 +105,34 @@ module TConsole
         end
 
         if paths.length == 0
-          puts ::Term::ANSIColor.yellow("No test files match your requested test set: #{globs.join(",")}.")
-          puts ::Term::ANSIColor.yellow("Skipping execution.")
+          reporter.warn("No test files match your requested test set: #{globs.join(",")}.")
+          reporter.warn("Skipping execution.")
           return nil
         end
 
         self.last_result = run_in_fork do
 
           paths.each do |path|
-            config.trace("Requested path `#{path}` doesn't exist.") unless File.exist?(path)
+            reporter.trace("Requested path `#{path}` doesn't exist.") unless File.exist?(path)
             require File.expand_path(path)
           end
 
-          config.trace("Running before_test_run callback")
+          reporter.trace("Running before_test_run callback")
           config.before_test_run!
-          config.trace("Completed before_test_run callback")
+          reporter.trace("Completed before_test_run callback")
 
           result = nil
           if defined?(::MiniTest)
-            config.trace("Detected minitest.")
+            reporter.trace("Detected minitest.")
             require File.join(File.dirname(__FILE__), "minitest_handler")
 
-            config.trace("Running tests.")
+            reporter.trace("Running tests.")
             runner = MiniTestHandler.setup(match_patterns, config)
 
             # Handle trapping interrupts
             trap("SIGINT") do
-              puts
-              puts "Trapped interrupt. Halting tests."
+              reporter.warn
+              reporter.warn("Trapped interrupt. Halting tests.")
 
               runner.interrupted = true
             end
@@ -147,16 +144,16 @@ module TConsole
             # Make sure minitest doesn't run automatically
             MiniTestHandler.patch_minitest
 
-            config.trace("Finished running tests.")
+            reporter.trace("Finished running tests.")
 
             if runner.interrupted
-              puts ::Term::ANSIColor.red("Test run was interrupted.")
+              reporter.error("Test run was interrupted.")
             end
 
           elsif defined?(::Test::Unit)
-            puts "Sorry, but tconsole doesn't support Test::Unit yet"
+            reporter.error("Sorry, but tconsole doesn't support Test::Unit yet")
           elsif defined?(::RSpec)
-            puts "Sorry, but tconsole doesn't support RSpec yet"
+            reporter.error("Sorry, but tconsole doesn't support RSpec yet")
           end
 
           result
@@ -172,9 +169,9 @@ module TConsole
         true
       end
 
-      puts
-      puts "Tests ran in #{"%0.6f" % time}s. Finished at #{Time.now.strftime('%Y-%m-%d %l:%M:%S %p')}."
-      puts
+      reporter.info
+      reporter.info("Tests ran in #{"%0.6f" % time}s. Finished at #{Time.now.strftime('%Y-%m-%d %l:%M:%S %p')}.")
+      reporter.info
     end
 
     # Preloads our autocomplete cache
@@ -206,18 +203,18 @@ module TConsole
 
     def run_failed
       if last_result.failures.empty?
-        puts "No tests failed in your last run, or you haven't run any tests in this session yet."
-        puts
+        reporter.info("No tests failed in your last run, or you haven't run any tests in this session yet.")
+        reporter.info
       else
         run_tests(config.file_sets["all"], last_result.failures)
       end
     end
 
     def run_info
-      puts "Defined Constants:"
-      puts Module.constants.sort.join("\n")
-      puts
-      puts
+      reporter.info("Defined Constants:")
+      reporter.info(Module.constants.sort.join("\n"))
+      reporter.info
+      reporter.info
     end
 
     def show_performance(limit = nil)
@@ -227,26 +224,19 @@ module TConsole
 
       sorted_timings = last_result.timings.sort_by { |timing| timing[:time] }
 
-      puts
-      puts "Timings from last run:"
-      puts
+      reporter.info
+      reporter.info("Timings from last run:")
+      reporter.info
 
       if sorted_timings.length == 0
-        puts ::Term::ANSIColor.red + "No timing data available. Be sure you've run some tests." + ::Term::ANSIColor.reset
+        reporter.error("No timing data available. Be sure you've run some tests.")
       else
         sorted_timings.reverse[0, limit].each do |timing|
-          output = "#{"%0.6f" % timing[:time]}s #{timing[:name]}"
-          if timing[:time] > 1
-            print ::Term::ANSIColor.red, output, ::Term::ANSIColor.reset
-          else
-            print ::Term::ANSIColor.green, output, ::Term::ANSIColor.reset
-          end
-
-          print ::Term::ANSIColor.magenta, " #{last_result.elements[timing[:name]]}", ::Term::ANSIColor.reset, "\n"
+          reporter.timing(timing, last_result.elements[timing[:name]])
         end
       end
 
-      puts
+      reporter.info
     end
 
     def set(key, value)
@@ -259,35 +249,16 @@ module TConsole
             config.fail_fast = false
           end
 
-          puts ::Term::ANSIColor.green + "Fail Fast is now #{config.fail_fast ? "on" : "off"}" + ::Term::ANSIColor.reset
-          puts
+          reporter.exclaim("Fail Fast is now #{config.fail_fast ? "on" : "off"}")
+          reporter.exclaim
         else
-          puts ::Term::ANSIColor.green + "Fail fast is currently #{config.fail_fast ? "on" : "off"}" + ::Term::ANSIColor.reset
-          puts
+          reporter.exclaim("Fail fast is currently #{config.fail_fast ? "on" : "off"}")
+          reporter.exclaim
         end
       else
-        puts ::Term::ANSIColor.yellow + "I don't know how to set `#{key}`." + ::Term::ANSIColor.reset + " Usage: set {key} {value}"
-        puts
-      end
-    end
-
-    # Internal: Runs the given command in the shell.
-    #
-    # command - the command to execute
-    #
-    # Examples
-    #
-    #   shell("ls -la")
-    def shell(command)
-      system(command)
-
-      result = $?
-
-      puts
-      if result.exitstatus == 0
-        puts ::Term::ANSIColor.green + "Command exited with status code: 0" + ::Term::ANSIColor.reset
-      else
-        puts ::Term::ANSIColor.red + "Command exited with status code: #{result.exitstatus}" + ::Term::ANSIColor.reset
+        reporter.warn("I don't know how to set `#{key}`.")
+        reporter.info("Usage: set {key} {value}")
+        reporter.warn
       end
     end
   end

data/lib/tconsole/version.rb

@@ -1,3 +1,3 @@
 module TConsole
-  VERSION = "1.2.7"
+  VERSION = "1.2.8"
 end

data/spec/config_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe TConsole::Config do
+  context "a Config without arguments" do
+    before do
+      @config = TConsole::Config.new([])
+      @config.test_dir = "./spec/fixtures/minitest"
+    end
+
+    context "when configured test directory doesn't exist" do
+      before do
+        @config.test_dir = "./monkey_business"
+      end
+
+      it "sets a validation error" do
+        expect(@config.validation_errors[0]).to eq("Couldn't find test directory `./monkey_business`. Exiting.")
+      end
+    end
+
+    context "when the configuration doesn't include an all file set" do
+      before do
+        @config.file_sets = {}
+      end
+
+      it "sets a validation error" do
+        expect(@config.validation_errors[0]).to eq("No `all` file set is defined in your configuration. Exiting.")
+      end
+    end
+  end
+
+  context "a Config with the trace argument" do
+    before do
+      @config = TConsole::Config.new(Shellwords.shellwords("--trace"))
+    end
+
+    it "has tracing enabled" do
+      expect(@config.trace_execution).to be_true
+    end
+  end
+
+  context "a Config with the once argument" do
+    before do
+      @config = TConsole::Config.new(Shellwords.shellwords("--once all"))
+    end
+
+    it "has run once enabled" do
+      expect(@config.once).to be_true
+    end
+  end
+
+  context "a Config with remaining arguments" do
+    before do
+      @config = TConsole::Config.new(Shellwords.shellwords("--trace set fast on"))
+    end
+
+    it "sets remaining args as first command" do
+      expect(@config.run_command).to eq("set fast on")
+    end
+  end
+
+  describe ".run" do
+    before do
+      TConsole::Config.run do |config|
+        config.test_dir = "./awesome_sauce"
+      end
+    end
+
+    after do
+      TConsole::Config.clear_loaded_configs
+    end
+
+    it "saves the run proc" do
+      loaded_configs = TConsole::Config.instance_variable_get(:@loaded_configs)
+      expect(loaded_configs.length).to eq(1)
+    end
+
+    it "runs loaded configs from first to last" do
+      TConsole::Config.run do |config|
+        config.test_dir = "./awesomer_sauce"
+      end
+
+      config = TConsole::Config.configure
+      expect(config.test_dir).to eq("./awesomer_sauce")
+    end
+  end
+
+  describe ".load_config" do
+    it "loads configs" do
+      TConsole::Config.load_config(File.join(File.dirname(__FILE__), "sample_config"))
+      loaded_configs = TConsole::Config.instance_variable_get(:@loaded_configs)
+      expect(loaded_configs.length).to eq(1)
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe TConsole::Runner do
+  before do
+    @runner = TConsole::Runner.new
+    @ps = ChattyProc::PipeServer.new
+  end
+
+  describe "#load_environment" do
+    before do
+      @ps.stub(:write) { }
+    end
+
+    it "returns false if the environment load call fails" do
+      @ps.stub(:read) { false }
+      expect(@runner.load_environment(@ps)).to be_false
+    end
+
+    it "returns true if the environment load call succeeds" do
+      @ps.stub(:read) { true }
+      expect(@runner.load_environment(@ps)).to be_true
+    end
+  end
+
+  describe "#console_run_loop" do
+    before do
+      @config = TConsole::Config.new
+      @reporter = TConsole::Reporter.new(@config)
+      @console = TConsole::Console.new(@config, @reporter)
+    end
+
+    it "returns false when loading the environment fails" do
+      @runner.stub(:load_environment) { false }
+
+      expect(@runner.console_run_loop(@console)).to be_false
+    end
+  end
+end

data/{test/test_helper.rb → spec/spec_helper.rb}

@@ -1,7 +1,4 @@
 require "rubygems"
 require "bundler/setup"
 
-require 'test/unit'
-require 'nutrasuite'
-
 require 'tconsole'

data/spec/util_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe "TConsole::Util" do
+  describe ".filter_backtrace" do
+    before do
+      @non_tconsole_path = "/Users/alan/Projects/commondream/tconsole-test/test/functional/posts_controller_test.rb:16:in `block in <class:PostsControllerTest>'"
+      @tconsole_path = "#{File.expand_path(File.join(File.dirname(__FILE__), ".."))}/posts_controller_test.rb:16:in `block in <class:PostsControllerTest>'"
+
+      @backtrace = [
+        @non_tconsole_path,
+        @tconsole_path
+      ]
+
+      @filtered_backtrace = TConsole::Util.filter_backtrace(@backtrace)
+    end
+
+    context "removes tconsole paths" do
+      it { expect(@filtered_backtrace.length).to eq(1) }
+      it { expect(@filtered_backtrace).to_not include(@tconsole_path) }
+    end
+
+    it "doesn't remove non-tconsole paths" do
+      expect(@filtered_backtrace).to include(@non_tconsole_path)
+    end
+  end
+end

data/tconsole.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |s|
 
   # specify any dependencies here; for example:
   # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "chattyproc", "~> 1.0.0"
   s.add_runtime_dependency "term-ansicolor", "~> 1.0.7"
   s.add_runtime_dependency "minitest", "~> 4.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tconsole
 version: !ruby/object:Gem::Version
-  version: 1.2.7
+  version: 1.2.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-16 00:00:00.000000000 Z
+date: 2013-01-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: chattyproc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: term-ansicolor
   requirement: !ruby/object:Gem::Requirement
@@ -65,16 +81,18 @@ files:
 - lib/tconsole/config.rb
 - lib/tconsole/console.rb
 - lib/tconsole/minitest_handler.rb
-- lib/tconsole/pipe_server.rb
+- lib/tconsole/reporter.rb
+- lib/tconsole/runner.rb
 - lib/tconsole/server.rb
 - lib/tconsole/test_result.rb
 - lib/tconsole/util.rb
 - lib/tconsole/version.rb
+- spec/config_spec.rb
+- spec/runner_spec.rb
+- spec/sample_config
+- spec/spec_helper.rb
+- spec/util_spec.rb
 - tconsole.gemspec
-- test/test_helper.rb
-- test/unit/config_test.rb
-- test/unit/sample_config
-- test/unit/util_test.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -100,7 +118,8 @@ signing_key:
 specification_version: 3
 summary: tconsole is a helpful console for running Rails tests
 test_files:
-- test/test_helper.rb
-- test/unit/config_test.rb
-- test/unit/sample_config
-- test/unit/util_test.rb
+- spec/config_spec.rb
+- spec/runner_spec.rb
+- spec/sample_config
+- spec/spec_helper.rb
+- spec/util_spec.rb

data/lib/tconsole/pipe_server.rb

@@ -1,47 +0,0 @@
-module TConsole
-  class PipeServer
-
-    def initialize
-      @callee = []
-      @caller = []
-      @callee[0], @caller[1] = IO.pipe
-      @caller[0], @callee[1] = IO.pipe
-
-      @me = nil
-    end
-
-    # Identifies the current process as the callee process
-    def callee!
-      @me = @callee
-
-      @caller.each do |io|
-        io.close
-      end
-    end
-
-    # Identifies the current process as the caller process
-    def caller!
-      @me = @caller
-
-      @callee.each do |io|
-        io.close
-      end
-    end
-
-    # Writes a message to the appropriate pipe. The message can be
-    # anything that will Marshal cleanly
-    def write(message)
-      encoded_message = [Marshal.dump(message)].pack("m0")
-      @me[1].puts(encoded_message)
-    end
-
-    # Reads a message from the appropriate pipe and unmarshalls it
-    def read
-      raw_message = @me[0].gets
-
-      return nil if raw_message.nil?
-
-      Marshal.load(raw_message.unpack("m")[0])
-    end
-  end
-end

data/test/unit/config_test.rb

@@ -1,91 +0,0 @@
-require 'test_helper'
-
-module TConsole
-  class ConfigTest < MiniTest::Unit::TestCase
-
-    a "Config" do
-      before do
-        @config = TConsole::Config.new([])
-      end
-
-      it "should have appropriate defaults" do
-        assert_equal false, @config.trace_execution
-        assert_equal "./test", @config.test_dir
-        assert_equal ["./test", "./lib"], @config.include_paths
-        assert_equal [], @config.preload_paths
-        assert_equal false, @config.fail_fast
-        assert_equal({ "all" => ["./test/**/*_test.rb"] }, @config.file_sets)
-      end
-
-      it "should have a validation error if the configured test directory doesn't exist" do
-        @config.test_dir = "./monkey_business"
-
-        errors = @config.validation_errors
-        refute_nil errors
-        assert_equal "Couldn't find test directory `./monkey_business`. Exiting.", errors[0]
-      end
-
-      it "should have a validation error if the configuration doesn't include an all file set" do
-        @config.file_sets = {}
-
-        errors = @config.validation_errors
-        refute_nil errors
-        assert_equal "No `all` file set is defined in your configuration. Exiting.", errors[0]
-      end
-    end
-
-    a "Config with command line arguments" do
-      it "should set up tracing correctly" do
-        @config = Config.new(Shellwords.shellwords("--trace"))
-
-        assert @config.trace_execution
-      end
-
-      it "should set up only running the passed command and exiting" do
-        @config = Config.new(Shellwords.shellwords("--once all"))
-
-        assert @config.once
-      end
-
-      it "should set all remaining unparsed text to be the first command to run" do
-        @config = Config.new(Shellwords.shellwords("--trace set fast on"))
-
-        assert_equal "set fast on", @config.run_command
-      end
-    end
-
-    the "Config class" do
-      before do
-        TConsole::Config.clear_loaded_configs
-      end
-
-      it "should save the proc passed to run when it's called" do
-        TConsole::Config.run do |config|
-          config.test_dir = "./awesome_sauce"
-        end
-
-        assert_equal 1, TConsole::Config.instance_variable_get(:@loaded_configs).length
-      end
-
-      it "should apply the loaded configs from first to last when configure is called" do
-        TConsole::Config.run do |config|
-          config.test_dir = "./awesome_sauce"
-        end
-
-        TConsole::Config.run do |config|
-          config.test_dir = "./awesomer_sauce"
-        end
-
-        config = TConsole::Config.configure
-
-        assert_equal "./awesomer_sauce", config.test_dir
-      end
-
-      it "should load a config file when load_config is called" do
-        TConsole::Config.load_config(File.join(File.dirname(__FILE__), "sample_config"))
-
-        assert_equal 1, TConsole::Config.instance_variable_get(:@loaded_configs).length
-      end
-    end
-  end
-end

data/test/unit/util_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-module TConsole
-  class ConfigTest < MiniTest::Unit::TestCase
-    a "Backtrace" do
-      before do
-        @non_tconsole_path = "/Users/alan/Projects/commondream/tconsole-test/test/functional/posts_controller_test.rb:16:in `block in <class:PostsControllerTest>'"
-        @tconsole_path = "#{File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))}/posts_controller_test.rb:16:in `block in <class:PostsControllerTest>'"
-
-        @backtrace = [
-          @non_tconsole_path,
-          @tconsole_path
-        ]
-
-        @filtered_backtrace = Util.filter_backtrace(@backtrace)
-      end
-
-      it "should remove the tconsole path" do
-        assert_equal 1, @filtered_backtrace.length
-        assert !@filtered_backtrace.include?(@tconsole_path), "Should filter backtrace item under tconsole"
-      end
-
-      it "shouldn't remove the non-tconsole path" do
-        assert @filtered_backtrace.include?(@non_tconsole_path), "Should not filter backtrace item outside of tconsole"
-      end
-
-    end
-  end
-end