rubocop 0.88.0 → 0.89.1

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

@@ -37,20 +37,19 @@ module RuboCop
       #
       #   # good
       #   format('%s', 'Hello')
-      class FormatStringToken < Cop
+      class FormatStringToken < Base
         include ConfigurableEnforcedStyle
 
         def on_str(node)
+          return unless node.value.include?('%')
           return if node.each_ancestor(:xstr, :regexp).any?
 
           tokens(node) do |detected_style, token_range|
-            if detected_style == style ||
-               unannotated_format?(node, detected_style)
+            if detected_style == style || unannotated_format?(node, detected_style)
               correct_style_detected
             else
               style_detected(detected_style)
-              add_offense(node, location: token_range,
-                                message: message(detected_style))
+              add_offense(token_range, message: message(detected_style))
             end
           end
         end
@@ -65,8 +64,7 @@ module RuboCop
         PATTERN
 
         def unannotated_format?(node, detected_style)
-          detected_style == :unannotated &&
-            !format_string_in_typical_context?(node)
+          detected_style == :unannotated && !format_string_in_typical_context?(node)
         end
 
         def message(detected_style)

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

@@ -73,10 +73,11 @@ module RuboCop
       #   module Bar
       #     # ...
       #   end
-      class FrozenStringLiteralComment < Cop
+      class FrozenStringLiteralComment < Base
         include ConfigurableEnforcedStyle
         include FrozenStringLiteral
         include RangeHelp
