pharpend/fewd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: pharpend:develop
Branches Tags
pharpend:master
pharpend:f-qrdemo
pharpend:develop
pharpend:staging
pharpend:0.1.0
..
compare: pharpend:master
Branches Tags
pharpend:f-qrdemo
pharpend:develop
pharpend:staging
pharpend:master
pharpend:0.1.0

No commits in common. "develop" and "master" have entirely different histories.
develop ... master

38 changed files with 1667 additions and 218 deletions
Show Stats Expand all files Collapse all files

7
NOTES.txt
View File

@ -1,10 +1,3 @@
OPEN LOOPS - 2025-11-12
- websockets
- separate websocket handling from websocket parsing/sending
- do renaming
- make wfc not terrible
VIDEO 1 - 2025-09-16 VIDEO 1 - 2025-09-16
TODONE TODONE
- add qhl as dep - add qhl as dep

11
ebin/fewd.app
View File

@ -3,12 +3,7 @@
{registered,[]}, {registered,[]},
{included_applications,[]}, {included_applications,[]},
{applications,[stdlib,kernel]}, {applications,[stdlib,kernel]},
{vsn,"0.2.0"}, {vsn,"0.1.0"},
{modules,[fd_httpd,fd_httpd_client,fd_httpd_client_man, {modules,[fd_client,fd_client_man,fd_client_sup,fd_clients,
fd_httpd_client_sup,fd_httpd_clients,fd_httpd_sfc, fd_sup,fewd]},
fd_httpd_sfc_cache,fd_httpd_sfc_entry,fd_httpd_utils,
fd_sup,fd_wfcd,fd_wfcd_cache,fewd,qhl,qhl_ws,wfc,
wfc_bm,wfc_eval,wfc_eval_context,wfc_ltr,wfc_pp,
wfc_read,wfc_sentence,wfc_sftt,wfc_ttfuns,wfc_utils,
wfc_word,zj]},
{mod,{fewd,[]}}]}. {mod,{fewd,[]}}]}.

106
priv/static/chat.html Normal file
View File

@ -0,0 +1,106 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Chat with Websockets</title>
<link rel="stylesheet" href="/css/default.css">
</head>
<body>
<div id="titlebar">
<div class="content">
<a href="/" class="tb-home">Home</a>
</div>
</div>
<div class="content">
<h1 class="content-title">Chat with websockets</h1>
<div class="content-body">
<input autofocus label="Nick" id="nick"></input>
<textarea hidden disabled id="wfc-output"></textarea>
<input hidden id="wfc-input"></input>
</div>
</div>
<script>
let nelt = document.getElementById('nick');
let ielt = document.getElementById('wfc-input');
let oelt = document.getElementById('wfc-output');
let ws = new WebSocket("/ws/chat");
let nick = '';
// when user hits any key while typing in nick
function on_nick(evt) {
if (evt.key === 'Enter') {
// don't do default thing
evt.preventDefault();
// grab contents
let contents = nelt.value;
let trimmed = contents.trim();
// if contents are nonempty
let nonempty_contents = trimmed.length > 0;
if (nonempty_contents) {
nick = trimmed;
let msg_obj = ['nick', nick];
let msg_str = JSON.stringify(msg_obj);
console.log('message to server:', contents.trim());
// query backend for result
ws.send(msg_str);
// delete element from dom
nelt.remove();
oelt.hidden = false;
ielt.hidden = false;
ielt.autofocus = true;
}
}
}
// when user hits any key while typing in ielt
function on_input_key(evt) {
if (evt.key === 'Enter') {
// don't do default thing
evt.preventDefault();
// grab contents
let contents = ielt.value;
let trimmed = contents.trim();
// if contents are nonempty
let nonempty_contents = trimmed.length > 0;
if (nonempty_contents) {
let msg_obj = ['chat', trimmed];
let msg_str = JSON.stringify(msg_obj);
console.log('message to server:', contents.trim());
// query backend for result
ws.send(msg_str);
// clear input
ielt.value = '';
// add to output
oelt.value += '> ';
oelt.value += trimmed;
oelt.value += '\n';
}
}
}
function main() {
nelt.addEventListener('keydown', on_nick);
ielt.addEventListener('keydown', on_input_key);
ws.onmessage =
function (msg_evt) {
console.log('message from server:', msg_evt);
let msg_str = msg_evt.data;
let msg_obj = JSON.parse(msg_str);
oelt.value += msg_obj.nick;
oelt.value += '> ';
oelt.value += msg_obj.msg;
oelt.value += '\n';
};
}
main();
</script>
</body>
</html>

2
priv/static/index.html
View File

@ -16,7 +16,9 @@
<h1 class="content-title">FEWD: index</h1> <h1 class="content-title">FEWD: index</h1>
<ul> <ul>
<li><a href="/chat.html">Chatroom</a></li>
<li><a href="/echo.html">Echo</a></li> <li><a href="/echo.html">Echo</a></li>
<li><a href="/tetris.html">Tetris</a></li>
<li><a href="/wfc.html">WFC</a></li> <li><a href="/wfc.html">WFC</a></li>
</ul> </ul>
</div> </div>

24
priv/static/tetris.html Normal file
View File

@ -0,0 +1,24 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Tetris with Websockets</title>
<link rel="stylesheet" href="/css/default.css">
<link rel="stylesheet" href="/css/tetris.css">
</head>
<body>
<div id="titlebar">
<div class="content">
<a href="/" class="tb-home">Home</a>
</div>
</div>
<div class="content">
<h1 class="content-title">Tetris</h1>
<textarea id="tetris-state"></textarea>
</div>
<script type="module" src="./js/dist/tetris.js"></script>
</body>
</html>

105
src/et_piece.erl Normal file
View File

