rubocop 0.49.1 → 0.52.0

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

@@ -10,11 +10,13 @@ module RuboCop
       #
       #   # bad
       #   if x % 2 == 0
+      #   end
       #
       #   # good
       #   if x.even?
+      #   end
       class EvenOdd < Cop
-        MSG = 'Replace with `Integer#%s?`.'.freeze
+        MSG = 'Replace with `Integer#%<method>s?`.'.freeze
 
         def_node_matcher :even_odd_candidate?, <<-PATTERN
           (send
@@ -27,7 +29,7 @@ module RuboCop
         def on_send(node)
           even_odd_candidate?(node) do |_base_number, method, arg|
             replacement_method = replacement_method(arg, method)
-            add_offense(node, :expression, format(MSG, replacement_method))
+            add_offense(node, message: format(MSG, method: replacement_method))
           end
         end
 

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that `#module_function` is used over `extend self`.
+      #
+      # @example EnforcedStyle: module_function (default)
+      #
+      #   # bad
+      #   module Foo
+      #     extend self
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     module_function
+      #   end
+      #
+      # @example EnforcedStyle: extend_self
+      #
+      #   # bad
+      #   module Foo
+      #     module_function
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     extend self
+      #   end
+      class ExtendSelf < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%<enforced>s` instead of `%<alternate>s`.'.freeze
+
+        def_node_matcher :extend_self?, <<-PATTERN
+          (send nil? :extend (self))
+        PATTERN
+
+        def_node_matcher :module_function?, <<-PATTERN
+          (send nil? :module_function)
+        PATTERN
+
+        def_node_matcher :module_scope?, <<-PATTERN
+          {^(module ...) ^^(module _ ({begin kwbegin} ...))}
+        PATTERN
+
+        def on_send(node)
+          return unless module_scope?(node)
+          return unless module_function_enforced? && extend_self?(node) ||
+                        extend_self_enforced? && module_function?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, enforced_source)
+          end
+        end
+
+        private
+
+        def message(_node)
+          format(MSG, enforced: enforced_source, alternate: alternate_source)
+        end
+
+        def enforced_source
+          case style
+          when :module_function then 'module_function'
+          when :extend_self     then 'extend self'
+          end
+        end
+
+        def alternate_source
+          case style
+          when :module_function then 'extend self'
+          when :extend_self     then 'module_function'
+          end
+        end
+
+        def module_function_enforced?
+          style == :module_function
+        end
+
+        def extend_self_enforced?
+          style == :extend_self
+        end
+      end
+    end
+  end
+end

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

@@ -4,15 +4,26 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for uses of flip flop operator
+      #
+      # @example
+      #   # bad
+      #   (1..20).each do |x|
+      #     puts x if (x == 5) .. (x == 10)
+      #   end
+      #
+      #   # good
+      #   (1..20).each do |x|
+      #     puts x if (x >= 5) && (x <= 10)
+      #   end
       class FlipFlop < Cop
         MSG = 'Avoid the use of flip flop operators.'.freeze
 
         def on_iflipflop(node)
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def on_eflipflop(node)
-          add_offense(node, :expression)
+          add_offense(node)
         end
       end
     end

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

@@ -13,7 +13,9 @@ module RuboCop
 
         def on_for(node)
           if style == :each
-            add_offense(node, :keyword, 'Prefer `each` over `for`.') do
+            msg = 'Prefer `each` over `for`.'
+
+            add_offense(node, location: :keyword, message: msg) do
               opposite_style_detected
             end
           else
@@ -39,7 +41,9 @@ module RuboCop
         def incorrect_style_detected(method)
           end_pos = method.source_range.end_pos
           range = range_between(end_pos - EACH_LENGTH, end_pos)
-          add_offense(range, range, 'Prefer `for` over `each`.') do
+          msg = 'Prefer `for` over `each`.'
+
+          add_offense(range, location: range, message: msg) do
             opposite_style_detected
           end
         end

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

@@ -10,16 +10,41 @@ module RuboCop
       # manner for all cases, so only two scenarios are considered -
       # if the first argument is a string literal and if the second
       # argument is an array literal.
+      #
+      # @example EnforcedStyle: format(default)
+      #   # bad
+      #   puts sprintf('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts format('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: sprintf
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts sprintf('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: percent
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts sprintf('%10s', 'hoge')
+      #
+      #   # good
+      #   puts '%10s' % 'hoge'
+      #
       class FormatString < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Favor `%s` over `%s`.'.freeze
+        MSG = 'Favor `%<prefer>s` over `%<current>s`.'.freeze
 
         def_node_matcher :formatter, <<-PATTERN
         {
-          (send nil ${:sprintf :format} _ _ ...)
+          (send nil? ${:sprintf :format} _ _ ...)
           (send {str dstr} $:% ... )
-          (send !nil $:% {array hash})
+          (send !nil? $:% {array hash})
         }
         PATTERN
 
@@ -29,12 +54,15 @@ module RuboCop
 
             return if detected_style == style
 
-            add_offense(node, :selector, message(detected_style))
+            add_offense(node, location: :selector,
+                              message: message(detected_style))
           end
         end
 
         def message(detected_style)
-          format(MSG, method_name(style), method_name(detected_style))
+          format(MSG,
+                 prefer: method_name(style),
+                 current: method_name(detected_style))
         end
 
         def method_name(style_name)

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

@@ -5,31 +5,32 @@ module RuboCop
     module Style
       # Use a consistent style for named format string tokens.
       #
-      # @example
-      #
-      #   EnforcedStyle: annotated
+      # @example EnforcedStyle: annotated (default)
       #
       #   # bad
-      #
       #   format('%{greeting}', greeting: 'Hello')
       #   format('%s', 'Hello')
       #
       #   # good
-      #
       #   format('%<greeting>s', greeting: 'Hello')
       #
-      # @example
-      #
-      #   EnforcedStyle: template
+      # @example EnforcedStyle: template
       #
       #   # bad
-      #
       #   format('%<greeting>s', greeting: 'Hello')
       #   format('%s', 'Hello')
       #
       #   # good
-      #
       #   format('%{greeting}', greeting: 'Hello')
+      #
+      # @example EnforcedStyle: unannotated
+      #
+      #   # bad
+      #   format('%<greeting>s', greeting: 'Hello')
+      #   format('%{greeting}', 'Hello')
+      #
+      #   # good
+      #   format('%s', 'Hello')
       class FormatStringToken < Cop
         include ConfigurableEnforcedStyle
 
@@ -37,7 +38,8 @@ module RuboCop
 
         STYLE_PATTERNS = {
           annotated: /(?<token>%<[^>]+>#{FIELD_CHARACTERS})/,
-          template:  /(?<token>%\{[^\}]+\})/
+          template: /(?<token>%\{[^\}]+\})/,
+          unannotated: /(?<token>%#{FIELD_CHARACTERS})/
         }.freeze
 
         TOKEN_PATTERN = Regexp.union(STYLE_PATTERNS.values)
@@ -50,7 +52,8 @@ module RuboCop
               correct_style_detected
             else
               style_detected(detected_style)
-              add_offense(node, token_range, message(detected_style))
+              add_offense(node, location: token_range,
+                                message: message(detected_style))
             end
           end
         end
@@ -61,14 +64,13 @@ module RuboCop
           "Prefer #{message_text(style)} over #{message_text(detected_style)}."
         end
 
-        # rubocop:disable FormatStringToken
         def message_text(style)
           case style
           when :annotated then 'annotated tokens (like `%<foo>s`)'
-          when :template  then 'template tokens (like `%{foo}`)'
+          when :template then 'template tokens (like `%{foo}`)'
+          when :unannotated then 'unannotated tokens (like `%s`)'
           end
         end
-        # rubocop:enable FormatStringToken
 
         def tokens(str_node, &block)
           return if str_node.source == '__FILE__'

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # This cop is designed to help upgrade to Ruby 3.0. It will add the
       # comment `# frozen_string_literal: true` to the top of files to
-      # enable frozen string literals. Frozen string literals will be default
+      # enable frozen string literals. Frozen string literals may be default
       # in Ruby 3.0. The comment will be added below a shebang and encoding
       # comment. The frozen string literal comment is only valid in Ruby 2.3+.
       class FrozenStringLiteralComment < Cop
@@ -27,10 +27,11 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
+        def autocorrect(node) # rubocop:disable Metrics/MethodLength
           lambda do |corrector|
             if style == :never
-              corrector.remove(range_with_surrounding_space(node.pos, :right))
+              corrector.remove(range_with_surrounding_space(range: node.pos,
+                                                            side: :right))
             else
               last_special_comment = last_special_comment(processed_source)
               if last_special_comment.nil?
@@ -79,7 +80,7 @@ module RuboCop
           last_special_comment = last_special_comment(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment, range, MSG)
+          add_offense(last_special_comment, location: range)
         end
 
         def unnecessary_comment_offense(processed_source)
@@ -87,8 +88,8 @@ module RuboCop
             frozen_string_literal_comment(processed_source)
 
           add_offense(frozen_string_literal_comment,
-                      frozen_string_literal_comment.pos,
-                      MSG_UNNECESSARY)
+                      location: frozen_string_literal_comment.pos,
+                      message: MSG_UNNECESSARY)
         end
       end
     end

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

