rubocop 0.82.0 → 1.18.4

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

@@ -17,12 +17,13 @@ module RuboCop
       #
       #   # good
       #   INCH_IN_CM = 2.54
-      class ConstantName < Cop
+      class ConstantName < Base
         MSG = 'Use SCREAMING_SNAKE_CASE for constants.'
         # Use POSIX character classes, so we allow accented characters rather
         # than just standard ASCII characters
         SNAKE_CASE = /^[[:digit:][:upper:]_]+$/.freeze
 
+        # @!method class_or_struct_return_method?(node)
         def_node_matcher :class_or_struct_return_method?, <<~PATTERN
           (send
             (const _ {:Class :Struct}) :new
@@ -47,7 +48,7 @@ module RuboCop
           return if allowed_assignment?(value)
           return if SNAKE_CASE.match?(const_name)
 
-          add_offense(node, location: :name)
+          add_offense(node.loc.name)
         end
 
         private
@@ -64,6 +65,7 @@ module RuboCop
             (node.receiver.nil? || !literal_receiver?(node))
         end
 
+        # @!method literal_receiver?(node)
         def_node_matcher :literal_receiver?, <<~PATTERN
           {(send literal? ...)
            (send (begin literal?) ...)}

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

@@ -24,50 +24,55 @@ module RuboCop
       #   lib/layout_manager.rb
       #
       #   anything/using_snake_case.rake
-      class FileName < Cop
+      class FileName < Base
         include RangeHelp
 
-        MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) ' \
-                         'should use snake_case.'
-        MSG_NO_DEFINITION = '%<basename>s should define a class or module ' \
-                            'called `%<namespace>s`.'
+        MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) should use snake_case.'
+        MSG_NO_DEFINITION = '%<basename>s should define a class or module called `%<namespace>s`.'
         MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
 
-        SNAKE_CASE = /^[\da-z_.?!]+$/.freeze
+        SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
-        def investigate(processed_source)
+        def on_new_investigation
           file_path = processed_source.file_path
-          return if config.file_to_exclude?(file_path) ||
-                    config.allowed_camel_case_file?(file_path)
+          return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
 
-          for_bad_filename(file_path) do |range, msg|
-            add_offense(nil, location: range, message: msg)
-          end
+          for_bad_filename(file_path) { |range, msg| add_offense(range, message: msg) }
         end
 
         private
 
         def for_bad_filename(file_path)
           basename = File.basename(file_path)
-          msg = if filename_good?(basename)
-                  return if matching_definition?(file_path)
 
-                  no_definition_message(basename, file_path)
-                else
-                  return if bad_filename_allowed?
+          if filename_good?(basename)
+            msg = perform_class_and_module_naming_checks(file_path, basename)
+          else
+            msg = other_message(basename) unless bad_filename_allowed?
+          end
+
+          yield source_range(processed_source.buffer, 1, 0), msg if msg
+        end
 
-                  other_message(basename)
-                end
+        def perform_class_and_module_naming_checks(file_path, basename)
+          return unless expect_matching_definition?
 
-          yield source_range(processed_source.buffer, 1, 0), msg
+          if check_definition_path_hierarchy? && !matching_definition?(file_path)
+            msg = no_definition_message(basename, file_path)
+          elsif !matching_class?(basename)
+            msg = no_definition_message(basename, basename)
+          end
+          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 matching_class?(file_name)
+          find_class_or_module(processed_source.ast, to_namespace(file_name))
+        end
+
         def bad_filename_allowed?
           ignore_executable_scripts? && processed_source.start_with?('#!')
         end
@@ -94,6 +99,10 @@ module RuboCop
           cop_config['ExpectMatchingDefinition']
         end
 
+        def check_definition_path_hierarchy?
+          cop_config['CheckDefinitionPathHierarchy']
+        end
+
         def regex
           cop_config['Regex']
         end
@@ -104,14 +113,13 @@ module RuboCop
 
         def filename_good?(basename)
           basename = basename.sub(/^\./, '')
-          basename = basename.sub(/\.[^\.]+$/, '')
+          basename = basename.sub(/\.[^.]+$/, '')
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx
           basename = basename.sub('+', '_')
-          basename =~ (regex || SNAKE_CASE)
+          basename.match?(regex || SNAKE_CASE)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def find_class_or_module(node, namespace)
           return nil unless node
 
@@ -122,15 +130,13 @@ module RuboCop
 
             const_namespace, const_name = *const
             next if name != const_name && !match_acronym?(name, const_name)
-            next unless namespace.empty? ||
-                        match_namespace(child, const_namespace, namespace)
+            next unless namespace.empty? || match_namespace(child, const_namespace, namespace)
 
             return node
           end
 
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def match_namespace(node, namespace, expected)
           match_partial = partial_matcher!(expected)
@@ -153,9 +159,7 @@ module RuboCop
 
               namespace, name = *namespace
 
