tconsole-rails4 2.2.0

data/lib/tconsole/minitest_server.rb

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+module TConsole
+  class MinitestServer < Server
+
+    # 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
+        reporter.info(message)
+        reporter.info
+
+        paths = []
+        globs.each do |glob|
+          paths.concat(Dir.glob(glob))
+        end
+
+        if paths.length == 0
+          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|
+            reporter.trace("Requested path `#{path}` doesn't exist.") unless File.exist?(path)
+            require File.expand_path(path)
+          end
+
+          reporter.trace("Running before_test_run callback")
+          config.before_test_run!
+          reporter.trace("Completed before_test_run callback")
+
+          result = nil
+          if defined?(::Minitest)
+            reporter.trace("Detected minitest.")
+            require File.join(File.dirname(__FILE__), "minitest_handler")
+            require File.join(File.dirname(__FILE__), "minitest_reporter")
+
+            reporter.trace("Running tests.")
+            runner = MiniTestHandler.new(config)
+
+            # TODO надо починить Ctrl+C
+            # Handle trapping interrupts
+            trap("SIGINT") do
+              reporter.warn
+              reporter.warn("Trapped interrupt. Halting tests.")
+
+              runner.interrupted = true
+            end
+
+
+            result, res_reporter = runner.match_and_run(match_patterns, config)
+
+            res_reporter.report
+            # Make sure minitest doesn't run automatically
+            MiniTestHandler.patch_minitest
+
+            reporter.trace("Finished running tests.")
+
+            if runner.interrupted
+              reporter.error("Test run was interrupted.")
+            end
+
+          elsif defined?(::Test::Unit)
+            reporter.error("Sorry, but #{config.app} doesn't support Test::Unit")
+          end
+
+          result
+        end
+
+        if self.last_result == nil
+          # Just in case anything crazy goes down with marshalling
+          self.last_result = TConsole::TestResult.new
+        end
+
+        config.cache_test_ids(self.last_result)
+
+        true
+      end
+
+      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
+    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)
+    end
+
+    # Runs a file set out of the config
+    def run_file_set(set)
+      run_tests(config.file_sets[set], nil)
+    end
+
+    def run_failed
+      if last_result.failures.empty?
+        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
+  end
+end

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 that you may want to change at runtime. At present, the following"
+      puts "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 #{config.app} (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/rspec_server.rb

@@ -0,0 +1,108 @@
+module TConsole
+  class RSpecServer < Server
+
+    # 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
+        reporter.info(message)
+        reporter.info
+
+        paths = []
+        globs.each do |glob|
+          paths.concat(Dir.glob(glob))
+        end
+
+        if paths.length == 0
+          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
+
+          # Make sure rspec is loaded up
+          require 'rspec'
+          
+          paths.each do |path|
+            reporter.trace("Requested path `#{path}` doesn't exist.") unless File.exist?(path)
+            require File.expand_path(path)
+          end
+
+          reporter.trace("Running before_test_run callback")
+          config.before_test_run!
+          reporter.trace("Completed before_test_run callback")
+
+          result = nil
+          if defined?(::RSpec)
+            reporter.trace("Detected rspec.")
+            
+            reporter.trace("Running tests.")
+
+            # Handle trapping interrupts
+            trap("SIGINT") do
+              reporter.warn
+              reporter.warn("Trapped interrupt. Halting tests.")
+            end
+            
+            # Actually run the tests!
+            configuration = RSpec::configuration
+            world = RSpec::world
+            options = RSpec::Core::ConfigurationOptions.new([])
+            options.parse_options
+            
+            configuration.error_stream = STDERR
+            configuration.output_stream = STDOUT
+            
+            options.configure(configuration)
+            
+            configuration.files_to_run = paths
+            
+            configuration.reporter.report(world.example_count, configuration.randomize? ? configuration.seed : nil) do |reporter|
+                begin
+                    configuration.run_hook(:before, :suite)
+                    world.example_groups.ordered.map {|g| g.run(reporter)}.all? ? 0 : configuration.failure_exit_code
+                ensure
+                    configuration.run_hook(:after, :suite)
+                end    
+            end
+            
+            # Patch RSpec to disable autorun
+            ::RSpec::Core::Runner.class_eval do
+              def self.run(args = [], err=$stderr, out=$stdout)
+                # do nothing
+              end
+            end
+
+            reporter.trace("Finished running tests.")
+          end
+
+          nil
+        end
+
+        if self.last_result == nil
+          # Just in case anything crazy goes down with marshalling
+          self.last_result = TConsole::TestResult.new
+        end
+
+        config.cache_test_ids(self.last_result)
+
+        true
+      end
+
+      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
+
+    # Runs all tests against the match patterns given
+    def run_all_tests(match_patterns = nil)
+      run_tests(config.file_sets["all"], match_patterns)
+    end
+
+    # Runs a file set out of the config
+    def run_file_set(set)
+      run_tests(config.file_sets[set], nil)
+    end
+  end
+end

data/lib/tconsole/runner.rb

@@ -0,0 +1,139 @@
+module TConsole
+  class Runner
+
+    attr_accessor :mode, :config, :reporter, :console, :stty_save
+
+    # Public: Sets up the new runner's config.
+    def initialize(mode, argv = [])
+      self.mode = mode
+      
+      # try to load the default configs
+      Config.load_config(File.join(Dir.home, ".#{Config.app(mode)}"))
+      Config.load_config(File.join(Dir.pwd, ".#{Config.app(mode)}"))
+      self.config = Config.configure(mode, 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!
+      
+      if mode == :minitest
+        server = MinitestServer.new(config, reporter)
+      elsif mode == :rspec
+        server = RSpecServer.new(config, reporter)
+      else
+        reporter.error
+        reporter.error("The given test mode isn't supported.")
+        reporter.error
+        exit
+      end
+
+      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