Class: RuboCop::Cop::Style::TernaryParentheses

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

def require_parentheses_when_complex?
  style == :require_parentheses_when_complex
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 101

def autocorrect(corrector, node)
  condition = node.condition

  return nil if parenthesized?(condition) &&
                (safe_assignment?(condition) || unsafe_autocorrect?(condition) ||
                 verified_by_reparse([condition]).empty?)

  if parenthesized?(condition)
    correct_parenthesized(corrector, condition)
  else
    correct_unparenthesized(corrector, condition)
  end
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 194

def below_ternary_precedence?(child)
  # Handle English "or", e.g. 'foo or bar ? a : b'
  (child.or_type? && child.semantic_operator?) ||
    # Handle English "and", e.g. 'foo and bar ? a : b'
    (child.and_type? && child.semantic_operator?) ||
    # Handle English "not", e.g. 'not foo ? a : b'
    (child.send_type? && child.prefix_not?)
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 137

def complex_condition?(condition)
  if condition.begin_type?
    condition.to_a.any? { |x| complex_condition?(x) }
  else
    !non_complex_expression?(condition)
  end
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 90

def condition_as_parenthesized_one_line_pattern_matching?(condition)
  return false unless condition.parenthesized_call?
  return false unless (first_child = condition.children.first)

  if target_ruby_version >= 3.0
    first_child.match_pattern_p_type?
  else
    first_child.match_pattern_type? # For Ruby 2.7's one line pattern matching AST.
  end
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 209

def correct_parenthesized(corrector, condition)
  corrector.remove(condition.loc.begin)
  corrector.remove(condition.loc.end)

  # Ruby allows no space between the question mark and parentheses.
  # If we remove the parentheses, we need to add a space or we'll
  # generate invalid code.
  corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)

  if (send_node = condition.child_nodes.last) && node_args_need_parens?(send_node)
    parenthesize_condition_arguments(corrector, send_node)
  end
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 243

def correct_unparenthesized(corrector, condition)
  corrector.wrap(condition, '(', ')')
end

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

def message(node)
  if require_parentheses_when_complex?
    command = parenthesized?(node.condition) ? 'Only use' : 'Use'
    format(MSG_COMPLEX, command: command)
  else
    command = require_parentheses? ? 'Use' : 'Omit'
    format(MSG, command: command)
  end
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 204

def_node_matcher :method_name, <<~PATTERN
  {($:defined? _ ...)
   (call {_ nil?} $_ _ ...)}
PATTERN

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 260

def node_args_need_parens?(send_node)
  return false unless node_with_args?(send_node)
  return false if send_node.arguments.none? || send_node.parenthesized?

  send_node.dot? || send_node.safe_navigation? || unparenthesized_method_call?(send_node)
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 267

def node_with_args?(node)
  node.type?(:call, :defined?)
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 147

def non_complex_expression?(condition)
  NON_COMPLEX_TYPES.include?(condition.type) || non_complex_send?(condition)
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 151

def non_complex_send?(node)
  return false unless node.call_type?

  !node.operator_method? || node.method?(:[])
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 232

def normalize_reparsed_ast(node)
  return node unless node.is_a?(::Parser::AST::Node)

  children = node.children.map { |child| normalize_reparsed_ast(child) }
  if node.begin_type? && children.one? && children.first.is_a?(::Parser::AST::Node)
    children.first
  else
    node.updated(nil, children)
  end
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 115

def offense?(node)
  condition = node.condition

  # A modifier `if`/`unless` requires the parentheses, e.g. `(a if b) ? x : y`,
  # so removing them would change the meaning. Don't flag it.
  return false if parenthesized_modifier_condition?(condition)

  if safe_assignment?(condition)
    !safe_assignment_allowed?
  else
    parens = parenthesized?(condition)
    case style
    when :require_parentheses_when_complex
      complex_condition?(condition) ? !parens : parens
    else
      require_parentheses? ? !parens : parens
    end
  end
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 70

def on_if(node)
  condition = node.condition

  return if only_closing_parenthesis_is_last_line?(condition)
  return if condition_as_parenthesized_one_line_pattern_matching?(condition)
  return unless node.ternary? && offense?(node)

  message = message(node)

  add_offense(node, message: message) do |corrector|
    autocorrect(corrector, node)
  end
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 86

def only_closing_parenthesis_is_last_line?(condition)
  condition.source.split("\n").last == ')'
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 247

def parenthesize_condition_arguments(corrector, send_node)
  range_start = send_node.defined_type? ? send_node.loc.keyword : send_node.loc.selector
  opening_range = range_start.end.join(send_node.first_argument.source_range.begin)

  corrector.replace(opening_range, '(')
  corrector.insert_after(send_node.last_argument, ')')
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 175

def parenthesized?(node)
  node.begin_type?
end

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

def parenthesized_modifier_condition?(condition)
  return false unless condition.begin_type?

  inner = condition.children.first
  inner&.if_type? && inner.modifier_form?
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 190

def unparenthesized_method_call?(child)
  /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
end

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

def unsafe_autocorrect?(condition)
  condition.children.any? { |child| below_ternary_precedence?(child) }
end

# File 'lib/rubocop/cop/style/ternary_parentheses.rb', line 255

def whitespace_after?(node)
  last_token = processed_source.last_token_of(node)
  last_token.space_after?
end