rubocop 0.93.1 → 1.6.1

data/lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb

@@ -6,7 +6,12 @@ module RuboCop
       module Utils
         # @api private
         #
-        # Helps to calculate code length for the provided node.
+        # Identifies repetitions `&.` on the same variable:
+        #
+        #  my_var&.foo
+        #  my_var&.bar # => repeated
+        #  my_var = baz # => reset
+        #  my_var&.qux # => not repeated
         module RepeatedCsendDiscount
           def reset_repeated_csend
             @repeated_csend = {}

data/lib/rubocop/cop/migration/department_name.rb

@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def qualified_legacy_cop_name(cop_name)
-          legacy_cop_names = RuboCop::ConfigObsoletion::OBSOLETE_COPS.keys
+          legacy_cop_names = RuboCop::ConfigObsoletion.legacy_cop_names
 
           legacy_cop_names.detect do |legacy_cop_name|
             legacy_cop_name.split('/')[1] == cop_name

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -103,7 +103,7 @@ module RuboCop
         # hashes wrapped in a set of curly braces like {foo: 1}.
         # That is, not a kwargs hash. For method calls, this ensures
         # the method call is made with parens.
-        starts_with_bracket = node.loc.begin
+        starts_with_bracket = !node.hash_type? || node.loc.begin
 
         # If the call has a second argument, we can insert a line
         # break before the second argument and the rest of the

data/lib/rubocop/cop/mixin/configurable_numbering.rb

@@ -7,10 +7,11 @@ module RuboCop
     module ConfigurableNumbering
       include ConfigurableFormatting
 
+      implicit_param = /\A_\d+\z/
       FORMATS = {
-        snake_case:  /(?:[[[:lower:]]_]|_\d+)$/,
-        normalcase:  /(?:_\D*|[[[:upper:]][[:lower:]]]\d*)$/,
-        non_integer: /[[[:upper:]][[:lower:]]_]$/
+        snake_case:  /(?:\D|_\d+|\A\d+)\z/,
+        normalcase:  /(?:\D|[^_\d]\d+|\A\d+)\z|#{implicit_param}/,
+        non_integer: /(\D|\A\d+)\z|#{implicit_param}/
       }.freeze
     end
   end

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -2,7 +2,15 @@
 
 module RuboCop
   module Cop
-    # Common functionality for enforcing a specific superclass
+    # Common functionality for enforcing a specific superclass.
+    #
+    # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
+    # Rails department has been extracted to RuboCop Rails gem.
+    # This module is deprecated and will be removed by RuboCop 2.0.
+    # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
+    # with existing RuboCop Rails 2.8 or lower.
+    #
+    # @api private
     module EnforceSuperclass
       def self.included(base)
         base.def_node_matcher :class_definition, <<~PATTERN

data/lib/rubocop/cop/mixin/ignored_methods.rb

@@ -4,15 +4,48 @@ module RuboCop
   module Cop
     # This module encapsulates the ability to ignore certain methods when
     # parsing.
+    # Cops that use `IgnoredMethods` can accept either strings or regexes to match
+    # against.
     module IgnoredMethods
-      private
+      # Configuration for IgnoredMethods. It is added to classes that include
+      # the module so that configuration can be set using the `ignored_methods`
+      # class macro.
+      module Config
+        attr_accessor :deprecated_key
+
+        def ignored_methods(**config)
+          self.deprecated_key = config[:deprecated_key]
+        end
+      end
+
+      def self.included(base)
+        base.extend(Config)
+      end
 
       def ignored_method?(name)
-        ignored_methods.include?(name.to_s)
+        ignored_methods.any? do |value|
+          case value
+          when Regexp
+            value.match? String(name)
+          else
+            value == String(name)
+          end
+        end
       end
 
       def ignored_methods
-        cop_config.fetch('IgnoredMethods', [])
+        keys = %w[IgnoredMethods]
+        keys << deprecated_key if deprecated_key
+
+        cop_config.slice(*keys).values.reduce(&:concat)
+      end
+
+      private
+
+      def deprecated_key
+        return unless self.class.respond_to?(:deprecated_key)
+
+        self.class.deprecated_key&.to_s
       end
     end
   end

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -57,7 +57,7 @@ module RuboCop
       def indentation_difference(line)
         return 0 unless tab_indentation_width
 
-        line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+        (line.index(/[^\t]/) || 0) * (tab_indentation_width - 1)
       end
 
       def tab_indentation_width

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -11,6 +11,12 @@ module RuboCop
       include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
 
