rubocop 0.51.0 → 0.87.0

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

@@ -27,22 +27,35 @@ module RuboCop
       #   foo != bar
       #   foo == bar
       #   !!('foo' =~ /^\w+$/)
+      #   !(foo.class < Numeric) # Checking class hierarchy is allowed
+      #   # Blocks with guard clauses are ignored:
+      #   foo.select do |f|
+      #     next if f.zero?
+      #     f != 1
+      #   end
       class InverseMethods < Cop
         include IgnoredNode
+        include RangeHelp
 
-        MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'.freeze
+        MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
+        CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
         EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
+        CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
-        def_node_matcher :inverse_candidate?, <<-PATTERN
+        def self.autocorrect_incompatible_with
+          [Style::Not, Style::SymbolProc]
+        end
+
+        def_node_matcher :inverse_candidate?, <<~PATTERN
           {
-            (send $(send (...) $_ ...) :!)
-            (send (block $(send (...) $_) ...) :!)
-            (send (begin $(send (...) $_ ...)) :!)
+            (send $(send $(...) $_ $...) :!)
+            (send (block $(send $(...) $_) $...) :!)
+            (send (begin $(send $(...) $_ $...)) :!)
           }
         PATTERN
 
-        def_node_matcher :inverse_block?, <<-PATTERN
+        def_node_matcher :inverse_block?, <<~PATTERN
           (block $(send (...) $_) ... { $(send ... :!)
                                         $(send (...) {:!= :!~} ...)
                                         (begin ... $(send ... :!))
@@ -52,8 +65,10 @@ module RuboCop
 
         def on_send(node)
           return if part_of_ignored_node?(node)
-          inverse_candidate?(node) do |_method_call, method|
+
+          inverse_candidate?(node) do |_method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
+            return if possible_class_hierarchy_check?(lhs, rhs, method)
             return if negated?(node)
 
             add_offense(node,
@@ -66,6 +81,7 @@ module RuboCop
           inverse_block?(node) do |_method_call, method, block|
             return unless inverse_blocks.key?(method)
             return if negated?(node) && negated?(node.parent)
+            return if node.each_node(:next).any?
 
             # Inverse method offenses inside of the block of an inverse method
             # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
@@ -78,20 +94,22 @@ module RuboCop
         end
 
         def autocorrect(node)
-          method_call, method = inverse_candidate?(node)
+          if node.block_type?
+            correct_inverse_block(node)
+          elsif node.send_type?
+            correct_inverse_method(node)
+          end
+        end
 
-          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)
+        def correct_inverse_method(node)
+          method_call, _lhs, method, _rhs = inverse_candidate?(node)
+          return unless method_call && method
 
-              if EQUALITY_METHODS.include?(method)
-                corrector.remove(end_parentheses(node, method_call))
-              end
-            end
-          else
-            correct_inverse_block(node)
+          lambda do |corrector|
+            corrector.remove(not_to_receiver(node, method_call))
+            corrector.replace(method_call.loc.selector,
+                              inverse_methods[method].to_s)
+            remove_end_parenthesis(corrector, node, method, method_call)
           end
         end
 
@@ -106,13 +124,19 @@ module RuboCop
         end
 
         def correct_inverse_selector(block, corrector)
-          selector = block.loc.selector.source
+          selector_loc = block.loc.selector
+          selector = selector_loc.source
 
           if NEGATED_EQUALITY_METHODS.include?(selector.to_sym)
             selector[0] = '='
-            corrector.replace(block.loc.selector, selector)
+            corrector.replace(selector_loc, selector)
           else
-            corrector.remove(block.loc.selector)
+            if block.loc.dot
+              range = dot_range(block.loc)
+              corrector.remove(range)
+            end
+
+            corrector.remove(selector_loc)
           end
         end
 
@@ -143,6 +167,30 @@ module RuboCop
                                     method_call.loc.expression.end_pos,
                                     node.loc.expression.end_pos)
         end
+
+        # When comparing classes, `!(Integer < Numeric)` is not the same as
+        # `Integer > Numeric`.
+        def possible_class_hierarchy_check?(lhs, rhs, method)
+          CLASS_COMPARISON_METHODS.include?(method) &&
+            (camel_case_constant?(lhs) ||
+             (rhs.size == 1 &&
+              camel_case_constant?(rhs.first)))
+        end
+
+        def camel_case_constant?(node)
+          node.const_type? && CAMEL_CASE.match?(node.source)
+        end
+
+        def dot_range(loc)
+          range_between(loc.dot.begin_pos, loc.expression.end_pos)
+        end
+
+        def remove_end_parenthesis(corrector, node, method, method_call)
+          return unless EQUALITY_METHODS.include?(method) ||
+                        method_call.parent.begin_type?
+
+          corrector.remove(end_parentheses(node, method_call))
+        end
       end
     end
   end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'resolv'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for hardcoded IP addresses, which can make code
+      # brittle. IP addresses are likely to need to be changed when code
+      # is deployed to a different server or environment, which may break
+      # a deployment if forgotten. Prefer setting IP addresses in ENV or
+      # other configuration.
+      #
+      # @example
+      #
+      #   # bad
+      #   ip_address = '127.59.241.29'
+      #
+      #   # good
+      #   ip_address = ENV['DEPLOYMENT_IP_ADDRESS']
+      class IpAddresses < Cop
+        include StringHelp
+
+        IPV6_MAX_SIZE = 45 # IPv4-mapped IPv6 is the longest
+        MSG = 'Do not hardcode IP addresses.'
+
+        def offense?(node)
+          contents = node.source[1...-1]
+          return false if contents.empty?
+
+          return false if allowed_addresses.include?(contents.downcase)
+
+          # To try to avoid doing two regex checks on every string,
+          # shortcut out if the string does not look like an IP address
+          return false unless could_be_ip?(contents)
+
+          ::Resolv::IPv4::Regex.match?(contents) || ::Resolv::IPv6::Regex.match?(contents)
+        end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def opposite_style_detected; end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def correct_style_detected; end
+
+        private
+
+        def allowed_addresses
+          allowed_addresses = cop_config['AllowedAddresses']
+          Array(allowed_addresses).map(&:downcase)
+        end
+
+        def could_be_ip?(str)
+          # If the string is too long, it can't be an IP
+          return false if too_long?(str)
+
+          # If the string doesn't start with a colon or hexadecimal char,
+          # we know it's not an IP address
+          starts_with_hex_or_colon?(str)
+        end
+
+        def too_long?(str)
+          str.size > IPV6_MAX_SIZE
+        end
+
+        def starts_with_hex_or_colon?(str)
+          first_char = str[0].ord
+          (48..58).cover?(first_char) || (65..70).cover?(first_char) ||
+            (97..102).cover?(first_char)
+        end
+      end
+    end
+  end
+end

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

@@ -8,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
@@ -24,10 +21,7 @@ module RuboCop
       #         x
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyle: lambda
-      #
+      # @example EnforcedStyle: lambda
       #   # bad
       #   f = ->(x) { x }
       #   f = ->(x) do
@@ -40,10 +34,7 @@ module RuboCop
       #         x
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyle: literal
-      #
+      # @example EnforcedStyle: literal
       #   # bad
       #   f = lambda { |x| x }
       #   f = lambda do |x|
@@ -59,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.'
+        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s ' \
+                         'lambdas.'
 
         OFFENDING_SELECTORS = {
           style: {
@@ -70,8 +62,6 @@ module RuboCop
           }
         }.freeze
 
-        def_node_matcher :lambda_node?, '(block $(send nil? :lambda) ...)'
-
         def on_block(node)
           return unless node.lambda?
 
@@ -83,6 +73,17 @@ module RuboCop
                       location: node.send_node.source_range,
                       message: message(node, selector))
         end
