class RuboCop::Cop::Style::RedundantCondition


end
c
elsif cond
b
if b
# good
b || c
# good
end
c
else
b
if b
# bad
@example
a = b || c
# good
a = b ? b : c
# bad
@example
This cop checks for unnecessary conditional expressions.

def autocorrect(node) 

def autocorrect(node)
  lambda do |corrector|
    if node.ternary?
      corrector.replace(range_of_offense(node), '||')
    elsif node.modifier_form? || !node.else_branch
      corrector.replace(node.source_range, node.if_branch.source)
    else
      corrected = make_ternary_form(node)
      corrector.replace(node.source_range, corrected)
    end
  end
end

def else_source(else_branch) 

def else_source(else_branch)
  wrap_else =
    else_branch.basic_conditional? && else_branch.modifier_form?
  wrap_else ? "(#{else_branch.source})" : else_branch.source
end

def make_ternary_form(node) 

def make_ternary_form(node)
  _condition, if_branch, else_branch = *node
  ternary_form = [if_branch.source,
                  else_source(else_branch)].join(' || ')
  if node.parent&.send_type?
    "(#{ternary_form})"
  else
    ternary_form
  end
end

def message(node) 

def message(node)
  if node.modifier_form? || !node.else_branch
    REDUNDANT_CONDITION
  else
    MSG
  end
end

def offense?(node) 

def offense?(node)
  condition, if_branch, else_branch = *node
  return false if use_if_branch?(else_branch)
  condition == if_branch && !node.elsif? && (
    node.ternary? ||
    !else_branch.instance_of?(AST::Node) ||
    else_branch.single_line?
  )
end

def on_if(node) 

def on_if(node)
  return if node.elsif_conditional?
  return unless offense?(node)
  add_offense(node, location: range_of_offense(node))
end

def range_of_offense(node) 

def range_of_offense(node)
  return :expression unless node.ternary?
  range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
end

def use_if_branch?(else_branch) 

def use_if_branch?(else_branch)
  else_branch&.if_type?
end