+      # Ensure cops that include `MethodComplexity` have the config
+      # `attr_accessor`s that `ignored_method?` needs.
+      def self.included(base)
+        base.extend(IgnoredMethods::Config)
+      end
+
       def on_def(node)
         return if ignored_method?(node.method_name)
 

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -31,7 +31,7 @@ module RuboCop
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        lhs = lhs.parent while lhs.parent&.send_type?
+        lhs = lhs.parent while lhs.parent&.send_type? && lhs.parent.loc.dot
         lhs
       end
 

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -19,7 +19,8 @@ module RuboCop
       def non_eligible_node?(node)
         node.modifier_form? ||
           node.nonempty_line_count > 3 ||
-          processed_source.line_with_comment?(node.loc.last_line)
+          processed_source.line_with_comment?(node.loc.last_line) ||
+          (first_line_comment(node) && code_after(node))
       end
 
       def non_eligible_body?(body)
@@ -41,11 +42,9 @@ module RuboCop
 
       def length_in_modifier_form(node)
         keyword_element = node.loc.keyword
-        end_element = node.loc.end
         code_before = keyword_element.source_line[0...keyword_element.column]
-        code_after = end_element.source_line[end_element.last_column..-1]
         expression = to_modifier_form(node)
-        line_length("#{code_before}#{expression}#{code_after}")
+        line_length("#{code_before}#{expression}#{code_after(node)}")
       end
 
       def to_modifier_form(node)
@@ -64,6 +63,12 @@ module RuboCop
         comment_source unless comment_disables_cop?(comment_source)
       end
 
+      def code_after(node)
+        end_element = node.loc.end
+        code = end_element.source_line[end_element.last_column..-1]
+        code unless code.empty?
+      end
+
       def parenthesize?(node)
         # Parenthesize corrected expression if changing to modifier-if form
         # would change the meaning of the parent expression

data/lib/rubocop/cop/mixin/string_help.rb

@@ -14,7 +14,10 @@ module RuboCop
         return if part_of_ignored_node?(node)
 
         if offense?(node)
-          add_offense(node) { opposite_style_detected }
+          add_offense(node) do |corrector|
+            opposite_style_detected
+            autocorrect(corrector, node) if respond_to?(:autocorrect, true)
+          end
         else
           correct_style_detected
         end

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -16,9 +16,7 @@ module RuboCop
       end
 
       def find_visibility_start(node)
-        node.left_siblings
-            .reverse
-            .find(&method(:visibility_block?))
+        node.left_siblings.reverse.find { |sibling| visibility_block?(sibling) }
       end
 
       # Navigate to find the last protected method

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -3,7 +3,13 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that accessor methods are named properly.
+      # This cop makes sure that accessor methods are named properly. Applies
+      # to both instance and class methods.
+      #
+      # NOTE: Offenses are only registered for methods with the expected
+      # arity. Getters (`get_attribute`) must have no arguments to be
+      # registered, and setters (`set_attribute(value)`) must have exactly
+      # one.
       #
       # @example
       #   # bad
@@ -21,6 +27,14 @@ module RuboCop
       #   # good
       #   def attribute
       #   end
+      #
+      #   # accepted, incorrect arity for getter
+      #   def get_value(attr)
+      #   end
+      #
+      #   # accepted, incorrect arity for setter
+      #   def set_value
+      #   end
       class AccessorMethodName < Base
         MSG_READER = 'Do not prefix reader method names with `get_`.'
         MSG_WRITER = 'Do not prefix writer method names with `set_`.'

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -14,11 +14,13 @@ module RuboCop
       #   # good
       #   def +(other); end
       class BinaryOperatorParameterName < Base
+        extend AutoCorrector
+
         MSG = 'When defining the `%<opr>s` operator, ' \
               'name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
-        EXCLUDED = %i[+@ -@ [] []= << === `].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === ` =~].freeze
 
         def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
@@ -26,7 +28,15 @@ module RuboCop
 
         def on_def(node)
           op_method_candidate?(node) do |name, arg|
-            add_offense(arg, message: format(MSG, opr: name))
+            add_offense(arg, message: format(MSG, opr: name)) do |corrector|
+              corrector.replace(arg, 'other')
+              node.each_descendant(:lvar, :lvasgn) do |lvar|
+                lvar_location = lvar.loc.name
+                next unless lvar_location.source == arg.source
+
+                corrector.replace(lvar_location, 'other')
+              end
+            end
           end
         end
 

data/lib/rubocop/cop/naming/heredoc_delimiter_case.rb

@@ -30,13 +30,19 @@ module RuboCop
       class HeredocDelimiterCase < Base
         include Heredoc
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Use %<style>s heredoc delimiters.'
 
         def on_heredoc(node)
           return if correct_case_delimiters?(node)
 
-          add_offense(node.loc.heredoc_end)
+          add_offense(node.loc.heredoc_end) do |corrector|
+            expr = node.loc.expression
+
+            corrector.replace(expr, correct_delimiters(expr.source))
+            corrector.replace(node.loc.heredoc_end, correct_delimiters(delimiter_string(expr)))
+          end
         end
 
         private
