removing unused funs and vars, adding _s

apps/luwak/src/luwak_file.erl

@@ -67,7 +67,7 @@ get_attributes(Obj) ->
 %% @doc Checks for the existence of the named file.
 exists(Riak, Name) ->
   case Riak:get(?O_BUCKET, Name, 2) of
-    {ok, Obj} -> {ok, true};
+    {ok, _Obj} -> {ok, true};
     {error, notfound} -> {ok, false};
     Err -> Err
   end.
@@ -118,11 +118,11 @@ get_property(Obj, PropName) ->
 
 %% @private
 update_root(Riak, Obj, NewRoot) ->
-  Values = riak_object:get_value(Obj),
   ObjVal1 = riak_object:get_value(Obj),
   OldRoot = proplists:get_value(root, ObjVal1),
   Ancestors = proplists:get_value(ancestors, ObjVal1),
-  ObjVal2 = lists:keyreplace(ancestors, 1, ObjVal1, {ancestors, [OldRoot|Ancestors]}),
+  ObjVal2 = lists:keyreplace(ancestors, 1, ObjVal1,
+                             {ancestors, [OldRoot|Ancestors]}),
   ObjVal3 = lists:keyreplace(root, 1, ObjVal2, {root, NewRoot}),
   Obj2 = riak_object:apply_updates(riak_object:update_value(Obj, ObjVal3)),
   ok = Riak:put(Obj2, 2),
@@ -132,9 +132,9 @@ update_root(Riak, Obj, NewRoot) ->
 update_checksum(Riak, Obj, ChecksumFun) ->
   case get_property(Obj, checksumming) of
     true ->
-      Values = riak_object:get_value(Obj),
       ObjVal1 = riak_object:get_value(Obj),
-      ObjVal2 = lists:keyreplace(checksum, 1, ObjVal1, {checksum, {sha1, ChecksumFun()}}),
+      ObjVal2 = lists:keyreplace(checksum, 1, ObjVal1, 
+                                 {checksum, {sha1, ChecksumFun()}}),
       Obj2 = riak_object:apply_updates(riak_object:update_value(Obj, ObjVal2)),
       ok = Riak:put(Obj2, 2),
       {ok, Obj2};
@@ -145,4 +145,4 @@ update_checksum(Riak, Obj, ChecksumFun) ->
 %% @spec name(Obj :: luwak_file()) -> binary()
 %% @doc returns the name of the given file handle.
 name(Obj) ->
-  riak_object:key(Obj).
+  riak_object:key(Obj).

apps/luwak/src/luwak_get_stream.erl

@@ -26,7 +26,7 @@ start(Riak, File, Start, Length) ->
 %%      delivered, the stream ends, or until Timeout milliseconds have elapsed.  Whichever
 %%      occurs first.  The data blocks are returned as a tuple with the data binary and
 %%      its offset from the start of the file.
-recv({get_stream, Ref, Pid}, Timeout) ->
+recv({get_stream, Ref, _Pid}, Timeout) ->
   receive
     {get, Ref, Data, Offset} -> {Data, Offset};
     {get, Ref, eos} -> eos;
@@ -42,7 +42,7 @@ close({get_stream, Ref, Pid}) ->
 
 nonblock_mr(Riak,Query,MapInput) ->
   case Riak:mapred_stream(Query,self(),60000) of
-      {ok, {ReqId, FlowPid}} ->
+      {ok, {_ReqId, FlowPid}} ->
           luke_flow:add_inputs(FlowPid, MapInput),
           luke_flow:finish_inputs(FlowPid);
       Error ->
@@ -104,29 +104,27 @@ map(Parent=#n{}, TreeOffset, Map=#map{riak=Riak,offset=Offset,endoffset=EndOffse
       end)
   end,
   [];
