rubocop 0.52.1 → 0.93.1

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

@@ -14,9 +14,10 @@ module RuboCop
       #
       #   # good
       #   raise ArgumentError, 'Error message here'
-      class ImplicitRuntimeError < Cop
+      class ImplicitRuntimeError < Base
         MSG = 'Use `%<method>s` with an explicit exception class and message,' \
-              ' rather than just a message.'.freeze
+              ' rather than just a message.'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         def_node_matcher :implicit_runtime_error_raise_or_fail,
                          '(send nil? ${:raise :fail} {str dstr})'

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

@@ -15,58 +15,95 @@ module RuboCop
       #   loop do
       #     work
       #   end
-      class InfiniteLoop < Cop
-        LEADING_SPACE = /\A(\s*)/
+      class InfiniteLoop < Base
+        extend AutoCorrector
 
-        MSG = 'Use `Kernel#loop` for infinite loops.'.freeze
+        LEADING_SPACE = /\A(\s*)/.freeze
 
-        def on_while(node)
-          return unless node.condition.truthy_literal?
+        MSG = 'Use `Kernel#loop` for infinite loops.'
 
-          add_offense(node, location: :keyword)
+        def self.joining_forces
+          VariableForce
         end
 
-        def on_until(node)
-          return unless node.condition.falsey_literal?
+        def after_leaving_scope(scope, _variable_table)
+          @variables ||= []
+          @variables.concat(scope.variables.values)
+        end
 
-          add_offense(node, location: :keyword)
+        def on_while(node)
+          while_or_until(node) if node.condition.truthy_literal?
+        end
+
+        def on_until(node)
+          while_or_until(node) if node.condition.falsey_literal?
         end
 
         alias on_while_post on_while
         alias on_until_post on_until
 
-        def autocorrect(node)
+        private
+
+        def while_or_until(node)
+          range = node.source_range
+          # Not every `while true` and `until false` can be turned into a
+          # `loop do` without further modification. The reason is that a
+          # variable that's introduced inside a while/until loop is in scope
+          # outside of that loop too, but a variable that's assigned for the
+          # first time inside a block cannot be accessed after the block. In
+          # those more complicated cases we don't report an offense.
+          return if @variables.any? do |var|
+            assigned_inside_loop?(var, range) &&
+            !assigned_before_loop?(var, range) &&
+            referenced_after_loop?(var, range)
+          end
+
+          add_offense(node.loc.keyword) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
           if node.while_post_type? || node.until_post_type?
-            replace_begin_end_with_modifier(node)
+            replace_begin_end_with_modifier(corrector, node)
           elsif node.modifier_form?
-            replace_source(node.source_range, modifier_replacement(node))
+            replace_source(corrector, node.source_range, modifier_replacement(node))
           else
-            replace_source(non_modifier_range(node), 'loop do')
+            replace_source(corrector, non_modifier_range(node), 'loop do')
           end
         end
 
-        private
+        def assigned_inside_loop?(var, range)
+          var.assignments.any? { |a| range.contains?(a.node.source_range) }
+        end
 
-        def replace_begin_end_with_modifier(node)
-          lambda do |corrector|
-            corrector.replace(node.body.loc.begin, 'loop do')
-            corrector.remove(node.body.loc.end.end.join(node.source_range.end))
-          end
+        def assigned_before_loop?(var, range)
+          b = range.begin_pos
+          var.assignments.any? { |a| a.node.source_range.end_pos < b }
         end
 
-        def replace_source(range, replacement)
-          lambda do |corrector|
-            corrector.replace(range, replacement)
-          end
+        def referenced_after_loop?(var, range)
+          e = range.end_pos
+          var.references.any? { |r| r.node.source_range.begin_pos > e }
+        end
+
+        def replace_begin_end_with_modifier(corrector, node)
+          corrector.replace(node.body.loc.begin, 'loop do')
+          corrector.remove(node.body.loc.end.end.join(node.source_range.end))
+        end
+
+        def replace_source(corrector, range, replacement)
+          corrector.replace(range, replacement)
         end
 
         def modifier_replacement(node)
+          body = node.body
           if node.single_line?
-            'loop { ' + node.body.source + ' }'
+            "loop { #{body.source} }"
           else
-            indentation = node.body.loc.expression.source_line[LEADING_SPACE]
+            indentation = body.source_range.source_line[LEADING_SPACE]
 
