rubocop 0.85.0 → 0.88.0

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain methods when
+    # parsing.
+    module AllowedMethods
+      private
+
+      def allowed_method?(name)
+        allowed_methods.include?(name.to_s)
+      end
+
+      def allowed_methods
+        cop_config.fetch('AllowedMethods', [])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # extend this module to signal autocorrection support
+    module AutoCorrector
+      def support_autocorrect?
+        true
+      end
+    end
+  end
+end

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

@@ -16,6 +16,10 @@ module RuboCop
         cop_config['CountComments']
       end
 
+      def count_as_one
+        Array(cop_config['CountAsOne']).map(&:to_sym)
+      end
+
       def check_code_length(node)
         length = code_length(node)
 

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

@@ -10,7 +10,7 @@ module RuboCop
         if valid_name?(node, name)
           correct_style_detected
         else
-          add_offense(node, location: name_range, message: message(style)) do
+          add_offense(name_range, message: message(style)) do
             report_opposing_styles(node, name)
           end
         end

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

@@ -9,7 +9,7 @@ module RuboCop
 
       FORMATS = {
         snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
-        camelCase:  /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
+        camelCase:  /^@{0,2}(?:_|_?[a-z][\da-zA-Z]*)[!?=]?$/
       }.freeze
     end
   end

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

@@ -41,11 +41,11 @@ module RuboCop
       end
 
       def interpreter_directive_comment?(comment)
-        comment.text =~ /^#\s*(frozen_string_literal|encoding):/
+        /^#\s*(frozen_string_literal|encoding):/.match?(comment.text)
       end
 
       def rubocop_directive_comment?(comment)
-        comment.text =~ CommentConfig::COMMENT_DIRECTIVE_REGEXP
+        CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
       end
     end
   end

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

@@ -51,7 +51,7 @@ module RuboCop
 
       def accept_end_kw_alignment?(end_loc)
         end_loc.nil? || # Discard modifier forms of if/while/until.
-          processed_source.lines[end_loc.line - 1] !~ /\A[ \t]*end/
+          !/\A[ \t]*end/.match?(processed_source.lines[end_loc.line - 1])
       end
 
       def style_parameter_name

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

@@ -10,7 +10,9 @@ module RuboCop
         PATTERN
 
         base.def_node_matcher :class_new_definition, <<~PATTERN