-map(Block, TreeOffset, Map=#map{riak=Riak,offset=Offset,endoffset=EndOffset,ref=Ref,pid=Pid,blocksize=BlockSize}) when TreeOffset < Offset ->
+map(Block, TreeOffset, _Map=#map{offset=Offset,ref=Ref,pid=Pid})
+ when TreeOffset < Offset ->
   ?debugFmt("B map(~p, ~p, ~p)~n", [Block, TreeOffset, Map]),
   PartialSize = Offset - TreeOffset,
   <<_:PartialSize/binary, Tail/binary>> = luwak_block:data(Block),
   ?debugFmt("sending ~p~n", [{get, Ref, Tail, Offset}]),
   Pid ! {get, Ref, Tail, Offset},
   [];
-map(Block, TreeOffset, Map=#map{riak=Riak,offset=Offset,endoffset=EndOffset,ref=Ref,pid=Pid,blocksize=BlockSize}) when BlockSize >= EndOffset - TreeOffset ->
+map(Block, TreeOffset,
+    _Map=#map{endoffset=EndOffset,ref=Ref,pid=Pid,blocksize=BlockSize})
+ when BlockSize >= EndOffset - TreeOffset ->
   ?debugFmt("C map(~p, ~p, ~p)~n", [Block, TreeOffset, Map]),
   PartialSize = EndOffset - TreeOffset,
   <<PartialData:PartialSize/binary, _/binary>> = luwak_block:data(Block),
   ?debugFmt("sending ~p~n", [{get, Ref, PartialData, TreeOffset}]),
   Pid ! {get, Ref, PartialData, TreeOffset},
   [];
-map(Block, TreeOffset, Map=#map{riak=Riak,offset=Offset,endoffset=EndOffset,ref=Ref,pid=Pid,blocksize=BlockSize}) ->
+map(Block, TreeOffset, _Map=#map{ref=Ref,pid=Pid}) ->
   ?debugFmt("D map(~p, ~p, ~p)~n", [Block, TreeOffset, Map]),
   Data = luwak_block:data(Block),
   ?debugFmt("sending ~p~n", [{get, Ref, Data, TreeOffset}]),
   Pid ! {get, Ref, Data, TreeOffset},
   [].
 
-ident_fun() ->
-  fun({Name,Length}, NodeOffset) ->
-    {[{Name,Length}], NodeOffset}
-  end.
-

apps/luwak/src/luwak_io.erl

@@ -47,11 +47,10 @@ truncate(Riak, File, Start) ->
 no_tree_put_range(Riak, File, 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 ->
-      ?debugFmt("blockoffset ~p~n", [BlockOffset]),
+    _BlockOffset ->
+      ?debugFmt("blockoffset ~p~n", [_BlockOffset]),
       {ok, Block} = luwak_tree:block_at(Riak, File, Start),
       write_blocks(Riak, File, Block, Start, Data, BlockSize, [])
   end.
@@ -65,15 +64,15 @@ internal_put_range(Riak, File, Start, Data) ->
       {ok, NewFile} = luwak_tree:update(Riak, File, BlockAlignedStart, Written),
       {ok, NewFile1} = luwak_file:update_checksum(Riak, NewFile, fun() -> crypto:sha(Data) end),
       {ok, Written, NewFile1};
-    BlockOffset -> 
+    _BlockOffset -> 
       {ok, Block} = luwak_tree:block_at(Riak, File, Start),
       {ok, Written} = write_blocks(Riak, File, Block, Start, Data, BlockSize, []),
       {ok, NewFile} = luwak_tree:update(Riak, File, BlockAlignedStart, Written),
       {ok, NewFile1} = luwak_file:update_checksum(Riak, NewFile, fun() -> crypto:sha(Data) end),
       {ok, Written, NewFile1}
   end.
 
-write_blocks(_, _, _, Start, <<>>, _, Written) when is_list(Written) ->
+write_blocks(_, _, _, _Start, <<>>, _, Written) when is_list(Written) ->
   ?debugFmt("A write_blocks(_, _, _, ~p, <<>>, _, ~p) ~n", [Start, Written]),
   {ok, lists:reverse(Written)};
 %% start aligned sub-block write
@@ -100,7 +99,7 @@ write_blocks(Riak, File, undefined, Start, Data, BlockSize, Written) when is_lis
   {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 ->
+write_blocks(Riak, _File, PartialStartBlock, Start, Data, BlockSize, Written) when is_list(Written), byte_size(Data) < BlockSize ->
   ?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,
@@ -132,7 +131,7 @@ write_blocks(Riak, File, PartialStartBlock, Start, Data, BlockSize, Written) whe
 retrieve_blocks(Riak, Blocks, ChopHead, Length) ->
   retrieve_blocks(Riak, Blocks, ChopHead, Length, []).
 
-retrieve_blocks(Riak, [], _, _, Acc) ->
+retrieve_blocks(_Riak, [], _, _, Acc) ->
   lists:reverse(Acc);
 retrieve_blocks(Riak, [{Name,_}], _, 0, Acc) ->
   {ok, Block} = luwak_tree:get(Riak, Name),

apps/luwak/src/luwak_put_stream.erl

@@ -74,7 +74,7 @@ status({put_stream, Ref, Pid}, Timeout) ->
 flush({put_stream, Ref, Pid}) ->
   Pid ! {flush, Ref}.
 
-recv(Riak, {closed, State = #state{file=File,ttl=TTL}}) ->
+recv(_Riak, {closed, _State = #state{file=File,ttl=TTL}}) ->
   receive
     {status, Client, Ref} -> Client ! {stream, Ref, File}
   after TTL ->
@@ -83,7 +83,7 @@ recv(Riak, {closed, State = #state{file=File,ttl=TTL}}) ->
 recv(Riak, State = #state{ref=Ref,ttl=TTL,buffer=Buffer,file=File}) ->
   recv(Riak,
     receive
-      {put, Ref, Data} -> handle_data(Riak, State#state{buffer=[Data|Buffer],buffersize=iolist_size([Data|Buffer])});
+      {put, Ref, Data} -> handle_data(Riak,State#state{buffer=[Data|Buffer],buffersize=iolist_size([Data|Buffer])});
       {ping, Ref} -> State;
       {flush, Ref} -> flush(Riak, State);
       {close, Ref} -> close(Riak, State);
@@ -113,7 +113,7 @@ update_tree(Riak, State=#state{offset=Offset,file=File,written=Written}) when le
   OriginalOffset = Offset - luwak_tree_utils:blocklist_length(Written),
   {ok, NewFile} = luwak_tree:update(Riak, File, OriginalOffset, Written),
   update_checksum(Riak, State#state{file=NewFile});
-update_tree(Riak, State) ->
+update_tree(_Riak, State) ->
   State.
 
 flush(Riak, State=#state{offset=Offset,file=File,buffer=Buffer,written=Written}) when length(Buffer) > 0 ->
@@ -127,7 +127,7 @@ flush(Riak, State=#state{offset=Offset,file=File,written=Written}) when length(W
   OriginalOffset = Offset - luwak_tree_utils:blocklist_length(Written),
   {ok, NewFile} = luwak_tree:update(Riak, File, OriginalOffset, Written),
   update_checksum(Riak, State#state{file=NewFile});
-flush(Riak, State) ->
+flush(_Riak, State) ->
   State.
 
 checksum(_, State=#state{checksumming=false}) ->

apps/luwak/src/luwak_tree.erl

@@ -1,6 +1,6 @@
 -module(luwak_tree).
 
--export([update/4, get/2, block_at/3, visualize_tree/2, get_range/6, get_range/7, truncate/7]).
+-export([update/4, get/2, block_at/3, visualize_tree/2, get_range/6, get_range/7, truncate/7, truncate/1]).
 
 -include_lib("luwak/include/luwak.hrl").
 
@@ -23,9 +23,7 @@ update(Riak, File, StartingPos, Blocks) ->
     RootName ->
       {ok, Root} = get(Riak, RootName),
       ?debugMsg("blocks~n"),
-      WriteLength = luwak_tree_utils:blocklist_length(Blocks),
       ?debugMsg("children~n"),
-      RootLength = luwak_tree_utils:blocklist_length(Root#n.children),
       {ok, NewRoot} = subtree_update(Riak, File, Order, StartingPos, 0, 
         Root, Blocks),
       NewRootName = riak_object:key(NewRoot),
@@ -46,33 +44,33 @@ get_range(Riak, Parent, BlockSize, TreeStart, Start, End) ->
 
 get_range(_, _, _, _, _, _, 0) ->
   [];
-get_range(Riak, Fun, Parent = #n{children=[]}, BlockSize, TreeStart, Start, End) ->
+get_range(_Riak, _Fun, _Parent = #n{children=[]}, _BlockSize, _TreeStart, _Start, _End) ->
   ?debugMsg("D get_range(_, _, _, _, _, _)~n"),
   [];
 %% children are individual blocks
 %% we can do this because trees are guaranteed to be full
-get_range(Riak, Fun, Parent = #n{children=[{_,BlockSize}|_]=Children}, BlockSize, TreeStart, Start, End) ->
+get_range(_Riak, Fun, _Parent = #n{children=[{_,BlockSize}|_]=Children}, BlockSize, TreeStart, Start, End) ->
   ?debugFmt("A 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, Nodes, Length);
-get_range(Riak, Fun, Parent = #n{children=Children}, BlockSize, TreeStart, Start, End) ->
+get_range(_Riak, Fun, _Parent = #n{children=Children}, _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, Nodes, Length).
 
-truncate(_Riak, File, _Start, undefined, _Order, _NodeOffset, _BlockSize) ->
+truncate(_Riak, _File, _Start, undefined, _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) ->
+truncate(Riak, File, Start, _Parent=#n{children=Children}, 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, []),
+  {Keep, {Recurse,_RecLength}, _} = which_child(Children, NodeOffset, Start, []),
   KeepLength = luwak_tree_utils:blocklist_length(Keep),
   {ok, SubNode} = get(Riak, Recurse),
-  {ok, NN={NewSubTreeName,NewSubTreeLength}} = truncate(Riak, File, Start, SubNode, Order, NodeOffset+KeepLength, BlockSize),
+  {ok, NN} = truncate(Riak, File, Start, SubNode, Order, NodeOffset+KeepLength, BlockSize),
   {ok, NewNode} = create_tree(Riak, Order, Keep ++ [NN]),
   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) ->
+truncate(Riak, _File, 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,
@@ -114,7 +112,7 @@ visualize_tree(Riak, RootName = <<Prefix:8/binary, _/binary>>, #n{children=Child
   lists:map(fun({ChildName,Length}) ->
       io_lib:format("\"~s\" -> \"~s\" [dir=none,weight=1,label=\"~p\"] ;~n", [RootName,ChildName,Length])
     end, Children);
-visualize_tree(Riak, DataName = <<Prefix:8/binary, _/binary>>, DataNode) ->
+visualize_tree(_Riak, DataName = <<Prefix:8/binary, _/binary>>, DataNode) ->
   Data = luwak_block:data(DataNode),
   PrefixData = if
     byte_size(Data) > 8 ->
@@ -141,7 +139,7 @@ subtree_update(Riak, File, Order, InsertPos, TreePos, Parent = #n{}, Blocks) ->
   ?debugFmt("NodeSplit ~p BlockSplit ~p~n", [NodeSplit, BlockSplit]),
   MidHeadStart = luwak_tree_utils:blocklist_length(NodeSplit#split.head) + TreePos,
   ?debugMsg("midhead~n"),
-  MidHeadReplacement = lists:map(fun({Name,Length}) ->
+  MidHeadReplacement = lists:map(fun({Name,_Length}) ->
       {ok, ChildNode} = get(Riak, Name),
       {ok, ReplacementChild} = subtree_update(Riak, File, Order, 
         InsertPos, MidHeadStart, 
@@ -154,7 +152,7 @@ subtree_update(Riak, File, Order, InsertPos, TreePos, Parent = #n{}, Blocks) ->
   MiddleReplacement = list_into_nodes(Riak, BlockSplit#split.middle, Order, MiddleInsertStart),
   MidTailStart = luwak_tree_utils:blocklist_length(BlockSplit#split.middle) + MiddleInsertStart,
   ?debugMsg("midtail~n"),
-  MidTailReplacement = lists:map(fun({Name,Length}) ->
+  MidTailReplacement = lists:map(fun({Name,_Length}) ->
       {ok, ChildNode} = get(Riak, Name),
       {ok, ReplacementChild} = subtree_update(Riak, File, Order,
         MidTailStart, MidTailStart,
@@ -187,8 +185,6 @@ list_into_nodes(Riak, Children, Order, StartingPos) ->
 %% @spec block_at(Riak::riak(), File::luwak_file(), Pos::int()) ->
 %%          {ok, BlockObj} | {error, Reason}
 block_at(Riak, File, Pos) ->
-  BlockSize = luwak_file:get_property(File, block_size),
-  Length = luwak_file:get_property(File, length),
   case luwak_file:get_property(File, root) of
     undefined -> {error, notfound};
     RootName ->
@@ -204,24 +200,24 @@ block_at_retr(Riak, NodeName, NodeOffset, Pos) ->
     Err -> Err
   end.
 
-block_at_node(Riak, NodeObj, node, Links, NodeOffset, Pos) ->
+block_at_node(Riak, _NodeObj, node, Links, NodeOffset, Pos) ->
   case which_child(Links, NodeOffset, Pos, []) of
     {Head, {ChildName,_}, _} -> block_at_retr(Riak, ChildName, NodeOffset+luwak_tree_utils:blocklist_length(Head), Pos);
     {_, undefined, _} -> {ok, undefined}
   end;
-block_at_node(Riak, NodeObj, block, _, NodeOffset, _) ->
+block_at_node(_Riak, NodeObj, block, _, _NodeOffset, _) ->
   {ok, NodeObj}.
 
-which_child([E={ChildName,Length}], NodeOffset, Pos, Acc) when Pos > Length+NodeOffset ->
+which_child([E={_ChildName,Length}], NodeOffset, Pos, Acc) when Pos > Length+NodeOffset ->
   ?debugFmt("A which_child(~p, ~p, ~p)~n", [E, NodeOffset, Pos]),
   {lists:reverse([E|Acc]), undefined, []};
-which_child([E={ChildName,Length}], NodeOffset, Pos, Acc) ->
+which_child([E], _NodeOffset, _Pos, Acc) ->
   ?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 ->
+which_child([E={_ChildName,Length}|Tail], NodeOffset, Pos, Acc) when Pos >= NodeOffset + Length ->
   ?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 ->
+which_child([{ChildName,Length}|Tail], NodeOffset, Pos, Acc) when Pos < NodeOffset + Length ->
   ?debugFmt("D which_child(~p, ~p, ~p)~n", [[{ChildName,Length}|Tail], NodeOffset, Pos]),
   {lists:reverse(Acc), {ChildName,Length}, Tail}.
 
@@ -232,7 +228,7 @@ map_sublist_1(_, _, [], [], Acc) ->
   lists:reverse(Acc);
 map_sublist_1(_, N, [], Sublist, []) when length(Sublist) < N ->
   lists:reverse(Sublist);
-map_sublist_1(Fun, N, [], Sublist, Acc) ->
+map_sublist_1(Fun, _N, [], Sublist, Acc) ->
   lists:reverse([Fun(lists:reverse(Sublist))|Acc]);
 map_sublist_1(Fun, N, List, Sublist, Acc) when length(Sublist) >= N ->
   Result = Fun(lists:reverse(Sublist)),
@@ -250,4 +246,4 @@ create_node(Riak, Children) ->
 
 truncate(List) when is_list(List) ->
  lists:map(fun({Data,Length}) -> {truncate(Data),Length} end, List);
-truncate(Data = <<Prefix:8/binary, _/binary>>) -> Prefix.
+truncate(<<Prefix:8/binary, _/binary>>) -> Prefix.