assert 2.19.2 → 2.19.3

data/lib/assert/stub.rb

@@ -27,9 +27,9 @@ module Assert
     orig_caller = caller_locations
     begin
       MuchStub.stub_send(*args, &block)
-    rescue MuchStub::NotStubbedError => err
-      err.set_backtrace(orig_caller.map(&:to_s))
-      raise err
+    rescue MuchStub::NotStubbedError => ex
+      ex.set_backtrace(orig_caller.map(&:to_s))
+      raise ex
     end
   end
 
@@ -80,7 +80,7 @@ module Assert
 
     # See MuchStub::CallSpy#inspect.
     def inspect
-      "#<Assert::StubCallSpy:#{"0x0%x" % (self.__id__ << 1)}>"
+      "#<Assert::StubCallSpy:#{"0x0%x" % (__id__ << 1)}>"
     end
   end
 end

data/lib/assert/suite.rb

@@ -27,21 +27,31 @@ module Assert
       @end_time   = @start_time
     end
 
-    def suite; self; end
+    def suite
+      self
+    end
 
     def setup(&block)
-      self.setups << (block || proc{})
+      setups << (block || proc{})
     end
     alias_method :startup, :setup
 
     def teardown(&block)
-      self.teardowns << (block || proc{})
+      teardowns << (block || proc{})
     end
     alias_method :shutdown, :teardown
 
-    def tests_to_run?;      @tests.size > 0; end
-    def tests_to_run_count; @tests.size;     end
-    def clear_tests_to_run; @tests.clear;    end
+    def tests_to_run?
+      @tests.any?
+    end
+
+    def tests_to_run_count
+      @tests.size
+    end
+
+    def clear_tests_to_run
+      @tests.clear
+    end
 
     def find_test_to_run(file_line)
       @tests.find{ |t| t.file_line == file_line }
@@ -51,32 +61,46 @@ module Assert
       @tests.sort.sort_by(&sort_by_proc)
     end
 
-    def test_count;          end
-    def result_count;        end
-    def pass_result_count;   end
-    def fail_result_count;   end
-    def error_result_count;  end
-    def skip_result_count;   end
-    def ignore_result_count; end
+    def test_count
+    end
+
+    def result_count
+    end
+
+    def pass_result_count
+    end
+
+    def fail_result_count
+    end
+
+    def error_result_count
+    end
+
+    def skip_result_count
+    end
+
+    def ignore_result_count
+    end
 
     def run_time
       @end_time - @start_time
     end
 
     def test_rate
-      get_rate(self.test_count, self.run_time)
+      get_rate(test_count, run_time)
     end
 
     def result_rate
-      get_rate(self.result_count, self.run_time)
+      get_rate(result_count, run_time)
     end
 
     # Callbacks
 
-    # define callback handlers to do special behavior during the test run.  These
-    # will be called by the test runner
+    # 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 before_load(test_files)
+    end
 
     # this is required to load tests into the suite, be sure to `super` if you
     # override this method
@@ -84,19 +108,34 @@ module Assert
       @tests << test
     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 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 inspect
       "#<#{self.class}:#{"0x0%x" % (object_id << 1)}"\
-      " test_count=#{self.test_count.inspect}"\
-      " result_count=#{self.result_count.inspect}>"
+      " test_count=#{test_count.inspect}"\
+      " result_count=#{result_count.inspect}>"
     end
   end
 end

data/lib/assert/test.rb

@@ -9,16 +9,16 @@ module Assert
     # Test is some code/method to run in the scope of a Context that may
     # produce results.
     def self.name_file_line_context_data(ci, name)
