rubocop 0.52.1 → 0.93.1

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.
-      class SingleLineBlockParams < Cop
-        MSG = 'Name `%<method>s` block params `|%<params>s|`.'.freeze
+      #
+      # 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 < Base
+        MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
         def on_block(node)
           return unless node.single_line?
@@ -19,7 +39,9 @@ module RuboCop
 
           return if args_match?(node.send_node.method_name, node.arguments)
 
-          add_offense(node.arguments)
+          message = message(node.arguments)
+
+          add_offense(node.arguments, message: message)
         end
 
         private

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

@@ -13,48 +13,55 @@ module RuboCop
       #   def @table.columns; super; end
       #
       #   # good
-      #   def no_op; end
       #   def self.resource_class=(klass); end
       #   def @table.columns; end
       #
-      class SingleLineMethods < Cop
+      # @example AllowIfMethodIsEmpty: true (default)
+      #   # good
+      #   def no_op; end
+      #
+      # @example AllowIfMethodIsEmpty: false
+      #   # bad
+      #   def no_op; end
+      #
+      class SingleLineMethods < Base
         include Alignment
+        extend AutoCorrector
 
-        MSG = 'Avoid single-line method definitions.'.freeze
+        MSG = 'Avoid single-line method definitions.'
 
         def on_def(node)
           return unless node.single_line?
           return if allow_empty? && !node.body
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          body = node.body
+        private
 
-          lambda do |corrector|
-            each_part(body) do |part|
-              break_line_before(part, node, corrector, 1)
-            end
+        def autocorrect(corrector, node)
+          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
-          end
+          move_comment(node, corrector)
         end
 
-        private
-
         def allow_empty?
           cop_config['AllowIfMethodIsEmpty']
         end
 
-        def end_of_line_comment(line)
-          processed_source.comments.find { |c| c.loc.line == line }
-        end
-
         def each_part(body)
           return unless body
 
@@ -65,20 +72,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: processed_source.comment_at_line(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,37 @@
+# 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 < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Prefer ary[n..] over ary[n..-1].'
+        RESTRICT_ON_SEND = %i[[]].freeze
+
+        def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
+
+        def on_send(node)
+          return unless node.arguments.count == 1
+          return unless range_till_minus_one?(node.arguments.first)
+
+          add_offense(node.first_argument) do |corrector|
+            corrector.remove(node.first_argument.end)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # If the branch of a conditional consists solely of a conditional node,
+      # its conditions can be combined with the conditions of the outer branch.
+      # This helps to keep the nesting level from getting too deep.
+      #
+      # @example
+      #   # bad
+      #   if condition_a
+      #     if condition_b
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   if condition_a && condition_b
+      #     do_something
+      #   end
+      #
+      # @example AllowModifier: false (default)
+      #   # bad
+      #   if condition_a
+      #     do_something if condition_b
+      #   end
+      #
+      # @example AllowModifier: true
+      #   # good
+      #   if condition_a
+      #     do_something if condition_b
+      #   end
+      #
+      class SoleNestedConditional < Base
+        MSG = 'Consider merging nested conditions into '\
+              'outer `%<conditional_type>s` conditions.'
+
+        def on_if(node)
+          return if node.ternary? || node.else? || node.elsif?
+
+          branch = node.if_branch
+          return unless offending_branch?(branch)
+
+          message = format(MSG, conditional_type: node.keyword)
+          add_offense(branch.loc.keyword, message: message)
+        end
+
+        private
+
+        def offending_branch?(branch)
+          return false unless branch
+
+          branch.if_type? &&
+            !branch.else? &&
+            !branch.ternary? &&
+            !(branch.modifier_form? && allow_modifier?)
+        end
+
+        def allow_modifier?
+          cop_config['AllowModifier']
+        end
+      end
+    end
+  end
+end

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

@@ -3,16 +3,69 @@
 module RuboCop
   module Cop
     module Style
+      #
       # This cop looks for uses of Perl-style global variables.
-      class SpecialGlobalVars < Cop
+      #
+      # @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 < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
-        'module (don\'t forget to require it), or `%<regular>s` over ' \
-        '`%<global>s`.'.freeze
+        '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`.'.freeze
-        MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'.freeze
+        '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],
@@ -68,13 +121,14 @@ module RuboCop
             correct_style_detected
           else
             opposite_style_detected
-            add_offense(node)
+
+            add_offense(node, message: message(global_var)) do |corrector|
+              autocorrect(corrector, node, global_var)
+            end
           end
         end
 
-        def message(node)
-          global_var, = *node
-
+        def message(global_var)
           if style == :use_english_names
             format_english_message(global_var)
           else
@@ -84,17 +138,10 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            global_var, = *node
+        def autocorrect(corrector, node, global_var)
+          node = node.parent while node.parent&.begin_type? && node.parent.children.one?
 
-            while node.parent && node.parent.begin_type? &&
-                  node.parent.children.one?
-              node = node.parent
-            end
-
-            corrector.replace(node.source_range, replacement(node, global_var))
-          end
+          corrector.replace(node, replacement(node, global_var))
         end
 
         private
@@ -108,17 +155,15 @@ module RuboCop
         end
 
         def format_message(english, regular, global)
-          if !regular.empty? && !english.empty?
+          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
             format(MSG_BOTH,
                    prefer: format_list(english),
                    regular: format_list(regular),
                    global: global)
-          elsif !regular.empty?
-            format(MSG_REGULAR, prefer: format_list(regular), global: global)
-          elsif !english.empty?
-            format(MSG_ENGLISH, prefer: format_list(english), global: global)
-          else
-            raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
           end
         end
 
@@ -128,16 +173,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

@@ -19,25 +19,26 @@ module RuboCop
       #
       #   # good
       #   ->a,b,c { a + b + c}
-      class StabbyLambdaParentheses < Cop
+      class StabbyLambdaParentheses < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        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
+                         'with parentheses.'
         def on_send(node)
           return unless stabby_lambda_with_args?(node)
-          return unless redundant_parentheses?(node) ||
-                        missing_parentheses?(node)
+          return unless redundant_parentheses?(node) || missing_parentheses?(node)
 
-          add_offense(node.parent.arguments)
-        end
+          arguments = node.block_node.arguments
 
-        def autocorrect(node)
-          if style == :require_parentheses
-            missing_parentheses_corrector(node)
-          elsif style == :require_no_parentheses
-            unwanted_parentheses_corrector(node)
+          add_offense(arguments) do |corrector|
+            case style
+            when :require_parentheses
+              missing_parentheses_corrector(corrector, arguments)
+            when :require_no_parentheses
+              unwanted_parentheses_corrector(corrector, arguments)
+            end
           end
         end
 
@@ -55,30 +56,23 @@ module RuboCop
           style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
         end
 
-        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, ')')
-          end
+        def missing_parentheses_corrector(corrector, node)
+          corrector.wrap(node, '(', ')')
         end
 
-        def unwanted_parentheses_corrector(node)
-          lambda do |corrector|
-            args_loc = node.parent.arguments.loc
+        def unwanted_parentheses_corrector(corrector, node)
+          args_loc = node.loc
 
-            corrector.replace(args_loc.begin, '')
-            corrector.remove(args_loc.end)
-          end
+          corrector.replace(args_loc.begin, '')
+          corrector.remove(args_loc.end)
         end
 
         def stabby_lambda_with_args?(node)
-          node.stabby_lambda? && node.parent.arguments?
+          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