@ -0,0 +1,105 @@
-module(et_piece).
-vsn("1.0.4").
-author("Craig Everett <zxq9@zxq9.com>").
-copyright("Craig Everett <zxq9@zxq9.com>").
-license("MIT").
-export([rand/0, new/1, flip/2, points/2, points/1, type/1, sides/1]).
-export_type([data/0]).
-record(p,
{flip = 1 :: 1..4,
type = i :: erltris:type()}).
-opaque data() :: #p{}.
rand() ->
case rand:uniform(7) of
1 -> new(i);
2 -> new(o);
3 -> new(t);
4 -> new(s);
5 -> new(z);
6 -> new(j);
7 -> new(l)
end.
new(T) -> #p{type = T}.
flip(r, Piece = #p{flip = 4}) -> Piece#p{flip = 1};
flip(r, Piece = #p{flip = F}) -> Piece#p{flip = F + 1};
flip(l, Piece = #p{flip = 1}) -> Piece#p{flip = 4};
flip(l, Piece = #p{flip = F}) -> Piece#p{flip = F - 1}.
points(Piece, {LX, LY}) ->
Offsets = points(Piece),
Translate = fun({OX, OY}) -> {LX + OX, LY + OY} end,
lists:map(Translate, Offsets).
points(#p{flip = F, type = T}) ->
offset(T, F).
offset(i, 1) -> [{0, 2}, {1, 2}, {2, 2}, {3, 2}];
offset(i, 2) -> [{2, 3}, {2, 2}, {2, 1}, {2, 0}];
offset(i, 3) -> [{0, 1}, {1, 1}, {2, 1}, {3, 1}];
offset(i, 4) -> [{1, 3}, {1, 2}, {1, 1}, {1, 0}];
offset(o, _) -> [{1, 1}, {1, 2}, {2, 1}, {2, 2}];
offset(t, 1) -> [{0, 1}, {1, 1}, {2, 1}, {1, 2}];
offset(t, 2) -> [{1, 2}, {1, 1}, {1, 0}, {2, 1}];
offset(t, 3) -> [{0, 1}, {1, 1}, {2, 1}, {1, 0}];
offset(t, 4) -> [{1, 2}, {1, 1}, {1, 0}, {0, 1}];
offset(s, 1) -> [{0, 1}, {1, 1}, {1, 2}, {2, 2}];
offset(s, 2) -> [{1, 2}, {1, 1}, {2, 1}, {2, 0}];
offset(s, 3) -> [{0, 0}, {1, 0}, {1, 1}, {2, 1}];
offset(s, 4) -> [{0, 2}, {0, 1}, {1, 1}, {1, 0}];
offset(z, 1) -> [{0, 2}, {1, 2}, {1, 1}, {2, 1}];
offset(z, 2) -> [{1, 0}, {1, 1}, {2, 1}, {2, 2}];
offset(z, 3) -> [{0, 1}, {1, 1}, {1, 0}, {2, 0}];
offset(z, 4) -> [{0, 0}, {0, 1}, {1, 1}, {1, 2}];
offset(j, 1) -> [{0, 2}, {0, 1}, {1, 1}, {2, 1}];
offset(j, 2) -> [{1, 0}, {1, 1}, {1, 2}, {2, 2}];
offset(j, 3) -> [{0, 1}, {1, 1}, {2, 1}, {2, 0}];
offset(j, 4) -> [{0, 0}, {1, 0}, {1, 1}, {1, 2}];
offset(l, 1) -> [{0, 1}, {1, 1}, {2, 1}, {2, 2}];
offset(l, 2) -> [{1, 2}, {1, 1}, {1, 0}, {2, 0}];
offset(l, 3) -> [{0, 0}, {0, 1}, {1, 1}, {2, 1}];
offset(l, 4) -> [{0, 2}, {1, 2}, {1, 1}, {1, 0}].
type(#p{type = T}) -> T.
sides(#p{type = T, flip = F}) ->
sides(T, F).
sides(i, 1) -> {0, 3, 2};
sides(i, 2) -> {2, 2, 3};
sides(i, 3) -> {0, 3, 1};
sides(i, 4) -> {1, 1, 3};
sides(o, _) -> {1, 2, 2};
sides(t, 1) -> {0, 2, 2};
sides(t, 2) -> {1, 2, 2};
sides(t, 3) -> {0, 2, 1};
sides(t, 4) -> {0, 1, 2};
sides(s, 1) -> {0, 2, 2};
sides(s, 2) -> {1, 2, 2};
sides(s, 3) -> {0, 2, 1};
sides(s, 4) -> {0, 1, 2};
sides(z, 1) -> {0 ,2, 2};
sides(z, 2) -> {1, 2, 2};
sides(z, 3) -> {0 ,2, 1};
sides(z, 4) -> {0, 1, 2};
sides(j, 1) -> {0, 2, 2};
sides(j, 2) -> {1, 2, 2};
sides(j, 3) -> {0, 2, 1};
sides(j, 4) -> {0, 1, 2};
sides(l, 1) -> {0, 2, 2};
sides(l, 2) -> {1, 2, 2};
sides(l, 3) -> {0, 2, 1};
sides(l, 4) -> {0, 1, 2}.

79
src/et_well.erl Normal file
View File

@ -0,0 +1,79 @@
-module(et_well).
-vsn("1.0.4").
-author("Craig Everett <zxq9@zxq9.com>").
-copyright("Craig Everett <zxq9@zxq9.com>").
-license("MIT").
-export([new/0, new/2,
dimensions/1, height/1, width/1,
fetch/3, store/4, complete/1, collapse/2]).
-export_type([playfield/0]).
-opaque playfield() :: tuple().
new() ->
new(10, 20).
new(W, H) ->
erlang:make_tuple(H, row(W)).
row(W) ->
erlang:make_tuple(W, x).
dimensions(Well) ->
H = size(Well),
W = size(element(1, Well)),
{W, H}.
height(Well) ->
size(Well).
width(Well) ->
size(element(1, Well)).
fetch(Well, X, Y) ->
element(X, element(Y, Well)).
store(Well, Value, X, Y) ->
setelement(Y, Well, setelement(X, element(Y, Well), Value)).
complete(Well) ->
{W, H} = dimensions(Well),
complete(H, W, Well, []).
complete(Y, W, Well, Lines) when Y >= 1 ->
case line_complete(W, element(Y, Well)) of
true -> complete(Y - 1, W, Well, [Y | Lines]);
false -> complete(Y - 1, W, Well, Lines)
end;
complete(_, _, _, Lines) ->
Lines.
line_complete(X, Line) when X >= 1 ->
case element(X, Line) of
x -> false;
_ -> line_complete(X - 1, Line)
end;
line_complete(_, _) ->
true.
collapse(Well, Lines) ->
Blank = row(width(Well)),
Crunch =
fun(L, {W, Count}) ->
Crunched = erlang:insert_element(1, erlang:delete_element(L, W), Blank),
{Crunched, Count + 1}
end,
lists:foldl(Crunch, {Well, 0}, Lines).

3
src/fd_wfcd_cache.erl → src/fd_cache.erl
View File

@ -1,6 +1,5 @@
% @doc storing map #{cookie := Context} % @doc storing map #{cookie := Context}
-module(fd_wfcd_cache). -module(fd_cache).
-vsn("0.2.0").
-behavior(gen_server). -behavior(gen_server).

262
src/fd_chat.erl Normal file
View File

@ -0,0 +1,262 @@
% @doc
% controller for chat
-module(fd_chat).
-vsn("0.1.0").
-behavior(gen_server).
-author("Peter Harpending <peterharpending@qpq.swiss>").
-copyright("Peter Harpending <peterharpending@qpq.swiss>").
-license("BSD-2-Clause-FreeBSD").
-export([
join/1,
relay/1,
nick_available/1
]).
-export([start_link/0]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
code_change/3, terminate/2]).
-include("$zx_include/zx_logger.hrl").
-record(o, {pid :: pid(),
nick :: string()}).
-type orator() :: #o{}.
-record(s, {orators = [] :: [orator()]}).
-type state() :: #s{}.
%%% Service Interface
-spec join(Nick) -> Result
when Nick :: string(),
Result :: ok
| {error, Reason :: any()}.
join(Nick) ->
gen_server:call(?MODULE, {join, Nick}).
-spec nick_available(Nick) -> Result
when Nick :: string(),
Result :: boolean().
nick_available(Nick) ->
gen_server:call(?MODULE, {nick_available, Nick}).
-spec relay(Message) -> ok
when Message :: string().
relay(Message) ->
gen_server:cast(?MODULE, {relay, self(), Message}).
%%% Startup Functions
-spec start_link() -> Result
when Result :: {ok, pid()}
| {error, Reason :: term()}.
%% @private
%% This should only ever be called by fd_chat_orators (the service-level supervisor).
start_link() ->
gen_server:start_link({local, ?MODULE}, ?MODULE, none, []).
-spec init(none) -> {ok, state()}.
%% @private
%% Called by the supervisor process to give the process a chance to perform any
%% preparatory work necessary for proper function.
init(none) ->
ok = tell("~p Starting.", [?MODULE]),
State = #s{},
{ok, State}.
%%% gen_server Message Handling Callbacks
-spec handle_call(Message, From, State) -> Result
when Message :: term(),
From :: {pid(), reference()},
State :: state(),
Result :: {reply, Response, NewState}
| {noreply, State},
Response :: term(),
NewState :: state().
%% @private
%% The gen_server:handle_call/3 callback.
%% See: http://erlang.org/doc/man/gen_server.html#Module:handle_call-3
handle_call({join, Nick}, {Pid, _}, State) ->
{Reply, NewState} = do_join(Pid, Nick, State),
{reply, Reply, NewState};
handle_call({nick_available, Nick}, _, State = #s{orators = Orators}) ->
Reply = is_nick_available(Nick, Orators),
{reply, Reply, State};
handle_call(Unexpected, From, State) ->
ok = tell("~p Unexpected call from ~tp: ~tp~n", [?MODULE, From, Unexpected]),
{noreply, State}.
-spec handle_cast(Message, State) -> {noreply, NewState}
when Message :: term(),
State :: state(),
NewState :: state().
%% @private
%% The gen_server:handle_cast/2 callback.
%% See: http://erlang.org/doc/man/gen_server.html#Module:handle_cast-2
handle_cast({relay, From, Message}, State = #s{orators = Orators}) ->
do_relay(From, Message, Orators),
{noreply, State};
handle_cast(Unexpected, State) ->
ok = tell("~p Unexpected cast: ~tp~n", [?MODULE, Unexpected]),
{noreply, State}.
-spec handle_info(Message, State) -> {noreply, NewState}
when Message :: term(),
State :: state(),
NewState :: state().
%% @private
%% The gen_server:handle_info/2 callback.
%% See: http://erlang.org/doc/man/gen_server.html#Module:handle_info-2
handle_info(Msg = {'DOWN', _Mon, process, _Pid, _Reason}, State) ->
NewState = handle_down(Msg, State),
{noreply, NewState};
handle_info(Unexpected, State) ->
ok = tell("~p Unexpected info: ~tp~n", [?MODULE, Unexpected]),
{noreply, State}.
%%% OTP Service Functions
-spec code_change(OldVersion, State, Extra) -> Result
when OldVersion :: {down, Version} | Version,
Version :: term(),
State :: state(),
Extra :: term(),
Result :: {ok, NewState}
| {error, Reason :: term()},
NewState :: state().
%% @private
%% The gen_server:code_change/3 callback.
%% See: http://erlang.org/doc/man/gen_server.html#Module:code_change-3
code_change(_, State, _) ->
{ok, State}.
-spec terminate(Reason, State) -> no_return()
when Reason :: normal
| shutdown
| {shutdown, term()}
| term(),
State :: state().
%% @private
%% The gen_server:terminate/2 callback.
%% See: http://erlang.org/doc/man/gen_server.html#Module:terminate-2
terminate(_, _) ->
ok.
%%% internals
-spec do_join(Pid, Nick, State) -> {Reply, NewState}
when Pid :: pid(),
Nick :: string(),
Reply :: ok | {error, Reason :: any()},
NewState :: State.
do_join(Pid, Nick, State = #s{orators = Orators}) ->
case ensure_can_join(Pid, Nick, Orators) of
ok -> do_join2(Pid, Nick, State);
Error -> {Error, State}
end.
do_join2(Pid, Nick, State = #s{orators = Orators}) ->
_Monitor = erlang:monitor(process, Pid),
NewOrator = #o{pid = Pid, nick = Nick},
NewOrators = [NewOrator | Orators],
NewState = State#s{orators = NewOrators},
{ok, NewState}.
-spec ensure_can_join(Pid, Nick, Orators) -> Result
when Pid :: pid(),
Nick :: string(),
Orators :: [orator()],
Result :: ok
| {error, Reason},
Reason :: any().
% @private
% ensures both Pid and Nick are unique
ensure_can_join(Pid, _ , [#o{pid = Pid} | _ ]) -> {error, already_joined};
ensure_can_join(_ , Nick, [#o{nick = Nick} | _ ]) -> {error, {nick_taken, Nick}};
ensure_can_join(Pid, Nick, [_ | Rest]) -> ensure_can_join(Pid, Nick, Rest);
ensure_can_join(_ , _ , [] ) -> ok.
-spec is_nick_available(Nick, Orators) -> boolean()
when Nick :: string(),
Orators :: [orator()].
is_nick_available(Nick, [#o{nick = Nick} | _ ]) -> false;
is_nick_available(Nick, [_ | Rest]) -> is_nick_available(Nick, Rest);
is_nick_available(_ , [] ) -> true.
-spec handle_down(Msg, State) -> NewState
when Msg :: {'DOWN', Mon, process, Pid, Reason},
Mon :: erlang:monitor(),
Pid :: pid(),
Reason :: any(),
State :: state(),
NewState :: State.
handle_down(Msg = {'DOWN', _, process, Pid, _}, State = #s{orators = Orators}) ->
NewOrators = hdn(Msg, Pid, Orators, []),
NewState = State#s{orators = NewOrators},
NewState.
% encountered item, removing
hdn(_, Pid, [#o{pid = Pid} | Rest], Acc) -> Rest ++ Acc;
hdn(Msg, Pid, [Skip | Rest], Acc) -> hdn(Msg, Pid, Rest, [Skip | Acc]);
hdn(Msg, _, [] , Acc) ->
log("~tp: Unexpected message: ~tp", [?MODULE, Msg]),
Acc.
do_relay(Pid, Message, Orators) ->
case lists:keyfind(Pid, #o.pid, Orators) of
#o{nick = Nick} ->
do_relay2(Nick, Message, Orators);
false ->
tell("~tp: Message received from outsider ~tp: ~tp", [?MODULE, Pid, Message]),
error
end.
% skip
do_relay2(Nick, Msg, [#o{nick = Nick} | Rest]) ->
do_relay2(Nick, Msg, Rest);
do_relay2(Nick, Msg, [#o{pid = Pid} | Rest]) ->
Pid ! {chat, {relay, Nick, Msg}},
do_relay2(Nick, Msg, Rest);
do_relay2(_, _, []) ->
ok.

158
src/fd_httpd_client.erl → src/fd_client.erl
View File

@ -13,8 +13,8 @@
%%% http://erlang.org/doc/design_principles/spec_proc.html %%% http://erlang.org/doc/design_principles/spec_proc.html
%%% @end %%% @end
-module(fd_httpd_client). -module(fd_client).
-vsn("0.2.0"). -vsn("0.1.0").
-author("Peter Harpending <peterharpending@qpq.swiss>"). -author("Peter Harpending <peterharpending@qpq.swiss>").
-copyright("Peter Harpending <peterharpending@qpq.swiss>"). -copyright("Peter Harpending <peterharpending@qpq.swiss>").
-license("BSD-2-Clause-FreeBSD"). -license("BSD-2-Clause-FreeBSD").
@ -52,11 +52,11 @@
| {shutdown, term()} | {shutdown, term()}
| term(). | term().
%% @private %% @private
%% How the fd_httpd_client_man or a prior fd_httpd_client kicks things off. %% How the fd_client_man or a prior fd_client kicks things off.
%% This is called in the context of fd_httpd_client_man or the prior fd_httpd_client. %% This is called in the context of fd_client_man or the prior fd_client.
start(ListenSocket) -> start(ListenSocket) ->
fd_httpd_client_sup:start_acceptor(ListenSocket). fd_client_sup:start_acceptor(ListenSocket).
-spec start_link(ListenSocket) -> Result -spec start_link(ListenSocket) -> Result
@ -67,7 +67,7 @@ start(ListenSocket) ->
| {shutdown, term()} | {shutdown, term()}
| term(). | term().
%% @private %% @private
%% This is called by the fd_httpd_client_sup. While start/1 is called to iniate a startup %% This is called by the fd_client_sup. While start/1 is called to iniate a startup
%% (essentially requesting a new worker be started by the supervisor), this is %% (essentially requesting a new worker be started by the supervisor), this is
%% actually called in the context of the supervisor. %% actually called in the context of the supervisor.
@ -86,7 +86,7 @@ start_link(ListenSocket) ->
%% call to listen/3. %% call to listen/3.
init(Parent, ListenSocket) -> init(Parent, ListenSocket) ->
ok = tell("~p Listening.~n", [self()]), ok = io:format("~p Listening.~n", [self()]),
Debug = sys:debug_options([]), Debug = sys:debug_options([]),
ok = proc_lib:init_ack(Parent, {ok, self()}), ok = proc_lib:init_ack(Parent, {ok, self()}),
listen(Parent, Debug, ListenSocket). listen(Parent, Debug, ListenSocket).
@ -98,7 +98,7 @@ init(Parent, ListenSocket) ->
ListenSocket :: gen_tcp:socket(). ListenSocket :: gen_tcp:socket().
%% @private %% @private
%% This function waits for a TCP connection. The owner of the socket is still %% This function waits for a TCP connection. The owner of the socket is still
%% the fd_httpd_client_man (so it can still close it on a call to fd_httpd_client_man:ignore/0), %% the fd_client_man (so it can still close it on a call to fd_client_man:ignore/0),
%% but the only one calling gen_tcp:accept/1 on it is this process. Closing the socket %% but the only one calling gen_tcp:accept/1 on it is this process. Closing the socket
%% is one way a manager process can gracefully unblock child workers that are blocking %% is one way a manager process can gracefully unblock child workers that are blocking
%% on a network accept. %% on a network accept.
@ -110,12 +110,12 @@ listen(Parent, Debug, ListenSocket) ->
{ok, Socket} -> {ok, Socket} ->
{ok, _} = start(ListenSocket), {ok, _} = start(ListenSocket),
{ok, Peer} = inet:peername(Socket), {ok, Peer} = inet:peername(Socket),
ok = tell("~p Connection accepted from: ~p~n", [self(), Peer]), ok = io:format("~p Connection accepted from: ~p~n", [self(), Peer]),
ok = fd_httpd_client_man:enroll(), ok = fd_client_man:enroll(),
State = #s{socket = Socket}, State = #s{socket = Socket},
loop(Parent, Debug, State); loop(Parent, Debug, State);
{error, closed} -> {error, closed} ->
ok = tell("~p Retiring: Listen socket closed.~n", [self()]), ok = io:format("~p Retiring: Listen socket closed.~n", [self()]),
exit(normal) exit(normal)
end. end.
@ -142,17 +142,17 @@ loop(Parent, Debug, State = #s{socket = Socket, next = Next0}) ->
%% should trigger bad request %% should trigger bad request
tell(error, "~p QHL parse error: ~tp", [?LINE, Error]), tell(error, "~p QHL parse error: ~tp", [?LINE, Error]),
tell(error, "~p bad request:~n~ts", [?LINE, Received]), tell(error, "~p bad request:~n~ts", [?LINE, Received]),
fd_httpd_utils:http_err(Socket, 400), fd_http_utils:http_err(Socket, 400),
gen_tcp:shutdown(Socket, read_write), gen_tcp:shutdown(Socket, read_write),
exit(normal) exit(normal)
end; end;
{tcp_closed, Socket} -> {tcp_closed, Socket} ->
ok = tell("~p Socket closed, retiring.~n", [self()]), ok = io:format("~p Socket closed, retiring.~n", [self()]),
exit(normal); exit(normal);
{system, From, Request} -> {system, From, Request} ->
sys:handle_system_msg(Request, From, Parent, ?MODULE, Debug, State); sys:handle_system_msg(Request, From, Parent, ?MODULE, Debug, State);
Unexpected -> Unexpected ->
ok = tell("~p Unexpected message: ~tp", [self(), Unexpected]), ok = io:format("~p Unexpected message: ~tp", [self(), Unexpected]),
loop(Parent, Debug, State) loop(Parent, Debug, State)
end. end.
@ -232,6 +232,7 @@ handle_request(Sock, R = #request{method = M, path = P}, Received) when M =/= un
route(Sock, get, Route, Request, Received) -> route(Sock, get, Route, Request, Received) ->
case Route of case Route of
<<"/ws/tetris">> -> ws_tetris(Sock, Request, Received);
<<"/ws/echo">> -> ws_echo(Sock, Request) , Received; <<"/ws/echo">> -> ws_echo(Sock, Request) , Received;
<<"/">> -> route_static(Sock, <<"/index.html">>) , Received; <<"/">> -> route_static(Sock, <<"/index.html">>) , Received;
_ -> route_static(Sock, Route) , Received _ -> route_static(Sock, Route) , Received
@ -239,10 +240,10 @@ route(Sock, get, Route, Request, Received) ->
route(Sock, post, Route, Request, Received) -> route(Sock, post, Route, Request, Received) ->
case Route of case Route of
<<"/wfcin">> -> wfcin(Sock, Request) , Received; <<"/wfcin">> -> wfcin(Sock, Request) , Received;
_ -> fd_httpd_utils:http_err(Sock, 404) , Received _ -> fd_http_utils:http_err(Sock, 404) , Received
end; end;
route(Sock, _, _, _, Received) -> route(Sock, _, _, _, Received) ->
fd_httpd_utils:http_err(Sock, 404), fd_http_utils:http_err(Sock, 404),
Received. Received.
@ -252,13 +253,13 @@ route(Sock, _, _, _, Received) ->
Route :: binary(). Route :: binary().
route_static(Sock, Route) -> route_static(Sock, Route) ->
respond_static(Sock, fd_httpd_sfc:query(Route)). respond_static(Sock, fd_sfc:query(Route)).
-spec respond_static(Sock, MaybeEty) -> ok -spec respond_static(Sock, MaybeEty) -> ok
when Sock :: gen_tcp:socket(), when Sock :: gen_tcp:socket(),
MaybeEty :: fd_httpd_sfc:maybe_entry(). MaybeEty :: fd_sfc:maybe_entry().
respond_static(Sock, {found, Entry}) -> respond_static(Sock, {found, Entry}) ->
% -record(e, {fs_path :: file:filename(), % -record(e, {fs_path :: file:filename(),
@ -267,18 +268,87 @@ respond_static(Sock, {found, Entry}) ->
% encoding :: encoding(), % encoding :: encoding(),
% contents :: binary()}). % contents :: binary()}).
Headers0 = Headers0 =
case fd_httpd_sfc_entry:encoding(Entry) of case fd_sfc_entry:encoding(Entry) of
gzip -> [{"content-encoding", "gzip"}]; gzip -> [{"content-encoding", "gzip"}];
none -> [] none -> []
end, end,
Headers1 = [{"content-type", fd_httpd_sfc_entry:mime_type(Entry)} | Headers0], Headers1 = [{"content-type", fd_sfc_entry:mime_type(Entry)} | Headers0],
Response = #response{headers = Headers1, Response = #response{headers = Headers1,
body = fd_httpd_sfc_entry:contents(Entry)}, body = fd_sfc_entry:contents(Entry)},
fd_httpd_utils:respond(Sock, Response); fd_http_utils:respond(Sock, Response);
respond_static(Sock, not_found) -> respond_static(Sock, not_found) ->
fd_httpd_utils:http_err(Sock, 404). fd_http_utils:http_err(Sock, 404).
%% ------------------------------
%% tetris
%% ------------------------------
-spec ws_tetris(Sock, Request, Received) -> NewReceived
when Sock :: gen_tcp:socket(),
Request :: request(),
Received :: binary(),
NewReceived :: binary().
ws_tetris(Sock, Request, Received) ->
.
-spec ws_tetris2(Sock, Request, Received) -> NewReceived
when Sock :: gen_tcp:socket(),
Request :: request(),
Received :: binary(),
NewReceived :: binary().
ws_tetris2(Sock, Request, Received) ->
%tell("~p: ws_tetris request: ~tp", [?LINE, Request]),
case fd_ws:handshake(Request) of
{ok, Response} ->
fd_http_utils:respond(Sock, Response),
{ok, TetrisPid} = fd_tetris:start_link(),
ws_tetris_loop(Sock, TetrisPid, [], Received);
Error ->
tell("ws_tetris: error: ~tp", [Error]),
fd_http_utils:http_err(Sock, 400)
end.
-spec ws_tetris_loop(Sock, Tetris, Frames, Received) -> NewReceived
when Sock :: gen_tcp:socket(),
Tetris :: pid(),
Frames :: [fd_ws:frame()],
Received :: binary(),
NewReceived :: binary().
ws_tetris_loop(Sock, Tetris, Frames, Received) ->
tell("~p:ws_tetris_loop(Sock, ~p, ~p, ~p)", [?MODULE, Tetris, Frames, Received]),
%% create tetris state
case inet:setopts(Sock, [{active, once}]) of
ok ->
receive
{tcp, Sock, Bin} ->
Rcv1 = <<Received/binary, Bin/binary>>,
case fd_ws:recv(Sock, Rcv1, 3_000, Frames) of
{ok, WsMsg, NewFrames, Rcv2} ->
ok = fd_tetris:ws_msg(Tetris, WsMsg),
ws_tetris_loop(Sock, Tetris, NewFrames, Rcv2);
Error ->
error(Error)
end;
{tetris, Message} ->
ok = log(info, "~p tetris: ~p", [self(), Message]),
ok = fd_ws:send(Sock, {text, Message}),
ws_tetris_loop(Sock, Tetris, Frames, Received);
{tcp_closed, Sock} -> {error, tcp_closed};
{tcp_error, Sock, Reason} -> {error, {tcp_error, Reason}}
after 30_000 ->
{error, timeout}
end;
{error, Reason} ->
{error, {inet, Reason}}
end.
%% ------------------------------ %% ------------------------------
%% echo %% echo
%% ------------------------------ %% ------------------------------
@ -289,17 +359,17 @@ ws_echo(Sock, Request) ->
catch catch
X:Y:Z -> X:Y:Z ->
tell(error, "CRASH ws_echo: ~tp:~tp:~tp", [X, Y, Z]), tell(error, "CRASH ws_echo: ~tp:~tp:~tp", [X, Y, Z]),
fd_httpd_utils:http_err(Sock, 500) fd_http_utils:http_err(Sock, 500)
end. end.
ws_echo2(Sock, Request) -> ws_echo2(Sock, Request) ->
case qhl_ws:handshake(Request) of case fd_ws:handshake(Request) of
{ok, Response} -> {ok, Response} ->
fd_httpd_utils:respond(Sock, Response), fd_http_utils:respond(Sock, Response),
ws_echo_loop(Sock); ws_echo_loop(Sock);
Error -> Error ->
tell("ws_echo: error: ~tp", [Error]), tell("ws_echo: error: ~tp", [Error]),
fd_httpd_utils:http_err(Sock, 400) fd_http_utils:http_err(Sock, 400)
end. end.
ws_echo_loop(Sock) -> ws_echo_loop(Sock) ->
@ -307,15 +377,15 @@ ws_echo_loop(Sock) ->
ws_echo_loop(Sock, Frames, Received) -> ws_echo_loop(Sock, Frames, Received) ->
tell("~p ws_echo_loop(Sock, ~tp, ~tp)", [self(), Frames, Received]), tell("~p ws_echo_loop(Sock, ~tp, ~tp)", [self(), Frames, Received]),
case qhl_ws:recv(Sock, Received, 5*qhl_ws:min(), Frames) of case fd_ws:recv(Sock, Received, 5*fd_ws:min(), Frames) of
{ok, Message, NewFrames, NewReceived} -> {ok, Message, NewFrames, NewReceived} ->
tell("~p echo message: ~tp", [self(), Message]), tell("~p echo message: ~tp", [self(), Message]),
% send the same message back % send the same message back
ok = qhl_ws:send(Sock, Message), ok = fd_ws:send(Sock, Message),
ws_echo_loop(Sock, NewFrames, NewReceived); ws_echo_loop(Sock, NewFrames, NewReceived);
Error -> Error ->
tell(error, "ws_echo_loop: error: ~tp", [Error]), tell(error, "ws_echo_loop: error: ~tp", [Error]),
qhl_ws:send(Sock, {close, <<>>}), fd_ws:send(Sock, {close, <<>>}),
error(Error) error(Error)
end. end.
@ -335,28 +405,28 @@ wfcin(Sock, #request{enctype = json,
case wfc_read:expr(Input) of case wfc_read:expr(Input) of
{ok, Expr, _Rest} -> {ok, Expr, _Rest} ->
case wfc_eval:eval(Expr, Ctx0) of case wfc_eval:eval(Expr, Ctx0) of
{ok, noop, Ctx1} -> {fd_httpd_utils:jsgud("<noop>"), Ctx1}; {ok, noop, Ctx1} -> {fd_http_utils:jsgud("<noop>"), Ctx1};
{ok, Sentence, Ctx1} -> {fd_httpd_utils:jsgud(wfc_pp:sentence(Sentence)), Ctx1}; {ok, Sentence, Ctx1} -> {fd_http_utils:jsgud(wfc_pp:sentence(Sentence)), Ctx1};
{error, Message} -> {fd_httpd_utils:jsbad(Message), Ctx0} {error, Message} -> {fd_http_utils:jsbad(Message), Ctx0}
end; end;
{error, Message} -> {error, Message} ->
{fd_httpd_utils:jsbad(Message), Ctx0} {fd_http_utils:jsbad(Message), Ctx0}
end end
catch catch
error:E:S -> error:E:S ->
ErrorMessage = unicode:characters_to_list(io_lib:format("parser crashed: ~p:~p", [E, S])), ErrorMessage = unicode:characters_to_list(io_lib:format("parser crashed: ~p:~p", [E, S])),
{fd_httpd_utils:jsbad(ErrorMessage), Ctx0} {fd_http_utils:jsbad(ErrorMessage), Ctx0}
end, end,
% update cache with new context % update cache with new context
ok = fd_wfcd_cache:set(Cookie, NewCtx), ok = fd_cache:set(Cookie, NewCtx),
Body = zj:encode(RespObj), Body = zj:encode(RespObj),
Response = #response{headers = [{"content-type", "application/json"}, Response = #response{headers = [{"content-type", "application/json"},
{"set-cookie", ["wfc=", Cookie]}], {"set-cookie", ["wfc=", Cookie]}],
body = Body}, body = Body},
fd_httpd_utils:respond(Sock, Response); fd_http_utils:respond(Sock, Response);
wfcin(Sock, Request) -> wfcin(Sock, Request) ->
tell("wfcin: bad request: ~tp", [Request]), tell("wfcin: bad request: ~tp", [Request]),
fd_httpd_utils:http_err(Sock, 400). fd_http_utils:http_err(Sock, 400).
@ -366,9 +436,17 @@ wfcin(Sock, Request) ->
Context :: wfc_eval_context:context(). Context :: wfc_eval_context:context().
ctx(#{<<"wfc">> := Cookie}) -> ctx(#{<<"wfc">> := Cookie}) ->
case fd_wfcd_cache:query(Cookie) of case fd_cache:query(Cookie) of
{ok, Context} -> {Cookie, Context}; {ok, Context} -> {Cookie, Context};
error -> {Cookie, wfc_eval_context:default()} error -> {Cookie, wfc_eval_context:default()}
end; end;
ctx(_) -> ctx(_) ->
{fd_httpd_utils:new_cookie(), wfc_eval_context:default()}. {fd_http_utils:new_cookie(), wfc_eval_context:default()}.

25
src/fd_httpd_client_man.erl → src/fd_client_man.erl
View File

@ -9,8 +9,8 @@
%%% OTP should take care of for us. %%% OTP should take care of for us.
%%% @end %%% @end
-module(fd_httpd_client_man). -module(fd_client_man).
-vsn("0.2.0"). -vsn("0.1.0").
-behavior(gen_server). -behavior(gen_server).
-author("Peter Harpending <peterharpending@qpq.swiss>"). -author("Peter Harpending <peterharpending@qpq.swiss>").
-copyright("Peter Harpending <peterharpending@qpq.swiss>"). -copyright("Peter Harpending <peterharpending@qpq.swiss>").
@ -23,8 +23,6 @@
code_change/3, terminate/2]). code_change/3, terminate/2]).
-include("$zx_include/zx_logger.hrl").
%%% Type and Record Definitions %%% Type and Record Definitions
@ -94,7 +92,7 @@ echo(Message) ->
when Result :: {ok, pid()} when Result :: {ok, pid()}
| {error, Reason :: term()}. | {error, Reason :: term()}.
%% @private %% @private
%% This should only ever be called by fd_httpd_clients (the service-level supervisor). %% This should only ever be called by fd_clients (the service-level supervisor).
start_link() -> start_link() ->
gen_server:start_link({local, ?MODULE}, ?MODULE, none, []). gen_server:start_link({local, ?MODULE}, ?MODULE, none, []).
@ -106,9 +104,8 @@ start_link() ->
%% preparatory work necessary for proper function. %% preparatory work necessary for proper function.
init(none) -> init(none) ->
ok = tell("Starting fd_httpd_client_man."), ok = io:format("Starting.~n"),
State = #s{}, State = #s{},
ok = tell("fd_httpd_client_man init state: ~tp", [State]),
{ok, State}. {ok, State}.
@ -133,7 +130,7 @@ handle_call({listen, PortNum}, _, State) ->
{Response, NewState} = do_listen(PortNum, State), {Response, NewState} = do_listen(PortNum, State),
{reply, Response, NewState}; {reply, Response, NewState};
handle_call(Unexpected, From, State) -> handle_call(Unexpected, From, State) ->
ok = tell("~p Unexpected call from ~tp: ~tp~n", [self(), From, Unexpected]), ok = io:format("~p Unexpected call from ~tp: ~tp~n", [self(), From, Unexpected]),
{noreply, State}. {noreply, State}.
@ -155,7 +152,7 @@ handle_cast(ignore, State) ->
NewState = do_ignore(State), NewState = do_ignore(State),
{noreply, NewState}; {noreply, NewState};
handle_cast(Unexpected, State) -> handle_cast(Unexpected, State) ->
ok = tell("~p Unexpected cast: ~tp~n", [self(), Unexpected]), ok = io:format("~p Unexpected cast: ~tp~n", [self(), Unexpected]),
{noreply, State}. {noreply, State}.
@ -171,7 +168,7 @@ handle_info({'DOWN', Mon, process, Pid, Reason}, State) ->
NewState = handle_down(Mon, Pid, Reason, State), NewState = handle_down(Mon, Pid, Reason, State),
{noreply, NewState}; {noreply, NewState};
handle_info(Unexpected, State) -> handle_info(Unexpected, State) ->
ok = tell("~p Unexpected info: ~tp~n", [self(), Unexpected]), ok = io:format("~p Unexpected info: ~tp~n", [self(), Unexpected]),
{noreply, State}. {noreply, State}.
@ -228,10 +225,10 @@ do_listen(PortNum, State = #s{port_num = none}) ->
{keepalive, true}, {keepalive, true},
{reuseaddr, true}], {reuseaddr, true}],
{ok, Listener} = gen_tcp:listen(PortNum, SocketOptions), {ok, Listener} = gen_tcp:listen(PortNum, SocketOptions),
{ok, _} = fd_httpd_client:start(Listener), {ok, _} = fd_client:start(Listener),
{ok, State#s{port_num = PortNum, listener = Listener}}; {ok, State#s{port_num = PortNum, listener = Listener}};
do_listen(_, State = #s{port_num = PortNum}) -> do_listen(_, State = #s{port_num = PortNum}) ->
ok = tell("~p Already listening on ~p~n", [self(), PortNum]), ok = io:format("~p Already listening on ~p~n", [self(), PortNum]),
{{error, {listening, PortNum}}, State}. {{error, {listening, PortNum}}, State}.
@ -257,7 +254,7 @@ do_enroll(Pid, State = #s{clients = Clients}) ->
case lists:member(Pid, Clients) of case lists:member(Pid, Clients) of
false -> false ->
Mon = monitor(process, Pid), Mon = monitor(process, Pid),
ok = tell("Monitoring ~tp @ ~tp~n", [Pid, Mon]), ok = io:format("Monitoring ~tp @ ~tp~n", [Pid, Mon]),
State#s{clients = [Pid | Clients]}; State#s{clients = [Pid | Clients]};
true -> true ->
State State
@ -295,6 +292,6 @@ handle_down(Mon, Pid, Reason, State = #s{clients = Clients}) ->
State#s{clients = NewClients}; State#s{clients = NewClients};
false -> false ->
Unexpected = {'DOWN', Mon, process, Pid, Reason}, Unexpected = {'DOWN', Mon, process, Pid, Reason},
ok = tell("~p Unexpected info: ~tp~n", [self(), Unexpected]), ok = io:format("~p Unexpected info: ~tp~n", [self(), Unexpected]),
State State
end. end.

18
src/fd_httpd_client_sup.erl → src/fd_client_sup.erl
View File

@ -2,8 +2,8 @@
%%% front end web development lab Client Supervisor %%% front end web development lab Client Supervisor
%%% %%%
%%% This process supervises the client socket handlers themselves. It is a peer of the %%% This process supervises the client socket handlers themselves. It is a peer of the
%%% fd_httpd_client_man (the manager interface to this network service component), %%% fd_client_man (the manager interface to this network service component),
%%% and a child of the supervisor named fd_httpd_clients. %%% and a child of the supervisor named fd_clients.
%%% %%%
%%% Because we don't know (or care) how many client connections the server may end up %%% Because we don't know (or care) how many client connections the server may end up
%%% handling this is a simple_one_for_one supervisor which can spawn and manage as %%% handling this is a simple_one_for_one supervisor which can spawn and manage as
@ -13,8 +13,8 @@
%%% http://erlang.org/doc/design_principles/sup_princ.html#id79244 %%% http://erlang.org/doc/design_principles/sup_princ.html#id79244
%%% @end %%% @end
-module(fd_httpd_client_sup). -module(fd_client_sup).
-vsn("0.2.0"). -vsn("0.1.0").
-behaviour(supervisor). -behaviour(supervisor).
-author("Peter Harpending <peterharpending@qpq.swiss>"). -author("Peter Harpending <peterharpending@qpq.swiss>").
-copyright("Peter Harpending <peterharpending@qpq.swiss>"). -copyright("Peter Harpending <peterharpending@qpq.swiss>").
@ -35,9 +35,9 @@
| {shutdown, term()} | {shutdown, term()}
| term(). | term().
%% @private %% @private
%% Spawns the first listener at the request of the fd_httpd_client_man when %% Spawns the first listener at the request of the fd_client_man when
%% fewd:listen/1 is called, or the next listener at the request of the %% fewd:listen/1 is called, or the next listener at the request of the
%% currently listening fd_httpd_client when a connection is made. %% currently listening fd_client when a connection is made.
%% %%
%% Error conditions, supervision strategies and other important issues are %% Error conditions, supervision strategies and other important issues are
%% explained in the supervisor module docs: %% explained in the supervisor module docs:
@ -61,10 +61,10 @@ start_link() ->
init(none) -> init(none) ->
RestartStrategy = {simple_one_for_one, 1, 60}, RestartStrategy = {simple_one_for_one, 1, 60},
Client = {fd_httpd_client, Client = {fd_client,
{fd_httpd_client, start_link, []}, {fd_client, start_link, []},
temporary, temporary,
brutal_kill, brutal_kill,
worker, worker,
[fd_httpd_client]}, [fd_client]},
{ok, {RestartStrategy, [Client]}}. {ok, {RestartStrategy, [Client]}}.

30
src/fd_httpd_clients.erl → src/fd_clients.erl
View File

@ -8,8 +8,8 @@
%%% See: http://erlang.org/doc/apps/kernel/application.html %%% See: http://erlang.org/doc/apps/kernel/application.html
%%% @end %%% @end
-module(fd_httpd_clients). -module(fd_clients).
-vsn("0.2.0"). -vsn("0.1.0").
-behavior(supervisor). -behavior(supervisor).
-author("Peter Harpending <peterharpending@qpq.swiss>"). -author("Peter Harpending <peterharpending@qpq.swiss>").
-copyright("Peter Harpending <peterharpending@qpq.swiss>"). -copyright("Peter Harpending <peterharpending@qpq.swiss>").
@ -32,17 +32,17 @@ start_link() ->
init(none) -> init(none) ->
RestartStrategy = {rest_for_one, 1, 60}, RestartStrategy = {rest_for_one, 1, 60},
HttpClientMan = {fd_httpd_client_man, ClientMan = {fd_client_man,
{fd_httpd_client_man, start_link, []}, {fd_client_man, start_link, []},
permanent, permanent,
5000, 5000,
worker, worker,
[fd_httpd_client_man]}, [fd_client_man]},
HttpClientSup = {fd_httpd_client_sup, ClientSup = {fd_client_sup,
{fd_httpd_client_sup, start_link, []}, {fd_client_sup, start_link, []},
permanent, permanent,
5000, 5000,
supervisor, supervisor,
[fd_httpd_client_sup]}, [fd_client_sup]},
Children = [HttpClientSup, HttpClientMan], Children = [ClientSup, ClientMan],
{ok, {RestartStrategy, Children}}. {ok, {RestartStrategy, Children}}.

10
src/fd_httpd_utils.erl → src/fd_http_utils.erl
View File

@ -1,6 +1,5 @@
% @doc http utility functions % @doc http utility functions
-module(fd_httpd_utils). -module(fd_http_utils).
-vsn("0.2.0").
-export([ -export([
new_cookie/0, new_cookie/0,
@ -8,10 +7,7 @@
http_err/2, http_err/2,
respond/2, respond/2,
fmtresp/1 fmtresp/1
]). ])
-include("http.hrl").
-include("$zx_include/zx_logger.hrl").
-spec new_cookie() -> Cookie -spec new_cookie() -> Cookie
@ -114,6 +110,6 @@ add_headers(Hs, Body) ->
default_headers(Body) -> default_headers(Body) ->
BodySize = byte_size(iolist_to_binary(Body)), BodySize = byte_size(iolist_to_binary(Body)),
#{"Server" => "fewd 0.2.0", #{"Server" => "fewd 0.1.0",
"Date" => qhl:ridiculous_web_date(), "Date" => qhl:ridiculous_web_date(),
"Content-Length" => io_lib:format("~p", [BodySize])}. "Content-Length" => io_lib:format("~p", [BodySize])}.

39
src/fd_httpd.erl
View File

@ -1,39 +0,0 @@
-module(fd_httpd).
-vsn("0.2.0").
-behaviour(supervisor).
-author("Peter Harpending <peterharpending@qpq.swiss>").
-copyright("Peter Harpending <peterharpending@qpq.swiss>").
-license("BSD-2-Clause-FreeBSD").
-export([start_link/0]).
-export([init/1]).
-spec start_link() -> {ok, pid()}.
%% @private
%% This supervisor's own start function.
start_link() ->
supervisor:start_link({local, ?MODULE}, ?MODULE, []).
-spec init([]) -> {ok, {supervisor:sup_flags(), [supervisor:child_spec()]}}.
%% @private
%% The OTP init/1 function.
init([]) ->
RestartStrategy = {one_for_one, 1, 60},
FileCache = {fd_httpd_sfc,
{fd_httpd_sfc, start_link, []},
permanent,
5000,
worker,
[fd_httpd_sfc]},
Clients = {fd_httpd_clients,
{fd_httpd_clients, start_link, []},
permanent,
5000,
supervisor,
[fd_httpd_clients]},
Children = [FileCache, Clients],
{ok, {RestartStrategy, Children}}.

15
src/fd_httpd_sfc.erl → src/fd_sfc.erl
View File

@ -1,6 +1,5 @@
% @doc static file cache % @doc static file cache
-module(fd_httpd_sfc). -module(fd_sfc).
-vsn("0.2.0").
-behavior(gen_server). -behavior(gen_server).
@ -22,12 +21,12 @@
-include("$zx_include/zx_logger.hrl"). -include("$zx_include/zx_logger.hrl").
-type entry() :: fd_httpd_sfc_entry:entry(). -type entry() :: fd_sfc_entry:entry().
-type maybe_entry() :: {found, fd_httpd_sfc_entry:entry()} | not_found. -type maybe_entry() :: {found, fd_sfc_entry:entry()} | not_found.
-record(s, {base_path = base_path() :: file:filename(), -record(s, {base_path = base_path() :: file:filename(),
cache = fd_httpd_sfc_cache:new(base_path()) :: fd_httpd_sfc_cache:cache(), cache = fd_sfc_cache:new(base_path()) :: fd_sfc_cache:cache(),
auto_renew = 0_500 :: pos_integer()}). auto_renew = 0_500 :: pos_integer()}).
%-type state() :: #s{}. %-type state() :: #s{}.
@ -63,14 +62,14 @@ start_link() ->
%% gen_server callbacks %% gen_server callbacks
init(none) -> init(none) ->
tell("starting fd_httpd_sfc"), tell("starting fd_sfc"),
InitState = #s{}, InitState = #s{},
erlang:send_after(InitState#s.auto_renew, self(), auto_renew), erlang:send_after(InitState#s.auto_renew, self(), auto_renew),
{ok, InitState}. {ok, InitState}.
handle_call({query, Path}, _, State = #s{cache = Cache}) -> handle_call({query, Path}, _, State = #s{cache = Cache}) ->
Reply = fd_httpd_sfc_cache:query(Path, Cache), Reply = fd_sfc_cache:query(Path, Cache),
{reply, Reply, State}; {reply, Reply, State};
handle_call(Unexpected, From, State) -> handle_call(Unexpected, From, State) ->
tell("~tp: unexpected call from ~tp: ~tp", [?MODULE, Unexpected, From]), tell("~tp: unexpected call from ~tp: ~tp", [?MODULE, Unexpected, From]),
@ -107,6 +106,6 @@ terminate(_, _) ->
%%----------------------------------------------------------------------------- %%-----------------------------------------------------------------------------
i_renew(State = #s{base_path = BasePath}) -> i_renew(State = #s{base_path = BasePath}) ->
NewCache = fd_httpd_sfc_cache:new(BasePath), NewCache = fd_sfc_cache:new(BasePath),
NewState = State#s{cache = NewCache}, NewState = State#s{cache = NewCache},
NewState. NewState.

9
src/fd_httpd_sfc_cache.erl → src/fd_sfc_cache.erl
View File

@ -1,7 +1,6 @@
% @doc % @doc
% cache data management % cache data management
-module(fd_httpd_sfc_cache). -module(fd_sfc_cache).
-vsn("0.2.0").
-export_type([ -export_type([
cache/0 cache/0
@ -14,7 +13,7 @@
-include("$zx_include/zx_logger.hrl"). -include("$zx_include/zx_logger.hrl").
-type cache() :: #{HttpPath :: binary() := Entry :: fd_httpd_sfc_entry:entry()}. -type cache() :: #{HttpPath :: binary() := Entry :: fd_sfc_entry:entry()}.
-spec query(HttpPath, Cache) -> Result -spec query(HttpPath, Cache) -> Result
@ -22,7 +21,7 @@
Cache :: cache(), Cache :: cache(),
Result :: {found, Entry} Result :: {found, Entry}
| not_found, | not_found,
Entry :: fd_httpd_sfc_entry:entry(). Entry :: fd_sfc_entry:entry().
query(HttpPath, Cache) -> query(HttpPath, Cache) ->
case maps:find(HttpPath, Cache) of case maps:find(HttpPath, Cache) of
@ -64,7 +63,7 @@ new2(BasePath) ->
BAbsPath = unicode:characters_to_binary(AbsPath), BAbsPath = unicode:characters_to_binary(AbsPath),
HttpPath = remove_prefix(BBaseDir, BAbsPath), HttpPath = remove_prefix(BBaseDir, BAbsPath),
NewCache = NewCache =
case fd_httpd_sfc_entry:new(AbsPath) of case fd_sfc_entry:new(AbsPath) of
{found, Entry} -> maps:put(HttpPath, Entry, AccCache); {found, Entry} -> maps:put(HttpPath, Entry, AccCache);
not_found -> AccCache not_found -> AccCache
end, end,

3
src/fd_httpd_sfc_entry.erl → src/fd_sfc_entry.erl
View File

@ -1,8 +1,7 @@
% @doc non-servery functions for static file caching % @doc non-servery functions for static file caching
% %
% this spams the filesystem, so it's not "pure" code % this spams the filesystem, so it's not "pure" code
-module(fd_httpd_sfc_entry). -module(fd_sfc_entry).
-vsn("0.2.0").
-export_type([ -export_type([
encoding/0, encoding/0,

30
src/fd_sup.erl
View File

@ -12,7 +12,7 @@
%%% @end %%% @end
-module(fd_sup). -module(fd_sup).
-vsn("0.2.0"). -vsn("0.1.0").
-behaviour(supervisor). -behaviour(supervisor).
-author("Peter Harpending <peterharpending@qpq.swiss>"). -author("Peter Harpending <peterharpending@qpq.swiss>").
-copyright("Peter Harpending <peterharpending@qpq.swiss>"). -copyright("Peter Harpending <peterharpending@qpq.swiss>").
@ -36,17 +36,29 @@ start_link() ->
init([]) -> init([]) ->
RestartStrategy = {one_for_one, 1, 60}, RestartStrategy = {one_for_one, 1, 60},
WFCd = {fd_wfcd, Clients = {fd_clients,
{fd_wfcd, start_link, []}, {fd_clients, start_link, []},
permanent, permanent,
5000, 5000,
supervisor, supervisor,
[fd_wfcd]}, [fd_clients]},
Httpd = {fd_httpd, Chat = {fd_chat,
{fd_httpd, start_link, []}, {fd_chat, start_link, []},
permanent, permanent,
5000, 5000,
supervisor, worker,
[fd_httpd]}, [fd_chat]},
Children = [WFCd, Httpd], FileCache = {fd_sfc,
{fd_sfc, start_link, []},
permanent,
5000,
worker,
[fd_sfc]},
Cache = {fd_cache,
{fd_cache, start_link, []},
permanent,
5000,
worker,
[fd_cache]},
Children = [Clients, Chat, FileCache, Cache],
{ok, {RestartStrategy, Children}}. {ok, {RestartStrategy, Children}}.

88
src/fd_tetris.erl Normal file
View File

@ -0,0 +1,88 @@
% @doc tetris
%
% manages state for a single game of tetris
%
% sends parent process messages `{tetris, String}` where String is an encoded
% JSON blob meant to be sent to the page script in /priv/static/js/ts/tetris.ts
%
% Refs:
% 1. https://www.erlang.org/docs/24/man/gen_server
-module(fd_tetris).
-behavior(gen_server).
-export([
%% caller context
start_link/0,
%% process context
%% gen_server callbacks
init/1, handle_call/3, handle_cast/2, handle_info/2,
code_change/3, terminate/2
]).
-include("$zx_include/zx_logger.hrl").
-record(s, {parent :: pid()}).
-type state() :: #s{}.
%%-----------------------------------------------------------------------------
%% caller context below this line
%%-----------------------------------------------------------------------------
-spec ws_msg(Tetris, Message) -> ok
when Tetris :: pid(),
Message :: fd_ws:ws_msg().
ws_msg(Tetris, Msg) ->
gen_server:cast(Tetris, {ws_msg, Msg}).
-spec start_link() -> {ok, pid()} | {error, term()}.
start_link() ->
gen_server:start_link(?MODULE, [self()], []).
%%-----------------------------------------------------------------------------
%% process context below this line
%%-----------------------------------------------------------------------------
%% gen_server callbacks
-spec init(Args) -> {ok, State}
when Args :: [Parent],
Parent :: pid(),
State :: state().
init([Parent]) ->
tell("~tp:~tp starting fd_tetris with parent ~p", [?MODULE, self(), Parent]),
self() ! {poop, 0},
InitState = #s{parent = Parent},
{ok, InitState}.
handle_call(Unexpected, From, State) ->
tell("~tp:~tp unexpected call from ~tp: ~tp", [?MODULE, self(), From, Unexpected]),
{noreply, State}.
handle_cast(Unexpected, State) ->
tell("~tp:~tp unexpected cast: ~tp", [?MODULE, self(), Unexpected]),
{noreply, State}.
handle_info({poop, N}, State = #s{parent = Parent}) ->
Parent ! {tetris, io_lib:format("poop~p", [N])},
erlang:send_after(1_000, self(), {poop, N+1}),
{noreply, State};
handle_info(Unexpected, State) ->
tell("~tp:~tp unexpected info: ~tp", [?MODULE, self(), Unexpected]),
{noreply, State}.
code_change(_, State, _) ->
{ok, State}.
terminate(_, _) ->
ok.

33
src/fd_wfcd.erl
View File

@ -1,33 +0,0 @@
-module(fd_wfcd).
-vsn("0.2.0").
-behaviour(supervisor).
-author("Peter Harpending <peterharpending@qpq.swiss>").
-copyright("Peter Harpending <peterharpending@qpq.swiss>").
-license("BSD-2-Clause-FreeBSD").
-export([start_link/0]).
-export([init/1]).
-spec start_link() -> {ok, pid()}.
%% @private
%% This supervisor's own start function.
start_link() ->
supervisor:start_link({local, ?MODULE}, ?MODULE, []).
-spec init([]) -> {ok, {supervisor:sup_flags(), [supervisor:child_spec()]}}.
%% @private
%% The OTP init/1 function.
init([]) ->
RestartStrategy = {one_for_one, 1, 60},
Cache = {fd_wfcd_cache,
{fd_wfcd_cache, start_link, []},
permanent,
5000,
worker,
[fd_wfcd_cache]},
Children = [Cache],
{ok, {RestartStrategy, Children}}.

8
src/qhl_ws.erl → src/fd_ws.erl
View File

@ -1,8 +1,7 @@
% @doc websockets % @doc websockets
% %
% ref: https://datatracker.ietf.org/doc/html/rfc6455 % ref: https://datatracker.ietf.org/doc/html/rfc6455
-module(qhl_ws). -module(fd_ws).
-vsn("0.2.0").
-export_type([ -export_type([
opcode/0, opcode/0,
@ -20,6 +19,7 @@
]). ]).
-include("http.hrl"). -include("http.hrl").
-include("$zx_include/zx_logger.hrl").
-define(MAX_PAYLOAD_SIZE, ((1 bsl 63) - 1)). -define(MAX_PAYLOAD_SIZE, ((1 bsl 63) - 1)).
@ -632,8 +632,11 @@ recv_frame_await(Frame, Sock, Received, Timeout) ->
% @end % @end
send(Socket, {Type, Payload}) -> send(Socket, {Type, Payload}) ->
log(info, "fd_ws: send(~tp, {~tp, ~tp})", [Socket, Type, Payload]),
BPayload = payload_to_binary(Payload), BPayload = payload_to_binary(Payload),
log(info, "fd_ws: BPayload = ~tp", [BPayload]),
Frame = message_to_frame(Type, BPayload), Frame = message_to_frame(Type, BPayload),
log(info, "fd_ws: Frame = ~tp", [Frame]),
send_frame(Socket, Frame). send_frame(Socket, Frame).
payload_to_binary(Bin) when is_binary(Bin) -> Bin; payload_to_binary(Bin) when is_binary(Bin) -> Bin;
@ -672,6 +675,7 @@ message_to_frame(Control, Payload)
send_frame(Sock, Frame) -> send_frame(Sock, Frame) ->
Binary = render_frame(Frame), Binary = render_frame(Frame),
log(info, "send_frame: rendered frame: ~tp", [Binary]),
gen_tcp:send(Sock, Binary). gen_tcp:send(Sock, Binary).

102
src/fd_wsp.erl Normal file
View File

@ -0,0 +1,102 @@
% @doc Abstracts a web socket into a process
%
% hands the TCP socket over to this process, also this process does the
% handshake.
%
% this process sends back `{ws, self(), Message: fd_ws:ws_msg()}'
%
% for each websocket message it gets
-module(fd_wsp).
-behavior(gen_server).
-export_type([
]).
-export([
%% caller context
handshake/0,
start_link/0,
%% process context
init/1, handle_call/3, handle_cast/2, handle_info/2,
code_change/3, terminate/2
]).
-include("http.hrl").
-include("$zx_include/zx_logger.hrl").
-record(s, {socket :: gen_tcp:socket()})
-type state() :: #s{}.
%%-----------------------------------------------------------------------------
%% caller context
%%-----------------------------------------------------------------------------
-spec start_link(Socket, HandshakeReq, Received) -> Result
when Socket :: gen_tcp:socket(),
HandshakeReq :: request(),
Received :: binary(),
Result :: {ok, pid()}
| {error, term()}.
% @doc
% starts a websocket and hands control of socket over to child process
start_link(Socket, HandshakeReq, Received) ->
case gen_server:start_link(?MODULE, [Socket, HandshakeReq, Received], []) of
{ok, PID} ->
gen_tcp:controlling_process(Socket, PID),
{ok, PID};
Error ->
Error
end.
%%-----------------------------------------------------------------------------
%% process context below this line
%%-----------------------------------------------------------------------------
%% gen_server callbacks
init([Socket, HandshakeReq, Received]) ->
log("~p:~p init", [?MODULE, self()]),
case fd_ws:handshake(HandshakeReq) of
{ok, Response} ->
ok = fd_http_utils:respond(Sock, Response),
InitState = #s{socket = Socket},
Error ->
tell("~p:~p websocket handshake err: ~p", [?MODULE, self(), Error]),
fd_http_utils:http_err(Socket, 400)
Error
end.
handle_call(Unexpected, From, State) ->
tell("~tp: unexpected call from ~tp: ~tp", [?MODULE, Unexpected, From]),
{noreply, State}.
handle_cast(Unexpected, State) ->
tell("~tp: unexpected cast: ~tp", [?MODULE, Unexpected]),
{noreply, State}.
handle_info({tcp, Sock, Bytes}, State = #s{socket = Sock}) ->
handle_info(Unexpected, State) ->
tell("~tp: unexpected info: ~tp", [?MODULE, Unexpected]),
{noreply, State}.
code_change(_, State, _) ->
{ok, State}.
terminate(_, _) ->
ok.
%%-----------------------------------------------------------------------------
%% internals
%%-----------------------------------------------------------------------------

6
src/fewd.erl
View File

@ -3,7 +3,7 @@
%%% @end %%% @end
-module(fewd). -module(fewd).
-vsn("0.2.0"). -vsn("0.1.0").
-behavior(application). -behavior(application).
-author("Peter Harpending <peterharpending@qpq.swiss>"). -author("Peter Harpending <peterharpending@qpq.swiss>").
-copyright("Peter Harpending <peterharpending@qpq.swiss>"). -copyright("Peter Harpending <peterharpending@qpq.swiss>").
@ -24,7 +24,7 @@
%% Returns an {error, Reason} tuple if it is already listening. %% Returns an {error, Reason} tuple if it is already listening.
listen(PortNum) -> listen(PortNum) ->
fd_httpd_client_man:listen(PortNum). fd_client_man:listen(PortNum).
-spec ignore() -> ok. -spec ignore() -> ok.
@ -32,7 +32,7 @@ listen(PortNum) ->
%% Make the server stop listening if it is, or continue to do nothing if it isn't. %% Make the server stop listening if it is, or continue to do nothing if it isn't.
ignore() -> ignore() ->
fd_httpd_client_man:ignore(). fd_client_man:ignore().
-spec start(normal, term()) -> {ok, pid()}. -spec start(normal, term()) -> {ok, pid()}.

1
src/wfc.erl
View File

@ -1,7 +1,6 @@
% @doc % @doc
% porcelain wfc ops % porcelain wfc ops
-module(wfc). -module(wfc).
-vsn("0.2.0").
-export_type([ -export_type([
sentence/0 sentence/0

1
src/wfc_bm.erl
View File

@ -1,7 +1,6 @@
% @doc % @doc
% bit matrices % bit matrices
-module(wfc_bm). -module(wfc_bm).
-vsn("0.2.0").
-export_type([ -export_type([
bit/0, bit/0,

1
src/wfc_eval.erl
View File

@ -1,5 +1,4 @@
-module(wfc_eval). -module(wfc_eval).
-vsn("0.2.0").
-export_type([ -export_type([
]). ]).

1
src/wfc_eval_context.erl
View File

@ -1,5 +1,4 @@
-module(wfc_eval_context). -module(wfc_eval_context).
-vsn("0.2.0").
-export_type([ -export_type([
context/0 context/0

1
src/wfc_ltr.erl
View File

@ -7,7 +7,6 @@
% %
% mathematically, this is a variable like "a", "b", "c", etc % mathematically, this is a variable like "a", "b", "c", etc
-module(wfc_ltr). -module(wfc_ltr).
-vsn("0.2.0").
-export_type([ -export_type([
ltr/0 ltr/0

1
src/wfc_pp.erl
View File

@ -1,5 +1,4 @@
-module(wfc_pp). -module(wfc_pp).
-vsn("0.2.0").
-export([ -export([
eval_result/1, eval_result/1,

1
src/wfc_read.erl
View File

@ -1,5 +1,4 @@
-module(wfc_read). -module(wfc_read).
-vsn("0.2.0").
-export_type([ -export_type([
]). ]).

1
src/wfc_sentence.erl
View File

@ -6,7 +6,6 @@
% %
% empty sentence is 0 % empty sentence is 0
-module(wfc_sentence). -module(wfc_sentence).
-vsn("0.2.0").
-export_type([ -export_type([
sentence/0 sentence/0

1
src/wfc_sftt.erl
View File

@ -1,7 +1,6 @@
% @doc % @doc
% sentence-fun <-> truth table logic % sentence-fun <-> truth table logic
-module(wfc_sftt). -module(wfc_sftt).
-vsn("0.2.0").
-export_type([ -export_type([
sf/0, tt/0 sf/0, tt/0

1
src/wfc_ttfuns.erl
View File

@ -1,7 +1,6 @@
% @doc % @doc
% library of truth tables % library of truth tables
-module(wfc_ttfuns). -module(wfc_ttfuns).
-vsn("0.2.0").
-export_type([ -export_type([
bit/0, bit/0,

1
src/wfc_utils.erl
View File

@ -1,6 +1,5 @@
% @doc misc utility functions % @doc misc utility functions
-module(wfc_utils). -module(wfc_utils).
-vsn("0.2.0").
-export([err/2, str/2, emsg/2]). -export([err/2, str/2, emsg/2]).

1
src/wfc_word.erl
View File

@ -13,7 +13,6 @@
% %
% operations assume all inputs are valid % operations assume all inputs are valid
-module(wfc_word). -module(wfc_word).
-vsn("0.2.0").
-export_type([ -export_type([
word/0 word/0

694
src/zj.erl Normal file
View File

@ -0,0 +1,694 @@
%%% @doc
%%% ZJ: The tiny JSON parser
%%%
%%% This module exports four functions and accepts no options.
%%% @end
-module(zj).
-vsn("1.1.2").
-author("Craig Everett <zxq9@zxq9.com>").
-copyright("Craig Everett <zxq9@zxq9.com>").
-license("MIT").
-export([encode/1, decode/1,
binary_encode/1, binary_decode/1]).
-export_type([value/0, bin_value/0]).
-type value() :: string()
| number()
| true
| false
| undefined
| [value()]
| #{string() := value()}.
-type bin_value() :: binary()
| number()
| true
| false
| undefined
| [bin_value()]
| #{binary() := bin_value()}.
%%% Character constants
-define(BKSPC, 16#08).
-define(H_TAB, 16#09).
-define(NEW_L, 16#0A).
-define(FORMF, 16#0C).
-define(CAR_R, 16#0D).
-define(SPACE, 16#20).
%%% Interface Functions
-spec encode(term()) -> string().
%% @doc
%% Take any convertable Erlang term and convert it to a JSON string.
%%
%% As JSON can only satirically be referred to as "a serialization format", it is
%% almost impossible to map any interesting data between Erlang (or any other language)
%% and JSON. For example, tuples do not exist in JSON, so converting an Erlang tuple
%% turns it into a list (a JSON array). Atoms also do not exist, so atoms other than
%% the ternay logic values `true', `false' and `null' become strings (those three
%% remain as atoms, with the added detail that JSON `null' maps to Erlang
%% `undefined').
%%
%% Unless care is taken to pick types that JSON can accurately express (integers,
%% floats, strings, maps, lists, ternary logic atoms) it is not possible to guarantee
%% (or even reasonable to expect) that `Term == decode(encode(Term))' will be true.
%%
%% This function crashes when it fails. Things that will cause a crash are trying to
%% convert non-UTF-8 binaries to strings, use non-string values as object keys,
%% encode an unaligned bitstring, etc.
%%
%% Note that Erlang terms are converted as type primitives, meaning that compound
%% functional structures like GB-trees, dicts, sets, etc. will wind up having their
%% underlying structures converted as-is which is almost never what you want. It is
%% usually best to reduce compound values down to primitives (lists or maps) before
%% running encode.
%%
%% The only unsupported Erlang pritmitive is bitstrings. Care has NOT been taken to
%% ensure separation between actual binary data and binaries that are supposed to be
%% interpreted as strings. The same is true of deep list data: it just comes out raw
%% unless you flatten or convert it to a utf8 string with the unicode module.
%%
%% NOTE: If you need a serialization format that is less ambiguous and expresses more
%% types consider using BERT (language-independent implementations of Erlang external
%% binary format) instead: http://bert-rpc.org
encode(true) -> "true";
encode(false) -> "false";
encode(undefined) -> "null";
encode([]) -> "[]";
encode(T) when is_atom(T) -> quote(atom_to_list(T));
encode(T) when is_float(T) -> float_to_list(T);
encode(T) when is_integer(T) -> integer_to_list(T);
encode(T) when is_pid(T) -> quote(pid_to_list(T));
encode(T) when is_port(T) -> quote(port_to_list(T));
encode(T) when is_function(T) -> quote(erlang:fun_to_list(T));
encode(T) when is_reference(T) -> quote(ref_to_list(T));
encode(T) -> unicode:characters_to_list(encode_value(T)).
-spec decode(Stream) -> Result
when Stream :: unicode:chardata(),
Result :: {ok, value()}
| {error, Parsed, Remainder}
| {incomplete, Parsed, Remainder},
Parsed :: value(),
Remainder :: unicode:chardata()
| unicode:external_chardata()
| binary().
%% @doc
%% Take any IO data acceptable to the unicode module and return a parsed data structure.
%% In the event of a parsing error whatever part of the structure could be successfully
%% parsed will be returned along with the remainder of the string. Note that the string
%% remainder may have been changed to a different form by unicode:characters_to_list/1.
%% If the unicode library itself runs into a problem performing the initial conversion
%% its error return (`error' or `incomplete') will be returned directly.
decode(Stream) ->
case unicode:characters_to_list(Stream) of
E when is_tuple(E) -> E;
[16#FEFF | String] -> parse(seek(String));
String -> parse(seek(String))
end.
-spec binary_encode(term()) -> binary().
%% @doc
%% A strict encoding routine that works very similarly to `encode/1' but with a few
%% differences:
%% ```
%% - Lists and Strings are firmly separated:
%% ALL lists are lists of discrete values, never strings.
%% ALL binaries are always UTF-8 strings.
%% An Erlang string or io_list will be encoded as JSON array.
%% - This function generates a UTF-8 binary, not a list.
%% - The burden is on the user to ensure that io_lists are collapsed to unicode
%% binaries via `unicode:characters_to_binary/1' before passing in string values.
%% - Erlang strings (lists) are still accepted as map/object keys.
%% '''
%%
%% NOTE:
%% Most cases are better served by `encode/1', as most code deals in strings and not
%% arrays of integer values.
%%
%% Using this function requires a little bit more work up front (because ununified
%% io_list() data will always be interpreted as a JSON array), but provides a way to
%% reliably generate lists or strings in an unambiguous way in the special case where
%% your code is generating both strings and lists of integer values that may overlap
%% with valid UTF-8 codepoint values.
binary_encode(true) -> <<"true">>;
binary_encode(false) -> <<"false">>;
binary_encode(undefined) -> <<"null">>;
binary_encode(T) when is_atom(T) -> <<"\"", (atom_to_binary(T, utf8))/binary, "\"">>;
binary_encode(T) when is_float(T) -> float_to_binary(T);
binary_encode(T) when is_integer(T) -> integer_to_binary(T);
binary_encode(T) when is_pid(T) -> <<"\"", (list_to_binary(pid_to_list(T)))/binary, "\"">>;
binary_encode(T) when is_port(T) -> <<"\"", (list_to_binary(port_to_list(T)))/binary, "\"">>;
binary_encode(T) when is_function(T) -> <<"\"", (list_to_binary(erlang:fun_to_list(T)))/binary, "\"">>;
binary_encode(T) when is_reference(T) -> <<"\"", (list_to_binary(ref_to_list(T)))/binary, "\"">>;
binary_encode(T) -> unicode:characters_to_binary(b_encode_value(T)).
-spec binary_decode(Stream) -> Result
when Stream :: unicode:chardata(),
Result :: {ok, bin_value()}
| {error, Parsed, Remainder}
| {incomplete, Parsed, Remainder},
Parsed :: bin_value(),
Remainder :: binary().
%% @doc
%% Almost identical in behavior to `decode/1' except this returns strings as binaries
%% and arrays of integers as Erlang lists (which may also be valid strings if the
%% values are valid UTF-8 codepoints).
%%
%% NOTE:
%% This function returns map keys as binaries
binary_decode(Stream) ->
case b_decode(Stream) of
{error, Part, Rest} -> {error, Part, unicode:characters_to_binary(Rest)};
Result -> Result
end.
%%% Encoding Functions
encode_value(true) -> "true";
encode_value(false) -> "false";
encode_value(undefined) -> "null";
encode_value(T) when is_atom(T) -> quote(atom_to_list(T));
encode_value(T) when is_float(T) -> float_to_list(T);
encode_value(T) when is_integer(T) -> integer_to_list(T);
encode_value(T) when is_binary(T) -> maybe_string(T);
encode_value(T) when is_list(T) -> maybe_array(T);
encode_value(T) when is_map(T) -> pack_object(T);
encode_value(T) when is_tuple(T) -> pack_array(tuple_to_list(T));
encode_value(T) when is_pid(T) -> quote(pid_to_list(T));
encode_value(T) when is_port(T) -> quote(port_to_list(T));
encode_value(T) when is_function(T) -> quote(erlang:fun_to_list(T));
encode_value(T) when is_reference(T) -> quote(ref_to_list(T)).
maybe_string(T) ->
L = binary_to_list(T),
true = io_lib:printable_unicode_list(L),
quote(L).
maybe_array(T) ->
case io_lib:printable_unicode_list(T) of
true -> quote(T);
false -> pack_array(T)
end.
quote(T) -> [$" | escape(T)].
escape([]) -> [$"];
escape([$\b | T]) -> [$\\, $b | escape(T)];
escape([$\f | T]) -> [$\\, $f | escape(T)];
escape([$\n | T]) -> [$\\, $n | escape(T)];
escape([$\r | T]) -> [$\\, $r | escape(T)];
escape([$\t | T]) -> [$\\, $t | escape(T)];
escape([$\" | T]) -> [$\\, $" | escape(T)];
escape([$\\ | T]) -> [$\\, $\\ | escape(T)];
escape([H | T]) -> [H | escape(T)].
pack_array([]) -> "[]";
pack_array([H | []]) -> [$[, encode_value(H), $]];
pack_array([H | T]) -> [$[, encode_value(H), $,, encode_array(T), $]].
encode_array([H | []]) -> encode_value(H);
encode_array([H | T]) -> [encode_value(H), $,, encode_array(T)].
pack_object(M) ->
case maps:to_list(M) of
[] ->
"{}";
[{K, V} | T] when is_list(K) ->
true = io_lib:printable_unicode_list(K),
Init = [$", K, $", $:, encode_value(V)],
[${, lists:foldl(fun pack_object/2, Init, T), $}];
[{K, V} | T] when is_binary(K) ->
Key = unicode:characters_to_list(K),
true = io_lib:printable_unicode_list(Key),
Init = [$", Key, $", $:, encode_value(V)],
[${, lists:foldl(fun pack_object/2, Init, T), $}];
[{K, V} | T] when is_float(K) ->
Key = float_to_list(K),
Init = [$", Key, $", $:, encode_value(V)],
[${, lists:foldl(fun pack_object/2, Init, T), $}];
[{K, V} | T] when is_integer(K) ->
Key = integer_to_list(K),
Init = [$", Key, $", $:, encode_value(V)],
[${, lists:foldl(fun pack_object/2, Init, T), $}];
[{K, V} | T] when is_atom(K) ->
Init = [$", atom_to_list(K), $", $:, encode_value(V)],
[${, lists:foldl(fun pack_object/2, Init, T), $}]
end.
pack_object({K, V}, L) when is_list(K) ->
true = io_lib:printable_unicode_list(K),
[$", K, $", $:, encode_value(V), $, | L];
pack_object({K, V}, L) when is_binary(K) ->
Key = unicode:characters_to_list(K),
true = io_lib:printable_unicode_list(Key),
[$", Key, $", $:, encode_value(V), $, | L];
pack_object({K, V}, L) when is_float(K) ->
Key = float_to_list(K),
[$", Key, $", $:, encode_value(V), $, | L];
pack_object({K, V}, L) when is_integer(K) ->
Key = integer_to_list(K),
[$", Key, $", $:, encode_value(V), $, | L];
pack_object({K, V}, L) when is_atom(K) ->
[$", atom_to_list(K), $", $:, encode_value(V), $, | L].
b_encode_value(true) -> <<"true">>;
b_encode_value(false) -> <<"false">>;
b_encode_value(undefined) -> <<"null">>;
b_encode_value(T) when is_atom(T) -> [$", atom_to_binary(T, utf8), $"];
b_encode_value(T) when is_float(T) -> float_to_binary(T);
b_encode_value(T) when is_integer(T) -> integer_to_binary(T);
b_encode_value(T) when is_binary(T) -> [$", b_maybe_string(T), $"];
b_encode_value(T) when is_list(T) -> b_pack_array(T);
b_encode_value(T) when is_map(T) -> b_pack_object(T);
b_encode_value(T) when is_tuple(T) -> b_pack_array(tuple_to_list(T));
b_encode_value(T) when is_pid(T) -> [$", list_to_binary(pid_to_list(T)), $"];
b_encode_value(T) when is_port(T) -> [$", list_to_binary(port_to_list(T)), $"];
b_encode_value(T) when is_function(T) -> [$", list_to_binary(erlang:fun_to_list(T)), $"];
b_encode_value(T) when is_reference(T) -> [$", list_to_binary(ref_to_list(T)), $"].
b_maybe_string(T) ->
S = unicode:characters_to_binary(T),
true = is_binary(S),
S.
b_pack_array([]) -> "[]";
b_pack_array([H | []]) -> [$[, b_encode_value(H), $]];
b_pack_array([H | T]) -> [$[, b_encode_value(H), $,, b_encode_array(T), $]].
b_encode_array([H | []]) -> b_encode_value(H);
b_encode_array([H | T]) -> [b_encode_value(H), $,, b_encode_array(T)].
b_pack_object(M) ->
case maps:to_list(M) of
[] ->
"{}";
[{K, V} | T] when is_list(K) ->
true = io_lib:printable_unicode_list(K),
Init = [$", K, $", $:, b_encode_value(V)],
[${, lists:foldl(fun b_pack_object/2, Init, T), $}];
[{K, V} | T] when is_binary(K) ->
true = io_lib:printable_unicode_list(unicode:characters_to_list(K)),
Init = [$", K, $", $:, b_encode_value(V)],
[${, lists:foldl(fun b_pack_object/2, Init, T), $}];
[{K, V} | T] when is_float(K) ->
Key = float_to_list(K),
Init = [$", Key, $", $:, b_encode_value(V)],
[${, lists:foldl(fun b_pack_object/2, Init, T), $}];
[{K, V} | T] when is_integer(K) ->
Key = integer_to_list(K),
Init = [$", Key, $", $:, b_encode_value(V)],
[${, lists:foldl(fun b_pack_object/2, Init, T), $}];
[{K, V} | T] when is_atom(K) ->
Init = [$", atom_to_binary(K, utf8), $", $:, b_encode_value(V)],
[${, lists:foldl(fun b_pack_object/2, Init, T), $}]
end.
b_pack_object({K, V}, L) when is_list(K) ->
true = io_lib:printable_unicode_list(K),
[$", K, $", $:, b_encode_value(V), $, | L];
b_pack_object({K, V}, L) when is_binary(K) ->
true = io_lib:printable_unicode_list(unicode:characters_to_list(K)),
[$", K, $", $:, b_encode_value(V), $, | L];
b_pack_object({K, V}, L) when is_float(K) ->
Key = float_to_list(K),
[$", Key, $", $:, b_encode_value(V), $, | L];
b_pack_object({K, V}, L) when is_integer(K) ->
Key = integer_to_list(K),
[$", Key, $", $:, b_encode_value(V), $, | L];
b_pack_object({K, V}, L) when is_atom(K) ->
[$", atom_to_list(K), $", $:, b_encode_value(V), $, | L].
%%% Decode Functions
-spec parse(Stream) -> Result
when Stream :: string(),
Result :: {ok, value()}
| {error, Extracted :: value(), Remaining :: string()}.
%% @private
%% The top-level dispatcher. This packages the top level value (or top-level error)
%% for return to the caller. A very similar function (value/1) is used for inner
%% values.
parse([${ | Rest]) ->
case object(Rest) of
{ok, Object, ""} -> {ok, Object};
{ok, Object, More} -> polish(Object, seek(More));
Error -> Error
end;
parse([$[ | Rest]) ->
case array(Rest) of
{ok, Array, ""} -> {ok, Array};
{ok, Array, More} -> polish(Array, seek(More));
Error -> Error
end;
parse([$" | Rest]) ->
case string(Rest) of
{ok, String, ""} -> {ok, String};
{ok, String, More} -> polish(String, seek(More));
Error -> Error
end;
parse([I | Rest]) when I == $-; $0 =< I, I =< $9 ->
case number_int(Rest, [I]) of
{ok, Number, ""} -> {ok, Number};
{ok, Number, More} -> polish(Number, seek(More));
Error -> Error
end;
parse("true" ++ More) ->
polish(true, seek(More));
parse("false" ++ More) ->
polish(false, seek(More));
parse("null" ++ More) ->
polish(undefined, seek(More));
parse(Other) ->
{error, [], Other}.
polish(Value, "") -> {ok, Value};
polish(Value, More) -> {error, Value, More}.
value([${ | Rest]) -> object(Rest);
value([$[ | Rest]) -> array(Rest);
value([$" | Rest]) -> string(Rest);
value([I | Rest]) when I == $-; $0 =< I, I =< $9 -> number_int(Rest, [I]);
value("true" ++ Rest) -> {ok, true, Rest};
value("false" ++ Rest) -> {ok, false, Rest};
value("null" ++ Rest) -> {ok, undefined, Rest};
value(_) -> error.
object([$} | Rest]) -> {ok, #{}, Rest};
object(String) -> object(seek(String), #{}).
object([$} | Rest], Map) ->
{ok, Map, Rest};
object([$" | Rest], Map) ->
case string(Rest) of
{ok, Key, Remainder} -> object_value(seek(Remainder), Key, Map);
{error, _, _} -> {error, Map, Rest}
end;
object(Rest, Map) ->
{error, Map, Rest}.
object_value([$: | Rest], Key, Map) ->
object_value_parse(seek(Rest), Key, Map);
object_value(Rest, Key, Map) ->
{error, maps:put(Key, undefined, Map), Rest}.
object_value_parse(String, Key, Map) ->
case value(String) of
{ok, Value, Rest} -> object_next(seek(Rest), maps:put(Key, Value, Map));
{error, Value, Rest} -> {error, maps:put(Key, Value, Map), Rest};
error -> {error, Map, String}
end.
object_next([$, | Rest], Map) -> object(seek(Rest), Map);
object_next([$} | Rest], Map) -> {ok, Map, seek(Rest)};
object_next(Rest, Map) -> {error, Map, Rest}.
array([$] | Rest]) -> {ok, [], Rest};
array(String) -> array(seek(String), []).
array([$] | Rest], List) ->
{ok, lists:reverse(List), seek(Rest)};
array(String, List) ->
case value(String) of
{ok, Value, Rest} -> array_next(seek(Rest), [Value | List]);
{error, Value, Rest} -> {error, lists:reverse([Value | List]), Rest};
error -> {error, lists:reverse(List), String}
end.
array_next([$, | Rest], List) -> array(seek(Rest), List);
array_next([$] | Rest], List) -> {ok, lists:reverse(List), seek(Rest)};
array_next(Rest, List) -> {error, lists:reverse(List), Rest}.
string(Stream) -> string(Stream, "").
string([$" | Rest], String) ->
{ok, lists:reverse(String), Rest};
string([$\\, $" | Rest], String) ->
string(Rest, [$" | String]);
string([$\\, $\\ | Rest], String) ->
string(Rest, [$\\ | String]);
string([$\\, $b | Rest], String) ->
string(Rest, [?BKSPC | String]);
string([$\\, $t | Rest], String) ->
string(Rest, [?H_TAB | String]);
string([$\\, $n | Rest], String) ->
string(Rest, [?NEW_L | String]);
string([$\\, $f | Rest], String) ->
string(Rest, [?FORMF | String]);
string([$\\, $r | Rest], String) ->
string(Rest, [?CAR_R | String]);
string([$\\, $u, A, B, C, D | Rest], String)
when (($0 =< A andalso A =< $9) or ($A =< A andalso A =< $F) or ($a =< A andalso A =< $f))
and (($0 =< B andalso B =< $9) or ($A =< B andalso B =< $F) or ($a =< B andalso B =< $f))
and (($0 =< C andalso C =< $9) or ($A =< C andalso C =< $F) or ($a =< C andalso C =< $f))
and (($0 =< D andalso D =< $9) or ($A =< D andalso D =< $F) or ($a =< D andalso D =< $f)) ->
Char = list_to_integer([A, B, C, D], 16),
string(Rest, [Char | String]);
string(Stream = [$\\, $u | _], String) ->
{error, String, Stream};
string([$\\, Char | Rest], String)
when Char == 16#20;
Char == 16#21;
16#23 =< Char, Char =< 16#5B;
16#5D =< Char, Char =< 16#10FFFF ->
string(Rest, [$\\, Char | String]);
string([Char | Rest], String)
when Char == 16#20;
Char == 16#21;
16#23 =< Char, Char =< 16#5B;
16#5D =< Char, Char =< 16#10FFFF ->
string(Rest, [Char | String]);
string(Rest, String) ->
{error, lists:reverse(String), Rest}.
number_int([$. | Rest], String) ->
number_float(Rest, [$. | String]);
number_int([$e, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $+, $e, $0, $. | String]);
number_int([$E, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $+, $e, $0, $. | String]);
number_int([$e, $+, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $+, $e, $0, $. | String]);
number_int([$E, $+, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $+, $e, $0, $. | String]);
number_int([$e, $-, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $-, $e, $0, $. | String]);
number_int([$E, $-, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $-, $e, $0, $. | String]);
number_int([Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_int(Rest, [Char | String]);
number_int(Rest, "-") ->
{error, "", [$- | Rest]};
number_int(Rest, String) ->
{ok, list_to_integer(lists:reverse(String)), seek(Rest)}.
number_float([Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float(Rest, [Char | String]);
number_float([$E, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $+, $e | String]);
number_float([$e, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $+, $e | String]);
number_float([$E, $+, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $+, $e | String]);
number_float([$e, $+, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $+, $e | String]);
number_float([$E, $-, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $-, $e | String]);
number_float([$e, $-, Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char, $-, $e | String]);
number_float(Rest, String) ->
Target = lists:reverse(String),
try
Number = list_to_float(Target),
{ok, Number, seek(Rest)}
catch
error:badarg -> {error, "", Target ++ Rest}
end.
number_float_exp([Char | Rest], String) when $0 =< Char, Char =< $9 ->
number_float_exp(Rest, [Char | String]);
number_float_exp(Rest, String) ->
Target = lists:reverse(String),
try
Number = list_to_float(Target),
{ok, Number, seek(Rest)}
catch
error:badarg -> {error, "", Target ++ Rest}
end.
seek([?H_TAB | Rest]) -> seek(Rest);
seek([?NEW_L | Rest]) -> seek(Rest);
seek([?CAR_R | Rest]) -> seek(Rest);
seek([?SPACE | Rest]) -> seek(Rest);
seek(String) -> String.
b_decode(Stream) ->
case unicode:characters_to_list(Stream) of
E when is_tuple(E) -> E;
[16#FEFF | String] -> binary_parse(seek(String));
String -> binary_parse(seek(String))
end.
-spec binary_parse(Stream) -> Result
when Stream :: string(),
Result :: {ok, bin_value()}
| {error, Extracted :: bin_value(), Remaining :: binary()}.
%% @private
%% The top-level dispatcher. This packages the top level value (or top-level error)
%% for return to the caller. A very similar function (b_value/1) is used for inner
%% values.
binary_parse([${ | Rest]) ->
case b_object(Rest) of
{ok, Object, ""} -> {ok, Object};
{ok, Object, More} -> b_polish(Object, seek(More));
Error -> Error
end;
binary_parse([$[ | Rest]) ->
case b_array(Rest) of
{ok, Array, ""} -> {ok, Array};
{ok, Array, More} -> b_polish(Array, seek(More));
Error -> Error
end;
binary_parse([$" | Rest]) ->
case string(Rest) of
{ok, String, ""} ->
case unicode:characters_to_binary(String) of
E when is_tuple(E) -> E;
Result -> {ok, Result}
end;
{ok, String, More} ->
case unicode:characters_to_binary(String) of
E when is_tuple(E) -> E;
Result -> b_polish(Result, seek(More))
end;
Error ->
Error
end;
binary_parse([I | Rest]) when I == $-; $0 =< I, I =< $9 ->
case number_int(Rest, [I]) of
{ok, Number, ""} -> {ok, Number};
{ok, Number, More} -> b_polish(Number, seek(More));
Error -> Error
end;
binary_parse("true" ++ More) ->
b_polish(true, seek(More));
binary_parse("false" ++ More) ->
b_polish(false, seek(More));
binary_parse("null" ++ More) ->
b_polish(undefined, seek(More));
binary_parse(Other) ->
{error, [], Other}.
b_polish(Value, "") -> {ok, Value};
b_polish(Value, More) -> {error, Value, More}.
b_value([${ | Rest]) -> b_object(Rest);
b_value([$[ | Rest]) -> b_array(Rest);
b_value([$" | Rest]) -> b_string(Rest);
b_value([I | Rest]) when I == $-; $0 =< I, I =< $9 -> number_int(Rest, [I]);
b_value("true" ++ Rest) -> {ok, true, Rest};
b_value("false" ++ Rest) -> {ok, false, Rest};
b_value("null" ++ Rest) -> {ok, undefined, Rest};
b_value(_) -> error.
b_string(Stream) ->
case string(Stream) of
{ok, String, More} ->
case unicode:characters_to_binary(String) of
E when is_tuple(E) -> E;
Result -> {ok, Result, More}
end;
Error -> Error
end.
b_object([$} | Rest]) -> {ok, #{}, Rest};
b_object(String) -> b_object(seek(String), #{}).
b_object([$} | Rest], Map) ->
{ok, Map, Rest};
b_object([$" | Rest], Map) ->
case string(Rest) of
{ok, Key, Remainder} ->
b_object_value(seek(Remainder), unicode:characters_to_binary(Key), Map);
{error, _, _} ->
{error, Map, Rest}
end;
b_object(Rest, Map) ->
{error, Map, Rest}.
b_object_value([$: | Rest], Key, Map) -> b_object_value_parse(seek(Rest), Key, Map);
b_object_value(Rest, Key, Map) -> {error, maps:put(Key, undefined, Map), Rest}.
b_object_value_parse(String, Key, Map) ->
case b_value(String) of
{ok, Value, Rest} -> b_object_next(seek(Rest), maps:put(Key, Value, Map));
{error, Value, Rest} -> {error, maps:put(Key, Value, Map), Rest};
error -> {error, Map, String}
end.
b_object_next([$, | Rest], Map) -> b_object(seek(Rest), Map);
b_object_next([$} | Rest], Map) -> {ok, Map, seek(Rest)};
b_object_next(Rest, Map) -> {error, Map, Rest}.
b_array([$] | Rest]) -> {ok, [], Rest};
b_array(String) -> b_array(seek(String), []).
b_array([$] | Rest], List) ->
{ok, lists:reverse(List), seek(Rest)};
b_array(String, List) ->
case b_value(String) of
{ok, Value, Rest} -> b_array_next(seek(Rest), [Value | List]);
{error, Value, Rest} -> {error, lists:reverse([Value | List]), Rest};
error -> {error, lists:reverse(List), String}
end.
b_array_next([$, | Rest], List) -> b_array(seek(Rest), List);
b_array_next([$] | Rest], List) -> {ok, lists:reverse(List), seek(Rest)};
b_array_next(Rest, List) -> {error, lists:reverse(List), Rest}.

6
zomp.meta
View File

@ -1,11 +1,11 @@
{name,"front end web development lab"}. {name,"front end web development lab"}.
{type,app}. {type,app}.
{modules,[]}. {modules,[]}.
{author,"Peter Harpending"}.
{prefix,"fd"}. {prefix,"fd"}.
{desc,"Front End Web Dev in Erlang stuff"}. {desc,"Front End Web Dev in Erlang stuff"}.
{package_id,{"otpr","fewd",{0,2,0}}}. {author,"Peter Harpending"}.
{deps,[{"otpr","zj",{1,1,2}}]}. {package_id,{"otpr","fewd",{0,1,0}}}.
{deps,[]}.
{key_name,none}. {key_name,none}.
{a_email,"peterharpending@qpq.swiss"}. {a_email,"peterharpending@qpq.swiss"}.
{c_email,"peterharpending@qpq.swiss"}. {c_email,"peterharpending@qpq.swiss"}.