nitro/src/nitro.erl

-module(nitro).
%%-author('Maxim Sokhatsky').

-include_lib("nitro/include/cx.hrl").
-include_lib("nitro/include/nitro.hrl").
-include_lib("nitro/include/event.hrl").


-export([atom/1, f/1, f/2, coalesce/1,
  pickle/1, depickle/1, unique_integer/0, temp_id/0,
  to_list/1, to_atom/1, to_binary/1, to_integer/1,
  join/2, replace/3, indexof/2, indexof/3, append/3, os_env/1, os_env/2,
  render/1, wire/1, hex/1, unhex/1, js_escape/1, js_escape/2,
  html_encode/1, html_encode/2, url_encode/1, url_decode/1,
  update/2, insert_top/2, insert_top/3, insert_bottom/2, insert_bottom/3,
  insert_before/2, insert_after/2, insert_adjacent/3, insert_adjacent/4,
  clear/1, remove/1, setAttr/3, style/2, style/3, display/2, show/1, hide/1,
  compact/1, meg/1, num/1
]).


atom(List) when erlang:is_list(List) ->
  string:join([ ?MODULE:to_list(L) || L <- List], "_");
atom(Scalar) -> ?MODULE:to_list(Scalar).


%% Convert and Utils API

f(S) -> f(S, []).

f(S, Args) -> lists:flatten(io_lib:format(S, Args)).


coalesce({_, Y}) -> Y;
coalesce(false) -> undefined;
coalesce([]) -> undefined;
coalesce([H]) -> H;
coalesce([undefined|T]) -> coalesce(T);
coalesce([[]|T]) -> coalesce(T);
coalesce([H|_]) -> H.


%% to_list to_atom to_binary to_integer

-define(IS_STRING(Term),
  (erlang:is_list(Term) andalso Term /= [] andalso erlang:is_integer(hd(Term)))).

to_list(L) when ?IS_STRING(L) -> L;
to_list(L) when erlang:is_list(L) ->
  SubLists = [inner_to_list(X) || X <- L],
  lists:flatten(SubLists);
to_list(A) -> inner_to_list(A).

inner_to_list(A) when erlang:is_atom(A) -> erlang:atom_to_list(A);
inner_to_list(B) when erlang:is_binary(B) -> erlang:binary_to_list(B);
inner_to_list(I) when erlang:is_integer(I) -> erlang:integer_to_list(I);
inner_to_list(L) when erlang:is_tuple(L) -> lists:flatten(io_lib:format("~p", [L]));
inner_to_list(L) when erlang:is_list(L) -> L;
inner_to_list(F) when erlang:is_float(F) -> erlang:float_to_list(F, [{decimals, 9}, compact]).

to_atom(A) when erlang:is_atom(A) -> A;
%%to_atom(B) when erlang:is_binary(B) -> to_atom(erlang:binary_to_list(B));
to_atom(B) when erlang:is_binary(B) -> erlang:binary_to_atom(B);
to_atom(I) when erlang:is_integer(I) -> to_atom(erlang:integer_to_list(I));
to_atom(F) when erlang:is_float(F) -> to_atom(erlang:float_to_list(F, [{decimals, 9}, compact]));
%%to_atom(L) when erlang:is_list(L) -> erlang:list_to_atom(erlang:binary_to_list(erlang:list_to_binary(L))).
to_atom(L) when erlang:is_list(L) -> erlang:list_to_atom(L).

to_binary(A) when erlang:is_atom(A) -> erlang:atom_to_binary(A, latin1);
to_binary(B) when erlang:is_binary(B) -> B;
%%to_binary(I) when erlang:is_integer(I) -> to_binary(erlang:integer_to_list(I));
to_binary(I) when erlang:is_integer(I) -> erlang:integer_to_binary(I);
to_binary(F) when erlang:is_float(F) -> erlang:float_to_binary(F, [{decimals, 9}, compact]);
to_binary(L) when erlang:is_list(L) ->  erlang:iolist_to_binary(L);
to_binary(X) when erlang:is_tuple(X) ->  erlang:term_to_binary(X).

to_integer(A) when erlang:is_atom(A) -> ?MODULE:to_integer(erlang:atom_to_list(A));
to_integer(B) when erlang:is_binary(B) -> ?MODULE:to_integer(erlang:binary_to_list(B));
to_integer(I) when erlang:is_integer(I) -> I;
to_integer([]) -> 0;
to_integer(L) when erlang:is_list(L) -> erlang:list_to_integer(L);
to_integer(F) when erlang:is_float(F) -> erlang:round(F).


%% JOIN
%% join(List, Delimiter)
join([], _) -> [];
join([Item], _Delim) -> [Item];
join([Item|Items], Delim) ->
  [Item, Delim | join(Items, Delim)].


