module RuboCop::Cop::Style::ConditionalAssignmentHelper

def assignment_rhs_exist?(node) 

def assignment_rhs_exist?(node)
  parent = node.parent
  return true unless parent
  !(parent.mlhs_type? || parent.resbody_type?)
end

def end_with_eq?(sym) 

def end_with_eq?(sym)
  sym.to_s.end_with?(EQUAL)
end

def expand_elses(branch)

the actual `else` branch.
but the last `node` an `elsif` branch and consider the last `node`
to recursively iterate over all `else` branches and consider all
`elsif` branches show up in the `node` as an `else`. We need 
def expand_elses(branch)
  elsif_branches = expand_elsif(branch)
  else_branch = elsif_branches.any? ? elsif_branches.pop : branch
  [elsif_branches, else_branch]
end

def expand_elsif(node, elsif_branches = []) 

def expand_elsif(node, elsif_branches = [])
  return [] if node.nil? || !node.if_type? || !node.elsif?
  elsif_branches << node.if_branch
  else_branch = node.else_branch
  if else_branch&.if_type? && else_branch&.elsif?
    expand_elsif(else_branch, elsif_branches)
  else
    elsif_branches << else_branch
  end
end

def expand_when_branches(when_branches)

We only need the contents of the branch, not the condition.
`when` nodes contain the entire branch including the condition. 
def expand_when_branches(when_branches)
  when_branches.map(&:body)
end

def indent(cop, source) 

def indent(cop, source)
  conf = cop.config.for_cop(END_ALIGNMENT)
  if conf[ALIGN_WITH] == KEYWORD
    ' ' * source.length
  else
    ''
  end
end

def lhs(node)

rubocop:disable Metrics/AbcSize 
def lhs(node)
  case node.type
  when :send
    lhs_for_send(node)
  when :op_asgn
    "#{node.children[0].source} #{node.children[1]}= "
  when :and_asgn, :or_asgn
    "#{node.children[0].source} #{node.loc.operator.source} "
  when :casgn
    lhs_for_casgn(node)
  when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
    "#{node.children[0]} = "
  else
    node.source
  end
end

def lhs_for_casgn(node) 

def lhs_for_casgn(node)
  namespace = node.children[0]
  if namespace.nil? || namespace.cbase_type?
    "#{namespace&.source}#{node.children[1]} = "
  else
    "#{namespace.source}::#{node.children[1]} = "
  end
end

def lhs_for_send(node) 

def lhs_for_send(node)
  receiver = node.receiver ? node.receiver.source : ''
  if node.method?(:[]=)
    indices = node.arguments[0...-1].map(&:source).join(', ')
    "#{receiver}[#{indices}] = "
  elsif node.setter_method?
    "#{receiver}.#{node.method_name[0...-1]} = "
  else
    "#{receiver} #{node.method_name} "
  end
end

def setter_method?(method_name) 

def setter_method?(method_name)
  method_name.to_s.end_with?(EQUAL) && !%i[!= == === >= <=].include?(method_name)
end

def tail(branch) 

def tail(branch)
  branch.begin_type? ? Array(branch).last : branch
end