@@ -46,14 +52,14 @@ module RuboCop
         end
 
         def correct_case_delimiters?(node)
-          delimiter_string(node) == correct_delimiters(node)
+          delimiter_string(node) == correct_delimiters(delimiter_string(node))
         end
 
-        def correct_delimiters(node)
+        def correct_delimiters(source)
           if style == :uppercase
-            delimiter_string(node).upcase
+            source.upcase
           else
-            delimiter_string(node).downcase
+            source.downcase
           end
         end
       end

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -20,6 +20,11 @@ module RuboCop
       #     @something ||= calculate_expensive_thing
       #   end
       #
+      #   def foo
+      #     return @something if defined?(@something)
+      #     @something = calculate_expensive_thing
+      #   end
+      #
       #   # good
       #   def _foo
       #     @foo ||= calculate_expensive_thing
@@ -54,6 +59,11 @@ module RuboCop
       #     @foo ||= calculate_expensive_thing
       #   end
       #
+      #   def foo
+      #     return @foo if defined?(@foo)
+      #     @foo = calculate_expensive_thing
+      #   end
+      #
       #   # good
       #   def foo
       #     @_foo ||= calculate_expensive_thing
@@ -64,6 +74,11 @@ module RuboCop
       #     @_foo ||= calculate_expensive_thing
       #   end
       #
+      #   def foo
+      #     return @_foo if defined?(@_foo)
+      #     @_foo = calculate_expensive_thing
+      #   end
+      #
       # @example EnforcedStyleForLeadingUnderscores :optional
       #   # bad
       #   def foo
@@ -84,6 +99,12 @@ module RuboCop
       #   def _foo
       #     @_foo ||= calculate_expensive_thing
       #   end
+      #
+      #   # good
+      #   def foo
+      #     return @_foo if defined?(@_foo)
+      #     @_foo = calculate_expensive_thing
+      #   end
       class MemoizedInstanceVariableName < Base
         include ConfigurableEnforcedStyle
 
@@ -92,32 +113,60 @@ module RuboCop
         UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
           'with `_`. Use `@%<suggested_var>s` instead.'
 
-        def self.node_pattern
-          memo_assign = '(or_asgn $(ivasgn _) _)'
-          memoized_at_end_of_method = "(begin ... #{memo_assign})"
-          instance_method =
-            "(def $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
-          class_method =
-            "(defs self $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
-          "{#{instance_method} #{class_method}}"
-        end
+        # rubocop:disable Metrics/AbcSize
+        def on_or_asgn(node)
+          lhs, _value = *node
+          return unless lhs.ivasgn_type?
+          return unless (method_node = node.each_ancestor(:def, :defs).first)
 
-        private_class_method :node_pattern
-        def_node_matcher :memoized?, node_pattern
+          body = method_node.body
+          return unless body == node || body.children.last == node
 
-        def on_def(node)
-          (method_name, ivar_assign) = memoized?(node)
-          return if matches?(method_name, ivar_assign)
+          method_name = method_node.method_name
+          return if matches?(method_name, lhs)
 
           msg = format(
-            message(ivar_assign.children.first.to_s),
-            var: ivar_assign.children.first.to_s,
+            message(lhs.children.first.to_s),
+            var: lhs.children.first.to_s,
             suggested_var: suggested_var(method_name),
             method: method_name
           )
-          add_offense(ivar_assign.source_range, message: msg)
+          add_offense(lhs, message: msg)
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def_node_matcher :defined_memoized?, <<~PATTERN
+          (begin
+            (if (defined $(ivar %1)) (return $(ivar %1)) nil?)
+            ...
+            $(ivasgn %1 _))
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def on_defined?(node)
+          arg = node.arguments.first
+          return unless arg.ivar_type?
+
+          method_node = node.each_ancestor(:def, :defs).first
+          return unless method_node
+
+          var_name = arg.children.first
+          method_name = method_node.method_name
+          defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
+            return if matches?(method_name, ivar_assign)
+
+            msg = format(
+              message(var_name.to_s),
+              var: var_name.to_s,
+              suggested_var: suggested_var(method_name),
+              method: method_name
+            )
+            add_offense(defined_ivar, message: msg)
+            add_offense(return_ivar, message: msg)
+            add_offense(ivar_assign.loc.name, message: msg)
+          end
         end
-        alias on_defs on_def
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         private
 

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -67,7 +67,8 @@ module RuboCop
         private
 
         def allowed_method_name?(method_name, prefix)
-          !method_name.match?(/^#{prefix}[^0-9]/) ||
+          !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
+              method_name.match?(/^#{prefix}[^0-9]/)) ||
             method_name == expected_name(method_name, prefix) ||
             method_name.end_with?('=') ||
             allowed_method?(method_name)