assert 2.19.2 → 2.19.3

data/lib/assert/context/subject_dsl.rb

@@ -4,13 +4,14 @@ 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
@@ -21,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

@@ -8,7 +8,8 @@ class Assert::Context
       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

@@ -10,45 +10,81 @@ 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/default_suite.rb

@@ -7,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

@@ -31,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
@@ -68,7 +70,7 @@ module Assert
       puts
     end
 
-    def on_interrupt(err)
+    def on_interrupt(_err)
       dump_test_results
     end
 
@@ -82,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})"
@@ -91,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
 
@@ -158,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

data/lib/assert/file_line.rb

@@ -3,7 +3,7 @@
 module Assert
   class FileLine
     def self.parse(file_line_path)
-      self.new(*(file_line_path.to_s.match(/(^[^\:]*)\:*(\d*).*$/) || [])[1..2])
+      new(*(file_line_path.to_s.match(/(^[^\:]*)\:*(\d*).*$/) || [])[1..2])
     end
 
     attr_reader :file, :line
@@ -13,13 +13,13 @@ module Assert
     end
 
     def to_s
-      "#{self.file}:#{self.line}"
+      "#{file}:#{line}"
     end
 
-    def ==(other_file_line)
-      if other_file_line.kind_of?(FileLine)
-        self.file == other_file_line.file &&
-        self.line == other_file_line.line
+    def ==(other)
+      if other.is_a?(FileLine)
+        file == other.file &&
+        line == other.line
       else
         super
       end

data/lib/assert/macro.rb

@@ -7,7 +7,7 @@ module Assert
     # will be instance_eval'd in that Assert::Context.
     attr_accessor :name
 
-    def initialize(name = nil, *args, &block)
+    def initialize(name = nil, *_args)
       raise ArgumentError unless block_given?
       @name = name || "run this macro"
       super()

data/lib/assert/macros/methods.rb

@@ -10,9 +10,12 @@ module Assert::Macros
 
     module ClassMethods
       def have_instance_method(*methods)
-        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller_locations).first
+        called_from =
+          (methods.last.is_a?(Array) ? methods.pop : caller_locations).first
         Assert::Macro.new do
-          methods.each{ |m| _methods_macro_instance_methods << [m, called_from] }
+          methods.each do |m|
+            _methods_macro_instance_methods << [m, called_from]
+          end
           _methods_macro_test called_from
         end
       end
@@ -21,9 +24,12 @@ module Assert::Macros
       alias_method :have_imeths, :have_instance_method
 
       def not_have_instance_method(*methods)
-        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller_locations).first
+        called_from =
+          (methods.last.is_a?(Array) ? methods.pop : caller_locations).first
         Assert::Macro.new do
-          methods.each{ |m| _methods_macro_not_instance_methods << [m, called_from] }
+          methods.each do |m|
+            _methods_macro_not_instance_methods << [m, called_from]
+          end
           _methods_macro_test called_from
         end
       end
@@ -32,7 +38,8 @@ module Assert::Macros
       alias_method :not_have_imeths, :not_have_instance_method
 
       def have_class_method(*methods)
-        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller_locations).first
+        called_from =
+          (methods.last.is_a?(Array) ? methods.pop : caller_locations).first
         Assert::Macro.new do
           methods.each{ |m| _methods_macro_class_methods << [m, called_from] }
           _methods_macro_test called_from
@@ -43,9 +50,12 @@ module Assert::Macros
       alias_method :have_cmeths, :have_class_method
 
       def not_have_class_method(*methods)
-        called_from = (methods.last.kind_of?(Array) ? methods.pop : caller_locations).first
+        called_from =
+          (methods.last.is_a?(Array) ? methods.pop : caller_locations).first
         Assert::Macro.new do
-          methods.each{ |m| _methods_macro_not_class_methods << [m, called_from] }
+          methods.each do |m|
+            _methods_macro_not_class_methods << [m, called_from]
+          end
           _methods_macro_test called_from
         end
       end
@@ -54,44 +64,44 @@ module Assert::Macros
       alias_method :not_have_cmeths, :not_have_class_method
 
       def have_reader(*methods)
-        methods << caller_locations if !methods.last.kind_of?(Array)
+        methods << caller_locations unless methods.last.is_a?(Array)
         have_instance_methods(*methods)
       end
       alias_method :have_readers, :have_reader
 
       def not_have_reader(*methods)
-        methods << caller_locations if !methods.last.kind_of?(Array)
+        methods << caller_locations unless methods.last.is_a?(Array)
         not_have_instance_methods(*methods)
       end
       alias_method :not_have_readers, :not_have_reader
 
       def have_writer(*methods)