+        alias on_numblock on_block
+
+        def autocorrect(node)
+          if node.send_node.source == 'lambda'
+            lambda do |corrector|
+              autocorrect_method_to_literal(corrector, node)
+            end
+          else
+            LambdaLiteralToMethodCorrector.new(node)
+          end
+        end
 
         private
 
@@ -95,7 +96,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)
@@ -107,112 +108,24 @@ 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_whitespace(corrector, node)
-
-          # Avoid correcting to `lambdado` by inserting whitespace
-          # if none exists before or after the lambda arguments.
-          if needs_whitespace?(block_method, args, node)
-            corrector.insert_before(node.loc.begin, ' ')
-          end
-          corrector.replace(block_method.source_range, 'lambda')
-          corrector.remove(args.source_range) if args.source_range
-          return if args.children.empty?
-          arg_str = " |#{lambda_arg_string(args)}|"
-          corrector.insert_after(node.loc.begin, arg_str)
-        end
-
         def autocorrect_method_to_literal(corrector, node)
-          block_method, args = *node
-          corrector.replace(block_method.source_range, '->')
-          return if args.children.empty?
-
-          arg_str = "(#{lambda_arg_string(args)})"
-          whitespace_and_old_args = node.loc.begin.end.join(args.loc.end)
-          corrector.insert_after(block_method.source_range, arg_str)
-          corrector.remove(whitespace_and_old_args)
-        end
+          corrector.replace(node.send_node, '->')
 
-        def needs_whitespace?(block_method, args, node)
-          selector_end = block_method.loc.selector.end.end_pos
-          block_begin  = node.loc.begin.begin_pos
+          return unless node.arguments?
 
-          (block_begin == end_pos(args) && selector_end == begin_pos(args)) ||
-            (block_begin == selector_end)
-        end
+          arg_str = "(#{lambda_arg_string(node.arguments)})"
 
