assert 2.19.1 → 2.19.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb7d42eb2185251217dae19781d2094535c5157e3331f11dc2e4ef7231f1c8a5
-  data.tar.gz: a70d2f737ead843cd0221c7e7ec19b480063867fce2c5b8c532fcb5d9faae735
+  metadata.gz: bd449dd7b34b86306e82212ebe0f487381bfceb1f5bebe4b33267287c1042ccf
+  data.tar.gz: 84993c54ea74a3ee84e955466e3a778d46ef9a746a7c6d1775994e99c2f218f3
 SHA512:
-  metadata.gz: f8286bebe4994b44d2a833101905d8381a5906bd4bc9ba7f0c2b93523724edfd8d7049c3866a8b6b792d09d5984d9aafe304cd9d498714177b41301d4d99890f
-  data.tar.gz: 5a92c2a699742fcdb8e44a3c897af7c595a678e7b4124b0c9972ab2df2b341586b2718fad7873e97afab4e37bc7252b1afa7dcfb2d3016383b92989af1c5d105
+  metadata.gz: f21c6d4fa31ed751d2e39989f9adfa4c7b3e127aed9de394e5cec9679d7e8abc1be3967702e0e7b5dff0e277e673d92ec5b8c0839902dfeaf12b329d3943cb65
+  data.tar.gz: b4273af162ac77362407cedb18bfbb79c55a014ef57cb3dcf8341ec901a40df4effe570b148b1ec86968c21dff637d50e99de11e7db67acba8b60b6cf38829df

data/assert.gemspec

@@ -1,6 +1,6 @@
+# -*- encoding: utf-8 -*-
 # frozen_string_literal: true
 
-# -*- encoding: utf-8 -*-
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "assert/version"
@@ -10,19 +10,22 @@ Gem::Specification.new do |gem|
   gem.version     = Assert::VERSION
   gem.authors     = ["Kelly Redding", "Collin Redding"]
   gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.summary     = %q{Assertion style testing framework.}
-  gem.description = %q{Assertion style testing framework.}
+  gem.summary     = "Assertion style testing framework."
+  gem.description = "Assertion style testing framework."
   gem.homepage    = "http://github.com/redding/assert"
   gem.license     = "MIT"
 
-  gem.files         = `git ls-files | grep "^[^.]"`.split($/)
+  gem.files = `git ls-files | grep "^[^.]"`.split($INPUT_RECORD_SEPARATOR)
+
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = "~> 2.5"
 
