assert 2.18.3 → 2.19.3

data/lib/assert/factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "much-factory"
 
 module Assert

data/lib/assert/file_line.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 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
@@ -11,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Assert
   class Macro < ::Proc
     # this class is essentially a way to define a custom set of tests using
@@ -5,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/macro"
 
 module Assert::Macros
@@ -8,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
@@ -19,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
@@ -30,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
@@ -41,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
@@ -52,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
@@ -98,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

data/lib/assert/result.rb

@@ -1,40 +1,48 @@
+# frozen_string_literal: true
+
 require "assert/file_line"
 
 module Assert; end
+
 module Assert::Result
-  class Base          ; end
-  class Pass   < Base ; end
-  class Ignore < Base ; end
-  class Fail   < Base ; end
-  class Error  < Base ; end
-  class Skip   < Base ; end
+  class Base; end
+  class Pass   < Base; end
+  class Ignore < Base; end
+  class Fail   < Base; end
+  class Error  < Base; end
+  class Skip   < Base; end
 
   def self.types
-    @types ||= Hash.new{ |h, k| Base }.tap do |hash|
+    @types ||= Hash.new{ |_h, _k| Base }.tap{ |hash|
       hash[:pass]   = Pass
       hash[:fail]   = Fail
       hash[:ignore] = Ignore
       hash[:skip]   = Skip
       hash[:error]  = Error
-    end.freeze
+    }.freeze
   end
 
   def self.new(data = nil)
     data ||= {}
-    self.types[data[:type]].new(data)
+    types[data[:type]].new(data)
   end
 
   class Base
-    def self.type; :unknown; end
-    def self.name; "";       end
+    def self.type
+      :unknown
+    end
+
+    def self.name
+      ""
+    end
 
     def self.for_test(test, message, bt)
