rubocop 0.90.0 → 0.91.0

data/lib/rubocop/cop/style/even_odd.rb

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Replace with `Integer#%<method>s?`.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
 
         def_node_matcher :even_odd_candidate?, <<~PATTERN
           (send

data/lib/rubocop/cop/style/expand_path_arguments.rb

@@ -52,6 +52,8 @@ module RuboCop
                            'instead of ' \
                            '`Pathname.new(__FILE__).parent.expand_path`.'
 
+        RESTRICT_ON_SEND = %i[expand_path].freeze
+
         def_node_matcher :file_expand_path, <<~PATTERN
           (send
             (const {nil? cbase} :File) :expand_path
@@ -75,8 +77,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.method?(:expand_path)
-
           if (current_path, default_dir = file_expand_path(node))
             inspect_offense_for_expand_path(node, current_path, default_dir)
           elsif (default_dir = pathname_parent_expand_path(node))

data/lib/rubocop/cop/style/explicit_block_argument.rb

@@ -83,7 +83,7 @@ module RuboCop
             replacement = ' &block'
             replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
             corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
-          elsif node.send_type?
+          elsif node.call_type?
             corrector.insert_after(node, '(&block)')
           else
             corrector.insert_after(node.loc.name, '(&block)')

data/lib/rubocop/cop/style/float_division.rb

@@ -48,6 +48,8 @@ module RuboCop
           fdiv: 'Prefer using `fdiv` for float divisions.'
         }.freeze
 
+        RESTRICT_ON_SEND = %i[/].freeze
+
         def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
         PATTERN

data/lib/rubocop/cop/style/format_string.rb

@@ -40,8 +40,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
-
-        FORMAT_METHODS = %i[format sprintf %].freeze
+        RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
         def_node_matcher :formatter, <<~PATTERN
           {
@@ -56,8 +55,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless FORMAT_METHODS.include?(node.method_name)
-
           formatter(node) do |selector|
             detected_style = selector == :% ? :percent : selector
 

data/lib/rubocop/cop/style/hash_as_last_array_item.rb

@@ -6,6 +6,9 @@ module RuboCop
       # Checks for presence or absence of braces around hash literal as a last
       # array item depending on configuration.
       #
+      # NOTE: This cop will ignore arrays where all items are hashes, regardless of
+      # EnforcedStyle.
+      #
       # @example EnforcedStyle: braces (default)
       #   # bad
       #   [1, 2, one: 1, two: 2]
@@ -13,6 +16,9 @@ module RuboCop
       #   # good
       #   [1, 2, { one: 1, two: 2 }]
       #
+      #   # good
+      #   [{ one: 1 }, { two: 2 }]
+      #
       # @example EnforcedStyle: no_braces
       #   # bad
       #   [1, 2, { one: 1, two: 2 }]
@@ -20,6 +26,8 @@ module RuboCop
       #   # good
       #   [1, 2, one: 1, two: 2]
       #
+      #   # good
+      #   [{ one: 1 }, { two: 2 }]
       class HashAsLastArrayItem < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -38,9 +46,10 @@ module RuboCop
 
         def last_array_item?(node)
           parent = node.parent
-          return false unless parent
+          return false unless parent&.array_type?
+          return false if parent.child_nodes.all?(&:hash_type?)
 
-          parent.array_type? && parent.children.last.equal?(node)
+          parent.children.last.equal?(node)
         end
 
         def check_braces(node)
@@ -53,6 +62,7 @@ module RuboCop
 
         def check_no_braces(node)
           return unless node.braces?
+          return if node.children.empty? # Empty hash cannot be "unbraced"
 
           add_offense(node, message: 'Omit the braces around the hash.') do |corrector|
             corrector.remove(node.loc.begin)

data/lib/rubocop/cop/style/hash_transform_keys.rb

@@ -34,15 +34,13 @@ module RuboCop
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend}
-              !{(send _ :each_with_index) (array ...)}
-              :each_with_object (hash))
+            ({send csend} !#array_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg $_)
                 (arg _val))
               (arg _memo))
