tconsole 1.1.0pre10 → 1.1.0pre11

data/lib/tconsole/console.rb

@@ -2,6 +2,8 @@ module TConsole
   class Console
     KNOWN_COMMANDS = ["exit", "reload", "help", "info", "!failed", "!timings", "set"]
 
+    attr_accessor :pipe_server
+
     def initialize(config)
       @config = config
       read_history
@@ -15,22 +17,24 @@ module TConsole
       # Proc for helping us figure out autocompletes
       Readline.completion_proc = Proc.new do |str|
         known_commands = KNOWN_COMMANDS.grep(/^#{Regexp.escape(str)}/)
+        known_commands.concat(@config.file_sets.keys.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
+        known_elements = []
+        unless pipe_server.nil?
+          known_elements = send_message_to_server({:action => "autocomplete", :text => str})
         end
 
-        known_commands.concat(formatted_files).concat(@config.file_sets.keys)
+        known_commands.concat(known_elements)
       end
     end
 
     # Returns true if the app should keep running, false otherwise
-    def read_and_execute(pipe_server)
+    def read_and_execute
+      if pipe_server.nil?
+        puts "No connection to test environment. Exiting."
+        return false
+      end
+
       while line = Readline.readline("tconsole> ", false)
         line.strip!
         args = Shellwords.shellwords(line)
@@ -43,32 +47,33 @@ module TConsole
         if line == ""
           # do nothing
         elsif args[0] == "exit"
-          send_message_to_server({:action => "exit"}, pipe_server)
+          send_message_to_server({:action => "exit"})
+          self.pipe_server = nil
           return false
         elsif args[0] == "reload"
-          send_message_to_server({:action => "exit"}, pipe_server)
+          send_message_to_server({:action => "exit"})
           return true
         elsif args[0] == "help"
           print_help
         elsif args[0] == "!failed"
-          send_message_to_server({:action => "run_failed"}, pipe_server)
+          send_message_to_server({:action => "run_failed"})
         elsif args[0] == "!timings"
-          send_message_to_server({:action => "show_performance", :limit => args[1]}, pipe_server)
+          send_message_to_server({:action => "show_performance", :limit => args[1]})
         elsif args[0] == "info"
           send_message_to_server({:action => "run_info"}, pipe_server)
         elsif args[0] == "set"
-          send_message_to_server({:action => "set", :var => args[1], :value => args[2]}, pipe_server)
+          send_message_to_server({:action => "set", :var => args[1], :value => args[2]})
         elsif @config.file_sets.has_key?(args[0])
-          send_message_to_server({:action => "run_file_set", :set => args[0]}, pipe_server)
+          send_message_to_server({:action => "run_file_set", :set => args[0]})
         else
-          send_message_to_server({:action => "run_all_tests", :args => args}, pipe_server)
+          send_message_to_server({:action => "run_all_tests", :args => args})
         end
       end
 
       true
     end
 
-    def send_message_to_server(message, pipe_server)
+    def send_message_to_server(message)
       pipe_server.write(message)
       pipe_server.read
     end

data/lib/tconsole/minitest_handler.rb

@@ -18,6 +18,23 @@ module TConsole
       runner.results
     end
 
+    # Preloads our element cache for autocompletion. Assumes tests are already loaded
+    def self.preload_elements
+      patch_minitest
+
+      results = TConsole::TestResult.new
+
+      suites = ::MiniTest::Unit::TestCase.test_suites
+      suites.each do |suite|
+        suite.test_methods.map do |method|
+          id = results.add_element(suite, method)
+        end
+      end
+
+      results
+    end
+
+
     # We're basically breaking MiniTest autorun here, since we want to manually run our
     # tests and Rails relies on autorun
     #
@@ -147,7 +164,7 @@ module TConsole
 
           output = "#{result} #{method}"
 
-          print COLOR_MAP[result], " #{output}", ::Term::ANSIColor.reset, " #{time}s ",
+          print COLOR_MAP[result], " #{output}", ::Term::ANSIColor.reset, " #{"%0.6f" % time }s ",
             ::Term::ANSIColor.magenta, "#{id}", ::Term::ANSIColor.reset, "\n"
 
           if @failed_fast

data/lib/tconsole/server.rb

@@ -24,6 +24,8 @@ module TConsole
         run_file_set(message[:set])
       elsif action == "run_all_tests"
         run_all_tests(message[:args])
+      elsif action == "autocomplete"
+        autocomplete(message[:text])
       elsif action == "exit"
         exit(0)
       end
@@ -61,24 +63,55 @@ module TConsole
 
           return false
         end
+
+        preload_test_ids
       end
 
-      puts "Environment loaded in #{time}s."
+      puts "Environment loaded in #{"%0.6f" % time}s."
       puts
 
       result
     end
 
+    # Returns an array of possible completions based on the available element data
+    def autocomplete(text)
+      config.cached_elements.keys.grep(/^#{Regexp.escape(text)}/)
+    end
+
+    # Runs the given code in a block and returns the result of the code in the block.
+    # The block's result needs to be marshallable. Otherwise, nil is returned.
+    def run_in_fork(&block)
+     # Pipe for communicating with child so we can get its results back
+      read, write = IO.pipe
+
+      pid = fork do
+        read.close
+
+        result = block.call
+
+        write.puts([Marshal.dump(result)].pack("m0"))
+      end
+
+      write.close
+      response = read.read
+      read.close
+      Process.wait(pid)
+
+      begin
+        config.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)
+        nil
+      end
+    end
+
     # 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
-
-        fork do
-          read.close
-
+        self.last_result = run_in_fork do
           puts message
           puts
 
@@ -96,6 +129,7 @@ module TConsole
           config.before_test_run!
           config.trace("Completed before_test_run callback")
 
+          result = nil
           if defined?(::MiniTest)
             config.trace("Detected minitest.")
             require File.join(File.dirname(__FILE__), "minitest_handler")
@@ -103,50 +137,47 @@ module TConsole
             config.trace("Running tests.")
             result = MiniTestHandler.run(match_patterns, config)
             config.trace("Finished running tests.")
-
-            config.trace("Writing test results back to server.")
-            write.puts([Marshal.dump(result)].pack("m"))
-            config.trace("Finished writing test results to server.")
-
           elsif defined?(::Test::Unit)
             puts "Sorry, but tconsole doesn't support Test::Unit yet"
-            return
           elsif defined?(::RSpec)
             puts "Sorry, but tconsole doesn't support RSpec yet"
-            return
           end
-        end
 
-        write.close
-        response = read.read
-        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}")
-          config.trace("==== Backtrace ====")
-          config.trace(e.backtrace.join("\n"))
-          config.trace("==== End Backtrace ====")
-
-          puts "ERROR: Unable to process test results."
-          puts
+          result
+        end
 
+        if self.last_result == nil
           # Just in case anything crazy goes down with marshalling
           self.last_result = TConsole::TestResult.new
         end
 
-        read.close
+        config.cache_test_ids(self.last_result)
 
-        Process.waitall
+        true
       end
 
       puts
-      puts "Test time (including load): #{time}s"
+      puts "Test time (including load): #{"%0.6f" % time}s"
       puts
     end
 
+    # Preloads our autocomplete cache
+    def preload_test_ids
+      result = run_in_fork do
+        paths = []
+        config.file_sets["all"].each do |glob|
+          paths.concat(Dir.glob(glob))
+        end
+
+        paths.each { |path| require File.expand_path(path) }
+
+        require File.join(File.dirname(__FILE__), "minitest_handler")
+        MiniTestHandler.preload_elements
+      end
+
+      config.cache_test_ids(result) unless result.nil?
+    end
+
     # Runs all tests against the match patterns given
     def run_all_tests(match_patterns = nil)
       run_tests(config.file_sets["all"], match_patterns)
@@ -188,7 +219,7 @@ module TConsole
         puts "No timing data available. Be sure you've run some tests."
       else
         sorted_timings.reverse[0, limit].each do |timing|
-          puts "#{timing[:time]}s #{timing[:suite]}##{timing[:method]}"
+          puts "#{"%0.6f" % timing[:time]}s #{timing[:suite]}##{timing[:method]}"
         end
       end
 

data/lib/tconsole/version.rb

@@ -1,3 +1,3 @@
 module TConsole
-  VERSION = "1.1.0pre10"
+  VERSION = "1.1.0pre11"
 end

data/lib/tconsole.rb

@@ -70,7 +70,9 @@ module TConsole
         end
         config.trace("Environment loaded successfully.")
 
-        running = console.read_and_execute(pipe_server)
+        console.pipe_server = pipe_server
+        running = console.read_and_execute
+        console.pipe_server = nil
 
         Process.waitall
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tconsole
 version: !ruby/object:Gem::Version
-  version: 1.1.0pre10
+  version: 1.1.0pre11
   prerelease: 5
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: term-ansicolor
-  requirement: &70325750739560 !ruby/object:Gem::Requirement
+  requirement: &70281579497440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 1.0.7
   type: :runtime
   prerelease: false
-  version_requirements: *70325750739560
+  version_requirements: *70281579497440
 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