rubocop 0.48.1 → 0.49.0

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

@@ -12,7 +12,7 @@ module RuboCop
       #
       # The supported styles are:
       #
-      # * ruby19 - forces use of the 1.9 syntax (e.g. {a: 1}) when hashes have
+      # * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have
       #   all symbols for keys
       # * hash_rockets - forces use of hash rockets for all hashes
       # * no_mixed_keys - simply checks for hashes with mixed syntaxes

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

@@ -42,7 +42,7 @@ module RuboCop
       #   end
       #
       #   @bad
-      #   switch foo
+      #   case foo
       #   when 1
       #     do_x
       #   when 2
@@ -52,7 +52,7 @@ module RuboCop
       #   end
       #
       #   @good
-      #   switch foo
+      #   case foo
       #   when 1
       #     do_x
       #     do_y

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for if and unless statements used as modifers of other if or
+      # Checks for if and unless statements used as modifiers of other if or
       # unless statements.
       #
       # @example

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

@@ -26,8 +26,9 @@ module RuboCop
       #   foo.any? { |f| f.even? }
       #   foo != bar
       #   foo == bar
+      #   !!('foo' =~ /^\w+$/)
       class InverseMethods < Cop
-        MSG = 'Use `%{inverse}` instead of inverting `%{method}`.'.freeze
+        MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'.freeze
         EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
 
         def_node_matcher :inverse_candidate?, <<-PATTERN
@@ -49,6 +50,7 @@ module RuboCop
         def on_send(node)
           inverse_candidate?(node) do |_method_call, method|
             return unless inverse_methods.key?(method)