+        extend AutoCorrector
 
         MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: '\
                            'true`.'
@@ -85,7 +86,7 @@ module RuboCop
         MSG_DISABLED = 'Frozen string literal comment must be set to `true`.'
         SHEBANG = '#!'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.tokens.empty?
 
           case style
@@ -98,23 +99,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            case style
-            when :never
-              remove_comment(corrector, node)
-            when :always_true
-              if frozen_string_literal_specified?
-                enable_comment(corrector)
-              else
-                insert_comment(corrector)
-              end
-            else
-              insert_comment(corrector)
-            end
-          end
-        end
-
         private
 
         def ensure_no_comment(processed_source)
@@ -160,51 +144,45 @@ module RuboCop
         end
 
         def missing_offense(processed_source)
-          last_special_comment = last_special_comment(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment,
-                      location: range,
-                      message: MSG_MISSING)
+          add_offense(range, message: MSG_MISSING) do |corrector|
+            insert_comment(corrector)
+          end
         end
 
         def missing_true_offense(processed_source)
-          last_special_comment = last_special_comment(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment,
-                      location: range,
-                      message: MSG_MISSING_TRUE)
+          add_offense(range, message: MSG_MISSING_TRUE) do |corrector|
+            insert_comment(corrector)
+          end
         end
 
         def unnecessary_comment_offense(processed_source)
-          frozen_string_literal_comment =
-            frozen_string_literal_comment(processed_source)
+          frozen_string_literal_comment = frozen_string_literal_comment(processed_source)
 
-          add_offense(frozen_string_literal_comment,
-                      location: frozen_string_literal_comment.pos,
-                      message: MSG_UNNECESSARY)
+          add_offense(frozen_string_literal_comment.pos, message: MSG_UNNECESSARY) do |corrector|
+            remove_comment(corrector, frozen_string_literal_comment)
+          end
         end
 
         def disabled_offense(processed_source)
-          frozen_string_literal_comment =
-            frozen_string_literal_comment(processed_source)
+          frozen_string_literal_comment = frozen_string_literal_comment(processed_source)
 
-          add_offense(frozen_string_literal_comment,
-                      location: frozen_string_literal_comment.pos,
-                      message: MSG_DISABLED)
+          add_offense(frozen_string_literal_comment.pos, message: MSG_DISABLED) do |corrector|
+            enable_comment(corrector)
+          end
         end
 
         def remove_comment(corrector, node)
-          corrector.remove(range_with_surrounding_space(range: node.pos,
-                                                        side: :right))
+          corrector.remove(range_with_surrounding_space(range: node.pos, side: :right))
         end
 
         def enable_comment(corrector)
           comment = frozen_string_literal_comment(processed_source)
 
-          corrector.replace(line_range(comment.line),
-                            FROZEN_STRING_LITERAL_ENABLED)
+          corrector.replace(line_range(comment.line), FROZEN_STRING_LITERAL_ENABLED)
         end
 
         def insert_comment(corrector)

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`.
+      # `STDOUT/STDERR/STDIN` are constants, and while you can actually
+      # reassign (possibly to redirect some stream) constants in Ruby, you'll get
+      # an interpreter warning if you do so.
+      #
+      # @example
+      #   # bad
+      #   STDOUT.puts('hello')
+      #
+      #   hash = { out: STDOUT, key: value }
+      #
+      #   def m(out = STDOUT)
+      #     out.puts('hello')
+      #   end
+      #
+      #   # good
+      #   $stdout.puts('hello')
+      #
+      #   hash = { out: $stdout, key: value }
+      #
+      #   def m(out = $stdout)
+      #     out.puts('hello')
+      #   end
+      #
+      class GlobalStdStream < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<gvar_name>s` instead of `%<const_name>s`.'
+
+        STD_STREAMS = %i[STDIN STDOUT STDERR].to_set.freeze
+
+        def_node_matcher :const_to_gvar_assignment?, <<~PATTERN
+          (gvasgn %1 (const nil? _))
+        PATTERN
+
+        def on_const(node)
+          const_name = node.children[1]
+          return unless STD_STREAMS.include?(const_name)
+
+          gvar_name = gvar_name(const_name).to_sym
+          return if const_to_gvar_assignment?(node.parent, gvar_name)
+
+          add_offense(node, message: message(const_name)) do |corrector|
+            corrector.replace(node, gvar_name)
+          end
+        end
+
+        private
+
+        def message(const_name)
+          format(MSG, gvar_name: gvar_name(const_name), const_name: const_name)
+        end
+
+        def gvar_name(const_name)
+          "$#{const_name.to_s.downcase}"
+        end
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module RuboCop
       #   FOO = 2
       #   foo = 2
       #   $stdin.read
-      class GlobalVars < Cop
+      class GlobalVars < Base
         MSG = 'Do not introduce global variables.'
 
         # built-in global variables and their English aliases
@@ -72,7 +72,7 @@ module RuboCop
         def check(node)
           global_var, = *node
 
-          add_offense(node, location: :name) unless allowed_var?(global_var)
+          add_offense(node.loc.name) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -46,7 +46,7 @@ module RuboCop
       #   # good
       #   foo || raise('exception') if something
       #   ok
-      class GuardClause < Cop
+      class GuardClause < Base
         include MinBodyLength
         include StatementModifier
 
@@ -87,7 +87,7 @@ module RuboCop
         private
 
         def check_ending_if(node)
-          return if accepted_form?(node, true) || !min_body_length?(node)
+          return if accepted_form?(node, ending: true) || !min_body_length?(node)
 
           register_offense(node, 'return', opposite_keyword(node))
         end
@@ -105,9 +105,8 @@ module RuboCop
             example = "#{conditional_keyword} #{condition.source}; " \
                       "#{scope_exiting_keyword}; end"
           end
-          add_offense(node,
-                      location: :keyword,
-                      message: format(MSG, example: example))
+
+          add_offense(node.loc.keyword, message: format(MSG, example: example))
         end
 
         def guard_clause_source(guard_clause)
@@ -125,7 +124,7 @@ module RuboCop
           max && node.source_range.column + example.length > max
         end
 
-        def accepted_form?(node, ending = false)
+        def accepted_form?(node, ending: false)
           accepted_if?(node, ending) || node.condition.multiline? ||
             node.parent&.assignment?
         end

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

@@ -25,7 +25,7 @@ module RuboCop
         extend AutoCorrector
 
         def on_hash(node)
-          return unless node.parent&.array_type?
+          return unless last_array_item?(node)
 
           if braces_style?
             check_braces(node)
@@ -36,6 +36,13 @@ module RuboCop
 
         private
 
+        def last_array_item?(node)
+          parent = node.parent
+          return false unless parent
+
+          parent.array_type? && parent.children.last.equal?(node)
+        end
+
         def check_braces(node)
           return if node.braces?
 

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

@@ -17,8 +17,9 @@ module RuboCop
       #   # good
       #   hash.each_key { |k| p k }
       #   hash.each_value { |v| p v }
-      class HashEachMethods < Cop
+      class HashEachMethods < Base
         include Lint::UnusedArgument
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -30,12 +31,6 @@ module RuboCop
           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)
@@ -45,7 +40,9 @@ module RuboCop
             msg = format(message, prefer: "each_#{method[0..-2]}",
                                   current: "#{method}.each")
 
-            add_offense(target, location: kv_range(target), message: msg)
+            add_offense(kv_range(target), message: msg) do |corrector|
+              correct_key_value_each(target, corrector)
+            end
           end
         end
 

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

@@ -73,7 +73,7 @@ module RuboCop
             ruby19_no_mixed_keys_check(pairs)
           elsif style == :no_mixed_keys
             no_mixed_keys_check(pairs)
-          else
+          elsif node.source.include?('=>')
             ruby19_check(pairs)
           end
         end
@@ -174,7 +174,7 @@ module RuboCop
 
           corrector.replace(
             range,
-            range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
+            range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: ")
           )
 
           hash_node = pair_node.parent
@@ -199,7 +199,8 @@ module RuboCop
         def autocorrect_hash_rockets(corrector, pair_node)
           op = pair_node.loc.operator
 
-          corrector.wrap(pair_node.key, ':', pair_node.inverse_delimiter(true))
+          key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
+          corrector.replace(pair_node.key, key_with_hash_rocket)
           corrector.remove(range_with_surrounding_space(range: op))
         end
 

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

@@ -23,9 +23,10 @@ module RuboCop
       #   # 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
+      class HashTransformKeys < Base
         include HashTransformMethod
+        extend TargetRubyVersion
+        extend AutoCorrector
 
         minimum_target_ruby_version 2.5
 

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

@@ -23,8 +23,9 @@ module RuboCop
       #   # good
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
       #   {a: 1, b: 2}.transform_values { |v| v * v }
-      class HashTransformValues < Cop
+      class HashTransformValues < Base
         include HashTransformMethod
+        extend AutoCorrector
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block

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

@@ -62,7 +62,7 @@ module RuboCop
       #     do_x
       #     do_z
       #   end
-      class IdenticalConditionalBranches < Cop
+      class IdenticalConditionalBranches < Base
         MSG = 'Move `%<source>s` out of the conditional.'
 
         def on_if(node)
@@ -81,7 +81,7 @@ module RuboCop
 
         private
 
-        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity
+        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
           return if branches.any?(&:nil?)

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

@@ -58,10 +58,10 @@ module RuboCop
       #     action_b
       #   end
       #
-      class IfInsideElse < Cop
+      class IfInsideElse < Base
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
-        def on_if(node) # rubocop:todo Metrics/CyclomaticComplexity
+        def on_if(node)
           return if node.ternary? || node.unless?
 
           else_branch = node.else_branch
@@ -69,7 +69,7 @@ module RuboCop
           return unless else_branch&.if_type? && else_branch&.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
-          add_offense(else_branch, location: :keyword)
+          add_offense(else_branch.loc.keyword)
         end
 
         private

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

@@ -30,10 +30,11 @@ module RuboCop
       #   if long_condition
       #     do_something_in_a_method_with_a_long_name(arg)
       #   end
-      class IfUnlessModifier < Cop
+      class IfUnlessModifier < Base
         include StatementModifier
         include LineLengthHelp
         include IgnoredPattern
+        extend AutoCorrector
 
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
@@ -49,22 +50,22 @@ module RuboCop
                 end
           return unless msg
 
-          add_offense(node,
-                      location: :keyword,
-                      message: format(msg, keyword: node.keyword))
+          add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           replacement = if node.modifier_form?
                           to_normal_form(node)
                         else
                           to_modifier_form(node)
                         end
-          ->(corrector) { corrector.replace(node, replacement) }
+          corrector.replace(node, replacement)
         end
 
-        private
-
         def too_long_due_to_modifier?(node)
           node.modifier_form? && too_long_single_line?(node) &&
             !another_statement_on_same_line?(node)
@@ -148,26 +149,6 @@ module RuboCop
             sibling.source_range.first_line == line_no
         end
 
-        def parenthesize?(node)
-          # Parenthesize corrected expression if changing to modifier-if form
-          # would change the meaning of the parent expression
-          # (due to the low operator precedence of modifier-if)
-          parent = node.parent
-          return false if parent.nil?
-          return true if parent.assignment? || parent.operator_keyword?
-
-          node.parent.send_type? && !node.parent.parenthesized?
-        end
-
-        def to_modifier_form(node)
-          expression = [node.body.source,
-                        node.keyword,
-                        node.condition.source,
-                        first_line_comment(node)].compact.join(' ')
-
-          parenthesize?(node) ? "(#{expression})" : expression
-        end
-
         def to_normal_form(node)
           indentation = ' ' * node.source_range.column
           <<~RUBY.chomp
@@ -178,10 +159,7 @@ module RuboCop
         end
 
         def first_line_comment(node)
-          comment =
-            processed_source.find_comment { |c| c.loc.line == node.loc.line }
-
-          comment ? comment.loc.expression.source : nil
+          processed_source.comment_at_line(node.loc.line)&.text
         end
       end
     end