change logging over to macros

apps/luwak/include/luwak.hrl

@@ -7,3 +7,15 @@
 -define(HASH_LEN, 512).
 
 -record(split, {head=[], midhead=[], middle=[], midtail=[], tail=[]}).
+
+-ifndef(EUNIT_HRL).
+
+-ifdef(DEBUG).
+-define(debugMsg(S), error_logger:info_msg(S)).
+-define(debugFmt(S, As), error_logger:info_msg(S,As)).
+-else.
+-define(debugMsg(S), ok).
+-define(debugFmt(S, As), ok).
+-endif.
+
+-endif.

apps/luwak/src/luwak_io.erl

@@ -2,6 +2,8 @@
 
 -export([put_range/4, get_range/4, truncate/3, no_tree_put_range/4]).
 
+-include_lib("luwak/include/luwak.hrl").
+
 put_range(Riak, File, Start, Data) ->
   internal_put_range(Riak, File, Start, Data).
 
@@ -10,9 +12,9 @@ get_range(Riak, File, Start, Length) ->
   BlockSize = luwak_file:get_property(File, block_size),
   {ok, RootObj} = luwak_tree:get(Riak, Root),
   Blocks = luwak_tree:get_range(Riak, RootObj, BlockSize, 0, Start, Start+Length),
-  error_logger:info_msg("blocks ~p~n", [Blocks]),
+  ?debugFmt("blocks ~p~n", [Blocks]),
   ChopHead = Start rem BlockSize,
-  error_logger:info_msg("chophead ~p choptail ~p~n", [ChopHead, Length]),
+  ?debugFmt("chophead ~p choptail ~p~n", [ChopHead, Length]),
   retrieve_blocks(Riak, Blocks, ChopHead, Length).
 
 truncate(Riak, File, 0) ->
@@ -29,13 +31,13 @@ truncate(Riak, File, Start) ->
 %% internal api
 %%==============================================
 no_tree_put_range(Riak, File, Start, Data) ->
-  error_logger:info_msg("no_tree_put_range(Riak, File, ~p, ~p)~n", [Start, Data]),
+  ?debugFmt("no_tree_put_range(Riak, File, ~p, ~p)~n", [Start, Data]),
   BlockSize = luwak_file:get_property(File, block_size),
   BlockAlignedStart = Start - (Start rem BlockSize),
   case (Start rem BlockSize) of
     0 -> write_blocks(Riak, File, undefined, Start, Data, BlockSize, []);
     BlockOffset ->
-      error_logger:info_msg("blockoffset ~p~n", [BlockOffset]),
+      ?debugFmt("blockoffset ~p~n", [BlockOffset]),
       {ok, Block} = luwak_tree:block_at(Riak, File, Start),
       write_blocks(Riak, File, Block, Start, Data, BlockSize, [])
   end.
@@ -56,11 +58,11 @@ internal_put_range(Riak, File, Start, Data) ->
   end.
 
 write_blocks(_, _, _, Start, <<>>, _, Written) when is_list(Written) ->
-  % error_logger:info_msg("A write_blocks(_, _, _, ~p, <<>>, _, ~p) ~n", [Start, Written]),
+  ?debugFmt("A write_blocks(_, _, _, ~p, <<>>, _, ~p) ~n", [Start, Written]),
   {ok, lists:reverse(Written)};
 %% start aligned sub-block write
 write_blocks(Riak, File, undefined, Start, Data, BlockSize, Written) when is_list(Written), byte_size(Data) < BlockSize ->
