tconsole-rails4 2.2.0

data/lib/tconsole/console.rb

@@ -0,0 +1,150 @@
+module TConsole
+  class Console
+    KNOWN_COMMANDS = ["exit", "reload", "help", "info", "!failed", "!timings", "set"]
+
+    attr_accessor :config, :reporter
+
+    def initialize(config, reporter)
+      self.config = config
+      self.reporter = reporter
+      read_history
+    end
+
+    def define_autocomplete(pipe_server)
+      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)}/)
+        known_commands.concat(@config.file_sets.keys.grep(/^#{Regexp.escape(str)}/))
+
+        known_elements = []
+        unless pipe_server.nil?
+          known_elements = send_message(pipe_server, :autocomplete, str)
+        end
+
+        known_commands.concat(known_elements)
+      end
+    end
+
+    # Returns true if the app should keep running, false otherwise
+    def read_and_execute(pipe_server)
+      prompt = "#{config.app}> "
+
+      trap("SIGTSTP", "SYSTEM_DEFAULT")
+      trap("SIGCONT") do
+        print prompt
+      end
+
+      # Run any commands that have been passed
+      result = process_command(pipe_server, @config.run_command)
+      @config.run_command = ""
+      if result == :exit || @config.once
+        return false
+      elsif result == :reload
+        return true
+      end
+
+      define_autocomplete(pipe_server)
+
+      # The command entry loop
+      while command = Readline.readline(prompt, false)
+        command.strip!
+        result = process_command(pipe_server, command)
+
+        if result == :exit
+          return false
+        elsif result == :reload
+          return true
+        end
+      end
+
+      send_message(:stop)
+      false
+    end
+
+    # 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(pipe_server, command)
+      args = Shellwords.shellwords(command)
+
+      # save the command unless we're exiting or repeating the last command
+      unless args[0] == "exit" || (Readline::HISTORY.length > 0 && Readline::HISTORY[Readline::HISTORY.length - 1] == command)
+        Readline::HISTORY << command
+      end
+
+      if command == ""
+        # do nothing
+      elsif args[0] == "exit"
+        send_message(pipe_server, :stop)
+        return :exit
+      elsif args[0] == "reload"
+        send_message(pipe_server, :stop)
+        return :reload
+      elsif args[0] == "help"
+        reporter.help_message
+      elsif args[0] == "!failed"
+        send_message(pipe_server, :run_failed)
+      elsif args[0] == "!timings"
+        send_message(pipe_server, :show_performance, args[1])
+      elsif args[0] == "info"
+        send_message(pipe_server, :run_info)
+      elsif args[0] == "set"
+        send_message(pipe_server, :set, args[1], args[2])
+      elsif args[0].start_with?(".")
+        shell_command(command[1, command.length - 1])
+      elsif @config.file_sets.has_key?(args[0])
+        send_message(pipe_server, :run_file_set, args[0])
+      else
+        send_message(pipe_server, :run_all_tests, args)
+      end
+
+      nil
+    end
+
+    def send_message(pipe_server, message, *args)
+      pipe_server.write({:action => message.to_sym, :args => args})
+      pipe_server.read
+    end
+
+    # Internal: Runs a shell command on the console and outputs the results.
+    def shell_command(command)
+      system(command)
+
+      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
+      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

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+require 'minitest'
+module TConsole
+  class MiniTestHandler
+    attr_accessor :interrupted
+
+    def initialize(config)
+      @reporter = ::TConsole::MinitestReporter.new
+      @reporter.tc_results.suite_counts = config.cached_suite_counts
+      @reporter.tc_results.elements = config.cached_elements
+      @interrupted = false
+    end
+
+    def match_and_run(match_patterns, config)
+
+      suites = Minitest::Runnable.runnables
+
+      @reporter.ready
+      suites.each do |suite|
+        suite_id = @reporter.tc_results.elements[suite.to_s]
+
+        suite_printed = false
+        suite.methods_matching(/^test/).map do |method|
+          if @interrupted
+            return @reporter.tc_results
+          end
+
+          id = @reporter.tc_results.add_element(suite, method)
+
+          unless match_patterns.nil?
+            match = match_patterns.find do |pattern|
+              pattern == suite.to_s ||
+                pattern == "#{suite.to_s}##{method.to_s}" ||
+                pattern == suite_id.to_s ||
+                pattern == id
+            end
+          end
+
+          if !suite_printed && (match_patterns.nil? || match_patterns.empty? || !match.nil?)
+            print(::Term::ANSIColor.cyan, suite, ::Term::ANSIColor.reset,
+                  ::Term::ANSIColor.magenta, " #{suite_id} \n")
+            suite_printed = true
+          end
+
+          if match_patterns.nil? || match_patterns.empty? || !match.nil?
+            @reporter.current_element_id = id
+            # TODO мб понтово свой метод run в минитест захуярить,
+            # который список suites принимать будет
+            Minitest::Runnable.run_one_method(suite, method, @reporter)
+          end
+        end
+
+        if suite_printed
+          puts
+        end
+      end
+
+      [@reporter.tc_results, @reporter]
+    end
+
+    # Preloads our element cache for autocompletion. Assumes tests are already loaded
+    def self.preload_elements
+      patch_minitest
+      results = TConsole::TestResult.new
+      suites = Minitest::Runnable.runnables
+      suites.each do |suite|
+        suite.methods_matching(/^test/).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
+    # A big reason for the need for this is that we're trying to work in the Rake environment
+    # rather than rebuilding all of the code in Rake just to get test prep happening
+    # correctly.
+    def self.patch_minitest
+      Minitest.class_eval do
+        class << self
+          alias_method :old_run, :run
+          def run(args = [])
+          end
+        end
+      end
+    end
+  end
+end
+
+# Make sure that output is only colored when it should be
+Term::ANSIColor::coloring = STDOUT.isatty

data/lib/tconsole/minitest_reporter.rb

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+require 'minitest'
+require 'ansi/code'
+
+module TConsole
+  # Turn-like reporter that reads like a spec.
+  #
+  # Based upon
+  # https://github.com/kern/minitest-reporters/blob/master/lib%2Fminitest%2Freporters%2Fbase_reporter.rb and spec_reporter
+  class BaseReporter < Minitest::StatisticsReporter
+    attr_accessor :tests
+
+    def initialize(options={})
+      super($stdout, options)
+      self.tests = []
+    end
+
+    def add_defaults(defaults)
+      self.options = defaults.merge(options)
+    end
+
+    # called by our own before hooks
+    def before_test(test)
+      last_test = tests.last
+      if last_test.class != test.class
+        after_suite(last_test.class) if last_test
+        before_suite(test.class)
+      end
+    end
+
+    def record(test)
+      super
+      tests << test
+    end
+
+    # called by our own after hooks
+    def after_test(test)
+    end
+
+    def report
+      super
+      after_suite(tests.last.class)
+    end
+
+    protected
+
+    def after_suite(test)
+    end
+
+    def before_suite(test)
+    end
+
+    def result(test)
+      if test.error?
+        :error
+      elsif test.skipped?
+        :skip
+      elsif test.failure
+        :fail
+      else
+        :pass
+      end
+    end
+
+    def print_colored_status(test)
+      if test.passed?
+        print(green { pad_mark( result(test).to_s.upcase ) })
+      elsif test.skipped?
+        print(yellow { pad_mark( result(test).to_s.upcase ) })
+      else
+        print(red { pad_mark( result(test).to_s.upcase ) })
+      end
+    end
+
+    def total_time
+      super || Time.now - start_time
+    end
+
+    def total_count
+      options[:total_count]
+    end
+
+    def filter_backtrace(backtrace)
+      Minitest.filter_backtrace(backtrace)
+    end
+
+    def puts(*args)
+      io.puts(*args)
+    end
+
+    def print(*args)
+      io.print(*args)
+    end
+
+    def print_info(e, name=true)
+      e.message.each_line { |line| print_with_info_padding(line) }
+
+      trace = filter_backtrace(e.backtrace)
+      trace.each { |line| print_with_info_padding(line) }
+    end
+  end
+
+  module RelativePosition
+    TEST_PADDING = 2
+    TEST_SIZE = 63
+    MARK_SIZE = 5
+    INFO_PADDING = 8
+
+    private
+
+    def print_with_info_padding(line)
+      puts pad(line, INFO_PADDING)
+    end
+
+    def pad(str, size = INFO_PADDING)
+      ' ' * size + str
+    end
+
+    def pad_mark(str)
+      "%#{MARK_SIZE}s" % str
+    end
+
+    def pad_test(str)
+      pad("%-#{TEST_SIZE}s" % str, TEST_PADDING)
+    end
+  end
+
+  class MinitestReporter < BaseReporter
+    include ANSI::Code
+    include RelativePosition
+    attr_accessor :tc_results
+    attr_accessor :current_element_id
+
+    def initialize(*args)
+      @current_element_id = 0
+      @tc_results = TConsole::TestResult.new
+      super
+    end
+
+    def start # not used
+      #super
+    end
+
+    def ready
+      #super
+      if defined? Minitest.clock_time
+        self.start_time = Minitest.clock_time
+      else
+        self.start_time = Time.now
+      end
+    end
+
+    def report
+      super
+      puts('Finished in %.5fs' % total_time)
+      res_str = '%d tests, ' % [count]
+      res_str += '%d assertions, ' % assertions
+      passed = count - (failures + errors + skips)
+      res_str += green { '%d passed, ' } % passed
+      color = failures.zero? && errors.zero? ? :green : :red
+      res_str += send(color) { '%d failures, %d errors, ' } % [failures, errors]
+      res_str += yellow { '%d skips' } % skips
+      puts(res_str)
+      if failures == 0 && errors == 0
+        puts
+        puts(green { "All tests passed! You are good!" })
+      end
+      puts
+    end
+
+    def record(test)
+      super
+      # TODO хорошо бы избавиться от @current_element_id
+      str = "#{::Term::ANSIColor.magenta(@current_element_id)} #{colored_string(test.name, test)}"
+      print pad_test(str)
+      print_colored_status(test)
+      print(" (%.2fs)" % test.time)
+      print()
+      puts
+      if !test.skipped? && test.failure
+        @tc_results.failures << @current_element_id
+        print_info(test.failure)
+        puts
+      end
+    end
+
+    protected
+
+    def colored_string(str, test)
+      if test.passed?
+        ::Term::ANSIColor.green(str)
+      elsif test.skipped?
+        ::Term::ANSIColor.yellow(str)
+      else
+        ::Term::ANSIColor.red(str)
+      end
+    end
+
+    def before_suite(suite)
+      puts suite
+    end
+
+    def after_suite(suite)
+      puts
+    end
+  end
+end