warning 0.10.1 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: '08cf870b5689f1fc79b3a2c1c9bd787c10802ed0'
-  data.tar.gz: 43f33015143cf420dd92f3db2ad0c5b91f05335d
+SHA256:
+  metadata.gz: aed045b84ec748f7558ea24268aef892d0efcd7d0f0f51cca7b5cf5f95d1aae7
+  data.tar.gz: ad651f6e4f47d4b6064f7863d145d2747fab8477a27a5234e2e3336d85d1ae17
 SHA512:
-  metadata.gz: 2f35fc384e25902773a66ec191ccdf522a762a3c6006d339b66ce4b16c11e1e67df9454d12be4a941c2ad0458b978707b1fc98bfde052c0918c48304d9bea30e
-  data.tar.gz: 6cd8864633508b1bcf4928d4d25c4d8e19763a48f58b1160eb9f03aa3a178413f4b42270bb92b9bf7f7d8941de2c5f02c53f05463ea5f003ab0eff769f535bea
+  metadata.gz: ead742a4b97033e1d1b6ec6460039d7f2138ba8586709a2819303ad0d6791daa26821ee7fd35a9701b2bf7d4ae01f47ef485781331ca77f116ef92d1ec06dada
+  data.tar.gz: 935a429f2a967a57e67bf44739e0583abf186fe3baeaee0ce61532e9083844971ba956ca55831f18092d80652f7090d30f0d1da06758186fccebb98b0f78b18a

data/CHANGELOG