-        def begin_pos(node)
-          node.loc.begin && node.loc.begin.begin_pos
+          corrector.insert_after(node.send_node, arg_str)
+          corrector.remove(arguments_with_whitespace(node))
         end
 
-        def end_pos(node)
-          node.loc.end && node.loc.end.end_pos
+        def arguments_with_whitespace(node)
+          node.loc.begin.end.join(node.arguments.loc.end)
         end
 
         def lambda_arg_string(args)
           args.children.map(&:source).join(', ')
         end
-
-        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)
-
-          arg_node.sibling_index > 1
-        end
-
-        def remove_unparenthesized_whitespace(corrector, node)
-          args = node.arguments
-
-          return unless unparenthesized_literal_args?(args)
-
-          remove_leading_whitespace(node, corrector)
-          remove_trailing_whitespace(node, corrector)
-        end
-
-        def remove_leading_whitespace(node, corrector)
-          corrector.remove_preceding(
-            node.arguments.source_range,
-            node.arguments.source_range.begin_pos -
-              node.send_node.source_range.end_pos
-          )
-        end
-
-        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)
-          args.source_range && args.source_range.begin && !parentheses?(args)
-        end
       end
     end
   end

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

@@ -5,13 +5,19 @@ 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
 
@@ -25,20 +31,13 @@ module RuboCop
           end
         end
 
-        private
-
-        def offense?(node)
-          explicit_style? && node.implicit_call? ||
-            implicit_style? && !node.implicit_call?
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             if explicit_style?
               receiver = node.receiver.source
               replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
 
-              corrector.replace(node.source_range, replacement)
+              corrector.replace(node, replacement)
             else
               add_parentheses(node, corrector) unless node.parenthesized?
               corrector.remove(node.loc.selector)
@@ -46,24 +45,11 @@ module RuboCop
           end
         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
+        private
 
-        def args_end(node)
-          node.loc.expression.end
+        def offense?(node)
+          explicit_style? && node.implicit_call? ||
+            implicit_style? && !node.implicit_call?
         end
 
         def message(_node)

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

@@ -20,17 +20,20 @@ module RuboCop
       #              'bala'
       #
       class LineEndConcatenation < Cop
+        include RangeHelp
+
         MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
-              'those strings.'.freeze
+              'those strings.'
         CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
-        COMPLEX_STRING_EDGE_TOKEN_TYPES = %i[tSTRING_BEG tSTRING_END].freeze
+        COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
+        COMPLEX_STRING_END_TOKEN = :tSTRING_END
         HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT
                                             tLBRACK2].freeze
         QUOTE_DELIMITERS = %w[' "].freeze
 
         def self.autocorrect_incompatible_with
-          [Style::UnneededInterpolation]
+          [Style::RedundantInterpolation]
         end
 
         def investigate(processed_source)
@@ -41,9 +44,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,
-                                                        false)
+          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.
@@ -57,11 +60,9 @@ module RuboCop
         def check_token_set(index)
           predecessor, operator, successor = processed_source.tokens[index, 3]
 
-          return unless eligible_successor?(successor) &&
-                        eligible_operator?(operator) &&
-                        eligible_predecessor?(predecessor)
+          return unless eligible_token_set?(predecessor, operator, successor)
 
-          return if operator.pos.line == successor.pos.line
+          return if operator.line == successor.line
 
           next_successor = token_after_last_string(successor, index)
 
@@ -70,6 +71,12 @@ module RuboCop
           add_offense(operator.pos, location: operator.pos)
         end
 
+        def eligible_token_set?(predecessor, operator, successor)
+          eligible_successor?(successor) &&
+            eligible_operator?(operator) &&
+            eligible_predecessor?(predecessor)
+        end
+
         def eligible_successor?(successor)
           successor && standard_string_literal?(successor)
         end
@@ -89,13 +96,12 @@ module RuboCop
 
         def token_after_last_string(successor, base_index)
           index = base_index + 3
-          begin_token, end_token = COMPLEX_STRING_EDGE_TOKEN_TYPES
-          if successor.type == begin_token
+          if successor.type == COMPLEX_STRING_BEGIN_TOKEN
             ends_to_find = 1
-            while ends_to_find > 0
+            while ends_to_find.positive?
               case processed_source.tokens[index].type
-              when begin_token then ends_to_find += 1
-              when end_token then ends_to_find -= 1
+              when COMPLEX_STRING_BEGIN_TOKEN then ends_to_find += 1
+              when COMPLEX_STRING_END_TOKEN then ends_to_find -= 1
               end
               index += 1
             end
@@ -107,7 +113,7 @@ module RuboCop
           case token.type
           when SIMPLE_STRING_TOKEN_TYPE
             true
-          when *COMPLEX_STRING_EDGE_TOKEN_TYPES
+          when COMPLEX_STRING_BEGIN_TOKEN, COMPLEX_STRING_END_TOKEN
             QUOTE_DELIMITERS.include?(token.text)
           else
             false