assert 2.19.0 → 2.19.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9486fb389a6e45657eaf3c79f7c2cfea3e8cd6d9b8593c28597b716f9316c86b
-  data.tar.gz: dea0bd1b5061630fddad2f2feaa43e3faf0e64504bf444599747035b3ca8e40f
+  metadata.gz: 35f8f95e4407b3f78d1f7f1c764bb22c0287bbdb8cf44574c50c43bb9f30732c
+  data.tar.gz: 1c1ab4b120c4b8e006971b492ec5ac776d5cd4e55ac9df85f387d5065801d7fc
 SHA512:
-  metadata.gz: c6e57f7df5c6b7273a3ccb190ecc77f014fe597fa15fb6cc72f4bdadd77a12066736e9dffc12cc02d4854f7cf92751fe1994d5142ad24c44eb196906eb079d64
-  data.tar.gz: cd2c4c0ef5c647abab8a9aac3340d17219ccd5b9d8eed5df34f47238296187122ee4b0df2c09aa9989e7dc8ddcb5d0529e3c615f539cf22e3e4f5d35a8b81575
+  metadata.gz: 77ffacb188ba7c3accba0ece4702a8695dd6735a09e2c86183c0e0a4106946b28d7e18bf8e4ead82046bd9376697fc45886b1e6bc43098f6c5eeaf4e78350037
+  data.tar.gz: 633e0ca4b3e75f7a653ff301cfebe98b76cd55a0665c3082dfb3cbd9b24e0d582e4f5aa752ec42a76e0c7035b61502f03cb4eddfd94662e9f797c04e093f4dd4

data/Gemfile

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
-ruby "~>2.4"
+ruby "~> 2.5"
 
 gemspec
 
-gem "pry", "~> 0.12.2"
+gem "pry"

data/assert.gemspec

@@ -1,4 +1,6 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "assert/version"
@@ -8,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.1.0"])
-  gem.add_dependency("much-not-given", ["~> 0.1.0"])
-  gem.add_dependency("much-stub",      ["~> 0.1.4"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.5.0"])
+
+  gem.add_dependency("much-factory",   ["~> 0.2.1"])
+  gem.add_dependency("much-not-given", ["~> 0.1.2"])
+  gem.add_dependency("much-stub",      ["~> 0.1.7"])
 end

data/bin/assert

@@ -2,6 +2,7 @@
 #
 # Copyright (c) 2011-Present Kelly Redding and Collin Redding
 #
+# frozen_string_literal: true
 
 require "assert"
 require "assert/cli"

data/lib/assert.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/version"
 
 require "assert/config"
@@ -9,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.configure
+    yield config if block_given?
+  end
+
+  def self.view
+    config.view
+  end
 
-  def self.view;   self.config.view;   end
-  def self.suite;  self.config.suite;  end
-  def self.runner; self.config.runner; 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

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "much-not-given"
 require "much-stub"
 
 module Assert; end
+
 class Assert::ActualValue
   include MuchNotGiven
 
@@ -34,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert/cli"
 
 module Assert
@@ -23,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
@@ -50,7 +57,7 @@ module Assert
     end
 
     def run
-      self.config.runner.run
+      config.runner.run
     end
 
     private
@@ -64,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
@@ -88,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

@@ -1,14 +1,20 @@
+# frozen_string_literal: true
+
 require "assert/utils"
 
 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)
@@ -22,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
@@ -43,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
@@ -58,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
@@ -97,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__)}."
@@ -183,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
@@ -191,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
@@ -203,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
 
@@ -222,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
 
@@ -234,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
@@ -243,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
 
@@ -262,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
@@ -297,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
@@ -315,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
@@ -335,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
 
@@ -347,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
 
@@ -362,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
@@ -377,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