-        called = methods.last.kind_of?(Array) ? methods.pop : caller_locations
-        writer_meths = methods.collect{|m| "#{m}="}
+        called = methods.last.is_a?(Array) ? methods.pop : caller_locations
+        writer_meths = methods.collect{ |m| "#{m}=" }
         writer_meths << called
         have_instance_methods(*writer_meths)
       end
       alias_method :have_writers, :have_writer
 
       def not_have_writer(*methods)
-        called = methods.last.kind_of?(Array) ? methods.pop : caller_locations
-        writer_meths = methods.collect{|m| "#{m}="}
+        called = methods.last.is_a?(Array) ? methods.pop : caller_locations
+        writer_meths = methods.collect{ |m| "#{m}=" }
         writer_meths << called
         not_have_instance_methods(*writer_meths)
       end
       alias_method :not_have_writers, :not_have_writer
 
       def have_accessor(*methods)
-        called = methods.last.kind_of?(Array) ? methods.pop : caller_locations
-        accessor_meths = methods.collect{|m| [m, "#{m}="]}.flatten
+        called = methods.last.is_a?(Array) ? methods.pop : caller_locations
+        accessor_meths = methods.collect{ |m| [m, "#{m}="] }.flatten
         accessor_meths << called
         have_instance_methods(*accessor_meths)
       end
       alias_method :have_accessors, :have_accessor
 
       def not_have_accessor(*methods)
-        called = methods.last.kind_of?(Array) ? methods.pop : caller_locations
-        accessor_meths = methods.collect{|m| [m, "#{m}="]}.flatten
+        called = methods.last.is_a?(Array) ? methods.pop : caller_locations
+        accessor_meths = methods.collect{ |m| [m, "#{m}="] }.flatten
         accessor_meths << called
         not_have_instance_methods(*accessor_meths)
       end
@@ -100,35 +110,51 @@ module Assert::Macros
       # private
 
       def _methods_macro_test(called_from)
-        @_methods_macro_test ||= test "should respond to methods", called_from do
-          self.class._methods_macro_instance_methods.each do |(method, called_from)|
-            msg = "#{subject.class.name} does not have instance method ##{method}"
-            with_backtrace([called_from]) do
-              assert_that(subject).responds_to(method, msg)
-            end
-          end
-
-          self.class._methods_macro_class_methods.each do |(method, called_from)|
-            msg = "#{subject.class.name} does not have class method ##{method}"
-            with_backtrace([called_from]) do
-              assert_that(subject.class).responds_to(method, msg)
-            end
+        @_methods_macro_test ||=
+          test "should respond to methods", called_from do
+            self
+              .class
+              ._methods_macro_instance_methods
+              .each do |(method, called_from)|
+                msg =
+                  "#{subject.class.name} does not have "\
+                  "instance method ##{method}"
+                with_backtrace([called_from]) do
+                  assert_that(subject).responds_to(method, msg)
+                end
+              end
+
+            self
+              .class
+              ._methods_macro_class_methods
+              .each do |(method, called_from)|
+                msg =
+                  "#{subject.class.name} does not have class method ##{method}"
+                with_backtrace([called_from]) do
+                  assert_that(subject.class).responds_to(method, msg)
+                end
+              end
+
+            self
+              .class
+              ._methods_macro_not_instance_methods
+              .each do |(method, called_from)|
+                msg = "#{subject.class.name} has instance method ##{method}"
+                with_backtrace([called_from]) do
+                  assert_that(subject).does_not_respond_to(method, msg)
+                end
+              end
+
+            self
+              .class
+              ._methods_macro_not_class_methods
+              .each do |(method, called_from)|
+                msg = "#{subject.class.name} has class method ##{method}"
+                with_backtrace([called_from]) do
+                  assert_that(subject.class).does_not_respond_to(method, msg)
+                end
+              end
           end
-
-          self.class._methods_macro_not_instance_methods.each do |(method, called_from)|
-            msg = "#{subject.class.name} has instance method ##{method}"
-            with_backtrace([called_from]) do
-              assert_that(subject).does_not_respond_to(method, msg)
-            end
-          end
-
-          self.class._methods_macro_not_class_methods.each do |(method, called_from)|
-            msg = "#{subject.class.name} has class method ##{method}"
-            with_backtrace([called_from]) do
-              assert_that(subject.class).does_not_respond_to(method, msg)
-            end
-          end
-        end
       end
 
       def _methods_macro_instance_methods