+            return if negated?(node)
 
             add_offense(node,
                         :expression,
@@ -60,6 +62,7 @@ module RuboCop
         def on_block(node)
           inverse_block?(node) do |_method_call, method, _block|
             return unless inverse_blocks.key?(method)
+            return if negated?(node) && negated?(node.parent)
 
             add_offense(node,
                         :expression,
@@ -103,6 +106,8 @@ module RuboCop
           end
         end
 
+        private
+
         def inverse_methods
           @inverse_methods ||= cop_config['InverseMethods']
                                .merge(cop_config['InverseMethods'].invert)
@@ -113,6 +118,10 @@ module RuboCop
                               .merge(cop_config['InverseBlocks'].invert)
         end
 
+        def negated?(node)
+          node.parent.respond_to?(:method?) && node.parent.method?(:!)
+        end
+
         def not_to_receiver(node, method_call)
           Parser::Source::Range.new(node.loc.expression.source_buffer,
                                     node.loc.selector.begin_pos,

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

@@ -73,15 +73,15 @@ module RuboCop
         def_node_matcher :lambda_node?, '(block $(send nil :lambda) ...)'
 
         def on_block(node)
-          lambda_node?(node) do |block_method|
-            selector = block_method.source
+          return unless node.lambda?
 
-            return unless offending_selector?(node, selector)
+          selector = node.send_node.source
 
-            add_offense(node,
-                        block_method.source_range,
-                        message(node, selector))
-          end
+          return unless offending_selector?(node, selector)
+
+          add_offense(node,
+                      node.send_node.source_range,
+                      message(node, selector))
         end
 
         private
@@ -189,13 +189,13 @@ module RuboCop
         def remove_unparenthesized_whitespaces(corrector, node)
           block_method, args = *node
           return unless unparenthesized_literal_args?(args)
-          # First, remove leading whitespaces (beetween arrow and args)
+          # First, remove leading whitespaces (between arrow and args)
           corrector.remove_preceding(
             args.source_range,
             args.source_range.begin_pos - block_method.source_range.end_pos
           )
 
-          # Then, remove trailing whitespaces (beetween args and 'do')
+          # Then, remove trailing whitespaces (between args and 'do')
           delta = node.loc.begin.begin_pos - args.source_range.end_pos - 1
           corrector.remove_preceding(node.loc.begin, delta)
         end

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

@@ -29,6 +29,10 @@ module RuboCop
                                             tLBRACK2].freeze
         QUOTE_DELIMITERS = %w[' "].freeze
 
+        def self.autocorrect_incompatible_with
+          [Style::UnneededInterpolation]
+        end
+
         def investigate(processed_source)
           processed_source.tokens.each_index do |index|
             check_token_set(index)

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

@@ -50,8 +50,7 @@ module RuboCop
         end
 
         def on_super(node)
-          # super nodetype implies call with arguments.
-          return if parentheses?(node)
+          return if node.parenthesized?
 
           add_offense(node, :keyword)
         end
@@ -93,7 +92,8 @@ module RuboCop
 
         def args_begin(node)
           loc = node.loc
-          selector = node.super_type? ? loc.keyword : loc.selector
+          selector =
+            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
           selector.end.resize(1)
         end
 

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

@@ -16,13 +16,12 @@ module RuboCop
         MSG = 'Avoid chaining a method call on a do...end block.'.freeze
 
         def on_block(node)
-          method, _args, _body = *node
           # If the method that is chained on the do...end block is itself a
           # method with a block, we allow it. It's pretty safe to assume that
           # these calls are not missed by anyone reading code. We also want to
           # avoid double reporting of offenses checked by the
           # MultilineBlockChain cop.
-          ignore_node(method)
+          ignore_node(node.send_node)
         end
 
         def on_send(node)

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

@@ -11,17 +11,23 @@ module RuboCop
 
         def on_def(node)
           name, = *node
-          check_name(node, name, node.loc.name)
+          check_name(node, sanitize_name(name), node.loc.name)
         end
 
         def on_defs(node)
           _object, name, = *node
-          check_name(node, name, node.loc.name)
+          check_name(node, sanitize_name(name), node.loc.name)
         end
 
+        private
+
         def message(style)
           format('Use %s for method names.', style)
         end
+
+        def sanitize_name(name)
+          name.to_s.delete('@').to_sym
+        end
       end
     end
   end

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

@@ -46,6 +46,21 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          if separated_style?
+            range = node.loc.expression
+            correction = separate_mixins(node)
+          else
+            mixins = sibling_mixins(node)
+            mixins.unshift(node)
+
+            range = node.loc.expression.join(mixins.last.loc.expression)
+            correction = group_mixins(node, mixins)
+          end
+
+          ->(corrector) { corrector.replace(range, correction) }
+        end
+
         private
 
         def check(send_node)
@@ -57,7 +72,7 @@ module RuboCop
         end
 
         def check_grouped_style(send_node)
-          return unless sibling_mixins?(send_node)
+          return if sibling_mixins(send_node).empty?
 
           add_offense(send_node, :expression)
         end
@@ -68,11 +83,11 @@ module RuboCop
           add_offense(send_node, :expression)
         end
 
-        def sibling_mixins?(send_node)
+        def sibling_mixins(send_node)
           siblings = send_node.parent.each_child_node(:send)
                               .reject { |sibling| sibling == send_node }
 
-          siblings.any? do |sibling_node|
+          siblings.select do |sibling_node|
             sibling_node.method_name == send_node.method_name
           end
         end
@@ -91,6 +106,29 @@ module RuboCop
         def separated_style?
           style == :separated
         end
+
+        def separate_mixins(node)
+          _receiver, mixin, *args = *node
+          args.reverse!
+          first_mixin = String.new("#{mixin} #{args.first.source}")
+
+          args[1..-1].inject(first_mixin) do |replacement, arg|
+            replacement << "\n#{indent(node)}#{mixin} #{arg.source}"
+          end
+        end
+
+        def group_mixins(node, mixins)
+          _receiver, mixin, *_args = *node
+          all_mixin_arguments = mixins.reverse.flat_map do |m|
+            m.arguments.map(&:source)
+          end
+
+          "#{mixin} #{all_mixin_arguments.join(', ')}"
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
       end
     end
   end

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

@@ -17,20 +17,16 @@ module RuboCop
         MSG = 'Avoid multi-line chains of blocks.'.freeze
 
         def on_block(node)
-          method, _args, _body = *node
-          method.each_node(:send) do |send_node|
-            receiver, _method_name, *_args = *send_node
-            next unless receiver && receiver.block_type?
+          node.send_node.each_node(:send) do |send_node|
+            receiver = send_node.receiver
 
-            # The begin and end could also be braces, but we call the
-            # variables do... and end...
-            do_kw_loc = receiver.loc.begin
-            end_kw_loc = receiver.loc.end
-            next if do_kw_loc.line == end_kw_loc.line
+            next unless receiver && receiver.block_type? && receiver.multiline?
+
+            range = range_between(receiver.loc.end.begin_pos,
+                                  node.send_node.source_range.end_pos)
 
-            range = range_between(end_kw_loc.begin_pos,
-                                  method.source_range.end_pos)
             add_offense(nil, range)
+
             # Done. If there are more blocks in the chain, they will be
             # found by subsequent calls to on_block.
             break

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks against comparing a variable with multiple items, where
+      # `Array#include?` could be used instead to avoid code repetition.
+      #
+      # @example
+      #   # bad
+      #   a = 'a'
+      #   foo if a == 'a' || a == 'b' || a == 'c'
+      #
+      #   # good
+      #   a = 'a'
+      #   foo if ['a', 'b', 'c'].include?(a)
+      class MultipleComparison < Cop
+        MSG = 'Avoid comparing a variable with multiple items' \
+          'in a conditional, use `Array#include?` instead.'.freeze
+
+        def on_if(node)
+          return unless nested_variable_comparison?(node.condition)
+          add_offense(node, :expression)
+        end
+
+        private
+
+        def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
+        def_node_matcher :simple_comparison?, <<-PATTERN
+          {(send $lvar :== _)
+           (send _ :== $lvar)}
+        PATTERN
+
+        def nested_variable_comparison?(node)
+          return false unless nested_comparison?(node)
+          variables_in_node(node).count == 1
+        end
+
+        def variables_in_node(node)
+          if node.or_type?
+            node.node_parts
+                .flat_map { |node_part| variables_in_node(node_part) }
+                .uniq
+          else
+            variables_in_simple_node(node)
+          end
+        end
+
+        def variables_in_simple_node(node)
+          simple_double_comparison?(node) do |var1, var2|
+            return [variable_name(var1), variable_name(var2)]
+          end
+          simple_comparison?(node) do |var|
+            return [variable_name(var)]
+          end
+          []
+        end
+
+        def variable_name(node)
+          node.children[0]
+        end
+
+        def nested_comparison?(node)
+          if node.or_type?
+            node.node_parts.all? { |node_part| comparison? node_part }
+          else
+            false
+          end
+        end
+
+        def comparison?(node)
+          simple_comparison?(node) || nested_comparison?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module RuboCop
       # @example
       #   # bad
       #   [1, 2].each do |a|
-      #     if a == 1 do
+      #     if a == 1
       #       puts a
       #     end
       #   end
@@ -24,11 +24,6 @@ module RuboCop
 
         MSG = 'Use `next` to skip iteration.'.freeze
         EXIT_TYPES = %i[break return].freeze
-        EACH_ = 'each_'.freeze
-        ENUMERATORS = %i[collect collect_concat detect downto each
-                         find find_all find_index inject loop map!
-                         map reduce reject reject! reverse_each select
-                         select! times upto].freeze
 
         def investigate(_processed_source)
           # When correcting nested offenses, we need to keep track of how much
@@ -37,32 +32,26 @@ module RuboCop
         end
 
         def on_block(node)
-          block_owner, _, body = *node
-          return unless block_owner.send_type?
-          return unless body && ends_with_condition?(body)
+          return unless node.send_node.send_type? &&
+                        node.send_node.enumerator_method?
 
-          _, method_name = *block_owner
-          return unless enumerator?(method_name)
-
-          offense_node = offense_node(body)
-          add_offense(offense_node, offense_location(offense_node), MSG)
+          check(node)
         end
 
         def on_while(node)
-          return unless node.body && ends_with_condition?(node.body)
-
-          offending_node = offense_node(node.body)
-
-          add_offense(offending_node, offense_location(offending_node), MSG)
+          check(node)
         end
         alias on_until on_while
         alias on_for on_while
 
         private
 
-        def enumerator?(method_name)
-          ENUMERATORS.include?(method_name) ||
-            method_name.to_s.start_with?(EACH_)
+        def check(node)
+          return unless node.body && ends_with_condition?(node.body)
+
+          offending_node = offense_node(node.body)
+
+          add_offense(offending_node, offense_location(offending_node))
         end
 
         def ends_with_condition?(body)

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

@@ -142,13 +142,18 @@ module RuboCop
 
             @assignments.each do |other|
               _other_lhs, other_rhs = *other
-              if ((var = var_name(my_lhs)) && uses_var?(other_rhs, var)) ||
-                 (my_lhs.asgn_method_call? && accesses?(other_rhs, my_lhs))
-                yield other
-              end
+
+              next unless dependency?(my_lhs, other_rhs)
+
+              yield other
             end
           end
 
+          def dependency?(lhs, rhs)
+            uses_var?(rhs, var_name(lhs)) ||
+              lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs)
+          end
+
           # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.
           # Does `rhs` access the same value which is assigned by `lhs`?
           def accesses?(rhs, lhs)
@@ -164,21 +169,7 @@ module RuboCop
         end
 
         def modifier_statement?(node)
-          node &&
-            ((node.if_type? && node.modifier_form?) ||
-            ((node.while_type? || node.until_type?) && modifier_while?(node)))
-        end
-
-        def modifier_while?(node)
-          node.loc.respond_to?(:keyword) &&
-            %w[while until].include?(node.loc.keyword.source) &&
-            node.modifier_form?
-        end
-
-        def rescue_modifier_old?(node)
-          node && node.rescue_type? &&
-            (node.parent.nil? || !(node.parent.kwbegin_type? ||
-            node.parent.ensure_type?))
+          node && %i[if while until].include?(node.type) && node.modifier_form?
         end
 
         # An internal class for correcting parallel assignment