-          [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
+          [!^(casgn {nil? cbase} :#{base::SUPERCLASS} ...)
+           !^^(casgn {nil? cbase} :#{base::SUPERCLASS} (block ...))
+           (send (const {nil? cbase} :Class) :new #{base::BASE_PATTERN})]
         PATTERN
       end
 

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

@@ -17,7 +17,7 @@ module RuboCop
 
       def method_uses_parens?(node, limit)
         source = node.source_range.source_line[0...limit.loc.column]
-        source =~ /\s*\(\s*$/
+        /\s*\(\s*$/.match?(source)
       end
 
       def check_children_line_break(node, children, start = node)

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

@@ -152,7 +152,7 @@ module RuboCop
         expression
       end
 
-      def argument_in_method_call(node, kind)
+      def argument_in_method_call(node, kind) # rubocop:todo Metrics/CyclomaticComplexity
         node.each_ancestor(:send, :block).find do |a|
           # If the node is inside a block, it makes no difference if that block
           # is an argument in a method call. It doesn't count.

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

@@ -7,19 +7,17 @@ module RuboCop
     # 2. Added to NilClass by explicitly requiring any standard libraries
     # 3. Cop's configuration parameter AllowedMethods.
     module NilMethods
+      include AllowedMethods
+
       private
 
       def nil_methods
-        nil.methods + other_stdlib_methods + allowed_methods
+        nil.methods + other_stdlib_methods + allowed_methods.map(&:to_sym)
       end
 
       def other_stdlib_methods
         [:to_d]
       end
-
-      def allowed_methods
-        cop_config['AllowedMethods'].map(&:to_sym)
-      end
     end
   end
 end

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

@@ -15,8 +15,13 @@ module RuboCop
         node.source_range
       end
 
+      def gem_canonical_name(name)
+        name = name.tr('-_', '') unless cop_config['ConsiderPunctuation']
+        name.downcase
+      end
+
       def case_insensitive_out_of_order?(string_a, string_b)
-        string_a.downcase < string_b.downcase
+        gem_canonical_name(string_a) < gem_canonical_name(string_b)
       end
 
       def consecutive_lines(previous, current)

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

@@ -9,8 +9,7 @@ module RuboCop
       def parens_required?(node)
         range  = node.source_range
         source = range.source_buffer.source
-        source[range.begin_pos - 1] =~ /[a-z]/ ||
-          source[range.end_pos] =~ /[a-z]/
+        /[a-z]/.match?(source[range.begin_pos - 1]) || /[a-z]/.match?(source[range.end_pos])
       end
     end
   end

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

@@ -87,7 +87,7 @@ module RuboCop
       end
 
       def aligned_words?(range, line)
-        line[range.column - 1, 2] =~ /\s\S/
+        /\s\S/.match?(line[range.column - 1, 2])
       end
 
       def aligned_char?(range, line)

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

@@ -109,7 +109,7 @@ module RuboCop
 
       def move_pos(src, pos, step, condition, regexp)
         offset = step == -1 ? -1 : 0
-        pos += step while condition && src[pos + offset] =~ regexp
+        pos += step while condition && regexp.match?(src[pos + offset])
         pos.negative? ? 0 : pos
       end
     end

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

@@ -11,6 +11,33 @@ module RuboCop
 
         regopt.children.include?(:x)
       end
+
+      def pattern_source(node)
+        freespace_mode = freespace_mode_regexp?(node)
+
+        node.children.reject(&:regopt_type?).map do |child|
+          source_with_comments_and_interpolations_blanked(child, freespace_mode)
+        end.join
+      end
+
+      def source_with_comments_and_interpolations_blanked(child, freespace_mode)
+        source = child.source
+
+        # We don't want to consider the contents of interpolations or free-space mode comments as
+        # part of the pattern source, but need to preserve their width, to allow offsets to
+        # correctly line up with the original source: spaces have no effect, and preserve width.
+        if child.begin_type?
+          replace_match_with_spaces(source, /.*/) # replace all content
+        elsif freespace_mode
+          replace_match_with_spaces(source, /(?<!\\)#.*/) # replace any comments
+        else
+          source
+        end
+      end
+
+      def replace_match_with_spaces(source, pattern)
+        source.sub(pattern) { ' ' * Regexp.last_match[0].length }
+      end
     end
   end
 end

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

@@ -17,9 +17,9 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        node.nonempty_line_count > 3 ||
-          !node.modifier_form? &&
-            processed_source.commented?(node.loc.end)
+        node.modifier_form? ||
+          node.nonempty_line_count > 3 ||
+          processed_source.commented?(node.loc.end)
       end
 
       def non_eligible_body?(body)

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

@@ -15,7 +15,7 @@ module RuboCop
         if style == :single_quotes
           !double_quotes_required?(src)
         else
-          src !~ /" | \\[^'] | \#(@|\{)/x
+          !/" | \\[^'] | \#(@|\{)/x.match?(src)
         end
       end
     end

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

@@ -14,7 +14,7 @@ module RuboCop
       private
 
       def side_space_range(range:, side:)
-        buffer = @processed_source.buffer
+        buffer = processed_source.buffer
         src = buffer.source
 
         begin_pos = range.begin_pos
@@ -47,7 +47,7 @@ module RuboCop
       def token_table
         @token_table ||= begin
           table = {}
-          @processed_source.tokens.each_with_index do |t, ix|
+          processed_source.tokens.each_with_index do |t, ix|
             table[t.line] ||= {}
             table[t.line][t.column] = ix
           end
@@ -55,6 +55,11 @@ module RuboCop
         end
       end
 
+      def on_new_investigation
+        @token_table = nil
+        super
+      end
+
       def no_space_offenses(node, # rubocop:disable Metrics/ParameterLists
                             left_token,
                             right_token,
@@ -87,15 +92,15 @@ module RuboCop
         return false unless token
 
         if side == :left
-          String(token.space_after?) =~ SINGLE_SPACE_REGEXP
+          SINGLE_SPACE_REGEXP.match?(String(token.space_after?))
         else
-          String(token.space_before?) =~ SINGLE_SPACE_REGEXP
+          SINGLE_SPACE_REGEXP.match?(String(token.space_before?))
         end
       end
 
       def reposition(src, pos, step)
         offset = step == -1 ? -1 : 0
-        pos += step while src[pos + offset] =~ SINGLE_SPACE_REGEXP
+        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset])
         pos.negative? ? 0 : pos
       end
 

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

@@ -16,19 +16,9 @@ module RuboCop
       end
 
       def code_length(node)
-        body = extract_body(node)
-        lines = body&.source&.lines || []
-
-        lines.count { |line| !irrelevant_line(line) }
-      end
-
-      def extract_body(node)
-        case node.type
-        when :block, :def, :defs
-          node.body
-        else
-          node
-        end
+        Metrics::Utils::CodeLengthCalculator.new(node,
+                                                 count_comments: count_comments?,
+                                                 foldable_types: count_as_one).calculate
       end
     end
   end

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

@@ -31,7 +31,7 @@ module RuboCop
         # 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(',')
+        comma_regex.match?(range.source) && range.source.index(',')
       end
 
       def check_comma(node, kind, comma_pos)

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

@@ -15,11 +15,13 @@ module RuboCop
         args.each do |arg|
           # Argument names might be "_" or prefixed with "_" to indicate they
           # are unused. Trim away this prefix and only analyse the basename.
-          full_name = arg.children.first.to_s
+          name_child = arg.children.first
+          next if name_child.nil?
+
+          full_name = name_child.to_s
           next if full_name == '_'
 
           name = full_name.gsub(/\A(_+)/, '')
-          next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
           next if allowed_names.include?(name)
 
           range = arg_range(arg, name.size)
@@ -44,7 +46,7 @@ module RuboCop
       end
 
       def uppercase?(name)
-        name =~ /[[:upper:]]/
+        /[[:upper:]]/.match?(name)
       end
 
       def name_type(node)
@@ -62,7 +64,7 @@ module RuboCop
       end
 
       def ends_with_num?(name)
-        name[-1] =~ /\d/
+        /\d/.match?(name[-1])
       end
 
       def length_offense(node, range)

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining node visibility.
+    module VisibilityHelp
+      extend NodePattern::Macros
+
+      VISIBILITY_SCOPES = %i[private protected public].freeze
+
+      private
+
+      def node_visibility(node)
+        scope = find_visibility_start(node)
+        scope&.method_name || :public
+      end
+
+      def find_visibility_start(node)
+        left_siblings_of(node)
+          .reverse
+          .find(&method(:visibility_block?))
+      end
+
+      # Navigate to find the last protected method
+      def find_visibility_end(node)
+        possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
+        right = right_siblings_of(node)
+        right.find do |child_node|
+          possible_visibilities.include?(node_visibility(child_node))
+        end || right.last
+      end
+
+      def left_siblings_of(node)
+        siblings_of(node)[0, node.sibling_index]
+      end
+
+      def right_siblings_of(node)
+        siblings_of(node)[node.sibling_index..-1]
+      end
+
+      def siblings_of(node)
+        node.parent.children
+      end
+
+      def_node_matcher :visibility_block?, <<~PATTERN
+        (send nil? { :private :protected :public })
+      PATTERN
+    end
+  end
+end

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

@@ -5,7 +5,9 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks for non-ascii characters in identifier names.
+      # This cop checks for non-ascii characters in identifier and constant names.
+      # Identifiers are always checked and whether constants are checked
+      # can be controlled using AsciiConstants config.
       #
       # @example
       #   # bad
@@ -36,21 +38,42 @@ module RuboCop
       #   # good
       #   params[:width_gteq]
       #
+      # @example AsciiConstants: true (default)
+      #   # bad
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
+      # @example AsciiConstants: false
+      #   # good
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
       class AsciiIdentifiers < Cop
         include RangeHelp
 
-        MSG = 'Use only ascii symbols in identifiers.'
+        IDENTIFIER_MSG = 'Use only ascii symbols in identifiers.'
+        CONSTANT_MSG   = 'Use only ascii symbols in constants.'
 
         def investigate(processed_source)
           processed_source.each_token do |token|
-            next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
+            next if !should_check?(token) || token.text.ascii_only?
 
-            add_offense(token, location: first_offense_range(token))
+            message = token.type == :tIDENTIFIER ? IDENTIFIER_MSG : CONSTANT_MSG
+            add_offense(token, location: first_offense_range(token), message: message)
           end
         end
 
         private
 
+        def should_check?(token)
+          token.type == :tIDENTIFIER ||
+            (token.type == :tCONSTANT && cop_config['AsciiConstants'])
+        end
+
         def first_offense_range(identifier)
           expression    = identifier.pos
           first_offense = first_non_ascii_chars(identifier.text)