Class: RuboCop::Cop::Style::FormatStringToken

# File 'lib/rubocop/cop/style/format_string_token.rb', line 236

def allowed_unannotated?(detections)
  return false unless detections.all? do |detected_sequence,|
                        detected_sequence.style == :unannotated
                      end
  return true if detections.size <= max_unannotated_placeholders_allowed

  detections.any? { |detected_sequence,| !correctable_sequence?(detected_sequence.type) }
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 161

def autocorrect_sequence(corrector, detected_sequence, token_range)
  return if style == :unannotated

  name = detected_sequence.name
  return if name.nil?

  flags = detected_sequence.flags
  width = detected_sequence.width
  precision = detected_sequence.precision
  type = detected_sequence.style == :template ? 's' : detected_sequence.type
  correction = case style
               when :annotated then "%<#{name}>#{flags}#{width}#{precision}#{type}"
               when :template then "%#{flags}#{width}#{precision}{#{name}}"
               end
  corrector.replace(token_range, correction)
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 146

def check_sequence(detected_sequence, token_range)
  if detected_sequence.style == style
    correct_style_detected
  elsif correctable_sequence?(detected_sequence.type)
    style_detected(detected_sequence.style)
    add_offense(token_range, message: message(detected_sequence.style)) do |corrector|
      autocorrect_sequence(corrector, detected_sequence, token_range)
    end
  end
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 226

def collect_detections(node)
  detections = []
  tokens(node) do |detected_sequence, token_range|
    unless allowed_string?(node, detected_sequence.style)
      detections << [detected_sequence, token_range]
    end
  end
  detections
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 157

def correctable_sequence?(detected_type)
  detected_type == 's' || style == :annotated || style == :unannotated
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 128

def_node_matcher :format_string_in_typical_context?, <<~PATTERN
  {
    ^(send _ {:format :sprintf :printf} %0 ...)
    ^(send %0 :% _)
  }
PATTERN

# File 'lib/rubocop/cop/style/format_string_token.rb', line 135

def format_string_token?(node)
  !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 245

def max_unannotated_placeholders_allowed
  cop_config['MaxUnannotatedPlaceholdersAllowed']
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 183

def message(detected_style)
  "Prefer #{message_text(style)} over #{message_text(detected_style)}."
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 188

def message_text(style)
  {
    annotated: 'annotated tokens (like `%<foo>s`)',
    template: 'template tokens (like `%{foo}`)',
    unannotated: 'unannotated tokens (like `%s`)'
  }[style]
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 113

def on_str(node)
  return if format_string_token?(node) || use_allowed_method?(node)

  detections = collect_detections(node)
  return if detections.empty?
  return if allowed_unannotated?(detections)

  detections.each do |detected_sequence, token_range|
    check_sequence(detected_sequence, token_range)
  end
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 203

def str_contents(source_map)
  if source_map.is_a?(Parser::Source::Map::Heredoc)
    source_map.heredoc_body
  elsif source_map.begin
    source_map.expression.adjust(begin_pos: +1, end_pos: -1)
  else
    source_map.expression
  end
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 213

def token_ranges(contents)
  format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)

  format_string.format_sequences.each do |detected_sequence|
    next if detected_sequence.percent?

    token = contents.begin.adjust(begin_pos: detected_sequence.begin_pos,
                                  end_pos: detected_sequence.end_pos)

    yield(detected_sequence, token)
  end
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 197

def tokens(str_node, &block)
  return if str_node.source == '__FILE__'

  token_ranges(str_contents(str_node.loc), &block)
end

# File 'lib/rubocop/cop/style/format_string_token.rb', line 139

def use_allowed_method?(node)
  send_parent = node.each_ancestor(:send).first
  send_parent &&
    (allowed_method?(send_parent.method_name) ||
    matches_allowed_pattern?(send_parent.method_name))
end