assert 2.18.4 → 2.19.4

data/lib/assert/context/let_dsl.rb

@@ -1,10 +1,16 @@
+# frozen_string_literal: true
+
 module Assert; end
 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/method_missing.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "assert/assertions"
 
 module Assert; end
 class Assert::Context; end
+
 module Assert::Context::MethodMissing
   def method_missing(method, *args, &block)
     if Assert::Assertions::IGNORED_ASSERTION_HELPERS.include?(method.to_sym)

data/lib/assert/context/setup_dsl.rb

@@ -1,29 +1,32 @@
+# frozen_string_literal: true
+
 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
 
@@ -40,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
@@ -53,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

data/lib/assert/context/subject_dsl.rb

@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 module Assert; end
 class Assert::Context; end
+
 module Assert::Context::SubjectDSL
-  # Add a piece of description text or return the full description for the context
+  # Add a piece of description text or return the full description
+  # for the context.
   def description(text = nil)
     if text
-      self.descriptions << text.to_s
+      descriptions << text.to_s
     else
-      parent = self.superclass.desc if self.superclass.respond_to?(:desc)
-      own = self.descriptions
+      parent = superclass.desc if superclass.respond_to?(:desc)
+      own = descriptions
       [parent, *own].compact.reject(&:empty?).join(" ")
     end
   end
@@ -18,9 +22,7 @@ module Assert::Context::SubjectDSL
     if block_given?
       @subject = block
     else
-      @subject || if superclass.respond_to?(:subject)
-        superclass.subject
-      end
+      @subject || (superclass.subject if superclass.respond_to?(:subject))
     end
   end
 

data/lib/assert/context/suite_dsl.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 module Assert; end
+
 class Assert::Context
   module SuiteDSL
     def suite(suite_obj = nil)
       if suite_obj
         @suite = suite_obj
       else
-        @suite || if superclass.respond_to?(:suite)
+        @suite ||
+        if superclass.respond_to?(:suite)
           superclass.suite
         else
           Assert.suite

data/lib/assert/context/test_dsl.rb

@@ -1,51 +1,90 @@
+# frozen_string_literal: true
+
 require "assert/context_info"
 require "assert/macro"
 require "assert/suite"
 require "assert/test"
 
 module Assert; end
+
 class Assert::Context
   module TestDSL
     def test(desc_or_macro, called_from = nil, first_caller = nil, &block)
-      if desc_or_macro.kind_of?(Assert::Macro)
+      if desc_or_macro.is_a?(Assert::Macro)
         instance_eval(&desc_or_macro)
       elsif block_given?
         # create a test from the given code block
-        self.suite.on_test(Assert::Test.for_block(
-          desc_or_macro.kind_of?(Assert::Macro) ? desc_or_macro.name : desc_or_macro,
-          Assert::ContextInfo.new(self, called_from, first_caller || caller_locations.first),
-          self.suite.config,
-          &block
-        ))
+        desc =
+          if desc_or_macro.is_a?(Assert::Macro)
+            desc_or_macro.name
+          else
+            desc_or_macro
+          end
+        suite.on_test(
+          Assert::Test.for_block(
+            desc,
+            Assert::ContextInfo.new(
+              self,
+              called_from,
+              first_caller || caller_locations.first,
+            ),
+            suite.config,
+            &block
+          ),
+        )
       else
-        test_eventually(desc_or_macro, called_from, first_caller || caller_locations.first, &block)
+        test_eventually(
+          desc_or_macro,
+          called_from,
+          first_caller || caller_locations.first,
+          &block
+        )
       end
     end
 
-    def test_eventually(desc_or_macro, called_from = nil, first_caller = nil, &block)
+    def test_eventually(desc_or_macro, called_from = nil, first_caller = nil)
       # create a test from a proc that just skips
