Class: RuboCop::Cop::Naming::InclusiveLanguage

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 178

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

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 208

def array_to_ignorecase_regex(strings)
  Regexp.new(strings.join('|'), Regexp::IGNORECASE)
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 128

def check_token?(type)
  !!@check_token[type]
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 258

def create_message(word, message = MSG)
  flagged_term = find_flagged_term(word)
  suggestions = flagged_term['SuggestionString']
  suggestions = ' with another term' if suggestions.blank?

  format(message, term: word, suffix: suggestions)
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 232

def create_multiple_word_message_for_file(words)
  format(MSG_FOR_FILE_PATH, term: words.join("', '"), suffix: ' with other terms')
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 228

def create_single_word_message_for_file(word)
  create_message(word, MSG_FOR_FILE_PATH)
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 204

def ensure_regex_string(regex)
  regex.is_a?(Regexp) ? regex.source : regex
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 171

def extract_regexp(term, term_definition)
  return term_definition['Regex'] if term_definition['Regex']
  return /(?:\b|(?<=[\W_]))#{term}(?:\b|(?=[\W_]))/ if term_definition['WholeWord']

  term
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 266

def find_flagged_term(word)
  _regexp, flagged_term = @flagged_term_hash.find do |key, _term|
    key.match?(word)
  end
  flagged_term
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 280

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

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 212

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

  add_global_offense(message)
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 102

def investigate_tokens
  processed_source.tokens.each 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

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 246

def mask_input(str)
  safe_str = if str.valid_encoding?
               str
             else
               str.encode('UTF-8', invalid: :replace, undef: :replace)
             end

  return safe_str if @allowed_regex.nil?

  safe_str.gsub(@allowed_regex) { |match| '*' * match.size }
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 295

def offense_range(token, word)
  start_position = token.pos.begin_pos + token.pos.source.index(word)

  range_between(start_position, start_position + word.length)
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 93

def on_new_investigation
  return unless @flagged_terms_regex

  investigate_filepath if cop_config['CheckFilepaths']
  investigate_tokens
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 162

def preferred_sole_term(suggestions)
  case suggestions
  when Array
    suggestions.one? && preferred_sole_term(suggestions.first)
  when String
    suggestions
  end
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 132

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

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 146

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(extract_regexp(term, term_definition))
    flagged_term_strings << regex_string

    add_to_flagged_term_hash(regex_string, term, term_definition)
  end

  set_regexes(flagged_term_strings, allowed_strings)
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 273

def preprocess_suggestions(suggestions)
  return '' if suggestions.nil? ||
               (suggestions.is_a?(String) && suggestions.strip.empty?) || suggestions.empty?

  format_suggestions(suggestions)
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 194

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

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 236

def scan_for_words(input)
  masked_input = mask_input(input)
  return EMPTY_ARRAY unless masked_input.match?(@flagged_terms_regex)

  masked_input.enum_for(:scan, @flagged_terms_regex).map do
    match = Regexp.last_match
    WordLocation.new(match.to_s, match.offset(0).first)
  end
end

# File 'lib/rubocop/cop/naming/inclusive_language.rb', line 185

def set_regexes(flagged_term_strings, allowed_strings)
  # With no flagged terms an empty regex would match everything, so leave the
  # regex nil and let `on_new_investigation` treat the cop as a no-op.
  unless flagged_term_strings.empty?
    @flagged_terms_regex = array_to_ignorecase_regex(flagged_term_strings)
  end
  @allowed_regex = array_to_ignorecase_regex(allowed_strings) unless allowed_strings.empty?
end