warning 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fd71447749bdaad9176ecb3eb6302104bcaf5401516719beed80594d2fa234a
-  data.tar.gz: 18eee8db50ef702428bcfd5690c3f92d013b4b8013dd6cd28e554ff808cccbd6
+  metadata.gz: 719af8cdb41da57d07edb0fa0eac81d2bb017d5d816cadf98e600cc75e63f4aa
+  data.tar.gz: 169550daf070386f36072d01c9c36303c631b6f598cf358e0f16e786f1d4ac68
 SHA512:
-  metadata.gz: 8038062c8d96ec8eb800be734041654d3dd24a1a5ddda523c5c44f465f7cbdf3fdbaa3537e4d360ad9673effb4a54e27de544325235b0fe343ec13f6ee3ec948
-  data.tar.gz: 26324dfc9591fda0a4627d515c3b18738e55f3213c0ff76b15f7493616980c54cf3cf3b945985d460d230db69b57ccd687f2b4ac5f367feec1b1efeae72319f0
+  metadata.gz: 5ddf24399c73e0b2b747189d02972c3616482ac90c3c9e89b16b8594a1e2c6cf005b3b81bab905de6f30d3fd1882d806c8746fd317f59e6915408f80f054ee8f
+  data.tar.gz: a5f1d714b59737dd6e67ab000687783acff87c3fe5cfd85bac2828c91556a7de5637d082e82d0a34198b53580a324c69639da93e07c0436e4f648e0031c7ff00

data/CHANGELOG

@@ -1,3 +1,11 @@
+=== 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)

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,7 +2,8 @@
 
 ruby-warning adds custom processing for warnings, including the
 ability to ignore specific warning messages, ignore warnings
-in specific files/directories, deduplicate warnings, and add
+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
@@ -32,6 +33,7 @@ appropriate regexp.  The supported symbols are:
 * :fixnum
 * :keyword_separation
 * :method_redefined
+* :mismatched_indentations
 * :missing_gvar
 * :missing_ivar
 * :not_reached
@@ -47,6 +49,14 @@ 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.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
@@ -93,6 +103,23 @@ loading any code that could cause warnings.
     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
 

data/lib/warning.rb

@@ -18,8 +18,17 @@ module Warning
       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/,
     }
 
+    # 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
@@ -81,14 +90,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
 
@@ -110,7 +112,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.ignore(__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)
@@ -138,18 +185,55 @@ module Warning
         synchronize{@dedup[str] = true}
       end
 
-      synchronize{@process.dup}.each do |path, block|
-        if str.start_with?(path)
-          block.call(str)
-          return
+      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
 
-      super
+      case action
+      when :default
+        super
+      when :backtrace
+        super
+        $stderr.puts caller
+      when :raise
+        raise str
+      else
+        # nothing
+      end
+
+      nil
     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

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_warning.rb

@@ -6,8 +6,12 @@ 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
@@ -351,6 +355,18 @@ 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
@@ -414,4 +430,86 @@ class WarningTest < Minitest::Test
     assert_equal(4, warn.first)
     assert_match(/instance variable @ivar6 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(/instance variable @ivar not initialized/) do
+      ivar
+    end
+    assert_match(/instance variable @ivar not initialized/, w)
+  end
+
+  def test_warning_process_block_return_backtrace
+    w = nil
+    Warning.process(__FILE__) do |warning|
+      w = warning
+      :backtrace
+    end
+
+    assert_warning(/instance variable @ivar not initialized.*#{__FILE__}/m) do
+      ivar
+    end
+    assert_match(/instance variable @ivar 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, /instance variable @ivar not initialized/) do
+      EnvUtil.verbose_warning{ivar}
+    end
+    assert_match(/instance variable @ivar not initialized/, w)
+  end
+
+  def test_warning_process_action
+    w = nil
+    Warning.process(__FILE__, :missing_ivar=>:default, :missing_gvar=>:backtrace, :ambiguous_slash=>:raise)
+    Warning.process(__FILE__, :not_reached=>proc do |warning|
+      w = warning
+      :raise
+    end)
+
+    assert_warning(/instance variable @ivar not initialized/) do
+      ivar
+    end
+
+    assert_warning(/global variable `\$gvar' not initialized.*#{__FILE__}/m) do
+      $gvar
+    end
+
+    Warning.process(__FILE__) do |warning|
+      w = warning
+      :raise
+    end
+
+    assert_raises(RuntimeError, /warning: ambiguous first argument; put parentheses or a space even after `\/' operator/) 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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: warning
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-21 00:00:00.000000000 Z
+date: 2020-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest-global_expectations
@@ -27,8 +27,9 @@ dependencies:
 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: []
@@ -42,6 +43,7 @@ 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