@@ -9,10 +9,20 @@ module RuboCop
       # 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
 
-        # predefined global variables their English aliases
+        # built-in global variables and their English aliases
         # http://www.zenspider.com/Languages/Ruby/QuickRef.html
         BUILT_IN_VARS = %w[
           $: $LOAD_PATH
@@ -62,7 +72,7 @@ module RuboCop
         def check(node)
           global_var, = *node
 
-          add_offense(node, :name) unless allowed_var?(global_var)
+          add_offense(node, location: :name) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -37,12 +37,13 @@ module RuboCop
       #   ok
       class GuardClause < Cop
         include MinBodyLength
-        include OnMethodDef
 
         MSG = 'Use a guard clause instead of wrapping the code inside a ' \
               'conditional expression.'.freeze
 
-        def on_method_def(_node, _method_name, _args, body)
+        def on_def(node)
+          body = node.body
+
           return unless body
 
           if body.if_type?
@@ -51,11 +52,12 @@ module RuboCop
             check_ending_if(body.children.last)
           end
         end
+        alias on_defs on_def
 
         def on_if(node)
           return if accepted_form?(node) || !contains_guard_clause?(node)
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
 
         private
@@ -63,7 +65,7 @@ module RuboCop
         def check_ending_if(node)
           return if accepted_form?(node, true) || !min_body_length?(node)
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
 
         def accepted_form?(node, ending = false)

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

@@ -19,49 +19,41 @@ module RuboCop
       # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
       #   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
 
@@ -70,18 +62,18 @@ module RuboCop
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'.freeze
 
         def on_hash(node)
-          return if node.pairs.empty?
+          pairs = node.pairs
 
-          @force_hash_rockets = force_hash_rockets?(node.pairs)
+          return if pairs.empty?
 
-          if style == :hash_rockets || @force_hash_rockets
-            hash_rockets_check(node.pairs)
+          if style == :hash_rockets || force_hash_rockets?(pairs)
+            hash_rockets_check(pairs)
           elsif style == :ruby19_no_mixed_keys
-            ruby19_no_mixed_keys_check(node.pairs)
+            ruby19_no_mixed_keys_check(pairs)
           elsif style == :no_mixed_keys
-            no_mixed_keys_check(node.pairs)
+            no_mixed_keys_check(pairs)
           else
-            ruby19_check(node.pairs)
+            ruby19_check(pairs)
           end
         end
 
@@ -94,7 +86,7 @@ module RuboCop
         end
 
         def ruby19_no_mixed_keys_check(pairs)
-          if @force_hash_rockets
+          if force_hash_rockets?
             check(pairs, ':', MSG_HASH_ROCKETS)
           elsif sym_indices?(pairs)
             check(pairs, '=>', MSG_19)
@@ -113,7 +105,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            if style == :hash_rockets || @force_hash_rockets
+            if style == :hash_rockets || force_hash_rockets?
               autocorrect_hash_rockets(corrector, node)
             elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
               autocorrect_no_mixed_keys(corrector, node)
@@ -164,9 +156,8 @@ module RuboCop
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.delimiter == delim
-              add_offense(pair,
-                          pair.source_range.begin.join(pair.loc.operator),
-                          msg) do
+              location = pair.source_range.begin.join(pair.loc.operator)
+              add_offense(pair, location: location, message: msg) do
                 opposite_style_detected
               end
             else
@@ -175,34 +166,43 @@ 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)
+          key = pair_node.key
+          op = pair_node.loc.operator
+
+          range = range_between(key.source_range.begin_pos, op.end_pos)
+          range = range_with_surrounding_space(range: range, side: :right)
+
+          new_key = key.sym_type? ? key.value : key.source
+
+          space = argument_without_space?(pair_node.parent) ? ' ' : ''
+
+          corrector.replace(range, "#{space}#{new_key}: ")
+        end
 
-          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: '))
+        def argument_without_space?(node)
+          node.argument? &&
+            node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
         end
 
-        def autocorrect_hash_rockets(corrector, node)
-          key = node.children.first.source_range
-          op = node.loc.operator
+        def autocorrect_hash_rockets(corrector, pair_node)
+          key = pair_node.key.source_range
+          op = pair_node.loc.operator
 
-          corrector.insert_after(key, node.inverse_delimiter(true))
+          corrector.insert_after(key, pair_node.inverse_delimiter(true))
           corrector.insert_before(key, ':')
-          corrector.remove(range_with_surrounding_space(op))
+          corrector.remove(range_with_surrounding_space(range: op))
         end
 
-        def autocorrect_no_mixed_keys(corrector, node)
-          if node.colon?
-            autocorrect_hash_rockets(corrector, node)
+        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)
+        def force_hash_rockets?(pairs = [])
           @force_hash_rockets ||= begin
             cop_config['UseHashRocketsWithSymbolValues'] &&
               pairs.map(&:value).any?(&:sym_type?)