assert 2.19.0 → 2.19.5

data/lib/assert/cli.rb

@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
 require "benchmark"
 require "set"
 require "assert/assert_runner"
+require "assert/clirb"
 require "assert/version"
 
 module Assert
   class CLI
+    SUCCESS_EXIT_STATUS = 0
+    ERROR_EXIT_STATUS   = 1
+
     def self.debug?(args)
       args.include?("-d") || args.include?("--debug")
     end
@@ -22,13 +28,17 @@ module Assert
     end
 
     def self.bench(start_msg, &block)
-      if !Assert.config.debug
-        block.call; return
+      unless Assert.config.debug
+        block.call
+        return
       end
+
       print debug_start_msg(start_msg)
-      RoundedMillisecondTime.new(Benchmark.measure(&block).real).tap do |time_in_ms|
-        puts debug_finish_msg(time_in_ms)
-      end
+      RoundedMillisecondTime
+        .new(Benchmark.measure(&block).real)
+        .tap do |time_in_ms|
+          puts debug_finish_msg(time_in_ms)
+        end
     end
 
     def initialize(*args)
@@ -61,25 +71,31 @@ module Assert
     end
 
     def run
+      fails_plus_errors_count = 0
       begin
         @cli.parse!(@args)
         catch(:halt) do
-          Assert::AssertRunner.new(Assert.config, @cli.args, @cli.opts).run
+          fails_plus_errors_count =
+            Assert::AssertRunner.new(Assert.config, @cli.args, @cli.opts).run
         end
       rescue CLIRB::HelpExit
         puts help
+        exit(SUCCESS_EXIT_STATUS)
       rescue CLIRB::VersionExit
         puts Assert::VERSION
-      rescue CLIRB::Error => exception
-        puts "#{exception.message}\n\n"
-        puts  Assert.config.debug ? exception.backtrace.join("\n") : help
-        exit(1)
-      rescue StandardError => exception
-        puts "#{exception.class}: #{exception.message}"
-        puts exception.backtrace.join("\n")
-        exit(1)
+        exit(SUCCESS_EXIT_STATUS)
+      rescue CLIRB::Error => ex
+        puts "#{ex.message}\n\n"
+        puts Assert.config.debug ? ex.backtrace.join("\n") : help
+        exit(ERROR_EXIT_STATUS)
+      rescue => ex
+        puts "#{ex.class}: #{ex.message}"
+        puts ex.backtrace.join("\n")
+        exit(ERROR_EXIT_STATUS)
       end
-      exit(0)
+      exit(
+        fails_plus_errors_count == 0 ? SUCCESS_EXIT_STATUS : ERROR_EXIT_STATUS,
+      )
     end
 
     def help
@@ -91,63 +107,9 @@ module Assert
 
   module RoundedMillisecondTime
     ROUND_PRECISION = 3
-    ROUND_MODIFIER = 10 ** ROUND_PRECISION
+    ROUND_MODIFIER = 10**ROUND_PRECISION
     def self.new(time_in_seconds)
       (time_in_seconds * 1000 * ROUND_MODIFIER).to_i / ROUND_MODIFIER.to_f
     end
   end
