mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-12-15 10:02:47 +03:00
283 lines
7.0 KiB
Plaintext
283 lines
7.0 KiB
Plaintext
::
|
|
:::: /hoon/static/app
|
|
::
|
|
::
|
|
:: XX REVIEW: should this be a generator?
|
|
:: - it makes sense, since it doesnt need to store state between calls, its just producing a result
|
|
:: - but we can't pass arbitrary run-time arguments to ford runes.... yet
|
|
:: and we need that to specify the input file
|
|
:: - but we could have a special fixed directory to place our input files, so that we don't
|
|
:: have to pass the location as an argument at runtime
|
|
:: - but then could you have multiple separate static builds?
|
|
:: - let it take all files in a directory, build them as html
|
|
:: spider the links, then keep a map from all top-level files a set of their connected files
|
|
:: - then let the generator args specify which top-level file to write out and where to write it
|
|
:: - how do we know what a top-level file is? or can we treat all files as top levels files
|
|
:: mapped to their corresponding subset of linked files?
|
|
::
|
|
::
|
|
/? 309
|
|
/- static
|
|
|%
|
|
::::
|
|
:::: structures
|
|
::::
|
|
+= move [bone card]
|
|
+= card
|
|
$% [%poke wire dock poke]
|
|
[%exec wire ship (unit bilk:ford)]
|
|
[%info wire ship toro:clay]
|
|
==
|
|
+= poke
|
|
$% [%static-action action:static]
|
|
==
|
|
::::
|
|
:::: utilities
|
|
::::
|
|
::
|
|
:: +find-links: takes a manx and returns a list of all href and src links in it
|
|
::
|
|
++ find-links
|
|
|= max=manx
|
|
^- (list tape)
|
|
%+ weld
|
|
::
|
|
%+ roll a.g.max
|
|
|= [[n=mane v=tape] out=(list tape)]
|
|
?: ?=(?(%href %src) n)
|
|
[v out]
|
|
out
|
|
::
|
|
%+ roll c.max
|
|
|= [m=manx out=(list tape)]
|
|
(weld out (find-links m))
|
|
::
|
|
+= relative
|
|
$% [%root wir=wire ext=mark]
|
|
[%here wir=wire ext=mark]
|
|
[%up n=@ wir=wire ext=mark]
|
|
==
|
|
::
|
|
++ parse-relative
|
|
|= pax=tape
|
|
^- (unit relative)
|
|
%+ rust pax
|
|
%+ cook
|
|
|= a=^
|
|
?: ?=([%up @] -.a)
|
|
((hard relative) [%up ->.a +.a])
|
|
((hard relative) a)
|
|
;~ plug
|
|
::
|
|
;~ pose
|
|
(cold %root fas)
|
|
::
|
|
(cold [%up 1] ;~(plug dot fas))
|
|
::
|
|
%+ cook
|
|
|= a=(list %up)
|
|
[%up +((lent a))]
|
|
(plus (cold %up ;~(plug dot dot fas)))
|
|
::
|
|
(cold [%up 1] (easy ~))
|
|
==
|
|
::
|
|
%+ cook
|
|
|= a=(list coin)
|
|
%+ turn a
|
|
|= b=coin
|
|
~(rent co b)
|
|
(more fas nuck:so)
|
|
::
|
|
;~ pose
|
|
(cold %html (jest '.html'))
|
|
(cold %md (jest '.md'))
|
|
(cold %umd (jest '.umd'))
|
|
(cold %hoon (jest '.hoon'))
|
|
(cold %js (jest '.js'))
|
|
(cold %css (jest '.css'))
|
|
(easy %$)
|
|
==
|
|
==
|
|
::
|
|
++ process-relative
|
|
|= [loc=beam rel=relative]
|
|
^- [loc=beam ext=mark]
|
|
|-
|
|
?- -.rel
|
|
%root
|
|
[loc(s (flop wir.rel)) ext.rel]
|
|
::
|
|
%here
|
|
[loc(s (flop (weld (flop s.loc) wir.rel))) ext.rel]
|
|
::
|
|
%up
|
|
%= $
|
|
s.loc (slag n.rel s.loc)
|
|
rel [%here wir.rel ext.rel]
|
|
==
|
|
==
|
|
::
|
|
+= state
|
|
$: waiting=(map wire [in=beam out=beam])
|
|
finished=(set beam)
|
|
==
|
|
--
|
|
::::
|
|
:::: app proper
|
|
::::
|
|
|_ [bol=bowl:gall sta=state]
|
|
::
|
|
++ this .
|
|
::
|
|
:: +prep: we don't need no state
|
|
::
|
|
++ prep
|
|
|= old=(unit)
|
|
:- ~
|
|
this(sta *state)
|
|
::
|
|
:: +poke-static-action: send build request to ford and wait for result
|
|
::
|
|
++ poke-static-action
|
|
|= act=action:static
|
|
^- (quip move _this)
|
|
?- -.act
|
|
%build
|
|
?> !?=(~ s.in.act)
|
|
=. s.out.act [-.s.in.act s.out.act]
|
|
=/ sil (find-file in.act ext.act)
|
|
=/ wir=wire /build/(scot %p (sham [in.act out.act]))
|
|
=/ car [%exec wir our.bol `[-.in.act sil]]
|
|
:- [ost.bol car]~
|
|
%= this
|
|
waiting.sta (~(put by waiting.sta) wir [in.act out.act])
|
|
==
|
|
==
|
|
::
|
|
:: +find-file: checks for file at %umd, %md, %html, %js, %css, and %hoon extensions
|
|
:: returns a silk to send to ford
|
|
::
|
|
++ find-file
|
|
|= [loc=beam ext=mark]
|
|
^- silk:ford
|
|
?> !?=(~ s.loc)
|
|
::
|
|
=/ try-exts=(list @tas)
|
|
:~ %hoon
|
|
%md
|
|
%umd
|
|
%html
|
|
==
|
|
:: if ext is unspecified then try the extensions defined in try-exts
|
|
::
|
|
=/ normed-ext=@tas
|
|
?: =(%$ ext)
|
|
|-
|
|
?~ try-exts
|
|
~_ leaf+"Error: Non-existent file: {<(en-beam:format loc)>}" !!
|
|
=/ pax (weld (en-beam:format loc) [i.try-exts ~])
|
|
=/ ark .^(arch %cy pax)
|
|
?~ fil.ark
|
|
$(try-exts t.try-exts)
|
|
i.try-exts
|
|
:: otherwise just try the extension given
|
|
::
|
|
=/ pax (weld (en-beam:format loc) [ext ~])
|
|
=/ ark .^(arch %cy pax)
|
|
?~ fil.ark
|
|
~_ leaf+"Error: Non-existent file: {<pax>}" !!
|
|
ext
|
|
:: form silk for the given mark
|
|
::
|
|
?: ?=(%hoon normed-ext)
|
|
:: [%cast %hymn [%bake %noun *coin loc]]
|
|
[%cast %hymn [%ride [%cnts p=~[[%.y p=1]] q=~] [%core loc]]]
|
|
?: ?=(%md normed-ext)
|
|
[%cast %elem [%cast %down [%file loc(s [normed-ext s.loc])]]]
|
|
?: ?=(%umd normed-ext)
|
|
[%cast %elem [%file loc(s [normed-ext s.loc])]]
|
|
?: ?=(%html normed-ext)
|
|
[%cast %hymn [%file loc(s [normed-ext s.loc])]]
|
|
?: ?=(?(%js %css) normed-ext)
|
|
[%file loc(s [normed-ext s.loc])]
|
|
~_ leaf+"Error: Unsupported filetype: {<normed-ext>}" !!
|
|
::
|
|
:: +coup: handle errors
|
|
::
|
|
++ coup
|
|
|= [wir=wire err=(unit tang)]
|
|
^- (quip move _this)
|
|
?~ err
|
|
[~ this]
|
|
(mean u.err)
|
|
::
|
|
:: +made: process ford result
|
|
::
|
|
++ made
|
|
|= [wir=path hash=@uvJ gag=gage:ford]
|
|
^- (quip move _this)
|
|
:: if ford build failed, print out error and crash
|
|
:: otherwise, assert we got single result, not a table
|
|
::
|
|
?: ?=(%| -.gag)
|
|
~_ p.gag !!
|
|
?> ?=(%& -.gag)
|
|
:: retrieve the build in/out beams
|
|
::
|
|
=/ bem=[in=beam out=beam] (need (~(get by waiting.sta) wir))
|
|
?> &(!?=(~ s.in.bem) !?=(~ s.out.bem))
|
|
::
|
|
=/ file-contents q.q.p.gag
|
|
=/ file-type=mark p.p.gag
|
|
:: finish by removing build from waiting list
|
|
:: and adding it to our finished list, to prevent infinite build loops
|
|
::
|
|
:_ %= this
|
|
waiting.sta (~(del by waiting.sta) wir)
|
|
finished.sta (~(put in finished.sta) in.bem)
|
|
==
|
|
::
|
|
^- (list move)
|
|
:: if js or css, pass it through without processing it
|
|
::
|
|
?. ?=(?(%hymn %elem) file-type)
|
|
?> ?=(?(%js %css) file-type)
|
|
=. s.out.bem [file-type s.out.bem]
|
|
=/ pax (en-beam:format out.bem)
|
|
?> ?=(@t file-contents)
|
|
=/ fol (foal:space:userlib pax [file-type !>(file-contents)])
|
|
:_ ~
|
|
[ost.bol %info /write our.bol fol]
|
|
:: get all links from manx
|
|
::
|
|
=/ file-contents=manx ((hard manx) q.q.p.gag)
|
|
=/ links=(list tape) (find-links file-contents)
|
|
:: process list of links into list of static-action
|
|
::
|
|
=/ new-actions=(list move)
|
|
%+ roll links
|
|
|= [link=tape output=(list move)]
|
|
=/ parsed (parse-relative link)
|
|
?~ parsed
|
|
output
|
|
=/ new-in (process-relative in.bem u.parsed)
|
|
=/ new-out (process-relative out.bem u.parsed)
|
|
=. s.loc.new-out (slag 1 s.loc.new-out)
|
|
?: (~(has in finished.sta) loc.new-in)
|
|
output
|
|
:_ output
|
|
[ost.bol %poke /act [our.bol dap.bol] %static-action [%build loc.new-in loc.new-out ext.new-in]]
|
|
:: write html output file to clay
|
|
::
|
|
=. s.out.bem [%html s.out.bem]
|
|
~& (flop s.out.bem)
|
|
=/ pax (en-beam:format out.bem)
|
|
=/ fol (foal:space:userlib pax [%html !>((crip (en-xml:html file-contents)))])
|
|
:_ new-actions
|
|
[ost.bol %info /write our.bol fol]
|
|
--
|
|
|
|
|
|
|