-  % error_logger:info_msg("B write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [undefined, Start, Data, BlockSize, Written]),
+  ?debugFmt("B write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [undefined, Start, Data, BlockSize, Written]),
   DataSize = byte_size(Data),
   case luwak_tree:block_at(Riak, File, Start) of
     {ok, undefined} ->
@@ -77,13 +79,13 @@ write_blocks(Riak, File, undefined, Start, Data, BlockSize, Written) when is_lis
   end;
 %% fully aligned write
 write_blocks(Riak, File, undefined, Start, Data, BlockSize, Written) when is_list(Written) ->
-  % error_logger:info_msg("C write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [undefined, Start, Data, BlockSize, Written]),
+  ?debugFmt("C write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [undefined, Start, Data, BlockSize, Written]),
   <<Slice:BlockSize/binary, Tail/binary>> = Data,
   {ok, Block} = luwak_block:create(Riak, Slice),
   write_blocks(Riak, File, undefined, Start+BlockSize, Tail, BlockSize, [{luwak_block:name(Block),BlockSize}|Written]);
 %% we are doing a sub-block write
 write_blocks(Riak, File, PartialStartBlock, Start, Data, BlockSize, Written) when is_list(Written), byte_size(Data) < BlockSize ->
-  % error_logger:info_msg("D write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [PartialStartBlock, Start, Data, BlockSize, Written]),
+  ?debugFmt("D write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [PartialStartBlock, Start, Data, BlockSize, Written]),
   DataSize = byte_size(Data),
   PartialStart = Start rem BlockSize,
   <<Head:PartialStart/binary, _:DataSize/binary, Tail/binary>> = luwak_block:data(PartialStartBlock),
@@ -92,19 +94,19 @@ write_blocks(Riak, File, PartialStartBlock, Start, Data, BlockSize, Written) whe
   {ok, lists:reverse([{luwak_block:name(Block),byte_size(BlockData)}|Written])};
 %% we are starting with a sub-block write
 write_blocks(Riak, File, PartialStartBlock, Start, Data, BlockSize, Written) when Start > BlockSize ->
-  % error_logger:info_msg("E write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [PartialStartBlock, Start, Data, BlockSize, Written]),
+  ?debugFmt("E write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [PartialStartBlock, Start, Data, BlockSize, Written]),
   HeadSize = Start rem BlockSize,
   MidSize = BlockSize - HeadSize,
-  % error_logger:info_msg("headsize ~p midsize ~p~n", [HeadSize, MidSize]),
+  ?debugFmt("headsize ~p midsize ~p~n", [HeadSize, MidSize]),
   <<Head:HeadSize/binary,_/binary>> = luwak_block:data(PartialStartBlock),
   <<Mid:MidSize/binary, Tail/binary>> = Data,
   BlockData = <<Head/binary, Mid/binary>>,
   {ok, Block} = luwak_block:create(Riak, BlockData),
   write_blocks(Riak, File, undefined, Start+byte_size(BlockData), Tail, BlockSize, [{luwak_block:name(Block),byte_size(BlockData)}|Written]);
 write_blocks(Riak, File, PartialStartBlock, Start, Data, BlockSize, Written) when is_list(Written) ->
-  % error_logger:info_msg("F write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [PartialStartBlock, Start, Data, BlockSize, Written]),
+  ?debugFmt("F write_blocks(Riak, File, ~p, ~p, ~p, ~p, ~p) ~n", [PartialStartBlock, Start, Data, BlockSize, Written]),
   ChopDataSize = BlockSize - Start,
-  % error_logger:info_msg("chopdatasize ~p~n", [ChopDataSize]),
+  ?debugFmt("chopdatasize ~p~n", [ChopDataSize]),
   <<ChopData:ChopDataSize/binary, Tail/binary>> = Data,
   <<Head:Start/binary, _/binary>> = luwak_block:data(PartialStartBlock),
   BlockData = <<Head/binary, ChopData/binary>>,

apps/luwak/src/luwak_put_stream.erl

@@ -2,6 +2,9 @@
 
 -define(BUFFER_SIZE, 20).
 -record(state, {file,offset,blocksize,ref,ttl,written=[],buffer=[],buffersize=0}).
+
+-include_lib("luwak/include/luwak.hrl").
+
 %% API
 -export([start_link/4, start/4, send/2, ping/1, close/1, status/2]).
 
@@ -87,12 +90,12 @@ update_tree(Riak, State) ->
   State.
 
 flush(Riak, State=#state{offset=Offset,file=File,buffer=Buffer,written=Written}) when length(Buffer) > 0 ->
-  error_logger:info_msg("A flush(Riak, ~p)~n", [State]),
+  ?debugFmt("A flush(Riak, ~p)~n", [State]),
   {ok, Written1} = luwak_io:no_tree_put_range(Riak, File, Offset, iolist_to_binary(lists:reverse(Buffer))),
   WriteSize = luwak_tree_utils:blocklist_length(Written1),
   flush(Riak, State#state{offset=Offset+WriteSize,buffer=[],buffersize=0,written=Written++Written1});
 flush(Riak, State=#state{offset=Offset,file=File,written=Written}) when length(Written) > 0 ->
-  error_logger:info_msg("B flush(Riak, ~p)~n", [State]),
+  ?debugFmt("B flush(Riak, ~p)~n", [State]),
   OriginalOffset = Offset - luwak_tree_utils:blocklist_length(Written),
   {ok, NewFile} = luwak_tree:update(Riak, File, OriginalOffset, Written),
   {flushed, State#state{file=NewFile}};

apps/luwak/src/luwak_tree.erl

@@ -22,9 +22,9 @@ update(Riak, File, StartingPos, Blocks) ->
       luwak_file:update_root(Riak, File, RootName);
     RootName ->
       {ok, Root} = get(Riak, RootName),
-      error_logger:info_msg("blocks~n"),
+      ?debugMsg("blocks~n"),
       WriteLength = luwak_tree_utils:blocklist_length(Blocks),
-      error_logger:info_msg("children~n"),
+      ?debugMsg("children~n"),
       RootLength = luwak_tree_utils:blocklist_length(Root#n.children),
       {ok, NewRoot} = subtree_update(Riak, File, Order, StartingPos, 0, 
         Root, Blocks),
@@ -34,33 +34,29 @@ update(Riak, File, StartingPos, Blocks) ->
 
 get_range(_, _, _, _, _, 0) ->
   [];
-% get_range(_, _, _, TreeStart, Start, _) when Start < TreeStart ->
-%   error_logger:info_msg("C get_range(_, _, _, ~p, ~p, _)~n", [TreeStart, Start]),
-%   %% what are you even doing here
-%   [];
 get_range(Riak, Parent = #n{children=[]}, BlockSize, TreeStart, Start, End) ->
-  error_logger:info_msg("D get_range(_, _, _, _, _, _)~n"),
+  ?debugMsg("D get_range(_, _, _, _, _, _)~n"),
   [];
 %% children are individual blocks
 %% we can do this because trees are guaranteed to be full
 get_range(Riak, Parent = #n{children=[{_,BlockSize}|_]=Children}, BlockSize, TreeStart, Start, End) ->
-  error_logger:info_msg("A get_range(Riak, ~p, ~p, ~p, ~p, ~p)~n", [Parent, BlockSize, TreeStart, Start, End]),
+  ?debugFmt("A get_range(Riak, ~p, ~p, ~p, ~p, ~p)~n", [Parent, BlockSize, TreeStart, Start, End]),
   {Nodes,_} = read_split(Children, TreeStart, Start, End);
 get_range(Riak, Parent = #n{children=Children}, BlockSize, TreeStart, Start, End) ->
-  error_logger:info_msg("B get_range(Riak, ~p, ~p, ~p, ~p, ~p)~n", [Parent, BlockSize, TreeStart, Start, End]),
+  ?debugFmt("B get_range(Riak, ~p, ~p, ~p, ~p, ~p)~n", [Parent, BlockSize, TreeStart, Start, End]),
   {Nodes, Length} = read_split(Children, TreeStart, Start, End),
   luwak_tree_utils:foldrflatmap(fun({Name,NodeLength}, AccLength) ->
-      error_logger:info_msg("foldrflatmap({~p,~p}, ~p)~n", [Name, NodeLength, AccLength]),
+      ?debugFmt("foldrflatmap({~p,~p}, ~p)~n", [Name, NodeLength, AccLength]),
       {ok, Node} = get(Riak, Name),
       {Blocks,_} = get_range(Riak, Node, BlockSize, AccLength, Start, End),
       {Blocks, AccLength+NodeLength}
     end, Nodes, Length).
 
 truncate(_Riak, File, _Start, undefined, _Order, _NodeOffset, _BlockSize) ->
-  error_logger:info_msg("A truncate(Riak, File, ~p, undefined, ~p, ~p, ~p)~n", [_Start, _Order, _NodeOffset, _BlockSize]),
+  ?debugFmt("A truncate(Riak, File, ~p, undefined, ~p, ~p, ~p)~n", [_Start, _Order, _NodeOffset, _BlockSize]),
   {ok, {undefined,0}};
 truncate(Riak, File, Start, Parent=#n{children=Children}, Order, NodeOffset, BlockSize) ->
-  error_logger:info_msg("B truncate(Riak, File, ~p, ~p, ~p, ~p, ~p)~n", [Start,Parent,Order,NodeOffset,BlockSize]),
+  ?debugFmt("B truncate(Riak, File, ~p, ~p, ~p, ~p, ~p)~n", [Start,Parent,Order,NodeOffset,BlockSize]),
   {Keep, {Recurse,RecLength}, _} = which_child(Children, NodeOffset, Start, []),
   KeepLength = luwak_tree_utils:blocklist_length(Keep),
   {ok, SubNode} = get(Riak, Recurse),
@@ -69,7 +65,7 @@ truncate(Riak, File, Start, Parent=#n{children=Children}, Order, NodeOffset, Blo
   NewNodeVal = riak_object:get_value(NewNode),
   {ok, {riak_object:key(NewNode), luwak_tree_utils:blocklist_length(NewNodeVal#n.children)}};
 truncate(Riak, File, Start, Block, _Order, NodeOffset, BlockSize) ->
-  error_logger:info_msg("C truncate(Riak, File, ~p, ~p, ~p, ~p, ~p)~n", [Start, Block, _Order, NodeOffset, BlockSize]),
+  ?debugFmt("C truncate(Riak, File, ~p, ~p, ~p, ~p, ~p)~n", [Start, Block, _Order, NodeOffset, BlockSize]),
   Data = luwak_block:data(Block),
   ByteOffset = Start - NodeOffset,
   <<Retain:ByteOffset/binary, _/binary>> = Data,
@@ -79,12 +75,12 @@ truncate(Riak, File, Start, Block, _Order, NodeOffset, BlockSize) ->
 read_split(Children, TreeStart, Start, End) when Start < 0 ->
   read_split(Children, TreeStart, 0, End);
 read_split(Children, TreeStart, Start, End) ->
-  error_logger:info_msg("read_split(~p, ~p, ~p, ~p)~n", [Children, TreeStart, Start, End]),
+  ?debugFmt("read_split(~p, ~p, ~p, ~p)~n", [Children, TreeStart, Start, End]),
   InsidePos = Start - TreeStart,
   InsideEnd = End - TreeStart,
   {Head,Tail} = luwak_tree_utils:split_at_length(Children, InsidePos),
   {Middle,_} = luwak_tree_utils:split_at_length_left_bias(Tail, InsideEnd),
-  error_logger:info_msg("middle ~p~n", [Middle]),
+  ?debugFmt("middle ~p~n", [Middle]),
   {Middle, luwak_tree_utils:blocklist_length(Head)+TreeStart}.
 
 get(Riak, Name) when is_binary(Name) ->
@@ -115,7 +111,7 @@ visualize_tree(Riak, DataName = <<Prefix:8/binary, _/binary>>, DataNode) ->
   io_lib:format("\"~s\" [shape=record,label=\"~s | ~s\",regular=1,style=filled,fillcolor=gray ] ;~n", [DataName,Prefix,Data]).
 
 create_tree(Riak, Order, Children) when is_list(Children) ->
-  % error_logger:info_msg("create_tree(Riak, ~p, ~p)~n", [Order, Children]),
+  ?debugFmt("create_tree(Riak, ~p, ~p)~n", [Order, Children]),
   if
     length(Children) > Order ->
       Written = list_into_nodes(Riak, Children, Order, 0),
@@ -126,11 +122,11 @@ create_tree(Riak, Order, Children) when is_list(Children) ->
 
 %% updating any node happens in up to 5 parts, depending on the coverage of the write list
 subtree_update(Riak, File, Order, InsertPos, TreePos, Parent = #n{}, Blocks) ->
-  % error_logger:info_msg("subtree_update(Riak, File, ~p, ~p, ~p, ~p, ~p)~n", [Order, InsertPos, TreePos, Parent, truncate(Blocks)]),
+  ?debugFmt("subtree_update(Riak, File, ~p, ~p, ~p, ~p, ~p)~n", [Order, InsertPos, TreePos, Parent, truncate(Blocks)]),
   {NodeSplit, BlockSplit} = luwak_tree_utils:five_way_split(TreePos, Parent#n.children, InsertPos, Blocks),
-  % error_logger:info_msg("NodeSplit ~p BlockSplit ~p~n", [NodeSplit, BlockSplit]),
+  ?debugFmt("NodeSplit ~p BlockSplit ~p~n", [NodeSplit, BlockSplit]),
   MidHeadStart = luwak_tree_utils:blocklist_length(NodeSplit#split.head) + TreePos,
-  % error_logger:info_msg("midhead~n"),
+  ?debugMsg("midhead~n"),
   MidHeadReplacement = lists:map(fun({Name,Length}) ->
       {ok, ChildNode} = get(Riak, Name),
       {ok, ReplacementChild} = subtree_update(Riak, File, Order, 
@@ -140,10 +136,10 @@ subtree_update(Riak, File, Order, InsertPos, TreePos, Parent = #n{}, Blocks) ->
       {riak_object:key(ReplacementChild), luwak_tree_utils:blocklist_length(V#n.children)}
     end, NodeSplit#split.midhead),
   MiddleInsertStart = luwak_tree_utils:blocklist_length(BlockSplit#split.midhead) + MidHeadStart,
-  % error_logger:info_msg("middle~n"),
+  ?debugMsg("middle~n"),
   MiddleReplacement = list_into_nodes(Riak, BlockSplit#split.middle, Order, MiddleInsertStart),
   MidTailStart = luwak_tree_utils:blocklist_length(BlockSplit#split.middle) + MiddleInsertStart,
-  % error_logger:info_msg("midtail~n"),
+  ?debugMsg("midtail~n"),
   MidTailReplacement = lists:map(fun({Name,Length}) ->
       {ok, ChildNode} = get(Riak, Name),
       {ok, ReplacementChild} = subtree_update(Riak, File, Order,
@@ -152,15 +148,15 @@ subtree_update(Riak, File, Order, InsertPos, TreePos, Parent = #n{}, Blocks) ->
       V = riak_object:get_value(ReplacementChild),
       {riak_object:key(ReplacementChild), luwak_tree_utils:blocklist_length(V#n.children)}
     end, NodeSplit#split.midtail),
-  % error_logger:info_msg("end~n"),
+  ?debugMsg("end~n"),
   create_tree(Riak, Order, NodeSplit#split.head ++ 
     MidHeadReplacement ++ 
     MiddleReplacement ++ 
     MidTailReplacement ++
     NodeSplit#split.tail).
 
 list_into_nodes(Riak, Children, Order, StartingPos) ->
-  % error_logger:info_msg("list_into_nodes(Riak, ~p, ~p, ~p)~n", [Children, Order, StartingPos]),
+  ?debugFmt("list_into_nodes(Riak, ~p, ~p, ~p)~n", [Children, Order, StartingPos]),
   map_sublist(fun(Sublist) ->
       Length = luwak_tree_utils:blocklist_length(Sublist),
       {ok, Obj} = create_node(Riak, Sublist),
@@ -175,7 +171,6 @@ block_at(Riak, File, Pos) ->
   Length = luwak_file:get_property(File, length),
   case luwak_file:get_property(File, root) of
     undefined -> {error, notfound};
-    % RootName when Pos > Length -> eof;
     RootName ->
       block_at_retr(Riak, RootName, 0, Pos)
   end.
@@ -198,16 +193,16 @@ block_at_node(Riak, NodeObj, block, _, NodeOffset, _) ->
   {ok, NodeObj}.
 
 which_child([E={ChildName,Length}], NodeOffset, Pos, Acc) when Pos > Length+NodeOffset ->
-  % error_logger:info_msg("A which_child(~p, ~p, ~p)~n", [E, NodeOffset, Pos]),
+  ?debugFmt("A which_child(~p, ~p, ~p)~n", [E, NodeOffset, Pos]),
   {lists:reverse([E|Acc]), undefined, []};
 which_child([E={ChildName,Length}], NodeOffset, Pos, Acc) ->
-  % error_logger:info_msg("B which_child(~p, ~p, ~p)~n", [E, NodeOffset, Pos]),
+  ?debugFmt("B which_child(~p, ~p, ~p)~n", [E, NodeOffset, Pos]),
   {lists:reverse(Acc), E, []};
 which_child([E={ChildName,Length}|Tail], NodeOffset, Pos, Acc) when Pos >= NodeOffset + Length ->
-  % error_logger:info_msg("C which_child(~p, ~p, ~p)~n", [[{ChildName,Length}|Tail], NodeOffset, Pos]),
+  ?debugFmt("C which_child(~p, ~p, ~p)~n", [[{ChildName,Length}|Tail], NodeOffset, Pos]),
   which_child(Tail, NodeOffset+Length, Pos, [E|Acc]);
 which_child([E={ChildName,Length}|Tail], NodeOffset, Pos, Acc) when Pos < NodeOffset + Length ->
-  % error_logger:info_msg("D which_child(~p, ~p, ~p)~n", [[{ChildName,Length}|Tail], NodeOffset, Pos]),
+  ?debugFmt("D which_child(~p, ~p, ~p)~n", [[{ChildName,Length}|Tail], NodeOffset, Pos]),
   {lists:reverse(Acc), {ChildName,Length}, Tail}.
 
 map_sublist(Fun, N, List) ->
@@ -226,28 +221,8 @@ map_sublist_1(Fun, N, [E|List], Sublist, Acc) ->
   map_sublist_1(Fun, N, List, [E|Sublist], Acc).
 
 create_node(Riak, Children) ->
-  % error_logger:info_msg("create_node(Riak, ~p)~n", [Children]),
+  ?debugFmt("create_node(Riak, ~p)~n", [Children]),
   N = #n{created=now(),children=Children},
   Name = skerl:hexhash(?HASH_LEN, term_to_binary(Children)),
   Obj = riak_object:new(?N_BUCKET, Name, N),
   {Riak:put(Obj, 2), Obj}.
-
-floor(X) ->
-  T = erlang:trunc(X),
-  case (X - T) of
-    Neg when Neg < 0 -> T - 1;
-    Pos when Pos > 0 -> T;
-    _ -> T
-  end.
-
-ceiling(X) ->
-  T = erlang:trunc(X),
-  case (X - T) of
-    Neg when Neg < 0 -> T;
-    Pos when Pos > 0 -> T + 1;
-    _ -> T
-  end.
-
-truncate(List) when is_list(List) ->
-  lists:map(fun({Data,Length}) -> {truncate(Data),Length} end, List);
-truncate(Data = <<Prefix:8/binary, _/binary>>) -> Prefix.

apps/luwak/src/luwak_tree_utils.erl

@@ -17,11 +17,11 @@ longest_divisable_subtree([], [], _, _, AccA, AccB) ->
   {{lists:reverse(AccA), []}, {lists:reverse(AccB), []}};
 %% listA was exhausted first, we favor listB as a special case here
 longest_divisable_subtree([], NodesB, _, LengthB, AccA, AccB) ->
-    % error_logger:info_msg("accA ~p accB ~p~n", [AccA, AccB]),
+    ?debugFmt("accA ~p accB ~p~n", [AccA, AccB]),
   {{lists:reverse(AccA), []}, {lists:reverse(AccB) ++ NodesB, []}};
 %% listB was exhausted first, put back until equal
 longest_divisable_subtree(NodesA, [], LengthA, _, AccA, AccB) ->
-    % error_logger:info_msg("accA ~p accB ~p~n", [AccA, AccB]),
+    ?debugFmt("accA ~p accB ~p~n", [AccA, AccB]),
   {NodesB, FinalAccB} = split_at_length(lists:reverse(AccB), LengthA),
   {{lists:reverse(AccA), NodesA}, {NodesB, FinalAccB}};
 %% equal length subseq
@@ -69,20 +69,20 @@ split_at_length([{Name,L}|Children], Length, AccLen, Acc) ->
 
 five_way_split(TreePos, Nodes, InsertPos, Blocks) ->
   Offset = InsertPos - TreePos,
-  % error_logger:info_msg("offset ~p~n", [Offset]),
+  ?debugFmt("offset ~p~n", [Offset]),
   One = {NoOverlapHeadNode, TailNode1} = split_at_length(Nodes, Offset),
-  % error_logger:info_msg("1: ~p~n", [One]),
+  ?debugFmt("1: ~p~n", [One]),
   NegativeOverlap = InsertPos - (TreePos + blocklist_length(NoOverlapHeadNode)),
-  % error_logger:info_msg("neg overlap ~p~n", [NegativeOverlap]),
+  ?debugFmt("neg overlap ~p~n", [NegativeOverlap]),
   Two = {{OverlapHeadNode, TailNode2}, {OverlapHeadBlocks, TailBlocks1}} = shortest_subtree_split(TailNode1, Blocks, 0, NegativeOverlap),
-  % error_logger:info_msg("2: ~p~n", [Two]),
+  ?debugFmt("2: ~p~n", [Two]),
   Three = {{MiddleNode, TailNode3}, {MiddleBlocks, TailBlocks2}} = longest_divisable_subtree(TailNode2, TailBlocks1),
-  % error_logger:info_msg("3: ~p~n", [Three]),
+  ?debugFmt("3: ~p~n", [Three]),
   Four = {OverlapTailNode, NoOverlapTailNode} = case TailNode3 of
     [V|T] when length(TailBlocks2) > 0 -> {[V], T};
     _ -> {[], TailNode3}
   end,
-  % error_logger:info_msg("4: ~p~n", [Four]),
+  ?debugFmt("4: ~p~n", [Four]),
   {#split{
     head=NoOverlapHeadNode,
     midhead=OverlapHeadNode,
@@ -95,7 +95,7 @@ five_way_split(TreePos, Nodes, InsertPos, Blocks) ->
     midtail=TailBlocks2}}.
 
 blocklist_length(Children) ->
-  % error_logger:info_msg("blocklist_length(~p)~n", [Children]),
+  ?debugFmt("blocklist_length(~p)~n", [Children]),
   lists:foldr(fun({_,L},Acc) ->
       L+Acc
     end, 0, Children).

apps/luwak/test/luwak_tree_tests.erl

@@ -1,7 +1,7 @@
 -module(luwak_tree_tests).
 
--include_lib("luwak/include/luwak.hrl").
 -include_lib("eunit/include/eunit.hrl").
+-include_lib("luwak/include/luwak.hrl").
 
 create_simple_tree_test() ->
   test_helper:riak_test(fun(Riak) ->