rubocop 1.17.0 → 1.18.4

data/lib/rubocop/cop/layout/multiline_array_brace_layout.rb

@@ -93,18 +93,18 @@ module RuboCop
         extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'The closing array brace must be on the same ' \
-          'line as the last array element when the opening brace is on the ' \
-          'same line as the first array element.'
+                            'line as the last array element when the opening brace is on the ' \
+                            'same line as the first array element.'
 
         NEW_LINE_MESSAGE = 'The closing array brace must be on the line ' \
-          'after the last array element when the opening brace is on a ' \
-          'separate line from the first array element.'
+                           'after the last array element when the opening brace is on a ' \
+                           'separate line from the first array element.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'The closing array brace must be on the ' \
-          'line after the last array element.'
+                                  'line after the last array element.'
 
         ALWAYS_SAME_LINE_MESSAGE = 'The closing array brace must be on the ' \
-          'same line as the last array element.'
+                                   'same line as the last array element.'
 
         def on_array(node)
           check_brace_layout(node)

data/lib/rubocop/cop/layout/multiline_assignment_layout.rb

@@ -64,10 +64,10 @@ module RuboCop
         extend AutoCorrector
 
         NEW_LINE_OFFENSE = 'Right hand side of multi-line assignment is on ' \
-          'the same line as the assignment operator `=`.'
+                           'the same line as the assignment operator `=`.'
 
         SAME_LINE_OFFENSE = 'Right hand side of multi-line assignment is not ' \
-          'on the same line as the assignment operator `=`.'
+                            'on the same line as the assignment operator `=`.'
 
         def check_assignment(node, rhs)
           return if node.send_type? && node.loc.operator&.source != '='

data/lib/rubocop/cop/layout/multiline_hash_brace_layout.rb

@@ -93,18 +93,18 @@ module RuboCop
         extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'Closing hash brace must be on the same line as ' \
-          'the last hash element when opening brace is on the same line as ' \
-          'the first hash element.'
+                            'the last hash element when opening brace is on the same line as ' \
+                            'the first hash element.'
 
         NEW_LINE_MESSAGE = 'Closing hash brace must be on the line after ' \
-          'the last hash element when opening brace is on a separate line ' \
-          'from the first hash element.'
+                           'the last hash element when opening brace is on a separate line ' \
+                           'from the first hash element.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'Closing hash brace must be on the line ' \
-          'after the last hash element.'
+                                  'after the last hash element.'
 
         ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
-          'line as the last hash element.'
+                                   'line as the last hash element.'
 
         def on_hash(node)
           check_brace_layout(node)

data/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb

@@ -93,18 +93,18 @@ module RuboCop
         extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'Closing method call brace must be on the ' \
-          'same line as the last argument when opening brace is on the same ' \
-          'line as the first argument.'
+                            'same line as the last argument when opening brace is on the same ' \
+                            'line as the first argument.'
 
         NEW_LINE_MESSAGE = 'Closing method call brace must be on the ' \
-          'line after the last argument when opening brace is on a separate ' \
-          'line from the first argument.'
+                           'line after the last argument when opening brace is on a separate ' \
+                           'line from the first argument.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'Closing method call brace must be on ' \
-          'the line after the last argument.'
+                                  'the line after the last argument.'
 
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method call brace must be on ' \
-          'the same line as the last argument.'
+                                   'the same line as the last argument.'
 
         def on_send(node)
           check_brace_layout(node)

data/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb

@@ -105,18 +105,18 @@ module RuboCop
         extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
-          'same line as the last parameter when opening brace is on the same ' \
-          'line as the first parameter.'
+                            'same line as the last parameter when opening brace is on the same ' \
+                            'line as the first parameter.'
 
         NEW_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
-          'line after the last parameter when opening brace is on a separate ' \
-          'line from the first parameter.'
+                           'line after the last parameter when opening brace is on a separate ' \
+                           'line from the first parameter.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'Closing method definition brace must be ' \
-          'on the line after the last parameter.'
+                                  'on the line after the last parameter.'
 
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
-          'on the same line as the last parameter.'
+                                   'on the same line as the last parameter.'
 
         def on_def(node)
           check_brace_layout(node.arguments)

data/lib/rubocop/cop/layout/multiline_operation_indentation.rb

@@ -59,9 +59,9 @@ module RuboCop
           return unless style == :aligned && cop_config['IndentationWidth']
 
           raise ValidationError, 'The `Layout/MultilineOperationIndentation`' \
-                                ' cop only accepts an `IndentationWidth` ' \
-                                'configuration parameter when ' \
-                                '`EnforcedStyle` is `indented`.'
+                                 ' cop only accepts an `IndentationWidth` ' \
+                                 'configuration parameter when ' \
+                                 '`EnforcedStyle` is `indented`.'
         end
 
         private

data/lib/rubocop/cop/layout/parameter_alignment.rb

@@ -73,10 +73,10 @@ module RuboCop
         extend AutoCorrector
 
         ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \
-          'they span more than one line.'
+                           'they span more than one line.'
 
         FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
-          'following the first line of a multi-line method definition.'
+                           'following the first line of a multi-line method definition.'
 
         def on_def(node)
           return if node.arguments.size < 2

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -63,6 +63,10 @@ module RuboCop
           [Style::SelfAssignment]
         end
 
