assert 2.18.4 → 2.19.4

data/lib/assert/cli.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "benchmark"
 require "set"
 require "assert/assert_runner"
+require "assert/clirb"
 require "assert/version"
 
 module Assert
@@ -22,13 +25,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)
@@ -70,13 +77,13 @@ module Assert
         puts help
       rescue CLIRB::VersionExit
         puts Assert::VERSION
-      rescue CLIRB::Error => exception
-        puts "#{exception.message}\n\n"
-        puts  Assert.config.debug ? exception.backtrace.join("\n") : help
+      rescue CLIRB::Error => ex
+        puts "#{ex.message}\n\n"
+        puts Assert.config.debug ? ex.backtrace.join("\n") : help
         exit(1)
-      rescue StandardError => exception
-        puts "#{exception.class}: #{exception.message}"
-        puts exception.backtrace.join("\n")
+      rescue => ex
+        puts "#{ex.class}: #{ex.message}"
+        puts ex.backtrace.join("\n")
         exit(1)
       end
       exit(0)
@@ -91,63 +98,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"
@@ -13,8 +15,13 @@ require "assert/suite"
 require "assert/utils"
 
 module Assert
+  # A Context is a scope for tests to run in. Contexts have setup and teardown
+  # blocks, subjects, and descriptions. Tests are run in the scope of a Context
+  # instance. Therefore, a Context should have minimal base
+  # logic/methods/instance_vars. The instance should remain pure to not pollute
+  # test scopes.
   class Context
-    # put all logic in DSL methods to keep context instances pure for running tests
+    # Put all logic in DSL methods to keep context instances pure.
     extend SetupDSL
     extend SubjectDSL
     extend SuiteDSL
@@ -24,33 +31,6 @@ module Assert
     include Assert::Assertions
     include Assert::Macros::Methods
 
-    # a Context is a scope for tests to run in.  Contexts have setup and
-    # teardown blocks, subjects, and descriptions.  Tests are run in the
-    # scope of a Context instance.  Therefore, a Context should have
-    # minimal base logic/methods/instance_vars.  The instance should remain
-    # pure to not pollute test scopes.
-
-    # if a test method is added to a context manually (not using a context helper):
-    # capture any context info, build a test obj, and add it to the suite
-    def self.method_added(method_name)
-      if method_name.to_s =~ Suite::TEST_METHOD_REGEX
-        klass_method_name = "#{self}##{method_name}"
-
-        if self.suite.test_methods.include?(klass_method_name)
-          puts "WARNING: redefining "#{klass_method_name}""
-          puts "  from: #{caller_locations(1,1)}"
-        else
-          self.suite.test_methods << klass_method_name
-        end
-
-        self.suite.on_test(Test.for_method(
-          method_name.to_s,
-          ContextInfo.new(self, nil, caller_locations(1,1)),
-          self.suite.config
-        ))
-      end
-    end
-
     def initialize(running_test, config, result_callback)
       @__assert_running_test__ = running_test
       @__assert_config__       = config
@@ -58,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)
@@ -83,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 "\
@@ -92,8 +73,10 @@ module Assert
     end
     alias_method :refute, :assert_not
 
-    def assert_that(actual_value)
-      Assert::ActualValue.new(actual_value, context: self)
+    def assert_that(
+          actual_value = Assert::ActualValue.not_given,
+          &actual_value_block)
+      Assert::ActualValue.new(actual_value, context: self, &actual_value_block)
     end
 
     # adds a Pass result to the end of the test's results
@@ -102,8 +85,10 @@ module Assert
       if @__assert_pending__ == 0
         capture_result(Assert::Result::Pass, pass_msg)
       else
-        capture_result(Assert::Result::Fail, "Pending pass (make it "\
-                                             "not pending)")
+        capture_result(
+          Assert::Result::Fail,
+          "Pending pass (make it not pending)",
+        )
       end
     end
 
@@ -122,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
@@ -154,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
@@ -193,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