tconsole 1.1.0pre9 → 1.1.0pre10

data/README.md

@@ -32,7 +32,7 @@ Installing tconsole
 
 Prereleases of tconsole come out pretty frequently. You can install the latest prerelease version with:
 
-	gem installt console --pre
+	gem install tconsole --pre
 
 How to use tconsole
 ------
@@ -45,7 +45,7 @@ In your shell of choice, cd into your Rails project's directory and then run `bu
 
 	>
 
-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:
+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...

data/lib/tconsole.rb

@@ -2,6 +2,7 @@ require "tconsole/version"
 require "tconsole/config"
 require "tconsole/console"
 require "tconsole/server"
+require "tconsole/pipe_server"
 require "tconsole/test_result"
 require "tconsole/util"
 
@@ -37,63 +38,40 @@ module TConsole
       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!
+
           begin
             server = Server.new(config)
 
-            drb_server = DRb.start_service("drbunix:/tmp/tconsole.#{Process.pid}", server)
-            DRb.thread.join
+            while message = pipe_server.read
+              config.trace("Server Received Message: #{message[:action]}")
+              pipe_server.write(server.handle(message))
+            end
+
           rescue Interrupt
             # do nothing here since the outer process will shut things down for us
           end
         end
 
-        wait_until = Time.now + 10
+        pipe_server.caller!
 
-        # Set up our client connection to the server
-        config.trace("Connecting to testing server.")
-        DRb.start_service
-        server = nil
-
-        loaded = false
-        until loaded || Time.now > wait_until
-          begin
-            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
-        end
-
-        unless loaded
-          puts
-          puts "Couldn't connect to the test environment. Exiting."
-          exit(1)
-        end
+        wait_until = Time.now + 10
 
-        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 ====")
+        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.")
 
-        running = console.read_and_execute(server) if running
+        running = console.read_and_execute(pipe_server)
 
-        server.stop
         Process.waitall
       end
 

data/lib/tconsole/console.rb

@@ -30,7 +30,7 @@ module TConsole
     end
 
     # Returns true if the app should keep running, false otherwise
-    def read_and_execute(server)
+    def read_and_execute(pipe_server)
       while line = Readline.readline("tconsole> ", false)
         line.strip!
         args = Shellwords.shellwords(line)
@@ -43,29 +43,36 @@ module TConsole
         if line == ""
           # do nothing
         elsif args[0] == "exit"
+          send_message_to_server({:action => "exit"}, pipe_server)
           return false
         elsif args[0] == "reload"
+          send_message_to_server({:action => "exit"}, pipe_server)
           return true
         elsif args[0] == "help"
           print_help
         elsif args[0] == "!failed"
-          server.run_failed
+          send_message_to_server({:action => "run_failed"}, pipe_server)
         elsif args[0] == "!timings"
-          server.show_performance(args[1])
+          send_message_to_server({:action => "show_performance", :limit => args[1]}, pipe_server)
         elsif args[0] == "info"
-          server.run_info
+          send_message_to_server({:action => "run_info"}, pipe_server)
         elsif args[0] == "set"
-          server.set(args[1], args[2])
+          send_message_to_server({:action => "set", :var => args[1], :value => args[2]}, pipe_server)
         elsif @config.file_sets.has_key?(args[0])
-          server.run_file_set(args[0])
+          send_message_to_server({:action => "run_file_set", :set => args[0]}, pipe_server)
         else
-          server.run_all_tests(args)
+          send_message_to_server({:action => "run_all_tests", :args => args}, pipe_server)
         end
       end
 
       true
     end
 
+    def send_message_to_server(message, pipe_server)
+      pipe_server.write(message)
+      pipe_server.read
+    end
+
     # Prints a list of available commands
     def print_help
       puts

data/lib/tconsole/minitest_handler.rb

@@ -113,10 +113,10 @@ module TConsole
         # 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
+            pattern == suite.to_s || pattern == "#{suite.to_s}##{method.to_s}" || pattern == suite_id.to_s || pattern == id
           end
 
-          skip = true unless match
+          skip = true unless !match.nil?
         end
 
         if skip
@@ -165,16 +165,16 @@ module TConsole
       e = case e
           when MiniTest::Skip then
             @skips += 1
-            results.skips += 1
+            results.skip_count += 1
             return "S" unless @verbose
             "Skipped:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
           when MiniTest::Assertion then
             @failures += 1
-            results.failures += 1
+            results.failure_count += 1
             "Failure:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
           else
             @errors += 1
-            results.errors += 1
+            results.error_count += 1
             bt = MiniTest::filter_backtrace(e.backtrace).join "\n    "
             "Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n    #{bt}\n"
           end

data/lib/tconsole/pipe_server.rb

@@ -0,0 +1,47 @@
+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/lib/tconsole/server.rb

@@ -7,13 +7,26 @@ 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
+    # Processes the message sent from the console
+    def handle(message)
+      action = message[:action]
+      if action == "load_environment"
+        load_environment
+      elsif action == "run_failed"
+        run_failed
+      elsif action == "show_performance"
+        show_performance(message[:limit])
+      elsif action == "run_info"
+        run_info
+      elsif action == "set"
+        set(message[:var], message[:value])
+      elsif action == "run_file_set"
+        run_file_set(message[:set])
+      elsif action == "run_all_tests"
+        run_all_tests(message[:args])
+      elsif action == "exit"
+        exit(0)
+      end
     end
 
     def load_environment
@@ -145,7 +158,12 @@ module TConsole
     end
 
     def run_failed
-      run_tests(config.file_sets["all"], last_result.failures)
+      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
+      else
+        run_tests(config.file_sets["all"], last_result.failures)
+      end
     end
 
     def run_info

data/lib/tconsole/test_result.rb

@@ -1,16 +1,16 @@
 module TConsole
   class TestResult
     # The number of failed tests in the last run
-    attr_accessor :failures
+    attr_accessor :failure_count
 
     # The number of errors that occurred in the last run
-    attr_accessor :errors
+    attr_accessor :error_count
 
     # The number of skipped tests
-    attr_accessor :skips
+    attr_accessor :skip_count
 
     # Details about the failures in the last run
-    attr_accessor :failure_details
+    attr_accessor :failures
 
     # The suites that we've run
     attr_accessor :suites
@@ -25,9 +25,9 @@ module TConsole
     attr_accessor :suite_counts
 
     def initialize
-      self.failures = 0
-      self.errors = 0
-      self.skips = 0
+      self.failure_count = 0
+      self.error_count = 0
+      self.skip_count = 0
       self.failures = []
       self.suites = {}
       self.timings = []

data/lib/tconsole/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tconsole
 version: !ruby/object:Gem::Version
-  version: 1.1.0pre9
+  version: 1.1.0pre10
   prerelease: 5
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-20 00:00:00.000000000 Z
+date: 2012-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: term-ansicolor
-  requirement: &70167646243500 !ruby/object:Gem::Requirement
+  requirement: &70325750739560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 1.0.7
   type: :runtime
   prerelease: false
-  version_requirements: *70167646243500
+  version_requirements: *70325750739560
 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,11 +39,11 @@ 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/pipe_server.rb
 - lib/tconsole/server.rb
 - lib/tconsole/test_result.rb
 - lib/tconsole/util.rb

data/drb_connection_test.rb

@@ -1,63 +0,0 @@
-#!/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