%% replace(String, S1, S2)
replace([], _, _) -> [];
replace(String, S1, S2) when erlang:is_list(String), erlang:is_list(S1), erlang:is_list(S2) ->
  Length = erlang:length(S1),
  case string:substr(String, 1, Length) of
    S1 ->
      S2 ++ replace(string:substr(String, Length + 1), S1, S2);
    _ ->
      [erlang:hd(String) | replace(erlang:tl(String), S1, S2)]
  end.


indexof(Key, Fields) -> indexof(Key, Fields, 2).

indexof(_, [], _) -> undefined;
indexof(Key, [Key|_], N) -> N;
indexof(Key, [_|T], N) -> indexof(Key, T, N + 1).

append(List, Key, Value) ->
  case Value of
    undefined -> List;
    _A -> [{Key, Value}|List]
  end.


os_env(Key) -> os_env(Key, "").

os_env(Key, Default) ->
  case os:getenv(Key) of
    false -> Default;
    V -> V
  end.


-ifndef(PICKLER).
-define(PICKLER, (application:get_env(nitro, pickler, nitro_pickle))).
-endif.

pickle(Data) -> ?PICKLER:pickle(Data).
depickle(SerializedData) -> ?PICKLER:depickle(SerializedData).


render(X) -> wf_render:render(X).


% Wire JavaScript nitro:wire
wire(Actions) -> action_wire:wire(Actions).


unique_integer() -> erlang:unique_integer().
temp_id() -> "auto" ++ erlang:integer_to_list(unique_integer() rem 1000000).


%% Fast HEX

%digit(0) -> $0;
%digit(1) -> $1;
%digit(2) -> $2;
%digit(3) -> $3;
%digit(4) -> $4;
%digit(5) -> $5;
%digit(6) -> $6;
%digit(7) -> $7;
%digit(8) -> $8;
%digit(9) -> $9;
%digit(10) -> $a;
%digit(11) -> $b;
%digit(12) -> $c;
%digit(13) -> $d;
%digit(14) -> $e;
%digit(15) -> $f.
digit(X) when X >= 0 andalso X =< 9 -> X + 48;
digit(X) when X >= 10 andalso X =< 15 -> X + 87.

hex(Bin) ->
  << << (digit(A1)), (digit(A2)) >> || <<A1:4, A2:4>> <= Bin >>.
unhex(Hex) ->
  << << (erlang:list_to_integer([H1, H2], 16)) >> || <<H1, H2>> <= Hex >>.


%% JavaScript escape

js_escape(undefined) -> [];
js_escape(Value) when erlang:is_list(Value) ->
  erlang:binary_to_list( ?MODULE:js_escape( erlang:iolist_to_binary(Value) ) );
js_escape(Value) -> js_escape(Value, <<>>).

js_escape(<<"\\", Rest/binary>>, Acc) -> %"
  js_escape(Rest, <<Acc/binary, "\\\\">>); %"
js_escape(<<"\r", Rest/binary>>, Acc) ->
  js_escape(Rest, <<Acc/binary, "\\r">>);
js_escape(<<"\n", Rest/binary>>, Acc) ->
  js_escape(Rest, <<Acc/binary, "\\n">>);
js_escape(<<"\"", Rest/binary>>, Acc) ->
  js_escape(Rest, <<Acc/binary, "\\\"">>);
js_escape(<<"'", Rest/binary>>, Acc) ->
  js_escape(Rest, <<Acc/binary, "\\'">>);
js_escape(<<"`", Rest/binary>>, Acc) ->
  js_escape(Rest, <<Acc/binary, "\\`">>);
js_escape(<<"<script", Rest/binary>>, Acc) ->
  js_escape(Rest, <<Acc/binary, "<script">>);
js_escape(<<"script>", Rest/binary>>, Acc) ->
  js_escape(Rest, <<Acc/binary, "script>">>);
js_escape(<<C, Rest/binary>>, Acc) ->
  js_escape(Rest, <<Acc/binary, C>>);
js_escape(<<>>, Acc) -> Acc.


%% HTML encode/decode

%% html_encode(B, normal)
html_encode(L, Fun) when erlang:is_function(Fun) ->
  Fun(L);
html_encode(L, EncType) when erlang:is_atom(L) ->
  html_encode(?MODULE:to_list(L), EncType);
html_encode(L, EncType) when erlang:is_integer(L) ->
  html_encode(erlang:integer_to_list(L), EncType);
html_encode(L, EncType) when erlang:is_float(L) ->
  html_encode(erlang:float_to_list(L, [{decimals, 9}, compact]), EncType);
html_encode(L, false) ->
  L;
html_encode(L, true) ->
  L;