-            ({send csend} (lvar _memo) :[]= $_ $(lvar _val)))
+            ({send csend} (lvar _memo) :[]= $!`_memo $(lvar _val)))
         PATTERN
 
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
@@ -50,7 +48,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              ({send csend} !(send _ :each_with_index) {:map :collect})
+              ({send csend} !#array_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -60,9 +58,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
-              ({send csend}
-                !{(send _ :each_with_index) (array ...)}
-                {:map :collect})
+              ({send csend} !#array_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -72,9 +68,7 @@ module RuboCop
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend}
-              !{(send _ :each_with_index) (array ...)}
-              :to_h)
+            ({send csend} !#array_receiver? :to_h)
             (args
               (arg $_)
               (arg _val))

data/lib/rubocop/cop/style/hash_transform_values.rb

@@ -31,15 +31,13 @@ module RuboCop
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend}
-              !{(send _ :each_with_index) (array ...)}
-              :each_with_object (hash))
+            ({send csend} !#array_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg _key)
                 (arg $_))
               (arg _memo))
-            ({send csend} (lvar _memo) :[]= $(lvar _key) $_))
+            ({send csend} (lvar _memo) :[]= $(lvar _key) $!`_memo))
         PATTERN
 
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
@@ -47,7 +45,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              ({send csend} !(send _ :each_with_index) {:map :collect})
+              ({send csend} !#array_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -57,9 +55,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
-              ({send csend}
-                !{(send _ :each_with_index) (array ...)}
-                 {:map :collect})
+              ({send csend} !#array_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -69,9 +65,7 @@ module RuboCop
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend}
-              !{(send _ :each_with_index) (array ...)}
-              :to_h)
+            ({send csend} !#array_receiver? :to_h)
             (args
               (arg _key)
               (arg $_))

data/lib/rubocop/cop/style/implicit_runtime_error.rb

@@ -17,6 +17,7 @@ module RuboCop
       class ImplicitRuntimeError < Base
         MSG = 'Use `%<method>s` with an explicit exception class and message,' \
               ' rather than just a message.'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         def_node_matcher :implicit_runtime_error_raise_or_fail,
                          '(send nil? ${:raise :fail} {str dstr})'

data/lib/rubocop/cop/style/lambda_call.rb

@@ -22,8 +22,10 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
+        RESTRICT_ON_SEND = %i[call].freeze
+
         def on_send(node)
-          return unless node.receiver && node.method?(:call)
+          return unless node.receiver
 
           if offense?(node) && opposite_style_detected
             add_offense(node) do |corrector|

data/lib/rubocop/cop/style/mixin_usage.rb

@@ -43,6 +43,7 @@ module RuboCop
       class MixinUsage < Base
         MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
               'or `module`.'
+        RESTRICT_ON_SEND = %i[include extend prepend].freeze
 
         def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}

data/lib/rubocop/cop/style/multiline_ternary_operator.rb

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # This cop checks for multi-line ternary op expressions.
       #
+      # NOTE: `return if ... else ... end` is syntax error. If `return` is used before
+      # multiline ternary operator expression, it cannot be auto-corrected.
+      #
       # @example
       #   # bad
       #   a = cond ?
@@ -29,9 +32,13 @@ module RuboCop
               'use `if` or `unless` instead.'
 
         def on_if(node)
-          return unless node.ternary? && node.multiline?
+          return unless offense?(node)
 
           add_offense(node) do |corrector|
+            # `return if ... else ... end` is syntax error. If `return` is used before
+            # multiline ternary operator expression, it cannot be auto-corrected.
+            next unless offense?(node) && !node.parent.return_type?
+
             corrector.replace(node, <<~RUBY.chop)
               if #{node.condition.source}
                 #{node.if_branch.source}
@@ -41,6 +48,12 @@ module RuboCop
             RUBY
           end
         end
+
+        private
+
+        def offense?(node)
+          node.ternary? && node.multiline?
+        end
       end
     end
   end

data/lib/rubocop/cop/style/nil_comparison.rb

@@ -35,6 +35,8 @@ module RuboCop
         PREDICATE_MSG = 'Prefer the use of the `nil?` predicate.'
         EXPLICIT_MSG = 'Prefer the use of the `==` comparison.'
 
+        RESTRICT_ON_SEND = %i[== === nil?].freeze
+
         def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
         def_node_matcher :nil_check?, '(send _ :nil?)'
 

data/lib/rubocop/cop/style/non_nil_check.rb

@@ -41,6 +41,8 @@ module RuboCop
       class NonNilCheck < Base
         extend AutoCorrector
 
+        RESTRICT_ON_SEND = %i[!= nil? !].freeze
+
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
         def_node_matcher :nil_check?, '(send _ :nil?)'

data/lib/rubocop/cop/style/not.rb

@@ -18,6 +18,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `!` instead of `not`.'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         OPPOSITE_METHODS = {
           :== => :!=,

data/lib/rubocop/cop/style/numeric_predicate.rb

@@ -54,11 +54,9 @@ module RuboCop
           'negative?' => '<'
         }.freeze
 
-        COMPARISON_METHODS = %i[== > < positive? negative? zero?].to_set.freeze
+        RESTRICT_ON_SEND = %i[== > < positive? negative? zero?].freeze
 
         def on_send(node)
-          return unless COMPARISON_METHODS.include?(node.method_name)
-
           numeric, replacement = check(node)
           return unless numeric
 

