Class: RuboCop::Cop::Style::RegexpLiteral

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 153

def allowed_mixed_slash?(node)
  style == :mixed && node.single_line? && !contains_disallowed_slash?(node)
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 191

def allowed_omit_parentheses_with_percent_r_literal?(node)
  return false unless node.parent&.call_type?
  return true if node.content.start_with?(' ', '=')
  return true if first_argument_of_command?(node) && node.content.match?(/\A\s/)

  enforced_style = config.for_cop('Style/MethodCallWithArgsParentheses')['EnforcedStyle']

  enforced_style == 'omit_parentheses'
end

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

def allowed_percent_r_literal?(node)
  (style == :slashes && contains_disallowed_slash?(node)) ||
    style == :percent_r ||
    allowed_mixed_percent_r?(node) || allowed_omit_parentheses_with_percent_r_literal?(node)
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 149

def allowed_slash_literal?(node)
  (style == :slashes && !contains_disallowed_slash?(node)) || allowed_mixed_slash?(node)
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 136

def balanced_delimiters?(text, opening, closing, pattern)
  depth = 0
  text.scan(pattern) do |match|
    if match == opening
      depth += 1
    elsif match == closing
      depth -= 1
      return false if depth.negative?
    end
  end
  depth.zero?
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 254

def calculate_replacement(node)
  if slash_literal?(node)
    ['%r', ''].zip(preferred_delimiters).map(&:join)
  else
    %w[/ /]
  end
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 167

def contains_disallowed_slash?(node)
  !allow_inner_slashes? && contains_slash?(node)
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 171

def contains_slash?(node)
  node_body(node).include?('/')
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 208

def correct_delimiters(node, corrector)
  replacement = calculate_replacement(node)
  corrector.replace(node.loc.begin, replacement.first)
  corrector.replace(node.loc.end, replacement.last)
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 262

def correct_escaped_delimiters(node, corrector)
  return unless (delimiter = delimiter_to_unescape(node))

  node.each_child_node(:str) do |str_node|
    text = str_node.source

    escaped_delimiter_indices(text, delimiter).each do |index|
      start = str_node.source_range.begin_pos + index
      replacement = escaped_delimiter_replacement(node, delimiter, text[index + 2])

      corrector.replace(range_between(start, start + 2), replacement)
    end
  end
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 214

def correct_inner_slashes(node, corrector)
  pattern = inner_slash_before_correction(node)
  replacement = inner_slash_after_correction(node)

  node.each_child_node(:str) do |str_node|
    inner_slash_indices(str_node.source, pattern).each do |index|
      start = str_node.source_range.begin_pos + index

      corrector.replace(range_between(start, start + pattern.length), replacement)
    end
  end
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 277

def delimiter_to_unescape(node)
  return if slash_literal?(node)

  delimiter = node.delimiters.first

  delimiter unless delimiter == '/' || DELIMITERS_KEEPING_ESCAPE.include?(delimiter)
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 285

def escaped_delimiter_indices(text, delimiter)
  indices = []
  index = 0

  while (index = text.index('\\', index))
    indices << index if text[index + 1] == delimiter
    index += 2
  end

  indices
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 301

def escaped_delimiter_replacement(node, delimiter, next_char)
  return delimiter unless delimiter == '#' && next_char&.match?(/[{@$]/)

  node.extended? ? '#\\' : '\\#'
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 201

def first_argument_of_command?(node)
  call = node.parent
  return false unless call.first_argument.equal?(node)

  !call.parenthesized? && !call.operator_method? && !call.setter_method?
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 231

def inner_slash_after_correction(node)
  inner_slash_for(calculate_replacement(node).first)
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 227

def inner_slash_before_correction(node)
  inner_slash_for(node.loc.begin.source)
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 246

def inner_slash_for(opening_delimiter)
  if ['/', '%r/'].include?(opening_delimiter)
    '\/'
  else
    '/'
  end
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 235

def inner_slash_indices(text, pattern)
  index = -1
  indices = []

  while (index = text.index(pattern, index + 1))
    indices << index
  end

  indices
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 179

def node_body(node)
  node.each_child_node(:str).map(&:source).join
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 109

def on_regexp(node)
  return if slash_literal?(node) && percent_r_delimiters_conflict?(node)

  message = if slash_literal?(node)
              MSG_USE_PERCENT_R unless allowed_slash_literal?(node)
            else
              MSG_USE_SLASHES unless allowed_percent_r_literal?(node)
            end

  return unless message

  add_offense(node, message: message) do |corrector|
    correct_delimiters(node, corrector)
    correct_inner_slashes(node, corrector)
    correct_escaped_delimiters(node, corrector)
  end
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 129

def percent_r_delimiters_conflict?(node)
  opening, closing = preferred_delimiters
  return false unless (pattern = PAIR_DELIMITER_PATTERNS[[opening, closing]])

  !balanced_delimiters?(node_body(node), opening, closing, pattern)
end

# File 'lib/rubocop/cop/style/regexp_literal.rb', line 187

def preferred_delimiters
  config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']['%r'].chars
end

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

def slash_literal?(node)
  node.loc.begin.source == '/'
end