@@ -1,3 +1,35 @@
+=== 1.2.1 (2021-10-04)
+
+* Recognize additional void context warnings (kachick) (#13)
+
+=== 1.2.0 (2021-02-16)
+
+* Add support for :void_context as regexp argument to Warning.ignore (jeremyevans)
+
+* Support :category keyword to Warning.warn on Ruby 3.0 (jeremyevans)
+
+* Fix :taint warning handling on Ruby 3.0 (jeremyevans)
+
+* Fix :ambiguous_slash warning handling on Ruby 3.0 (jeremyevans)
+
+=== 1.1.0 (2020-06-12)
+
+* Allow Warning.process to be called with a hash of actions instead of a block (jeremyevans)
+
+* Handle Warning.process blocks that return :default, :backtrace, or :raise specially (jeremyevans)
+
+* Add support for :mismatched_indentations as regexp argument to Warning.ignore (qortex) (#7)
+
+=== 1.0.0 (2020-01-21)
+
+* Add support for :taint as regexp argument to Warning.ignore (jeremyevans)
+
+* Add support for :safe as regexp argument to Warning.ignore (jeremyevans)
+
+* Add Warning.dedup for deduplicating warnings (jeremyevans)
+
+* Add support for :keyword_separation as regexp argument to Warning.ignore (jeremyevans)
+
 === 0.10.1 (2017-11-16)
 
 * Correctly handle Warning.freeze (jeremyevans)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016 Jeremy Evans
+Copyright (c) 2016-2020 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -2,8 +2,9 @@
 
 ruby-warning adds custom processing for warnings, including the
 ability to ignore specific warning messages, ignore warnings
-in specific files/directories, and add custom handling for all
-warnings in specific files/directories.
+in specific files/directories, include backtraces with warnings,
+treat warnings as errors, deduplicate warnings, and add
+custom handling for all warnings in specific files/directories.
 
 ruby-warning requires ruby 2.4+, as previous versions of ruby do
 not support custom processing of warnings.
@@ -30,13 +31,18 @@ appropriate regexp.  The supported symbols are:
 * :ambiguous_slash
 * :bignum
 * :fixnum
+* :keyword_separation
 * :method_redefined
+* :mismatched_indentations
 * :missing_gvar
 * :missing_ivar
 * :not_reached
+* :safe
 * :shadow
+* :taint
 * :unused_var
 * :useless_operator
+* :void_context
 
 <tt>Warning.process</tt> takes an optional path prefix and a block, and if the
 warning string starts with the path prefix, it calls the block with the warning
@@ -44,15 +50,35 @@ string instead of performing the default behavior. You can call
 <tt>Warning.process</tt> multiple times and it will operate intelligently,
 choosing the longest path prefix that the string starts with.
 
-<tt>Warning.clear</tt> just clears the current ignored warnings and warning
-processors.
+<tt>Warning.process</tt> blocks can return +:default+ to use the default
+behavior, +:backtrace+ to use the default behavior and also print the backtrace
+or +:raise+ to raise the warning string as a RuntimeError.
+
+<tt>Warning.process</tt> can also accept a hash of actions instead of a block,
+with keys being regexps (or symbols supported by <tt>Warning.ignore</tt>) and
+values being callable objects (or +:default+, +:backtrace+, or +:raise+).
+
+<tt>Warning.dedup</tt> deduplicates warnings, so that if a warning is received
+that is the same as a warning that has already been processed, the warning is
+ignored. Note that this should be used with care, since if the application
+generates an arbitrary number of unique warnings, that can lead to unbounded
+memory growth.
+
+<tt>Warning.clear</tt> resets the library to its initial state, clearing the
+current ignored warnings and warning processors, and turning off deduplication.
 
 By using path prefixes, it's fairly easy for a gem to set that specific warnings
 should be ignored inside the gem's directory.
 
 Note that path prefixes will not correctly handle warnings raised by
 <tt>Kernel#warn</tt>, unless the warning message given to <tt>Kernel#warn</tt>
-starts with the filename where the warning is used.
+starts with the filename where the warning is used. The <tt>Kernel#warn</tt>
++:uplevel+ option will make sure the warning starts with the filename.
+
+Note that many of the warnings this library can ignore are warnings caused
+during compilation (i.e. when files are loaded via require).  You should
+require this library and setup the appropriate warning handling before
+loading any code that could cause warnings.
 
 = Examples
 
@@ -78,6 +104,31 @@ starts with the filename where the warning is used.
     LOGGER.error(warning)
   end
 
+  # Write warnings in the current file to $stderr, but include backtrace
+  Warning.process(__FILE__) do |warning|
+    :backtrace
+  end
+
+  # Raise warnings in the current file as RuntimeErrors, with the warning
+  # string as the exception message
+  Warning.process(__FILE__) do |warning|
+    :raise
+  end
+
+  # Raise keyword argument separation warnings in the current file as
+  # RuntimeErrors, and write ambiguous slash warnings to $stderr, including
+  # the backtrace
+  Warning.process(__FILE__, keyword_separation: :raise,
+                  ambiguous_slash: :backtrace)
+
+  # Deduplicate warnings
+  Warning.dedup
+
+  # Ignore all warnings in Gem dependencies
+  Gem.path.each do |path|
+    Warning.ignore(//, path)
+  end
+
 = License
 
 MIT

data/lib/warning.rb

@@ -4,7 +4,7 @@ module Warning
   module Processor
     # Map of symbols to regexps for warning messages to ignore.
     IGNORE_MAP = {
-      ambiguous_slash: /: warning: ambiguous first argument; put parentheses or a space even after `\/' operator\n\z/,
+      ambiguous_slash: /: warning: ambiguous first argument; put parentheses or a space even after `\/' operator\n\z|: warning: ambiguity between regexp and two divisions: wrap regexp in parentheses or add a space after `\/' operator\n\z/,
       arg_prefix: /: warning: `[&\*]' interpreted as argument prefix\n\z/,
       bignum: /: warning: constant ::Bignum is deprecated\n\z/,
       fixnum: /: warning: constant ::Fixnum is deprecated\n\z/,
@@ -15,16 +15,38 @@ module Warning
       shadow: /: warning: shadowing outer local variable - \w+\n\z/,
       unused_var: /: warning: assigned but unused variable - \w+\n\z/,
       useless_operator: /: warning: possibly useless use of [><!=]+ in void context\n\z/,
+      keyword_separation: /: warning: (?:Using the last argument (?:for `.+' )?as keyword parameters is deprecated; maybe \*\* should be added to the call|Passing the keyword argument (?:for `.+' )?as the last hash parameter is deprecated|Splitting the last argument (?:for `.+' )?into positional and keyword parameters is deprecated|The called method (?:`.+' )?is defined here)\n\z/,
+      safe: /: warning: (?:rb_safe_level_2_warning|rb_safe_level|rb_set_safe_level_force|rb_set_safe_level|rb_secure|rb_insecure_operation|rb_check_safe_obj|\$SAFE) will (?:be removed|become a normal global variable) in Ruby 3\.0\n\z/,
+      taint: /: warning: (?:rb_error_untrusted|rb_check_trusted|Pathname#taint|Pathname#untaint|rb_env_path_tainted|Object#tainted\?|Object#taint|Object#untaint|Object#untrusted\?|Object#untrust|Object#trust|rb_obj_infect|rb_tainted_str_new|rb_tainted_str_new_cstr) is deprecated and will be removed in Ruby 3\.2\.?\n\z/,
+      mismatched_indentations: /: warning: mismatched indentations at '.+' with '.+' at \d+\n\z/,
+      void_context: /possibly useless use of (?:a )?\S+ in void context/,
     }
 
-    # Clear all current ignored warnings and warning processors.
+    # Map of action symbols to procs that return the symbol
+    ACTION_PROC_MAP = {
+      default: proc{|_| :default},
+      backtrace: proc{|_| :backtrace},
+      raise: proc{|_| :raise},
+    }
+    private_constant :ACTION_PROC_MAP
+
+    # Clear all current ignored warnings, warning processors, and duplicate check cache.
+    # Also disables deduplicating warnings if that is currently enabled.
     def clear
       synchronize do
         @ignore.clear
         @process.clear
+        @dedup = false
       end
     end
 
+    # Deduplicate warnings, suppress warning messages if the same warning message
+    # has already occurred.  Note that this can lead to unbounded memory use
+    # if unique warnings are generated.
+    def dedup
+      @dedup = {}
+    end
+
     def freeze
       @ignore.freeze
       @process.freeze
@@ -40,6 +62,7 @@ module Warning
     # :ambiguous_slash :: Ignore warnings for things like <tt>method /regexp/</tt>
     # :bignum :: Ignore warnings when referencing the ::Bignum constant.
     # :fixnum :: Ignore warnings when referencing the ::Fixnum constant.
+    # :keyword_separation :: Ignore warnings related to keyword argument separation.
     # :method_redefined :: Ignore warnings when defining a method in a class/module where a
     #                      method of the same name was already defined in that class/module.
     # :missing_gvar :: Ignore warnings for accesses to global variables
@@ -47,10 +70,14 @@ module Warning
     # :missing_ivar :: Ignore warnings for accesses to instance variables
     #                  that have not yet been initialized
     # :not_reached :: Ignore statement not reached warnings.
+    # :safe :: Ignore warnings related to $SAFE and related C-API functions.
     # :shadow :: Ignore warnings related to shadowing outer local variables.
+    # :taint :: Ignore warnings related to taint and related methods and C-API functions.
     # :unused_var :: Ignore warnings for unused variables.
     # :useless_operator :: Ignore warnings when using operators such as == and > when the
     #                      result is not used.
+    # :void_context :: Ignore warnings for :: to reference constants when the result is not
+    #                  used (often used to trigger autoload).
     #
     # Examples:
     #
@@ -66,14 +93,7 @@ module Warning
     #   # Ignore all uninitialized instance variable and method redefined warnings in current file
     #   Warning.ignore([:missing_ivar, :method_redefined],  __FILE__)
     def ignore(regexp, path='')
-      case regexp
-      when Regexp
-        # already regexp
-      when Symbol
-        regexp = IGNORE_MAP.fetch(regexp)
-      when Array
-        regexp = Regexp.union(regexp.map{|re| IGNORE_MAP.fetch(re)})
-      else
+      unless regexp = convert_regexp(regexp)
         raise TypeError, "first argument to Warning.ignore should be Regexp, Symbol, or Array of Symbols, got #{regexp.inspect}"
       end
 
@@ -95,7 +115,52 @@ module Warning
     #   Warning.process(__FILE__) do |warning|
     #     LOGGER.error(warning)
     #   end
-    def process(path='', &block)
+    #
+    # The block can return one of the following symbols:
+    #
+    # :default :: Take the default action (call super, printing to $stderr).
+    # :backtrace :: Take the default action (call super, printing to $stderr),
+    #               and also print the backtrace.
+    # :raise :: Raise a RuntimeError with the warning as the message.
+    #
+    # If the block returns anything else, it is assumed the block completely handled
+    # the warning and takes no other action.
+    #
+    # Instead of passing a block, you can pass a hash of actions to take for specific
+    # warnings, using regexp as keys and a callable objects as values:
+    #
+    #   Warning.process(__FILE__,
+    #     /instance variable @\w+ not initialized/ => proc do |warning|
+    #       LOGGER.warning(warning)
+    #     end,
+    #     /global variable `\$\w+' not initialized/ => proc do |warning|
+    #       LOGGER.error(warning)
+    #     end
+    #   )
+    #
+    # Instead of passing a regexp as a key, you can pass a symbol that is recognized
+    # by Warning.ignore.  Instead of passing a callable object as a value, you can
+    # pass a symbol, which will be treated as a callable object that returns that symbol:
+    #
+    #   Warning.process(__FILE__, :missing_ivar=>:backtrace, :keyword_separation=>:raise)
+    def process(path='', actions=nil, &block)
+      if block
+        if actions
+          raise ArgumentError, "cannot pass both actions and block to Warning.process"
+        end
+      elsif actions
+        block = {}
+        actions.each do |regexp, value|
+          unless regexp = convert_regexp(regexp)
+            raise TypeError, "action provided to Warning.process should be Regexp, Symbol, or Array of Symbols, got #{regexp.inspect}"
+          end
+
+          block[regexp] = ACTION_PROC_MAP[value] || value
+        end
+      else
+        raise ArgumentError, "must pass either actions or block to Warning.process"
+      end
+
       synchronize do
         @process << [path, block]
         @process.sort_by!(&:first)
@@ -104,28 +169,80 @@ module Warning
       nil
     end
 
-    # Handle ignored warnings and warning processors.  If the warning is
-    # not ignored and there is no warning processor setup for the warning
-    # string, then use the default behavior of writing to $stderr.
-    def warn(str)
-      synchronize{@ignore.dup}.each do |path, regexp|
-        if str.start_with?(path) && str =~ regexp
-          return
+
+    if RUBY_VERSION >= '3.0'
+      method_args = ', category: nil'
+      super_ = "category ? super : super(str)"
+    else
+      super_ = "super"
+    end
+
+    class_eval(<<-END, __FILE__, __LINE__+1)
+      def warn(str#{method_args})
+        synchronize{@ignore.dup}.each do |path, regexp|
+          if str.start_with?(path) && str =~ regexp
+            return
+          end
         end
-      end
 
-      synchronize{@process.dup}.each do |path, block|
-        if str.start_with?(path)
-          block.call(str)
-          return
+        if @dedup
+          if synchronize{@dedup[str]}
+            return
+          end
+
+          synchronize{@dedup[str] = true}
         end
-      end
 
-      super
-    end
+        action = catch(:action) do
+          synchronize{@process.dup}.each do |path, block|
+            if str.start_with?(path)
+              if block.is_a?(Hash)
+                block.each do |regexp, blk|
+                  if str =~ regexp
+                    throw :action, blk.call(str)
+                  end
+                end
+              else
+                throw :action, block.call(str)
+              end
+            end
+          end
+
+          :default
+        end
+
+        case action
+        when :default
+          #{super_}
+        when :backtrace
+          #{super_}
+          $stderr.puts caller
+        when :raise
+          raise str
+        else
+          # nothing
+        end
+
+        nil
+      end
+    END
 
     private
 
+    # Convert the given Regexp, Symbol, or Array of Symbols into a Regexp.
+    def convert_regexp(regexp)
+      case regexp
+      when Regexp
+        regexp
+      when Symbol
+        IGNORE_MAP.fetch(regexp)
+      when Array
+        Regexp.union(regexp.map{|re| IGNORE_MAP.fetch(re)})
+      else
+        # nothing
+      end
+    end
+
     def synchronize(&block)
       @monitor.synchronize(&block)
     end
@@ -133,6 +250,7 @@ module Warning
 
   @ignore = []
   @process = []
+  @dedup = false
   @monitor = Monitor.new
 
   extend Processor

data/test/fixtures/mismatched_indentations.rb

@@ -0,0 +1,4 @@
+# Example that will trigger the "mismatched indentations" warning from Ruby
+if 2 > 1
+  true
+    end

data/test/test_freeze_warning.rb

@@ -1,4 +1,5 @@
-require 'minitest/autorun'
+ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
+require 'minitest/global_expectations/autorun'
 require 'warning'
 
 class WarningFreezeTest < Minitest::Test
@@ -39,31 +40,30 @@ class WarningFreezeTest < Minitest::Test
   end
 
   def test_warning_ignore
-    obj = Object.new
     w = nil
 
-    Warning.ignore(/instance variable @ivar not initialized/)
+    Warning.ignore(/global variable `\$test_warning_ignore' not initialized/)
     Warning.process do |warning|
       w = [4, warning]
     end
     Warning.freeze
 
     assert_raises RuntimeError do
-      Warning.ignore(/instance variable @ivar not initialized/)
+      Warning.ignore(/global variable `\$test_warning_ignore' not initialized/)
     end
     assert_raises RuntimeError do
       Warning.process{|warning| w = [4, warning]}
     end
 
     assert_warning '' do
-      assert_nil(obj.instance_variable_get(:@ivar))
+      $test_warning_ignore
     end
     assert_nil w
 
     assert_warning '' do
-      assert_nil(obj.instance_variable_get(:@ivar6))
+      $test_warning_ignore2
     end
     assert_equal(4, w.first)
-    assert_match(/instance variable @ivar6 not initialized/, w.last)
+    assert_match(/global variable `\$test_warning_ignore2' not initialized/, w.last)
   end
 end

data/test/test_warning.rb

@@ -1,11 +1,17 @@
-require 'minitest/autorun'
+ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
+require 'minitest/global_expectations/autorun'
 require 'warning'
+require 'pathname'
 
 class WarningTest < Minitest::Test
   module EnvUtil
     def verbose_warning
+      stderr = ""
       class << (stderr = "")
         alias write <<
+        def puts(*a)
+          self << a.join("\n")
+        end
       end
       stderr, $stderr, verbose, $VERBOSE = $stderr, stderr, $VERBOSE, true
       yield stderr
@@ -42,49 +48,65 @@ class WarningTest < Minitest::Test
     Warning.clear
   end
 
-  def test_warning_ignore
-    obj = Object.new
+  def test_warning_dedup
+    gvar = ->{$test_warning_dedup}
+
+    assert_warning(/global variable `\$test_warning_dedup' not initialized/) do
+      gvar.call
+    end
+    assert_warning(/global variable `\$test_warning_dedup' not initialized/) do
+      gvar.call
+    end
 
-    assert_warning(/instance variable @ivar not initialized/) do
-      assert_nil(obj.instance_variable_get(:@ivar))
+    Warning.dedup
+
+    assert_warning(/global variable `\$test_warning_dedup' not initialized/) do
+      gvar.call
+    end
+    assert_warning('') do
+      gvar.call
     end
+  end
 
-    assert_warning(/instance variable @ivar not initialized/) do
-      assert_nil(obj.instance_variable_get(:@ivar))
+  def test_warning_ignore
+    assert_warning(/global variable `\$test_warning_ignore' not initialized/) do
+      assert_nil($test_warning_ignore)
     end
 
-    Warning.ignore(/instance variable @ivar not initialized/)
+    Warning.ignore(/global variable `\$test_warning_ignore' not initialized/)
 
     assert_warning '' do
-      assert_nil(obj.instance_variable_get(:@ivar))
+      assert_nil($test_warning_ignore)
     end
 
-    assert_warning(/instance variable @ivar2 not initialized/) do
-      assert_nil(obj.instance_variable_get(:@ivar2))
+    assert_warning(/global variable `\$test_warning_ignore2' not initialized/) do
+      assert_nil($test_warning_ignore2)
     end
 
-    Warning.ignore(/instance variable @ivar2 not initialized/, __FILE__)
+    Warning.ignore(/global variable `\$test_warning_ignore2' not initialized/, __FILE__)
 
     assert_warning '' do
-      assert_nil(obj.instance_variable_get(:@ivar2))
+      assert_nil($test_warning_ignore2)
     end
 
-    assert_warning(/instance variable @ivar3 not initialized/) do
-      assert_nil(obj.instance_variable_get(:@ivar3))
+    assert_warning(/global variable `\$test_warning_ignore3' not initialized/) do
+      assert_nil($test_warning_ignore3)
     end
 
-    Warning.ignore(/instance variable @ivar3 not initialized/, __FILE__+'a')
+    Warning.ignore(/global variable `\$test_warning_ignore3' not initialized/, __FILE__ + 'a')
 
-    assert_warning(/instance variable @ivar3 not initialized/) do
-      assert_nil(obj.instance_variable_get(:@ivar3))
+    assert_warning(/global variable `\$test_warning_ignore3' not initialized/) do
+      assert_nil($test_warning_ignore3)
     end
   end
 
   def test_warning_ignore_missing_ivar
     Warning.clear
 
-    assert_warning(/instance variable @ivar not initialized/) do
-      assert_nil(instance_variable_get(:@ivar))
+    unless RUBY_VERSION >= '3.0'
+      assert_warning(/instance variable @ivar not initialized/) do
+        assert_nil(instance_variable_get(:@ivar))
+      end
     end
 
     Warning.ignore(:missing_ivar, __FILE__)
@@ -156,9 +178,43 @@ class WarningTest < Minitest::Test
     end
   end
 
+  def test_warning_ignore_void_context
+    assert_warning(/warning: possibly useless use of :: in void context/) do
+      instance_eval('::Object; nil', __FILE__, __LINE__)
+    end
+
+    Warning.ignore(:void_context, __FILE__)
+
+    assert_warning '' do
+      instance_eval('::Object; nil', __FILE__, __LINE__)
+    end
+
+    assert_warning '' do
+      instance_eval('Object; nil', __FILE__, __LINE__)
+    end
+
+    assert_warning '' do
+      instance_eval('v = 0; v; nil', __FILE__, __LINE__)
+    end
+
+    assert_warning '' do
+      instance_eval('1 > 1; nil', __FILE__, __LINE__)
+    end
+
+    assert_warning '' do
+      instance_eval('defined? C; nil', __FILE__, __LINE__)
+    end
+
+    if RUBY_VERSION >= '2.6'
+      assert_warning '' do
+        instance_eval('1..; nil', __FILE__, __LINE__)
+      end
+    end
+  end
+
   def test_warning_ignore_ambiguous_slash
     def self.d(re); end
-    assert_warning(/warning: ambiguous first argument; put parentheses or a space even after `\/' operator/) do
+    assert_warning(/warning: ambi/) do
       instance_eval('d /a/', __FILE__)
     end
 
@@ -219,6 +275,98 @@ class WarningTest < Minitest::Test
     assert_warning '' do
       instance_eval('lambda{|a| lambda{|a|}}', __FILE__)
     end
+  end if RUBY_VERSION < '2.6'
+
+  if RUBY_VERSION > '2.7' && RUBY_VERSION < '2.8'
+    def h2kw(**kw)
+    end
+    def kw2h(h, **kw)
+    end
+    def skw(h=1, a: 1)
+    end
+
+    def test_warning_ignore_keyword
+      assert_warning(/warning: Using the last argument as keyword parameters is deprecated; maybe \*\* should be added to the call.*The called method `h2kw' is defined here/m) do
+        h2kw({})
+      end
+      assert_warning(/warning: Passing the keyword argument as the last hash parameter is deprecated.*The called method `kw2h' is defined here/m) do
+        kw2h(a: 1)
+      end
+      assert_warning(/warning: Splitting the last argument into positional and keyword parameters is deprecated.*The called method `skw' is defined here/m) do
+        skw("b" => 1, a: 2)
+      end
+      assert_warning(/warning: Splitting the last argument into positional and keyword parameters is deprecated.*The called method `skw' is defined here/m) do
+        skw({"b" => 1, a: 2})
+      end
+
+      Warning.ignore(:keyword_separation, __FILE__)
+
+      assert_warning '' do
+        h2kw({})
+        kw2h(a: 1)
+        skw("b" => 1, a: 2)
+        skw({"b" => 1, a: 2})
+      end
+    end
+
+    def test_warning_ignore_safe
+      assert_warning(/\$SAFE will become a normal global variable in Ruby 3\.0/) do
+        $SAFE = 0
+      end
+
+      Warning.ignore(:safe, __FILE__)
+
+      assert_warning("") do
+        $SAFE = 0
+      end
+    end
+  end
+
+  if RUBY_VERSION > '2.7' && RUBY_VERSION < '3.2'
+
+    def test_warning_ignore_taint
+      o = Object.new
+
+      assert_warning(/Object#taint is deprecated and will be removed in Ruby 3\.2/) do
+        o.taint
+      end
+      assert_warning(/Object#untaint is deprecated and will be removed in Ruby 3\.2/) do
+        o.untaint
+      end
+      assert_warning(/Object#tainted\? is deprecated and will be removed in Ruby 3\.2/) do
+        o.tainted?
+      end
+      assert_warning(/Object#trust is deprecated and will be removed in Ruby 3\.2/) do
+        o.trust
+      end
+      assert_warning(/Object#untrust is deprecated and will be removed in Ruby 3\.2/) do
+        o.untrust
+      end
+      assert_warning(/Object#untrusted\? is deprecated and will be removed in Ruby 3\.2/) do
+        o.untrusted?
+      end
+
+      path = Pathname.new(__FILE__)
+      assert_warning(/Pathname#taint is deprecated and will be removed in Ruby 3\.2/) do
+        path.taint
+      end
+      assert_warning(/Pathname#untaint is deprecated and will be removed in Ruby 3\.2/) do
+        path.untaint
+      end
+
+      Warning.ignore(:taint, __FILE__)
+
+      assert_warning("") do
+        o.taint
+        o.untaint
+        o.tainted?
+        o.trust
+        o.untrust
+        o.untrusted?
+        p.taint
+        p.untaint
+      end
+    end
   end
 
   def test_warning_ignore_symbol_array
@@ -235,16 +383,27 @@ class WarningTest < Minitest::Test
     end
   end
 
+  def test_warning_ignore_mismatched_indentation
+    assert_warning(/warning: mismatched indentations/) do
+      load 'test/fixtures/mismatched_indentations.rb'
+    end
+
+    Warning.ignore(:mismatched_indentations, 'test/fixtures/mismatched_indentations.rb')
+
+    assert_warning '' do
+      load 'test/fixtures/mismatched_indentations.rb'
+    end
+  end
+
   def test_warning_process
-    obj = Object.new
     warn = nil
 
     Warning.process(__FILE__+'a') do |warning|
       warn = [0, warning]
     end
 
-    assert_warning(/instance variable @ivar not initialized/) do
-      assert_nil(obj.instance_variable_get(:@ivar))
+    assert_warning(/global variable `\$test_warning_process' not initialized/) do
+      $test_warning_process
     end
     assert_nil(warn)
 
@@ -253,10 +412,10 @@ class WarningTest < Minitest::Test
     end
 
     assert_warning '' do
-      assert_nil(obj.instance_variable_get(:@ivar2))
+      $test_warning_process2
     end
     assert_equal(1, warn.first)
-    assert_match(/instance variable @ivar2 not initialized/, warn.last)
+    assert_match(/global variable `\$test_warning_process2' not initialized/, warn.last)
     warn = nil
 
     Warning.process(File.dirname(__FILE__)) do |warning|
@@ -264,10 +423,10 @@ class WarningTest < Minitest::Test
     end
 
     assert_warning '' do
-      assert_nil(obj.instance_variable_get(:@ivar3))
+      $test_warning_process3
     end
     assert_equal(1, warn.first)
-    assert_match(/instance variable @ivar3 not initialized/, warn.last)
+    assert_match(/global variable `\$test_warning_process3' not initialized/, warn.last)
     warn = nil
 
     Warning.process(__FILE__+':') do |warning|
@@ -275,16 +434,16 @@ class WarningTest < Minitest::Test
     end
 
     assert_warning '' do
-      assert_nil(obj.instance_variable_get(:@ivar4))
+      $test_warning_process4
     end
     assert_equal(3, warn.first)
-    assert_match(/instance variable @ivar4 not initialized/, warn.last)
+    assert_match(/global variable `\$test_warning_process4' not initialized/, warn.last)
     warn = nil
 
     Warning.clear
 
-    assert_warning(/instance variable @ivar5 not initialized/) do
-      assert_nil(obj.instance_variable_get(:@ivar5))
+    assert_warning(/global variable `\$test_warning_process5' not initialized/) do
+      $test_warning_process5
     end
     assert_nil(warn)
 
@@ -293,9 +452,102 @@ class WarningTest < Minitest::Test
     end
 
     assert_warning '' do
-      assert_nil(obj.instance_variable_get(:@ivar6))
+      $test_warning_process6
     end
     assert_equal(4, warn.first)
-    assert_match(/instance variable @ivar6 not initialized/, warn.last)
+    assert_match(/global variable `\$test_warning_process6' not initialized/, warn.last)
+  end
+
+  def test_warning_process_block_return_default
+    w = nil
+    Warning.process(__FILE__) do |warning|
+      w = warning
+      :default
+    end
+
+    assert_warning(/global variable `\$test_warning_process_block_return_default' not initialized/) do
+      $test_warning_process_block_return_default
+    end
+    assert_match(/global variable `\$test_warning_process_block_return_default' not initialized/, w)
+  end
+
+  def test_warning_process_block_return_backtrace
+    w = nil
+    Warning.process(__FILE__) do |warning|
+      w = warning
+      :backtrace
+    end
+
+    assert_warning(/global variable `\$test_warning_process_block_return_backtrace' not initialized.*#{__FILE__}/m) do
+      $test_warning_process_block_return_backtrace
+    end
+    assert_match(/global variable `\$test_warning_process_block_return_backtrace' not initialized/, w)
+  end
+
+  def test_warning_process_block_return_raise
+    w = nil
+    Warning.process(__FILE__) do |warning|
+      w = warning
+      :raise
+    end
+
+    assert_raises(RuntimeError) do
+      $test_warning_process_block_return_raise
+    end
+    assert_match(/global variable `\$test_warning_process_block_return_raise' not initialized/, w)
+  end
+
+  def test_warning_process_action
+    w = nil
+    Warning.process(__FILE__, :method_redefined=>:default, :missing_gvar=>:backtrace, :ambiguous_slash=>:raise)
+    Warning.process(__FILE__, :not_reached=>proc do |warning|
+      w = warning
+      :raise
+    end)
+
+    assert_warning(/warning: method redefined/) do
+      Class.new do
+        def a; end
+        def a; end
+      end
+    end
+
+    assert_warning(/global variable `\$test_warning_process_action' not initialized.*#{__FILE__}/m) do
+      $test_warning_process_action
+    end
+
+    Warning.process(__FILE__) do |warning|
+      w = warning
+      :raise
+    end
+
+    assert_raises(RuntimeError, /warning: ambi/) do
+      EnvUtil.verbose_warning{instance_eval('d /a/', __FILE__)}
+    end
+
+    assert_raises(RuntimeError, /warning: statement not reached/) do
+      EnvUtil.verbose_warning{instance_eval('def self.b; return; 1 end', __FILE__)}
+    end
+    assert_match(/warning: statement not reached/, w)
+  end
+
+  def test_warning_process_action_and_block
+    assert_raises(ArgumentError) do
+      Warning.process(__FILE__)
+    end
+  end
+
+  def test_warning_process_no_action_and_no_block
+    assert_raises(ArgumentError) do
+      Warning.process(__FILE__, :missing_ivar=>:default){}
+    end
+  end
+
+  if RUBY_VERSION >= '3.0'
+    def test_warning_warn_category_keyword
+      assert_warning('foo') do
+        Warning.warn("foo", category: :deprecated)
+      end
+    end
   end
 end

metadata

@@ -1,20 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: warning
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 1.2.1
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-16 00:00:00.000000000 Z
-dependencies: []
+date: 2021-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest-global_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   ruby-warning adds custom processing for warnings, including the
   ability to ignore specific warning messages, ignore warnings
-  in specific files/directories, and add custom handling for all
-  warnings in specific files/directories.
+  in specific files/directories, include backtraces with warnings,
+  treat warnings as errors, deduplicate warnings, and add
+  custom handling for all warnings in specific files/directories.
 email: code@jeremyevans.net
 executables: []
 extensions: []
@@ -28,12 +43,17 @@ files:
 - README.rdoc
 - Rakefile
 - lib/warning.rb
+- test/fixtures/mismatched_indentations.rb
 - test/test_freeze_warning.rb
 - test/test_warning.rb
 homepage: https://github.com/jeremyevans/ruby-warning
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/jeremyevans/ruby-warning/issues
+  changelog_uri: https://github.com/jeremyevans/ruby-warning/blob/master/CHANGELOG
+  documentation_uri: https://github.com/jeremyevans/ruby-warning/blob/master/README.rdoc
+  source_code_uri: https://github.com/jeremyevans/ruby-warning
 post_install_message: 
 rdoc_options:
 - "--quiet"
@@ -47,17 +67,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.99
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Add custom processing for warnings