rubocop 0.72.0 → 0.76.0

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Check that cop names in rubocop:disable comments are given with
+      # department name.
+      class DepartmentName < Cop
+        include RangeHelp
+
+        MSG = 'Department name is missing.'
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next if comment.text !~ /\A(# *rubocop:((dis|en)able|todo) +)(.*)/
+
+            offset = Regexp.last_match(1).length
+            Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
+              check_cop_name(name, comment, offset)
+              offset += name.length
+            end
+          end
+        end
+
+        def autocorrect(range)
+          shall_warn = false
+          qualified_cop_name = Cop.registry.qualified_cop_name(range.source,
+                                                               nil, shall_warn)
+          ->(corrector) { corrector.replace(range, qualified_cop_name) }
+        end
+
+        private
+
+        def check_cop_name(name, comment, offset)
+          return if name !~ /^[A-Z]/ || name =~ %r{/}
+
+          start = comment.location.expression.begin_pos + offset
+          range = range_between(start, start + name.length)
+          add_offense(range, location: range)
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module RuboCop
 
       def configured_indentation_width
         cop_config['IndentationWidth'] ||
-          config.for_cop('IndentationWidth')['Width']
+          config.for_cop('Layout/IndentationWidth')['Width']
       end
 
       def indentation(node)

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

@@ -25,7 +25,7 @@ module RuboCop
         processed_source[0..index].map(&:strip)
       end
 
-      def_node_matcher :non_public_modifier?, <<-PATTERN
+      def_node_matcher :non_public_modifier?, <<~PATTERN
         (send nil? {:private :protected} ({def defs} ...))
       PATTERN
     end

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

@@ -9,8 +9,6 @@ module RuboCop
 
       private
 
-      def_node_matcher :constant_definition?, '{class module casgn}'
-
       def documentation_comment?(node)
         preceding_lines = preceding_lines(node)
 

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

@@ -8,7 +8,7 @@ module RuboCop
 
       private
 
-      def_node_matcher :empty_arguments?, <<-PATTERN
+      def_node_matcher :empty_arguments?, <<~PATTERN
         (block _ $(args) _)
       PATTERN
 

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

@@ -5,12 +5,12 @@ module RuboCop
     # Common functionality for enforcing a specific superclass
     module EnforceSuperclass
       def self.included(base)
-        base.def_node_matcher :class_definition, <<-PATTERN
-        (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
+        base.def_node_matcher :class_definition, <<~PATTERN
+          (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
         PATTERN
 
-        base.def_node_matcher :class_new_definition, <<-PATTERN
-        [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
+        base.def_node_matcher :class_new_definition, <<~PATTERN
+          [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
         PATTERN
       end
 

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

@@ -12,7 +12,7 @@ module RuboCop
 
       def frozen_string_literal_comment_exists?
         leading_comment_lines.any? do |line|
-          MagicComment.parse(line).frozen_string_literal_specified?
+          MagicComment.parse(line).valid_literal_value?
         end
       end
 

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with string interpolations.
+    #
+    # @abstract Subclasses are expected to implement {#on_interpolation}.
+    module Interpolation
+      def on_dstr(node)
+        on_node_with_interpolations(node)
+      end
+
+      alias on_xstr on_dstr
+      alias on_dsym on_dstr
+      alias on_regexp on_dstr
+
+      def on_node_with_interpolations(node)
+        node.each_child_node(:begin) do |begin_node|
+          on_interpolation(begin_node)
+        end
+      end
+
+      # @!method on_interpolation(begin_node)
+      #   Inspect the `:begin` node of an interpolation
+    end
+  end
+end

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

@@ -20,7 +20,7 @@ module RuboCop
 
       private
 
-      def_node_matcher :define_method?, <<-PATTERN
+      def_node_matcher :define_method?, <<~PATTERN
         (block
          (send nil? :define_method ({sym str} $_))
          args
@@ -32,13 +32,14 @@ module RuboCop
         return unless node.body
 
         max = cop_config['Max']
-        complexity = complexity(node.body)
+        complexity, abc_vector = complexity(node.body)
 
         return unless complexity > max
 
         msg = format(self.class::MSG,
                      method: method_name,
                      complexity: complexity,
+                     abc_vector: abc_vector,
                      max: max)
 
         add_offense(node, message: msg) do

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

@@ -159,11 +159,11 @@ module RuboCop
           break false if a.block_type?
 
           next if a.setter_method?
+          next unless kind == :with_or_without_parentheses ||
+                      kind == :with_parentheses && parentheses?(a)
 
           a.arguments.any? do |arg|
-            within_node?(node, arg) && (kind == :with_or_without_parentheses ||
-                                        kind == :with_parentheses &&
-                                        parentheses?(node.parent))
+            within_node?(node, arg)
           end
         end
       end

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

@@ -19,6 +19,18 @@ module RuboCop
         aligned_with_adjacent_line?(range, method(:aligned_operator?))
       end
 
+      def aligned_with_preceding_assignment(token)
+        preceding_line_range = token.line.downto(1)
+
+        aligned_with_assignment(token, preceding_line_range)
+      end
+
+      def aligned_with_subsequent_assignment(token)
+        subsequent_line_range = token.line.upto(processed_source.lines.length)
+
+        aligned_with_assignment(token, subsequent_line_range)
+      end
+
       def aligned_with_adjacent_line?(range, predicate)
         # minus 2 because node.loc.line is zero-based
         pre  = (range.line - 2).downto(0)
@@ -89,6 +101,81 @@ module RuboCop
       def aligned_identical?(range, line)
         range.source == line[range.column, range.size]
       end
+
+      def aligned_with_assignment(token, line_range)
+        token_line_indent    = processed_source
+                               .line_indentation(token.line)
+        assignment_lines     = relevant_assignment_lines(line_range)
+        relevant_line_number = assignment_lines[1]
+
+        return :none unless relevant_line_number
+
+        relevant_indent = processed_source
+                          .line_indentation(relevant_line_number)
+
+        return :none if relevant_indent < token_line_indent
+
+        assignment_line = processed_source.lines[relevant_line_number - 1]
+
+        return :none unless assignment_line
+
+        aligned_assignment?(token.pos, assignment_line) ? :yes : :no
+      end
+
+      def assignment_lines
+        @assignment_lines ||= assignment_tokens.map(&:line)
+      end
+
+      def assignment_tokens
+        @assignment_tokens ||= begin
+          tokens = processed_source.tokens.select(&:equal_sign?)
+
+          # we don't want to operate on equals signs which are part of an
+          #   optarg in a method definition
+          # e.g.: def method(optarg = default_val); end
+          tokens = remove_optarg_equals(tokens, processed_source)
+
+          # Only attempt to align the first = on each line
+          Set.new(tokens.uniq(&:line))
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
+      def relevant_assignment_lines(line_range)
+        result                        = []
+        original_line_indent          = processed_source
+                                        .line_indentation(line_range.first)
+        relevant_line_indent_at_level = true
+
+        line_range.each do |line_number|
+          current_line_indent = processed_source.line_indentation(line_number)
+          blank_line          = processed_source.lines[line_number - 1].blank?
+
+          if (current_line_indent < original_line_indent && !blank_line) ||
+             (relevant_line_indent_at_level && blank_line)
+            break
+          end
+
+          result << line_number if assignment_lines.include?(line_number) &&
+                                   current_line_indent == original_line_indent
+
+          unless blank_line
+            relevant_line_indent_at_level = \
+              current_line_indent == original_line_indent
+          end
+        end
+
+        result
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
+
+      def remove_optarg_equals(asgn_tokens, processed_source)
+        optargs    = processed_source.ast.each_node(:optarg)
+        optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
+        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
+      end
     end
   end
 end

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

@@ -3,6 +3,8 @@
 module RuboCop
   module Cop
     # Common functionality for Rails safe mode.
+    #
+    # This module can be removed from RuboCop 0.76.
     module SafeMode
       private
 

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

@@ -41,10 +41,13 @@ module RuboCop
       end
 
       def length_in_modifier_form(node, cond, body_length)
-        indentation = node.loc.keyword.column * indentation_multiplier
-        kw_length = node.loc.keyword.size
+        keyword = node.loc.keyword
+
+        indentation = keyword.column * indentation_multiplier
+        kw_length = keyword.size
         cond_length = cond.source_range.size
         space = 1
+
         indentation + body_length + space + kw_length + space + cond_length
       end
 

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

@@ -9,6 +9,8 @@ module RuboCop
       NO_SPACE_COMMAND = 'Do not use'
       SPACE_COMMAND = 'Use'
 
+      SINGLE_SPACE_REGEXP = /[ \t]/.freeze
+
       private
 
       def side_space_range(range:, side:)
@@ -18,11 +20,11 @@ module RuboCop
         begin_pos = range.begin_pos
         end_pos = range.end_pos
         if side == :left
+          end_pos = begin_pos
           begin_pos = reposition(src, begin_pos, -1)
-          end_pos -= 1
         end
         if side == :right
-          begin_pos += 1
+          begin_pos = end_pos
           end_pos = reposition(src, end_pos, 1)
         end
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
@@ -85,15 +87,15 @@ module RuboCop
         return false unless token
 
         if side == :left
-          String(token.space_after?) == ' '
+          String(token.space_after?) =~ SINGLE_SPACE_REGEXP
         else
-          String(token.space_before?) == ' '
+          String(token.space_before?) =~ SINGLE_SPACE_REGEXP
         end
       end
 
       def reposition(src, pos, step)
         offset = step == -1 ? -1 : 0
-        pos += step while src[pos + offset] =~ /[ \t]/
+        pos += step while src[pos + offset] =~ SINGLE_SPACE_REGEXP
         pos.negative? ? 0 : pos
       end
 

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

@@ -18,12 +18,7 @@ module RuboCop
 
       def check(node, items, kind, begin_pos, end_pos)
         after_last_item = range_between(begin_pos, end_pos)
-
-        # If there is any heredoc in items, then match the comma succeeding
-        # any whitespace (except newlines), otherwise allow for newlines
-        comma_regex = any_heredoc?(items) ? /\A[^\S\n]*,/ : /\A\s*,/
-        comma_offset = after_last_item.source =~ comma_regex &&
-                       after_last_item.source.index(',')
+        comma_offset = comma_offset(items, after_last_item)
 
         if comma_offset && !inside_comment?(after_last_item, comma_offset)
           check_comma(node, kind, after_last_item.begin_pos + comma_offset)
@@ -32,6 +27,13 @@ module RuboCop
         end
       end
 
+      def comma_offset(items, range)
+        # If there is any heredoc in items, then match the comma succeeding
+        # any whitespace (except newlines), otherwise allow for newlines
+        comma_regex = any_heredoc?(items) ? /\A[^\S\n]*,/ : /\A\s*,/
+        range.source =~ comma_regex && range.source.index(',')
+      end
+
       def check_comma(node, kind, comma_pos)
         return if should_have_comma?(style, node)
 

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

@@ -20,7 +20,7 @@ module RuboCop
         OP_LIKE_METHODS = %i[eql? equal?].freeze
         BLACKLISTED = %i[+@ -@ [] []= << === `].freeze
 
-        def_node_matcher :op_method_candidate?, <<-PATTERN
+        def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
         PATTERN
 

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

@@ -23,7 +23,7 @@ module RuboCop
         # than just standard ASCII characters
         SNAKE_CASE = /^[[:digit:][:upper:]_]+$/.freeze
 
-        def_node_matcher :class_or_struct_return_method?, <<-PATTERN
+        def_node_matcher :class_or_struct_return_method?, <<~PATTERN
           (send
             (const _ {:Class :Struct}) :new
             ...)
@@ -63,7 +63,7 @@ module RuboCop
             (node.receiver.nil? || !literal_receiver?(node))
         end
 
-        def_node_matcher :literal_receiver?, <<-PATTERN
+        def_node_matcher :literal_receiver?, <<~PATTERN
           {(send literal? ...)
            (send (begin literal?) ...)}
         PATTERN

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

@@ -50,14 +50,11 @@ module RuboCop
         def for_bad_filename(file_path)
           basename = File.basename(file_path)
           msg = if filename_good?(basename)
-                  return unless expect_matching_definition?
-                  return if find_class_or_module(processed_source.ast,
-                                                 to_namespace(file_path))
+                  return if matching_definition?(file_path)
 
                   no_definition_message(basename, file_path)
                 else
-                  return if ignore_executable_scripts? &&
-                            processed_source.start_with?('#!')
+                  return if bad_filename_allowed?
 
                   other_message(basename)
                 end
@@ -65,6 +62,16 @@ module RuboCop
           yield source_range(processed_source.buffer, 1, 0), msg
         end
 
+        def matching_definition?(file_path)
+          return true unless expect_matching_definition?
+
+          find_class_or_module(processed_source.ast, to_namespace(file_path))
+        end
+
+        def bad_filename_allowed?
+          ignore_executable_scripts? && processed_source.start_with?('#!')
+        end
+
         def no_definition_message(basename, file_path)
           format(MSG_NO_DEFINITION,
                  basename: basename,

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

@@ -6,6 +6,15 @@ module RuboCop
       # This cop makes sure that all methods use the configured style,
       # snake_case or camelCase, for their names.
       #
+      # This cop has `IgnoredPatterns` configuration option.
+      #
+      #   Naming/MethodName:
+      #     IgnoredPatterns:
+      #       - '\A\s*onSelectionBulkChange\s*'
+      #       - '\A\s*onSelectionCleared\s*'
+      #
+      # Method names matching patterns are always allowed.
+      #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
       #   def fooBar; end
@@ -21,11 +30,13 @@ module RuboCop
       #   def fooBar; end
       class MethodName < Cop
         include ConfigurableNaming
+        include IgnoredPattern
 
         MSG = 'Use %<style>s for method names.'
 
         def on_def(node)
-          return if node.operator_method?
+          return if node.operator_method? ||
+                    matches_ignored_pattern?(node.method_name)
 
           check_name(node, node.method_name, node.loc.name)
         end