assert 2.19.2 → 2.19.3

data/lib/assert/result.rb

@@ -5,39 +5,44 @@ require "assert/file_line"
 module Assert; end
 
 module Assert::Result
-  class Base          ; end
-  class Pass   < Base ; end
-  class Ignore < Base ; end
-  class Fail   < Base ; end
-  class Error  < Base ; end
-  class Skip   < Base ; end
+  class Base; end
+  class Pass   < Base; end
+  class Ignore < Base; end
+  class Fail   < Base; end
+  class Error  < Base; end
+  class Skip   < Base; end
 
   def self.types
-    @types ||= Hash.new{ |h, k| Base }.tap do |hash|
+    @types ||= Hash.new{ |_h, _k| Base }.tap{ |hash|
       hash[:pass]   = Pass
       hash[:fail]   = Fail
       hash[:ignore] = Ignore
       hash[:skip]   = Skip
       hash[:error]  = Error
-    end.freeze
+    }.freeze
   end
 
   def self.new(data = nil)
     data ||= {}
-    self.types[data[:type]].new(data)
+    types[data[:type]].new(data)
   end
 
   class Base
-    def self.type; :unknown; end
-    def self.name; "";       end
+    def self.type
+      :unknown
+    end
+
+    def self.name
+      ""
+    end
 
     def self.for_test(test, message, bt)
