urbit/shrub
1
1
Fork 0
mirror of https://github.com/urbit/shrub.git synced 2024-12-20 09:21:42 +03:00
Code Issues Packages Projects Releases Wiki Activity
771816b908
shrub/tests/lib/dprint.hoon

319 lines
6.3 KiB
Plaintext
Raw Normal View History

doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
:: This library contains unit tests for doccords.
::
/+ *test, *dprint
::
doccords: unit test for core dox
2022-05-09 23:01:32 +03:00
=> =>
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-summary
::
:: core-description
hoon, dprint: remove |% and |@ core names partial revert of 3d3ea61d53, which introduced core names by completing an unimplemented feature that was already present in hoon.hoon. we've decided to remove this for the initial launch since it violates the principle of least surprise for the name of a core to end up in its $garb and yet only be used for doccords, as opposed to something like a wing resolution. it was also confusing that this only worked for |% and |@. this breaks two of the tests for the dprint library, which have been commented out. these tests ought to be restored once dprint is rewritten in order to implement a different way to refer to cores not built by arms
2022-11-16 01:48:07 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: chapter-summary
::
:: chapter-description
doccords: unit test for chapter dox
2022-05-09 23:45:16 +03:00
+| %chapter-test
doccords: unit test for core dox
2022-05-09 23:01:32 +03:00
++ empty ~
--
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: arms used for testing doccords
hoon, dprint: remove |% and |@ core names partial revert of 3d3ea61d53, which introduced core names by completing an unimplemented feature that was already present in hoon.hoon. we've decided to remove this for the initial launch since it violates the principle of least surprise for the name of a core to end up in its $garb and yet only be used for doccords, as opposed to something like a wing resolution. it was also confusing that this only worked for |% and |@. this breaks two of the tests for the dprint library, which have been commented out. these tests ought to be restored once dprint is rewritten in order to implement a different way to refer to cores not built by arms
2022-11-16 01:48:07 +03:00
|%
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
+| %types
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
+$ arm-dox [tape what what what]
hoon, dprint: remove |% and |@ core names partial revert of 3d3ea61d53, which introduced core names by completing an unimplemented feature that was already present in hoon.hoon. we've decided to remove this for the initial launch since it violates the principle of least surprise for the name of a core to end up in its $garb and yet only be used for doccords, as opposed to something like a wing resolution. it was also confusing that this only worked for |% and |@. this breaks two of the tests for the dprint library, which have been commented out. these tests ought to be restored once dprint is rewritten in order to implement a different way to refer to cores not built by arms
2022-11-16 01:48:07 +03:00
+$ core-dox what
doccords: unit test for chapter dox
2022-05-09 23:45:16 +03:00
+$ chapter-dox [tape what]
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
+| %helper-functions
++ get-item
|= a=(list term)
^- item
dprint: fix test library argument
2022-07-01 00:18:09 +03:00
+:(find-item-in-type a -:!>(.))
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
++ get-arm-dox
|= a=(list term)
^- arm-dox
=/ itm=item (get-item a)
?> ?=([%arm *] itm)
[name adoc pdoc cdoc]:itm
::
doccords: unit test for core dox
2022-05-09 23:01:32 +03:00
++ get-core-dox
|= a=(list term)
^- core-dox
=/ itm=item (get-item a)
?> ?=([%core *] itm)
hoon, dprint: remove |% and |@ core names partial revert of 3d3ea61d53, which introduced core names by completing an unimplemented feature that was already present in hoon.hoon. we've decided to remove this for the initial launch since it violates the principle of least surprise for the name of a core to end up in its $garb and yet only be used for doccords, as opposed to something like a wing resolution. it was also confusing that this only worked for |% and |@. this breaks two of the tests for the dprint library, which have been commented out. these tests ought to be restored once dprint is rewritten in order to implement a different way to refer to cores not built by arms
2022-11-16 01:48:07 +03:00
docs:itm
doccords: unit test for core dox
2022-05-09 23:01:32 +03:00
::
doccords: unit test for chapter dox
2022-05-09 23:45:16 +03:00
++ get-chapter-dox
|= a=(list term)
^- chapter-dox
=/ itm=item (get-item a)
?> ?=([%chapter *] itm)
[name docs]:itm
::
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
++ arm-check
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
|= [arms=(list term) wat=(trel ? ? ?) docs=(trel what what what)]
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
^- tang
=| res=tang
|-
?~ arms res
%= $
arms t.arms
res %+ weld
res
%+ expect-eq
!> ^- arm-dox
:* (trip i.arms)
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
?:(p.wat p.docs *what)
?:(q.wat q.docs *what)
?:(r.wat r.docs *what)
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
==
::
!> (get-arm-dox ~[i.arms])
==
::
++ run-arm-tests
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
|= [wat=(trel ? ? ?)]
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
^- tang
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
=/ num (sub 3 :(add p.wat q.wat r.wat))
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
=/ prefix=term
;: (cury cat 3)
%arm-
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
?:(p.wat %adoc- ~)
?:(q.wat %pdoc- ~)
?:(r.wat %cdoc- ~)
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
==
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
=/ arms=(list term)
%- turn
:_ |= [postfix=term]
`term`(cat 3 prefix postfix)
^- (list term)
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
?+ num ~
%1 ~[%pre %post]
%2 ~[%pre-pre %post-pre %post-post]
%3 :~ %pre-pre-pre
%pre-pre-post
%pre-post-pre
%post-pre-pre
%pre-post-post
%post-pre-post
%post-post-pre
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
==
==
%^ arm-check
arms
wat
[`['arm-doc' ~] `['product-doc' ~] `['core-doc' ~]]
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
::
+| %batch-comments
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: +b-foo: a foo
:: $b-baz: a baz
:: +b-bar: a bar
::
:: a very bar foo
::
:: $b-boz: a boz
::
:: a very boz baz
::
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
++ b-foo ~
++ b-bar ~
+$ b-baz *
+$ b-boz *
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
::
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
+| %docs-for-arms
++ no-doc ~
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: +arm-adoc-pre: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ arm-adoc-pre ~
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ arm-adoc-post :: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
~
::
++ arm-pdoc-pre
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
'foo'
++ arm-pdoc-post
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
'foo' :: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
++ arm-cdoc-pre
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ $ ~
--
::
++ arm-cdoc-post
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ $ :: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
~
--
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: +arm-adoc-pdoc-pre-pre: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ arm-adoc-pdoc-pre-pre
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
'foo'
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ arm-adoc-pdoc-post-pre :: arm-doc
:: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
'foo'
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ arm-adoc-pdoc-post-post :: arm-doc
'foo' :: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: +arm-adoc-cdoc-pre-pre: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ arm-adoc-cdoc-pre-pre
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ $ ~
--
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ arm-adoc-cdoc-post-pre :: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ $ ~
--
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ arm-adoc-cdoc-post-post :: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ $ :: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
~
--
::
++ arm-pdoc-cdoc-pre-pre
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ $ ~
--
++ arm-pdoc-cdoc-post-pre
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ $ ~
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
-- :: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
++ arm-pdoc-cdoc-post-post
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ $ :: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
~
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
-- :: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: +arm-adoc-pdoc-cdoc-pre-pre-pre: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ arm-adoc-pdoc-cdoc-pre-pre-pre
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ $ ~
--
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ arm-adoc-pdoc-cdoc-post-pre-pre :: arm-doc
:: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ $ ~
--
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: +arm-adoc-pdoc-cdoc-pre-post-pre: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ arm-adoc-pdoc-cdoc-pre-post-pre
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ $ ~
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
-- :: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: +arm-adoc-pdoc-cdoc-pre-pre-post: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ arm-adoc-pdoc-cdoc-pre-pre-post
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ $ :: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
~
--
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ arm-adoc-pdoc-cdoc-post-post-pre :: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ $ ~
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
-- :: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ arm-adoc-pdoc-cdoc-post-pre-post :: arm-doc
:: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ $ :: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
~
--
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: +arm-adoc-pdoc-cdoc-pre-post-post: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ arm-adoc-pdoc-cdoc-pre-post-post
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ $ :: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
~
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
-- :: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ arm-adoc-pdoc-cdoc-post-post-post :: arm-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
|%
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
++ $ :: core-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
~
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
-- :: product-doc
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
--
::
hoon, dprint: change doccords syntax to :: this constitutes a pretty major rework of how whitespace is handled in hoon in order to change the doccords syntax from :> and :< to ::. in summary: throughout the hoon parser (+vast) many instances of +gap have been replaced by +jump, which first tries to remove whitespace (+leap) until it arrives at something that can be parsed as a prefix doccord (+apex:docs:vast). if it does not encounter a doccord, it instead uses +gap as normal. if you follow along with the parser, you will notice that every time jump is called, it then tries to call +apex:docs via +scye or +seam. if apex:docs succeeds, it will end up consuming a newline at the end, hiding the fact that there was valid whitespace from the parser. thus +apex:docs then inserts a newline after successfully parsing a prefix doccord, which will then be consumed by a subsequent invocation of +gap, ensuring that there was proper whitespace if the doccord would have been consumed by +gap instead of +leap. there are a few other changes: +hint in the compiler throws out doccords attached to %noun types. this was already the behavior before doccords, and the change was made before i understood what i was doing. similarly for commenting out the %note case in +open:ap - this was an earlier mistake postfix comments for chapters are now enabled. +expx was unused and removed in order to be rid of the convention-defying +exp1. other unused +ex(p/q)* were commented out. arms that handle batch comments (+glow and +whap) were refactored +toad, which was used to change between tall and wide form, tries to +jump before +gap. since +jump is ;~(pose leap:docs gap), i would have thought that just using +jump there would be fine, but it fails for some reason. some parsers built with |@ were rewritten to use |* |$ was made so that any doccords put on the spec are converted into hoon doccords on the $ arm. it wouldn't compile otherwise. there's probably a more principled way to do this but it works fine for now.
2022-07-19 21:57:36 +03:00
:: contains the actual tests to be run by -test
hoon, dprint: remove |% and |@ core names partial revert of 3d3ea61d53, which introduced core names by completing an unimplemented feature that was already present in hoon.hoon. we've decided to remove this for the initial launch since it violates the principle of least surprise for the name of a core to end up in its $garb and yet only be used for doccords, as opposed to something like a wing resolution. it was also confusing that this only worked for |% and |@. this breaks two of the tests for the dprint library, which have been commented out. these tests ought to be restored once dprint is rewritten in order to implement a different way to refer to cores not built by arms
2022-11-16 01:48:07 +03:00
|%
dprint: batch comment tests, more refactoring
2022-07-01 20:48:48 +03:00
+| %batch-tests
++ test-b-foo
%+ expect-eq
!> ^- arm-dox
["b-foo" `['a foo' ~] *what *what]
::
!> (get-arm-dox ~[%b-foo])
::
++ test-b-bar
%+ expect-eq
!> ^- arm-dox
["b-bar" `['a bar' ~[~[[& 'a very bar foo']]]] *what *what]
::
!> (get-arm-dox ~[%b-bar])
::
++ test-b-baz
%+ expect-eq
!> ^- arm-dox
["b-baz" `['a baz' ~] *what *what]
::
!> (get-arm-dox ~[%b-baz])
::
++ test-b-boz
%+ expect-eq
!> ^- arm-dox
["b-boz" `['a boz' ~[~[[& 'a very boz baz']]]] *what *what]
::
!> (get-arm-dox ~[%b-boz])
::
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
+| %arm-tests
::
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
++ test-no-doc
%+ expect-eq
!> ^- arm-dox
["no-doc" *what *what *what]
dprint: swap expected<->actual order in unit tests
2022-06-09 18:52:38 +03:00
::
!> (get-arm-dox ~[%no-doc])
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
::
dprint: simplify arm doc testing
2022-07-01 17:39:01 +03:00
++ test-adoc (run-arm-tests & | |)
++ test-pdoc (run-arm-tests | & |)
++ test-cdoc (run-arm-tests | | &)
++ test-adoc-pdoc (run-arm-tests & & |)
++ test-adoc-cdoc (run-arm-tests & | &)
++ test-pdoc-cdoc (run-arm-tests | & &)
++ test-adoc-pdoc-cdoc (run-arm-tests & & &)
doccords: unit test for core dox
2022-05-09 23:01:32 +03:00
::
hoon, dprint: remove |% and |@ core names partial revert of 3d3ea61d53, which introduced core names by completing an unimplemented feature that was already present in hoon.hoon. we've decided to remove this for the initial launch since it violates the principle of least surprise for the name of a core to end up in its $garb and yet only be used for doccords, as opposed to something like a wing resolution. it was also confusing that this only worked for |% and |@. this breaks two of the tests for the dprint library, which have been commented out. these tests ought to be restored once dprint is rewritten in order to implement a different way to refer to cores not built by arms
2022-11-16 01:48:07 +03:00
:: +| %core-tests
:: ++ test-core
:: %+ expect-eq
:: !> ^- core-dox
:: `['core-summary' ~[~[[%.y 'core-description']]]]
:: ::
:: !> (get-core-dox ~[%core-summary])
:: ::
:: ++ test-chapter
:: %+ expect-eq
:: !> ^- chapter-dox
:: ["chapter-test" `['chapter-summary' ~[~[[%.y 'chapter-description']]]]]
:: ::
:: !> (get-chapter-dox ~[%core-summary %chapter-test])
doccords: unit test for chapter dox
2022-05-09 23:45:16 +03:00
::
doccords: unit tests for arm dox
2022-05-09 21:57:43 +03:00
--
Reference in New Issue Copy Permalink