anchor.diff:  	%BelongsNames = [{B, belongs_to} || B <- BossRec:belongs_to_names()],
   	HasTypes = extract_has_types(RecType),
   	Excluded = case erlang:function_exported(RecType, json_dec_exclude, 1) of
  -		true -> BossRec:json_exlude();
  +		true -> BossRec:json_dec_exlude();
   		_ -> []
   	end,
   	AllNames = lists:append([Attrs, HasTypes]),
  
positive.code: 		{_, boolean} when Val; not Val ->
  			correct_types(Tail, Types, [H | Acc]);
  		{_, DahType} ->
  			?info("Skipping ~p:~p as type ~p didn't sync up", [Key, Val, DahType]),
  			correct_types(Tail, Types, Acc)
  	end.
  
  
negative.code: 	end,
  	Attr2 = proplists:substitute_aliases(Lexxed, Attr1),
  
  	BelongsToAttrs = assign_belongs(BossRec, SkipRecs0),
  	Attr3 = lists:append(Attr2, BelongsToAttrs),
  	Hases = assign_hases(BossRec, SkipRecs0),
  	lists:append(Attr3, Hases).
  
  assign_hases(BossRec, SkipRecs) when is_list(SkipRecs) ->
  	Mod = boss_db:type(BossRec:id()),
  	ModAttr = Mod:module_info(attributes),
  	HasAttrs = lists:flatten(proplists:get_all_values(has, ModAttr)),
  	HasAttrs0 = filter_hases(HasAttrs, SkipRecs),
  	[{element(1, H), assign_hases(BossRec, element(1,H), SkipRecs)} || H <- HasAttrs0].
  
  assign_hases(BossRec, HasName, SkipRecs) when is_atom(HasName) ->
  	Recs = BossRec:HasName(),
  	[to_json(Rec, SkipRecs) || Rec <- Recs].
  
  filter_hases(Hases, SkipRecs) ->
  	filter_hases(Hases, SkipRecs, []).
  
  filter_hases([], _, Acc) ->
  	lists:reverse(Acc);
  
  filter_hases([{Name, _Count} = H| Tail], Skips, Acc) ->
  	case lists:member(Name, Skips) of
  		true ->
  			filter_hases(Tail, Skips, Acc);
  		false ->
  			filter_hases(Tail, Skips, [H | Acc])
  	end;
  
  filter_hases([{Name, _Count, Options} = H | Tail], Skips, Acc) ->
  	NameMem = lists:member(Name, Skips),
  	ModMem = lists:member(proplists:get_value(module, Options), Skips),
  	if
  		NameMem orelse ModMem ->
  			filter_hases(Tail, Skips, Acc);
  		true ->
  			filter_hases(Tail, Skips, [H | Acc])
  	end.
  
  
  assign_belongs(BossRec, SkipRecs) when is_list(SkipRecs) ->
  	Names = BossRec:belongs_to_names(),
  	assign_belongs(Names, BossRec, SkipRecs).
  
  assign_belongs(Names, BossRec, SkipRecs) ->
  	assign_belongs(Names, BossRec, SkipRecs, []).
  
  assign_belongs([], _BossRec, _SkipRecs, Acc) ->
  	lists:reverse(Acc);
  
  assign_belongs([Name | Tail], BossRec, SkipRecs, Acc) ->
  	case BossRec:Name() of
  		{error, Err} ->
  			?info("not encoding ~s due to ~p", [Name, Err]),
  			assign_belongs(Tail, BossRec, Acc);
  		Rec ->
  			Type = boss_db:type(Rec:id()),
  			case lists:member(Type, SkipRecs) of
  				true ->
  					assign_belongs(Tail, BossRec, Acc);
  				false ->
  					Json = to_json(Rec, SkipRecs),
  					assign_belongs(Tail, BossRec, [{Name, Json} | Acc])
  			end
  	end.
  
  correct_types(Attrs, Types) ->
  