-      self.new({
-        :test_name      => test.name,
-        :test_file_line => test.file_line,
-        :message        => message,
-        :output         => test.output,
-        :backtrace      => Backtrace.new(bt)
+      new({
+        test_name: test.name,
+        test_file_line: test.file_line,
+        message: message,
+        output: test.output,
+        backtrace: Backtrace.new(bt),
       })
     end
 
@@ -59,14 +64,20 @@ module Assert::Result
     end
 
     def test_file_line
-      @test_file_line ||= (@build_data[:test_file_line] || Assert::FileLine.parse(""))
+      @test_file_line ||=
+        (@build_data[:test_file_line] || Assert::FileLine.parse(""))
     end
 
-    def test_file_name; self.test_file_line.file;      end
-    def test_line_num;  self.test_file_line.line.to_i; end
+    def test_file_name
+      test_file_line.file
+    end
+
+    def test_line_num
+      test_file_line.line.to_i
+    end
 
     def test_id
-      self.test_file_line.to_s
+      test_file_line.to_s
     end
 
     def message
@@ -108,32 +119,38 @@ module Assert::Result
     end
 
     def src_line
-      @src_line ||= first_filtered_bt_line(self.backtrace)
+      @src_line ||= first_filtered_bt_line(backtrace)
     end
 
     def file_line
-      @file_line ||= Assert::FileLine.parse(self.src_line)
+      @file_line ||= Assert::FileLine.parse(src_line)
     end
 
-    def file_name; self.file_line.file;      end
-    def line_num;  self.file_line.line.to_i; end
+    def file_name
+      file_line.file
+    end
+
+    def line_num
+      file_line.line.to_i
+    end
 
     Assert::Result.types.keys.each do |type|
       define_method("#{type}?"){ self.type == type }
     end
 
-    def to_sym; self.type; end
+    def to_sym
+      type
+    end
 
     def to_s
-      [ "#{self.name.upcase}: #{self.test_name}",
-        self.message,
-        self.trace
-      ].reject(&:empty?).join("\n")
+      ["#{name.upcase}: #{test_name}", message, trace]
+        .reject(&:empty?)
+        .join("\n")
     end
 
-    def ==(other_result)
-      if other_result.is_a?(self.class)
-        self.type == other_result.type && self.message == other_result.message
+    def ==(other)
+      if other.is_a?(self.class)
+        type == other.type && message == other.message
       else
         super
       end
@@ -141,9 +158,9 @@ module Assert::Result
 
     def inspect
       "#<#{self.class}:#{"0x0%x" % (object_id << 1)} "\
-      "@message=#{self.message.inspect} "\
-      "@file_line=#{self.file_line.to_s.inspect} "\
-      "@test_file_line=#{self.test_file_line.to_s.inspect}>"
+      "@message=#{message.inspect} "\
+      "@file_line=#{file_line.to_s.inspect} "\
+      "@test_file_line=#{test_file_line.to_s.inspect}>"
     end
 
     private
@@ -153,10 +170,10 @@ module Assert::Result
     # filtered line of the backtrace).  This is overridden for error results
     # as they always show their full backtrace.
     def build_trace
-      if self.with_bt_set?
-        Backtrace.to_s(@with_bt+[first_filtered_bt_line(self.backtrace)])
+      if with_bt_set?
+        Backtrace.to_s(@with_bt + [first_filtered_bt_line(backtrace)])
       else
-        self.src_line
+        src_line
       end
     end
 
@@ -169,13 +186,23 @@ module Assert::Result
   end
 
   class Pass < Base
-    def self.type; :pass;  end
-    def self.name; "Pass"; end
+    def self.type
+      :pass
+    end
+
+    def self.name
+      "Pass"
+    end
   end
 
   class Ignore < Base
-    def self.type; :ignore;  end
-    def self.name; "Ignore"; end
+    def self.type
+      :ignore
+    end
+
+    def self.name
+      "Ignore"
+    end
   end
 
   class HaltingTestResultError < RuntimeError
@@ -186,17 +213,26 @@ module Assert::Result
   TestFailure = Class.new(HaltingTestResultError)
 
   class Fail < Base
-    def self.type; :fail;  end
-    def self.name; "Fail"; end
+    def self.type
+      :fail
+    end
+
+    def self.name
+      "Fail"
+    end
 
-    # fail results can be generated manually or by raising Assert::Result::TestFailure
+    # fail results can be generated manually or by raising
+    # Assert::Result::TestFailure
     def self.for_test(test, msg_or_err, bt = nil)
-      if msg_or_err.kind_of?(TestFailure)
+      if msg_or_err.is_a?(TestFailure)
         super(test, msg_or_err.message, msg_or_err.backtrace).tap do |result|
           result.set_with_bt(msg_or_err.assert_with_bt)
         end
-      elsif msg_or_err.kind_of?(Exception)
-        raise ArgumentError, "generate fail results by raising Assert::Result::TestFailure"
+      elsif msg_or_err.is_a?(Exception)
+        raise(
+          ArgumentError,
+          "generate fail results by raising Assert::Result::TestFailure",
+        )
       else
         super(test, msg_or_err, bt)
       end
@@ -207,17 +243,25 @@ module Assert::Result
   TestSkipped = Class.new(HaltingTestResultError)
 
   class Skip < Base
-    def self.type; :skip;  end
-    def self.name; "Skip"; end
+    def self.type
+      :skip
+    end
+
+    def self.name
+      "Skip"
+    end
 
     # skip results are generated by raising Assert::Result::TestSkipped
     def self.for_test(test, msg_or_err, bt = nil)
-      if msg_or_err.kind_of?(TestSkipped)
+      if msg_or_err.is_a?(TestSkipped)
         super(test, msg_or_err.message, msg_or_err.backtrace).tap do |result|
           result.set_with_bt(msg_or_err.assert_with_bt)
         end
-      elsif msg_or_err.kind_of?(Exception)
-        raise ArgumentError, "generate skip results by raising Assert::Result::TestSkipped"
+      elsif msg_or_err.is_a?(Exception)
+        raise(
+          ArgumentError,
+          "generate skip results by raising Assert::Result::TestSkipped",
+        )
       else
         super(test, msg_or_err, bt)
       end
@@ -225,12 +269,17 @@ module Assert::Result
   end
 
   class Error < Base
-    def self.type; :error;  end
-    def self.name; "Error"; end
+    def self.type
+      :error
+    end
+
+    def self.name
+      "Error"
+    end
 
     # error results are generated by raising exceptions in tests
     def self.for_test(test, err)
-      if err.kind_of?(Exception)
+      if err.is_a?(Exception)
         super(test, "#{err.message} (#{err.class.name})", err.backtrace)
       else
         raise ArgumentError, "generate error results by raising an exception"
@@ -246,10 +295,10 @@ module Assert::Result
   end
 
   class Backtrace < ::Array
-    DELIM = "\n".freeze
+    DELIM = "\n"
 
     def self.parse(bt)
-      self.new(bt.to_s.split(DELIM))
+      new(bt.to_s.split(DELIM))
     end
 
     def self.to_s(bt_array)
@@ -261,7 +310,7 @@ module Assert::Result
     end
 
     def filtered
-      self.class.new(self.reject { |line| filter_out?(line.to_s) })
+      self.class.new(reject{ |line| filter_out?(line.to_s) })
     end
 
     protected
@@ -271,8 +320,8 @@ module Assert::Result
       # "./lib" in project dir, or "/usr/local/blahblah" if installed
       assert_lib_path    = File.expand_path("../..", __FILE__)
       assert_macros_path = File.join(assert_lib_path, "assert/macros")
-      assert_bin_regex = /bin\/assert\:/
-      ( line.rindex(assert_lib_path, 0) &&
+      assert_bin_regex = %r{bin/assert\:}
+      (line.rindex(assert_lib_path, 0) &&
         !line.rindex(assert_macros_path, 0)
       ) ||
       line =~ assert_bin_regex

data/lib/assert/runner.rb

@@ -14,21 +14,21 @@ module Assert
       @config = config
     end
 
-    def runner; self; end
+    def runner
+      self
+    end
 
     def run
-      self.on_start
-      self.suite.on_start
-      self.view.on_start
-
-      if self.single_test?
-        self.view.print "Running test: #{self.single_test_file_line}"
-      elsif self.tests_to_run?
-        self.view.print "Running tests in random order"
-      end
-      if self.tests_to_run?
-        self.view.puts ", seeded with \"#{self.runner_seed}\""
+      on_start
+      suite.on_start
+      view.on_start
+
+      if single_test?
+        view.print "Running test: #{single_test_file_line}"
+      elsif tests_to_run?
+        view.print "Running tests in random order"
       end
+      view.puts ", seeded with \"#{runner_seed}\"" if tests_to_run?
 
       @current_running_test = nil
 
@@ -36,46 +36,46 @@ module Assert
       # (Ctrl+T on Macs), process it
       if Signal.list.keys.include?("INFO")
         Signal.trap("INFO") do
-          self.on_info(@current_running_test)
-          self.suite.on_info(@current_running_test)
-          self.view.on_info(@current_running_test)
+          on_info(@current_running_test)
+          suite.on_info(@current_running_test)
+          view.on_info(@current_running_test)
         end
       end
 
       begin
-        self.suite.start_time = Time.now
-        self.suite.setups.each(&:call)
-        tests_to_run.tap{ self.suite.clear_tests_to_run }.delete_if do |test|
+        suite.start_time = Time.now
+        suite.setups.each(&:call)
+        tests_to_run.tap{ suite.clear_tests_to_run }.delete_if do |test|
           @current_running_test = test
 
-          self.before_test(test)
-          self.suite.before_test(test)
-          self.view.before_test(test)
+          before_test(test)
+          suite.before_test(test)
+          view.before_test(test)
           test.run do |result|
-            self.on_result(result)
-            self.suite.on_result(result)
-            self.view.on_result(result)
+            on_result(result)
+            suite.on_result(result)
+            view.on_result(result)
           end
-          self.after_test(test)
-          self.suite.after_test(test)
-          self.view.after_test(test)
+          after_test(test)
+          suite.after_test(test)
+          view.after_test(test)
 
           # always delete `test` from `tests_to_run` since it has been run
           true
         end
-        self.suite.teardowns.each(&:call)
-        self.suite.end_time = Time.now
-      rescue Interrupt => err
-        self.on_interrupt(err)
-        self.suite.on_interrupt(err)
-        self.view.on_interrupt(err)
-        raise(err)
+        suite.teardowns.each(&:call)
+        suite.end_time = Time.now
+      rescue Interrupt => ex
+        on_interrupt(ex)
+        suite.on_interrupt(ex)
+        view.on_interrupt(ex)
+        raise(ex)
       end
 
-      (self.fail_result_count + self.error_result_count).tap do
-        self.view.on_finish
-        self.suite.on_finish
-        self.on_finish
+      (fail_result_count + error_result_count).tap do
+        view.on_finish
+        suite.on_finish
+        on_finish
       end
     end
 
@@ -84,24 +84,41 @@ module Assert
     # define callback handlers to do special behavior during the test run. These
     # will be called by the test runner
 
-    def before_load(test_files); end
-    def after_load;              end
-    def on_start;                end
-    def before_test(test);       end
-    def on_result(result);       end
-    def after_test(test);        end
-    def on_finish;               end
-    def on_info(test);           end
-    def on_interrupt(err);       end
+    def before_load(test_files)
+    end
+
+    def after_load
+    end
+
+    def on_start
+    end
+
+    def before_test(test)
+    end
+
+    def on_result(result)
+    end
+
+    def after_test(test)
+    end
+
+    def on_finish
+    end
+
+    def on_info(test)
+    end
+
+    def on_interrupt(err)
+    end
 
     private
 
     def tests_to_run
-      srand self.runner_seed
-      if self.single_test?
-        [self.suite.find_test_to_run(self.single_test_file_line)].compact
+      srand runner_seed
+      if single_test?
+        [suite.find_test_to_run(single_test_file_line)].compact
       else
-        self.suite.sorted_tests_to_run{ rand self.tests_to_run_count }
+        suite.sorted_tests_to_run{ rand tests_to_run_count }
       end
     end
   end