rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop check for usages of not (`not` or `!`) called on a method
+      # when an inverse of that method can be used instead.
+      # Methods that can be inverted by a not (`not` or `!`) should be defined
+      # in `InverseMethods`
+      # Methods that are inverted by inverting the return
+      # of the block that is passed to the method should be defined in
+      # `InverseBlocks`
+      #
+      # @example
+      #   # bad
+      #   !foo.none?
+      #   !foo.any? { |f| f.even? }
+      #   !foo.blank?
+      #   !(foo == bar)
+      #   foo.select { |f| !f.even? }
+      #   foo.reject { |f| f != 7 }
+      #
+      #   # good
+      #   foo.none?
+      #   foo.blank?
+      #   foo.any? { |f| f.even? }
+      #   foo != bar
+      #   foo == bar
+      #   !!('foo' =~ /^\w+$/)
+      class InverseMethods < Cop
+        include IgnoredNode
+
+        MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'.freeze
+        EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
+        NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
+
+        def_node_matcher :inverse_candidate?, <<-PATTERN
+          {
+            (send $(send (...) $_ ...) :!)
+            (send (block $(send (...) $_) ...) :!)
+            (send (begin $(send (...) $_ ...)) :!)
+          }
+        PATTERN
+
+        def_node_matcher :inverse_block?, <<-PATTERN
+          (block $(send (...) $_) ... { $(send ... :!)
+                                        $(send (...) {:!= :!~} ...)
+                                        (begin ... $(send ... :!))
+                                        (begin ... $(send (...) {:!= :!~} ...))
+                                      })
+        PATTERN
+
+        def on_send(node)
+          return if part_of_ignored_node?(node)
+          inverse_candidate?(node) do |_method_call, method|
+            return unless inverse_methods.key?(method)
+            return if negated?(node)
+
+            add_offense(node,
+                        message: format(MSG, method: method,
+                                             inverse: inverse_methods[method]))
+          end
+        end
+
+        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)
+
+            # Inverse method offenses inside of the block of an inverse method
+            # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
+            # can cause auto-correction to apply improper corrections.
+            ignore_node(block)
+            add_offense(node,
+                        message: format(MSG, method: method,
+                                             inverse: inverse_blocks[method]))
+          end
+        end
+
+        def autocorrect(node)
+          method_call, method = inverse_candidate?(node)
+
+          if method_call && method
+            lambda do |corrector|
+              corrector.remove(not_to_receiver(node, method_call))
+              corrector.replace(method_call.loc.selector,
+                                inverse_methods[method].to_s)
+
+              if EQUALITY_METHODS.include?(method)
+                corrector.remove(end_parentheses(node, method_call))
+              end
+            end
+          else
+            correct_inverse_block(node)
+          end
+        end
+
+        def correct_inverse_block(node)
+          method_call, method, block = inverse_block?(node)
+
+          lambda do |corrector|
+            corrector.replace(method_call.loc.selector,
+                              inverse_blocks[method].to_s)
+            correct_inverse_selector(block, corrector)
+          end
+        end
+
+        def correct_inverse_selector(block, corrector)
+          selector = block.loc.selector.source
+
+          if NEGATED_EQUALITY_METHODS.include?(selector.to_sym)
+            selector[0] = '='
+            corrector.replace(block.loc.selector, selector)
+          else
+            corrector.remove(block.loc.selector)
+          end
+        end
+
+        private
+
+        def inverse_methods
+          @inverse_methods ||= cop_config['InverseMethods']
+                               .merge(cop_config['InverseMethods'].invert)
+        end
+
+        def inverse_blocks
+          @inverse_blocks ||= cop_config['InverseBlocks']
+                              .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,
+                                    method_call.loc.expression.begin_pos)
+        end
+
+        def end_parentheses(node, method_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    method_call.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,10 +8,7 @@ module RuboCop
       # It is configurable to enforce one of the styles for both single line
       # and multiline lambdas as well.
       #
-      # @example
-      #
-      #   # EnforcedStyle: line_count_dependent (default)
-      #
+      # @example EnforcedStyle: line_count_dependent (default)
       #   # bad
       #   f = lambda { |x| x }
       #   f = ->(x) do
@@ -25,10 +21,7 @@ module RuboCop
       #         x
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyle: lambda
-      #
+      # @example EnforcedStyle: lambda
       #   # bad
       #   f = ->(x) { x }
       #   f = ->(x) do
@@ -41,10 +34,7 @@ module RuboCop
       #         x
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyle: literal
-      #
+      # @example EnforcedStyle: literal
       #   # bad
       #   f = lambda { |x| x }
       #   f = lambda do |x|
@@ -60,8 +50,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
-                          '%s lambdas.'.freeze
-        METHOD_MESSAGE = 'Use the `lambda` method for %s lambdas.'.freeze
+                          '%<modifier>s lambdas.'.freeze
+        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s ' \
+                         'lambdas.'.freeze
 
         OFFENDING_SELECTORS = {
           style: {
@@ -71,33 +62,38 @@ module RuboCop
           }
         }.freeze
 
-        TARGET = s(:send, nil, :lambda)
+        def_node_matcher :lambda_node?, '(block $(send nil? :lambda) ...)'
 
         def on_block(node)
-          # We're looking for
-          # (block
-          #   (send nil :lambda)
-          #   ...)
-          block_method, _args, = *node
-
-          return unless block_method == TARGET
+          return unless node.lambda?
 
-          check(node)
-        end
+          selector = node.send_node.source
 
-        private
+          return unless offending_selector?(node, selector)
 
-        def check(node)
-          block_method, _args, = *node
+          add_offense(node,
+                      location: node.send_node.source_range,
+                      message: message(node, selector))
+        end
 
+        def autocorrect(node)
+          block_method, _args = *node
           selector = block_method.source
 
-          if offending_selector?(node, selector)
-            add_offense(node, block_method.source_range,
-                        message(node, selector))
+          # Don't autocorrect if this would change the meaning of the code
+          return if selector == '->' && arg_to_unparenthesized_call?(node)
+
+          lambda do |corrector|
+            if selector == 'lambda'
+              autocorrect_method_to_literal(corrector, node)
+            else
+              autocorrect_literal_to_method(corrector, node)
+            end
           end
         end
 
+        private
+
         def offending_selector?(node, selector)
           lines = node.multiline? ? :multiline : :single_line
 
@@ -107,7 +103,7 @@ module RuboCop
         def message(node, selector)
           message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
 
-          format(message, message_line_modifier(node))
+          format(message, modifier: message_line_modifier(node))
         end
 
         def message_line_modifier(node)
@@ -119,27 +115,11 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          block_method, _args = *node
-          selector = block_method.source
-
-          # Don't autocorrect if this would change the meaning of the code
-          return if selector == '->' && arg_to_unparenthesized_call?(node)
-
-          lambda do |corrector|
-            if selector == 'lambda'
-              autocorrect_method_to_literal(corrector, node)
-            else
-              autocorrect_literal_to_method(corrector, node)
-            end
-          end
-        end
-
         def autocorrect_literal_to_method(corrector, node)
           block_method, args = *node
 
           # Check for unparenthesized args' preceding and trailing whitespaces.
-          remove_unparenthesized_whitespaces(corrector, node)
+          remove_unparenthesized_whitespace(corrector, node)
 
           # Avoid correcting to `lambdado` by inserting whitespace
           # if none exists before or after the lambda arguments.
@@ -166,37 +146,60 @@ module RuboCop
 
         def needs_whitespace?(block_method, args, node)
           selector_end = block_method.loc.selector.end.end_pos
-          args_begin   = args.loc.begin && args.loc.begin.begin_pos
-          args_end     = args.loc.end && args.loc.end.end_pos
           block_begin  = node.loc.begin.begin_pos
-          (block_begin == args_end && selector_end == args_begin) ||
+
+          (block_begin == end_pos(args) && selector_end == begin_pos(args)) ||
             (block_begin == selector_end)
         end
 
+        def begin_pos(node)
+          node.loc.begin && node.loc.begin.begin_pos
+        end
+
+        def end_pos(node)
+          node.loc.end && node.loc.end.end_pos
+        end
+
         def lambda_arg_string(args)
           args.children.map(&:source).join(', ')
         end
 
-        def arg_to_unparenthesized_call?(node)
-          parent = node.parent
+        def arg_to_unparenthesized_call?(arg_node)
+          parent = arg_node.parent
+
+          if parent && parent.pair_type?
+            arg_node = parent.parent
+            parent = arg_node.parent
+          end
+
           return false unless parent && parent.send_type?
           return false if parenthesized_call?(parent)
 
-          node.sibling_index > 1
+          arg_node.sibling_index > 1
         end
 
-        def remove_unparenthesized_whitespaces(corrector, node)
-          block_method, args = *node
+        def remove_unparenthesized_whitespace(corrector, node)
+          args = node.arguments
+
           return unless unparenthesized_literal_args?(args)
-          # First, remove leading whitespaces (beetween arrow and args)
+
+          remove_leading_whitespace(node, corrector)
+          remove_trailing_whitespace(node, corrector)
+        end
+
+        def remove_leading_whitespace(node, corrector)
           corrector.remove_preceding(
-            args.source_range,
-            args.source_range.begin_pos - block_method.source_range.end_pos
+            node.arguments.source_range,
+            node.arguments.source_range.begin_pos -
+              node.send_node.source_range.end_pos
           )
+        end
 
-          # Then, remove trailing whitespaces (beetween args and 'do')
-          delta = node.loc.begin.begin_pos - args.source_range.end_pos - 1
-          corrector.remove_preceding(node.loc.begin, delta)
+        def remove_trailing_whitespace(node, corrector)
+          corrector.remove_preceding(
+            node.loc.begin,
+            node.loc.begin.begin_pos - node.arguments.source_range.end_pos - 1
+          )
         end
 
         def unparenthesized_literal_args?(args)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,57 +5,88 @@ module RuboCop
     module Style
       # This cop checks for use of the lambda.(args) syntax.
       #
-      # @example
-      #
+      # @example EnforcedStyle: call (default)
       #  # bad
       #  lambda.(x, y)
       #
       #  # good
       #  lambda.call(x, y)
+      #
+      # @example EnforcedStyle: braces
+      #  # bad
+      #  lambda.call(x, y)
+      #
+      #  # good
+      #  lambda.(x, y)
       class LambdaCall < Cop
         include ConfigurableEnforcedStyle
 
         def on_send(node)
-          _receiver, selector, = *node
-
-          # we care only about `call` methods
-          return unless selector == :call
+          return unless node.receiver && node.method?(:call)
 
           if offense?(node)
-            add_offense(node, :expression) { opposite_style_detected }
+            add_offense(node) { opposite_style_detected }
           else
             correct_style_detected
           end
         end
 
-        private
-
-        def offense?(node)
-          # lambda.() does not have a selector
-          style == :call && node.loc.selector.nil? ||
-            style == :braces && node.loc.selector
-        end
-
         def autocorrect(node)
           lambda do |corrector|
-            if style == :call
-              receiver_node, = *node
-              receiver = receiver_node.source
+            if explicit_style?
+              receiver = node.receiver.source
               replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+
               corrector.replace(node.source_range, replacement)
             else
+              add_parentheses(node, corrector) unless node.parenthesized?
               corrector.remove(node.loc.selector)
             end
           end
         end
 
+        private
+
+        def offense?(node)
+          explicit_style? && node.implicit_call? ||
+            implicit_style? && !node.implicit_call?
+        end
+
+        def add_parentheses(node, corrector)
+          if node.arguments.empty?
+            corrector.insert_after(node.source_range, '()')
+          else
+            corrector.replace(args_begin(node), '(')
+            corrector.insert_after(args_end(node), ')')
+          end
+        end
+
+        def args_begin(node)
+          loc = node.loc
+          selector =
+            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+          selector.end.resize(1)
+        end
+
+        def args_end(node)
+          node.loc.expression.end
+        end
+
         def message(_node)
-          if style == :call
+          if explicit_style?
             'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
           else
             'Prefer the use of `lambda.(...)` over `lambda.call(...)`.'
           end
         end
+
+        def implicit_style?
+          style == :braces
+        end
+
+        def explicit_style?
+          style == :call
+        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -23,12 +22,16 @@ module RuboCop
       class LineEndConcatenation < Cop
         MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
               'those strings.'.freeze
-        CONCAT_TOKEN_TYPES = [:tPLUS, :tLSHFT].freeze
+        CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
-        COMPLEX_STRING_EDGE_TOKEN_TYPES = [:tSTRING_BEG, :tSTRING_END].freeze
-        HIGH_PRECEDENCE_OP_TOKEN_TYPES = [:tSTAR2, :tPERCENT, :tDOT,
-                                          :tLBRACK2].freeze
-        QUOTE_DELIMITERS = %w(' ").freeze
+        COMPLEX_STRING_EDGE_TOKEN_TYPES = %i[tSTRING_BEG tSTRING_END].freeze
+        HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT
+                                            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|
@@ -38,9 +41,9 @@ module RuboCop
 
         def autocorrect(operator_range)
           # Include any trailing whitespace so we don't create a syntax error.
-          operator_range = range_with_surrounding_space(operator_range,
-                                                        :right,
-                                                        !:with_newline)
+          operator_range = range_with_surrounding_space(range: operator_range,
+                                                        side: :right,
+                                                        newlines: false)
           one_more_char = operator_range.resize(operator_range.size + 1)
           # Don't create a double backslash at the end of the line, in case
           # there already was a backslash after the concatenation operator.
@@ -53,17 +56,35 @@ module RuboCop
 
         def check_token_set(index)
           predecessor, operator, successor = processed_source.tokens[index, 3]
-          return unless successor
-          return unless CONCAT_TOKEN_TYPES.include?(operator.type)
-          return unless standard_string_literal?(predecessor)
-          return unless standard_string_literal?(successor)
-          return if operator.pos.line == successor.pos.line
+
+          return unless eligible_successor?(successor) &&
+                        eligible_operator?(operator) &&
+                        eligible_predecessor?(predecessor)
+
+          return if operator.line == successor.line
 
           next_successor = token_after_last_string(successor, index)
-          return if next_successor &&
-                    HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type)
 
-          add_offense(operator.pos, operator.pos)
+          return unless eligible_next_successor?(next_successor)
+
+          add_offense(operator.pos, location: operator.pos)
+        end
+
+        def eligible_successor?(successor)
+          successor && standard_string_literal?(successor)
+        end
+
+        def eligible_operator?(operator)
+          CONCAT_TOKEN_TYPES.include?(operator.type)
+        end
+
+        def eligible_next_successor?(next_successor)
+          !(next_successor &&
+            HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type))
+        end
+
+        def eligible_predecessor?(predecessor)
+          standard_string_literal?(predecessor)
         end
 
         def token_after_last_string(successor, base_index)

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks presence of parentheses in method calls containing
+      # parameters. By default, macro methods are ignored. Additional methods
+      # can be added to the `IgnoredMethods` list.
+      #
+      # @example
+      #
+      #   # bad
+      #   array.delete e
+      #
+      #   # good
+      #   array.delete(e)
+      #
+      #   # good
+      #   # Operators don't need parens
+      #   foo == bar
+      #
+      #   # good
+      #   # Setter methods don't need parens
+      #   foo.bar = baz
+      #
+      #   # okay with `puts` listed in `IgnoredMethods`
+      #   puts 'test'
+      #
+      #   # IgnoreMacros: true (default)
+      #
+      #   # good
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      #   # IgnoreMacros: false
+      #
+      #   # bad
+      #   class Foo
+      #     bar :baz
+      #   end
+      class MethodCallWithArgsParentheses < Cop
+        MSG = 'Use parentheses for method calls with arguments.'.freeze
+
+        def on_send(node)
+          return if ignored_method?(node)
+          return unless node.arguments? && !node.parenthesized?
+
+          add_offense(node)
+        end
+        alias on_super on_send
+        alias on_yield on_send
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(args_begin(node), '(')
+            corrector.insert_after(args_end(node), ')')
+          end
+        end
+
+        private
+
+        def ignored_method?(node)
+          node.operator_method? || node.setter_method? ||
+            ignore_macros? && node.macro? ||
+            ignored_list.include?(node.method_name)
+        end
+
+        def ignored_list
+          cop_config['IgnoredMethods'].map(&:to_sym)
+        end
+
+        def ignore_macros?
+          cop_config['IgnoreMacros']
+        end
+
+        def args_begin(node)
+          loc = node.loc
+          selector =
+            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+          selector.end.resize(1)
+        end
+
+        def args_end(node)
+          node.loc.expression.end
+        end
+      end
+    end
+  end
+end