rubocop 0.51.0 → 0.87.0

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

@@ -8,8 +8,28 @@ module RuboCop
       #
       # For instance one can configure `reduce`(`inject`) to use |a, e| as
       # parameters.
+      #
+      # Configuration option: Methods
+      # Should be set to use this cop. Array of hashes, where each key is the
+      # method name and value - array of argument names.
+      #
+      # @example Methods: [{reduce: %w[a b]}]
+      #   # bad
+      #   foo.reduce { |c, d| c + d }
+      #   foo.reduce { |_, _d| 1 }
+      #
+      #   # good
+      #   foo.reduce { |a, b| a + b }
+      #   foo.reduce { |a, _b| a }
+      #   foo.reduce { |a, (id, _)| a + id }
+      #   foo.reduce { true }
+      #
+      #   # good
+      #   foo.reduce do |c, d|
+      #     c + d
+      #   end
       class SingleLineBlockParams < Cop
-        MSG = 'Name `%s` block params `|%s|`.'.freeze
+        MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
         def on_block(node)
           return unless node.single_line?
@@ -28,7 +48,7 @@ module RuboCop
           method_name = node.parent.send_node.method_name
           arguments   = target_args(method_name).join(', ')
 
-          format(MSG, method_name, arguments)
+          format(MSG, method: method_name, params: arguments)
         end
 
         def eligible_arguments?(node)

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

@@ -3,12 +3,31 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for single-line method definitions.
-      # It can optionally accept single-line methods with no body.
+      # This cop checks for single-line method definitions that contain a body.
+      # It will accept single-line methods with no body.
+      #
+      # @example
+      #   # bad
+      #   def some_method; body end
+      #   def link_to(url); {:name => url}; end
+      #   def @table.columns; super; end
+      #
+      #   # good
+      #   def self.resource_class=(klass); end
+      #   def @table.columns; end
+      #
+      # @example AllowIfMethodIsEmpty: true (default)
+      #   # good
+      #   def no_op; end
+      #
+      # @example AllowIfMethodIsEmpty: false
+      #   # bad
+      #   def no_op; end
+      #
       class SingleLineMethods < Cop
-        include AutocorrectAlignment
+        include Alignment
 
-        MSG = 'Avoid single-line method definitions.'.freeze
+        MSG = 'Avoid single-line method definitions.'
 
         def on_def(node)
           return unless node.single_line?
@@ -18,29 +37,28 @@ module RuboCop
         end
         alias on_defs on_def
 
-        private
-
-        def allow_empty?
-          cop_config['AllowIfMethodIsEmpty']
-        end
-
         def autocorrect(node)
-          body = node.body
-
           lambda do |corrector|
-            each_part(body) do |part|
-              break_line_before(part, node, corrector, 1)
+            each_part(node.body) do |part|
+              LineBreakCorrector.break_line_before(
+                range: part, node: node, corrector: corrector,
+                configured_width: configured_indentation_width
+              )
             end
 
-            break_line_before(node.loc.end, node, corrector, 0)
+            LineBreakCorrector.break_line_before(
+              range: node.loc.end, node: node, corrector: corrector,
+              indent_steps: 0, configured_width: configured_indentation_width
+            )
 
-            eol_comment = end_of_line_comment(node.source_range.line)
-            move_comment(eol_comment, node, corrector) if eol_comment
+            move_comment(node, corrector)
           end
         end
 
-        def end_of_line_comment(line)
-          processed_source.comments.find { |c| c.loc.line == line }
+        private
+
+        def allow_empty?
+          cop_config['AllowIfMethodIsEmpty']
         end
 
         def each_part(body)
@@ -53,20 +71,12 @@ module RuboCop
           end
         end
 
