warning 0.9.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 70b1655bff238b444c9373002b6d1010812a9a71
-  data.tar.gz: 2276292182d974e7fdb71802295ed1dc45771f82
+SHA256:
+  metadata.gz: c2628e7956e2f0c2a7f55ef1d4397a1f1ff8339d48904b49fc16692934930464
+  data.tar.gz: 72b7fa93465fe52a2907ef2172d3c90694308af52bb2cd5b9117c6e7084419d1
 SHA512:
-  metadata.gz: 6a512057f73e7f275e806a9e9442919e128c0edcf312e730b4787f9b9630c8f088bdfce0af7a7b7f9d6e3811aa94ae95211a4b13d205353e1853c20f2f5a0a4d
-  data.tar.gz: 16e8d3da29e75c5c6f1dd70fede11564006ad30201923d8750aa0d383e77820fa4355c6fd6f6b44600bd276d9afd38706581c123c34898bbbf2534bb64cab5b3
+  metadata.gz: e8f95072982d387477121b90c13790876743d9a40a0a32c06a1ea72720b85c6d831c4dceff28445dd8be2a3ba6e915670b874a908e6b438cce40c83229f95a15
+  data.tar.gz: 3cf24b069bc071cdf425aad86fae1c0b37b3cf723ee8c365a09a183da7e3f737f7eb454f8b1fbc29be1a9651d01fd286e13562ea442c1ae57ca5fc2c045a7570

data/CHANGELOG

@@ -1,3 +1,53 @@
+=== 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)
+
+=== 0.10.0 (2016-11-16)
+
+* Add support for :arg_prefix and :shadow as regexp argument to Warning.ignore (jeremyevans)
+
+* Add support for :useless_operator as regexp argument to Warning.ignore (jeremyevans)
+
+* Add support for :missing_gvar as regexp argument to Warning.ignore (jeremyevans)
+
+* Add support for :ambiguous_slash and :unused_var as regexp arguments to Warning.ignore (jeremyevans)
+
+* Add support for :fixnum and :bignum as regexp arguments to Warning.ignore (jeremyevans)
+
+* Add support for array of symbols as regexp argument to Warning.ignore (jeremyevans)
+
+* Add support for :not_reached as regexp argument to Warning.ignore (jeremyevans)
+
+* Add support for :missing_ivar and :method_redefined as regexp argument to Warning.ignore (jeremyevans)
+
 === 0.9.0 (2016-08-09)
 
 * Initial Public Release

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.
@@ -23,7 +24,25 @@ warnings, it just adds methods that allow you to customize the processing.
 
 <tt>Warning.ignore</tt> takes a regexp and optionally a path prefix, and ignores
 any warning that matches the regular expression if it starts with the path
-prefix.
+prefix.  It can also take a symbol or an array of symbols, and will use an
+appropriate regexp.  The supported symbols are:
+
+* :arg_prefix
+* :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
@@ -31,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
 
@@ -49,6 +88,12 @@ starts with the filename where the warning is used.
   # Ignore all uninitialized instance variable warnings in current file
   Warning.ignore(/instance variable @\w+ not initialized/, __FILE__)
 
+  # Ignore all uninitialized instance variable warnings in current file
+  Warning.ignore(:missing_ivar, __FILE__)
+
+  # Ignore all Fixnum and Bignum warnings in current file
+  Warning.ignore([:fixnum, :bignum], __FILE__)
+
   # Write warning to LOGGER at level warning
   Warning.process do |warning|
     LOGGER.warning(warning)
@@ -59,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/Rakefile

@@ -15,11 +15,19 @@ end
 desc "Run test"
 Rake::TestTask.new do |t|
   t.libs.push "lib"
-  t.test_files = FileList['test/test_*.rb']
+  t.test_files = FileList['test/test_warning.rb']
   t.verbose = true
 end
 
-task :default=>:test
+desc "Run test"
+Rake::TestTask.new(:test_freeze) do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['test/test_freeze_warning.rb']
+  t.verbose = true
+end
+
+desc "Run all tests"
+task :default=>[:test, :test_freeze]
 
 ### RDoc
 

data/lib/warning.rb

@@ -2,23 +2,101 @@ require 'monitor'
 
 module Warning
   module Processor
