rubocop 0.51.0 → 0.87.0

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

@@ -3,17 +3,27 @@
 module RuboCop
   module Cop
     module Style
-      # This cops looks for uses of global variables.
+      # This cop looks for uses of global variables.
       # It does not report offenses for built-in global variables.
       # Built-in global variables are allowed by default. Additionally
       # users can allow additional variables via the AllowedVariables option.
       #
       # Note that backreferences like $1, $2, etc are not global variables.
+      #
+      # @example
+      #   # bad
+      #   $foo = 2
+      #   bar = $foo + 5
+      #
+      #   # good
+      #   FOO = 2
+      #   foo = 2
+      #   $stdin.read
       class GlobalVars < Cop
-        MSG = 'Do not introduce global variables.'.freeze
+        MSG = 'Do not introduce global variables.'
 
-        # predefined global variables their English aliases
-        # http://www.zenspider.com/Languages/Ruby/QuickRef.html
+        # built-in global variables and their English aliases
+        # https://www.zenspider.com/ruby/quickref.html
         BUILT_IN_VARS = %w[
           $: $LOAD_PATH
           $" $LOADED_FEATURES

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

@@ -35,11 +35,23 @@ module RuboCop
       #   # good
       #   raise 'exception' if something
       #   ok
+      #
+      #   # bad
+      #   if something
+      #     foo || raise('exception')
+      #   else
+      #     ok
+      #   end
+      #
+      #   # good
+      #   foo || raise('exception') if something
+      #   ok
       class GuardClause < Cop
         include MinBodyLength
+        include StatementModifier
 
-        MSG = 'Use a guard clause instead of wrapping the code inside a ' \
-              'conditional expression.'.freeze
+        MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
+              'code inside a conditional expression.'
 
         def on_def(node)
           body = node.body
@@ -48,16 +60,28 @@ module RuboCop
 
           if body.if_type?
             check_ending_if(body)
-          elsif body.begin_type? && body.children.last.if_type?
-            check_ending_if(body.children.last)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
           end
         end
         alias on_defs on_def
 
         def on_if(node)
-          return if accepted_form?(node) || !contains_guard_clause?(node)
+          return if accepted_form?(node)
+
+          guard_clause_in_if = node.if_branch&.guard_clause?
+          guard_clause_in_else = node.else_branch&.guard_clause?
+          guard_clause = guard_clause_in_if || guard_clause_in_else
+          return unless guard_clause
 
-          add_offense(node, location: :keyword)
+          kw = if guard_clause_in_if
+                 node.loc.keyword.source
+               else
+                 opposite_keyword(node)
+               end
+
+          register_offense(node, guard_clause_source(guard_clause), kw)
         end
 
         private
@@ -65,11 +89,45 @@ module RuboCop
         def check_ending_if(node)
           return if accepted_form?(node, true) || !min_body_length?(node)
 
-          add_offense(node, location: :keyword)
+          register_offense(node, 'return', opposite_keyword(node))
+        end
+
+        def opposite_keyword(node)
+          node.if? ? 'unless' : 'if'
+        end
+
+        def register_offense(node, scope_exiting_keyword, conditional_keyword)
+          condition, = node.node_parts
+          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"
+          end
+          add_offense(node,
+                      location: :keyword,
+                      message: format(MSG, example: example))
+        end
+
+        def guard_clause_source(guard_clause)
+          parent = guard_clause.parent
+
+          if parent.and_type? || parent.or_type?
+            guard_clause.parent.source
+          else
+            guard_clause.source
+          end
+        end
+
+        def too_long_for_single_line?(node, example)
+          max = max_line_length
+          max && node.source_range.column + example.length > max
         end
 
         def accepted_form?(node, ending = false)
-          accepted_if?(node, ending) || node.condition.multiline?
+          accepted_if?(node, ending) || node.condition.multiline? ||
+            node.parent&.assignment?
         end
 
         def accepted_if?(node, ending)
@@ -81,11 +139,6 @@ module RuboCop
             !node.else? || node.elsif?
           end
         end
-
-        def contains_guard_clause?(node)
-          node.if_branch && node.if_branch.guard_clause? ||
-            node.else_branch && node.else_branch.guard_clause?
-        end
       end
     end
   end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of `each_key` and `each_value` Hash methods.
+      #
+      # NOTE: If you have an array of two-element arrays, you can put
+      #   parentheses around the block arguments to indicate that you're not
+      #   working with a hash, and suppress RuboCop offenses.
+      #
+      # @example
+      #   # bad
+      #   hash.keys.each { |k| p k }
+      #   hash.values.each { |v| p v }
+      #
+      #   # good
+      #   hash.each_key { |k| p k }
+      #   hash.each_value { |v| p v }
+      class HashEachMethods < Cop
+        include Lint::UnusedArgument
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        def_node_matcher :kv_each, <<~PATTERN
+          (block $(send (send _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        def on_block(node)
+          register_kv_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            correct_key_value_each(node, corrector)
+          end
+        end
+
+        private
+
+        def register_kv_offense(node)
+          kv_each(node) do |target, method|
+            return unless target.receiver.receiver
+
+            msg = format(message, prefer: "each_#{method[0..-2]}",
+                                  current: "#{method}.each")
+
+            add_offense(target, location: kv_range(target), message: msg)
+          end
+        end
+
+        def check_argument(variable)
+          return unless variable.block_argument?
+
+          (@block_args ||= []).push(variable)
+        end
+
+        def used?(arg)
+          @block_args.find { |var| var.declaration_node.loc == arg.loc }.used?
+        end
+
+        def correct_implicit(node, corrector, method_name)
+          corrector.replace(node, method_name)
+          correct_args(node, corrector)
+        end
+
+        def correct_key_value_each(node, corrector)
+          receiver = node.receiver.receiver
+          name = "each_#{node.receiver.method_name.to_s.chop}"
+          return correct_implicit(node, corrector, name) unless receiver
+
+          new_source = receiver.source + ".#{name}"
+          corrector.replace(node, new_source)
+        end
+
+        def correct_args(node, corrector)
+          args = node.parent.arguments
+          name, = *args.children.find { |arg| used?(arg) }
+
+          corrector.replace(args, "|#{name}|")
+        end
+
+        def kv_range(outer_node)
+          outer_node.receiver.loc.selector.join(outer_node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -13,61 +13,54 @@ module RuboCop
       # The supported styles are:
       #
       # * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have
-      #   all symbols for keys
+      # all symbols for keys
       # * hash_rockets - forces use of hash rockets for all hashes
       # * no_mixed_keys - simply checks for hashes with mixed syntaxes
       # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
-      #   syntax hashes
+      # syntax hashes
       #
-      # @example
-      #   "EnforcedStyle => 'ruby19'"
+      # @example EnforcedStyle: ruby19 (default)
+      #   # bad
+      #   {:a => 2}
+      #   {b: 1, :c => 2}
       #
-      #   @good
+      #   # good
       #   {a: 2, b: 1}
       #   {:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol
       #   {d: 1, 'e' => 2} # technically not forbidden
       #
-      #   @bad
-      #   {:a => 2}
-      #   {b: 1, :c => 2}
-      #
-      # @example
-      #   "EnforcedStyle => 'hash_rockets'"
-      #
-      #   @good
-      #   {:a => 1, :b => 2}
-      #
-      #   @bad
+      # @example EnforcedStyle: hash_rockets
+      #   # bad
       #   {a: 1, b: 2}
       #   {c: 1, 'd' => 5}
       #
-      # @example
-      #   "EnforcedStyle => 'no_mixed_keys'"
-      #
-      #   @good
+      #   # good
       #   {:a => 1, :b => 2}
-      #   {c: 1, d: 2}
       #
-      #   @bad
+      # @example EnforcedStyle: no_mixed_keys
+      #   # bad
       #   {:a => 1, b: 2}
       #   {c: 1, 'd' => 2}
       #
-      # @example
-      #   "EnforcedStyle => 'ruby19_no_mixed_keys'"
-      #
-      #   @good
-      #   {a: 1, b: 2}
-      #   {:c => 3, 'd' => 4}
+      #   # good
+      #   {:a => 1, :b => 2}
+      #   {c: 1, d: 2}
       #
-      #   @bad
+      # @example EnforcedStyle: ruby19_no_mixed_keys
+      #   # bad
       #   {:a => 1, :b => 2}
       #   {c: 2, 'd' => 3} # should just use hash rockets
+      #
+      #   # good
+      #   {a: 1, b: 2}
+      #   {:c => 3, 'd' => 4}
       class HashSyntax < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG_19 = 'Use the new Ruby 1.9 hash syntax.'.freeze
-        MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash.".freeze
-        MSG_HASH_ROCKETS = 'Use hash rockets syntax.'.freeze
+        MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
+        MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash."
+        MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
 
         def on_hash(node)
           pairs = node.pairs
@@ -94,7 +87,7 @@ module RuboCop
         end
 
         def ruby19_no_mixed_keys_check(pairs)
-          if force_hash_rockets?
+          if force_hash_rockets?(pairs)
             check(pairs, ':', MSG_HASH_ROCKETS)
           elsif sym_indices?(pairs)
             check(pairs, '=>', MSG_19)
@@ -113,7 +106,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            if style == :hash_rockets || force_hash_rockets?
+            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)
@@ -125,9 +118,9 @@ module RuboCop
 
         def alternative_style
           case style
-          when :hash_rockets then
+          when :hash_rockets
             :ruby19
-          when :ruby19, :ruby19_no_mixed_keys then
+          when :ruby19, :ruby19_no_mixed_keys
             :hash_rockets
           end
         end
@@ -139,7 +132,7 @@ module RuboCop
         end
 
         def word_symbol_pair?(pair)
-          return false unless pair.key.sym_type?
+          return false unless pair.key.sym_type? || pair.key.dsym_type?
 
           acceptable_19_syntax_symbol?(pair.key.source)
         end
@@ -151,11 +144,11 @@ module RuboCop
             # 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 sym_name =~ /[\p{Alnum}"']\z/
+            return false unless /[\p{Alnum}"']\z/.match?(sym_name)
           end
 
           # Most hash keys can be matched against a simple regex.
-          return true if sym_name =~ /\A[_a-z]\w*[?!]?\z/i
+          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?
@@ -174,38 +167,53 @@ module RuboCop
           end
         end
 
-        def autocorrect_ruby19(corrector, node)
-          key = node.children.first.source_range
-          op = node.loc.operator
+        def autocorrect_ruby19(corrector, pair_node)
+          range = range_for_autocorrect_ruby19(pair_node)
+
+          space = argument_without_space?(pair_node.parent) ? ' ' : ''
+
+          corrector.replace(
+            range,
+            range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
+          )
+
+          hash_node = pair_node.parent
+          return unless hash_node.parent&.return_type? && !hash_node.braces?
 
-          range = range_between(key.begin_pos, op.end_pos)
-          range = range_with_surrounding_space(range, :right)
-          corrector.replace(range,
-                            range.source.sub(/^:(.*\S)\s*=>\s*$/, '\1: '))
+          corrector.wrap(hash_node, '{', '}')
         end
 
-        def autocorrect_hash_rockets(corrector, node)
-          key = node.children.first.source_range
-          op = node.loc.operator
+        def range_for_autocorrect_ruby19(pair_node)
+          key = pair_node.key.source_range
+          operator = pair_node.loc.operator
 
-          corrector.insert_after(key, node.inverse_delimiter(true))
-          corrector.insert_before(key, ':')
-          corrector.remove(range_with_surrounding_space(op))
+          range = key.join(operator)
+          range_with_surrounding_space(range: range, side: :right)
         end
 
-        def autocorrect_no_mixed_keys(corrector, node)
-          if node.colon?
-            autocorrect_hash_rockets(corrector, node)
+        def argument_without_space?(node)
+          node.argument? &&
+            node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+        end
+
+        def autocorrect_hash_rockets(corrector, pair_node)
+          op = pair_node.loc.operator
+
+          corrector.wrap(pair_node.key, ':', pair_node.inverse_delimiter(true))
+          corrector.remove(range_with_surrounding_space(range: op))
+        end
+
+        def autocorrect_no_mixed_keys(corrector, pair_node)
+          if pair_node.colon?
+            autocorrect_hash_rockets(corrector, pair_node)
           else
-            autocorrect_ruby19(corrector, node)
+            autocorrect_ruby19(corrector, pair_node)
           end
         end
 
-        def force_hash_rockets?(pairs = [])
-          @force_hash_rockets ||= begin
-            cop_config['UseHashRocketsWithSymbolValues'] &&
-              pairs.map(&:value).any?(&:sym_type?)
-          end
+        def force_hash_rockets?(pairs)
+          cop_config['UseHashRocketsWithSymbolValues'] &&
+            pairs.map(&:value).any?(&:sym_type?)
         end
       end
     end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of `_.each_with_object({}) {...}`,
+      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # 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.)
+      #
+      # @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] }
+      #
+      #   # good
+      #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
+      #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
+      class HashTransformKeys < Cop
+        extend TargetRubyVersion
+        include HashTransformMethod
+
+        minimum_target_ruby_version 2.5
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
+            (args
+              (mlhs
+                (arg $_)
+                (arg _val))
+              (arg _memo))
+            ({send csend} (lvar _memo) :[]= $_ $(lvar _val)))
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} !(send _ :each_with_index) {:map :collect})
+              (args
+                (arg $_)
+                (arg _val))
+              (array $_ $(lvar _val))))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                {:map :collect})
+              (args
+                (arg $_)
+                (arg _val))
+              (array $_ $(lvar _val)))
+            :to_h)
+        PATTERN
+
+        private
+
+        def extract_captures(match)
+          key_argname, key_body_expr, val_body_expr = *match
+          Captures.new(key_argname, key_body_expr, val_body_expr)
+        end
+
+        def new_method_name
+          'transform_keys'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of `_.each_with_object({}) {...}`,
+      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # 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.)
+      #
+      # @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] }
+      #
+      #   # good
+      #   {a: 1, b: 2}.transform_values { |v| foo(v) }
+      #   {a: 1, b: 2}.transform_values { |v| v * v }
+      class HashTransformValues < Cop
+        include HashTransformMethod
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
+            (args
+              (mlhs
+                (arg _key)
+                (arg $_))
+              (arg _memo))
+            ({send csend} (lvar _memo) :[]= $(lvar _key) $_))
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} !(send _ :each_with_index) {:map :collect})
+              (args
+                (arg _key)
+                (arg $_))
+              (array $(lvar _key) $_)))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                 {:map :collect})
+              (args
+                (arg _key)
+                (arg $_))
+              (array $(lvar _key) $_))
+            :to_h)
+        PATTERN
+
+        private
+
+        def extract_captures(match)
+          val_argname, key_body_expr, val_body_expr = *match
+          Captures.new(val_argname, val_body_expr, key_body_expr)
+        end
+
+        def new_method_name
+          'transform_values'
+        end
+      end
+    end
+  end
+end