data/lib/rubocop/cop/style/preferred_hash_methods.rb

@@ -36,6 +36,8 @@ module RuboCop
           verbose: %i[key? value?]
         }.freeze
 
+        RESTRICT_ON_SEND = OFFENDING_SELECTORS.values.flatten.freeze
+
         def on_send(node)
           return unless node.arguments.one? && offending_selector?(node.method_name)
 

data/lib/rubocop/cop/style/raise_args.rb

@@ -41,6 +41,8 @@ module RuboCop
         COMPACT_MSG = 'Provide an exception object ' \
           'as an argument to `%<method>s`.'
 
+        RESTRICT_ON_SEND = %i[raise fail].freeze
+
         def on_send(node)
           return unless node.command?(:raise) || node.command?(:fail)
 

data/lib/rubocop/cop/style/random_with_offset.rb

@@ -28,6 +28,7 @@ module RuboCop
 
         MSG = 'Prefer ranges when generating random numbers instead of ' \
           'integers with offsets.'
+        RESTRICT_ON_SEND = %i[+ - succ pred next].freeze
 
         def_node_matcher :integer_op_rand?, <<~PATTERN
           (send

data/lib/rubocop/cop/style/redundant_exception.rb

@@ -23,13 +23,11 @@ module RuboCop
         MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
                 'just the message.'
 
-        RAISE_METHODS = %i[raise fail].freeze
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
         # `raise RuntimeError.new('message')` to `raise 'message'`.
         def on_send(node)
-          return unless RAISE_METHODS.include?(node.method_name)
-
           fix_exploded(node) || fix_compact(node)
         end
 

data/lib/rubocop/cop/style/redundant_file_extension_in_require.rb

@@ -28,6 +28,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant `.rb` file extension detected.'
+        RESTRICT_ON_SEND = %i[require require_relative].freeze
 
         def_node_matcher :require_call?, <<~PATTERN
           (send nil? {:require :require_relative} $str_type?)

data/lib/rubocop/cop/style/redundant_freeze.rb

@@ -17,9 +17,10 @@ module RuboCop
 
         MSG = 'Do not freeze immutable objects, as freezing them has no ' \
               'effect.'
+        RESTRICT_ON_SEND = %i[freeze].freeze
 
         def on_send(node)
-          return unless node.receiver && node.method?(:freeze) &&
+          return unless node.receiver &&
                         (immutable_literal?(node.receiver) ||
                          operation_produces_immutable_object?(node.receiver))
 

data/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -26,9 +26,7 @@ module RuboCop
                          '^^(block (send _ _ equal?(%0) ...) ...)'
 
         def on_begin(node)
-          return if !parentheses?(node) || parens_allowed?(node)
-          return if node.parent && (node.parent.while_post_type? ||
-                                    node.parent.until_post_type?)
+          return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
 
           check(node)
         end
@@ -42,6 +40,13 @@ module RuboCop
             allowed_expression?(node)
         end
 
+        def ignore_syntax?(node)
+          return false unless (parent = node.parent)
+
+          parent.while_post_type? || parent.until_post_type? ||
+            like_method_argument_parentheses?(parent)
+        end
+
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
@@ -68,6 +73,10 @@ module RuboCop
           !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
         end
 
+        def like_method_argument_parentheses?(node)
+          node.send_type? && node.arguments.size == 1 && !node.arithmetic_operation?
+        end
+
         def empty_parentheses?(node)
           # Don't flag `()`
           node.children.empty?

data/lib/rubocop/cop/style/redundant_self_assignment.rb

@@ -37,8 +37,8 @@ module RuboCop
         METHODS_RETURNING_SELF = %i[
           append clear collect! compare_by_identity concat delete_if
           fill initialize_copy insert keep_if map! merge! prepend push
-          rehash replace reverse! rotate! shuffle! sort! sort_by! to_ary
-          to_hash transform_keys! transform_values! unshift update
+          rehash replace reverse! rotate! shuffle! sort! sort_by!
+          transform_keys! transform_values! unshift update
         ].to_set.freeze
 
         ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = {

data/lib/rubocop/cop/style/redundant_sort.rb

@@ -55,7 +55,7 @@ module RuboCop
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
-        SORT_METHODS = %i[sort sort_by].freeze
+        RESTRICT_ON_SEND = %i[sort sort_by].freeze
 
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
@@ -74,8 +74,6 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          return unless sort_method?(node)
-
           if (sort_node, sorter, accessor = redundant_sort?(node.parent))
             ancestor = node.parent
           elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
@@ -113,10 +111,6 @@ module RuboCop
 
         private
 
-        def sort_method?(node)
-          SORT_METHODS.include?(node.method_name)
-        end
-
         def offense_range(sort_node, ancestor)
           range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
         end