Packages
nova
0.15.1
0.15.1
0.14.3
0.14.1
0.13.7
0.13.1
0.13.0
0.12.1
0.12.0
0.11.0
0.10.4
0.10.3
0.10.2
0.10.1
0.10.0
0.9.24
0.9.23
0.9.22
0.9.21
0.9.20
0.9.19
0.9.18
0.9.17
0.9.16
0.9.15
0.9.11
0.9.5
0.9.4
0.9.3
0.9.2
0.9.1
0.9.0
0.8.6
0.8.5
0.8.4
0.8.3
0.8.2
0.8.1
0.8.0
0.7.2
0.7.1
0.7.0
0.6.2
0.6.1
0.6.0
0.5.2
0.5.1
0.4.4
0.4.3
0.4.2
0.4.1
0.2.2
0.1.0
0.0.1
0.0.0
Nova is a web application framework
Current section
Files
Jump to
Current section
Files
src/nova.erl
%%% @author Niclas Axelsson <niclas@burbas.se>
%%% @doc
%%% Interface module for nova
%%% @end
-module(nova).
-include_lib("kernel/include/logger.hrl").
-export([
get_main_app/0,
get_apps/0,
get_environment/0,
get_env/2,
set_env/2,
use_stacktrace/1,
format_stacktrace/1,
detect_language/0
]).
-type state() :: any().
-export_type([state/0]).
%%--------------------------------------------------------------------
%% @doc
%% Returns the name of the main bw-application (The one that started
%% everything)
%%
%% @end
%%--------------------------------------------------------------------
-spec get_main_app() -> {ok, Application :: atom()} | undefined.
get_main_app() ->
application:get_env(nova, bootstrap_application).
%%--------------------------------------------------------------------
%% @doc
%% Returns a proplist with all nova applications and their prefix. This
%% function is useful when calulating dynamic routes.
%%
%% @end
%%--------------------------------------------------------------------
-spec get_apps() -> [{App :: atom(), Prefix :: list()}].
get_apps() ->
nova_router:compiled_apps().
%%--------------------------------------------------------------------
%% @doc
%% Returns which environment nova is started in. This fetches the
%% environment-variable in sys.config for Nova and returns the value found.
%% Defaults to: dev
%%
%% @end
%%--------------------------------------------------------------------
-spec get_environment() -> any().
get_environment() ->
application:get_env(nova, environment, dev).
%%--------------------------------------------------------------------
%% @doc
%% Works as the regular application:get_env/3 but instead of giving
%% a specific application we target the application that started
%% nova.
%%
%% @end
%%--------------------------------------------------------------------
-spec get_env(Parameter :: atom(), Default :: any()) -> term() | undefined.
get_env(Parameter, Default) ->
case get_main_app() of
{ok, App} ->
application:get_env(App, Parameter, Default);
_ ->
Default
end.
%%--------------------------------------------------------------------
%% @doc
%% Sets an environment variable for the main application.
%%
%% @end
%%--------------------------------------------------------------------
-spec set_env(Key :: atom(), Value :: any()) -> ok | {error, main_app_not_found}.
set_env(Key, Value) ->
case get_main_app() of
{ok, App} ->
application:set_env(App, Key, Value);
_ ->
{error, main_app_not_found}
end.
%%--------------------------------------------------------------------
%% @doc
%% Enables or disables stacktraces. This is a global setting and
%% affects all requests. If stacktraces are enabled, nova will
%% try to print a stacktrace when an exception is thrown.
%% @end
%%--------------------------------------------------------------------
-spec use_stacktrace(Enable :: boolean()) -> ok.
use_stacktrace(true) ->
persistent_term:put(nova_use_stacktrace, true);
use_stacktrace(_) ->
persistent_term:erase(nova_use_stacktrace).
%%--------------------------------------------------------------------
%% @doc
%% Formats a stacktrace into a list of maps. Each map contains
%% the module, function, arity, file, and line number of the
%% function call.
%% @end
-spec format_stacktrace(Stacktrace :: [{M :: atom(), F :: atom(), A :: integer(), Info :: list()}])
-> [map()].
format_stacktrace(Stacktrace) ->
SingleFun = fun({M, F, A, Info}) ->
#{module => M,
function => F,
arity => A,
file => proplists:get_value(file, Info, <<"unknown">>),
line => proplists:get_value(line, Info, -1)}
end,
[SingleFun(S) || S <- Stacktrace].
%%--------------------------------------------------------------------
%% @doc
%% Detects the language Nova is running in. It checks for the presence
%% of the Elixir and LFE modules, and returns the language.
%% @end
%%--------------------------------------------------------------------
-spec detect_language() -> elixir | lfe | erlang.
detect_language() ->
case {code:which('Elixir.System'), code:which(lfe_eval)} of
{non_existing, non_existing} -> erlang;
{_, non_existing} -> elixir;
{non_existing, _} -> lfe;
{_, _} -> elixir % prefer Elixir if both are present
end.