         nil -> [sibling_node|acc]
         _ ->
           {_, _, children_nodes} = sibling_node
-          transverse(children_nodes, sibling_nodes, selector.combinator.selector, acc)
+          traverse(children_nodes, sibling_nodes, selector.combinator.selector, acc)
       end
     else
       acc
     end
   end
 
-  defp transverse_general_sibling(_nodes, sibling_nodes, selector, acc) do
+  defp traverse_general_sibling(_nodes, sibling_nodes, selector, acc) do
     sibling_nodes = Enum.drop_while(sibling_nodes, &ignore_node?/1)
 
     Enum.reduce(sibling_nodes, acc, fn(sibling_node, res_acc) ->

    end)
  end

  defp transverse_sibling(_nodes, sibling_nodes, selector, acc) do
    sibling_node = Enum.drop_while(sibling_nodes, &ignore_node?/1) |> hd

    if Selector.match?(sibling_node, selector) do

          _ ->
            case combinator.match_type do
              :descendant ->
                traverse(children_nodes, sibling_nodes, combinator.selector, acc)
              :child ->
                traverse_child(children_nodes, sibling_nodes, combinator.selector, acc)
              :sibling ->
                traverse_sibling(children_nodes, sibling_nodes, combinator.selector, acc)
              :general_sibling ->
                traverse_general_sibling(children_nodes, sibling_nodes, combinator.selector, acc)
              other ->
                raise "Combinator of type \"#{other}\" not implemented"
            end
