anchor.diff:    StdErr     = filename:join([LogDir, "beehive.err"]),
   
     lists:flatten([
  -    build_env({name, App#app.name}),
  -    build_env({repos, App#app.url}),
  -    build_env({revision, App#app.revision}),
  -    build_env({path, BeehivePath}),
  -    build_env({branch, App#app.branch}),
  -    {stdout, StdOut},
  -    {stderr, StdErr},
  -    OtherEnvs
  -  ]).
  +                 build_env({name, App#app.name}),
  +                 build_env({repos, App#app.url}),
  +                 build_env({revision, App#app.revision}),
  +                 build_env({path, BeehivePath}),
  +                 build_env({branch, App#app.branch}),
  +                 {stdout, StdOut},
  +                 {stderr, StdErr},
  +                 OtherEnvs
  +                ]).
   
   build_env({Key, Value}) ->
     RealValue = case Value of
  -    undefined -> "undefined";
  -    _ -> Value
  -  end,
  +                undefined -> "undefined";
  +                _ -> Value
  +              end,
     T = lists:flatten([
  -    string:to_upper(erlang:atom_to_list(Key)),
  -    "=",RealValue,""
  -  ]),
  +                     string:to_upper(erlang:atom_to_list(Key)),
  +                     "=",RealValue,""
  +                    ]),
     {env, T}.
   
  -% If erlang had 'meta-programming,' we wouldn't have to do all this work to validate the proplists
  +%% If erlang had 'meta-programming,' we wouldn't have to do all this work to validate the proplists
   from_proplists(Proplists) -> from_proplists(Proplists, #app{}).
   from_proplists([], App)  -> App;
   from_proplists([{name, V}|Rest], App) -> from_proplists(Rest, App#app{name = V});
  
positive.code: -include ("beehive.hrl").
  -include ("common.hrl").
  
  % DATABASE STUFF
  -export ([
    create/1,
    read/1,
    save/1,
    update/2,
    delete/1,
    find_by_name/1,
    find_all_by_name/1,
    exist/1,
    all/0
  ]).
  
  -export ([
    new/1,
    update_by_name/1,
    restart_by_name/1,
    expand_by_name/1
  ]).
  
  % APPLICATION STUFF
  -export ([
    to_proplist/1,
    build_app_env/2
  ]).
  
  -define (DB, beehive_db_srv).
  
  
negative.code:     _ ->  []
    end.
  
  %% APPLICATION STUFF
  update_by_name(Name) ->
    case find_by_name(Name) of
      not_found -> {error, "Cannot find app to update"};
      App ->
        %% Should this be synchronous or asynchronous?
        NewApp = App#app{updated_at = date_util:now_to_seconds(), latest_error = undefined, revision = undefined},
        ?NOTIFY({app, updated, NewApp}),
        {ok, save(NewApp)}
  