-
-  class CLIRB  # Version 1.1.0, https://github.com/redding/cli.rb
-    Error    = Class.new(RuntimeError);
-    HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
-    attr_reader :argv, :args, :opts, :data
-
-    def initialize(&block)
-      @options = []; instance_eval(&block) if block
-      require "optparse"
-      @data, @args, @opts = [], [], {}; @parser = OptionParser.new do |p|
-        p.banner = ""; @options.each do |o|
-          @opts[o.name] = o.value; p.on(*o.parser_args){ |v| @opts[o.name] = v }
-        end
-        p.on_tail("--version", ""){ |v| raise VersionExit, v.to_s }
-        p.on_tail("--help",    ""){ |v| raise HelpExit,    v.to_s }
-      end
-    end
-
-    def option(*args); @options << Option.new(*args); end
-    def parse!(argv)
-      @args = (argv || []).dup.tap do |args_list|
-        begin; @parser.parse!(args_list)
-        rescue OptionParser::ParseError => err; raise Error, err.message; end
-      end; @data = @args + [@opts]
-    end
-    def to_s; @parser.to_s; end
-    def inspect
-      "#<#{self.class}:#{"0x0%x" % (object_id << 1)} @data=#{@data.inspect}>"
-    end
-
-    class Option
-      attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
-
-      def initialize(name, desc = nil, abbrev: nil, value: nil)
-        @name, @desc = name, desc || ""
-        @opt_name, @abbrev = parse_name_values(name, abbrev)
-        @value, @klass = gvalinfo(value)
-        @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
-          ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
-        else
-          ["-#{@abbrev}", "--#{@opt_name} VALUE", @klass, @desc]
-        end
-      end
-
-      private
-
-      def parse_name_values(name, custom_abbrev)
-        [ (processed_name = name.to_s.strip.downcase).gsub("_", "-"),
-          custom_abbrev || processed_name.gsub(/[^a-z]/, "").chars.first || "a"
-        ]
-      end
-      def gvalinfo(v); v.kind_of?(Class) ? [nil,v] : [v,v.class]; end
-    end
-  end
 end

data/lib/assert/clirb.rb

@@ -0,0 +1,55 @@
+module Assert
+  class CLIRB  # Version 1.1.0, https://github.com/redding/cli.rb
+    Error    = Class.new(RuntimeError);
+    HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
+    attr_reader :argv, :args, :opts, :data
+
+    def initialize(&block)
+      @options = []; instance_eval(&block) if block
+      require "optparse"
+      @data, @args, @opts = [], [], {}; @parser = OptionParser.new do |p|
+        p.banner = ""; @options.each do |o|
+          @opts[o.name] = o.value; p.on(*o.parser_args){ |v| @opts[o.name] = v }
+        end
+        p.on_tail("--version", ""){ |v| raise VersionExit, v.to_s }
+        p.on_tail("--help",    ""){ |v| raise HelpExit,    v.to_s }
+      end
+    end
+
+    def option(*args); @options << Option.new(*args); end
+    def parse!(argv)
+      @args = (argv || []).dup.tap do |args_list|
+        begin; @parser.parse!(args_list)
+        rescue OptionParser::ParseError => err; raise Error, err.message; end
+      end; @data = @args + [@opts]
+    end
+    def to_s; @parser.to_s; end
+    def inspect
+      "#<#{self.class}:#{"0x0%x" % (object_id << 1)} @data=#{@data.inspect}>"
+    end
+
+    class Option
+      attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
+
+      def initialize(name, desc = nil, abbrev: nil, value: nil)
+        @name, @desc = name, desc || ""
+        @opt_name, @abbrev = parse_name_values(name, abbrev)
+        @value, @klass = gvalinfo(value)
+        @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
+          ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
+        else
+          ["-#{@abbrev}", "--#{@opt_name} VALUE", @klass, @desc]
+        end
+      end
+
+      private
+
+      def parse_name_values(name, custom_abbrev)
+        [ (processed_name = name.to_s.strip.downcase).gsub("_", "-"),
+          custom_abbrev || processed_name.gsub(/[^a-z]/, "").chars.first || "a"
+        ]
+      end
+      def gvalinfo(v); v.kind_of?(Class) ? [nil,v] : [v,v.class]; end
+    end
+  end
+end

data/lib/assert/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/default_runner"
 require "assert/default_suite"
 require "assert/default_view"
@@ -9,7 +11,7 @@ module Assert
     def self.settings(*items)
       items.each do |item|
         define_method(item) do |*args|
-          if !(value = args.size > 1 ? args : args.first).nil?
+          unless (value = args.size > 1 ? args : args.first).nil?
             instance_variable_set("@#{item}", value)
           end
           instance_variable_get("@#{item}")
