class RuboCop::Cop::Lint::LiteralInCondition


end
do_something
if some_var && true
end
do_something
if 20
@example
if/while/until.
operands in and/or expressions serving as the conditions of
This cop checks for literals used as the conditions or as

def basic_literal?(node) 

def basic_literal?(node)
  if node && node.type == :array
    primitive_array?(node)
  else
    BASIC_LITERALS.include?(node.type)
  end
end

def check_case_cond(node) 

def check_case_cond(node)
  return if node.type == :array && !primitive_array?(node)
  return if node.type == :dstr
  handle_node(node)
end

def check_for_literal(node) 

def check_for_literal(node)
  cond, = *node
  # if the cond node is literal we obviously have a problem
  if literal?(cond)
    add_offense(cond, :expression)
  else
    # alternatively we have to consider a logical node with a
    # literal argument
    check_node(cond)
  end
end

def check_node(node) 

def check_node(node)
  return unless node
  if not?(node)
    receiver, = *node
    handle_node(receiver)
  elsif [:and, :or].include?(node.type)
    *operands = *node
    operands.each do |op|
      handle_node(op)
    end
  elsif node.type == :begin && node.children.size == 1
    child_node = node.children.first
    handle_node(child_node)
  end
end

def handle_node(node) 

def handle_node(node)
  if literal?(node)
    add_offense(node, :expression)
  elsif [:send, :and, :or, :begin].include?(node.type)
    check_node(node)
  end
end

def literal?(node) 

def literal?(node)
  LITERALS.include?(node.type)
end

def message(node) 

def message(node)
  format(MSG, node.loc.expression.source)
end

def not?(node) 

def not?(node)
  return false unless node && node.type == :send
  _receiver, method_name, *_args = *node
  method_name == :!
end

def on_case(node) 

def on_case(node)
  cond, *whens, _else = *node
  if cond
    check_case_cond(cond)
  else
    whens.each do |when_node|
      check_for_literal(when_node)
    end
  end
end

def on_if(node) 

def on_if(node)
  check_for_literal(node)
end

def on_until(node) 

def on_until(node)
  check_for_literal(node)
end

def on_until_post(node) 

def on_until_post(node)
  check_for_literal(node)
end

def on_while(node) 

def on_while(node)
  check_for_literal(node)
end

def on_while_post(node) 

def on_while_post(node)
  check_for_literal(node)
end

def primitive_array?(node) 

def primitive_array?(node)
  node.children.all? { |n| basic_literal?(n) }
end