-            ['loop do', node.body.source.gsub(/^/, configured_indent),
+            ['loop do', body.source.gsub(/^/, configured_indent),
              'end'].join("\n#{indentation}")
           end
         end
@@ -83,7 +120,7 @@ module RuboCop
         end
 
         def configured_indent
-          ' ' * config.for_cop('IndentationWidth')['Width']
+          ' ' * config.for_cop('Layout/IndentationWidth')['Width']
         end
       end
     end

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

@@ -17,12 +17,14 @@ module RuboCop
       #   foo.each do |f|
       #     f.bar # Trailing inline comment
       #   end
-      class InlineComment < Cop
-        MSG = 'Avoid trailing inline comments.'.freeze
+      class InlineComment < Base
+        MSG = 'Avoid trailing inline comments.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.comments.each do |comment|
-            next if comment_line?(processed_source[comment.loc.line - 1])
+            next if comment_line?(processed_source[comment.loc.line - 1]) ||
+                    comment.text.match?(/\A# rubocop:(enable|disable)/)
+
             add_offense(comment)
           end
         end

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

@@ -27,22 +27,36 @@ module RuboCop
       #   foo != bar
       #   foo == bar
       #   !!('foo' =~ /^\w+$/)
-      class InverseMethods < Cop
+      #   !(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 < Base
         include IgnoredNode
+        include RangeHelp
+        extend AutoCorrector
 
-        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 ... :!))
@@ -51,14 +65,15 @@ module RuboCop
         PATTERN
 
         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 negated?(node)
+            return if part_of_ignored_node?(node)
+            return if possible_class_hierarchy_check?(lhs, rhs, method)
 
-            add_offense(node,
-                        message: format(MSG, method: method,
-                                             inverse: inverse_methods[method]))
+            add_offense(node, message: message(method, inverse_methods[method])) do |corrector|
+              correct_inverse_method(corrector, node)
+            end
           end
         end
 
@@ -66,58 +81,53 @@ 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/) }`,
             # can cause auto-correction to apply improper corrections.
             ignore_node(block)
-            add_offense(node,
-                        message: format(MSG, method: method,
-                                             inverse: inverse_blocks[method]))
+            add_offense(node, message: message(method, inverse_blocks[method])) do |corrector|
+              correct_inverse_block(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
-          method_call, method = inverse_candidate?(node)
+        private
 
-          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(corrector, 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)
-          end
+          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
 
-        def correct_inverse_block(node)
+        def correct_inverse_block(corrector, 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
+          corrector.replace(method_call.loc.selector, inverse_blocks[method].to_s)
+          correct_inverse_selector(block, corrector)
         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
 
-        private
-
         def inverse_methods
           @inverse_methods ||= cop_config['InverseMethods']
                                .merge(cop_config['InverseMethods'].invert)
@@ -143,6 +153,34 @@ 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
+
+        def message(method, inverse)
+          format(MSG, method: method, inverse: inverse)
+        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/keyword_parameters_order.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces that optional keyword parameters are placed at the
+      # end of the parameters list.
+      #
+      # This improves readability, because when looking through the source,
+      # it is expected to find required parameters at the beginning of parameters list
+      # and optional parameters at the end.
+      #
+      # @example
+      #   # bad
+      #   def some_method(first: false, second:, third: 10)
+      #     # body omitted
+      #   end
+      #
+      #   # good
+      #   def some_method(second:, first: false, third: 10)
+      #     # body omitted
+      #   end
+      #
+      class KeywordParametersOrder < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Place optional keyword parameters at the end of the parameters list.'
+
+        def on_kwoptarg(node)
+          kwarg_nodes = node.right_siblings.select(&:kwarg_type?)
+          return if kwarg_nodes.empty?
+
+          add_offense(node) do |corrector|
+            if node.parent.find(&:kwoptarg_type?) == node
+              corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+              remove_kwargs(kwarg_nodes, corrector)
+            end
+          end
+        end
+
+        private
+
+        def remove_kwargs(kwarg_nodes, corrector)
+          kwarg_nodes.each do |kwarg|
+            with_space = range_with_surrounding_space(range: kwarg.source_range)
+            corrector.remove(range_with_surrounding_comma(with_space, :left))
+          end
+        end
+      end
+    end
+  end
+end