-  gem.add_dependency("much-factory",   ["~> 0.2.0"])
-  gem.add_dependency("much-not-given", ["~> 0.1.1"])
-  gem.add_dependency("much-stub",      ["~> 0.1.6"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.6.1"])
+
+  gem.add_dependency("much-factory",   ["~> 0.2.2"])
+  gem.add_dependency("much-not-given", ["~> 0.1.2"])
+  gem.add_dependency("much-stub",      ["~> 0.1.7"])
 end

data/lib/assert.rb

@@ -11,16 +11,28 @@ require "assert/utils"
 require "assert/view"
 
 module Assert
-  def self.config; @config ||= Config.new; end
-  def self.configure; yield self.config if block_given?; end
+  def self.config
+    @config ||= Config.new
+  end
 
-  def self.view;   self.config.view;   end
-  def self.suite;  self.config.suite;  end
-  def self.runner; self.config.runner; end
+  def self.configure
+    yield config if block_given?
+  end
+
+  def self.view
+    config.view
+  end
+
+  def self.suite
+    config.suite
+  end
+
+  def self.runner
+    config.runner
+  end
 
   # unstub all stubs automatically (see stub.rb)
   class Context
     teardown{ Assert.unstub! }
   end
 end
-

data/lib/assert/actual_value.rb

@@ -37,15 +37,17 @@ class Assert::ActualValue
     @context.assert_not_changes(*args, &@value)
   end
 
-  def is_a_kind_of(expected_class, *args)
-    @context.assert_kind_of(expected_class, @value, *args)
+  def is_a(expected_class, *args)
+    @context.assert_is_a(expected_class, @value, *args)
   end
-  alias_method :is_kind_of, :is_a_kind_of
+  alias_method :is_a_kind_of, :is_a
+  alias_method :is_kind_of, :is_a
 
-  def is_not_a_kind_of(expected_class, *args)
-    @context.assert_not_kind_of(expected_class, @value, *args)
+  def is_not_a(expected_class, *args)
+    @context.assert_is_not_a(expected_class, @value, *args)
   end
-  alias_method :is_not_kind_of, :is_not_a_kind_of
+  alias_method :is_not_a_kind_of, :is_not_a
+  alias_method :is_not_kind_of, :is_not_a
 
   def is_an_instance_of(expected_class, *args)
     @context.assert_instance_of(expected_class, @value, *args)

data/lib/assert/assert_runner.rb

@@ -25,24 +25,29 @@ module Assert
 
     def init(test_files, test_dir)
       # load any test helper file
-      if test_dir && (h = File.join(test_dir, self.config.test_helper)) && File.exists?(h)
+      if (
+        test_dir &&
+        (h = File.join(test_dir, config.test_helper)) &&
+        File.exist?(h)
+      )
         Assert::CLI.bench("Requiring test helper"){ require h }
       end
 
-      if self.config.list
+      if config.list
         $stdout.puts test_files
         halt
       end
 
       # load the test files
-      runner, suite, view = self.config.runner, self.config.suite, self.config.view
+      runner, suite, view =
+        config.runner, config.suite, config.view
       runner.before_load(test_files)
       suite.before_load(test_files)
       view.before_load(test_files)
       Assert::CLI.bench("Requiring #{test_files.size} test files") do
         test_files.each{ |p| require p }
       end
-      if self.config.debug
+      if config.debug
         puts Assert::CLI.debug_msg("Test files:")
         test_files.each{ |f| puts Assert::CLI.debug_msg("  #{f}") }
       end
@@ -52,7 +57,7 @@ module Assert
     end
 
     def run
-      self.config.runner.run
+      config.runner.run
     end
 
     private
@@ -66,22 +71,27 @@ module Assert
     end
 
     def apply_local_settings
-      safe_require(ENV["ASSERT_LOCALFILE"] || path_of(LOCAL_SETTINGS_FILE, Dir.pwd))
+      safe_require(
+        ENV["ASSERT_LOCALFILE"] ||
+        path_of(LOCAL_SETTINGS_FILE, Dir.pwd),
+      )
     end
 
     def apply_env_settings
-      self.config.runner_seed ENV["ASSERT_RUNNER_SEED"].to_i if ENV["ASSERT_RUNNER_SEED"]
+      if ENV["ASSERT_RUNNER_SEED"]
+        config.runner_seed ENV["ASSERT_RUNNER_SEED"].to_i
+      end
     end
 
     def apply_option_settings(options)
-      self.config.apply(options)
+      config.apply(options)
     end
 
     def lookup_test_files(test_paths)
-      file_paths = if self.config.changed_only
+      file_paths = if config.changed_only
         changed_test_files(test_paths)
-      elsif self.config.single_test?
-        globbed_test_files([self.config.single_test_file_path])
+      elsif config.single_test?
+        globbed_test_files([config.single_test_file_path])
       else
         globbed_test_files(test_paths)
       end
@@ -90,33 +100,42 @@ module Assert
     end
 
     def changed_test_files(test_paths)
-      globbed_test_files(self.config.changed_proc.call(self.config, test_paths))
+      globbed_test_files(config.changed_proc.call(config, test_paths))
     end
 
     def globbed_test_files(test_paths)
       test_paths.inject(Set.new) do |paths, path|
         p = File.expand_path(path, Dir.pwd)
-        paths += Dir.glob("#{p}*") + Dir.glob("#{p}*/**/*")
+        paths + Dir.glob("#{p}*") + Dir.glob("#{p}*/**/*")
       end
     end
 
     def is_test_file?(path)
-      self.config.test_file_suffixes.inject(false) do |result, suffix|
+      config.test_file_suffixes.inject(false) do |result, suffix|
         result || path =~ /#{suffix}$/
       end
     end
 
     def safe_require(settings_file)
-      require settings_file if File.exists?(settings_file)
+      require settings_file if File.exist?(settings_file)
     end
 
     def path_of(segment, a_path)
       # this method inspects a test path and finds the test dir path.
       full_path = File.expand_path(a_path || ".", Dir.pwd)
       seg_pos = full_path.index(segment_regex(segment))
-      File.join(seg_pos && (seg_pos > 0) ? full_path[0..(seg_pos-1)] : full_path, segment)
+      File.join(
+        if seg_pos && (seg_pos > 0)
+          full_path[0..(seg_pos - 1)]
+        else
+          full_path
+        end,
+        segment,
+      )
     end
 
-    def segment_regex(seg); /^#{seg}$|^#{seg}\/|\/#{seg}\/|\/#{seg}$/; end
+    def segment_regex(seg)
+      %r{^#{seg}$|^#{seg}/|/#{seg}/|/#{seg}$}
+    end
   end
 end

data/lib/assert/assertions.rb

@@ -6,11 +6,15 @@ module Assert
   module Assertions
     IGNORED_ASSERTION_HELPERS =
       [
-        :assert_throws,     :assert_nothing_thrown,
-        :assert_operator,   :refute_operator,
-        :assert_in_epsilon, :refute_in_epsilon,
-        :assert_in_delta,   :refute_in_delta,
-        :assert_send
+        :assert_throws,
+        :assert_nothing_thrown,
+        :assert_operator,
+        :refute_operator,
+        :assert_in_epsilon,
+        :refute_in_epsilon,
+        :assert_in_delta,
+        :refute_in_delta,
+        :assert_send,
       ]
 
     def assert_block(desc = nil)
@@ -24,13 +28,15 @@ module Assert
 
     def assert_empty(collection, desc = nil)
       assert(collection.empty?, desc) do
-        "Expected #{Assert::U.show(collection, __assert_config__)} to be empty."
+        "Expected #{Assert::U.show(collection, __assert_config__)} to "\
+        "be empty."
       end
     end
 
     def assert_not_empty(collection, desc = nil)
       assert(!collection.empty?, desc) do
-        "Expected #{Assert::U.show(collection, __assert_config__)} to not be empty."
+        "Expected #{Assert::U.show(collection, __assert_config__)} to "\
+        "not be empty."
       end
     end
     alias_method :refute_empty, :assert_not_empty
@@ -45,7 +51,8 @@ module Assert
           "Expected does not equal actual, diff:\n"\
           "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "Expected #{Assert::U.show(act, c)} to be equal to #{Assert::U.show(exp, c)}."
+          "Expected #{Assert::U.show(act, c)} to "\
+          "be equal to #{Assert::U.show(exp, c)}."
         end
       end
     end
@@ -60,20 +67,21 @@ module Assert
           "Expected equals actual, diff:\n"\
           "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "Expected #{Assert::U.show(act, c)} to not be equal to #{Assert::U.show(exp, c)}."
+          "Expected #{Assert::U.show(act, c)} to "\
+          "not be equal to #{Assert::U.show(exp, c)}."
         end
       end
     end
     alias_method :refute_equal, :assert_not_equal
 
     def assert_file_exists(file_path, desc = nil)
-      assert(File.exists?(File.expand_path(file_path)), desc) do
+      assert(File.exist?(File.expand_path(file_path)), desc) do
         "Expected #{Assert::U.show(file_path, __assert_config__)} to exist."
       end
     end
 
     def assert_not_file_exists(file_path, desc = nil)
-      assert(!File.exists?(File.expand_path(file_path)), desc) do
+      assert(!File.exist?(File.expand_path(file_path)), desc) do
         "Expected #{Assert::U.show(file_path, __assert_config__)} to not exist."
       end
     end
@@ -99,36 +107,41 @@ module Assert
 
     def assert_instance_of(klass, instance, desc = nil)
       assert(instance.instance_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
-        " to be an instance of #{klass}."
+        "Expected #{Assert::U.show(instance, __assert_config__)} "\
+        "(#{instance.class}) to be an instance of #{klass}."
       end
     end
 
     def assert_not_instance_of(klass, instance, desc = nil)
       assert(!instance.instance_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
-        " to not be an instance of #{klass}."
+        "Expected #{Assert::U.show(instance, __assert_config__)} "\
+        "(#{instance.class}) to not be an instance of #{klass}."
       end
     end
     alias_method :refute_instance_of, :assert_not_instance_of
 
-    def assert_kind_of(klass, instance, desc = nil)
-      assert(instance.kind_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
-        " to be a kind of #{klass}."
+    def assert_is_a(klass, instance, desc = nil)
+      assert(instance.is_a?(klass), desc) do
+        "Expected #{Assert::U.show(instance, __assert_config__)} "\
+        "(#{instance.class}) to be a `#{klass}`."
       end
     end
+    alias_method :assert_kind_of, :assert_is_a
 
-    def assert_not_kind_of(klass, instance, desc = nil)
-      assert(!instance.kind_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
-        " to not be a kind of #{klass}."
+    def assert_is_not_a(klass, instance, desc = nil)
+      assert(!instance.is_a?(klass), desc) do
+        "Expected #{Assert::U.show(instance, __assert_config__)} "\
+        "(#{instance.class}) to not be a `#{klass}`."
       end
     end
-    alias_method :refute_kind_of, :assert_not_kind_of
+    alias_method :assert_not_a, :assert_is_not_a
+    alias_method :assert_not_kind_of, :assert_is_not_a
+    alias_method :refute_is_a, :assert_is_not_a
+    alias_method :refute_kind_of, :assert_is_not_a
 
     def assert_match(exp, act, desc = nil)
-      exp_regex = String === exp && String === act ? /#{Regexp.escape(exp)}/ : exp
+      exp_regex =
+        String === exp && String === act ? /#{Regexp.escape(exp)}/ : exp
       assert(act =~ exp_regex, desc) do
         "Expected #{Assert::U.show(act, __assert_config__)}"\
         " to match #{Assert::U.show(exp, __assert_config__)}."
@@ -185,7 +198,7 @@ module Assert
     alias_method :refute_false, :assert_not_false
 
     def assert_raises(*exceptions, &block)
-      desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
+      desc = exceptions.last.is_a?(String) ? exceptions.pop : nil
       err = RaisedException.new(exceptions, &block)
       assert(err.raised?, desc){ err.msg }
       err.exception
@@ -193,7 +206,7 @@ module Assert
     alias_method :assert_raise, :assert_raises
 
     def assert_nothing_raised(*exceptions, &block)
-      desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
+      desc = exceptions.last.is_a?(String) ? exceptions.pop : nil
       err = NoRaisedException.new(exceptions, &block)
       assert(!err.raised?, desc){ err.msg }
     end
@@ -205,15 +218,15 @@ module Assert
           desc: nil,
           from: Assert::ActualValue.not_given,
           to: Assert::ActualValue.not_given,
-          &block
-        )
+          &block)
       desc_msg = desc ? "#{desc}\n" : ""
       from_eval = instance_eval(ruby_string_to_eval)
       if Assert::ActualValue.given?(from)
         assert_equal(
           from,
           from_eval,
-          "#{desc_msg}Expected `#{ruby_string_to_eval}` to change from `#{from.inspect}`."
+          "#{desc_msg}Expected `#{ruby_string_to_eval}` to "\
+          "change from `#{from.inspect}`.",
         )
       end
 
@@ -224,7 +237,8 @@ module Assert
         assert_equal(
           to,
           to_eval,
-          "#{desc_msg}Expected `#{ruby_string_to_eval}` to change to `#{to.inspect}`."
+          "#{desc_msg}Expected `#{ruby_string_to_eval}` to "\
+          "change to `#{to.inspect}`.",
         )
       end
 
@@ -236,7 +250,7 @@ module Assert
           from_eval,
           to_eval,
           "#{desc_msg}Expected `#{ruby_string_to_eval}` to change; "\
-          "it was `#{from_eval.inspect}` and didn't change."
+          "it was `#{from_eval.inspect}` and didn't change.",
         )
       end
     end
@@ -245,15 +259,15 @@ module Assert
           ruby_string_to_eval,
           desc: nil,
           from: Assert::ActualValue.not_given,
-          &block
-        )
+          &block)
       desc_msg = desc ? "#{desc}\n" : ""
       from_eval = instance_eval(ruby_string_to_eval)
       if Assert::ActualValue.given?(from)
         assert_equal(
           from,
           from_eval,
-          "#{desc_msg}Expected `#{ruby_string_to_eval}` to not change from `#{from.inspect}`."
+          "#{desc_msg}Expected `#{ruby_string_to_eval}` to "\
+          "not change from `#{from.inspect}`.",
         )
       end
 
@@ -264,23 +278,23 @@ module Assert
         from_eval,
         to_eval,
         "#{desc_msg}Expected `#{ruby_string_to_eval}` to not change; "\
-        "it was `#{from_eval.inspect}` and changed to `#{to_eval.inspect}`."
+        "it was `#{from_eval.inspect}` and changed to `#{to_eval.inspect}`.",
       )
     end
     alias_method :refute_changes, :assert_not_changes
 
     def assert_respond_to(method, object, desc = nil)
       assert(object.respond_to?(method), desc) do
-        "Expected #{Assert::U.show(object, __assert_config__)} (#{object.class})"\
-        " to respond to `#{method}`."
+        "Expected #{Assert::U.show(object, __assert_config__)} "\
+        "(#{object.class}) to respond to `#{method}`."
       end
     end
     alias_method :assert_responds_to, :assert_respond_to
 
     def assert_not_respond_to(method, object, desc = nil)
       assert(!object.respond_to?(method), desc) do
-        "Expected #{Assert::U.show(object, __assert_config__)} (#{object.class})"\
-        " to not respond to `#{method}`."
+        "Expected #{Assert::U.show(object, __assert_config__)} "\
+        "(#{object.class}) to not respond to `#{method}`."
       end
     end
     alias_method :assert_not_responds_to, :assert_not_respond_to
@@ -299,8 +313,8 @@ module Assert
           "Expected #{act_id} to be the same as #{exp_id}, diff:\n"\
           "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "Expected #{Assert::U.show(act, c)} (#{act_id}) to be the same as"\
-          " #{Assert::U.show(exp, c)} (#{exp_id})."
+          "Expected #{Assert::U.show(act, c)} (#{act_id}) to "\
+          "be the same as #{Assert::U.show(exp, c)} (#{exp_id})."
         end
       end
     end
@@ -317,8 +331,8 @@ module Assert
           "Expected #{act_id} to not be the same as #{exp_id}, diff:\n"\
           "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "Expected #{Assert::U.show(act, c)} (#{act_id}) to not be the same as"\
-          " #{Assert::U.show(exp, c)} (#{exp_id})."
+          "Expected #{Assert::U.show(act, c)} (#{act_id}) to "\
+          "not be the same as #{Assert::U.show(exp, c)} (#{exp_id})."
         end
       end
     end
@@ -337,7 +351,16 @@ module Assert
 
       def initialize(exceptions, &block)
         @exceptions = exceptions
-        begin; block.call; rescue Exception => @exception; end
+        # rubocop:disable Lint/SuppressedException
+        # rubocop:disable Lint/RescueException
+        # rubocop:disable Naming/RescuedExceptionsVariableName
+        begin
+          block.call
+        rescue Exception => @exception
+        end
+        # rubocop:enable Lint/SuppressedException
+        # rubocop:enable Lint/RescueException
+        # rubocop:enable Naming/RescuedExceptionsVariableName
         @msg = "#{exceptions_sentence(@exceptions)} #{exception_details}"
       end
 
@@ -349,7 +372,11 @@ module Assert
 
       def is_one_of?(exception, exceptions)
         exceptions.empty? || exceptions.any? do |exp|
-          exp.instance_of?(Module) ? exception.kind_of?(exp) : exception.class == exp
+          if exp.instance_of?(Module)
+            exception.is_a?(exp)
+          else
+            exception.class == exp
+          end
         end
       end
 
@@ -364,13 +391,16 @@ module Assert
       def exception_details(raised_msg = nil, no_raised_msg = nil)
         if @exception
           backtrace = Assert::Result::Backtrace.new(@exception.backtrace)
-          [ raised_msg,
+          [
+            raised_msg,
             "Class: `#{@exception.class}`",
             "Message: `#{@exception.message.inspect}`",
             "---Backtrace---",
             backtrace.filtered.to_s,
-            "---------------"
-          ].compact.join("\n")
+            "---------------",
+          ]
+            .compact
+            .join("\n")
         else
           no_raised_msg
         end
@@ -379,7 +409,10 @@ module Assert
 
     class RaisedException < CheckException
       def exception_details
-        super("exception expected, not:", "exception expected but nothing raised.")
+        super(
+          "exception expected, not:",
+          "exception expected but nothing raised."
+        )
       end
     end