@@ -39,7 +41,7 @@ module Assert
       @run_diff_proc = Assert::U.syscmd_diff_proc
 
       # option settings
-      @runner_seed    = begin; srand; srand % 0xFFFF; end.to_i
+      @runner_seed    = (env_runner_seed || random_runner_seed).to_i
       @changed_only   = false
       @changed_ref    = ""
       @single_test    = ""
@@ -51,30 +53,42 @@ module Assert
       @list           = false
       @debug          = false
 
-      self.apply(settings || {})
+      apply(settings || {})
     end
 
     def apply(settings)
       settings.keys.each do |name|
-        if !settings[name].nil? && self.respond_to?(name.to_s)
-          self.send(name.to_s, settings[name])
+        if !settings[name].nil? && respond_to?(name.to_s)
+          send(name.to_s, settings[name])
         end
       end
       @single_test_file_line = nil
     end
 
     def single_test?
-      !self.single_test.empty?
+      !single_test.empty?
     end
 
     def single_test_file_line
       @single_test_file_line ||= Assert::FileLine.parse(
-        File.expand_path(self.single_test, Dir.pwd)
+        File.expand_path(single_test, Dir.pwd),
       )
     end
 
     def single_test_file_path
-      self.single_test_file_line.file if self.single_test_file_line
+      single_test_file_line&.file
+    end
+
+    def env_runner_seed
+      ENV["SEED"]
+    end
+
+    def random_runner_seed
+      @random_runner_seed ||=
+        begin
+          srand
+          srand % 0xFFFF
+        end
     end
   end
 end

data/lib/assert/config_helpers.rb

@@ -1,34 +1,69 @@
+# frozen_string_literal: true
+
 module Assert
   module ConfigHelpers
-    def runner; self.config.runner; end
-    def suite;  self.config.suite;  end
-    def view;   self.config.view;   end
+    def runner
+      config.runner
+    end
+
+    def suite
+      config.suite
+    end
+
+    def view
+      config.view
+    end
 
     def runner_seed
-      self.config.runner_seed
+      config.runner_seed
     end
 
     def single_test?
-      self.config.single_test?
+      config.single_test?
     end
 
     def single_test_file_line
-      self.config.single_test_file_line
+      config.single_test_file_line
+    end
+
+    def tests_to_run?
+      config.suite.tests_to_run?
+    end
+
+    def tests_to_run_count
+      config.suite.tests_to_run_count
+    end
+
+    def test_count
+      config.suite.test_count
+    end
+
+    def result_count
+      config.suite.result_count
     end
 
-    def tests_to_run?;      self.config.suite.tests_to_run?;      end
-    def tests_to_run_count; self.config.suite.tests_to_run_count; end
+    def pass_result_count
+      config.suite.pass_result_count
+    end
+
+    def fail_result_count
+      config.suite.fail_result_count
+    end
 
-    def test_count;          self.config.suite.test_count;          end
-    def result_count;        self.config.suite.result_count;        end
-    def pass_result_count;   self.config.suite.pass_result_count;   end
-    def fail_result_count;   self.config.suite.fail_result_count;   end
-    def error_result_count;  self.config.suite.error_result_count;  end
-    def skip_result_count;   self.config.suite.skip_result_count;   end
-    def ignore_result_count; self.config.suite.ignore_result_count; end
+    def error_result_count
+      config.suite.error_result_count
+    end
+
+    def skip_result_count
+      config.suite.skip_result_count
+    end
+
+    def ignore_result_count
+      config.suite.ignore_result_count
+    end
 
     def all_pass?
-      self.pass_result_count == self.result_count
+      pass_result_count == result_count
     end
 
     def formatted_run_time(run_time, format = "%.6f")
@@ -44,29 +79,29 @@ module Assert
     end
 
     def formatted_suite_run_time(format = "%.6f")
-      formatted_run_time(self.config.suite.run_time, format)
+      formatted_run_time(config.suite.run_time, format)
     end
 
     def formatted_suite_test_rate(format = "%.6f")
