ANSI escape codes in Erlang — io:format, \e, cf, OTP logger

%% Erlang accepts FOUR ESC forms in "..." literals.
%% All compile to the same single byte (0x1b = 27).
%%
%%   "\e"     — named ESC escape (most readable)
%%   "\033"   — \NNN is OCTAL (same as C — \033 = decimal 27)
%%   "\x1b"   — hex (exactly 2 digits)
%%   "\^["    — caret-notation control character (^A..^Z map
%%              to ASCII 1..26; ^[ maps to ASCII 27 = ESC)
%%
%% Erlang follows C's octal convention (unlike Nim and OCaml
%% which use decimal). When porting from C, "\033" works
%% unchanged. When porting from Nim/OCaml, "\27" silently
%% mis-compiles to the wrong byte — use "\e" or "\x1b".

-module(ansi_demo).
-export([main/0]).

main() ->
    io:format("\e[1;31merror:\e[0m permission denied~n"),
    io:format("\033[33mwarn:\033[0m deprecated flag~n"),
    io:format("\x1b[32mok:\x1b[0m 142 tests passed~n"),
    io:format("\^[[36minfo:\^[[0m skipping cache~n"),

    %% Truecolor — 38;2;R;G;B
    io:format("\e[38;2;255;128;0morange truecolor\e[0m~n"),

    %% 256-palette — 38;5;n
    io:format("\e[38;5;196mbright red\e[0m~n"),

    %% String interpolation via ~s — passes the list through:
    Msg = "permission denied",
    io:format("\e[1;31merror:\e[0m ~s~n", [Msg]),

    %% io_lib:format returns the formatted charlist
    %% instead of writing — handy for building log lines:
    Line = io_lib:format("\e[32mok:\e[0m ~B tests passed~n", [142]),
    io:put_chars(Line).

%% Reusable helper — pure Erlang:
esc(Sgr, Text) ->
    io_lib:format("\e[~sm~s\e[0m", [Sgr, Text]).

%% rebar.config:
%%   {deps, [{cf, "0.3.1"}]}.
%%
%% Then `rebar3 compile` and use:

-module(cf_demo).
-export([main/0]).

main() ->
    %% cf:format extends ~ directives with colour:
    %%   ~!r — red    ~!g — green   ~!b — blue
    %%   ~!y — yellow ~!m — magenta ~!c — cyan
    %%   ~!w — white  ~!_ — bold    ~!! — reset
    cf:print("~!rerror:~!! permission denied~n"),
    cf:print("~!gok:~!! 142 tests passed~n"),
    cf:print("~!yawarn:~!! deprecated flag~n"),

    %% Capital letter = background:
    cf:print("~!_~!Y ~!K~!RCAUTION~!! brakes wet~n"),
    %% ~!_ = bold start; ~!Y = bg yellow; ~!K = fg black; ~!R = fg red

    %% Combine with regular io:format directives:
    Port = 8080,
    cf:print("~!c[INFO]~!! started on port ~p~n", [Port]),

    Tests = 142, Failed = 3,
    cf:print(
        "~!grun:~!! ~B tests, ~!r~B failed~!!~n",
        [Tests, Failed]
    ),

    %% cf:format/1,2 returns the formatted iolist
    %% (use cf:print/1,2 to write to standard_io):
    Line = cf:format("~!_~!cFATAL~!!: ~s~n", ["server crashed"]),
    io:put_chars(Line),

    %% Auto-disables when stdout is not a TTY — try:
    %%   rebar3 shell --script script.escript | cat
    %% cf detects via io:rows() and emits plain text when
    %% the call returns {error, enotsup}.
    ok.

%% OTP 21+ stdlib — no dependency needed.
%% sys.config (or application:set_env at boot):
%%
%%   [{kernel, [
%%       {logger_level, info},
%%       {logger, [
%%           {handler, default, logger_std_h,
%%               #{config => #{type => standard_io},
%%                 formatter => {logger_formatter,
%%                     #{template =>
%%                         [time, " [", level, "] ",
%%                          msg, "\n"],
%%                       single_line => true,
%%                       legacy_header => false}}}}
%%       ]}
%%   ]}].

-module(logger_demo).
-export([main/0]).

main() ->
    %% Plain structured logging — coloured level prefix
    %% on TTY, plain text on redirect, JSON if you swap
    %% the formatter for logger_logstash_formatter:
    logger:debug("trace: entering handler"),
    logger:info("started on port ~p", [8080]),
    logger:warning("slow query: ~p ms", [1240]),
    logger:error("auth failed for user ~p", [42]),

    %% Structured form with a metadata map:
    logger:info("request received",
                #{method => "GET", path => "/users/42"}),

    %% Per-module level — set at runtime:
    logger:set_module_level(?MODULE, debug),
    logger:debug("now visible after set_module_level"),

    %% Per-handler config — change formatting / destination
    %% without touching call sites:
    logger:update_handler_config(default, #{
        formatter => {logger_formatter,
            #{template => [time, " ", level, ": ", msg, "\n"],
              single_line => true}}
    }),

    ok.

%% Capability gating in Erlang:
%%   io:rows()             — {ok, Rows} when TTY,
%%                           {error, enotsup} when redirected
%%   os:getenv("NO_COLOR") — universal opt-out env var
%%   os:type()             — {unix, _} | {win32, _}
%%
%% OTP RELEASE-MODE CAVEAT (page's primary SERP differentiator):
%% Every Erlang process has a group_leader handling its I/O.
%% In a shell or escript, group_leader IS the user's terminal —
%% ANSI passes through. In an OTP release run as a daemon
%% (rebar3 release → bin/myapp daemon), group_leader is
%% reassigned to a logger process writing to log/erlang.log.N,
%% and ANSI bytes appear LITERALLY in the log file as
%% "\e[31m...". The fix: use the OTP logger module with a
%% coloured handler (auto-strips ANSI when not on a TTY), or
%% gate your io:format colour calls explicitly.

-module(cap_demo).
-export([ansi_capable/0, styled/2, main/0]).

ansi_capable() ->
    case os:getenv("NO_COLOR") of
        false ->
            case os:getenv("FORCE_COLOR") of
                false ->
                    %% io:rows() returns {ok, _} only on TTY:
                    case io:rows() of
                        {ok, _}     -> true;
                        {error, _}  -> false
                    end;
                _ -> true
            end;
        _ -> false
    end.

styled(Text, Sgr) ->
    case ansi_capable() of
        true  -> io_lib:format("\e[~sm~s\e[0m", [Sgr, Text]);
        false -> Text
    end.

main() ->
    %% Plain io:format with embedded ANSI works fine
    %% from the shell. In a release daemon, those bytes
    %% would land literally in log/erlang.log.N.
    io:format("~s~n", [styled("OK",   "32")]),
    io:format("~s~n", [styled("FAIL", "1;31")]),

    %% Detect release-mode group_leader explicitly:
    GL = group_leader(),
    case erlang:process_info(GL, registered_name) of
        {registered_name, logger_std_h_default} ->
            io:format("(running under release logger — "
                      "colour calls would land in log file)~n");
        _ ->
            io:format("(running under shell group_leader — "
                      "colour passes through to terminal)~n")
    end,

    %% Force-emit via 'standard_error' which retains the
    %% terminal even under some release configurations:
    io:format(standard_error, "~s ~s~n",
              [styled("DEBUG", "36"), "checkpoint hit"]).