-              if name == expected.last || match_acronym?(expected.last, name)
-                expected.pop
-              end
+              expected.pop if name == expected.last || match_acronym?(expected.last, name)
             end
 
             false
@@ -170,9 +174,7 @@ module RuboCop
           expected = expected.to_s
           name = name.to_s
 
-          allowed_acronyms.any? do |acronym|
-            expected.gsub(acronym.capitalize, acronym) == name
-          end
+          allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
         end
 
         def to_namespace(path)

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

@@ -27,16 +27,22 @@ module RuboCop
       #   <<-sql
       #     SELECT * FROM foo
       #   sql
-      class HeredocDelimiterCase < Cop
+      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, location: :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/heredoc_delimiter_naming.rb

@@ -23,7 +23,7 @@ module RuboCop
       #   <<-EOS
       #     SELECT * FROM foo
       #   EOS
-      class HeredocDelimiterNaming < Cop
+      class HeredocDelimiterNaming < Base
         include Heredoc
 
         MSG = 'Use meaningful heredoc delimiters.'
@@ -31,7 +31,7 @@ module RuboCop
         def on_heredoc(node)
           return if meaningful_delimiters?(node)
 
-          add_offense(node, location: :heredoc_end)
+          add_offense(node.loc.heredoc_end)
         end
 
         private
@@ -42,7 +42,7 @@ module RuboCop
           return false unless /\w/.match?(delimiters)
 
           forbidden_delimiters.none? do |forbidden_delimiter|
