rubocop 1.9.1 → 1.22.3

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

@@ -5,14 +5,22 @@ module RuboCop
     module Style
       # This cop is designed to help you transition from mutable string literals
       # to frozen string literals.
-      # It will add the comment `# frozen_string_literal: true` to the top of
-      # files to enable frozen string literals. Frozen string literals may be
+      # It will add the `# frozen_string_literal: true` magic comment to the top
+      # of files to enable frozen string literals. Frozen string literals may be
       # default in future Ruby. The comment will be added below a shebang and
       # encoding comment.
       #
-      # Note that the cop will ignore files where the comment exists but is set
+      # Note that the cop will accept files where the comment exists but is set
       # to `false` instead of `true`.
       #
+      # To require a blank line after this comment, please see
+      # `Layout/EmptyLineAfterMagicComment` cop.
+      #
+      # @safety
+      #  This cop's autocorrection is unsafe since any strings mutations will
+      #  change from being accepted to raising `FrozenError`, as all strings
+      #  will become frozen by default, and will need to be manually refactored.
+      #
       # @example EnforcedStyle: always (default)
       #   # The `always` style will always add the frozen string literal comment
       #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
@@ -79,8 +87,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: '\
-                           'true`.'
+        MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: true`.'
         MSG_MISSING = 'Missing frozen string literal comment.'
         MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'
         MSG_DISABLED = 'Frozen string literal comment must be set to `true`.'
@@ -139,24 +146,20 @@ module RuboCop
 
         def frozen_string_literal_comment(processed_source)
           processed_source.find_token do |token|
