shrub/pkg/arvo/app/dojo.hoon

1198 lines
40 KiB
Plaintext
Raw Normal View History

2019-01-18 08:37:34 +03:00
:: :: ::
2016-02-11 03:41:28 +03:00
:::: /hoon/dojo/app :: ::::
2015-05-07 05:31:54 +03:00
:: :: ::
/? 309 :: arvo kelvin
2016-02-27 04:13:00 +03:00
/- sole, lens :: console structures
2015-05-07 05:31:54 +03:00
/+ sole :: console library
2017-12-16 07:13:50 +03:00
=, sole
2015-05-07 05:31:54 +03:00
:: :: ::
:::: :: ::::
2016-11-17 04:42:58 +03:00
:: :: ::
2015-05-07 05:31:54 +03:00
=> |% :: external structures
++ house :: all state
$: $5
2015-12-20 23:50:45 +03:00
egg/@u :: command count
hoc/(map bone session) :: conversations
2015-05-07 05:31:54 +03:00
== ::
++ session :: per conversation
2015-12-20 23:50:45 +03:00
$: say/sole-share :: command-line state
dir/beam :: active path
poy/(unit dojo-project) :: working
$: :: sur: structure imports
::
sur=(list cable:ford)
:: lib: library imports
::
lib=(list cable:ford)
==
2015-12-20 23:50:45 +03:00
var/(map term cage) :: variable state
old/(set term) :: used TLVs
buf/tape :: multiline buffer
2015-05-07 05:31:54 +03:00
== ::
2017-12-16 07:13:50 +03:00
++ monkey :: per conversation
$: say/sole-share :: command-line state
dir/beam :: active path
poy/(unit dojo-project) :: working
var/(map term cage) :: variable state
old/(set term) :: used TLVs
buf/tape :: multiline buffer
== ::
2015-05-07 05:31:54 +03:00
++ dojo-command ::
2015-12-14 10:58:14 +03:00
$^ (pair dojo-sink dojo-source) :: route value
2015-12-20 23:50:45 +03:00
{$brev p/term} :: unbind variable
2015-12-09 04:54:26 +03:00
::
2015-09-29 22:15:33 +03:00
++ dojo-sink ::
2015-12-20 23:50:45 +03:00
$% {$flat p/path} :: atom to unix
{$pill p/path} :: noun to unix pill
:: {$tree p/path} :: noun to unix tree
{$file p/beam} :: save to clay
2016-11-08 04:40:00 +03:00
$: $http :: http outbound
2019-01-18 08:37:34 +03:00
p/?($post $put)
r/@t
2016-11-08 04:40:00 +03:00
==
2015-12-20 23:50:45 +03:00
{$poke p/goal} :: poke app
{$show p/?($0 $1 $2 $3 $4 $5)} :: val/type/hoon/xray
2015-12-20 23:50:45 +03:00
{$verb p/term} :: store variable
2015-05-07 05:31:54 +03:00
== ::
++ dojo-source :: construction node
2015-12-20 23:50:45 +03:00
$: p/@ud :: assembly index
q/dojo-build :: general build
2015-05-07 05:31:54 +03:00
== ::
2016-03-03 03:38:59 +03:00
++ dojo-build :: one arvo step
2018-02-12 08:17:42 +03:00
$~ [%ex *hoon]
$% {$ur p/@t} :: http GET request
2015-12-20 23:50:45 +03:00
{$ge p/dojo-model} :: generator
{$dv p/path} :: core from source
2017-11-17 00:50:03 +03:00
{$ex p/hoon} :: hoon expression
2017-10-25 23:12:14 +03:00
{$sa p/mark} :: example mark value
2015-12-20 23:50:45 +03:00
{$as p/mark q/dojo-source} :: simple transmute
2017-11-17 00:50:03 +03:00
{$do p/hoon q/dojo-source} :: gate apply
2015-12-20 23:50:45 +03:00
{$tu p/(list dojo-source)} :: tuple
2015-05-07 05:31:54 +03:00
== ::
2019-01-18 08:37:34 +03:00
++ dojo-model :: data construction
2015-12-20 23:50:45 +03:00
$: p/dojo-server :: core source
q/dojo-config :: configuration
2015-05-07 05:31:54 +03:00
== ::
++ dojo-server :: numbered device
2015-12-20 23:50:45 +03:00
$: p/@ud :: assembly index
q/path :: gate path
2015-05-07 05:31:54 +03:00
== ::
++ dojo-config :: configuration
2015-12-20 23:50:45 +03:00
$: p/(list dojo-source) :: by order
q/(map term (unit dojo-source)) :: by keyword
2015-05-07 05:31:54 +03:00
== ::
++ dojo-project :: construction state
2015-12-20 23:50:45 +03:00
$: mad/dojo-command :: operation
num/@ud :: number of tasks
cud/(unit dojo-source) :: now solving
pux/(unit path) :: ford working
pro/(unit vase) :: prompting loop
per/(unit sole-edit) :: pending reverse
job/(map @ud dojo-build) :: problems
rez/(map @ud cage) :: results
2015-05-07 05:31:54 +03:00
== ::
2015-12-20 23:50:45 +03:00
++ bead {p/(set beam) q/cage} :: computed result
++ goal {p/ship q/term} :: flat application
2015-05-07 05:31:54 +03:00
++ clap :: action, user
2015-12-20 23:50:45 +03:00
$% {$peer p/path} :: subscribe
{$poke p/(cask)} :: apply
2018-03-19 07:18:20 +03:00
{$pull ~} :: unsubscribe
2015-05-07 05:31:54 +03:00
== ::
++ club :: action, system
2015-12-20 23:50:45 +03:00
$% {$peer p/path} :: subscribe
{$poke p/cage} :: apply
2018-03-19 07:18:20 +03:00
{$pull ~} :: unsubscribe
2015-05-07 05:31:54 +03:00
== ::
++ card :: general card
2015-12-14 10:58:14 +03:00
$% {$diff $sole-effect sole-effect} ::
2015-12-09 04:54:26 +03:00
{$send wire {ship term} clap} ::
[%request wire request:http outbound-config:http-client] :: %l
2018-12-13 09:34:12 +03:00
[%build wire ? schematic:ford]
2018-12-13 09:38:35 +03:00
[%kill wire ~]
2015-12-09 04:54:26 +03:00
{$deal wire sock term club} ::
2018-12-13 10:59:53 +03:00
{$info wire toro:clay} ::
2015-05-07 05:31:54 +03:00
== ::
++ move (pair bone card) :: user-level move
++ sign ::
$% :: %made: build result; response to %build +task
::
$: %made
:: date: formal date of the build
::
date=@da
:: result: result of the build; either complete build, or error
::
$= result
$% :: %complete: contains the result of the completed build
::
[%complete build-result=build-result:ford]
:: %incomplete: couldn't finish build; contains error message
::
[%incomplete =tang]
== ==
{$unto p/cuft:gall}
==
--
=>
|%
:: |parser-at: parsers for dojo expressions using :dir as working directory
::
++ parser-at
|= [our=ship dir=beam]
|%
++ default-app %hood
++ hoon-parser (vang | (en-beam:format dir))
++ our p.dir
::
++ parse-command-line ;~(sfix parse-command (star ace) (just '\0a'))
::
++ to-command
|= [gol=goal mod=dojo-model]
^- dojo-command
[[%poke gol] [0 [%ge mod(q.p [q.gol q.p.mod])]]]
::
++ parse-variable
|* [sym=rule src=rule]
%+ cook
|= {a/term b/(unit dojo-source)}
^- dojo-command
?~(b [%brev a] [[%verb a] u.b])
;~(plug sym (punt src))
::
++ parse-command
:: =< ;~(less |-(;~(pose (jest '|*') ;~(pfix next (knee ** |.(^$))))) .)
%+ knee *dojo-command |. ~+
;~ pose
;~ pfix bar
%+ cook to-command
(stag `goal`[our default-app] parse-model)
==
2015-09-29 22:15:33 +03:00
::
;~ pfix col
%+ cook
|= {a/goal b/$^(dojo-model dojo-source)}
?@ -.b [[%poke a] b]
(to-command a b)
;~ plug
parse-goal
2017-05-22 01:43:23 +03:00
;~ pose
;~(pfix bar parse-model)
;~(pfix ace parse-source)
2017-05-22 01:43:23 +03:00
==
==
2015-05-07 05:31:54 +03:00
==
2015-09-16 02:27:19 +03:00
::
;~ pfix tis
;~ pose
(parse-variable (jest %dir) ;~(pfix ace :(stag 0 %ex parse-rood)))
(parse-variable sym ;~(pfix ace parse-source))
==
2015-09-16 02:27:19 +03:00
==
::
;~ pfix net
;~ pose
(parse-variable (cold %sur hep) ;~(pfix gap parse-cables))
(parse-variable (cold %lib lus) ;~(pfix gap parse-cables))
==
==
2015-09-16 02:27:19 +03:00
::
;~((glue ace) parse-sink parse-source)
(stag [%show %0] parse-source)
==
::
++ parse-sink
;~ pose
;~(plug (cold %file tar) parse-beam)
;~(plug (cold %flat vat) (most net sym))
;~(plug (cold %pill dot) (most net sym))
;~(plug (cold %http lus) (stag %post parse-url))
;~(plug (cold %http hep) (stag %put parse-url))
(stag %show (cook $?($1 $2 $3 $4 $5) (cook lent (stun [1 5] wut))))
==
::
++ parse-cables
%+ cook
|= cables=(list cable:ford)
:+ 0 %ex
^- hoon
::
:- %clsg
%+ turn cables
|= cable=cable:ford
^- hoon
::
:+ %clhp
?~ face.cable
[%rock %n ~]
[%clhp [%rock %n ~] [%sand %tas u.face.cable]]
[%sand %tas file-path.cable]
(most ;~(plug com gaw) parse-cable)
::
++ parse-cable
%+ cook |=(a=cable:ford a)
;~ pose
(stag ~ ;~(pfix tar sym))
(cook |=([face=term tis=@ file=term] [`face file]) ;~(plug sym tis sym))
(cook |=(a=term [`a a]) sym)
==
++ parse-source (stag 0 parse-build)
++ parse-build
2015-05-07 05:31:54 +03:00
%+ knee *dojo-build |. ~+
;~ pose
;~(plug (cold %ur lus) parse-url)
;~(plug (cold %ge lus) parse-model)
;~(plug (cold %as pad) sym ;~(pfix ace parse-source))
;~(plug (cold %do cab) parse-hoon ;~(pfix ace parse-source))
parse-value
2015-05-07 05:31:54 +03:00
==
::
++ parse-goal
%+ cook |=(a/goal a)
;~ pose
;~ plug
;~(pfix sig fed:ag)
;~(pose ;~(pfix net sym) (easy default-app))
2015-05-07 05:31:54 +03:00
==
%+ stag our
;~(pose sym (easy default-app))
==
::
++ parse-beam
%+ cook
|= a=path
:: hack: fixup paths that come out of the hoon parser
::
:: We currently invoke the hoon parser to read relative paths from
:: the command line, and this parser will produce leading ~ path
:: components with paths that start with a `/`.
::
:: This entire path is nuts and we shouldn't be representing paths
:: as arbitrary hoons.
::
=? a &(?=(^ a) =('' i.a))
t.a
(fall (de-beam:format a) [`beak`[p q r]:dir (flop a)])
=+ vez=hoon-parser
(sear plex:vez (stag %clsg poor:vez))
::
++ parse-iden-url
%+ cook
|=([a=(unit knot) b=purl:eyre] [`(fall a *knot) b])
auru:de-purl:html
::
++ parse-url
%+ cook
|=(a=purl:eyre (crip (en-purl:html a)))
auri:de-purl:html
::
++ parse-model ;~(plug parse-server parse-config)
++ parse-server (stag 0 (most net sym))
++ parse-hoon tall:hoon-parser
::
++ parse-rood
:: XX should this use +hoon-parser instead to normalize the case?
2015-09-04 02:17:34 +03:00
::
=> (vang | (en-beam:format dir))
;~ pose
rood
2016-03-03 03:38:59 +03:00
::
:: XX refactor ++scat
::
=- ;~(pfix cen (stag %clsg -))
%+ sear |=([a=@ud b=tyke] (posh ~ ~ a b))
2015-05-07 05:31:54 +03:00
;~ pose
porc
(cook |=(a=(list) [(lent a) ~]) (star cen))
2015-05-07 05:31:54 +03:00
==
==
++ parse-value
;~ pose
(stag %sa ;~(pfix tar pad sym))
(stag %ex parse-hoon)
(stag %tu (ifix [lac rac] (most ace parse-source)))
==
::
++ parse-config
;~ plug
(star ;~(pfix ace (stag 0 parse-value)))
%+ cook
~(gas by *(map term (unit dojo-source)))
%- star
2015-05-07 05:31:54 +03:00
;~ plug
;~(pfix com ace tis sym)
(punt ;~(pfix ace (stag 0 parse-value)))
2015-05-07 05:31:54 +03:00
==
==
--
--
:: ::
:::: ::
:: ::
=, gall
=+ foo=*monkey
|_ $: hid/bowl :: system state
house :: program state
== ::
++ he :: per session
|_ {moz/(list move) session} ::
::
++ he-beam
^- beam
?. =([%ud 0] r.dir)
dir
dir(r [%da now.hid])
::
++ he-disc `disc:ford`[p q]:he-beam
++ he-beak `beak`[p q r]:he-beam
++ he-rail `rail:ford`[[p q] s]:he-beam
++ he-parser (parser-at our.hid he-beam)
2015-05-07 05:31:54 +03:00
::
++ dy :: project work
|_ dojo-project ::
++ dy-abet +>(poy `+<) :: resolve
2015-10-02 23:55:34 +03:00
++ dy-amok +>(poy ~) :: terminate
2015-05-07 05:31:54 +03:00
++ dy-ford :: send work to ford
|= [way=wire schematic=schematic:ford]
2015-05-07 05:31:54 +03:00
^+ +>+>
2015-12-09 04:54:26 +03:00
?> ?=($~ pux)
:: pin all builds to :now.hid so they don't get cached forever
::
2018-12-13 09:34:12 +03:00
(he-card(poy `+>+<(pux `way)) %build way live=%.n schematic)
2015-05-07 05:31:54 +03:00
::
++ dy-request
|= [way=wire =request:http]
^+ +>+>
?> ?=(~ pux)
(he-card(poy `+>+<(pux `way)) %request way request *outbound-config:http-client)
::
2015-05-07 05:31:54 +03:00
++ dy-stop :: stop work
^+ +>
2015-10-07 21:58:17 +03:00
=. poy ~
2015-05-07 05:31:54 +03:00
?~ pux +>
2015-10-02 23:55:34 +03:00
%. [%txt "! cancel {<u.pux>}"]
2018-12-13 09:38:35 +03:00
he-diff:(he-card [%kill u.pux ~])
2015-05-07 05:31:54 +03:00
::
++ dy-slam :: call by ford
2015-12-20 23:50:45 +03:00
|= {way/wire gat/vase sam/vase}
2015-05-07 05:31:54 +03:00
^+ +>+>
(dy-ford way `schematic:ford`[%call [%$ %noun gat] [%$ %noun sam]])
2015-05-07 05:31:54 +03:00
::
++ dy-errd :: reject change, abet
|= {rev/(unit sole-edit) err/@u}
^+ +>+>
(he-errd(poy `+>+<) rev err)
::
2015-05-07 05:31:54 +03:00
++ dy-diff :: send effects, abet
2015-12-20 23:50:45 +03:00
|= fec/sole-effect
2015-05-07 05:31:54 +03:00
^+ +>+>
(he-diff(poy `+>+<) fec)
::
++ dy-rash :: send effects, amok
2015-12-20 23:50:45 +03:00
|= fec/sole-effect
2015-05-07 05:31:54 +03:00
^+ +>+>
(he-diff(poy ~) fec)
::
++ dy-init-command :: ++dojo-command
2015-12-20 23:50:45 +03:00
|= mad/dojo-command
2015-05-07 05:31:54 +03:00
^+ [mad +>]
2015-09-29 22:15:33 +03:00
?@ -.mad [mad +>.$]
=. q.mad
2015-12-10 12:17:19 +03:00
?+(-.p.mad q.mad $http [0 %as %mime q.mad])
2015-09-29 22:15:33 +03:00
=^ src +>.$ (dy-init-source q.mad)
[mad(q src) +>.$]
2015-05-07 05:31:54 +03:00
::
++ dy-init-source :: ++dojo-source
2015-12-20 23:50:45 +03:00
|= src/dojo-source
2015-05-07 05:31:54 +03:00
^+ [src +>]
=^ bul +> (dy-init-build q.src)
=: p.src num
q.src bul
==
[src +>.$(num +(num), job (~(put by job) -.src +.src))]
2015-05-07 05:31:54 +03:00
::
2015-09-29 22:15:33 +03:00
++ dy-init-source-unit :: (unit dojo-source)
2015-12-20 23:50:45 +03:00
|= urc/(unit dojo-source)
2015-09-29 22:15:33 +03:00
^+ [urc +>]
?~ urc [~ +>]
=^ src +> (dy-init-source u.urc)
[`src +>.$]
::
2015-05-07 05:31:54 +03:00
++ dy-init-build :: ++dojo-build
2015-12-20 23:50:45 +03:00
|= bul/dojo-build
2015-05-07 05:31:54 +03:00
^+ [bul +>]
?- -.bul
2015-12-09 04:54:26 +03:00
$ex [bul +>.$]
$dv [bul +>.$]
2017-10-25 23:12:14 +03:00
$sa [bul +>.$]
2015-12-09 04:54:26 +03:00
$as =^(mor +>.$ (dy-init-source q.bul) [bul(q mor) +>.$])
$do =^(mor +>.$ (dy-init-source q.bul) [bul(q mor) +>.$])
$ge =^(mod +>.$ (dy-init-model p.bul) [[%ge mod] +>.$])
$ur [bul +>.$]
$tu =^ dof +>.$
2015-05-07 05:31:54 +03:00
|- ^+ [p.bul +>.^$]
?~ p.bul [~ +>.^$]
=^ dis +>.^$ (dy-init-source i.p.bul)
=^ mor +>.^$ $(p.bul t.p.bul)
[[dis mor] +>.^$]
[[%tu dof] +>.$]
==
::
++ dy-init-model :: ++dojo-model
2015-12-20 23:50:45 +03:00
|= mol/dojo-model
2015-05-07 05:31:54 +03:00
^+ [mol +>]
=^ one +>.$ (dy-init-server p.mol)
=^ two +>.$ (dy-init-config q.mol)
[[one two] +>.$]
::
++ dy-init-server :: ++dojo-server
2015-12-20 23:50:45 +03:00
|= srv/dojo-server
2015-05-07 05:31:54 +03:00
=. p.srv num
2015-09-12 00:15:25 +03:00
[srv +>.$(num +(num), job (~(put by job) num [%dv [%gen q.srv]]))]
2015-05-07 05:31:54 +03:00
::
++ dy-init-config :: prepare config
2015-12-20 23:50:45 +03:00
|= cig/dojo-config
2015-05-07 05:31:54 +03:00
^+ [cig +>]
=^ ord +>.$ (dy-init-ordered p.cig)
=^ key +>.$ (dy-init-named q.cig)
[[ord key] +>.$]
::
++ dy-init-ordered :: (list dojo-source)
2015-12-20 23:50:45 +03:00
|= ord/(list dojo-source)
2015-05-07 05:31:54 +03:00
^+ [ord +>]
?~ ord [~ +>.$]
=^ fir +>.$ (dy-init-source i.ord)
=^ mor +>.$ $(ord t.ord)
[[fir mor] +>.$]
::
++ dy-init-named :: (map @tas dojo-src)
2015-12-20 23:50:45 +03:00
|= key/(map term (unit dojo-source))
2015-05-07 05:31:54 +03:00
^+ [key +>.$]
?~ key [~ +>.$]
=^ top +>.$ (dy-init-source-unit q.n.key)
=^ lef +>.$ $(key l.key)
=^ rit +>.$ $(key r.key)
[[[p.n.key top] lef rit] +>.$]
::
++ dy-init :: full initialize
^+ .
=^(dam . (dy-init-command mad) +(mad dam))
::
++ dy-hand :: complete step
2015-12-20 23:50:45 +03:00
|= cag/cage
2015-05-07 05:31:54 +03:00
^+ +>+>
?> ?=(^ cud)
(dy-step(cud ~, rez (~(put by rez) p.u.cud cag)) +(p.u.cud))
::
++ dy-meal :: vase to cage
2015-12-20 23:50:45 +03:00
|= vax/vase
2015-05-07 05:31:54 +03:00
?. &(?=(@ -.q.vax) ((sane %tas) -.q.vax))
~& %dy-meal-cage
(dy-rash %bel ~)
(dy-hand -.q.vax (slot 3 vax))
::
++ dy-made-edit :: sole edit
2015-12-20 23:50:45 +03:00
|= cag/cage
2015-05-07 05:31:54 +03:00
^+ +>+>
?> ?=(^ per)
2019-01-18 08:37:34 +03:00
?: ?| ?=(^ q.q.cag)
2015-05-07 05:31:54 +03:00
=((lent buf.say) q.q.cag)
2015-12-09 04:54:26 +03:00
!&(?=($del -.u.per) =(+(p.u.per) (lent buf.say)))
2015-05-07 05:31:54 +03:00
==
dy-abet(per ~)
(dy-errd(per ~) per q.q.cag)
2015-05-07 05:31:54 +03:00
::
++ dy-done :: dialog submit
2015-12-20 23:50:45 +03:00
|= txt/tape
2018-03-19 07:18:20 +03:00
?: |(?=(^ per) ?=(^ pux) ?=(~ pro))
~& %dy-no-prompt
(dy-diff %bel ~)
2015-05-07 05:31:54 +03:00
(dy-slam /dial u.pro !>(txt))
::
2015-09-09 00:05:40 +03:00
++ dy-cast
2015-12-20 23:50:45 +03:00
|* {typ/_* bun/vase}
|= a/vase ^- typ
~| [p.bun p.a]
2015-09-09 00:05:40 +03:00
?> (~(nest ut p.bun) & p.a)
;;(typ q.a)
::
2015-05-07 05:31:54 +03:00
++ dy-over :: finish construction
^+ +>
2018-03-18 04:06:15 +03:00
:: XX needs filter
::
:: ?: ?=({$show $3} -.mad)
:: (dy-rash %tan (dy-show-source q.mad) ~) :: XX separate command
2015-12-09 04:54:26 +03:00
?: ?=($brev -.mad)
2015-09-29 22:15:33 +03:00
=. var (~(del by var) p.mad)
=< dy-amok
2019-01-18 08:37:34 +03:00
?+ p.mad .
2015-12-14 10:58:14 +03:00
$?($eny $now $our) !!
2015-12-09 04:54:26 +03:00
$lib .(lib ~)
2016-03-22 08:03:13 +03:00
$sur .(sur ~)
2015-12-21 00:16:39 +03:00
$dir .(dir [[our.hid %home ud+0] /])
2015-09-29 22:15:33 +03:00
==
=+ cay=(~(got by rez) p.q.mad)
?- -.p.mad
2015-12-09 04:54:26 +03:00
$verb
2015-09-29 22:15:33 +03:00
=. var (~(put by var) p.p.mad cay)
2015-12-21 00:16:39 +03:00
~| bad-set+[p.p.mad p.q.cay]
2015-09-29 22:15:33 +03:00
=< dy-amok
?+ p.p.mad .
2016-11-08 04:40:00 +03:00
$eny ~|(%entropy-is-eternal !!)
$now ~|(%time-is-immutable !!)
$our ~|(%self-is-immutable !!)
2017-05-22 01:43:23 +03:00
$lib
%_ .
lib
((dy-cast (list cable:ford) !>(*(list cable:ford))) q.cay)
==
2016-11-08 04:40:00 +03:00
::
2017-05-22 01:43:23 +03:00
$sur
%_ .
sur
((dy-cast (list cable:ford) !>(*(list cable:ford))) q.cay)
==
2016-11-08 04:40:00 +03:00
::
$dir =+ ^= pax ^- path
=+ pax=((dy-cast path !>(*path)) q.cay)
2018-03-19 07:18:20 +03:00
?: ?=(~ pax) ~[(scot %p our.hid) %home '0']
?: ?=({@ ~} pax) ~[i.pax %home '0']
?: ?=({@ @ ~} pax) ~[i.pax i.t.pax '0']
2016-11-08 04:40:00 +03:00
pax
2018-12-12 00:48:34 +03:00
=. dir (need (de-beam:format pax))
2016-11-08 04:40:00 +03:00
=- +>(..dy (he-diff %tan - ~))
2018-12-12 00:48:34 +03:00
rose+[" " `~]^~[leaf+"=%" (smyt (en-beam:format he-beak s.dir))]
2015-09-29 22:15:33 +03:00
==
2017-05-22 01:43:23 +03:00
::
$poke
2015-05-07 05:31:54 +03:00
%- he-card(poy ~)
:* %deal
/poke
2015-09-29 22:15:33 +03:00
[our.hid p.p.p.mad]
q.p.p.mad
2015-05-07 05:31:54 +03:00
%poke
2015-09-29 22:15:33 +03:00
cay
2015-05-07 05:31:54 +03:00
==
2015-09-04 02:17:34 +03:00
::
2015-12-09 04:54:26 +03:00
$file
2015-09-04 02:17:34 +03:00
%- he-card(poy ~) :*
%info
/file
2018-12-12 00:48:34 +03:00
(foal:space:userlib (en-beam:format p.p.mad) cay)
2015-09-04 02:17:34 +03:00
==
2015-05-07 05:31:54 +03:00
::
2015-12-09 04:54:26 +03:00
$flat
?^ q.q.cay
2015-05-07 05:31:54 +03:00
(dy-rash %tan [%leaf "not an atom"]~)
2015-09-29 22:15:33 +03:00
(dy-rash %sav p.p.mad q.q.cay)
2015-05-07 05:31:54 +03:00
::
2015-12-09 04:54:26 +03:00
$pill
2015-09-29 22:15:33 +03:00
(dy-rash %sag p.p.mad q.q.cay)
2015-09-11 02:01:43 +03:00
::
2015-12-09 04:54:26 +03:00
$http
?> ?=($mime p.cay)
=+ mim=;;(mime q.q.cay)
%+ dy-request /show
:* ?:(=(%put p.p.mad) %'PUT' %'POST')
r.p.mad
~[['content-type' (en-mite:mimes:html p.mim)]]
`q.mim
==
2015-05-07 05:31:54 +03:00
::
2015-12-09 04:54:26 +03:00
$show
|^ (prnt cay note)
++ prnt ?: (gte p.p.mad 4)
dy-xprint
dy-print
++ note ^- tang
?- p.p.mad
%0 ~
%1 [[%rose [~ " " ~] (skol p.q.cay) ~] maar]
:: XX actually print something meaningful here
::
%2 [[%rose [~ " " ~] *tank ~] maar]
%3 ~
%4 ~
%5 [[%rose [~ " " ~] (xskol p.q.cay) ~] maar]
==
++ maar ?: =(%noun p.cay) ~
[[%rose [~ " " ~] >p.cay< ~] ~]
--
2015-09-11 02:01:43 +03:00
==
::
2015-12-20 23:50:45 +03:00
++ dy-show |=(cay/cage (dy-print cay ~))
::
:: Print a value (given as a cage) and a note (given as a tang).
::
++ dy-xprint
|= {cay/cage tan/tang}
%+ dy-rash %tan
%- welp :_ tan
?+ p.cay [(xsell q.cay)]~
$tang ;;(tang q.q.cay)
$httr
=+ hit=;;(httr:eyre q.q.cay)
=- (flop (turn `wall`- |=(a/tape leaf+(dash:us a '' ~))))
:- "HTTP {<p.hit>}"
%+ weld
(turn q.hit |=({a/@t b/@t} "{(trip a)}: {(trip b)}"))
:- i=""
t=(turn `wain`?~(r.hit ~ (to-wain:format q.u.r.hit)) trip)
==
::
:: Print a value (given as a cage) and a note (given as a tang).
::
2015-09-29 22:15:33 +03:00
++ dy-print
2015-12-20 23:50:45 +03:00
|= {cay/cage tan/tang}
2015-09-11 02:01:43 +03:00
%+ dy-rash %tan
2015-09-29 22:15:33 +03:00
%- welp :_ tan
2015-09-11 02:01:43 +03:00
?+ p.cay [(sell q.cay)]~
2015-12-09 04:54:26 +03:00
$tang ;;(tang q.q.cay)
$httr
=+ hit=;;(httr:eyre q.q.cay)
=- (flop (turn `wall`- |=(a/tape leaf+(dash:us a '' ~))))
2015-09-11 02:01:43 +03:00
:- "HTTP {<p.hit>}"
%+ weld
2015-12-20 23:50:45 +03:00
(turn q.hit |=({a/@t b/@t} "{(trip a)}: {(trip b)}"))
2016-03-03 03:38:59 +03:00
:- i=""
t=(turn `wain`?~(r.hit ~ (to-wain:format q.u.r.hit)) trip)
2015-05-07 05:31:54 +03:00
==
::
++ dy-edit :: handle edit
2015-12-20 23:50:45 +03:00
|= cal/sole-change
2015-05-07 05:31:54 +03:00
^+ +>+>
2018-12-12 00:39:39 +03:00
=^ dat say (~(transceive sole say) cal)
2018-03-19 07:18:20 +03:00
?: |(?=(^ per) ?=(^ pux) ?=(~ pro))
2015-05-07 05:31:54 +03:00
~& %dy-edit-busy
2018-12-12 00:39:39 +03:00
=^ lic say (~(transmit sole say) dat)
2015-05-07 05:31:54 +03:00
(dy-diff %mor [%det lic] [%bel ~] ~)
(dy-slam(per `dat) /edit u.pro !>((tufa buf.say)))
::
2017-11-16 23:44:27 +03:00
++ dy-type :: sole action
2015-12-20 23:50:45 +03:00
|= act/sole-action
2015-05-07 05:31:54 +03:00
?- -.act
2015-12-10 12:17:19 +03:00
$det (dy-edit +.act)
$ret (dy-done (tufa buf.say))
$clr dy-stop
2015-05-07 05:31:54 +03:00
==
::
2015-12-20 23:50:45 +03:00
++ dy-cage |=(num/@ud (~(got by rez) num)) :: known cage
++ dy-vase |=(num/@ud q:(dy-cage num)) :: known vase
++ dy-silk-vase |=(vax/vase [%$ %noun vax]) :: vase to silk
++ dy-silk-sources :: arglist to silk
|= src/(list dojo-source)
^- schematic:ford
::
:+ %$ %noun
2015-09-12 00:15:25 +03:00
|-
?~ src !>(~)
(slop (dy-vase p.i.src) $(src t.src))
2015-05-07 05:31:54 +03:00
::
2015-09-12 00:15:25 +03:00
++ dy-silk-config :: configure
2015-12-20 23:50:45 +03:00
|= {cay/cage cig/dojo-config}
^- [wire schematic:ford]
?. (~(nest ut [%cell [%atom %$ ~] %noun]) | p.q.cay)
::
:: naked gate
::
?. &(?=({* ~} p.cig) ?=(~ q.cig))
~|(%one-argument !!)
:- /noun
:+ %call [%$ %noun q.cay]
[%$ %noun (dy-vase p.i.p.cig)]
::
:: normal generator
::
2015-09-12 00:15:25 +03:00
:- ?+ -.q.q.cay ~|(%bad-gen ~_((sell (slot 2 q.cay)) !!))
2015-12-09 10:12:11 +03:00
$say /gent
$ask /dial
2015-09-12 00:15:25 +03:00
==
=+ gat=(slot 3 q.cay)
:+ %call [%$ %noun gat]
:+ [%$ %noun !>([now=now.hid eny=eny.hid bec=he-beak])]
2015-09-12 00:15:25 +03:00
(dy-silk-sources p.cig)
:+ %mute [%$ %noun (fall (slew 27 gat) !>(~))]
^- (list [wing schematic:ford])
%+ turn ~(tap by q.cig)
2015-12-20 23:50:45 +03:00
|= {a/term b/(unit dojo-source)}
^- [wing schematic:ford]
2015-09-12 00:15:25 +03:00
:- [a ~]
:+ %$ %noun
2015-09-12 00:15:25 +03:00
?~(b !>([~ ~]) (dy-vase p.u.b))
2015-05-07 05:31:54 +03:00
::
2017-11-17 00:50:03 +03:00
++ dy-hoon-head :: dynamic state
2017-05-22 01:43:23 +03:00
:: todo: how do i separate the toplevel 'dojo state' comment?
2018-05-25 01:39:56 +03:00
:: dojo state
::
:: our: the name of this urbit
:: now: the current time
:: eny: a piece of random entropy
::
2015-09-04 04:29:34 +03:00
^- cage
:- %noun
2015-12-20 23:50:45 +03:00
=+ sloop=|=({a/vase b/vase} ?:(=(*vase a) b ?:(=(*vase b) a (slop a b))))
2015-09-10 01:57:25 +03:00
%+ sloop
%- ~(rep by var)
2015-12-20 23:50:45 +03:00
|= {{a/term @ b/vase} c/vase} ^- vase
2018-05-17 00:51:20 +03:00
(sloop b(p face+[a p.b]) c)
2015-09-12 00:15:25 +03:00
!>([our=our now=now eny=eny]:hid)
2015-05-11 22:09:41 +03:00
::
2015-05-07 05:31:54 +03:00
++ dy-made-dial :: dialog product
2015-12-20 23:50:45 +03:00
|= cag/cage
2015-05-07 05:31:54 +03:00
^+ +>+>
?. ?=(^ q.q.cag)
(dy-errd ~ q.q.cag)
2015-05-07 05:31:54 +03:00
=+ tan=((list tank) +2.q.q.cag)
=. +>+>.$ (he-diff %tan tan)
2018-03-29 21:03:14 +03:00
=+ vax=(sped (slot 3 q.cag))
2015-05-07 05:31:54 +03:00
?+ -.q.vax !!
2018-03-19 06:54:47 +03:00
%&
2015-05-07 05:31:54 +03:00
?~ +.q.vax
~& %dy-made-dial-abort
(dy-rash %bel ~)
(dy-meal (slot 7 vax))
::
2018-03-19 06:54:47 +03:00
%|
2015-05-07 05:31:54 +03:00
=< he-pone
2015-12-21 08:05:19 +03:00
%- dy-diff(pro `(slap (slot 7 vax) [%limb %q]))
2015-05-07 05:31:54 +03:00
=+ pom=(sole-prompt +<.q.vax)
[%pro pom(cad [':' ' ' cad.pom])]
==
::
++ dy-made-gent :: generator product
2015-12-20 23:50:45 +03:00
|= cag/cage
2015-05-07 05:31:54 +03:00
(dy-meal q.cag)
::
++ dy-made-noun :: generator product
|= cag/cage
(dy-hand %noun q.cag)
::
2015-05-07 05:31:54 +03:00
++ dy-make :: build step
^+ +>
?> ?=(^ cud)
2015-09-10 01:57:25 +03:00
=+ bil=q.u.cud :: XX =*
2015-12-09 04:54:26 +03:00
?: ?=($ur -.bil)
(dy-request /hand `request:http`[%'GET' p.bil ~ ~])
2015-05-07 05:31:54 +03:00
%- dy-ford
^- [path schematic:ford]
2015-09-12 00:15:25 +03:00
?- -.bil
2015-12-09 10:12:11 +03:00
$ge (dy-silk-config (dy-cage p.p.p.bil) q.p.bil)
$dv [/hand [%core [he-disc (weld /hoon (flop p.bil))]]]
2015-12-09 10:12:11 +03:00
$ex [/hand (dy-mare p.bil)]
$sa [/hand [%bunt he-disc p.bil]]
$as [/hand [%cast he-disc p.bil [%$ (dy-cage p.q.bil)]]]
2017-09-19 23:08:18 +03:00
$do [/hand [%call (dy-mare p.bil) [%$ (dy-cage p.q.bil)]]]
2015-12-09 10:12:11 +03:00
$tu :- /hand
:+ %$ %noun
2015-05-07 05:31:54 +03:00
|- ^- vase
2015-09-10 01:57:25 +03:00
?~ p.bil !!
=+ hed=(dy-vase p.i.p.bil)
?~ t.p.bil hed
(slop hed $(p.bil t.p.bil))
2015-05-07 05:31:54 +03:00
==
::
2017-11-17 00:50:03 +03:00
++ dy-hoon-mark :: XX architect
2015-09-09 00:05:40 +03:00
=+ ^= ope
2017-11-17 00:50:03 +03:00
|= gen/hoon ^- hoon
2018-05-27 23:01:04 +03:00
?: ?=(?($sgld $sgbn) -.gen)
2015-09-09 00:05:40 +03:00
$(gen q.gen)
=+ ~(open ap gen)
?.(=(gen -) $(gen -) gen)
2017-11-17 00:50:03 +03:00
|= gen/hoon ^- (unit mark)
2015-09-09 00:05:40 +03:00
=. gen (ope gen)
2018-03-19 07:18:20 +03:00
?: ?=({$cnts {@ ~} ~} gen)
2015-09-10 01:57:25 +03:00
(bind (~(get by var) i.p.gen) head)
2018-03-13 04:20:48 +03:00
~
2015-09-09 00:05:40 +03:00
::
2015-06-02 21:36:56 +03:00
++ dy-mare :: build expression
2017-11-17 00:50:03 +03:00
|= gen/hoon
^- schematic:ford
2017-11-17 00:50:03 +03:00
=+ too=(dy-hoon-mark gen)
=- ?~(too - [%cast he-disc u.too -])
2015-09-04 04:29:34 +03:00
:+ %ride gen
2017-11-17 00:50:03 +03:00
:- [%$ dy-hoon-head]
:^ %plan he-rail `coin`blob+**
`scaffold:ford`[he-rail zuse sur lib ~ ~]
2015-06-02 21:36:56 +03:00
::
2015-05-07 05:31:54 +03:00
++ dy-step :: advance project
2015-12-20 23:50:45 +03:00
|= nex/@ud
2015-05-07 05:31:54 +03:00
^+ +>+>
2018-03-19 07:18:20 +03:00
?> ?=(~ cud)
2015-05-07 05:31:54 +03:00
?: =(nex num)
2019-01-15 20:19:07 +03:00
dy-over
2015-05-07 05:31:54 +03:00
dy-make(cud `[nex (~(got by job) nex)])
--
::
++ he-dope
2015-12-20 23:50:45 +03:00
|= txt/tape ::
2015-12-21 00:16:39 +03:00
^- (each (unit (each dojo-command tape)) hair) :: prefix+result
2015-09-04 01:10:18 +03:00
=+ len=+((lent txt)) :: line length
=. txt (weld buf `tape`(weld txt "\0a")) ::
=+ vex=((full parse-command-line:he-parser) [1 1] txt)
?: =(q.p.vex len) :: matched to line end
2015-09-04 01:10:18 +03:00
[%& ~] ::
2015-12-20 23:50:45 +03:00
?: =(p.p.vex +((lent (skim txt |=(a/@ =(10 a)))))) :: parsed all lines
2015-12-29 01:01:44 +03:00
[%& ~ ?~(q.vex [%| txt] [%& p.u.q.vex])] :: new buffer+complete
2015-09-04 01:10:18 +03:00
[%| p.p.vex (dec q.p.vex)] :: syntax error
2019-01-18 08:37:34 +03:00
::
2015-05-07 05:31:54 +03:00
++ he-duke :: ++he-dope variant
2015-12-20 23:50:45 +03:00
|= txt/tape
2015-12-09 10:12:11 +03:00
^- (each (unit (each dojo-command tape)) @ud)
2015-05-07 05:31:54 +03:00
=+ foy=(he-dope txt)
?- -.foy
2018-03-19 06:54:47 +03:00
%| [%| q.p.foy]
%& [%& p.foy]
2015-05-07 05:31:54 +03:00
==
::
++ he-abet :: resolve
[(flop moz) %_(+> hoc (~(put by hoc) ost.hid +<+))]
::
++ he-abut :: discard
=> he-stop
[(flop moz) %_(+> hoc (~(del by hoc) ost.hid))]
2015-05-07 05:31:54 +03:00
::
++ he-card :: emit gift
2015-12-20 23:50:45 +03:00
|= cad/card
2015-05-07 05:31:54 +03:00
^+ +>
%_(+> moz [[ost.hid cad] moz])
2015-05-07 05:31:54 +03:00
::
++ he-send
2015-12-20 23:50:45 +03:00
|= {way/wire him/ship dap/term cop/clap}
2015-05-07 05:31:54 +03:00
^+ +>
(he-card %send way [him dap] cop)
::
++ he-diff :: emit update
2015-12-20 23:50:45 +03:00
|= fec/sole-effect
2015-05-07 05:31:54 +03:00
^+ +>
(he-card %diff %sole-effect fec)
::
++ he-stop :: abort work
^+ .
?~(poy . ~(dy-stop dy u.poy))
::
++ he-peer :: subscribe to
2015-12-20 23:50:45 +03:00
|=(pax/path ?>(=(~ pax) he-prom))
2015-05-07 05:31:54 +03:00
::
++ he-pine :: restore prompt
^+ .
?^ poy .
he-prom:he-pone
::
++ he-errd :: reject update
|= {rev/(unit sole-edit) err/@u} ^+ +>
=+ red=(fall rev [%nop ~]) :: required for error location sync
2018-12-12 00:39:39 +03:00
=^ lic say (~(transmit sole say) red)
(he-diff %mor [%det lic] [%err err] ~)
::
2015-05-07 05:31:54 +03:00
++ he-pone :: clear prompt
^+ .
2018-12-12 00:39:39 +03:00
=^ cal say (~(transmit sole say) [%set ~])
2015-05-07 05:31:54 +03:00
(he-diff %mor [%det cal] ~)
::
++ he-prow :: where we are
^- tape
?: &(=(our.hid p.dir) =(%home q.dir) =([%ud 0] r.dir) =(~ s.dir)) ~
%+ weld
?: &(=(our.hid p.dir) =([%ud 0] r.dir))
(weld "/" (trip q.dir))
;: weld
"/" ?:(=(our.hid p.dir) "=" (scow %p p.dir))
"/" ?:(=(%home q.dir) "=" (trip q.dir))
"/" ?:(=([%ud 0] r.dir) "=" (scow r.dir))
2019-01-18 08:37:34 +03:00
==
2015-12-07 22:24:35 +03:00
?:(=(~ s.dir) "" (spud (flop s.dir)))
::
2015-05-07 05:31:54 +03:00
++ he-prom :: send prompt
%- he-diff
:- %pro
[& %$ (weld he-prow ?~(buf "> " "< "))]
2015-05-07 05:31:54 +03:00
::
++ he-made :: result from ford
|= $: way=wire
date=@da
$= result
$% [%complete build-result=build-result:ford]
[%incomplete =tang]
== ==
2015-05-07 05:31:54 +03:00
^+ +>
?> ?=(^ poy)
=< he-pine
?- -.result
%incomplete
(he-diff(poy ~) %tan tang.result)
::
%complete
?- -.build-result.result
::
%success
::
%. (result-to-cage:ford build-result.result)
=+ dye=~(. dy u.poy(pux ~))
?+ way !!
{$hand ~} dy-hand:dye
{$dial ~} dy-made-dial:dye
{$gent ~} dy-made-gent:dye
{$noun ~} dy-made-noun:dye
{$edit ~} dy-made-edit:dye
==
::
%error
(he-diff(poy ~) %tan message.build-result.result)
== ==
2015-05-07 05:31:54 +03:00
::
++ he-unto :: result from behn
|= {way/wire cit/cuft:gall}
2015-05-07 05:31:54 +03:00
^+ +>
2015-12-09 04:54:26 +03:00
?. ?=($coup -.cit)
~& [%strange-unto cit]
+>
2019-01-18 08:37:34 +03:00
?~ p.cit
2015-05-07 05:31:54 +03:00
(he-diff %txt ">=")
(he-diff %tan u.p.cit)
:: +he-http-response: result from http-client
::
++ he-http-response
|= [way=wire response=client-response:http-client]
^+ +>
?> ?=(^ poy)
=< he-pine
?. ?=(%finished -.response)
~& %dojo-received-http-progress
+>
::
~! response
%. [%httr !>((to-httr:http-client response-header.response full-file.response))]
=+ dye=~(. dy u.poy(pux ~))
?+ way !!
{$hand ~} dy-hand:dye
{$show ~} dy-show:dye
==
2015-05-07 05:31:54 +03:00
::
++ he-lens
|= com/command:lens
^+ +>
=+ ^- source/dojo-source
=| num/@
=- ?. ?=($send-api -.sink.com) :: XX num is incorrect
sor
:- 0
:+ %as `mark`(cat 3 api.sink.com '-poke')
:- 1
:+ %do
^- hoon
:+ %brtr [%base %noun]
:^ %clls [%rock %tas %post]
[%rock %$ endpoint.sink.com]
[%cnts [%& 6]~ ~]
sor
^= sor
|- ^- dojo-source
:- num
?- -.source.com
$data [%ex %sand %t data.source.com]
$dojo
%+ rash command.source.com
(ifix [(punt gap) (punt gap)] parse-build:he-parser)
::
$clay
:- %ex
^- hoon
:+ %dtkt
[%base %noun]
:+ %clhp
[%rock %tas %cx]
%+ rash pax.source.com
rood:(vang | /(scot %p our.hid)/home/(scot %da now.hid))
::
$url [%ur (crip (en-purl:html url.source.com))]
$api !!
$get-api
:- %ex
^- hoon
:+ %dtkt
[%like ~[%json] ~]
:* %clsg
[%rock %tas %gx]
[%sand %ta (scot %p our.hid)]
[%sand %tas api.source.com]
[%sand %ta (scot %da now.hid)]
(turn endpoint.source.com |=(a/@t [%sand %ta a]))
==
::
$listen-api !!
$as
:* %as mar.source.com
$(num +(num), source.com next.source.com)
==
::
$hoon
:* %do
%+ rash code.source.com
tall:(vang | /(scot %p our.hid)/home/(scot %da now.hid))
$(num +(num), source.com next.source.com)
==
::
$tuple
:- %tu
|- ^- (list dojo-source)
?~ next.source.com
~
=. num +(num)
:- ^$(source.com i.next.source.com)
$(next.source.com t.next.source.com)
==
=+ |- ^- sink/dojo-sink
?- -.sink.com
$stdout [%show %0]
$output-file $(sink.com [%command (cat 3 '@' pax.sink.com)])
$output-pill $(sink.com [%command (cat 3 '.' pax.sink.com)])
2018-12-12 00:48:34 +03:00
$output-clay [%file (need (de-beam:format pax.sink.com))]
$url [%http %post (crip (en-purl:html url.sink.com))]
$to-api !!
$send-api [%poke our.hid api.sink.com]
$command (rash command.sink.com parse-sink:he-parser)
$app [%poke our.hid app.sink.com]
==
(he-plan sink source)
::
2015-05-07 05:31:54 +03:00
++ he-like :: accept line
2015-12-20 23:50:45 +03:00
|= buf/(list @c)
2015-05-07 05:31:54 +03:00
=(%& -:(he-dope (tufa buf)))
::
++ he-stir :: apply change
2015-12-20 23:50:45 +03:00
|= cal/sole-change
2015-05-07 05:31:54 +03:00
^+ +>
:: ~& [%his-clock ler.cal]
:: ~& [%our-clock ven.say]
2018-12-12 00:39:39 +03:00
=^ dat say (~(transceive sole say) cal)
2015-12-09 04:54:26 +03:00
?. ?& ?=($del -.dat)
2015-05-07 05:31:54 +03:00
=(+(p.dat) (lent buf.say))
==
+>.$
=+ foy=(he-dope (tufa buf.say))
2018-03-19 06:54:47 +03:00
?: ?=(%& -.foy) +>.$
2015-05-07 05:31:54 +03:00
:: ~& [%bad-change dat ted.cal]
:: ~& [%our-leg leg.say]
(he-errd `dat q.p.foy)
2015-05-07 05:31:54 +03:00
::
++ he-plan :: execute command
2015-12-20 23:50:45 +03:00
|= mad/dojo-command
2015-05-07 05:31:54 +03:00
^+ +>
2018-03-19 07:18:20 +03:00
?> ?=(~ poy)
2015-09-04 01:10:18 +03:00
he-pine:(dy-step:~(dy-init dy %*(. *dojo-project mad mad)) 0)
2015-05-07 05:31:54 +03:00
::
++ he-done :: parse command
2015-12-20 23:50:45 +03:00
|= txt/tape
2015-05-07 05:31:54 +03:00
^+ +>
?~ txt
2015-09-10 03:52:55 +03:00
=< he-prom(buf ~)
2015-05-07 05:31:54 +03:00
%- he-diff
:~ %mor
[%txt "> "]
[%nex ~]
==
=+ doy=(he-duke txt)
?- -.doy
2018-03-19 06:54:47 +03:00
%| (he-errd ~ p.doy)
%&
2015-09-04 01:10:18 +03:00
?~ p.doy
(he-errd ~ (lent txt))
2015-09-04 04:40:30 +03:00
=+ old=(weld ?~(buf "> " " ") (tufa buf.say))
2018-12-12 00:39:39 +03:00
=^ cal say (~(transmit sole say) [%set ~])
2015-12-21 00:16:39 +03:00
=. +>.$ (he-diff %mor txt+old nex+~ det+cal ~)
2015-09-04 01:10:18 +03:00
?- -.u.p.doy
2018-03-19 06:54:47 +03:00
%& (he-plan(buf ~) p.u.p.doy)
%| he-prom(buf p.u.p.doy)
2015-05-07 05:31:54 +03:00
==
==
::
2017-11-16 23:44:27 +03:00
++ he-type :: apply input
2015-12-20 23:50:45 +03:00
|= act/sole-action
2015-05-07 05:31:54 +03:00
^+ +>
?^ poy
2017-11-16 23:44:27 +03:00
he-pine:(~(dy-type dy u.poy) act)
2015-05-07 05:31:54 +03:00
?- -.act
2015-12-09 10:12:11 +03:00
$det (he-stir +.act)
$ret (he-done (tufa buf.say))
$clr he-pine(buf "")
2015-05-07 05:31:54 +03:00
==
::
++ he-lame :: handle error
2015-12-20 23:50:45 +03:00
|= {wut/term why/tang}
^+ +>
%- (slog (flop `tang`[>%dojo-lame wut< why]))
?^ poy
he-pine:~(dy-amok dy u.poy)
he-pine :: XX give mean to original keystroke
2015-05-07 05:31:54 +03:00
--
::
2015-09-04 01:10:18 +03:00
++ prep
2018-03-18 04:06:15 +03:00
|= old/(unit house)
^+ [~ ..prep]
2015-09-04 01:10:18 +03:00
?~ old `..prep
2018-03-18 04:06:15 +03:00
`..prep(+<+ u.old)
2015-09-04 01:10:18 +03:00
::
2015-09-09 03:10:42 +03:00
:: pattern: ++ foo |=(data he-abet:(~(he-foo he (~(got by hoc) ost)) data))
++ arm (arm-session ~ (~(got by hoc) ost.hid))
2015-09-09 03:10:42 +03:00
++ arm-session
2015-12-20 23:50:45 +03:00
|= {moz/(list move) ses/session}
=> ~(. he moz ses)
2015-09-09 03:10:42 +03:00
=- [wrap=- +]
2017-12-16 07:13:50 +03:00
=+ he-arm=he-type
2018-05-27 22:15:15 +03:00
|@ ++ $
2019-01-18 08:37:34 +03:00
|: +<.he-arm
2017-12-16 07:13:50 +03:00
^- (quip move _..he)
he-abet:(he-arm +<)
--
2015-09-09 03:10:42 +03:00
::
++ peer-sole
~? !=(our.hid src.hid) [%dojo-peer-stranger ost.hid src.hid]
?> (team:title our.hid src.hid)
=^ moz .
?. (~(has by hoc) ost.hid) [~ .]
~& [%dojo-peer-replaced ost.hid]
~(he-abut he ~ (~(got by hoc) ost.hid))
2015-12-21 00:16:39 +03:00
=+ ses=%*(. *session -.dir [our.hid %home ud+0])
(wrap he-peer):(arm-session moz ses)
2015-05-07 05:31:54 +03:00
::
++ poke-sole-action
2015-12-21 00:16:39 +03:00
|= act/sole-action ~| poke+act %. act
2017-11-16 23:44:27 +03:00
(wrap he-type):arm
2016-02-24 04:15:36 +03:00
::
++ poke-lens-command
|= com/command:lens ~| poke-lens+com %. com
(wrap he-lens):arm
::
2016-02-24 04:15:36 +03:00
++ poke-json
|= jon=json
^- [(list move) _+>.$]
2016-02-24 04:15:36 +03:00
~& jon=jon
[~ +>.$]
:: +poke-wipe: clear all dojo sessions
::
++ poke-wipe
|= *
^- [(list move) _+>.$]
~& %dojo-wipe
=. hoc
%- ~(run by hoc)
|= =session
%_ session
sur ~
lib ~
var ~
old ~
==
::
[~ +>.$]
2016-02-24 04:15:36 +03:00
::
2015-09-09 03:10:42 +03:00
++ made (wrap he-made):arm
++ http-response (wrap he-http-response):arm
2015-09-09 03:10:42 +03:00
++ lame (wrap he-lame):arm
++ unto (wrap he-unto):arm
2015-05-07 05:31:54 +03:00
++ pull
2015-12-20 23:50:45 +03:00
|= {pax/path}
^- (quip move _+>)
=^ moz +> ~(he-abut he ~ (~(got by hoc) ost.hid))
2015-05-28 09:51:32 +03:00
[moz +>.$(hoc (~(del by hoc) ost.hid))]
2015-05-07 05:31:54 +03:00
--