-      ci = Assert::ContextInfo.new(self, called_from, first_caller || caller_locations.first)
-      self.suite.on_test(Assert::Test.for_block(
-        desc_or_macro.kind_of?(Assert::Macro) ? desc_or_macro.name : desc_or_macro,
+      ci =
+        Assert::ContextInfo.new(
+          self,
+          called_from,
+          first_caller || caller_locations.first,
+        )
+      suite.on_test(Assert::Test.for_block(
+        desc_or_macro.is_a?(Assert::Macro) ? desc_or_macro.name : desc_or_macro,
         ci,
-        self.suite.config,
-        &proc { skip("TODO", [ci.called_from.to_s]) }
+        suite.config,
+        &proc{ skip("TODO", [ci.called_from.to_s]) }
       ))
     end
     alias_method :test_skip, :test_eventually
 
     def should(desc_or_macro, called_from = nil, first_caller = nil, &block)
-      if !desc_or_macro.kind_of?(Assert::Macro)
+      unless desc_or_macro.is_a?(Assert::Macro)
         desc_or_macro = "should #{desc_or_macro}"
       end
-      test(desc_or_macro, called_from, first_caller || caller_locations.first, &block)
+      test(
+        desc_or_macro,
+        called_from,
+        first_caller || caller_locations.first,
+        &block
+      )
     end
 
-    def should_eventually(desc_or_macro, called_from = nil, first_caller = nil, &block)
-      if !desc_or_macro.kind_of?(Assert::Macro)
+    def should_eventually(
+          desc_or_macro,
+          called_from = nil,
+          first_caller = nil,
+          &block)
+      unless desc_or_macro.is_a?(Assert::Macro)
         desc_or_macro = "should #{desc_or_macro}"
       end
-      test_eventually(desc_or_macro, called_from, first_caller || caller_locations.first, &block)
+      test_eventually(
+        desc_or_macro,
+        called_from,
+        first_caller || caller_locations.first,
+        &block
+      )
     end
     alias_method :should_skip, :should_eventually
   end

data/lib/assert/context_info.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Assert
   class ContextInfo
     attr_reader :called_from, :klass, :file

data/lib/assert/default_runner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/runner"
 
 module Assert

data/lib/assert/default_suite.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/suite"
 
 module Assert
@@ -5,41 +7,51 @@ module Assert
   # behavior, it accumulates test/result counts in memory.  This data is used
   # by the runner/view for handling and presentation purposes.
   class DefaultSuite < Assert::Suite
+    attr_reader :test_count, :result_count, :pass_result_count
+    attr_reader :fail_result_count, :error_result_count
+    attr_reader :skip_result_count, :ignore_result_count
+
     def initialize(config)
       super
       reset_run_data
     end
 
-    def test_count;          @test_count;          end
-    def result_count;        @result_count;        end
-    def pass_result_count;   @pass_result_count;   end
-    def fail_result_count;   @fail_result_count;   end
-    def error_result_count;  @error_result_count;  end
-    def skip_result_count;   @skip_result_count;   end
-    def ignore_result_count; @ignore_result_count; end
-
     # Callbacks
 
     def on_start
       reset_run_data
     end
 
-    def before_test(test)
+    def before_test(_test)
       @test_count += 1
     end
 
     def on_result(result)
       @result_count += 1
-      self.send("increment_#{result.type}_result_count")
+      send("increment_#{result.type}_result_count")
     end
 
     private
 
-    def increment_pass_result_count;   @pass_result_count   += 1; end
-    def increment_fail_result_count;   @fail_result_count   += 1; end
-    def increment_error_result_count;  @error_result_count  += 1; end
-    def increment_skip_result_count;   @skip_result_count   += 1; end
-    def increment_ignore_result_count; @ignore_result_count += 1; end
+    def increment_pass_result_count
+      @pass_result_count += 1
+    end
+
+    def increment_fail_result_count
+      @fail_result_count += 1
+    end
+
+    def increment_error_result_count
+      @error_result_count += 1
+    end
+
+    def increment_skip_result_count
+      @skip_result_count += 1
+    end
+
+    def increment_ignore_result_count
+      @ignore_result_count += 1
+    end
 
     def reset_run_data
       @test_count          = 0

data/lib/assert/default_view.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/view"
 require "assert/view_helpers"
 
@@ -29,26 +31,28 @@ module Assert
     end
 
     def on_finish
-      if self.test_count > 0
-        dump_test_results
-      end
+      dump_test_results if test_count > 0
 
       # show profile output
       if show_test_profile_info?
         # sort the test datas fastest to slowest
-        @test_datas.values.sort{ |a, b| a.run_time <=> b.run_time }.each do |test_data|
-          puts "#{formatted_run_time(test_data.run_time)} seconds,"\
-               " #{test_data.result_count} results,"\
-               " #{formatted_result_rate(test_data.result_rate)} results/s --"\
-               " #{test_data.context}: #{test_data.name.inspect}"
-        end
+        @test_datas
+          .values
+          .sort{ |a, b| a.run_time <=> b.run_time }
+          .each do |test_data|
+            puts "#{formatted_run_time(test_data.run_time)} seconds,"\
+                 " #{test_data.result_count} results,"\
+                 " #{formatted_result_rate(test_data.result_rate)} results/s "\
+                 "-- #{test_data.context}: #{test_data.name.inspect}"
+          end
         puts
       end
 
       # style the summaries of each result set
-      styled_results_sentence = results_summary_sentence do |summary, result_type|
-        ansi_styled_msg(summary, result_type)
-      end
+      styled_results_sentence =
+        results_summary_sentence do |summary, result_type|
+          ansi_styled_msg(summary, result_type)
+        end
 
       puts "#{result_count_statement}: #{styled_results_sentence}"
       puts
@@ -66,7 +70,7 @@ module Assert
       puts
     end
 
-    def on_interrupt(err)
+    def on_interrupt(_err)
       dump_test_results
     end
 
@@ -80,7 +84,7 @@ module Assert
     def set_callbacks
       @metaclass = class << self; self; end
       if accumulate_test_data?
-        @metaclass.class_eval <<-callbacks
+        @metaclass.class_eval <<-RUBY
           def before_test(test)
             test_data = get_test_data(test)
             puts  "\#{test_data.name.inspect} (\#{test_data.context})"
@@ -89,32 +93,46 @@ module Assert
           end
 
           def on_result(result)
-            print ansi_styled_msg(self.send("\#{result.to_sym}_abbrev"), result.type)
-            @results_to_dump << ResultData.for_result(result) if dumpable_result?(result)
+            print(
+              ansi_styled_msg(
+                self.send("\#{result.to_sym}_abbrev"),
+                result.type,
+              )
+            )
+            @results_to_dump <<
+              ResultData.for_result(result) if dumpable_result?(result)
             find_test_data(result.test_file_line).result_count += 1
           end
 
           def after_test(test)
             test_data = find_test_data(test.file_line)
-            test_data.run_time    = test.run_time
-            test_data.result_rate = get_rate(test_data.result_count, test_data.run_time)
+            test_data.run_time = test.run_time
+            test_data.result_rate =
+              get_rate(test_data.result_count, test_data.run_time)
 
             if show_test_verbose_info?
               print " \#{formatted_run_time(test_data.run_time)} seconds,"\
                     " \#{test_data.result_count} results,"\
-                    " \#{formatted_result_rate(test_data.result_rate)} results/s\n"
+                    " \#{formatted_result_rate(test_data.result_rate)} "\
+                    "results/s\n"
             else
               print "\n"
             end
           end
-        callbacks
+        RUBY
       else
-        @metaclass.class_eval <<-callbacks
+        @metaclass.class_eval <<-RUBY
           def on_result(result)
-            print ansi_styled_msg(self.send("\#{result.to_sym}_abbrev"), result.type)
-            @results_to_dump << ResultData.for_result(result) if dumpable_result?(result)
+            print(
+              ansi_styled_msg(
+                self.send("\#{result.to_sym}_abbrev"),
+                result.type
+              )
+            )
+            @results_to_dump <<
+              ResultData.for_result(result) if dumpable_result?(result)
           end
-        callbacks
+        RUBY
       end
     end
 
@@ -156,27 +174,28 @@ module Assert
       end
     end
 
-    attrs = [:name, :context, :file_line, :result_count, :run_time, :result_rate]
+    attrs =
+      [:name, :context, :file_line, :result_count, :run_time, :result_rate]
     class TestData < Struct.new(*attrs)
       def self.for_test(t)
-        self.new(t.name, t.context_class, t.file_line.to_s, 0, 0.0, 0.0)
+        new(t.name, t.context_class, t.file_line.to_s, 0, 0.0, 0.0)
       end
     end
 
     attrs = [:type, :details, :output, :test_id, :sort_by]
     class ResultData < Struct.new(*attrs)
       def self.for_result(r)
-        self.new(r.type, r.to_s, r.output, r.test_id, self.sort_by(r))
+        new(r.type, r.to_s, r.output, r.test_id, sort_by(r))
       end
 
       def self.sort_by(r)
         [r.test_file_name, r.test_line_num, r.file_name, r.line_num]
       end
 
-      def <=>(other_rd)
+      def <=>(other)
         # show in reverse definition order
-        if other_rd.kind_of?(ResultData)
-          other_rd.sort_by <=> self.sort_by
+        if other.is_a?(ResultData)
+          other.sort_by <=> sort_by
         else
           super
         end