src/tool/world.bend

ezx@1.11.0.0 · 232 lines · 37 definitions

1# tool/world: what `ez tool run`, `install` and `upgrade` read. The act and
2# the target they were given; the directory they run in (`here`), which a
3# relative cache root is taken from; the variables that place the cache and
4# the link (`EZ_TOOL_BIN`, `XDG_BIN_HOME`, `XDG_CACHE_HOME`, `HOME`, `PATH`);
5# the bend on the PATH, as its banner's first line; the file `--entry` names,
6# "" when it names none; the project's ledger and lock, None when there is
7# none; and the answers to the questions the planner (tool/plan.bend)
8# asked. `ez tool sync` reads only the ledger and the lock.
9#
10# A question is a file's text, whether a binary is there, what git says of a
11# local path, or one of the upgrade's (lock/up.bend): `Head` for the commit a
12# remote's HEAD names, and `Clone` for the checkout at a rev with every
13# file's text. The upgrade's are answered by the lock's interpreter and kept
14# apart, in `ups`, so its lookups serve here as they are.
15#
16# Everything else here is a projection: what a World says, read one way.
17import Base
18import ezx@1.11.0.0/src/lock/up.bend as Up
19import ezx@1.11.0.0/src/ledger/manifest.bend as M
20import ezx@1.11.0.0/src/pkg/path.bend as P
21
22# what the command does with the binary once it is current: `Run` starts it
23# with these words, `Install` and `Upgrade` link it onto PATH
24type Act is Data:
25  Run{args: List<&2, String>}
26  Install{}
27  Upgrade{}
28
29# the variables the command reads, each "" when it is unset
30type Env is Data:
31  Env{tool_bin: String, xdg_bin: String, xdg_cache: String, home: String, path: String}
32
33# a question the planner asks that is not git's about a remote
34type Ask is Data:
35  Read{path: String}      # a file's text, None when there is none
36  Exec{path: String}      # whether a file is there and executable
37  Locate{path: String}    # what git says of a local path
38
39# the answer to one: a file's text, whether a binary is there, or what git
40# said of a path: its real path, the top of the checkout holding it, the
41# commit HEAD names, and whether `git status` answered and what it printed.
42# A path that has no real path, or a question IO could not answer, is a miss.
43type Answer is Data:
44  Plain{got: Maybe<&2, String>}
45  Is{yes: Bool}
46  Located{abs: String, top: String, head: String, ok: Bool, status: String}
47  Miss{why: String}
48
49# one question, answered
50type Reply is Data:
51  Reply{ask: Ask, answer: Answer}
52
53# everything `ez tool run`, `install` and `upgrade` read
54type World is Data:
55  World{act: Act, target: String, want: String, here: String, env: Env, bend: String,
56    ledger: Maybe<&2, String>, lock: Maybe<&2, String>, replies: List<&2, Reply>,
57    ups: List<&2, Up.Reply>}
58
59# the act
60def act(world: World) -> Act:
61  World{a, _t, _want, _here, _env, _bend, _ledger, _lock, _rs, _ups} = world
62  a
63
64# the target asked for
65def target(world: World) -> String:
66  World{_a, t, _want, _here, _env, _bend, _ledger, _lock, _rs, _ups} = world
67  t
68
69# the file `--entry` names, "" when it names none
70def want(world: World) -> String:
71  World{_a, _t, w, _here, _env, _bend, _ledger, _lock, _rs, _ups} = world
72  w
73
74# the directory ez runs in
75def here(world: World) -> String:
76  World{_a, _t, _want, h, _env, _bend, _ledger, _lock, _rs, _ups} = world
77  h
78
79# the variables
80def env(world: World) -> Env:
81  World{_a, _t, _want, _here, e, _bend, _ledger, _lock, _rs, _ups} = world
82  e
83
84# the bend on the PATH, "" when it did not answer
85def bend(world: World) -> String:
86  World{_a, _t, _want, _here, _env, b, _ledger, _lock, _rs, _ups} = world
87  b
88
89# the project's ez.toml, None when there is none
90def ledger(world: World) -> Maybe<&2, String>:
91  World{_a, _t, _want, _here, _env, _bend, l, _lock, _rs, _ups} = world
92  l
93
94# the project's ez.lock.toml, None when there is none
95def lock(world: World) -> Maybe<&2, String>:
96  World{_a, _t, _want, _here, _env, _bend, _ledger, l, _rs, _ups} = world
97  l
98
99# every question of ours answered so far
100def replies(world: World) -> List<&2, Reply>:
101  World{_a, _t, _want, _here, _env, _bend, _ledger, _lock, rs, _ups} = world
102  rs
103
104# every one of the upgrade's questions answered so far
105def ups(world: World) -> List<&2, Up.Reply>:
106  World{_a, _t, _want, _here, _env, _bend, _ledger, _lock, _rs, us} = world
107  us
108
109def env.tool_bin(vars: Env) -> String:
110  Env{b, _x, _c, _h, _p} = vars
111  b
112
113def env.xdg_bin(vars: Env) -> String:
114  Env{_b, x, _c, _h, _p} = vars
115  x
116
117def env.xdg_cache(vars: Env) -> String:
118  Env{_b, _x, c, _h, _p} = vars
119  c
120
121def env.home(vars: Env) -> String:
122  Env{_b, _x, _c, h, _p} = vars
123  h
124
125def env.path(vars: Env) -> String:
126  Env{_b, _x, _c, _h, p} = vars
127  p
128
129# HOME
130def home(world: World) -> String:
131  env.home(env(world))
132
133# ---------------------------------------------------------------------------
134# where things go
135
136# `~/.local/bin`, when there is a HOME
137def bin.home(+home: String) -> Maybe<&2, String>:
138  Bool.pick(Maybe<&2, String>, String.is_empty(home), None{}, Some{home ++ "/.local/bin"})
139
140# `$XDG_BIN_HOME` when it is set, otherwise the one above
141def bin.xdg(+xdg: String, +home: String) -> Maybe<&2, String>:
142  Bool.pick(Maybe<&2, String>, String.is_empty(xdg), bin.home(home), Some{xdg})
143
144# where an installed command is linked: `$EZ_TOOL_BIN` when it is set,
145# otherwise `$XDG_BIN_HOME`, otherwise `$HOME/.local/bin`, an empty value
146# counting as unset; None when all three are empty (EZ-TOOL-1)
147def bin.dir(+ez: String, +xdg: String, +home: String) -> Maybe<&2, String>:
148  Bool.pick(Maybe<&2, String>, String.is_empty(ez), bin.xdg(xdg, home), Some{ez})
149
150# the link directory of a World's variables
151def bin.of(vars: Env) -> Maybe<&2, String>:
152  Env{+b, +x, _c, +h, _p} = vars
153  bin.dir(b, x, h)
154
155# the cache root: `$XDG_CACHE_HOME/ez/tool`, otherwise `$HOME/.cache/ez/tool`,
156# taken from where ez runs when it is relative, so every path the plan names
157# is absolute; None when neither variable is set
158def cache.home(+here: String, +home: String) -> Maybe<&2, String>:
159  Bool.pick(Maybe<&2, String>, String.is_empty(home), None{},
160    Some{P.anchor(here, home) ++ "/.cache/ez/tool"})
161
162def cache.dir(+here: String, +xdg: String, +home: String) -> Maybe<&2, String>:
163  Bool.pick(Maybe<&2, String>, String.is_empty(xdg), cache.home(here, home),
164    Some{P.anchor(here, xdg) ++ "/ez/tool"})
165
166# the cache root of a World
167def cache.of(world: World) -> Maybe<&2, String>:
168  World{_a, _t, _want, +here, vars, _bend, _ledger, _lock, _rs, _ups} = world
169  Env{_b, _x, +c, +h, _p} = vars
170  cache.dir(here, c, h)
171
172# a Maybe's text, "" for none
173def text.or(got: Maybe<&2, String>) -> String:
174  match got:
175    case None{}:
176      ""
177    case Some{t}:
178      t
179
180# ---------------------------------------------------------------------------
181# the project
182
183# the project's ledger as read. A project with no ez.toml pins nothing, so
184# every target is a free one; one that does not parse is its own refusal.
185def project.of(got: Maybe<&2, String>) -> M.Read:
186  match got:
187    case None{}:
188      M.Good{M.Manifest{"", "", "", "", "", "", [], []}}
189    case Some{text}:
190      M.parse(text)
191
192# the project's ledger as read
193def project(world: World) -> M.Read:
194  project.of(ledger(world))
195
196# ---------------------------------------------------------------------------
197# answers
198
199# the key a question is looked up by
200def key(ask: Ask) -> String:
201  match ask:
202    case Read{path}:
203      "read\n" ++ path
204    case Exec{path}:
205      "exec\n" ++ path
206    case Locate{path}:
207      "locate\n" ++ path
208
209# an answer looked up, or none yet
210type Heard is Data:
211  Heard{answer: Answer}
212  Open{}
213
214# this answer when it is the question's, otherwise the rest's
215def look.step(hit: Bool, answer: Answer, rest: Unit -> Heard) -> Heard:
216  match hit:
217    case True{}:
218      Heard{answer}
219    case False{}:
220      rest(Unit{})
221
222# the first answer given to a question
223def look(rs: List<&2, Reply>, +want: String) -> Heard:
224  match rs:
225    case []:
226      Open{}
227    case Reply{ask, answer} <> t:
228      look.step(String.eq(key(ask), want), answer, _u => look(t, want))
229
230# the answer to a question, or none yet
231def heard(+world: World, ask: Ask) -> Heard:
232  look(replies(world), key(ask))