+        def on_sclass(node)
+          check_operator(:sclass, node.loc.operator, node.source_range)
+        end
+
         def on_pair(node)
           return unless node.hash_rocket?
 
@@ -198,7 +202,7 @@ module RuboCop
           elsif excess_leading_space?(type, operator, with_space) ||
                 excess_trailing_space?(right_operand, with_space)
             "Operator `#{operator.source}` should be surrounded " \
-            'by a single space.'
+              'by a single space.'
           end
         end
 

data/lib/rubocop/cop/lint/duplicate_branch.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks that there are no repeated bodies
-      # within `if/unless`, `case-when` and `rescue` constructs.
+      # within `if/unless`, `case-when`, `case-in` and `rescue` constructs.
       #
       # With `IgnoreLiteralBranches: true`, branches are not registered
       # as offenses if they return a basic literal value (string, symbol,
@@ -97,6 +97,7 @@ module RuboCop
         end
         alias on_if on_branching_statement
         alias on_case on_branching_statement
+        alias on_case_match on_branching_statement
         alias on_rescue on_branching_statement
 
         private

data/lib/rubocop/cop/lint/nested_percent_literal.rb

@@ -33,7 +33,7 @@ module RuboCop
         include PercentLiteral
 
         MSG = 'Within percent literals, nested percent literals do not ' \
-          'function and may be unwanted in the result.'
+              'function and may be unwanted in the result.'
 
         # The array of regular expressions representing percent literals that,
         # if found within a percent literal expression, will cause a

data/lib/rubocop/cop/lint/percent_string_array.rb

@@ -29,7 +29,7 @@ module RuboCop
         TRAILING_QUOTE = /['"]?,?$/.freeze
 
         MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
-          'unwanted in the resulting strings.'
+              'unwanted in the resulting strings.'
 
         def on_array(node)
           process(node, '%w', '%W')

data/lib/rubocop/cop/lint/percent_symbol_array.rb

@@ -25,7 +25,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = "Within `%i`/`%I`, ':' and ',' are unnecessary and may be " \
-          'unwanted in the resulting symbols.'
+              'unwanted in the resulting symbols.'
 
         def on_array(node)
           process(node, '%i', '%I')

data/lib/rubocop/cop/lint/symbol_conversion.rb

@@ -70,7 +70,7 @@ module RuboCop
 
         MSG = 'Unnecessary symbol conversion; use `%<correction>s` instead.'
         MSG_CONSISTENCY = 'Symbol hash key should be quoted for consistency; ' \
-          'use `%<correction>s` instead.'
+                          'use `%<correction>s` instead.'
         RESTRICT_ON_SEND = %i[to_sym intern].freeze
 
         def on_send(node)

data/lib/rubocop/cop/lint/unused_block_argument.rb

@@ -143,7 +143,7 @@ module RuboCop
 
         def message_for_underscore_prefix(variable)
           "If it's necessary, use `_` or `_#{variable.name}` " \
-          "as an argument name to indicate that it won't be used."
+            "as an argument name to indicate that it won't be used."
         end
 
         def define_method_call?(variable)

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -85,7 +85,7 @@ module RuboCop
           return unless assignment.meta_assignment_node.equal?(return_value_node)
 
           " Use `#{assignment.operator.sub(/=$/, '')}` " \
-          "instead of `#{assignment.operator}`."
+            "instead of `#{assignment.operator}`."
         end
 
         def similar_name_message(variable)

data/lib/rubocop/cop/lint/useless_times.rb

@@ -81,7 +81,7 @@ module RuboCop
           return if block_reassigns_arg?(node, block_arg)
 
           source = node.body.source
-          source.gsub!(/\b#{block_arg}\b/, '1') if block_arg
+          source.gsub!(/\b#{block_arg}\b/, '0') if block_arg
 
           corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
         end

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

@@ -50,7 +50,7 @@ module RuboCop
                 ->(node) { heredoc_node?(node) }
               else
                 raise ArgumentError, "Unknown foldable type: #{type.inspect}. "\
-                  "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
+                                     "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
               end
             end
           end

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

@@ -72,7 +72,9 @@ module RuboCop
 
         # If a `send` node is not parenthesized, don't move the first element, because it
         # can result in changed behavior or a syntax error.
-        elements = elements.drop(1) if node.send_type? && !node.parenthesized?
+        if node.send_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
+          elements = elements.drop(1)
+        end
 
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
@@ -84,13 +86,20 @@ module RuboCop
         elements[i - 1]
       end
 
+      # @api private
+      def first_argument_is_heredoc?(node)
+        first_argument = node.first_argument
+
+        first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+      end
+
       # @api private
       # If a send node contains a heredoc argument, splitting cannot happen
       # after the heredoc or else it will cause a syntax error.
       def shift_elements_for_heredoc_arg(node, elements, index)
-        return index unless node.send_type?
+        return index unless node.send_type? || node.array_type?
 
-        heredoc_index = elements.index { |arg| (arg.str_type? || arg.dstr_type?) && arg.heredoc? }
+        heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
         return index unless heredoc_index
         return nil if heredoc_index.zero?
 

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

@@ -175,7 +175,12 @@ module RuboCop
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          corrector.replace(block_node.body, transforming_body_expr.loc.expression.source)
+          body_source = transforming_body_expr.loc.expression.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
         end
       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