-        def break_line_before(range, node, corrector, indent_steps)
-          corrector.insert_before(
-            range,
-            "\n" + ' ' * (node.loc.keyword.column +
-                          indent_steps * configured_indentation_width)
+        def move_comment(node, corrector)
+          LineBreakCorrector.move_comment(
+            eol_comment: end_of_line_comment(node.source_range.line),
+            node: node, corrector: corrector
           )
         end
-
-        def move_comment(eol_comment, node, corrector)
-          text = eol_comment.loc.expression.source
-          corrector.insert_before(node.source_range,
-                                  text + "\n" + (' ' * node.loc.keyword.column))
-          corrector.remove(eol_comment.loc.expression)
-        end
       end
     end
   end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that arrays are sliced with endless ranges instead of
+      # `ary[start..-1]` on Ruby 2.6+.
+      #
+      # @example
+      #   # bad
+      #   items[1..-1]
+      #
+      #   # good
+      #   items[1..]
+      class SlicingWithRange < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Prefer ary[n..] over ary[n..-1].'
+
+        def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
+
+        def on_send(node)
+          return unless node.method?(:[]) && node.arguments.count == 1
+          return unless range_till_minus_one?(node.arguments.first)
+
+          add_offense(node.arguments.first)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.end)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,15 +3,68 @@
 module RuboCop
   module Cop
     module Style
+      #
       # This cop looks for uses of Perl-style global variables.
+      #
+      # @example EnforcedStyle: use_english_names (default)
+      #   # good
+      #   puts $LOAD_PATH
+      #   puts $LOADED_FEATURES
+      #   puts $PROGRAM_NAME
+      #   puts $ERROR_INFO
+      #   puts $ERROR_POSITION
+      #   puts $FIELD_SEPARATOR # or $FS
+      #   puts $OUTPUT_FIELD_SEPARATOR # or $OFS
+      #   puts $INPUT_RECORD_SEPARATOR # or $RS
+      #   puts $OUTPUT_RECORD_SEPARATOR # or $ORS
+      #   puts $INPUT_LINE_NUMBER # or $NR
+      #   puts $LAST_READ_LINE
+      #   puts $DEFAULT_OUTPUT
+      #   puts $DEFAULT_INPUT
+      #   puts $PROCESS_ID # or $PID
+      #   puts $CHILD_STATUS
+      #   puts $LAST_MATCH_INFO
+      #   puts $IGNORECASE
+      #   puts $ARGV # or ARGV
+      #   puts $MATCH
+      #   puts $PREMATCH
+      #   puts $POSTMATCH
+      #   puts $LAST_PAREN_MATCH
+      #
+      # @example EnforcedStyle: use_perl_names
+      #   # good
+      #   puts $:
+      #   puts $"
+      #   puts $0
+      #   puts $!
+      #   puts $@
+      #   puts $;
+      #   puts $,
+      #   puts $/
+      #   puts $\
+      #   puts $.
+      #   puts $_
+      #   puts $>
+      #   puts $<
+      #   puts $$
+      #   puts $?
+      #   puts $~
+      #   puts $=
+      #   puts $*
+      #   puts $&
+      #   puts $`
+      #   puts $'
+      #   puts $+
+      #
       class SpecialGlobalVars < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_BOTH = 'Prefer `%s` from the stdlib \'English\' module ' \
-        '(don\'t forget to require it), or `%s` over `%s`.'.freeze
-        MSG_ENGLISH = 'Prefer `%s` from the stdlib \'English\' module ' \
-        '(don\'t forget to require it) over `%s`.'.freeze
-        MSG_REGULAR = 'Prefer `%s` over `%s`.'.freeze
+        MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+        'module (don\'t forget to require it) or `%<regular>s` over ' \
+        '`%<global>s`.'
+        MSG_ENGLISH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+        'module (don\'t forget to require it) over `%<global>s`.'
+        MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'
 
         ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
           :$: => [:$LOAD_PATH],
@@ -77,7 +130,9 @@ module RuboCop
           if style == :use_english_names
             format_english_message(global_var)
           else
-            format(MSG_REGULAR, preferred_names(global_var).first, global_var)
+            format(MSG_REGULAR,
+                   prefer: preferred_names(global_var).first,
+                   global: global_var)
           end
         end
 
