assert 2.19.2 → 2.19.3

data/lib/assert/cli.rb

@@ -3,6 +3,7 @@
 require "benchmark"
 require "set"
 require "assert/assert_runner"
+require "assert/clirb"
 require "assert/version"
 
 module Assert
@@ -24,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)
@@ -72,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)
@@ -93,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

@@ -11,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}")
@@ -53,30 +53,30 @@ 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
   end
 end

data/lib/assert/config_helpers.rb

@@ -2,35 +2,68 @@
 
 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?;      self.config.suite.tests_to_run?;      end
-    def tests_to_run_count; self.config.suite.tests_to_run_count; end
+    def tests_to_run?
+      config.suite.tests_to_run?
+    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 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 pass_result_count
+      config.suite.pass_result_count
+    end
+
+    def fail_result_count
+      config.suite.fail_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")
@@ -46,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

@@ -38,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)
@@ -63,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 "\
@@ -74,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
 
@@ -87,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
@@ -107,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
@@ -139,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
@@ -178,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

data/lib/assert/context/let_dsl.rb

@@ -5,9 +5,12 @@ class Assert::Context; end
 
 module Assert::Context::LetDSL
   def let(name, &block)
-    self.send(:define_method, name, &-> {
+    send(:define_method, name, &->{
       unless instance_variable_defined?("@__assert_let_#{name}__")
-        instance_variable_set("@__assert_let_#{name}__", instance_eval(&block))
+        instance_variable_set(
+          "@__assert_let_#{name}__",
+          instance_eval(&block),
+        )
       end
 
       instance_variable_get("@__assert_let_#{name}__")

data/lib/assert/context/setup_dsl.rb

@@ -5,28 +5,28 @@ module Assert; end
 class Assert::Context
   module SetupDSL
     def setup_once(&block)
-      self.suite.setup(&block)
+      suite.setup(&block)
     end
     alias_method :before_once, :setup_once
     alias_method :startup, :setup_once
 
     def teardown_once(&block)
-      self.suite.teardown(&block)
+      suite.teardown(&block)
     end
     alias_method :after_once, :teardown_once
     alias_method :shutdown, :teardown_once
 
     def around(&block)
-      self.arounds << block
+      arounds << block
     end
 
     def setup(method_name = nil, &block)
-      self.setups << (block || method_name)
+      setups << (block || method_name)
     end
     alias_method :before, :setup
 
     def teardown(method_name = nil, &block)
-      self.teardowns << (block || method_name)
+      teardowns << (block || method_name)
     end
     alias_method :after, :teardown
 
@@ -43,12 +43,13 @@ class Assert::Context
     end
 
     def run_arounds(scope, &run_block)
-      context_block = self.arounds.compact.reverse.inject(run_block) do |run_b, around_b|
-        Proc.new{ scope.instance_exec(run_b, &around_b) }
-      end
+      context_block =
+        arounds.compact.reverse.inject(run_block) do |run_b, around_b|
+          Proc.new{ scope.instance_exec(run_b, &around_b) }
+        end
 
-      if self.superclass.respond_to?(:run_arounds)
-        self.superclass.run_arounds(scope, &context_block)
+      if superclass.respond_to?(:run_arounds)
+        superclass.run_arounds(scope, &context_block)
       else
         context_block.call
       end
@@ -56,20 +57,24 @@ class Assert::Context
 
     def run_setups(scope)
       # setup the parent...
-      self.superclass.run_setups(scope) if self.superclass.respond_to?(:run_setups)
+      superclass.run_setups(scope) if superclass.respond_to?(:run_setups)
       # ... before you setup the child
-      self.setups.compact.each do |setup|
-        setup.kind_of?(::Proc) ? scope.instance_eval(&setup) : scope.send(setup)
+      setups.compact.each do |setup|
+        setup.is_a?(::Proc) ? scope.instance_eval(&setup) : scope.send(setup)
       end
     end
 
     def run_teardowns(scope)
       # teardown the child...
-      self.teardowns.compact.each do |teardown|
-        teardown.kind_of?(::Proc) ? scope.instance_eval(&teardown) : scope.send(teardown)
+      teardowns.compact.each do |teardown|
+        if teardown.is_a?(::Proc)
+          scope.instance_eval(&teardown)
+        else
+          scope.send(teardown)
+        end
       end
       # ... before the parent
-      self.superclass.run_teardowns(scope) if self.superclass.respond_to?(:run_teardowns)
+      superclass.run_teardowns(scope) if superclass.respond_to?(:run_teardowns)
     end
   end
 end