-      self.new({
-        :test_name      => test.name,
-        :test_file_line => test.file_line,
-        :message        => message,
-        :output         => test.output,
-        :backtrace      => Backtrace.new(bt)
+      new({
+        test_name: test.name,
+        test_file_line: test.file_line,
+        message: message,
+        output: test.output,
+        backtrace: Backtrace.new(bt),
       })
     end
 
@@ -56,14 +64,20 @@ module Assert::Result
     end
 
     def test_file_line
-      @test_file_line ||= (@build_data[:test_file_line] || Assert::FileLine.parse(""))
+      @test_file_line ||=
+        (@build_data[:test_file_line] || Assert::FileLine.parse(""))
+    end
+
+    def test_file_name
+      test_file_line.file
     end
 
-    def test_file_name; self.test_file_line.file;      end
-    def test_line_num;  self.test_file_line.line.to_i; end
+    def test_line_num
+      test_file_line.line.to_i
+    end
 
     def test_id
-      self.test_file_line.to_s
+      test_file_line.to_s
     end
 
     def message
@@ -105,38 +119,48 @@ module Assert::Result
     end
 
     def src_line
-      @src_line ||= first_filtered_bt_line(self.backtrace)
+      @src_line ||= first_filtered_bt_line(backtrace)
     end
 
     def file_line
-      @file_line ||= Assert::FileLine.parse(self.src_line)
+      @file_line ||= Assert::FileLine.parse(src_line)
     end
 
-    def file_name; self.file_line.file;      end
-    def line_num;  self.file_line.line.to_i; end
+    def file_name
+      file_line.file
+    end
+
+    def line_num
+      file_line.line.to_i
+    end
 
     Assert::Result.types.keys.each do |type|
       define_method("#{type}?"){ self.type == type }
     end
 
-    def to_sym; self.type; end
+    def to_sym
+      type
+    end
 
     def to_s
-      [ "#{self.name.upcase}: #{self.test_name}",
-        self.message,
-        self.trace
-      ].reject(&:empty?).join("\n")
+      ["#{name.upcase}: #{test_name}", message, trace]
+        .reject(&:empty?)
+        .join("\n")
     end
 
-    def ==(other_result)
-      self.type == other_result.type && self.message == other_result.message
+    def ==(other)
+      if other.is_a?(self.class)
+        type == other.type && message == other.message
+      else
+        super
+      end
     end
 
     def inspect
       "#<#{self.class}:#{"0x0%x" % (object_id << 1)} "\
-      "@message=#{self.message.inspect} "\
-      "@file_line=#{self.file_line.to_s.inspect} "\
-      "@test_file_line=#{self.test_file_line.to_s.inspect}>"
+      "@message=#{message.inspect} "\
+      "@file_line=#{file_line.to_s.inspect} "\
+      "@test_file_line=#{test_file_line.to_s.inspect}>"
     end
 
     private
@@ -146,10 +170,10 @@ module Assert::Result
     # filtered line of the backtrace).  This is overridden for error results
     # as they always show their full backtrace.
     def build_trace
-      if self.with_bt_set?
-        Backtrace.to_s(@with_bt+[first_filtered_bt_line(self.backtrace)])
+      if with_bt_set?
+        Backtrace.to_s(@with_bt + [first_filtered_bt_line(backtrace)])
       else
-        self.src_line
+        src_line
       end
     end
 
@@ -162,13 +186,23 @@ module Assert::Result
   end
 
   class Pass < Base
-    def self.type; :pass;  end
-    def self.name; "Pass"; end
+    def self.type
+      :pass
+    end
+
+    def self.name
+      "Pass"
+    end
   end
 
   class Ignore < Base
-    def self.type; :ignore;  end
-    def self.name; "Ignore"; end
+    def self.type
+      :ignore
+    end
+
+    def self.name
+      "Ignore"
+    end
   end
 
   class HaltingTestResultError < RuntimeError
@@ -179,17 +213,26 @@ module Assert::Result
   TestFailure = Class.new(HaltingTestResultError)
 
   class Fail < Base
-    def self.type; :fail;  end
-    def self.name; "Fail"; end
+    def self.type
+      :fail
+    end
+
+    def self.name
+      "Fail"
+    end
 
-    # fail results can be generated manually or by raising Assert::Result::TestFailure
+    # fail results can be generated manually or by raising
+    # Assert::Result::TestFailure
     def self.for_test(test, msg_or_err, bt = nil)
-      if msg_or_err.kind_of?(TestFailure)
+      if msg_or_err.is_a?(TestFailure)
         super(test, msg_or_err.message, msg_or_err.backtrace).tap do |result|
           result.set_with_bt(msg_or_err.assert_with_bt)
         end
-      elsif msg_or_err.kind_of?(Exception)
-        raise ArgumentError, "generate fail results by raising Assert::Result::TestFailure"
+      elsif msg_or_err.is_a?(Exception)
+        raise(
+          ArgumentError,
+          "generate fail results by raising Assert::Result::TestFailure",
+        )
       else
         super(test, msg_or_err, bt)
       end
@@ -200,17 +243,25 @@ module Assert::Result
   TestSkipped = Class.new(HaltingTestResultError)
 
   class Skip < Base
-    def self.type; :skip;  end
-    def self.name; "Skip"; end
+    def self.type
+      :skip
+    end
+
+    def self.name
+      "Skip"
+    end
 
     # skip results are generated by raising Assert::Result::TestSkipped
     def self.for_test(test, msg_or_err, bt = nil)
-      if msg_or_err.kind_of?(TestSkipped)
+      if msg_or_err.is_a?(TestSkipped)
         super(test, msg_or_err.message, msg_or_err.backtrace).tap do |result|
           result.set_with_bt(msg_or_err.assert_with_bt)
         end
-      elsif msg_or_err.kind_of?(Exception)
-        raise ArgumentError, "generate skip results by raising Assert::Result::TestSkipped"
+      elsif msg_or_err.is_a?(Exception)
+        raise(
+          ArgumentError,
+          "generate skip results by raising Assert::Result::TestSkipped",
+        )
       else
         super(test, msg_or_err, bt)
       end
@@ -218,12 +269,17 @@ module Assert::Result
   end
 
   class Error < Base
-    def self.type; :error;  end
-    def self.name; "Error"; end
+    def self.type
+      :error
+    end
+
+    def self.name
+      "Error"
+    end
 
     # error results are generated by raising exceptions in tests
     def self.for_test(test, err)
-      if err.kind_of?(Exception)
+      if err.is_a?(Exception)
         super(test, "#{err.message} (#{err.class.name})", err.backtrace)
       else
         raise ArgumentError, "generate error results by raising an exception"
@@ -239,10 +295,10 @@ module Assert::Result
   end
 
   class Backtrace < ::Array
-    DELIM = "\n".freeze
+    DELIM = "\n"
 
     def self.parse(bt)
-      self.new(bt.to_s.split(DELIM))
+      new(bt.to_s.split(DELIM))
     end
 
     def self.to_s(bt_array)
@@ -254,7 +310,7 @@ module Assert::Result
     end
 
     def filtered
-      self.class.new(self.reject { |line| filter_out?(line.to_s) })
+      self.class.new(reject{ |line| filter_out?(line.to_s) })
     end
 
     protected
@@ -264,8 +320,8 @@ module Assert::Result
       # "./lib" in project dir, or "/usr/local/blahblah" if installed
       assert_lib_path    = File.expand_path("../..", __FILE__)
       assert_macros_path = File.join(assert_lib_path, "assert/macros")
-      assert_bin_regex = /bin\/assert\:/
-      ( line.rindex(assert_lib_path, 0) &&
+      assert_bin_regex = %r{bin/assert\:}
+      (line.rindex(assert_lib_path, 0) &&
         !line.rindex(assert_macros_path, 0)
       ) ||
       line =~ assert_bin_regex