rubocop 0.50.0 → 0.51.0

data/lib/rubocop/cop/lint/loop.rb

@@ -55,7 +55,7 @@ module RuboCop
         private
 
         def register_offense(node)
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
       end
     end

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -95,7 +95,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
-          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
+          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb

@@ -59,7 +59,7 @@ module RuboCop
             next if args_node.children.empty?
 
             if chained_send?(send_node)
-              add_offense(return_node, :keyword)
+              add_offense(return_node, location: :keyword)
               break
             end
           end
@@ -75,7 +75,7 @@ module RuboCop
           !return_node.children.empty?
         end
 
-        def_node_matcher :chained_send?, '(send !nil ...)'
+        def_node_matcher :chained_send?, '(send !nil? ...)'
         def_node_matcher :define_method?, <<-PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -29,8 +29,9 @@ module RuboCop
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length > 0
 
-          add_offense(nil, space_range(node.first_argument.source_range,
-                                       space_length))
+          range = space_range(node.first_argument.source_range, space_length)
+
+          add_offense(nil, location: range)
         end
 
         private

data/lib/rubocop/cop/lint/percent_string_array.rb

@@ -44,7 +44,7 @@ module RuboCop
 
         def contains_quotes_or_commas?(node)
           node.values.any? do |value|
-            literal = scrub_string(value.children.first.to_s)
+            literal = value.children.first.to_s.scrub
 
             # To avoid likely false positives (e.g. a single ' or ")
             next if literal.gsub(/[^\p{Alnum}]/, '').empty?

data/lib/rubocop/cop/lint/rand_one.rb

@@ -25,7 +25,7 @@ module RuboCop
               'Perhaps you meant `rand(2)` or `rand`?'.freeze
 
         def_node_matcher :rand_one?, <<-PATTERN