-      formatted_test_rate(self.config.suite.test_rate, format)
+      formatted_test_rate(config.suite.test_rate, format)
     end
 
     def formatted_suite_result_rate(format = "%.6f")
-      formatted_result_rate(self.config.suite.result_rate, format)
+      formatted_result_rate(config.suite.result_rate, format)
     end
 
     def show_test_profile_info?
-      !!self.config.profile
+      !!config.profile
     end
 
     def show_test_verbose_info?
-      !!self.config.verbose
+      !!config.verbose
     end
 
     # return a list of result type symbols that have actually occurred
     def ocurring_result_types
       @result_types ||= [:pass, :fail, :ignore, :skip, :error].select do |sym|
-        self.send("#{sym}_result_count") > 0
+        send("#{sym}_result_count") > 0
       end
     end
 

data/lib/assert/context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/actual_value"
 require "assert/assertions"
 require "assert/context/let_dsl"
@@ -36,7 +38,7 @@ module Assert
       @__assert_pending__      = 0
 
       @__assert_result_callback__ = proc do |result|
-        if !@__assert_with_bt__.empty?
+        unless @__assert_with_bt__.empty?
           result.set_with_bt(@__assert_with_bt__.dup)
         end
         result_callback.call(result)
@@ -61,7 +63,8 @@ module Assert
     end
 
     # The opposite of assert. Check if the result is false. If so, create a new
-    # pass result. Otherwise create a new fail result with the desc and fail msg.
+    # pass result. Otherwise create a new fail result with the desc and
+    # fail msg.
     def assert_not(assertion, fail_desc = nil)
       assert(!assertion, fail_desc) do
         "Failed assert_not: assertion was "\
@@ -72,8 +75,7 @@ module Assert
 
     def assert_that(
           actual_value = Assert::ActualValue.not_given,
-          &actual_value_block
-        )
+          &actual_value_block)
       Assert::ActualValue.new(actual_value, context: self, &actual_value_block)
     end
 
@@ -85,7 +87,7 @@ module Assert
       else
         capture_result(
           Assert::Result::Fail,
-          "Pending pass (make it not pending)"
+          "Pending pass (make it not pending)",
         )
       end
     end
@@ -105,12 +107,10 @@ module Assert
         else
           capture_result(Assert::Result::Fail, message || "")
         end
+      elsif halt_on_fail?
+        raise Result::TestSkipped, "Pending fail: #{message || ""}"
       else
-        if halt_on_fail?
-          raise Result::TestSkipped, "Pending fail: #{message || ""}"
-        else
-          capture_result(Assert::Result::Skip, "Pending fail: #{message || ""}")
-        end
+        capture_result(Assert::Result::Skip, "Pending fail: #{message || ""}")
       end
     end
     alias_method :flunk, :fail
@@ -137,11 +137,11 @@ module Assert
       begin
         @__assert_with_bt__.push(bt.first)
         instance_eval(&block)
-      rescue Result::TestSkipped, Result::TestFailure => e
-        if e.assert_with_bt.nil? && !@__assert_with_bt__.empty?
-          e.assert_with_bt = @__assert_with_bt__.dup
+      rescue Result::TestSkipped, Result::TestFailure => ex
+        if ex.assert_with_bt.nil? && !@__assert_with_bt__.empty?
+          ex.assert_with_bt = @__assert_with_bt__.dup
         end
-        raise(e)
+        raise(ex)
       ensure
         @__assert_with_bt__.pop
       end
@@ -176,12 +176,10 @@ module Assert
 
     def capture_result(result_klass, msg)
       @__assert_result_callback__.call(
-        result_klass.for_test(@__assert_running_test__, msg, caller_locations)
+        result_klass.for_test(@__assert_running_test__, msg, caller_locations),
       )
     end
 
-    def __assert_config__
-      @__assert_config__
-    end
+    attr_reader :__assert_config__
   end
 end