lib/rubocop/cop/util.rb
# frozen_string_literal: true
module RuboCop
module Cop
# This module contains a collection of useful utility methods.
# rubocop:disable Metrics/ModuleLength
module Util
include PathUtil
# Match literal regex characters, not including anchors, character
# classes, alternatives, groups, repetitions, references, etc
LITERAL_REGEX = %r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze
module_function
# This is a bad API
def comment_line?(line_source)
/^\s*#/.match?(line_source)
end
# @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
def comment_lines?(node)
processed_source[line_range(node)].any? { |line| comment_line?(line) }
end
def line_range(node)
node.first_line..node.last_line
end
def parentheses?(node)
node.loc.respond_to?(:end) && node.loc.end && node.loc.end.is?(')')
end
# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
def add_parentheses(node, corrector)
if node.args_type?
arguments_range = node.source_range
args_with_space = range_with_surrounding_space(arguments_range, side: :left)
leading_space = range_between(args_with_space.begin_pos, arguments_range.begin_pos)
corrector.replace(leading_space, '(')
corrector.insert_after(arguments_range, ')')
elsif !node.respond_to?(:arguments)
corrector.wrap(node, '(', ')')
elsif node.arguments.empty?
corrector.insert_after(node, '()')
else
args_begin = args_begin(node)
corrector.remove(args_begin)
corrector.insert_before(args_begin, '(')
corrector.insert_after(args_end(node), ')')
end
end
# rubocop:enable Metrics/AbcSize, Metrics/MethodLength
def any_descendant?(node, *types)
if block_given?
node.each_descendant(*types) do |descendant|
return true if yield(descendant)
end
else
# Use a block version to avoid allocating enumerators.
node.each_descendant do # rubocop:disable Lint/UnreachableLoop
return true
end
end
false
end
def args_begin(node)
loc = node.loc
selector = if node.super_type? || node.yield_type?
loc.keyword
elsif node.def_type? || node.defs_type?
loc.name
else
loc.selector
end
selector.end.resize(1)
end
def args_end(node)
node.source_range.end
end
def on_node(syms, sexp, excludes = [], &block)
return to_enum(:on_node, syms, sexp, excludes) unless block
yield sexp if include_or_equal?(syms, sexp.type)
return if include_or_equal?(excludes, sexp.type)
sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
end
# Arbitrarily chosen value, should be enough to cover
# the most nested source code in real world projects.
MAX_LINE_BEGINS_REGEX_INDEX = 50
LINE_BEGINS_REGEX_CACHE = Hash.new do |hash, index|
hash[index] = /^\s{#{index}}\S/ if index <= MAX_LINE_BEGINS_REGEX_INDEX
end
private_constant :MAX_LINE_BEGINS_REGEX_INDEX, :LINE_BEGINS_REGEX_CACHE
def begins_its_line?(range)
if (regex = LINE_BEGINS_REGEX_CACHE[range.column])
range.source_line.match?(regex)
else
range.source_line.index(/\S/) == range.column
end
end
# Returns, for example, a bare `if` node if the given node is an `if`
# with calls chained to the end of it.
def first_part_of_call_chain(node)
while node
case node.type
when :send
node = node.receiver
when :block
node = node.send_node
else
break
end
end
node
end
# If converting a string to Ruby string literal source code, must
# double quotes be used?
def double_quotes_required?(string)
# Double quotes are required for strings which either:
# - Contain single quotes
# - Contain non-printable characters, which must use an escape
# Regex matches IF there is a ' or there is a \\ in the string that is
# not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
/'|(?<! \\) \\{2}* \\ (?![\\"])/x.match?(string)
end
def needs_escaping?(string)
double_quotes_required?(escape_string(string))
end
def escape_string(string)
string.inspect[1..-2].tap { |s| s.gsub!('\\"', '"') }
end
def to_string_literal(string)
if needs_escaping?(string) && compatible_external_encoding_for?(string)
string.inspect
else
# In a single-quoted strings, double quotes don't need to be escaped
"'#{string.gsub('\\') { '\\\\' }.gsub('\"', '"')}'"
end
end
def trim_string_interpolation_escape_character(str)
str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
end
def interpret_string_escapes(string)
StringInterpreter.interpret(string)
end
def line(node_or_range)
if node_or_range.respond_to?(:line)
node_or_range.line
elsif node_or_range.respond_to?(:loc)
node_or_range.loc.line
end
end
def same_line?(node1, node2)
line1 = line(node1)
line2 = line(node2)
line1 && line2 && line1 == line2
end
def indent(node, offset: 0)
' ' * (node.loc.column + offset)
end
@to_supported_styles_cache = {}
def to_supported_styles(enforced_style)
@to_supported_styles_cache[enforced_style] ||=
enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
end
private
def compatible_external_encoding_for?(src)
src = src.dup if RUBY_ENGINE == 'jruby'
src.force_encoding(Encoding.default_external).valid_encoding?
end
def include_or_equal?(source, target)
source == target || (source.is_a?(Array) && source.include?(target))
end
end
# rubocop:enable Metrics/ModuleLength
end
end