-    # Clear all current ignored warnings and warning processors.
+    # 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|: 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/,
+      method_redefined: /: warning: method redefined; discarding old .+\n\z|: warning: previous definition of .+ was here\n\z/,
+      missing_gvar: /: warning: global variable `\$.+' not initialized\n\z/,
+      missing_ivar: /: warning: instance variable @.+ not initialized\n\z/,
+      not_reached: /: warning: statement not reached\n\z/,
+      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 :: in void context/,
+    }
+
+    # 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, supress 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
+      super
+    end
     
     # Ignore any warning messages matching the given regexp, if they
-    # start with the given path. Examples:
+    # start with the given path.
+    # The regexp can also be one of the following symbols (or an array including them), which will
+    # use an appropriate regexp for the given warning:
+    #
+    # :arg_prefix :: Ignore warnings when using * or & as an argument prefix
+    # :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
+    #                  that have not yet been initialized
+    # :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:
     #
     #   # Ignore all uninitialized instance variable warnings
     #   Warning.ignore(/instance variable @\w+ not initialized/)
     #
     #   # Ignore all uninitialized instance variable warnings in current file
     #   Warning.ignore(/instance variable @\w+ not initialized/, __FILE__)
+    #
+    #   # Ignore all uninitialized instance variable warnings in current file
+    #   Warning.ignore(:missing_ivar, __FILE__)
+    #
+    #   # Ignore all uninitialized instance variable and method redefined warnings in current file
+    #   Warning.ignore([:missing_ivar, :method_redefined],  __FILE__)
     def ignore(regexp, path='')
+      unless regexp = convert_regexp(regexp)
+        raise TypeError, "first argument to Warning.ignore should be Regexp, Symbol, or Array of Symbols, got #{regexp.inspect}"
+      end
+
       synchronize do 
         @ignore << [path, regexp]
       end
@@ -37,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)
@@ -46,30 +169,89 @@ 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
+
+        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
 
-      super
+    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
   end
 
   @ignore = []
   @process = []
+  @dedup = false
+  @monitor = Monitor.new
 
-  extend MonitorMixin
   extend Processor
 end

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

@@ -0,0 +1,69 @@
+ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
+require 'minitest/global_expectations/autorun'
+require 'warning'
+
+class WarningFreezeTest < Minitest::Test
+  module EnvUtil
+    def verbose_warning
+      class << (stderr = "")
+        alias write <<
+      end
+      stderr, $stderr, verbose, $VERBOSE = $stderr, stderr, $VERBOSE, true
+      yield stderr
+      return $stderr
+    ensure
+      stderr, $stderr, $VERBOSE = $stderr, stderr, verbose
+    end
+    module_function :verbose_warning
+
+    def with_default_internal(enc)
+      verbose, $VERBOSE = $VERBOSE, nil
+      origenc, Encoding.default_internal = Encoding.default_internal, enc
+      $VERBOSE = verbose
+      yield
+    ensure
+      verbose, $VERBOSE = $VERBOSE, nil
+      Encoding.default_internal = origenc
+      $VERBOSE = verbose
+    end
+    module_function :with_default_internal
+  end
+
+  def assert_warning(pat, msg = nil)
+    stderr = EnvUtil.verbose_warning {
+      EnvUtil.with_default_internal(pat.encoding) {
+        yield
+      }
+    }
+    msg = message(msg) {diff pat, stderr}
+    assert(pat === stderr, msg)
+  end
+
+  def test_warning_ignore
+    w = nil
+
+    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(/global variable `\$test_warning_ignore' not initialized/)
+    end
+    assert_raises RuntimeError do
+      Warning.process{|warning| w = [4, warning]}
+    end
+
+    assert_warning '' do
+      $test_warning_ignore
+    end
+    assert_nil w
+
+    assert_warning '' do
+      $test_warning_ignore2
+    end
+    assert_equal(4, w.first)
+    assert_match(/global variable `\$test_warning_ignore2' not initialized/, w.last)
+  end
+end

data/test/test_warning.rb

@@ -1,11 +1,17 @@
-require 'minitest/unit'
-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
@@ -38,66 +44,344 @@ class WarningTest < Minitest::Test
     assert(pat === stderr, msg)
   end
 
-  def test_warning_ignore
-    obj = Object.new
+  def teardown
+    Warning.clear
+  end
 
-    assert_warning /instance variable @ivar not initialized/ do
-      assert_nil(obj.instance_variable_get(:@ivar))
+  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
 
-    require 'warning'
+    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(obj.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__)
+
+    assert_warning '' do
+      assert_nil(instance_variable_get(:@ivar))
+    end
+  end
+
+  def test_warning_ignore_missing_gvar
+    assert_warning(/global variable `\$gvar' not initialized/) do
+      $gvar
+    end
+
+    Warning.ignore(:missing_gvar, __FILE__)
+
+    assert_warning '' do
+      $gvar
+    end
+  end
+
+  def test_warning_ignore_method_redefined
+    def self.a; end
+
+    assert_warning(/method redefined; discarding old a.+previous definition of a was here/m) do
+      def self.a; end
+    end
+
+    Warning.ignore(:method_redefined, __FILE__)
+
+    assert_warning '' do
+      def self.a; end
+    end
+  end
+
+  def test_warning_ignore_not_reached
+    assert_warning(/: warning: statement not reached/) do
+      instance_eval('def self.b; return; 1 end', __FILE__)
+    end
+
+    Warning.ignore(:not_reached, __FILE__)
+
+    assert_warning '' do
+      instance_eval('def self.c; return; 1 end', __FILE__)
+    end
+  end
+
+  def test_warning_ignore_fixnum
+    assert_warning(/warning: constant ::Fixnum is deprecated/) do
+      ::Fixnum
+    end
+
+    Warning.ignore(:fixnum, __FILE__)
+
+    assert_warning '' do
+      ::Fixnum
+    end
+  end
+
+  def test_warning_ignore_bignum
+    assert_warning(/warning: constant ::Bignum is deprecated/) do
+      ::Bignum
+    end
+
+    Warning.ignore(:bignum, __FILE__)
+
+    assert_warning '' do
+      ::Bignum
+    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
+  end
+
+  def test_warning_ignore_ambiguous_slash
+    def self.d(re); end
+    assert_warning(/warning: ambi/) do
+      instance_eval('d /a/', __FILE__)
+    end
+
+    Warning.ignore(:ambiguous_slash, __FILE__)
+
+    assert_warning '' do
+      instance_eval('d /a/', __FILE__)
+    end
+  end
+
+  def test_warning_ignore_unused_var
+    assert_warning(/warning: assigned but unused variable - \w+/) do
+      instance_eval('def self.e; b = 1; 2 end', __FILE__)
+    end
+
+    Warning.ignore(:unused_var, __FILE__)
+
+    assert_warning '' do
+      instance_eval('def self.f; b = 1; 2 end', __FILE__)
+    end
+  end
+
+  def test_warning_ignore_useless_operator
+    assert_warning(/warning: possibly useless use of == in void context/) do
+      instance_eval('1 == 2; true', __FILE__)
+    end
+
+    Warning.ignore(:useless_operator, __FILE__)
+
+    assert_warning '' do
+      instance_eval('1 == 2; true', __FILE__)
+    end
+  end
+
+  def test_warning_ignore_arg_prefix
+    assert_warning(/: warning: `\*' interpreted as argument prefix/) do
+      instance_eval('Array *[nil]', __FILE__)
+    end
+
+    assert_warning(/: warning: `&' interpreted as argument prefix/) do
+      instance_eval('tap &proc{}', __FILE__)
+    end
+    Warning.ignore(:arg_prefix, __FILE__)
+
+    assert_warning '' do
+      instance_eval('Array *[nil]', __FILE__)
+      instance_eval('tap &proc{}', __FILE__)
+    end
+  end
+
+  def test_warning_ignore_shadow
+    assert_warning(/warning: shadowing outer local variable - a/) do
+      instance_eval('lambda{|a| lambda{|a|}}', __FILE__)
+    end
+
+    Warning.ignore(:shadow, __FILE__)
+
+    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
+    def self.c; end
+
+    assert_warning(/statement not reached.+method redefined; discarding old c.+previous definition of c was here/m) do
+      instance_eval('def self.c; return; 1 end', __FILE__)
+    end
+
+    Warning.ignore([:method_redefined, :not_reached], __FILE__)
+
+    assert_warning '' do
+      instance_eval('def self.c; return; 1 end', __FILE__)
+    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
-  ensure
-    Warning.clear
   end
 
   def test_warning_process
-    obj = Object.new
     warn = nil
 
-    require 'warning'
-
     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)
 
@@ -106,10 +390,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|
@@ -117,10 +401,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|
@@ -128,16 +412,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)
 
@@ -146,11 +430,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)
-  ensure
-    Warning.clear
+    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.9.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-09 00:00:00.000000000 Z
-dependencies: []
+date: 2021-02-16 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,11 +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"
@@ -48,15 +69,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Add custom processing for warnings