-      { :name      => ci.test_name(name),
-        :file_line => ci.called_from
+      { name: ci.test_name(name),
+        file_line: ci.called_from,
       }
     end
 
     def self.for_block(name, context_info, config, &block)
-      self.new(self.name_file_line_context_data(context_info, name).merge({
-        :context_info => context_info,
-        :config       => config,
-        :code         => block
+      new(name_file_line_context_data(context_info, name).merge({
+        context_info: context_info,
+        config: config,
+        code: block,
       }))
     end
 
@@ -31,8 +31,13 @@ module Assert
       @file_line ||= FileLine.parse((@build_data[:file_line] || "").to_s)
     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
 
     def name
       @name ||= (@build_data[:name] || "")
@@ -51,7 +56,7 @@ module Assert
     end
 
     def context_class
-      self.context_info.klass
+      context_info.klass
     end
 
     def config
@@ -64,22 +69,22 @@ module Assert
 
     def run(&result_callback)
       @result_callback = result_callback || proc{ |result| } # noop by default
-      scope = self.context_class.new(self, self.config, @result_callback)
+      scope = context_class.new(self, config, @result_callback)
       start_time = Time.now
       capture_output do
-        self.context_class.run_arounds(scope){ run_test(scope) }
+        context_class.run_arounds(scope){ run_test(scope) }
       end
       @result_callback = nil
       @run_time = Time.now - start_time
     end
 
-    def <=>(other_test)
-      self.name <=> other_test.name
+    def <=>(other)
+      name <=> other.name
     end
 
     def inspect
       attributes_string = ([:name, :context_info].collect do |attr|
-        "@#{attr}=#{self.send(attr).inspect}"
+        "@#{attr}=#{send(attr).inspect}"
       end).join(" ")
       "#<#{self.class}:#{"0x0%x" % (object_id << 1)} #{attributes_string}>"
     end
@@ -89,33 +94,33 @@ module Assert
     def run_test(scope)
       begin
         # run any assert style "setup do" setups
-        self.context_class.run_setups(scope)
+        context_class.run_setups(scope)
         # run any test/unit style "def setup" setups
         scope.setup if scope.respond_to?(:setup)
         # run the code block
-        scope.instance_eval(&(self.code || proc{}))
-      rescue Result::TestFailure => err
-        capture_result(Result::Fail, err)
-      rescue Result::TestSkipped => err
-        capture_result(Result::Skip, err)
-      rescue SignalException => err
-        raise(err)
-      rescue Exception => err
-        capture_result(Result::Error, err)
+        scope.instance_eval(&(code || proc{}))
+      rescue Result::TestFailure => ex
+        capture_result(Result::Fail, ex)
+      rescue Result::TestSkipped => ex
+        capture_result(Result::Skip, ex)
+      rescue SignalException => ex
+        raise(ex)
+      rescue => ex
+        capture_result(Result::Error, ex)
       ensure
         begin
           # run any assert style "teardown do" teardowns
-          self.context_class.run_teardowns(scope)
+          context_class.run_teardowns(scope)
           # run any test/unit style "def teardown" teardowns
           scope.teardown if scope.respond_to?(:teardown)
-        rescue Result::TestFailure => err
-          capture_result(Result::Fail, err)
-        rescue Result::TestSkipped => err
-          capture_result(Result::Skip, err)
-        rescue SignalException => err
-          raise(err)
-        rescue Exception => err
-          capture_result(Result::Error, err)
+        rescue Result::TestFailure => ex
+          capture_result(Result::Fail, ex)
+        rescue Result::TestSkipped => ex
+          capture_result(Result::Skip, ex)
+        rescue SignalException => ex
+          raise(ex)
+        rescue => ex
+          capture_result(Result::Error, ex)
         end
       end
     end
@@ -125,7 +130,7 @@ module Assert
     end
 
     def capture_output(&block)
-      if self.config.capture_output == true
+      if config.capture_output == true
         orig_stdout = $stdout.clone
         $stdout = capture_io
         block.call
@@ -136,7 +141,7 @@ module Assert
     end
 
     def capture_io
-      StringIO.new(self.output, "a+")
+      StringIO.new(output, "a+")
     end
   end
 end

data/lib/assert/utils.rb

@@ -12,18 +12,21 @@ module Assert
       out
     end
 
-    # show objects in a human-readable manner and make the output diff-able. This
-    # expands on the basic `show` util by escaping newlines and making object id
-    # hex-values generic.
+    # show objects in a human-readable manner and make the output diff-able.
+    # This expands on the basic `show` util by escaping newlines and making
+    # object id hex-values generic.
     def self.show_for_diff(obj, config)
-      show(obj, config).gsub(/\\n/, "\n").gsub(/:0x[a-fA-F0-9]{4,}/m, ":0xXXXXXX")
+      show(obj, config)
+        .gsub(/\\n/, "\n")
+        .gsub(/:0x[a-fA-F0-9]{4,}/m, ":0xXXXXXX")
     end
 
     # open a tempfile and yield it
     def self.tempfile(name, content)
       require "tempfile"
       Tempfile.open(name) do |tmpfile|
-        tmpfile.puts(content); tmpfile.flush
+        tmpfile.puts(content)
+        tmpfile.flush
         yield tmpfile if block_given?
       end
     end
@@ -34,7 +37,8 @@ module Assert
       Proc.new{ |obj| PP.pp(obj, +"", width || 79).strip }
     end
 
-    # Return true if if either show output has newlines or is bigger than 29 chars
+    # Return true if if either show output has newlines or is bigger than 29
+    # chars.
     def self.default_use_diff_proc
       Proc.new do |exp_show_output, act_show_output|
         exp_show_output.include?("\n") || exp_show_output.size > 29 ||
@@ -62,10 +66,15 @@ module Assert
     def self.git_changed_proc
       Proc.new do |config, test_paths|
         files = []
-        cmd = [
-          "git diff --no-ext-diff --name-only #{config.changed_ref}", # changed files
-          "git ls-files --others --exclude-standard"                  # added files
-        ].map{ |c| "#{c} -- #{test_paths.join(" ")}" }.join(" && ")
+        cmd =
+          [
+            # changed files
+            "git diff --no-ext-diff --name-only #{config.changed_ref}",
+            # added files
+            "git ls-files --others --exclude-standard",
+          ]
+            .map{ |c| "#{c} -- #{test_paths.join(" ")}" }
+            .join(" && ")
         Assert::CLI.bench("Load only changed files") do
           files = `#{cmd}`.split("\n")
         end

data/lib/assert/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Assert
-  VERSION = "2.19.2"
+  VERSION = "2.19.3"
 end

data/lib/assert/view.rb

@@ -16,16 +16,18 @@ module Assert
 
     def self.require_user_view(view_name)
       views_file = File.expand_path(
-        File.join("#{ENV["HOME"]}/.assert/views", view_name, "lib", view_name)
+        File.join("#{ENV["HOME"]}/.assert/views", view_name, "lib", view_name),
       )
 
-      if File.exists?(view_name) || File.exists?(view_name + ".rb")
+      if File.exist?(view_name) || File.exist?(view_name + ".rb")
         require view_name
-      elsif File.exists?(views_file + ".rb")
+      elsif File.exist?(views_file + ".rb")
         require views_file
       else
-        msg = "[WARN] Can't find or require #{view_name.inspect} view."
-        msg << " Did you install it in `~/.assert/views`?" if !view_name.match(/\A\//)
+        msg = +"[WARN] Can't find or require #{view_name.inspect} view."
+        unless view_name.match(%r{\A/})
+          msg << " Did you install it in `~/.assert/views`?"
+        end
         warn msg
       end
     end
@@ -48,11 +50,13 @@ module Assert
     attr_reader :config
 
     def initialize(config, output_io)
-      @config , @output_io, = config, output_io
+      @config, @output_io, = config, output_io
       @output_io.sync = true if @output_io.respond_to?(:sync=)
     end
 
-    def view; self; end
+    def view
+      self
+    end
 
     def is_tty?
       !!@output_io.isatty
@@ -79,19 +83,41 @@ module Assert
     #                   the test suite
     # * `on_interrupt`: called when the test suite is interrupted while running
     #                   the interrupt exception is passed as an arg
-    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
 
     # IO capture
 
-    def puts(*args); @output_io.puts(*args); end
-    def print(*args); @output_io.print(*args); end
+    def puts(*args)
+      @output_io.puts(*args)
+    end
+
+    def print(*args)
+      @output_io.print(*args)
+    end
   end
 end