@@ -85,12 +140,12 @@ module RuboCop
           lambda do |corrector|
             global_var, = *node
 
-            while node.parent && node.parent.begin_type? &&
+            while node.parent&.begin_type? &&
                   node.parent.children.one?
               node = node.parent
             end
 
-            corrector.replace(node.source_range, replacement(node, global_var))
+            corrector.replace(node, replacement(node, global_var))
           end
         end
 
@@ -104,16 +159,16 @@ module RuboCop
           format_message(english, regular, global_var)
         end
 
-        def format_message(english, regular, global_var)
-          if !regular.empty? && !english.empty?
-            format(MSG_BOTH, format_list(english), format_list(regular),
-                   global_var)
-          elsif !regular.empty?
-            format(MSG_REGULAR, format_list(regular), global_var)
-          elsif !english.empty?
-            format(MSG_ENGLISH, format_list(english), global_var)
+        def format_message(english, regular, global)
+          if regular.empty?
+            format(MSG_ENGLISH, prefer: format_list(english), global: global)
+          elsif english.empty?
+            format(MSG_REGULAR, prefer: format_list(regular), global: global)
           else
-            raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
+            format(MSG_BOTH,
+                   prefer: format_list(english),
+                   regular: format_list(regular),
+                   global: global)
           end
         end
 
@@ -123,16 +178,12 @@ module RuboCop
         end
 
         def replacement(node, global_var)
-          parent_type = node.parent && node.parent.type
+          parent_type = node.parent&.type
           preferred_name = preferred_names(global_var).first
 
-          unless %i[dstr xstr regexp].include?(parent_type)
-            return preferred_name.to_s
-          end
+          return preferred_name.to_s unless %i[dstr xstr regexp].include?(parent_type)
 
-          if style == :use_english_names
-            return english_name_replacement(preferred_name, node)
-          end
+          return english_name_replacement(preferred_name, node) if style == :use_english_names
 
           "##{preferred_name}"
         end

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

@@ -6,32 +6,31 @@ module RuboCop
       # Check for parentheses around stabby lambda arguments.
       # There are two different styles. Defaults to `require_parentheses`.
       #
-      # @example
-      #   # require_parentheses - bad
+      # @example EnforcedStyle: require_parentheses (default)
+      #   # bad
       #   ->a,b,c { a + b + c }
       #
-      #   # require_parentheses - good
+      #   # good
       #   ->(a,b,c) { a + b + c}
       #
-      #   # require_no_parentheses - bad
+      # @example EnforcedStyle: require_no_parentheses
+      #   # bad
       #   ->(a,b,c) { a + b + c }
       #
-      #   # require_no_parentheses - good
+      #   # good
       #   ->a,b,c { a + b + c}
       class StabbyLambdaParentheses < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'.freeze
+        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
         MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
-                         'with parentheses.'.freeze
-        ARROW = '->'.freeze
-
+                         'with parentheses.'
         def on_send(node)
           return unless stabby_lambda_with_args?(node)
           return unless redundant_parentheses?(node) ||
                         missing_parentheses?(node)
 
-          add_offense(node.parent.arguments)
+          add_offense(node.block_node.arguments)
         end
 
         def autocorrect(node)
@@ -58,16 +57,13 @@ module RuboCop
 
         def missing_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node.parent.arguments.source_range
-
-            corrector.insert_before(args_loc, '(')
-            corrector.insert_after(args_loc, ')')
+            corrector.wrap(node, '(', ')')
           end
         end
 
         def unwanted_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node.parent.arguments.loc
+            args_loc = node.loc
 
             corrector.replace(args_loc.begin, '')
             corrector.remove(args_loc.end)
@@ -75,15 +71,11 @@ module RuboCop
         end
 
         def stabby_lambda_with_args?(node)
-          node.command?(:lambda) && arrow_form?(node) && node.parent.arguments?
-        end
-
-        def arrow_form?(node)
-          node.loc.selector.source == ARROW
+          node.lambda_literal? && node.block_node.arguments?
         end
 
         def parentheses?(node)