html_encode(L, whites) ->
  html_encode_whites(?MODULE:to_list(lists:flatten([L]))).

html_encode(<<>>) ->
  [];
html_encode([]) ->
  [];
html_encode(B) when is_binary(B) ->
  ?MODULE:to_binary(
    html_encode(erlang:binary_to_list(B))
  );
html_encode([$\n |T]) ->
  "<br>" ++ html_encode(T);
html_encode([H|T]) ->
  case H of
    $< -> "&lt;" ++ html_encode(T);
    $> -> "&gt;" ++ html_encode(T);
    $" -> "&quot;" ++ html_encode(T);
    $' -> "&#39;" ++ html_encode(T);
    $& -> "&amp;" ++ html_encode(T);
    $\\ -> "&#92;" ++ html_encode(T);
    BigNum when erlang:is_integer(BigNum) andalso BigNum > 255 ->
      %% Any integers above 255 are converted to their HTML encode equivalent
      %% Example: 7534 gets turned into &#7534;
      [$&, $# | ?MODULE:to_list(BigNum)] ++ ";" ++ html_encode(T);
    Tup when erlang:is_tuple(Tup) ->
      erlang:throw({html_encode, encountered_tuple, Tup});
    _ ->
      [H|html_encode(T)]
  end.

html_encode_whites([]) -> [];
html_encode_whites([H|T]) ->
  case H of
    $\s -> "&nbsp;" ++ html_encode_whites(T);
    $\t -> "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;" ++ html_encode_whites(T);
    $< -> "&lt;" ++ html_encode_whites(T);
    $> -> "&gt;" ++ html_encode_whites(T);
    $" -> "&quot;" ++ html_encode_whites(T);
    $' -> "&#39;" ++ html_encode_whites(T);
    $& -> "&amp;" ++ html_encode_whites(T);
    $\n -> "<br>" ++ html_encode_whites(T);
    $\\ -> "&#92;" ++ html_encode_whites(T);
    _ -> [H|html_encode_whites(T)]
  end.


%% URL encode/decode

-define(PERCENT, 37).  % $\%
-define(FULLSTOP, 46). % $\.
-define(IS_HEX(C), ((C >= $0 andalso C =< $9) orelse
    (C >= $a andalso C =< $f) orelse
    (C >= $A andalso C =< $F))).
-define(QS_SAFE(C), ((C >= $a andalso C =< $z) orelse
    (C >= $A andalso C =< $Z) orelse
    (C >= $0 andalso C =< $9) orelse
    (C =:= ?FULLSTOP orelse C =:= $- orelse
     C =:= $~ orelse C =:= $_))).

url_encode(Atom) when erlang:is_atom(Atom) ->
  url_encode(erlang:atom_to_list(Atom));
url_encode(Int) when erlang:is_integer(Int) ->
  url_encode(erlang:integer_to_list(Int));
url_encode(Bin) when erlang:is_binary(Bin) ->
  url_encode(erlang:binary_to_list(Bin));
url_encode(String) ->
  url_encode(String, []).

url_encode([], Acc) ->
  lists:reverse(Acc);
url_encode([C | Rest], Acc) when ?QS_SAFE(C) ->
  url_encode(Rest, [C | Acc]);
url_encode([$\s | Rest], Acc) ->
  url_encode(Rest, [$+ | Acc]);
url_encode([C | Rest], Acc) ->
  <<Hi:4, Lo:4>> = <<C>>,
  url_encode(Rest, [digit(Lo), digit(Hi), ?PERCENT | Acc]).

url_decode(Binary) when erlang:is_binary(Binary) ->
  url_decode(erlang:binary_to_list(Binary));
url_decode(String) -> url_decode_h(lists:reverse(String)).

unhexdigit(C) when C >= $0, C =< $9 ->
  C - $0;
unhexdigit(C) when C >= $a, C =< $f ->
  C - $a + 10;
unhexdigit(C) when C >= $A, C =< $F ->
  C - $A + 10.

url_decode_h(S) -> url_decode_h(S, []).

url_decode_h([], Acc) -> Acc;
url_decode_h([$+ | Rest], Acc) ->
  url_decode_h(Rest, [$\s | Acc]);
url_decode_h([Lo, Hi, ?PERCENT | Rest], Acc) when ?IS_HEX(Lo), ?IS_HEX(Hi) ->
  url_decode_h(Rest, [(unhexdigit(Lo) bor (unhexdigit(Hi) bsl 4)) | Acc]);
url_decode_h([C | Rest], Acc) -> url_decode_h(Rest, [C | Acc]).


%% Update DOM nitro:update

update(Target, Elements) ->
  nitro:wire(#jq{target = Target, property = outerHTML, right = Elements, format = "`~s`"}).

insert_top(Tag, Target, Elements) ->
  {Render, _Ref, Actions} = render_html(Elements),
  nitro:wire(nitro:f(
    "qi('~s').insertBefore("
    "(function(){var div = qn('~s'); div.innerHTML = `~s`; return div.firstChild; })(),"
    "qi('~s').firstChild);",
    [Target, Tag, Render, Target])),
  nitro:wire(nitro:render(Actions)).


insert_bottom(Tag, Target, Elements) ->
  {Render, _Ref, Actions} = render_html(Elements),
  nitro:wire(nitro:f(
    "(function(){ var div = qn('~s'); div.innerHTML = `~s`;"
    "qi('~s').appendChild(div.firstChild); })();",
    [Tag, Render, Target])),
  nitro:wire(nitro:render(Actions)).


insert_before(Target, Elements) -> insert_adjacent(beforebegin, Target, Elements).
insert_after(Target, Elements) -> insert_adjacent(afterend, Target, Elements).


insert_adjacent(Command, Target, Elements) ->
  insert_adjacent(Command, Target, Elements, "qi").
insert_adjacent(Command, Target, Elements, Q) ->
  {Render, _Ref, Actions} = render_html(Elements),
  nitro:wire(nitro:f("~s('~s').insertAdjacentHTML('~s', `~s`);", [Q, Target, Command, Render])),
  nitro:wire(nitro:render(Actions)).


render_html(Elements) ->
  Pid = erlang:self(),
  Ref = erlang:make_ref(),
  erlang:spawn(fun() ->
    R = nitro:render(Elements),
    Pid ! {R, Ref, erlang:get(actions)}
    end),
  {Render, Ref, Actions} = receive {_, Ref, _} = A -> A end,
  {Render, Ref, Actions}.


insert_top(Target, Elements) when erlang:element(1, Elements) == tr ->
  insert_top(tbody, Target, Elements);
insert_top(Target, Elements) ->
  insert_top('div', Target, Elements).


insert_bottom(Target, Elements) when erlang:element(1, Elements) == tr ->
  insert_bottom(tbody, Target, Elements);
insert_bottom(Target, Elements) ->
  insert_bottom('div', Target, Elements).


clear(Target) ->
  nitro:wire("var x = qi('" ++ ?MODULE:to_list(Target) ++ "');"
             "while(x && x.firstChild) x.removeChild(x.firstChild);").

remove(Target) ->
  nitro:wire("var x = qi('" ++ ?MODULE:to_list(Target) ++ "');"
             "x && x.parentNode.removeChild(x);").


setAttr(Element, Attr, Value) ->
  nitro:wire("{ var x = qi('" ++ ?MODULE:to_list(Element) ++ "');"
             "if(x) x.setAttribute('" ++ ?MODULE:to_list(Attr) ++ "', '" ++ ?MODULE:to_list(Value) ++ "'); }").


style(Element, Style) ->
  setAttr(Element, "style", Style).

style(Element, Style, Value) -> 
  nitro:wire("{ var x = qi('" ++ ?MODULE:to_list(Element) ++ "');"
    "if(x) x.style." ++ ?MODULE:to_list(Style) ++ " = '" ++ ?MODULE:to_list(Value) ++ "'; }").


display(Element, Status) -> style(Element, "display", Status).


show(Element) -> display(Element, block).
hide(Element) -> display(Element, none).


compact([]) -> "[]";
compact("\n") -> "[]";
compact([X|_] = Y) when erlang:is_tuple(X) ->
  [ compact(F) || F <- Y ];
compact(Bin) when erlang:is_binary(Bin) ->
  unicode:characters_to_binary(Bin);
compact(Tuple) when erlang:is_tuple(Tuple) ->
  Min = erlang:min(9, erlang:size(Tuple)),
  Fields = lists:zip(lists:seq(1, Min),
    lists:sublist(erlang:tuple_to_list(Tuple), 1, Min)),
  "{" ++ string:join([ io_lib:format("~s", [compact(F)]) || {_, F} <- Fields ], ",") ++ "}";
compact(T) ->
  ?MODULE:js_escape(?MODULE:to_list(T)).


meg(X) -> erlang:integer_to_list(X div 1000000) ++ "M".

num(S) -> case lists:reverse(S) of
    [$K|K] -> erlang:list_to_integer(lists:reverse(K)) * 1000;
    [$M|M] -> erlang:list_to_integer(lists:reverse(M)) * 1000 * 1000;
    [$G|G] -> erlang:list_to_integer(lists:reverse(G)) * 1000 * 1000 * 1000;
    [$T|T] -> erlang:list_to_integer(lists:reverse(T)) * 1000 * 1000 * 1000 * 1000
  end.