rubocop 0.89.1 → 0.93.0

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

@@ -42,6 +42,8 @@ module RuboCop
       #   # good
       #   something.to_time
       class DateTime < Base
+        extend AutoCorrector
+
         CLASS_MSG = 'Prefer Time over DateTime.'
         COERCION_MSG = 'Do not use #to_datetime.'
 
@@ -63,7 +65,10 @@ module RuboCop
           return if historic_date?(node)
 
           message = to_datetime?(node) ? COERCION_MSG : CLASS_MSG
-          add_offense(node, message: message)
+
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         private
@@ -71,6 +76,12 @@ module RuboCop
         def disallow_coercion?
           !cop_config['AllowCoercion']
         end
+
+        def autocorrect(corrector, node)
+          return if to_datetime?(node)
+
+          corrector.replace(node.receiver.loc.name, 'Time')
+        end
       end
     end
   end

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

@@ -20,6 +20,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = "Use `__dir__` to get an absolute path to the current file's directory."
+        RESTRICT_ON_SEND = %i[expand_path dirname].freeze
 
         def_node_matcher :dir_replacement?, <<~PATTERN
           {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))

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

@@ -36,6 +36,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MSG = 'Avoid the use of double negation (`!!`).'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 

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

@@ -21,9 +21,10 @@ module RuboCop
       #
       #   # good
       #   a { do_something }
-      class EmptyBlockParameter < Cop
+      class EmptyBlockParameter < Base
         include EmptyParameter
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Omit pipes for the empty block parameters.'
 
@@ -32,15 +33,13 @@ module RuboCop
           check(node) unless send_node.send_type? && send_node.lambda_literal?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            block = node.parent
-            range = range_between(
-              block.loc.begin.end_pos,
-              node.loc.expression.end_pos
-            )
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          block = node.parent
+          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
+
+          corrector.remove(range)
         end
       end
     end

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

@@ -16,9 +16,10 @@ module RuboCop
       #
       #   # good
       #   -> (arg) { do_something(arg) }
-      class EmptyLambdaParameter < Cop
+      class EmptyLambdaParameter < Base
         include EmptyParameter
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
@@ -29,15 +30,13 @@ module RuboCop
           check(node) if node.send_node.lambda_literal?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            send_node = node.parent.send_node
-            range = range_between(
-              send_node.loc.expression.end_pos,
-              node.loc.expression.end_pos
-            )
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          send_node = node.parent.send_node
+          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+
+          corrector.remove(range)
         end
       end
     end

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

@@ -25,6 +25,8 @@ module RuboCop
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
         STR_MSG = 'Use string literal `%<prefer>s` instead of `String.new`.'
 
+        RESTRICT_ON_SEND = %i[new].freeze
+
         def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
         def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
@@ -69,7 +71,7 @@ module RuboCop
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.object_id == parent.arguments.first.object_id &&
+          node.equal?(parent.arguments.first) &&
             !parentheses?(node.parent)
         end
 

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

@@ -37,7 +37,7 @@ module RuboCop
         MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
                              'as they are used by backtraces.'
 