-          (send {(const nil :Kernel) nil} :rand {(int {-1 1}) (float {-1.0 1.0})})
+          (send {(const nil? :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/lint/redundant_with_index.rb

@@ -41,7 +41,7 @@ module RuboCop
 
         def on_block(node)
           redundant_with_index?(node) do |send|
-            add_offense(node, with_index_range(send))
+            add_offense(node, location: with_index_range(send))
           end
         end
 

data/lib/rubocop/cop/lint/redundant_with_object.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant `with_object`.
+      #
+      # @example
+      #   # bad
+      #   ary.each_with_object([]) do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      #   # bad
+      #   ary.each.with_object([]) do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      class RedundantWithObject < Cop
+        MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
+                               .freeze
+        MSG_WITH_OBJECT = 'Remove redundant `with_object`.'.freeze
+
+        def_node_matcher :redundant_with_object?, <<-PATTERN
+          (block
+            $(send _ {:each_with_object :with_object}
+              (_))
+            (args
+              (arg _))
+            ...)
+        PATTERN
+
+        def on_block(node)
+          redundant_with_object?(node) do |send|
+            add_offense(node, location: with_object_range(send))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            redundant_with_object?(node) do |send|
+              if send.method_name == :each_with_object
+                corrector.replace(with_object_range(send), 'each')
+              else
+                corrector.remove(with_object_range(send))
+                corrector.remove(send.loc.dot)
+              end
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          if node.method_name == :each_with_object
+            MSG_EACH_WITH_OBJECT
+          else
+            MSG_WITH_OBJECT
+          end
+        end
+
+        def with_object_range(send)
+          range_between(
+            send.loc.selector.begin_pos,
+            send.source.length
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/regexp_as_condition.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for regexp literals used as `match-current-line`.
+      # If a regexp literal is in condition, the regexp matches `$_` implicitly.
+      #
+      # @example
+      #   # bad
+      #   if /foo/
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if /foo/ =~ $_
+      #     do_something
+      #   end
+      class RegexpAsCondition < Cop
+        MSG = 'Do not use regexp literal as a condition.' \
+              ' The regexp literal matches `$_` implicitly.'.freeze
+
+        def on_match_current_line(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -47,7 +47,7 @@ module RuboCop
           range = range_between(node.source_range.begin_pos,
                                 ternary.condition.source_range.end_pos)
 
-          add_offense(range, range)
+          add_offense(range, location: range)
         end
 
         def check_predicate(predicate, node)

data/lib/rubocop/cop/lint/rescue_type.rb

@@ -48,9 +48,11 @@ module RuboCop
           invalid_exceptions = invalid_exceptions(exceptions)
           return if invalid_exceptions.empty?
 
-          add_offense(node,
-                      node.loc.keyword.join(rescued.loc.expression),
-                      format(MSG, invalid_exceptions.map(&:source).join(', ')))
+          add_offense(
+            node,
+            location: node.loc.keyword.join(rescued.loc.expression),
+            message: format(MSG, invalid_exceptions.map(&:source).join(', '))
+          )
         end
 
         private

data/lib/rubocop/cop/lint/rescue_without_error_class.rb

@@ -21,16 +21,19 @@ module RuboCop
       #     bar
       #   end
       class RescueWithoutErrorClass < Cop
+        include RescueNode
+
         MSG = 'Avoid rescuing without specifying an error class.'.freeze
 
         def_node_matcher :rescue_without_error_class?, <<-PATTERN
-          (resbody nil ...)
+          (resbody nil? _ _)
         PATTERN
 
         def on_resbody(node)
-          return unless rescue_without_error_class?(node)
+          return unless rescue_without_error_class?(node) &&
+                        !rescue_modifier?(node)
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
       end
     end

data/lib/rubocop/cop/lint/return_in_void_context.rb

@@ -33,29 +33,40 @@ module RuboCop
       #   end
       class ReturnInVoidContext < Cop
         MSG = 'Do not return a value in `%s`.'.freeze
+
         def on_return(return_node)
-          method_name = method_name(return_node)
-          return unless method_name && return_node.descendants.any? &&
-                        useless_return_method?(method_name)
+          return unless return_node.descendants.any?
+
+          context_node = non_void_context(return_node)
+
+          return unless context_node && context_node.def_type?
 
-          add_offense(return_node, :keyword, format(message, method_name))
+          method_name = method_name(context_node)
+
+          return unless method_name && void_context_method?(method_name)
+
+          add_offense(return_node,
+                      location: :keyword,
+                      message: format(message, method_name))
         end
 
         private
 
-        def method_name(return_node)
-          method_node = return_node.each_ancestor(:block, :def, :defs).first
-          return nil unless method_node.def_type?
-          method_node.children.first
+        def non_void_context(return_node)
+          return_node.each_ancestor(:block, :def, :defs).first
         end
 
-        def method_setter?(method_name)
-          method_name.to_s.end_with?('=') &&
-            !AST::Node::COMPARISON_OPERATORS.include?(method_name)
+        def method_name(context_node)
+          context_node.children.first
+        end
+
+        def void_context_method?(method_name)
+          method_name == :initialize || setter_method?(method_name)
         end
 
-        def useless_return_method?(method_name)
-          method_name == :initialize || method_setter?(method_name)
+        def setter_method?(method_name)
+          method_name.to_s.end_with?('=') &&
+            !AST::Node::COMPARISON_OPERATORS.include?(method_name)
         end
       end
     end

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -41,7 +41,7 @@ module RuboCop
 
             loc = node.loc.dot || :selector
 
-            add_offense(node, loc)
+            add_offense(node, location: loc)
           end
         end
 

data/lib/rubocop/cop/lint/script_permission.rb

@@ -15,7 +15,7 @@ module RuboCop
           return if executable?(processed_source)
           comment = processed_source.comments[0]
           message = format_message_from(processed_source)
-          add_offense(comment, :expression, message)
+          add_offense(comment, message: message)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -19,8 +19,6 @@ module RuboCop
       #     handle_standard_error
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   begin
@@ -30,6 +28,21 @@ module RuboCop
       #   rescue Exception
       #     handle_exception
       #   end
+      #
+      #   # good, however depending on runtime environment.
+      #   #
+      #   # This is a special case for system call errors.
+      #   # System dependent error code depends on runtime environment.
+      #   # For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are
+      #   # the same error code or different error code depends on environment.
+      #   # This good case is for `Errno::EAGAIN` and `Errno::EWOULDBLOCK` with
+      #   # the same error code.
+      #   begin
+      #     something
+      #   rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+      #     handle_standard_error
+      #   end
+      #
       class ShadowedException < Cop
         include RescueNode
 
@@ -51,7 +64,7 @@ module RuboCop
           return if !rescue_group_rescues_multiple_levels &&
                     sorted?(rescued_groups)
 
-          add_offense(node, offense_range(rescues))
+          add_offense(node, location: offense_range(rescues))
         end
 
         private
@@ -77,7 +90,27 @@ module RuboCop
             return !(group.size == 2 && group.include?(NilClass))
           end
 
-          group.combination(2).any? { |a, b| a && b && a <=> b }
+          group.combination(2).any? do |a, b|
+            compare_exceptions(a, b)
+          end
+        end
+
+        def compare_exceptions(exception, other_exception)
+          if system_call_err?(exception) && system_call_err?(other_exception)
+            # This condition logic is for special case.
+            # System dependent error code depends on runtime environment.
+            # For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are
+            # the same error code or different error code depends on runtime
+            # environment. This checks the error code for that.
+            exception.const_get(:Errno) != other_exception.const_get(:Errno) &&
+              exception <=> other_exception
+          else
+            exception && other_exception && exception <=> other_exception
+          end
+        end
+
+        def system_call_err?(error)
+          error && error.ancestors[1] == SystemCallError
         end
 
         def evaluate_exceptions(rescue_group)
@@ -116,12 +149,6 @@ module RuboCop
         def rescued_exceptions(rescue_group)
           klasses = *rescue_group
           klasses.map do |klass|
-            # `rescue nil` is valid syntax in all versions of Ruby. In Ruby
-            # 1.9.3, it effectively disables the `rescue`. In versions
-            # after 1.9.3, a `TypeError` is thrown when the statement is
-            # rescued. In order to account for this, we convert `nil` to
-            # `NilClass`.
-            next 'NilClass' if klass.nil_type?
             next unless klass.const_type?
             klass.source
           end.compact

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -45,7 +45,7 @@ module RuboCop
           return unless outer_local_variable
 
           message = format(MSG, variable.name)
-          add_offense(variable.declaration_node, :expression, message)
+          add_offense(variable.declaration_node, message: message)
         end
       end
     end

data/lib/rubocop/cop/lint/string_conversion_in_interpolation.rb

@@ -29,7 +29,7 @@ module RuboCop
             next unless final_node && final_node.send_type? &&
                         final_node.method?(:to_s) && !final_node.arguments?
 
-            add_offense(final_node, :selector)
+            add_offense(final_node, location: :selector)
           end
         end
 

data/lib/rubocop/cop/lint/syntax.rb

@@ -31,12 +31,18 @@ module RuboCop
           message =
             "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
             'configure using `TargetRubyVersion` parameter, under `AllCops`)'
-          add_offense(nil, diagnostic.location, message, diagnostic.level)
+          add_offense(nil,
+                      location: diagnostic.location,
+                      message: message,
+                      severity: diagnostic.level)
         end
 
         def add_offense_from_error(error)
           message = beautify_message(error.message)
-          add_offense(nil, ERROR_SOURCE_RANGE, message, :fatal)
+          add_offense(nil,
+                      location: ERROR_SOURCE_RANGE,
+                      message: message,
+                      severity: :fatal)
         end
 
         private

data/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb

@@ -54,7 +54,7 @@ module RuboCop
                        node.loc.name
                      end
 
-          add_offense(nil, location)
+          add_offense(nil, location: location)
         end
       end
     end