-            delimiters =~ Regexp.new(forbidden_delimiter)
+            Regexp.new(forbidden_delimiter).match?(delimiters)
           end
         end
 

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

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cops recommends the use of inclusive language instead of problematic terms.
+      # The cop can check the following locations for offenses:
+      # - identifiers
+      # - constants
+      # - variables
+      # - strings
+      # - symbols
+      # - comments
+      # - file paths
+      # Each of these locations can be individually enabled/disabled via configuration,
+      # for example CheckIdentifiers = true/false.
+      #
+      # Flagged terms are configurable for the cop. For each flagged term an optional
+      # Regex can be specified to identify offenses. Suggestions for replacing a flagged term can
+      # be configured and will be displayed as part of the offense message.
+      # An AllowedRegex can be specified for a flagged term to exempt allowed uses of the term.
+      #
+      # @example FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } }
+      #   # Suggest replacing identifier whitelist with allowlist
+      #
+      #   # bad
+      #   whitelist_users = %w(user1 user1)
+      #
+      #   # good
+      #   allowlist_users = %w(user1 user2)
+      #
+      # @example FlaggedTerms: { master: { Suggestions: ['main', 'primary', 'leader'] } }
+      #   # Suggest replacing master in an instance variable name with main, primary, or leader
+      #
+      #   # bad
+      #   @master_node = 'node1.example.com'
+      #
+      #   # good
+      #   @primary_node = 'node1.example.com'
+      #
+      # @example FlaggedTerms: { whitelist: { Regex: !ruby/regexp '/white[-_\s]?list' } }
+      #   # Identify problematic terms using a Regexp
+      #
+      #   # bad
+      #   white_list = %w(user1 user2)
+      #
+      #   # good
+      #   allow_list = %w(user1 user2)
+      #
+      # @example FlaggedTerms: { master: { AllowedRegex: 'master\'?s degree' } }
+      #   # Specify allowed uses of the flagged term as a string or regexp.
+      #
+      #   # bad
+      #   # They had a masters
+      #
+      #   # good
+      #   # They had a master's degree
+      #
+      class InclusiveLanguage < Base
+        include RangeHelp
+
+        EMPTY_ARRAY = [].freeze
+
+        WordLocation = Struct.new(:word, :position)
+
+        def initialize(config = nil, options = nil)
+          super
+          @flagged_term_hash = {}
+          @flagged_terms_regex = nil
+          @allowed_regex = nil
+          @check_token = preprocess_check_config
+          preprocess_flagged_terms
+        end
+
+        def on_new_investigation
+          investigate_filepath if cop_config['CheckFilepaths']
+          investigate_tokens
+        end
+
+        private
+
+        def investigate_tokens
+          processed_source.each_token do |token|
+            next unless check_token?(token.type)
+
+            word_locations = scan_for_words(token.text)
+            next if word_locations.empty?
+
+            add_offenses_for_token(token, word_locations)
+          end
+        end
+
+        def add_offenses_for_token(token, word_locations)
+          word_locations.each do |word_location|
+            start_position = token.pos.begin_pos + token.pos.source.index(word_location.word)
+            range = range_between(start_position, start_position + word_location.word.length)
+            add_offense(range, message: create_message(word_location.word))
+          end
+        end
+
+        def check_token?(type)
+          !!@check_token[type]
+        end
+
+        def preprocess_check_config # rubocop:disable Metrics/AbcSize
+          {
+            tIDENTIFIER: cop_config['CheckIdentifiers'],
+            tCONSTANT: cop_config['CheckConstants'],
+            tIVAR: cop_config['CheckVariables'],
+            tCVAR: cop_config['CheckVariables'],
+            tGVAR: cop_config['CheckVariables'],
+            tSYMBOL: cop_config['CheckSymbols'],
+            tSTRING: cop_config['CheckStrings'],
+            tSTRING_CONTENT: cop_config['CheckStrings'],
+            tCOMMENT: cop_config['CheckComments']
+          }.freeze
+        end
+
+        def preprocess_flagged_terms
+          allowed_strings = []
+          flagged_term_strings = []
+          cop_config['FlaggedTerms'].each do |term, term_definition|
+            next if term_definition.nil?
+
+            allowed_strings.concat(process_allowed_regex(term_definition['AllowedRegex']))
+            regex_string = ensure_regex_string(term_definition['Regex'] || term)
+            flagged_term_strings << regex_string
+
+            add_to_flagged_term_hash(regex_string, term, term_definition)
+          end
+
+          set_regexes(flagged_term_strings, allowed_strings)
+        end
+
+        def add_to_flagged_term_hash(regex_string, term, term_definition)
+          @flagged_term_hash[Regexp.new(regex_string, Regexp::IGNORECASE)] =
+            term_definition.merge('Term' => term,
+                                  'SuggestionString' =>
+                                    preprocess_suggestions(term_definition['Suggestions']))
+        end
+
+        def set_regexes(flagged_term_strings, allowed_strings)
+          @flagged_terms_regex = array_to_ignorecase_regex(flagged_term_strings)
+          @allowed_regex = array_to_ignorecase_regex(allowed_strings) unless allowed_strings.empty?
+        end
+
+        def process_allowed_regex(allowed)
+          return EMPTY_ARRAY if allowed.nil?
+
+          Array(allowed).map do |allowed_term|
+            next if allowed_term.is_a?(String) && allowed_term.strip.empty?
+
+            ensure_regex_string(allowed_term)
+          end
+        end
+
+        def ensure_regex_string(regex)
+          regex.is_a?(Regexp) ? regex.source : regex
+        end
+
+        def array_to_ignorecase_regex(strings)
+          Regexp.new(strings.join('|'), Regexp::IGNORECASE)
+        end
+
+        def investigate_filepath
+          word_locations = scan_for_words(processed_source.file_path)
+
+          case word_locations.length
+          when 0
+            return
+          when 1
+            message = create_single_word_message_for_file(word_locations.first.word)
+          else
+            words = word_locations.map(&:word)
+            message = create_multiple_word_message_for_file(words)
+          end
+
+          range = source_range(processed_source.buffer, 1, 0)
+          add_offense(range, message: message)
+        end
+
+        def create_single_word_message_for_file(word)
+          create_message(word).sub(/\.$/, ' in file path.')
+        end
+
+        def create_multiple_word_message_for_file(words)
+          quoted_words = words.map { |word| "'#{word}'" }
+          "Consider replacing problematic terms #{quoted_words.join(', ')} in file path."
+        end
+
+        def scan_for_words(input)
+          mask_input(input).enum_for(:scan, @flagged_terms_regex).map do
+            match = Regexp.last_match
+            WordLocation.new(match.to_s, match.offset(0).first)
+          end
+        end
+
+        def mask_input(str)
+          return str if @allowed_regex.nil?
+
+          safe_str = if str.valid_encoding?
+                       str
+                     else
+                       str.encode('UTF-8', invalid: :replace, undef: :replace)
+                     end
+          safe_str.gsub(@allowed_regex) { |match| '*' * match.size }
+        end
+
+        def create_message(word)
+          flagged_term = find_flagged_term(word)
+          "Consider replacing problematic term '#{word}'#{flagged_term['SuggestionString']}."
+        end
+
+        def find_flagged_term(word)
+          _regexp, flagged_term = @flagged_term_hash.find do |key, _term|
+            key.match?(word)
+          end
+          flagged_term
+        end
+
+        def create_message_for_file(word)
+          create_message(word).sub(/\.$/, ' in file path.')
+        end
+
+        def preprocess_suggestions(suggestions)
+          return '' if suggestions.nil? ||
+                       (suggestions.is_a?(String) && suggestions.strip.empty?) || suggestions.empty?
+
+          format_suggestions(suggestions)
+        end
+
+        def format_suggestions(suggestions)
+          quoted_suggestions = Array(suggestions).map { |word| "'#{word}'" }
+          suggestion_str = case quoted_suggestions.size
+                           when 1
+                             quoted_suggestions.first
+                           when 2
+                             quoted_suggestions.join(' or ')
+                           else
+                             last_quoted = quoted_suggestions.pop
+                             quoted_suggestions << "or #{last_quoted}"
+                             quoted_suggestions.join(', ')
+                           end
+          " with #{suggestion_str}"
+        end
+      end
+    end
+  end
+end