-        EVAL_METHODS = %i[eval class_eval module_eval instance_eval].to_set.freeze
+        RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
 
         def_node_matcher :eval_without_location?, <<~PATTERN
           {
@@ -63,8 +63,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless EVAL_METHODS.include?(node.method_name)
-
           eval_without_location?(node) do |code|
             if with_lineno?(node)
               on_with_lineno(node, code)

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

@@ -57,12 +57,16 @@ module RuboCop
           yielding_block?(block_node) do |send_node, block_args, yield_args|
             return unless yielding_arguments?(block_args, yield_args)
 
+            def_node = block_node.each_ancestor(:def, :defs).first
+            # if `yield` is being called outside of a method context, ignore
+            # this is not a valid ruby pattern, but can happen in haml or erb,
+            # so this can cause crashes in haml_lint
+            return unless def_node
+
             add_offense(block_node) do |corrector|
               corrector.remove(block_body_range(block_node, send_node))
 
               add_block_argument(send_node, corrector)
-
-              def_node = block_node.each_ancestor(:def, :defs).first
               add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
             end
           end
@@ -83,7 +87,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/for.rb

@@ -49,8 +49,6 @@ module RuboCop
 
         def on_for(node)
           if style == :each
-            return unless opposite_style_detected
-
             add_offense(node, message: PREFER_EACH) do |corrector|
               ForToEachCorrector.new(node).call(corrector)
             end
@@ -63,8 +61,6 @@ module RuboCop
           return unless suspect_enumerable?(node)
 
           if style == :for
-            return unless opposite_style_detected
-
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
             end

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/format_string_token.rb

@@ -33,7 +33,7 @@ module RuboCop
       #
       #   # bad
       #   format('%<greeting>s', greeting: 'Hello')
-      #   format('%{greeting}', 'Hello')
+      #   format('%{greeting}', greeting: 'Hello')
       #
       #   # good
       #   format('%s', 'Hello')

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

@@ -17,6 +17,7 @@ module RuboCop
       #   # good
       #   def test
       #     return unless something
+      #
       #     work
       #   end
       #

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,12 +26,15 @@ module RuboCop
       #   # good
       #   [1, 2, one: 1, two: 2]
       #
+      #   # good
+      #   [{ one: 1 }, { two: 2 }]
       class HashAsLastArrayItem < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
         def on_hash(node)
-          return unless last_array_item?(node)
+          return unless (array = containing_array(node))
+          return unless last_array_item?(array, node) && explicit_array?(array)
 
           if braces_style?
             check_braces(node)
@@ -36,11 +45,20 @@ module RuboCop
 
         private
 
-        def last_array_item?(node)
-          parent = node.parent
-          return false unless parent
+        def containing_array(hash_node)
+          parent = hash_node.parent
+          parent if parent&.array_type?
+        end
+
+        def last_array_item?(array, node)
+          return false if array.child_nodes.all?(&:hash_type?)
+
+          array.children.last.equal?(node)
+        end
 
-          parent.array_type? && parent.children.last.equal?(node)
+        def explicit_array?(array)
+          # an implicit array cannot have an "unbraced" hash
+          array.square_brackets?
         end
 
         def check_braces(node)
@@ -53,6 +71,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_syntax.rb

@@ -140,11 +140,12 @@ module RuboCop
         def acceptable_19_syntax_symbol?(sym_name)
           sym_name.sub!(/\A:/, '')
 
-          if cop_config['PreferHashRocketsForNonAlnumEndingSymbols']
-            # Prefer { :production? => false } over { production?: false } and
-            # similarly for other non-alnum final characters (except quotes,
-            # to prefer { "x y": 1 } over { :"x y" => 1 }).
-            return false unless /[\p{Alnum}"']\z/.match?(sym_name)
+          if cop_config['PreferHashRocketsForNonAlnumEndingSymbols'] &&
+             # Prefer { :production? => false } over { production?: false } and
+             # similarly for other non-alnum final characters (except quotes,
+             # to prefer { "x y": 1 } over { :"x y" => 1 }).
+             !/[\p{Alnum}"']\z/.match?(sym_name)
+            return false
           end
 
           # Most hash keys can be matched against a simple regex.

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

@@ -18,7 +18,9 @@ module RuboCop
       # @example
       #   # bad
       #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[foo(k)] = v }
-      #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }
+      #   Hash[{a: 1, b: 2}.collect { |k, v| [foo(k), v] }]
+      #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h
+      #   {a: 1, b: 2}.to_h { |k, v| [k.to_s, v] }
       #
       #   # good
       #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
@@ -32,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
@@ -48,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))
@@ -58,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))
@@ -68,6 +66,15 @@ module RuboCop
             :to_h)
         PATTERN
 
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            ({send csend} !#array_receiver? :to_h)
+            (args
+              (arg $_)
+              (arg _val))
+            (array $_ $(lvar _val)))
+        PATTERN
+
         private
 
         def extract_captures(match)

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

@@ -18,7 +18,9 @@ module RuboCop
       # @example
       #   # bad
       #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
-      #   {a: 1, b: 2}.map { |k, v| [k, v * v] }
+      #   Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }]
+      #   {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h
+      #   {a: 1, b: 2}.to_h { |k, v| [k, v * v] }
       #
       #   # good
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
@@ -29,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
@@ -45,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 $_))
@@ -55,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 $_))
@@ -65,6 +63,15 @@ module RuboCop
             :to_h)
         PATTERN
 
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            ({send csend} !#array_receiver? :to_h)
+            (args
+              (arg _key)
+              (arg $_))
+            (array $(lvar _key) $_))
+        PATTERN
+
         private
 
         def extract_captures(match)