-            token.text.start_with?(FrozenStringLiteral::FROZEN_STRING_LITERAL)
+            token.text.start_with?(FROZEN_STRING_LITERAL)
           end
         end
 
         def missing_offense(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(range, message: MSG_MISSING) do |corrector|
-            insert_comment(corrector)
-          end
+          add_offense(range, message: MSG_MISSING) { |corrector| insert_comment(corrector) }
         end
 
         def missing_true_offense(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(range, message: MSG_MISSING_TRUE) do |corrector|
-            insert_comment(corrector)
-          end
+          add_offense(range, message: MSG_MISSING_TRUE) { |corrector| insert_comment(corrector) }
         end
 
         def unnecessary_comment_offense(processed_source)

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

@@ -8,6 +8,10 @@ module RuboCop
       # reassign (possibly to redirect some stream) constants in Ruby, you'll get
       # an interpreter warning if you do so.
       #
+      # @safety
+      #   Autocorrection is unsafe because `STDOUT` and `$stdout` may point to different
+      #   objects, for example.
+      #
       # @example
       #   # bad
       #   STDOUT.puts('hello')
@@ -34,6 +38,7 @@ module RuboCop
 
         STD_STREAMS = %i[STDIN STDOUT STDERR].to_set.freeze
 
+        # @!method const_to_gvar_assignment?(node, name)
         def_node_matcher :const_to_gvar_assignment?, <<~PATTERN
           (gvasgn %1 (const nil? _))
         PATTERN

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

@@ -99,12 +99,9 @@ module RuboCop
 
         def register_offense(node, scope_exiting_keyword, conditional_keyword)
           condition, = node.node_parts
-          example = [scope_exiting_keyword,
-                     conditional_keyword,
-                     condition.source].join(' ')
+          example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
           if too_long_for_single_line?(node, example)
-            example = "#{conditional_keyword} #{condition.source}; " \
-                      "#{scope_exiting_keyword}; end"
+            example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
           end
 
           add_offense(node.loc.keyword, message: format(MSG, example: example))
@@ -126,8 +123,7 @@ module RuboCop
         end
 
         def accepted_form?(node, ending: false)
-          accepted_if?(node, ending) || node.condition.multiline? ||
-            node.parent&.assignment?
+          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
         end
 
         def accepted_if?(node, ending)

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

@@ -29,6 +29,7 @@ module RuboCop
       #   # good
       #   [{ one: 1 }, { two: 2 }]
       class HashAsLastArrayItem < Base
+        include RangeHelp
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
@@ -74,6 +75,7 @@ module RuboCop
           return if node.children.empty? # Empty hash cannot be "unbraced"
 
           add_offense(node, message: 'Omit the braces around the hash.') do |corrector|
+            remove_last_element_trailing_comma(corrector, node.parent)
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end
@@ -82,6 +84,15 @@ module RuboCop
         def braces_style?
           style == :braces
         end
+
+        def remove_last_element_trailing_comma(corrector, node)
+          range = range_with_surrounding_space(
+            range: node.children.last.source_range,
+            side: :right
+          ).end.resize(1)
+
+          corrector.remove(range) if range.source == ','
+        end
       end
     end
   end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the usage of pre-2.1 `Hash[args]` method of converting enumerables and
+      # sequences of values to hashes.
+      #
+      # Correction code from splat argument (`Hash[*ary]`) is not simply determined. For example,
+      # `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated.
+      # So, `AllowSplatArgument` option is true by default to allow splat argument for simple code.
+      #
+      # @example
+      #   # bad
+      #   Hash[ary]
+      #
+      #   # good
+      #   ary.to_h
+      #
+      #   # bad
+      #   Hash[key1, value1, key2, value2]
+      #
+      #   # good
+      #   {key1 => value1, key2 => value2}
+      #
+      # @example AllowSplatArgument: true (default)
+      #   # good
+      #   Hash[*ary]
+      #
+      # @example AllowSplatArgument: false
+      #   # bad
+      #   Hash[*ary]
+      #
+      class HashConversion < Base
+        extend AutoCorrector
+
+        MSG_TO_H = 'Prefer ary.to_h to Hash[ary].'
+        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to Hash[arg1, arg2, ...].'
+        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to Hash[key: value, ...].'
+        MSG_SPLAT = 'Prefer array_of_pairs.to_h to Hash[*array].'
+        RESTRICT_ON_SEND = %i[[]].freeze
+
+        # @!method hash_from_array?(node)
+        def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
+
+        def on_send(node)
+          return unless hash_from_array?(node)
+
+          # There are several cases:
+          # If there is one argument:
+          #   Hash[ary] => ary.to_h
+          #   Hash[*ary] => don't suggest corrections
+          # If there is 0 or 2+ arguments:
+          #   Hash[a1, a2, a3, a4] => {a1 => a2, a3 => a4}
+          #   ...but don't suggest correction if there is odd number of them (it is a bug)
+          node.arguments.count == 1 ? single_argument(node) : multi_argument(node)
+        end
+
+        private
+
+        def single_argument(node)
+          first_argument = node.first_argument
+          if first_argument.hash_type?
+            register_offense_for_hash(node, first_argument)
+          elsif first_argument.splat_type?
+            add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
+          elsif use_zip_method_without_argument?(first_argument)
+            register_offense_for_zip_method(node, first_argument)
+          else
+            add_offense(node, message: MSG_TO_H) do |corrector|
+              replacement = first_argument.source
+              replacement = "(#{replacement})" if requires_parens?(first_argument)
+              corrector.replace(node, "#{replacement}.to_h")
+            end
+          end
+        end
+
+        def use_zip_method_without_argument?(first_argument)
+          return false unless first_argument&.send_type?
+
+          first_argument.method?(:zip) && first_argument.arguments.empty?
+        end
+
+        def register_offense_for_hash(node, hash_argument)
+          add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
+            corrector.replace(node, "{#{hash_argument.source}}")
+
+            parent = node.parent
+            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+          end
+        end
+
+        def register_offense_for_zip_method(node, zip_method)
+          add_offense(node, message: MSG_TO_H) do |corrector|
+            if zip_method.parenthesized?
+              corrector.insert_before(zip_method.loc.end, '[]')
+            else
+              corrector.insert_after(zip_method, '([])')
+            end
+          end
+        end
+
+        def requires_parens?(node)
+          node.call_type? && node.arguments.any? && !node.parenthesized?
+        end
+
+        def multi_argument(node)
+          if node.arguments.count.odd?
+            add_offense(node, message: MSG_LITERAL_MULTI_ARG)
+          else
+            add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
+              corrector.replace(node, args_to_hash(node.arguments))
+
+              parent = node.parent
+              add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+            end
+          end
+        end
+
+        def args_to_hash(args)
+          content = args.each_slice(2)
+                        .map { |arg1, arg2| "#{arg1.source} => #{arg2.source}" }
+                        .join(', ')
+          "{#{content}}"
+        end
+
+        def allowed_splat_argument?
+          cop_config.fetch('AllowSplatArgument', true)
+        end
+      end
+    end
+  end
+end

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

@@ -9,6 +9,11 @@ module RuboCop
       #   parentheses around the block arguments to indicate that you're not
       #   working with a hash, and suppress RuboCop offenses.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash`. The `AllowedReceivers` configuration can mitigate,
+      #   but not fully resolve, this safety issue.
+      #
       # @example
       #   # bad
       #   hash.keys.each { |k| p k }
@@ -17,12 +22,18 @@ module RuboCop
       #   # good
       #   hash.each_key { |k| p k }
       #   hash.each_value { |v| p v }
+      #
+      # @example AllowedReceivers: ['execute']
+      #   # good
+      #   execute(sql).keys.each { |v| p v }
+      #   execute(sql).values.each { |v| p v }
       class HashEachMethods < Base
         include Lint::UnusedArgument
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
+        # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
           (block $(send (send _ ${:keys :values}) :each) ...)
         PATTERN
@@ -35,10 +46,11 @@ module RuboCop
 
         def register_kv_offense(node)
           kv_each(node) do |target, method|
-            return unless target.receiver.receiver
+            parent_receiver = target.receiver.receiver
+            return unless parent_receiver
+            return if allowed_receiver?(parent_receiver)
 
-            msg = format(message, prefer: "each_#{method[0..-2]}",
-                                  current: "#{method}.each")
+            msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
 
             add_offense(kv_range(target), message: msg) do |corrector|
               correct_key_value_each(target, corrector)
@@ -80,6 +92,16 @@ module RuboCop
         def kv_range(outer_node)
           outer_node.receiver.loc.selector.join(outer_node.loc.selector)
         end
+
+        def allowed_receiver?(receiver)
+          receiver_name = receiver.send_type? ? receiver.method_name.to_s : receiver.source
+
+          allowed_receivers.include?(receiver_name)
+        end
+
+        def allowed_receivers
+          cop_config.fetch('AllowedReceivers', [])
+        end
       end
     end
   end

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

@@ -33,6 +33,7 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead.'
         RESTRICT_ON_SEND = %i[reject select filter].freeze
 
+        # @!method bad_method?(node)
         def_node_matcher :bad_method?, <<~PATTERN
           (block
             (send _ _)
@@ -48,7 +49,7 @@ module RuboCop
           return unless bad_method?(block) && semantically_except_method?(node, block)
 
           except_key = except_key(block)
-          return unless safe_to_register_offense?(block, except_key)
+          return if except_key.nil? || !safe_to_register_offense?(block, except_key)
 
           range = offense_range(node)
           preferred_method = "except(#{except_key.source})"
@@ -80,10 +81,11 @@ module RuboCop
         end
 
         def except_key(node)
-          key_argument = node.argument_list.first
+          key_argument = node.argument_list.first.source
           lhs, _method_name, rhs = *node.body
+          return if [lhs, rhs].map(&:source).none?(key_argument)
 
-          [lhs, rhs].find { |operand| operand.source != key_argument.source }
+          [lhs, rhs].find { |operand| operand.source != key_argument }
         end
 
         def offense_range(node)

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

@@ -39,6 +39,7 @@ module RuboCop
       class HashLikeCase < Base
         MSG = 'Consider replacing `case-when` with a hash lookup.'
 
+        # @!method hash_like_case?(node)
         def_node_matcher :hash_like_case?, <<~PATTERN
           (case
             _
@@ -51,8 +52,7 @@ module RuboCop
           return if node.when_branches.size < min_branches_count
 
           hash_like_case?(node) do |condition_nodes, body_nodes|
-            if nodes_of_same_type?(condition_nodes) &&
-               nodes_of_same_type?(body_nodes)
+            if nodes_of_same_type?(condition_nodes) && nodes_of_same_type?(body_nodes)
               add_offense(node)
             end
           end

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

@@ -54,9 +54,10 @@ module RuboCop
       #   # good
       #   {a: 1, b: 2}
       #   {:c => 3, 'd' => 4}
-      class HashSyntax < Cop
+      class HashSyntax < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
         MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash."
@@ -73,7 +74,7 @@ module RuboCop
             ruby19_no_mixed_keys_check(pairs)
           elsif style == :no_mixed_keys
             no_mixed_keys_check(pairs)
-          elsif node.source.include?('=>')
+          else
             ruby19_check(pairs)
           end
         end
@@ -104,18 +105,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
-              autocorrect_hash_rockets(corrector, node)
-            elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
-              autocorrect_no_mixed_keys(corrector, node)
-            else
-              autocorrect_ruby19(corrector, node)
-            end
-          end
-        end
-
         def alternative_style
           case style
           when :hash_rockets
@@ -127,6 +116,16 @@ module RuboCop
 
         private
 
+        def autocorrect(corrector, node)
+          if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
+            autocorrect_hash_rockets(corrector, node)
+          elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
+            autocorrect_no_mixed_keys(corrector, node)
+          else
+            autocorrect_ruby19(corrector, node)
+          end
+        end
+
         def sym_indices?(pairs)
           pairs.all? { |p| word_symbol_pair?(p) }
         end
@@ -138,7 +137,7 @@ module RuboCop
         end
 
         def acceptable_19_syntax_symbol?(sym_name)
-          sym_name.sub!(/\A:/, '')
+          sym_name.delete_prefix!(':')
 
           if cop_config['PreferHashRocketsForNonAlnumEndingSymbols'] &&
              # Prefer { :production? => false } over { production?: false } and
@@ -152,14 +151,16 @@ module RuboCop
           return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
           # For more complicated hash keys, let the parser validate the syntax.
-          parse("{ #{sym_name}: :foo }").valid_syntax?
+          ProcessedSource.new("{ #{sym_name}: :foo }", target_ruby_version).valid_syntax?
         end
 
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.delimiter == delim
               location = pair.source_range.begin.join(pair.loc.operator)
-              add_offense(pair, location: location, message: msg) do
+              add_offense(location, message: msg) do |corrector|
+                autocorrect(corrector, pair)
+
                 opposite_style_detected
               end
             else
@@ -173,10 +174,7 @@ module RuboCop
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''
 
-          corrector.replace(
-            range,
-            range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: ")
-          )
+          corrector.replace(range, range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: "))
 
           hash_node = pair_node.parent
           return unless hash_node.parent&.return_type? && !hash_node.braces?
@@ -193,8 +191,7 @@ module RuboCop
         end
 
         def argument_without_space?(node)
-          node.argument? &&
-            node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+          node.argument? && node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
@@ -214,8 +211,7 @@ module RuboCop
         end
 
         def force_hash_rockets?(pairs)
-          cop_config['UseHashRocketsWithSymbolValues'] &&
-            pairs.map(&:value).any?(&:sym_type?)
+          cop_config['UseHashRocketsWithSymbolValues'] && pairs.map(&:value).any?(&:sym_type?)
         end
       end
     end

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

@@ -8,12 +8,10 @@ module RuboCop
       # transforming the keys of a hash, and tries to use a simpler & faster
       # call to `transform_keys` instead.
       #
-      # This can produce false positives if we are transforming an enumerable
-      # of key-value-like pairs that isn't actually a hash, e.g.:
-      # `[[k1, v1], [k2, v2], ...]`
-      #
-      # This cop should only be enabled on Ruby version 2.5 or newer
-      # (`transform_keys` was added in Ruby 2.5.)
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if we are
+      #   transforming an enumerable of key-value-like pairs that isn't actually
+      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
       #
       # @example
       #   # bad
@@ -27,11 +25,9 @@ module RuboCop
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
       class HashTransformKeys < Base
         include HashTransformMethod
-        extend TargetRubyVersion
         extend AutoCorrector
 
-        minimum_target_ruby_version 2.5
-
+        # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :each_with_object (hash))
@@ -43,6 +39,7 @@ module RuboCop
             ({send csend} (lvar _memo) :[]= $!`_memo $(lvar _val)))
         PATTERN
 
+        # @!method on_bad_hash_brackets_map(node)
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
             (const _ :Hash)
@@ -55,6 +52,7 @@ module RuboCop
               (array $_ $(lvar _val))))
         PATTERN
 
+        # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
@@ -66,6 +64,7 @@ module RuboCop
             :to_h)
         PATTERN
 
+        # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :to_h)

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

@@ -8,12 +8,10 @@ module RuboCop
       # transforming the values of a hash, and tries to use a simpler & faster
       # call to `transform_values` instead.
       #
-      # This can produce false positives if we are transforming an enumerable
-      # of key-value-like pairs that isn't actually a hash, e.g.:
-      # `[[k1, v1], [k2, v2], ...]`
-      #
-      # This cop should only be enabled on Ruby version 2.4 or newer
-      # (`transform_values` was added in Ruby 2.4.)
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if we are
+      #   transforming an enumerable of key-value-like pairs that isn't actually
+      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
       #
       # @example
       #   # bad
@@ -29,6 +27,7 @@ module RuboCop
         include HashTransformMethod
         extend AutoCorrector
 
+        # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :each_with_object (hash))
@@ -40,6 +39,7 @@ module RuboCop
             ({send csend} (lvar _memo) :[]= $(lvar _key) $!`_memo))
         PATTERN
 
+        # @!method on_bad_hash_brackets_map(node)
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
             (const _ :Hash)
@@ -52,6 +52,7 @@ module RuboCop
               (array $(lvar _key) $_)))
         PATTERN
 
+        # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
@@ -63,6 +64,7 @@ module RuboCop
             :to_h)
         PATTERN
 
+        # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :to_h)