rubocop 0.70.0 → 1.6.1

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

@@ -49,6 +49,10 @@ module RuboCop
       #   foo && foo < bar
       #   foo < bar if foo
       #
+      #   # When checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+      #   # do the opposite of what the author intends.
+      #   foo && foo.empty?
+      #
       #   # This could start returning `nil` as well as the return of the method
       #   foo.nil? || foo.bar
       #   !foo || foo.bar
@@ -58,9 +62,10 @@ module RuboCop
       #   foo.baz = bar if foo
       #   foo.baz + bar if foo
       #   foo.bar > 2 if foo
-      class SafeNavigation < Cop
+      class SafeNavigation < Base
         include NilMethods
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
               'exists before calling the method.'
@@ -69,7 +74,7 @@ module RuboCop
 
         # if format: (if checked_variable body nil)
         # unless format: (if checked_variable nil body)
-        def_node_matcher :modifier_if_safe_navigation_candidate, <<-PATTERN
+        def_node_matcher :modifier_if_safe_navigation_candidate, <<~PATTERN
           {
             (if {
                   (send $_ {:nil? :!})
@@ -103,34 +108,67 @@ module RuboCop
           # chain greater than 2
           return if chain_size(method_chain, method) > 1
           return if unsafe_method_used?(method_chain, method)
+          return if method_chain.method?(:empty?)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def use_var_only_in_unless_modifier?(node, variable)
           node.if_type? && node.unless? && !method_called?(variable)
         end
 
-        def autocorrect(node)
-          _check, body, = node.node_parts
-          _checked_variable, matching_receiver, = extract_parts(node)
-          method_call, = matching_receiver.parent
+        private
+
+        def autocorrect(corrector, node)
+          body = node.node_parts[1]
+          method_call = method_call(node)
+
+          corrector.remove(begin_range(node, body))
+          corrector.remove(end_range(node, body))
+          corrector.insert_before(method_call.loc.dot, '&')
+          handle_comments(corrector, node, method_call)
+
+          add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
+        end
 
-          lambda do |corrector|
-            corrector.remove(begin_range(node, body))
-            corrector.remove(end_range(node, body))
-            corrector.insert_before(method_call.loc.dot, '&')
+        def handle_comments(corrector, node, method_call)
+          comments = comments(node)
+          return if comments.empty?
 
-            add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
+          corrector.insert_before(method_call,
+                                  "#{comments.map(&:text).join("\n")}\n")
+        end
+
+        def comments(node)
+          relevant_comment_ranges(node).each.with_object([]) do |range, comments|
+            comments.concat(processed_source.each_comment_in_lines(range).to_a)
           end
         end
 
-        private
+        def relevant_comment_ranges(node)
+          # Get source lines ranges inside the if node that aren't inside an inner node
+          # Comments inside an inner node should remain attached to that node, and not
+          # moved.
+          begin_pos = node.loc.first_line
+          end_pos = node.loc.last_line
+
+          node.child_nodes.each.with_object([]) do |child, ranges|
+            ranges << (begin_pos...child.loc.first_line)
+            begin_pos = child.loc.last_line
+          end << (begin_pos...end_pos)
+        end
 
         def allowed_if_condition?(node)
           node.else? || node.elsif? || node.ternary?
         end
 
+        def method_call(node)
+          _checked_variable, matching_receiver, = extract_parts(node)
+          matching_receiver.parent
+        end
+
         def extract_parts(node)
           case node.type
           when :if
@@ -147,9 +185,7 @@ module RuboCop
           checked_variable, matching_receiver, method =
             extract_common_parts(receiver, variable)
 
-          if receiver && LOGIC_JUMP_KEYWORDS.include?(receiver.type)
-            matching_receiver = nil
-          end
+          matching_receiver = nil if receiver && LOGIC_JUMP_KEYWORDS.include?(receiver.type)
 
           [checked_variable, matching_receiver, receiver, method]
         end
@@ -201,9 +237,7 @@ module RuboCop
           return true if unsafe_method?(method)
 
           method.each_ancestor(:send).any? do |ancestor|
-            unless config.for_cop('Lint/SafeNavigationChain')['Enabled']
-              break true
-            end
+            break true unless config.for_cop('Lint/SafeNavigationChain')['Enabled']
 
             break true if unsafe_method?(ancestor)
             break true if nil_methods.include?(ancestor.method_name)
@@ -224,7 +258,7 @@ module RuboCop
         end
 
         def method_called?(send_node)
-          send_node.parent&.send_type?
+          send_node&.parent&.send_type?
         end
 
         def begin_range(node, method_call)

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

@@ -27,30 +27,28 @@ module RuboCop
       #   [1, 2, 3].shuffle[1..3]    # sample(3) might return a longer Array
       #   [1, 2, 3].shuffle[foo, bar]
       #   [1, 2, 3].shuffle(random: Random.new)
-      class Sample < Cop
+      class Sample < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
+        RESTRICT_ON_SEND = %i[first last [] at slice].freeze
 
-        def_node_matcher :sample_candidate?, <<-PATTERN
-          (send $(send _ :shuffle $...) ${:first :last :[] :at :slice} $...)
+        def_node_matcher :sample_candidate?, <<~PATTERN
+          (send $(send _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
         PATTERN
 
         def on_send(node)
-          sample_candidate?(node) do |shuffle, shuffle_arg, method, method_args|
+          sample_candidate?(node) do |shuffle_node, shuffle_arg, method, method_args|
             return unless offensive?(method, method_args)
 
-            range = source_range(shuffle, node)
+            range = source_range(shuffle_node, node)
             message = message(shuffle_arg, method, method_args, range)
-            add_offense(node, location: range, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          shuffle_node, shuffle_arg, method, method_args =
-            sample_candidate?(node)
 
-          lambda do |corrector|
-            corrector.replace(source_range(shuffle_node, node),
-                              correction(shuffle_arg, method, method_args))
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(
+                source_range(shuffle_node, node), correction(shuffle_arg, method, method_args)
+              )
+            end
           end
         end
 
@@ -92,7 +90,7 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        def range_size(range_node)
+        def range_size(range_node) # rubocop:todo Metrics/CyclomaticComplexity
           vals = range_node.to_a
           return :unknown unless vals.all?(&:int_type?)
 

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

@@ -12,7 +12,9 @@ module RuboCop
       #
       #   # good
       #   x += 1
-      class SelfAssignment < Cop
+      class SelfAssignment < Base
+        extend AutoCorrector
+
         MSG = 'Use self-assignment shorthand `%<method>s=`.'
         OPS = %i[+ - * ** / | &].freeze
 
@@ -32,16 +34,6 @@ module RuboCop
           check(node, :cvar)
         end
 
-        def autocorrect(node)
-          _var_name, rhs = *node
-
-          if rhs.send_type?
-            autocorrect_send_node(node, rhs)
-          elsif %i[and or].include?(rhs.type)
-            autocorrect_boolean_node(node, rhs)
-          end
-        end
-
         private
 
         def check(node, var_type)
@@ -62,7 +54,9 @@ module RuboCop
           target_node = s(var_type, var_name)
           return unless receiver == target_node
 
-          add_offense(node, message: format(MSG, method: method_name))
+          add_offense(node, message: format(MSG, method: method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def check_boolean_node(node, rhs, var_name, var_type)
@@ -72,24 +66,34 @@ module RuboCop
           return unless first_operand == target_node
 
           operator = rhs.loc.operator.source
-          add_offense(node, message: format(MSG, method: operator))
+          add_offense(node, message: format(MSG, method: operator)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect_send_node(node, rhs)
+        def autocorrect(corrector, node)
+          _var_name, rhs = *node
+
+          if rhs.send_type?
+            autocorrect_send_node(corrector, node, rhs)
+          elsif %i[and or].include?(rhs.type)
+            autocorrect_boolean_node(corrector, node, rhs)
+          end
+        end
+
+        def autocorrect_send_node(corrector, node, rhs)
           _receiver, method_name, args = *rhs
-          apply_autocorrect(node, rhs, method_name.to_s, args)
+          apply_autocorrect(corrector, node, rhs, method_name.to_s, args)
         end
 
-        def autocorrect_boolean_node(node, rhs)
+        def autocorrect_boolean_node(corrector, node, rhs)
           _first_operand, second_operand = *rhs
-          apply_autocorrect(node, rhs, rhs.loc.operator.source, second_operand)
+          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, second_operand)
         end
 
-        def apply_autocorrect(node, rhs, operator, new_rhs)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.operator, operator)
-            corrector.replace(rhs.source_range, new_rhs.source)
-          end
+        def apply_autocorrect(corrector, node, rhs, operator, new_rhs)
+          corrector.insert_before(node.loc.operator, operator)
+          corrector.replace(rhs, new_rhs.source)
         end
       end
     end

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
       #
+      # This cop has `AllowAsExpressionSeparator` configuration option.
+      # It allows `;` to separate several expressions on the same line.
+      #
       # @example
       #   # bad
       #   foo = 1; bar = 2;
@@ -15,12 +18,21 @@ module RuboCop
       #   foo = 1
       #   bar = 2
       #   baz = 3
-      class Semicolon < Cop
+      #
+      # @example AllowAsExpressionSeparator: false (default)
+      #   # bad
+      #   foo = 1; bar = 2
+      #
+      # @example AllowAsExpressionSeparator: true
+      #   # good
+      #   foo = 1; bar = 2
+      class Semicolon < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use semicolons to terminate expressions.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           @processed_source = processed_source
@@ -28,7 +40,7 @@ module RuboCop
           check_for_line_terminator_or_opener
         end
 
-        def on_begin(node)
+        def on_begin(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if cop_config['AllowAsExpressionSeparator']
 
           exprs = node.children
@@ -36,8 +48,8 @@ module RuboCop
           return if exprs.size < 2
 
           # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map { |e| e.source_range.line }
-          lines = exprs_lines.group_by { |i| i }
+          exprs_lines = exprs.map(&:first_line)
+          lines = exprs_lines.group_by(&:itself)
 
           lines.each do |line, expr_on_line|
             # Every line with more than one expression on it is a
@@ -55,15 +67,12 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          return unless range
-
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def check_for_line_terminator_or_opener
+          # Make the obvious check first
+          return unless @processed_source.raw_source.include?(';')
+
           each_semicolon { |line, column| convention_on(line, column, true) }
         end
 
@@ -82,7 +91,9 @@ module RuboCop
           range = source_range(@processed_source.buffer, line, column)
           # Don't attempt to autocorrect if semicolon is separating statements
           # on the same line
-          add_offense(autocorrect ? range : nil, location: range)
+          add_offense(range) do |corrector|
+            corrector.remove(range) if autocorrect
+          end
         end
       end
     end

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

@@ -13,16 +13,15 @@ module RuboCop
       #   # good
       #   Foo.__send__(:bar)
       #   quuz.public_send(:fred)
-      class Send < Cop
+      class Send < Base
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
               '`send`.'
-
-        def_node_matcher :sending?, '({send csend} _ :send ...)'
+        RESTRICT_ON_SEND = %i[send].freeze
 
         def on_send(node)
-          return unless sending?(node) && node.arguments?
+          return unless node.arguments?
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
         alias on_csend on_send
       end

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

@@ -104,18 +104,21 @@ module RuboCop
       #
       #   explicit_receiver.fail
       #   explicit_receiver.raise
-      class SignalException < Cop
+      class SignalException < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
         RAISE_MSG = 'Use `raise` instead of `fail` to ' \
                     'rethrow exceptions.'
 
-        def_node_matcher :kernel_call?, '(send (const nil? :Kernel) %1 ...)'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
+
+        def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
         def_node_search :custom_fail_methods,
                         '{(def :fail ...) (defs _ :fail ...)}'
 
-        def investigate(processed_source)
+        def on_new_investigation
           ast = processed_source.ast
           @custom_fail_defined = ast && custom_fail_methods(ast).any?
         end
@@ -145,20 +148,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            name =
-              case style
-              when :semantic
-                command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
-              when :only_raise then 'raise'
-              when :only_fail then 'fail'
-              end
-
-            corrector.replace(node.loc.selector, name)
-          end
-        end
-
         private
 
         def message(method_name)
@@ -178,8 +167,9 @@ module RuboCop
           each_command_or_kernel_call(method_name, node) do |send_node|
             next if ignored_node?(send_node)
 
-            add_offense(send_node,
-                        location: :selector, message: message(method_name))
+            add_offense(send_node.loc.selector, message: message(method_name)) do |corrector|
+              autocorrect(corrector, send_node)
+            end
             ignore_node(send_node)
           end
         end
@@ -187,10 +177,26 @@ module RuboCop
         def check_send(method_name, node)
           return unless node && command_or_kernel_call?(method_name, node)
 
-          add_offense(node, location: :selector, message: message(method_name))
+          add_offense(node.loc.selector, message: message(method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          name =
+            case style
+            when :semantic
+              command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
+            when :only_raise then 'raise'
+            when :only_fail then 'fail'
+            end
+
+          corrector.replace(node.loc.selector, name)
         end
 
         def command_or_kernel_call?(name, node)
+          return unless node.method?(name)
+
           node.command?(name) || kernel_call?(node, name)
         end
 

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Sometimes using dig method ends up with just a single
+      # argument. In such cases, dig should be replaced with [].
+      #
+      # @example
+      #   # bad
+      #   { key: 'value' }.dig(:key)
+      #   [1, 2, 3].dig(0)
+      #
+      #   # good
+      #   { key: 'value' }[:key]
+      #   [1, 2, 3][0]
+      #
+      #   # good
+      #   { key1: { key2: 'value' } }.dig(:key1, :key2)
+      #   [1, [2, [3]]].dig(1, 1)
+      #
+      #   # good
+      #   keys = %i[key1 key2]
+      #   { key1: { key2: 'value' } }.dig(*keys)
+      #
+      class SingleArgumentDig < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
+        RESTRICT_ON_SEND = %i[dig].freeze
+
+        def_node_matcher :single_argument_dig?, <<~PATTERN
+          (send _ :dig $!splat)
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver
+
+          expression = single_argument_dig?(node)
+          return unless expression
+
+          receiver = node.receiver.source
+          argument = expression.source
+
+          message = format(MSG, receiver: receiver, argument: argument,
+                                original: node.source)
+          add_offense(node, message: message) do |corrector|
+            correct_access = "#{receiver}[#{argument}]"
+            corrector.replace(node, correct_access)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -28,7 +28,9 @@ module RuboCop
       #   foo.reduce do |c, d|
       #     c + d
       #   end
-      class SingleLineBlockParams < Cop
+      class SingleLineBlockParams < Base
+        extend AutoCorrector
+
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
         def on_block(node)
@@ -37,18 +39,41 @@ module RuboCop
           return unless eligible_method?(node)
           return unless eligible_arguments?(node)
 
-          return if args_match?(node.send_node.method_name, node.arguments)
+          method_name = node.send_node.method_name
+          return if args_match?(method_name, node.arguments)
+
+          preferred_block_arguments = build_preferred_arguments_map(node, target_args(method_name))
+          joined_block_arguments = preferred_block_arguments.values.join(', ')
+
+          message = format(MSG, method: method_name, params: joined_block_arguments)
 
-          add_offense(node.arguments)
+          add_offense(node.arguments, message: message) do |corrector|
+            autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments)
+          end
         end
 
         private
 
-        def message(node)
-          method_name = node.parent.send_node.method_name
-          arguments   = target_args(method_name).join(', ')
+        def build_preferred_arguments_map(node, preferred_arguments)
+          preferred_arguments_map = {}
+          node.arguments.each_with_index do |current_lvar, index|
+            preferred_argument = preferred_arguments[index]
+            current_argument = current_lvar.source
+            preferred_argument = "_#{preferred_argument}" if current_argument.start_with?('_')
+            preferred_arguments_map[current_argument] = preferred_argument
+          end
 
-          format(MSG, method: method_name, params: arguments)
+          preferred_arguments_map
+        end
+
+        def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments)
+          corrector.replace(node.arguments, "|#{joined_block_arguments}|")
+
+          node.each_descendant(:lvar) do |lvar|
+            if (preferred_lvar = preferred_block_arguments[lvar.source])
+              corrector.replace(lvar, preferred_lvar)
+            end
+          end
         end
 
         def eligible_arguments?(node)

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

@@ -13,12 +13,20 @@ 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.'
 
@@ -26,29 +34,29 @@ module RuboCop
           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)
-          lambda do |corrector|
-            each_part(node.body) do |part|
-              LineBreakCorrector.break_line_before(
-                range: part, node: node, corrector: corrector,
-                configured_width: configured_indentation_width
-              )
-            end
+        private
 
+        def autocorrect(corrector, node)
+          each_part(node.body) do |part|
             LineBreakCorrector.break_line_before(
-              range: node.loc.end, node: node, corrector: corrector,
-              indent_steps: 0, configured_width: configured_indentation_width
+              range: part, node: node, corrector: corrector,
+              configured_width: configured_indentation_width
             )
-
-            move_comment(node, corrector)
           end
-        end
 
-        private
+          LineBreakCorrector.break_line_before(
+            range: node.loc.end, node: node, corrector: corrector,
+            indent_steps: 0, configured_width: configured_indentation_width
+          )
+
+          move_comment(node, corrector)
+        end
 
         def allow_empty?
           cop_config['AllowIfMethodIsEmpty']
@@ -66,7 +74,7 @@ module RuboCop
 
         def move_comment(node, corrector)
           LineBreakCorrector.move_comment(
-            eol_comment: end_of_line_comment(node.source_range.line),
+            eol_comment: processed_source.comment_at_line(node.source_range.line),
             node: node, corrector: corrector
           )
         end