anchor.diff:                  none,
                   lists:zip(Mine, tl(Mine)++[hd(Mine)])).
   
  -claim_rebalance_n(Ring0, Node) ->
  -    Ring = riak_core_ring:upgrade(Ring0),
  -    Nodes = lists:usort([Node|riak_core_ring:claiming_members(Ring)]),
  -    Zipped = diagonal_stripe(Ring, Nodes),
  -    lists:foldl(fun({P, N}, Acc) ->
  -                        riak_core_ring:transfer_node(P, N, Acc)
  -                end,
  -                Ring,
  -                Zipped).
  -
  -diagonal_stripe(Ring, Nodes) ->
  -    %% diagonal stripes guarantee most disperse data
  -    Partitions = lists:sort([ I || {I, _} <- riak_core_ring:all_owners(Ring) ]),
  -    Zipped = lists:zip(Partitions,
  -                       lists:sublist(
  -                         lists:flatten(
  -                           lists:duplicate(
  -                             1+(length(Partitions) div length(Nodes)),
  -                             Nodes)),
  -                         1, length(Partitions))),
  -    Zipped.
  -
  -random_choose_claim(Ring) ->
  -    random_choose_claim(Ring, node()).
  -
  -random_choose_claim(Ring0, Node) ->
  -    Ring = riak_core_ring:upgrade(Ring0),
  -    riak_core_ring:transfer_node(riak_core_ring:random_other_index(Ring),
  -                                 Node, Ring).
  -
  -%% @spec never_wants_claim(riak_core_ring()) -> no
  -%% @doc For use by nodes that should not claim any partitions.
  -never_wants_claim(_) -> no.
  -
  +%% @private
  +get_expected_partitions(Ring, Node) ->
  +    riak_core_ring:num_partitions(Ring) div get_member_count(Ring, Node).
  +
  +%% @private
  +get_member_count(Ring, Node) ->
  +    %% Determine how many nodes are involved with the ring; if the requested
  +    %% node is not yet part of the ring, include it in the count.
  +    AllMembers = riak_core_ring:claiming_members(Ring),
  +    case lists:member(Node, AllMembers) of
  +        true ->
  +            length(AllMembers);
  +        false ->
  +            length(AllMembers) + 1
  +    end.
   
   %% ===================================================================
   %% Unit tests
  
positive.code: 
  default_wants_claim(Ring, Node) ->
      wants_claim_v1(Ring, Node).
  
  get_member_count(Ring, Node) ->
      %% Determine how many nodes are involved with the ring; if the requested
      %% node is not yet part of the ring, include it in the count.
      AllMembers = riak_core_ring:claiming_members(Ring),
      case lists:member(Node, AllMembers) of
          true ->
              length(AllMembers);
          false ->
              length(AllMembers) + 1
      end.
  
  get_expected_partitions(Ring, Node) ->
      riak_core_ring:num_partitions(Ring) div get_member_count(Ring, Node).
  
  wants_claim_v1(Ring) ->
      wants_claim_v1(Ring, node()).
  
negative.code: -include_lib("eunit/include/eunit.hrl").
  -endif.
  
  %% ===================================================================
  %% API
  %% ===================================================================
  
  %% @spec default_choose_claim(riak_core_ring()) -> riak_core_ring()
  %% @doc Choose a partition at random.
  default_choose_claim(Ring) ->
      default_choose_claim(Ring, node()).
  
  default_choose_claim(Ring, Node) ->
      choose_claim_v1(Ring, Node).
  
  %% @spec default_wants_claim(riak_core_ring()) -> {yes, integer()} | no
  %% @doc Want a partition if we currently have less than floor(ringsize/nodes).
  default_wants_claim(Ring) ->
  