src/add/hub.bend

ezx@1.11.0.0 · 467 lines · 54 definitions

1# add/hub: `ez add <name>@<version>` as a pure planner, for a target bend
2# reads as a hub package's name (`Tgt.aim`). It reads the same World as the
3# git planner (add/world.bend), and asks the lock's own questions of the hub
4# the ledger names (lock/world.bend): what the name names (`W.Name`), then
5# that package's manifest and files (`W.Pkg`). Their answers are the World's
6# `hubs`.
7#
8# Before it asks anything the planner refuses what needs no answer: no
9# ledger, one that does not parse, a ref and an entry both given (a name pins
10# its version, so the word after it is the entry), and a key the ledger
11# alone refuses (`Named.hub.why`). Then it asks at most two rounds: the name,
12# then the package it names. The hub's answer must be a `0x` name, and the
13# package is judged as `ez lock` judges a hub package (`W.hub.how`): its
14# manifest hashes to that name, no path leaves it, each file hashes to its
15# sum, and the files hash to the name (EZ-HASH-3).
16#
17# With the package in hand, the entry is the one given, which the package
18# must hold, else its `main.bend`, else its first top-level `.bend` file in
19# manifest order, else none. The key is `Named.hub.key`'s: `--rename`, else
20# the key the ledger gives this name part, else the name part itself. The
21# plan of an add that succeeds, in order: the tree laid under `$BEND_LIB`;
22# the name's file, `$BEND_LIB/names/<name>@<version>`, so bend reads the name
23# without asking the hub; ez.toml written with `[deps.<key>]` holding `hub`
24# and `hash`; `.gitignore` when the allowlist changes; and the lines a person
25# is told, the hash the name names and, when there is an entry, the import
26# line. A refusal has no effect at all. `ez add` writes no lock, for a name
27# as for a git package: the next `ez lock` reads the name from ez.toml and
28# asks the hub nothing (EZ-HUB-2).
29import Base
30import ezx@1.11.0.0/src/add/world.bend as A
31import ezx@1.11.0.0/src/lock/plan.bend as P
32import ezx@1.11.0.0/src/lock/world.bend as W
33import ezx@1.11.0.0/src/lock/lock.bend as L
34import ezx@1.11.0.0/src/ledger/manifest.bend as M
35import ezx@1.11.0.0/src/ledger/render.bend as Rend
36import ezx@1.11.0.0/src/ledger/ignore.bend as I
37import ezx@1.11.0.0/src/pkg/pkg.bend as K
38import ezx@1.11.0.0/src/pkg/path.bend as Path
39import ezx@1.11.0.0/src/git/git.bend as Git
40import ezx@1.11.0.0/src/ez/named.bend as Named
41
42# ---------------------------------------------------------------------------
43# what the World says
44
45# the `<name>@<version>` asked for
46def nv(world: A.World) -> String:
47  A.target(world)
48
49# its name part, which a re-add of another version finds its entry by
50def part(+world: A.World) -> String:
51  Named.hub.part(nv(world))
52
53# the key the dependency is recorded under (EZ-LED-7)
54def key(+world: A.World) -> String:
55  Named.hub.key(A.deps(world), part(world), A.rename(world))
56
57# the entry asked for: the word after the name. A name pins its version, so
58# that word is the entry, whichever place it was given in.
59def asked(+world: A.World) -> String:
60  Bool.pick(String, String.is_empty(A.entry.arg(world)), A.ref(world), A.entry.arg(world))
61
62# this reply's answer when it is about the key, else the rest's. The rest
63# arrives as a thunk, so the first answer ends the scan.
64def heard.at(hit: Bool, answer: W.Answer, rest: Unit -> Maybe<&2, W.Answer>) -> Maybe<&2, W.Answer>:
65  match hit:
66    case True{}:
67      Some{answer}
68    case False{}:
69      rest(Unit{})
70
71# the answer the World holds for a question about this key: a name, or a
72# package's hash
73def heard(rs: List<&2, W.Reply>, +key: String) -> Maybe<&2, W.Answer>:
74  match rs:
75    case []:
76      None{}
77    case W.Reply{ask, answer} <> t:
78      heard.at(String.eq(W.ask.hash(ask), key), answer, _u => heard(t, key))
79
80# ---------------------------------------------------------------------------
81# where the World stands
82
83# every answer is in, with the hash the hub named and the package it serves
84# checked against it; a question is still open; or the add refuses
85type Verdict is Data:
86  Go{hash: String, files: List<&2, K.Item>, srcs: List<&2, String>}
87  Pending{asks: List<&2, W.Ask>}
88  Stop{why: String}
89
90# the package, judged as the lock judges a hub package
91def decide.body(verdict: W.Verdict, +hash: String) -> Verdict:
92  match verdict:
93    case W.Ok{fs, ss}:
94      Go{hash, fs, ss}
95    case W.No{why}:
96      Stop{why}
97    case W.Named{_ns}:
98      Stop{"ez: " ++ hash ++ " was not answered with a package"}
99
100# the package the hub served for the hash, or why it served none
101def decide.got(answer: W.Answer, +hash: String, +world: A.World) -> Verdict:
102  match answer:
103    case W.Got{how, manifest, ss}:
104      decide.body(W.hub.how(how, hash, manifest, ss), hash)
105    case W.Miss{why}:
106      Stop{W.hub.why(True{}, hash, A.hub(world), why)}
107    case _:
108      Stop{"ez: " ++ hash ++ " was not answered with a package"}
109
110# the package, once it is asked for
111def decide.pkg(got: Maybe<&2, W.Answer>, +hash: String, +world: A.World) -> Verdict:
112  match got:
113    case None{}:
114      Pending{[W.Pkg{hash, L.Hub{}, A.hub(world)}]}
115    case Some{answer}:
116      decide.got(answer, hash, world)
117
118# a `0x` name the hub answered, or an answer that names none
119def decide.hash(ok: Bool, +hash: String, +world: A.World) -> Verdict:
120  match ok:
121    case True{}:
122      decide.pkg(heard(A.hubs(world), hash), hash, world)
123    case False{}:
124      Stop{"ez: the hub at " ++ A.hub(world) ++ " names no package " ++ nv(world) ++
125        " (it answered `" ++ hash ++ "`)"}
126
127# why the hub gave no answer, without the `ez: ` a miss is said with
128def unsaid(ez: Bool, +why: String) -> String:
129  match ez:
130    case True{}:
131      String.drop(why, 4n)
132    case False{}:
133      why
134
135# what the hub said the name names
136def decide.said(answer: W.Answer, +world: A.World) -> Verdict:
137  match answer:
138    case W.Said{text}:
139      +hash = String.trim(text)
140      decide.hash(L.hash.ok(hash), hash, world)
141    case W.Miss{+why}:
142      Stop{"ez: the hub at " ++ A.hub(world) ++ " has no package " ++ nv(world) ++ " (" ++
143        unsaid(String.starts_with(why, "ez: "), why) ++ ")"}
144    case _:
145      Stop{"ez: " ++ nv(world) ++ " was not answered with a hash"}
146
147# the name, once it is asked of the hub
148def decide.name(got: Maybe<&2, W.Answer>, +world: A.World) -> Verdict:
149  match got:
150    case None{}:
151      Pending{[W.Name{nv(world), A.hub(world)}]}
152    case Some{answer}:
153      decide.said(answer, world)
154
155# why the add is refused before anything is asked, "" when it is not: a ref
156# and an entry both given, or a key the ledger refuses
157def early(+world: A.World) -> String:
158  Bool.pick(String,
159    Bool.or(String.is_empty(A.ref(world)), String.is_empty(A.entry.arg(world))),
160    Named.hub.why(A.deps(world), key(world), part(world), A.rename(world)),
161    "ez: " ++ nv(world) ++ " pins its version; the word after it is the entry, " ++
162      "and there is only one")
163
164# a refusal the ledger alone decides
165def decide.early(ok: Bool, +why: String, +world: A.World) -> Verdict:
166  match ok:
167    case True{}:
168      decide.name(heard(A.hubs(world), nv(world)), world)
169    case False{}:
170      Stop{why}
171
172# no ledger, or one that does not parse, is refused before anything else,
173# with the reason every command that edits a ledger gives
174def decide.read(read: M.Read, +world: A.World) -> Verdict:
175  match read:
176    case M.Bad{why}:
177      Stop{"ez: " ++ M.show(M.Bad{why})}
178    case M.Good{_m}:
179      +e = early(world)
180      decide.early(String.is_empty(e), e, world)
181
182# where a World stands
183def decide(+world: A.World) -> Verdict:
184  decide.read(A.read(world), world)
185
186# ---------------------------------------------------------------------------
187# the entry
188
189# whether a package holds a file at this path
190def holds(fs: List<&2, K.Item>, +at: String) -> Bool:
191  match fs:
192    case []:
193      False{}
194    case +h <> t:
195      +rest = holds(t, at)
196      Bool.or(String.eq(K.file.at(h), at), rest)
197
198# a top-level `.bend` file: one with no directory in front of it
199def top.one(+at: String) -> Bool:
200  Bool.and(String.ends_with(at, ".bend"), Bool.not(String.contains(at, "/")))
201
202# this file when it is a top-level `.bend` file, else the rest's. The rest
203# arrives as a thunk, so the first one ends the scan.
204def top.at(hit: Bool, +at: String, rest: Unit -> String) -> String:
205  match hit:
206    case True{}:
207      at
208    case False{}:
209      rest(Unit{})
210
211# the first top-level `.bend` file, in manifest order, "" for none
212def top(fs: List<&2, K.Item>) -> String:
213  match fs:
214    case []:
215      ""
216    case +h <> t:
217      top.at(top.one(K.file.at(h)), K.file.at(h), _u => top(t))
218
219# `main.bend` when the package holds one, else its first top-level file
220def entry.main(held: Bool, fs: List<&2, K.Item>) -> String:
221  match held:
222    case True{}:
223      "main.bend"
224    case False{}:
225      top(fs)
226
227# the entry a package is recorded with when none was asked for: its
228# `main.bend`, else its first top-level `.bend` file, else none
229def entry.of(+fs: List<&2, K.Item>) -> String:
230  entry.main(holds(fs, "main.bend"), fs)
231
232# the entry asked for, or, when none was, the package's own
233def entry.pick(none: Bool, +fs: List<&2, K.Item>, +asked: String) -> String:
234  match none:
235    case True{}:
236      entry.of(fs)
237    case False{}:
238      asked
239
240# the entry recorded: the one asked for, else the package's own
241def entry(+fs: List<&2, K.Item>, +world: A.World) -> String:
242  entry.pick(String.is_empty(asked(world)), fs, asked(world))
243
244# ---------------------------------------------------------------------------
245# the plan
246
247# the dependency recorded for a package the hub named by this hash
248def dep.of(+hash: String, +fs: List<&2, K.Item>, +world: A.World) -> M.Dep:
249  M.Dep{key(world), hash, entry(fs, world), M.Hub{nv(world)}}
250
251# the ledger with the package added, once it is known to read back. A
252# ledger that could not be written so that it reads back is refused
253# (EZ-LED-4).
254def outcome.fit(fit: Bool) -> P.Outcome:
255  match fit:
256    case True{}:
257      P.Success{}
258    case False{}:
259      P.Refused{Rend.unrenderable()}
260
261# an entry asked for must be in the package
262def outcome.entry(held: Bool, fit: Bool, +at: String, +world: A.World) -> P.Outcome:
263  match held:
264    case True{}:
265      outcome.fit(fit)
266    case False{}:
267      P.Refused{"ez: " ++ at ++ " is not in " ++ nv(world)}
268
269# how an add ends once the package is in hand
270def outcome.of(+hash: String, +fs: List<&2, K.Item>, +world: A.World) -> P.Outcome:
271  outcome.entry(Bool.or(String.is_empty(asked(world)), holds(fs, Path.norm(asked(world)))),
272    Rend.renderable(Rend.add.keep(A.manifest.of(A.read(world)), dep.of(hash, fs, world))),
273    asked(world), world)
274
275# where the tree is laid: under `.ez/lib` when the entry it replaces is
276# vendored, under BEND_LIB otherwise. A hub dependency is never vendored, so
277# a name the ledger already records is laid under BEND_LIB like a new one.
278def place.of(vend: Bool) -> P.Place:
279  match vend:
280    case True{}:
281      P.Committed{}
282    case False{}:
283      P.Cache{}
284
285# `.gitignore` written ahead of the rest when the allowlist changes it
286def ignore.put(same: Bool, +next: String, rest: List<&2, P.Effect>) -> List<&2, P.Effect>:
287  match same:
288    case True{}:
289      rest
290    case False{}:
291      P.Write{A.ignore.file(), next} <> rest
292
293# the lines a person is told: the hash the name names, then, when there is
294# an entry, the import line for it, the line `ez publish` prints with the
295# name in place of the hash
296def says(+hash: String, +entry: String, +world: A.World) -> List<&2, P.Effect>:
297  Bool.pick(List<&2, P.Effect>, String.is_empty(entry), [P.Say{nv(world) ++ " is " ++ hash}],
298    [P.Say{nv(world) ++ " is " ++ hash}, P.Say{Git.import.line(nv(world), Path.norm(entry))}])
299
300# what an add of a package the hub served does: the tree laid, its name's
301# file, ez.toml written, `.gitignore` when the allowlist changes, and what a
302# person is told
303def effects.of(
304  +dep: M.Dep,
305  +hash: String,
306  +ls: List<&2, W.Source>,
307  +manifest: M.Manifest,
308  +world: A.World
309) -> List<&2, P.Effect>:
310  +old = M.find(A.deps.of(manifest), M.dep.name(dep))
311  +next = I.sync(A.deps.of(Rend.add.keep(manifest, dep)), A.ignore(world))
312  P.Lay{place.of(M.source.vendor(M.source.dep(old))), hash,
313    List.append(&2, W.Source, ls, [W.Source{"manifest", W.manifest(ls)}])} <>
314    (P.Name{nv(world), hash} <>
315      (P.Write{A.toml(), Rend.show(Rend.add.keep(manifest, dep))} <>
316        ignore.put(String.eq(next, A.ignore(world)), next,
317          says(hash, M.dep.entry(dep), world))))
318
319# a plan that refuses has no effect at all; its reason is how it ends
320def seal(es: List<&2, P.Effect>, outcome: P.Outcome) -> P.Plan:
321  match outcome:
322    case P.Success{}:
323      P.Plan{es, P.Success{}}
324    case P.Refused{why}:
325      P.Plan{[], P.Refused{why}}
326
327# the plan once the package is in hand
328def made(+hash: String, +fs: List<&2, K.Item>, +ss: List<&2, String>, +world: A.World) -> P.Plan:
329  seal(effects.of(dep.of(hash, fs, world), hash, W.laid(fs, ss),
330      A.manifest.of(A.read(world)), world),
331    outcome.of(hash, fs, world))
332
333# the plan for where the World stands. One that still asks is a World the
334# interpreter did not finish, and is refused rather than guessed at.
335def plan.v(verdict: Verdict, +world: A.World) -> P.Plan:
336  match verdict:
337    case Go{hash, fs, ss}:
338      made(hash, fs, ss, world)
339    case Pending{_asks}:
340      P.Plan{[], P.Refused{"ez: the hub was never asked what " ++ nv(world) ++ " names"}}
341    case Stop{why}:
342      P.Plan{[], P.Refused{why}}
343
344# `ez add <name>@<version>` over a World
345def plan(+world: A.World) -> P.Plan:
346  plan.v(decide(world), world)
347
348# the questions still open where the World stands
349def asks.v(verdict: Verdict) -> List<&2, W.Ask>:
350  match verdict:
351    case Go{_hash, _fs, _ss}:
352      []
353    case Pending{asks}:
354      asks
355    case Stop{_why}:
356      []
357
358# the questions a World still leaves open
359def wants(+world: A.World) -> List<&2, W.Ask>:
360  asks.v(decide(world))
361
362# ---------------------------------------------------------------------------
363# law vocabulary
364
365# whether a plan ends in a refusal
366def refuses.plan(pl: P.Plan) -> Bool:
367  P.Plan{_es, outcome} = pl
368  match outcome:
369    case P.Success{}:
370      False{}
371    case P.Refused{_why}:
372      True{}
373
374# whether `ez add <name>@<version>` refuses on a World
375def refuses(+world: A.World) -> Bool:
376  refuses.plan(plan(world))
377
378# the hash and files a verdict carries, none when it carries no package
379def verdict.hash(verdict: Verdict) -> String:
380  match verdict:
381    case Go{hash, _fs, _ss}:
382      hash
383    case Pending{_asks}:
384      ""
385    case Stop{_why}:
386      ""
387
388def verdict.files(verdict: Verdict) -> List<&2, K.Item>:
389  match verdict:
390    case Go{_hash, fs, _ss}:
391      fs
392    case Pending{_asks}:
393      []
394    case Stop{_why}:
395      []
396
397# the hash the hub named, as the World answered it
398def hash(+world: A.World) -> String:
399  verdict.hash(decide(world))
400
401# the package's files, as the hub served them
402def files(+world: A.World) -> List<&2, K.Item>:
403  verdict.files(decide(world))
404
405# the dependency `ez add <name>@<version>` records on a World
406def added(+world: A.World) -> M.Dep:
407  dep.of(hash(world), files(world), world)
408
409# the hub a question names
410def ask.hub(ask: W.Ask) -> String:
411  match ask:
412    case W.Pkg{_hash, _src, hub}:
413      hub
414    case W.Name{_nv, hub}:
415      hub
416    case W.Lock{}:
417      ""
418
419# whether every question names this hub
420def asks.hub(as: List<&2, W.Ask>, +hub: String) -> Bool:
421  match as:
422    case []:
423      True{}
424    case h <> t:
425      +rest = asks.hub(t, hub)
426      Bool.and(String.eq(ask.hub(h), hub), rest)
427
428# whether a question asks the hub what a name names
429def names.one(ask: W.Ask) -> Bool:
430  match ask:
431    case W.Name{_nv, _hub}:
432      True{}
433    case _:
434      False{}
435
436# whether any question does
437def names(as: List<&2, W.Ask>) -> Bool:
438  match as:
439    case []:
440      False{}
441    case h <> t:
442      +rest = names(t)
443      Bool.or(names.one(h), rest)
444
445# the last of some lines, `prev` when there are none after it
446def last.go(ls: List<&2, String>, +prev: String) -> String:
447  match ls:
448    case []:
449      prev
450    case h <> t:
451      last.go(t, h)
452
453# the last line a plan says, "" when it says none
454def last(pl: P.Plan) -> String:
455  last.go(P.said(pl), "")
456
457# every name's file a list of effects lays, in order
458def names.laid(es: List<&2, P.Effect>) -> List<&2, L.Name>:
459  match es:
460    case []:
461      []
462    case e <> t:
463      match e:
464        case P.Name{nv, hash}:
465          L.Name{nv, hash} <> names.laid(t)
466        case _:
467          names.laid(t)