-          node.parent.arguments.loc.begin
+          node.block_node.arguments.loc.begin
         end
       end
     end

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # This cop identifies places where `$stderr.puts`
-      # can be replaced by `warn`.
+      # This cop identifies places where `$stderr.puts` can be replaced by
+      # `warn`. The latter has the advantage of easily being disabled by,
+      # the `-W0` interpreter flag or setting `$VERBOSE` to `nil`.
       #
       # @example
       #   # bad
@@ -14,11 +15,15 @@ module RuboCop
       #   warn('hello')
       #
       class StderrPuts < Cop
-        MSG = 'Use `warn` instead of `$stderr.puts`.'.freeze
+        include RangeHelp
 
-        def_node_matcher :stderr_puts?, <<-PATTERN
+        MSG =
+          'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+
+        def_node_matcher :stderr_puts?, <<~PATTERN
           (send
-            (gvar #stderr_gvar?) :puts
+            {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
+            :puts $_
             ...)
         PATTERN
 
@@ -36,6 +41,10 @@ module RuboCop
 
         private
 
+        def message(node)
+          format(MSG, bad: "#{node.receiver.source}.#{node.method_name}")
+        end
+
         def stderr_gvar?(sym)
           sym == :$stderr
         end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of strings as keys in hashes. The use of
+      # symbols is preferred instead.
+      #
+      # @example
+      #   # bad
+      #   { 'one' => 1, 'two' => 2, 'three' => 3 }
+      #
+      #   # good
+      #   { one: 1, two: 2, three: 3 }
+      class StringHashKeys < Cop
+        MSG = 'Prefer symbols instead of strings as hash keys.'
+
+        def_node_matcher :string_hash_key?, <<~PATTERN
+          (pair (str _) _)
+        PATTERN
+
+        def_node_matcher :receive_environments_method?, <<~PATTERN
+          {
+            ^^(send (const {nil? cbase} :IO) :popen ...)
+            ^^(send (const {nil? cbase} :Open3)
+                {:capture2 :capture2e :capture3 :popen2 :popen2e :popen3} ...)
+            ^^^(send (const {nil? cbase} :Open3)
+                {:pipeline :pipeline_r :pipeline_rw :pipeline_start :pipeline_w} ...)
+            ^^(send {nil? (const {nil? cbase} :Kernel)} {:spawn :system} ...)
+            ^^(send _ {:gsub :gsub!} ...)
+          }
+        PATTERN
+
+        def on_pair(node)
+          return unless string_hash_key?(node)
+          return if receive_environments_method?(node)
+
+          add_offense(node.key)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            symbol_content = node.str_content.to_sym.inspect
+            corrector.replace(node, symbol_content)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,11 +4,33 @@ module RuboCop
   module Cop
     module Style
       # Checks if uses of quotes match the configured preference.
+      #
+      # @example EnforcedStyle: single_quotes (default)
+      #   # bad
+      #   "No special symbols"
+      #   "No string interpolation"
+      #   "Just text"
+      #
+      #   # good
+      #   'No special symbols'
+      #   'No string interpolation'
+      #   'Just text'
+      #   "Wait! What's #{this}!"
+      #
+      # @example EnforcedStyle: double_quotes
+      #   # bad
+      #   'Just some text'
+      #   'No special chars or interpolation'
+      #
+      #   # good
+      #   "Just some text"
+      #   "No special chars or interpolation"
+      #   "Every string in #{project} uses double_quotes"
       class StringLiterals < Cop
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
 
-        MSG_INCONSISTENT = 'Inconsistent quote style.'.freeze
+        MSG_INCONSISTENT = 'Inconsistent quote style.'
 
         def on_dstr(node)
           # Strings which are continued across multiple lines using \
@@ -16,7 +38,7 @@ module RuboCop
           # If one part of that continued string contains interpolations,
           # then it will be parsed as a nested `dstr` node
           return unless consistent_multiline?
-          return if node.loc.is_a?(Parser::Source::Map::Heredoc)
+          return if node.heredoc?
 
           children = node.children
           return unless all_string_literals?(children)
@@ -32,6 +54,10 @@ module RuboCop
           ignore_node(node)
         end
 
+        def autocorrect(node)
+          StringLiteralCorrector.correct(node, style)
+        end
+
         private
 
         def all_string_literals?(nodes)
@@ -50,7 +76,7 @@ module RuboCop
           styles.map(&:source).uniq
         end
 
-        def message(*)
+        def message(_node)
           if style == :single_quotes
             "Prefer single-quoted strings when you don't need string " \
             'interpolation or special symbols.'

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

@@ -6,20 +6,14 @@ module RuboCop
       # This cop checks that quotes inside the string interpolation
       # match the configured preference.
       #
-      # @example
-      #
-      #   # EnforcedStyle: single_quotes
-      #
+      # @example EnforcedStyle: single_quotes (default)
       #   # bad
       #   result = "Tests #{success ? "PASS" : "FAIL"}"
       #
       #   # good
       #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
       #
-      # @example
-      #
-      #   # EnforcedStyle: double_quotes
-      #
+      # @example EnforcedStyle: double_quotes
       #   # bad
       #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
       #
@@ -29,9 +23,13 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
 
+        def autocorrect(node)
+          StringLiteralCorrector.correct(node, style)
+        end
+
         private
 
-        def message(*)
+        def message(_node)
           # single_quotes -> single-quoted
           kind = style.to_s.sub(/_(.*)s/, '-\1d')
 

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

@@ -5,22 +5,26 @@ module RuboCop
     module Style
       # This cop enforces the use of consistent method names
       # from the String class.
+      #
+      # @example
+      #   # bad
+      #   'name'.intern
+      #   'var'.unfavored_method
+      #
+      #   # good
+      #   'name'.to_sym
+      #   'var'.preferred_method
       class StringMethods < Cop
         include MethodPreference
 
-        MSG = 'Prefer `%s` over `%s`.'.freeze
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
         def on_send(node)
           return unless preferred_method(node.method_name)
 
           add_offense(node, location: :selector)
         end
-
-        private
-
-        def message(node)
-          format(MSG, preferred_method(node.method_name), node.method_name)
-        end
+        alias on_csend on_send
 
         def autocorrect(node)
           lambda do |corrector|
@@ -28,6 +32,14 @@ module RuboCop
                               preferred_method(node.method_name))
           end
         end
+
+        private
+
+        def message(node)
+          format(MSG,
+                 prefer: preferred_method(node.method_name),
+                 current: node.method_name)
+        end
       end
     end
   end

data/lib/rubocop/cop/{performance/lstrip_rstrip.rb → style/strip.rb}

@@ -2,21 +2,23 @@
 
 module RuboCop
   module Cop
-    module Performance
+    module Style
       # This cop identifies places where `lstrip.rstrip` can be replaced by
       # `strip`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc'.lstrip.rstrip
       #   'abc'.rstrip.lstrip
       #
-      #   @good
+      #   # good
       #   'abc'.strip
-      class LstripRstrip < Cop
-        MSG = 'Use `strip` instead of `%s.%s`.'.freeze
+      class Strip < Cop
+        include RangeHelp
 
-        def_node_matcher :lstrip_rstrip, <<-PATTERN
+        MSG = 'Use `strip` instead of `%<methods>s`.'
+
+        def_node_matcher :lstrip_rstrip, <<~PATTERN
           {(send $(send _ $:rstrip) $:lstrip)
            (send $(send _ $:lstrip) $:rstrip)}
         PATTERN
@@ -27,7 +29,8 @@ module RuboCop
                                   node.source_range.end_pos)
             add_offense(node,
                         location: range,
-                        message: format(MSG, method_one, method_two))
+                        message: format(MSG,
+                                        methods: "#{method_one}.#{method_two}"))
           end
         end