work/ 0000775 0000000 0000000 00000000000 14777226410 006742 5 ustar work/.dir-locals.el 0000664 0000000 0000000 00000000054 14777226410 011372 0 ustar ((cperl-mode . ((cperl-indent-level . 2))))
work/.gitlab-ci.yml 0000664 0000000 0000000 00000000137 14777226410 011377 0 ustar ---
include:
- https://salsa.debian.org/salsa-ci-team/pipeline/raw/master/recipes/debian.yml
work/AGPL-3 0000664 0000000 0000000 00000103335 14777226410 007555 0 ustar GNU AFFERO GENERAL PUBLIC LICENSE
Version 3, 19 November 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU Affero General Public License is a free, copyleft license
for software and other kinds of works, specifically designed to ensure
cooperation with the community in the case of network server software.
The licenses for most software and other practical works are
designed to take away your freedom to share and change the works. By
contrast, our General Public Licenses are intended to guarantee your
freedom to share and change all versions of a program--to make sure it
remains free software for all its users.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
Developers that use our General Public Licenses protect your rights
with two steps: (1) assert copyright on the software, and (2) offer
you this License which gives you legal permission to copy, distribute
and/or modify the software.
A secondary benefit of defending all users' freedom is that
improvements made in alternate versions of the program, if they
receive widespread use, become available for other developers to
incorporate. Many developers of free software are heartened and
encouraged by the resulting cooperation. However, in the case of
software used on network servers, this result may fail to come about.
The GNU General Public License permits making a modified version and
letting the public access it on a server without ever releasing its
source code to the public.
The GNU Affero General Public License is designed specifically to
ensure that, in such cases, the modified source code becomes available
to the community. It requires the operator of a network server to
provide the source code of the modified version running there to the
users of that server. Therefore, public use of a modified version, on
a publicly accessible server, gives the public access to the source
code of the modified version.
An older license, called the Affero General Public License and
published by Affero, was designed to accomplish similar goals. This is
a different license, not a version of the Affero GPL, but Affero has
released a new version of the Affero GPL which permits relicensing under
this license.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU Affero General Public
License.
"Copyright" also means copyright-like laws that apply to other kinds
of works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further restriction,
you may remove that term. If a license document contains a further
restriction but permits relicensing or conveying under this License, you
may add to a covered work material governed by the terms of that license
document, provided that the further restriction does not survive such
relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Remote Network Interaction; Use with the GNU General Public License.
Notwithstanding any other provision of this License, if you modify the
Program, your modified version must prominently offer all users
interacting with it remotely through a computer network (if your version
supports such interaction) an opportunity to receive the Corresponding
Source of your version by providing access to the Corresponding Source
from a network server at no charge, through some standard or customary
means of facilitating copying of software. This Corresponding Source
shall include the Corresponding Source for any work covered by version 3
of the GNU General Public License that is incorporated pursuant to the
following paragraph.
Notwithstanding any other provision of this License, you have permission
to link or combine any covered work with a work licensed under version 3
of the GNU General Public License into a single combined work, and to
convey the resulting work. The terms of this License will continue to
apply to the part which is the covered work, but the work with which it is
combined will remain governed by version 3 of the GNU General Public
License.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU Affero General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may differ
in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU Affero
General Public License "or any later version" applies to it, you have
the option of following the terms and conditions either of that
numbered version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number
of the GNU Affero General Public License, you may choose any version
ever published by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU Affero General Public License can be used, that
proxy's public statement of acceptance of a version permanently
authorizes you to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If your software can interact with users remotely through a computer
network, you should also make sure that it provides a way for users to
get its source. For example, if your program is a web application, its
interface could display a "Source" link that leads users to an archive
of the code. There are many ways you could offer source, and different
solutions will be better for different programs; see section 13 for the
specific requirements.
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU AGPL, see
.
work/DEVELOPER-CERTIFICATE 0000664 0000000 0000000 00000002616 14777226410 011737 0 ustar Developer Certificate of Origin
Version 1.1
Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
1 Letterman Drive
Suite D4700
San Francisco, CA, 94129
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
Developer's Certificate of Origin 1.1
By making a contribution to this project, I certify that:
(a) The contribution was created in whole or in part by me and I
have the right to submit it under the open source license
indicated in the file; or
(b) The contribution is based upon previous work that, to the best
of my knowledge, is covered under an appropriate open source
license and I have the right under that license to submit that
work with modifications, whether created in whole or in part
by me, under the same open source license (unless I am
permitted to submit under a different license), as indicated
in the file; or
(c) The contribution was provided directly to me by some other
person who certified (a), (b) or (c) and I have not modified
it.
(d) I understand and agree that this project and the contribution
are public and that a record of the contribution (including all
personal information I submit with it, including my sign-off) is
maintained indefinitely and may be redistributed consistent with
this project or the open source license(s) involved.
work/LICENSE 0000664 0000000 0000000 00000000053 14777226410 007745 0 ustar SPDX-License-Identifier: AGPL-3.0-or-later
work/README.md 0000664 0000000 0000000 00000110167 14777226410 010227 0 ustar nailing-cargo
=============
This is a wrapper tool for cargo, the Rust build tool and package
manager. Functions:
* Perform out-of-tree builds, including in an account with
no write access to the source tree.
* Conveniently use local crates, including completely
unpublished crates.
* Provide convenience aliases for target architecture names.
* Make the default be offline (ie, not to access the internet).
These functions are of course configurable.
A default method for out-of-tree builds is usually configured in
`~/.nailing-cargo.toml`.
To configure project-specific methods for out-of-tree builds, and to
configure the use of local crates to override crates from `crates.io`,
you will also need a `../Cargo.nail`, which is in TOML syntax.
You put `Cargo.nail` alongside the top-level git repositories you are
working with, and invoke nailing-cargo from the git directory
containing the Rust package you want to build.
Installing
----------
nailing-cargo is designed to be run out of a git clone:
```
$ git clone https://salsa.debian.org/iwj/nailing-cargo.git
$ ln -s `pwd`/nailing-cargo/nailing-cargo ~/bin
```
It is self-contained, depending only on a reasonably functional Perl
installation.
Most basic example usage with nailing
-------------------------------------
```
$ cd myproject
$ cat >../Cargo.nail
subdirs="""
myproject
mylibrary
"""
$ nailing-cargo -u fetch
$ nailing-cargo build
```
Documentation table of contents
-------------------------------
* [Introduction](#nailing-cargo)
* [Installing](#installing)
* [Most basic example usage with nailing](#most-basic-example-usage-with-nailing)
* [Documentation table of contents](#documentation-table-of-contents)
* [Out-of-tree builds](#out-of-tree-builds)
* [How nailing-cargo helps with out-of-tree builds](#how-nailing-cargo-helps-with-out-of-tree-builds)
* [Configuring out-of-tree builds](#configuring-out-of-tree-builds)
* [Using local crates, or locally modified crates](#using-local-crates-or-locally-modified-crates)
* [How nailing-cargo helps with using local crates](#how-nailing-cargo-helps-with-using-local-crates)
* [Telling nailing-cargo how to massage `Cargo.toml`](#telling-nailing-cargo-how-to-massage-cargo.toml)
* [Scope of nailing-cargo's local crate functionality](#scope-of-nailing-cargos-local-crate-functionality)
* [Target architecture convenience aliases](#target-architecture-convenience-aliases)
* [Default change to offline mode](#default-change-to-offline-mode)
* [Invocation and command-line option reference](#invocation-and-command-line-option-reference)
* [Usages](#usages)
* [Options](#options)
* [Environment of the build command](#environment-of-the-build-command)
* [Configuration reference](#configuration-reference)
* [Source directories and packages (toplevel)](#source-directories-and-packages-toplevel)
* [`[alt_cargolock]`: Alternative `Cargo.lock` filename](#alt_cargolock-alternative-cargo.lock-filename)
* [`[oot]`: Out-of-tree build support](#oot-out-of-tree-build-support)
* [`[arch]`: Architecture convenience aliases](#arch-architecture-convenience-aliases)
* [`[misc]`: Miscellaneous individual nailing-cargo config](#misc-miscellaneous-individual-nailing-cargo-config)
* [Limitations and bugs](#limitations-and-bugs)
* [Contributing and legal](#contributing-and-legal)
* [Legal](#legal)
Out-of-tree builds
==================
It is often desirable to run builds in a way that does not write to
the source tree. cargo's enthusiastic approach to the dependency
management task means that it is a good idea to try to insulate your
main working environment from the many things cargo has decided to
download and execute.
However, when you tell cargo to do an out of tree build (using
`--manifest-path`) it will insist on `Cargo.lock` being in the source
directory, and often will insist on writing to it.
How nailing-cargo helps with out-of-tree builds
-----------------------------------------------
nailing-cargo (configured appropriately) copies files back and forth
to between the source and build directories, and runs cargo as your
build user.
The `Cargo.lock` must still be saved in your source tree somewhere.
nailing-cargo arranges this for you. You can either put this file in
`.gitignore`; or commit it to git; or you can tell nailing-cargo to
save it as something like `Cargo.lock.example`.
Depending on the circumstances, nailing-cargo uses a variety of
strategies, including `--manifest-path` options, and linkfarming, to
make out of tree builds. Some crates don't natively support
out-of-tree builds, in which case passing a `--linkfarm` option to
nailing-cargo can be helpful.
Configuring out-of-tree builds
------------------------------
To enable out-of-tree-builds, put an `[oot]` section in your
`Cargo.nail` or one of nailing-cargo's other config files.
In that section, specify at least `use`.
Also, specify `dir`, or create a symlink `Build` next to `Cargo.nail`,
pointing to to your build area.
For example,
```
[oot]
use='ssh'
user='rustcargo'
```
will have nailing-cargo run `ssh rustcargo@localhost` to
run build commands.
Using local crates, or locally modified crates
==============================================
cargo does not work well with local crates,
especially completely unpublished ones.
(See [issue#6713](https://github.com/rust-lang/cargo/issues/6713),
[stackoverflow](https://stackoverflow.com/questions/33025887/how-to-use-a-local-unpublished-crate),
[issue#1481](https://github.com/rust-lang/cargo/issues/1481),
[my blog](https://diziet.dreamwidth.org/1805.html).)
Using a local version of a crate should be possible without putting
paths into your `Cargo.toml` and without editing complex
configuration.
How nailing-cargo helps with using local crates
-----------------------------------------------
nailing-cargo temporarily edits all the `Cargo.toml` files in all the
subdirectories you mention, to refer to each other; then it runs
cargo; and then it puts everything back.
Telling nailing-cargo how to massage `Cargo.toml`
-------------------------------------------------
To find the subdirectories, and the packages, nailing-cargo looks for
`subdirs` and `packages` in `Cargo.nail`.
For straightforward use, write `subdirs` as a multi-line string
containing a list of subdirectory names one per line. In each of
these directories `Cargo.toml` will be massaged, and the package there
will be used for other massaged `Cargo.toml`s.
See the [Configuration reference](#configuration-reference) for full details.
Scope of nailing-cargo's local crate functionality
--------------------------------------------------
nailing-cargo's `Cargo.toml` massaging will allow you to easily build
an interdepending set of local packages, possibly even including
private unpublished packages, and/or locally-modified versions of
published packages. These local packages can freely depend on
published packages (eg from `crates.io`) in the usual way.
Compared to the corresponding cargo feature, nailing-cargo's approach:
(i) works even for local crates that have not been published anywhere; and
(ii) is a lot simpler to configure.
But nailing-cargo's local crate support won't work if any non-local
crate needs to be rebuilt against a local crate (ie, a local version
of one of its dependencies). If that is your requirement, either make
local versions of the intermediate crates in the dependency graph, or
use the cargo override facility --- see [Overriding
Dependencies](https://doc.rust-lang.org/cargo/reference/overriding-dependencies.html)
in the Cargo Book.
Target architecture convenience aliases
=======================================
If you are cross-building you may need to tell cargo `--target=`.
The architecture names are quite long and inconvenient.
A simple shell alias would help a lot, except that cargo rejects
`--target=` when it thinks it's not needed.
In your nailing-cargo config, you can write something like
`arch.RPI='arm-unknown-linux-gnueabihf'`. Then `nailing-cargo -TRPI`
will DTRT. In fact, you do not even need to specify that particular
arch alias, since it is built-in to nailing-cargo.
Default change to offline mode
==============================
It seems to me that build tools should be explicit about their use of
the network. So by default, nailing-cargo passes `--offline` to
cargo.
If you disagree with my opinion, write `misc.online=true` in your
nailing-cargo configuration. `misc.online=false`, and command line
options, are also available, for overriding.
If you agree with me, you may wish to use `nailing-cargo
generate-lockfile`, which can update (even an existing) `Cargo.lock`
without going online, instead of `update`.
Invocation and command-line option reference
============================================
Usages
------
```
1$ nailing-cargo [--] ...
2$ nailing-cargo --- [--] ...
3$ nailing-cargo --- [--] ...
```
Ususally the `--` is not needed. (It should generally be passed by
programs which wrap nailing-cargo. See [Invocation argument disambiguation rules](#invocation-argument-disambiguation-rules), below.)
In usage 1, nailing-cargo runs `cargo` (from `PATH`). In the usage 2
nailing-cargo runs ``. In both these cases it adds its own
options to control cargo's behaviour. In both of these cases
nailing-cargo looks at `` to determine the cargo subcommand
being run: this controls various defaults, to try to do the right
things.
In the third syntax, nailing-cargo runs `...` without
additional arguments and does not attempt to identify the cargo
subcommand(s) that it will run. Possibly it will be necessary to pass
`--online` or `--cargo-lock-update`, or even `--cargo-*arg*`
### Invocation argument disambiguation rules ###
For authors of tools which call nailing-cargo (and pedants):
The usages overlap in syntax! nailing-cargo follows the following
rules when interpreting its command line:
* The first option not recognised as a nailing-cargo option is
treated as the start of the ``.
* `` are terminated by `--` (which is removed) or the
first argument which does not start with a `-` or `+`.
(It is not possible to get nailing-cargo to pass the value `--`
as a separate argument to a cargo global option, but cargo global
options can typically take the values cuddled with `=`, so doing
that is not necessary.)
* After `---`, nailing-cargo will search for a `--`, to the end of
the arguments if necessary. The position of the `--` determines
whether this is usage 2 or usage 3, and what `` is.
If the arguments after `nailing-cargo ... ---` might contain `--`
anywhere, an explicit `--` should be passed.
* If no `--` appears after `---`, the word after `---` is the
command to run; if its final pathname component contains the
string `cargo`, it is treated as `` (implying usage 2 and
the search for ``). Otherwise it is treated as
`` (usage 3).
Options
-------
* `-v`: Increase verbosity. Default is 1.
* `-q`: Set verbosity to 0.
* `-D`: Increase amount of debugging dump.
* `-n`: "No action": stop after writing `Cargo.toml.nailing~`
everywhere, and do not run any build command.
* `-f` | `--force`: Force going ahead even if problems are likely.
(E.g., due to missing `-E` option.)
* `-T` | `--target=`
Specify target architecture.
This option translates to a `--target=` option to cargo
(when the subcommand accepts it).
If `` starts with a capital ascii letter, it is an alias
for some other arch: it is looked up in the configuration, and
then in the builtin arch alias list. The builtin list is
equivalent to:
```
[arch]
RPI="arm-unknown-linux-gnueabihf"
WASM="wasm32-unknown-unknown"
```
* `-o` | `--online` | `-O` | `--offline`
Whether to allow cargo to make network access. nailing-cargo
always passes `--offline` to cargo, unless `--online` is in
force. The default value depends on the configuration and the
cargo subcommand - see [`[misc]` `online`](#misc_online),
under Configuration.
* `-u` | `--cargo-lock-update` | `-U` | `--no-cargo-lock-update`
Allows (or disallows) cargo to update `Cargo.lock` in the source
directory. Without this enabled, nailing-cargo passes `--locked`
to cargo.
With this enabled, in an out-of-tree build the `Cargo.lock` and
`Cargo.toml` are copied to the build directory along with a
linkfarm, to fool cargo. After cargo has run, the resulting
`Cargo.lock` is copied back to the source tree.
Default is no update unless the whole point of the cargo
subcommand is to update `Cargo.lock`.
* `-c` | `-C`
Controls the addition of cargo command line options; ie,
whether nailing-cargo should treat the build command as if it
were cargo.
With `-C`, nailing-cargo will not add additional options
to the build command. With `-c` it will pass those options
after the cargo subcommand (usages 1 and 2) or right
after the build command (usage 3).
The cargo options are in any case also passed in the
environment - see [Environment of the build command](#environment-of-the-build-command).
The default is to pass cargo options if the command line
parsing yielded a cargo command and options (usages 1 and 2),
rather than a non-cargo build command (usage 3). `-C` and `-c`
do not affect the parsing of nailing-cargo's command line.
* `-s`
Behave as if the build command were `cargo `.
This influences the logic which tries to determine which
options to pass to cargo, whether cargo needs to be online, and
whether cargo might want to update `Cargo.lock`.
nailing-cargo knows about the following commands:
* `fetch`
* `fmt`
* `generate-lockfile`
* `init`
* `metadatay`
* `miri`
* `publish`
* `update`
* `upgrades`
All other subcommands are (silently) treated the same way
as `build` (ie, no subcommand properties). See
`--subcommand-props` for more detail about how the
subcommand affects nailing-cargo's behaviour.
The default is to use the cargo subcommand found from parsing
nailing-cargo's command line. NB: `-s` does not affect
which build command (and which cargo subcommand) is actually run.
* `--subcommand-props=,...`
Specify the properties of the subcommand. This is an
alternative to `-s`. The usual properties are:
* `lock-update`: cargo will want to update `Cargo.lock`. (The `-u` and `-U` options override this.)
* `online`: this subcommand makes no sense to run offline. (The `-o` and `-O` options, and the configuration, can override this.)
* `edits`: The purpose of this subcommand is to edit the source tree. Imples that `--edit-sources` is necessary (unless `--force`).
* `creates`: The purpose of this subcommand is to edit the source tree and create new files in it. Imples that `-EE` (`--edit-sources`, twice) is necessary (unless `--force`).
* `!target`: cargo would reject `--target=`; in this case nailing-cargo's `-T` option is ineffective.
* `!target-dir`: cargo would reject `--target-dir`, so don't pass it. (Usually we pass `--target-dir=target` when we pass `--manifest-path`, since cargo's default is `target` in the same directory as `Cargo.toml`.)
* `linkfarm-shallow`: Make the default be `--linkfarm=shallow`. This is the default for `miri` and can also be used for other subcommands which do not understandg `--manifest-path` properly.
* `linkfarm-gitclean`: Make the defaults be `--linkfarm=git` and `--preclean-build=src`.
* `pristine-git`: Turn on `--git` mode, and insist that the source tree be clean and clean the build tree before proceeding. This is the default for `publish`.
There are also some properties which should not be needed, but are
provided for completeness. Do not use these to solve the problem
of nailing-cargo passing cargo options to a build command which is
not cargo - use `-C` for that. The properties whose use is discouraged:
* `!manifest-path`: cargo would reject `--manifest-path`, so don't pass it (and don't pass `--target-dir` either). Only makes any difference for out-of-tree builds. Things will probably go wrong unless the build command looks at `[NAILING]CARGO_MANIFEST_DIR`.
* `!locked`: cargo would reject `--locked`, so don't pass it. Hazardous.
* `!offline`: the build command would reject `--offline`, so never pass it. *Not* overridden by configuration or command line.
* `--git|--no-git`: When git mode is enabled, and out-of-tree builds
are being done, nailing-cargo will, instead of using
`--manifest-path`, or linkfarming, use git operations to transfer
the source code to the build directory.
In git mode, the build directory should be a git working tree
(and nailing-cargo will try to make it into one).
If the source tree is dirty, nailing-cargo
will generate a synthetic commit in the build tree, to contain the
changes, so that the build tree is not dirty. The build tree will
be left in a detached HEAD state.
When precleaning is enabled, nailing-cargo will clean and `git
reset --hard`. Without precleaning, a dirty tree may cause
nailing-cargo to fail.
Switching between git mode and non-git mode does not work well
and is not recommended.
* `--linkfarm[=no|shallow|git|full]`: Override nailing-cargo's
approach to out-of-tree builds. Normally nailing-cargo chooses
automatically whether to make a linkfarm, and precisely what kind
of linkfarm, based on the cargo subcommand. The linkfarm styles
are:
* `no`: Do not make a linkfarm; pass a `--manifest-path` option
pointing to the actual source directory. This is the default
for most cargo commands.
* `shallow`: Symlink top-level objects in the source directory,
including whole subdirectories. This the default when
nailing-cargo thinks cargo is going to update `Cargo.lock`.
* `git`: Make a deep linkfarm, with subdirectories. Symlink
those objects tracked by git. This is the default for
`cargo publish`. This is *not* the same as `--git`:
`--linkfarm=git` transfers the *files* tracked by git into the
build environment, but *not* any actual git objects.
* `full`: Make a deep linkfarm and symlink every nondirectory found
in the source tree. This will including all sorts of junk,
including for example editor backup files.
Whenever nailing-cargo linkfarms, old symlinks pointing back to
the source tree are deleted. In each case, `Cargo.lock` is not
symlinked, but copied. If nailing-cargo expects cargo to update
`Cargo.lock`, it will copy it back to the source tree afterwards.
Just `--linkfarm` is the same as `--linkfarm=git`.
* `--edit | --edit-sources | -E`: Permits the cargo command to edit
sources in the source tree. This is achieved by *copying* the
entire source tree (all files tracked by git) into the destination
directory, and then copying back all changed files. *Only git
tracked filles* can be edited by the cargo command; edits to
other files, and creation of new files, will be ignored.
When this option is repeated (`-EE`), the cargo subcommand can
create new files including dotfiles (but nothing in the toplevel
`target` and nothing called `.git`). (This also enables
`--preclean=src` by default.)
If you are running out of tree builds for privsep reasons, you
should use git to review the edits made by the cargo command and
either stage and commit them, or reject them.
This option is overridden by a subsequent `--linkfarm` options.
`-E` or `-f` is needed for `nailing-cargo fmt`. `-EE` or `-f` is
needed for `nailing-cargo init`. `-E` is never the default,
even if nailing-cargo thinks it's needed.
* `--just-linkfarm[=shallow|git|full]`: Make the out-of-tree
linkfarm as if for `--cargo-lock-update`, but do not actually run
any command, nor try to copy back a a generated `Cargo.lock`.
Forces `--keep-linkfarm` (even if the contrary is also specified).
With a linkfarming mode, overrides (and is overridden by)
`--linkfarm=`. Without a linkfarming mode, and without
`--linkfarm`, the default is `shallow`.
* `--keep-linkfarm` | `--clean-linkfarm`: When doing an out-of-tree
lockfile update, controls whether the linkfarm is kept afterwards.
Overrides the `oot.clean` config option. (Default: keep.)
* `--[no-]preclean-build[=no|src|full]`: When doing an out-of-tree
build, controls whether the build directory is purged of leftover
contents *before* the build is run. The usual default is `no`.
For `cargo publish`, the default is `src`, which deletes
everything except the directory `target`. `full` means to clean
out that too.
* `--leave-nailed`: At the end, leave all the `Cargo.toml` files in
their edited state, rather than (trying to) clean them up. To
clean this up later, run `nailing-cargo` again without this option.
Without this option, the nailed versions are left in
`.Cargo.toml.nailed~`, so you only need this if you want to run
cargo by hand or something.
* `--subdir=`: operate in the relative subdirectory ``.
This not ony changes directory before running the command,
but also adjusts the various environment variables to
which point to parts of the source and build trees.
* `--chdir=`: change directory just before invoking cargo.
If `` is relative, it is relative to the build tree.
This is useful for `cargo publish`, which unfortunately does not
support `-p` or `-workspace`. Just `--chdir=` cancels.
* `--just-run`: Execute the specified command (perhaps concurrently
with other commands), but do not manipulate any of Cargo's
metadata fiules. Useful in out of tree mode to invoke a non-cargo
command in the build environment. Implies `--no-nail`,
`--no-cargo-lock-manip` and `--no-concurrency-lock` (overrideable
by later occurrences of the corresponding opposite options).
Hazardous if the command is actually cargo, or will run cargo.
* `--no-nail` | `--nail` (default): Whether to actually nail - ie,
whether to actually modify any `Cargo.toml`s while running the
command. This can be useful, e.g., in out-of-tree mode with
commands that don't actually invoke cargo. Consider passing
`--no-concurrency-lock` too. Regardless of this option, no
nailing is actually done unless `../Cargo.nail` exists and has
some entries in its `subdirs` or `packages`.
* `--no-cargo-lock-manip` | `--cargo-lock-manip` (default):
Whether to manipulate `Cargo.lock`. For example, whether to copy
it to the build tree and back (in out of tree mode) and whether to
rename it from an alternative lockfile name, and put it back.
Overrides `-u` etc.
* `--no-concurrency-lock` | `--concurrency-lock` (default): Whether
to take the nailing-cargo lock. Some kind of protection against
concurrent operation is necessary to prevent multiple instances of
nailing-cargo trashing each others' work, and possibly mangling
your `Cargo.toml`s, `Cargo.lock`, etc., so `--no-concurrency-lock`
is dangerous unless you take other measures against concurrent
execution.
* `-h` | `--help`: Print usage summary.
* `--doc` | `--man` | `--manual`: Format this manual into html using
`pandoc` and display it with `w3m`.
Environment of the build command
--------------------------------
nailing-cargo passes these environment variables to the build command:
* `CARGO_MANIFEST_DIR`: invocation `.` (invocation directory)
* `NAILINGCARGO_MANIFEST_DIR`: same as `CARGO_MANIFEST_DIR`
* `NAILINGCARGO_WORKSPHERE`: invocation `..` (parent)
* `NAILINGCARGO_BUILD_DIR`: build directory (even if same as source)
* `NAILINGCARGO_BUILDSPHERE`: parent of build dir (only set if out-of-tree)
* `NAILINGCARGO_CARGO_OPTIONS`: additional options that nailing-cargo passed (or would pass) to cargo. Space-separated; does not include `--manifest-path`.
* `NAILINGCARGO_TOOLCHAIN`: The toolchain (as `+TOOLCHAIN`) if one was specified via `misc.usual.toolchain`, or on the command line.
All of these are absolute paths.
### Build commands which wrap cargo ###
If you specify a build command which eventually runs cargo, you may
wish to pass on to your cargo the options which nailing-cargo would
have passed. This will definitely be necessary if you are using nailing-cargo's out-of-tree facility.
In such a situation, do it like this:
```
cargo build --manifest-path="${CARGO_MANIFEST_DIR-.}"/Cargo.toml $NAILINGCARGO_CARGO_OPTIONS
```
If you need to run a cargo subcommand which doesn't understand some of
nailing-cargo's options, currently, you must strip them out of
`NAILINGCARGO_CARGO_OPTIONS` yourself - or pass some `-s` or
`--subcmd-props` option to nailing-cargo (but that is a layering
violation and may not work if one build command runs various different
cargo runes).
Configuration reference
=======================
nailing-cargo reads these configuration files:
```
/etc/nailing-cargo/cfg.toml
~/.nailing-cargo.toml
./.nailing-cargo.toml
../Nailing-Cargo.toml
../Cargo.nail
```
Settings in later-mentioned files override ones in earlier-mentioned
files.
Source directories and packages (toplevel)
------------------------------------------
Note that unlike everything else, these keys (`packages` and
`subdirs`) are read only from `Cargo.nail` (see "Limitations and
bugs", below).
These keys specify a combination of (i) a mapping from package name to
source subdirectory (ii) a set of subdirectories whose `Cargo.toml`
must be massaged.
* `packages`: a map keyed by package name, giving the subdirectory
for each one.
This causes each mentioned subdirectory's `Cargo.toml` to be
massaged, and records that subdirectory as the source for that
package. (nailing-cargo will check that subdirectory actually
contains the indicated package.)
Each value can be just the subdirectory name (eg `[packages]`
`mylibrary='mylibrary-test'`) or itself a map with the key `subdir`
(eg `[packages.mylibrary]` `subdir='mylibrary-test'`).
* `subdirs`: a list of subdirectory names to process.
Each subdirectory's `Cargo.toml` will be massaged. Also, the
subdirectory will be examined to see what package it contains; it
will then be used as the source for that package, unless that
package appears in an entry in `packages`, or an earlier entry in
`subdirs`.
This can be a list of strings (eg `subdirs =
['myproject','mylibrary']`). Or it can be single multi-line
string containing one subdirectory name per line; in that
case, `#`-comments are supported and tabs and spaces are ignored
(see "Most basic example usage" above.)
In each case the subdirectory should usually be a relative pathname;
it is relative to the directory containing `Cargo.nail`.
`[alt_cargolock]`: Alternative `Cargo.lock` filename
----------------------------------------------------
To control use of alternative `Cargo.lock` filename, use the section
`[alt_cargolock]`. Settings here:
* `file = `.
* `file = true`: Equivalent to `file = "Cargo.lock.example"`.
(This is the default.)
* `file = false`: Disables this feature.
* `force = false`: Uses the alternative filename only if it
already exists. (This is the default.)
* `force = true`: Always uses the alternative filename.
`[oot]`: Out-of-tree build support
----------------------------------
* `dir`: The build directory. If relative, it is relative to the
parent of the invocation directory (and could be a symlink then).
Default is `Build` (assuming `use` is specified).
The build directory will contain one subdir for each package: each
subdir in the build dir corresponds to one source dir where
nailing-cargo was invoked. nailing-cargo will arrange to create
these subdirectories, so the build directory can start out empty.
* `use`: How to become the build user. Needs to be combined
with other setting(s):
* `ssh`: Use ssh. `user` must be given as well and can be
a username on localhost, or the `@`
argument to ssh.
* `sudo`: Use sudo. `user` must be given as well.
* `command_args`: `command` must be specified as a list,
specifying a command and arguments which work like `nice`.
* `command_sh`: `command` must be specified as a list,
specifying a command and arguments which work like `sh -c`.
* `null`: Run builds as the same user.
* `really`: Use `really` from `chiark-really.deb`.
`user` must be given as well.
* `disable': Disable this feature, even if `dir` is set.
* `command`: The command to run for `command_sh` or `command_args`.
In both cases, this is a command and its arguments/options. The
list will be passed to `execvp`. The difference between
`command_args` and `command_sh` is in what nailing-cargo appends to
the specified `command` list:
For `command_args`, nailing cargo appends multiple more arguments;
each one should be passed as-is as a single argument to the actual
build command. This is correct if `command` is a program like
`nice` or `really`, which takes a command and its arguments and
does not go via the shell.
For `command_sh`, nailing-cargo appends one single further
argument. That argument is a shell command; nailing-cargo
constructs it by shell-quoting the real command and arguments and
wrapping them up in a small script, the text of which becomes the
extra argument to `command`. This is correct if `command` will
pass its argument to a bournelike shell - for example, if `command`
is an ssh rune for a remote account whose shell is `/bin/sh` or
`/bin/bash`.
* `user`: The build username, for `really`, `sudo` and `ssh`.
For `ssh`, can be just the local username (meaning `@localhost`), or
`@`.
* `clean` (boolean): When doing a `Cargo.lock` update, which involves
linkfarming in the build directory, whether the clean up the
linkfarm afterwards. Default: `true`. Can be overridden by
`--keep-linkfarm` or `--clean-linkfarm`.
`[arch]`: Architecture convenience aliases
------------------------------------------
This is a map from archictecture aliases to full cargo architecture
names. The keys are the aliases; each entry should be a string, the
cargo architecture name.
Only keys starting with an ascii uppercase letter are relevant, since
other names are not looked up in this alias map.
`[misc]`: Miscellaneous individual nailing-cargo config
-------------------------------------------------------
* `usual_toolchain`:
Specifies a default `+` option to pass to `cargo`.
This is used only in the first usage pattern, where
`` is followed immediately by ``,
and only if `` doesn't start with a `+...` argument.
* `online`:
Specifies whether to allow or prevent cargo from accessing the
network. Value is a boolean or `'auto'`. `'auto'` permits online
access if the cargo subcommand being invoked is one whose main
purpose involves online access.
Implemented by passing `--offline` to cargo when necessary ---
cargo's default is online. nailing-cargo's default is
`'auto'`.
Limitations and bugs
====================
* nailing-cargo temporarily dirties your source trees, including
particularly `Cargo.toml` and `Cargo.lock`; and if nailing-cargo
crashes or is interrupted these changes may be left behind.
Unfortunately it is not possible to avoid this temporary dirtying
because the cargo team have deliberately made cargo inflexible -
[issue#6715](https://github.com/rust-lang/cargo/issues/6715).
At least, running nailing-cargo again will clean up any mess
left by an interrupted run.
* nailing-cargo needs to understand the behaviour of the cargo
subcommand you are running - especially for out-of-tree builds.
nailing-cargo only has a short builtin list of commands it knows
about (see [`-s.
Individual files generally contain the following tag in the copyright
notice, instead of the full licence grant text:
```
SPDX-License-Identifier: AGPL-3.0-or-later
```
As is conventional, this should be read as a licence grant.
work/TOML-Tiny/ 0000775 0000000 0000000 00000000000 14777226410 010436 5 ustar work/TOML-Tiny/.appveyor.yml 0000664 0000000 0000000 00000000636 14777226410 013111 0 ustar skip_tags: true
build: off
cache:
- C:\strawberry
platform:
- x86
- x64
install:
- if not exist "C:\strawberry" cinst strawberryperl
- set PATH=C:\strawberry\perl\bin;C:\strawberry\perl\site\bin;C:\strawberry\c\bin;%PATH%
- cd C:\projects\%APPVEYOR_PROJECT_NAME%
- cpanm -n Dist::Zilla
- dzil authordeps --missing | cpanm -nq
- dzil listdeps --missing | cpanm -nq
test_script:
- dzil test
work/TOML-Tiny/.github/ 0000775 0000000 0000000 00000000000 14777226410 011776 5 ustar work/TOML-Tiny/.github/workflows/ 0000775 0000000 0000000 00000000000 14777226410 014033 5 ustar work/TOML-Tiny/.github/workflows/dzil-test.yml 0000664 0000000 0000000 00000001775 14777226410 016507 0 ustar name: run-tests
on:
push:
branches:
- '*'
tags-ignore:
- '*'
pull_request:
jobs:
dzil-test:
env:
# some plugins still needs this to run their tests...
PERL_USE_UNSAFE_INC: 0
AUTHOR_TESTING: 1
AUTOMATED_TESTING: 1
RELEASE_TESTING: 1
PERL_ANYEVENT_MODEL: Perl
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
perl-version:
- 'latest'
- '5.40'
- '5.38'
- '5.36'
- '5.34'
- '5.32'
- '5.30'
- '5.28'
- '5.26'
- '5.24'
- '5.22'
- '5.20'
- '5.18'
container:
image: perldocker/perl-tester:${{ matrix.perl-version }}
steps:
- uses: actions/checkout@v3
- name: perl -V
run: perl -V
- name: Install Dependencies
run: cpm install -g --no-test --show-build-log-on-failure --cpanfile cpanfile
- name: Run tests
run: prove -lmfr -j4 t
work/TOML-Tiny/.gitignore 0000664 0000000 0000000 00000000054 14777226410 012425 0 ustar .build
scratch.pl
TOML-Tiny-*
nytprof*
tags
work/TOML-Tiny/Changes 0000664 0000000 0000000 00000010436 14777226410 011735 0 ustar {{$NEXT}}
0.20 2025-03-25
- Fix parsing of quoted keys (GH#41) (Ian Jackson)
- Fix writing of more kinds of quote-needing keys (GH#40) (Ian Jackson)
- Avoid looking at string values to try to find the type (GH#37) (Ian Jackson)
- die if data to be encoded is not a hashref (GH#36) (djerius)
- inline table keys were not normalized via to_toml_key() (GH#35) (djerius)
0.19 2025-02-11
- trap and die on undefined values (GH#32) (djerius)
0.18 2024-09-04
- Support builtin booleans (GH#31) (Tina Mller (tinita))
0.17 2024-06-03
- regexp for values which match a DateTime should be anchored to start and end
of string (GH#30) (djerius)
0.16 2023-05-31
- Remove when (GH#25) (Olaf Alders)
- Test strict mode in to_toml_array() (GH#26) (Olaf Alders)
- Replace @Author::BLUEFEET with equivalent config (GH#23) (Olaf Alders)
- Make some imports explicit (GH#19) (Olaf Alders)
0.15 2021-08-13
- bugfix: strings with "inf" or "nan" in them no longer treated as special
floats
0.14 2021-08-02
- Fix an issue with serialisation of nan, inf, and -inf (thanks jjatria)
- Enforcement of homogenous arrays is no longer supported as it has been
dropped from the TOML spec
- strict_arrays is now strict (strict_arrays still accepted for compatibility)
- strict mode now disallows trailing commas
- bugfix: table names whose individual segments include a dot can no longer
cause parser to incorrectly identify duplicate table names
- bugfix: correctly fail on arrays without separators
- bugfix: correctly fail when array ends without closing at EOF
- bugfix: correctly fail when inline table is missing separators or has
trailing separator
- bugfix: disallow non-permitted control characters in strings and comments
- bugfix: disallow invalid unicode in input
- bugfix: allow double-zero exponents (e00)
- bugfix: correctly parse multi-line literal strings, dealing properly with
some edge cases
- bugfix: correctly parse multi-line basic strings, dealing properly with some
edge cases
- bugfix: correctly escape unicode control characters in toml output
- bugfix: correctly handle comment-like sequences in multiline strings
- bugfix: correctly handle keys with names that are toml keywords
- bugfix: better handling of inf/nan in parsing, writing
- bugfix: correctly generate empty inline tables within arrays
- bugfix: make duplicate key enforcement match the toml 1.0 spec
- bugfix: update datetime support to match toml abnf, w/ workaround for
burntsushi tests supporting lowercase z and toml supporting a space instead
of T
- bugfix: fix support for local dates, local times, fractional second precision
- bugfix: fix parsing of dotted keys in inline tables
- bugfix: fixes for escapes and unicode in key names, both in parsing and
generating toml
0.13 2021-07-26
-Fix a spurious warning being raised on trailing spaces in hexadecimal numbers (thanks jjatria)
0.12 2021-05-28
-Fix bug causing to_toml to incorrectly dereference \1 and \0 (thanks oschwald)
0.11 2021-02-12
-Fix bug in strict_arrays where string containing integer is recognized as an
integer, causing parsing to fail when present in an array containing other
strings
0.10 2020-09-08
-Remove dependency on DateTime::Format::RFC3339
0.09 2020-08-11
-Fix warning when calling `to_toml(from_toml(...))`
-Fix bug allowing perl to stringify numbers (thanks oschwald)
-Fix bug disallowing weird forms of nan (+nan, -nan)
-Behavior change: return Math::Big(Int|Float) for large numbers (thanks oschwald)
0.08 2020-06-25
-Fix bug in TOML table output generation (thanks ijackson)
0.07 2020-05-08
-Add support for floating time zones in TOML output (thanks ijackson)
-Fix bug where datetimes were being outputed as ISO8601 instead of RFC3339
-Clarified documentation with explicit description of supported perl types for each toml type
0.06 2020-03-30
-Performance improvements in TOML::Tiny::Tokenizer->next_token
-Fix totally broken OO interface (thanks noctux)
0.05 2020-01-21
-POD fixes for TOML::Tiny::Grammar
0.04 2020-01-21
-Remove superfluous dependency on DateTime::Format::RFC3339, which was only
needed for unit tests
0.03 2020-01-18
-Remove automatic inflation of numerical types using Math::Big(Int|Float);
this may now be done with inflate_integer and inflate_float
0.02 2020-01-17
-Add MANIFEST.SKIP to prevent dzil from including author scripts
0.01 2020-01-17
-Initial release
work/TOML-Tiny/Dockerfile 0000664 0000000 0000000 00000000304 14777226410 012425 0 ustar FROM perl:latest
RUN mkdir /toml-tiny
WORKDIR /toml-tiny
COPY ./ ./
RUN cpanm -nq Dist::Zilla
RUN dzil authordeps --missing | cpanm -nq
RUN dzil listdeps --missing | cpanm -nq
RUN dzil test -j8
work/TOML-Tiny/MANIFEST.SKIP 0000664 0000000 0000000 00000000032 14777226410 012327 0 ustar scratch.pl
build-tests.pl
work/TOML-Tiny/README.pod 0000664 0000000 0000000 00000021154 14777226410 012102 0 ustar =pod
=encoding UTF-8
=head1 NAME
TOML::Tiny - a minimal, pure perl TOML parser and serializer
=head1 VERSION
version 0.20
=head1 SYNOPSIS
use TOML::Tiny qw(from_toml to_toml);
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
# Decoding TOML
my $toml = do{ local $/; };
my ($parsed, $error) = from_toml $toml;
# Encoding TOML
say to_toml({
stuff => {
about => ['other', 'stuff'],
},
});
# Object API
my $parser = TOML::Tiny->new;
my $data = $parser->decode($toml);
say $parser->encode($data);
=head1 DESCRIPTION
=for html
C implements a pure-perl parser and generator for the
L data format. It conforms to TOML v1.0
(with a few caveats; see L).
C strives to maintain an interface compatible to the L and
L modules, and could even be used to override C<$TOML::Parser>:
use TOML;
use TOML::Tiny;
local $TOML::Parser = TOML::Tiny->new(...);
say to_toml(...);
=head1 EXPORTS
C exports the following to functions for compatibility with the
L module. See L.
=head2 from_toml
Parses a string of C-formatted source and returns the resulting data
structure. Any arguments after the first are passed to L's
constructor.
If there is a syntax error in the C source, C will die with
an explanation which includes the line number of the error.
my $result = eval{ from_toml($toml_string) };
Alternately, this routine may be called in list context, in which case syntax
errors will result in returning two values, C and an error message.
my ($result, $error) = from_toml($toml_string);
Additional arguments may be passed after the toml source string; see L.
=head3 GOTCHAS
=over
=item Big integers and floats
C supports integers and floats larger than what many perls support. When
C encounters a value it may not be able to represent as a number,
it will instead return a L or L. This behavior
can be overridden by providing inflation routines:
my $toml = TOML::Tiny->new(
inflate_float => sub{
return do_something_else_with_floats( $_[0] );
};
);
=back
=head2 to_toml
Encodes a hash ref as a C-formatted string.
my $toml = to_toml({foo => {'bar' => 'bat'}});
# [foo]
# bar="bat"
=head3 mapping perl to TOML types
=head4 table
=over
=item C ref
=back
=head4 array
=over
=item C ref
=back
=head4 boolean
=over
=item C<\0> or C<\1>
=item L
=item L
=back
=head4 numeric types
These are tricky in perl. When encountering a C,
that representation is used.
If the value is a defined (non-ref) scalar with the C or C
flags set, the value will be emitted unchanged. This is in line with most
other packages, so the normal hinting hacks for typed output apply:
number => 0 + $number,
string => "" . $string,
=over
=item L
=item L
=item numerical scalars
=back
=head4 datetime
=over
=item RFC3339-formatted string
e.g., C<"1985-04-12T23:20:50.52Z">
=item L
Ls are formatted as C, as expected by C. However,
C supports the concept of a "local" time zone, which strays from
C by allowing a datetime without a time zone offset. This is
represented in perl by a C with a B.
=back
=head4 string
All other non-ref scalars are treated as strings.
=head1 OBJECT API
=head2 new
=over
=item inflate_datetime
By default, C treats TOML datetimes as strings in the generated
data structure. The C parameter allows the caller to provide
a routine to intercept those as they are generated:
use DateTime::Format::RFC3339;
my $parser = TOML::Tiny->new(
inflate_datetime => sub{
my ($dt_string) = @_;
# DateTime::Format::RFC3339 will set the resulting DateTime's formatter
# to itself. Fallback is the DateTime default, ISO8601, with a possibly
# floating time zone.
return eval{ DateTime::Format::RFC3339->parse_datetime($dt_string) }
|| DateTime::Format::ISO8601->parse_datetime($dt_string);
},
);
=item inflate_boolean
By default, boolean values in a C document result in a C<1> or C<0>.
If L is installed, they will instead be C
or C.
If you wish to override this, you can provide your own routine to generate values:
my $parser = TOML::Tiny->new(
inflate_boolean => sub{
my $bool = shift;
if ($bool eq 'true') {
return 'The Truth';
} else {
return 'A Lie';
}
},
);
=item inflate_integer
TOML integers are 64 bit and may not match the size of the compiled perl's
internal integer type. By default, C coerces numbers that fit
within a perl number by adding C<0>. For bignums, a L is
returned. This may be overridden by providing an inflation routine:
my $parser = TOML::Tiny->new(
inflate_integer => sub{
my $parsed = shift;
return sprintf 'the number "%d"', $parsed;
};
);
=item inflate_float
TOML floats are 64 bit and may not match the size of the compiled perl's
internal float type. As with integers, floats are coerced to numbers and large
floats are upgraded to Ls. The special strings C and
C may also be returned. You can override this by specifying an inflation
routine.
my $parser = TOML::Tiny->new(
inflate_float => sub{
my $parsed = shift;
return sprintf '"%0.8f" is a float', $parsed;
};
);
=item strict
C imposes some miscellaneous strictures on C input, such as
disallowing trailing commas in inline tables and failing on invalid UTF8 input.
B C was previously called C. Both are accepted
for backward compatibility, although enforcement of homogenous arrays is no
longer supported as it has been dropped from the spec.
=back
=head2 decode
Decodes C and returns a hash ref. Dies on parse error.
=head2 encode
Encodes a perl hash ref as a C-formatted string.
=head2 parse
Alias for C to provide compatibility with C when
overriding the parser by setting C<$TOML::Parser>.
=head1 DIFFERENCES FROM L AND L
C differs in a few significant ways from the L module,
particularly in adding support for newer C features and strictness.
L defaults to lax parsing and provides C to (slightly)
tighten things up. C defaults to (somewhat) stricter parsing,
enabling some extra strictures with L.
C supports a number of options which do not exist in L:
L, L, and L.
C ignores invalid surrogate pairs within basic and multiline
strings (L may attempt to decode an invalid pair). Additionally, only
those character escapes officially supported by TOML are interpreted as such by
C.
C supports stripping initial whitespace and handles lines
terminating with a backslash correctly in multilne strings:
# TOML input
x="""
foo"""
y="""\
how now \
brown \
bureaucrat.\
"""
# Perl output
{x => 'foo', y => 'how now brown bureaucrat.'}
C includes support for integers specified in binary, octal or hex
as well as the special float values C and C.
=head1 SEE ALSO
=over
=item L
Regexp scraps used by C to parse TOML source.
=back
=head1 ACKNOWLEDGEMENTS
Thanks to L for encouraging their
employees to contribute back to the open source ecosystem. Without their
dedication to quality software development this distribution would not exist.
A big thank you to those who have contributed code or bug reports:
=over
=item L
=item L
=item L
=item L
=back
=head1 AUTHOR
Jeff Ober
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2025 by Jeff Ober.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
work/TOML-Tiny/build-tests.pl 0000664 0000000 0000000 00000020240 14777226410 013230 0 ustar #-------------------------------------------------------------------------------
# Generates perl unit tests from the toml/json files in BurntSush/toml-test
# without having to add special casing to TOML::Tiny to conform to their
# annotated JSON format.
#-------------------------------------------------------------------------------
use strict;
use warnings;
no warnings 'experimental';
use v5.18;
use Data::Dumper;
use JSON::PP;
use File::Copy;
use File::Find;
use File::Spec;
# We want to read unicde as characters from toml-test source files. That makes
# things simpler for us when we parse them and generate perl source in the
# generated test file.
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
sub slurp{
open my $fh, '<', $_[0] or die $!;
local $/;
<$fh>;
}
# Removes type annotations from BurntSushi/toml-test JSON files and returns the
# cleaned up data structure to which the associated TOML file should be parsed.
sub deturd_json{
state $json = JSON::PP->new->utf8(1);
my $annotated = $json->decode(slurp(shift));
my $cleanish = deannotate($annotated);
local $Data::Dumper::Varname = 'expected';
local $Data::Dumper::Deparse = 1;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
return Dumper($cleanish);
}
# Recursively deannotates and inflates values from toml-test JSON data
# structures into a format more in line with TOML::Tiny's parser outout. For
# integer and float values, a Test2::Tools::Compare validator is generated to
# compare using Math::Big(Int|Float)->beq, since TOML's float and int types are
# 64 bits. Datetimes are converted to a common, normalized string format.
sub deannotate{
my $data = shift;
for (ref $data) {
when ('HASH') {
if (exists $data->{type} && exists $data->{value} && keys(%$data) == 2) {
for ($data->{type}) {
return $data->{value} eq 'true' ? 1 : 0 when /bool/;
return [ map{ deannotate($_) } @{$data->{value}} ] when /array/;
when (/integer/) {
my $src = qq{
use Test2::Tools::Compare qw(validator);
validator('Math::BigInt->new("$data->{value}")->beq(\$_)' => sub{
require Math::BigInt;
my \$got = Math::BigInt->new(\$_);
Math::BigInt->new("$data->{value}")->beq(\$got);
});
};
my $result = eval $src;
$@ && die $@;
return $result;
}
when (/float/) {
my $src;
if ($data->{value} eq 'nan') {
$src = qq{
use Test2::Tools::Compare qw(validator);
validator('Math::BigFloat->new(\$_)->is_nan' => sub{
require Math::BigFloat;
Math::BigFloat->new(\$_)->is_nan;
});
};
}
elsif ($data->{value} eq 'inf') {
$src = qq{
use Test2::Tools::Compare qw(validator);
validator('Math::BigFloat->new(\$_)->is_inf' => sub{
require Math::BigFloat;
Math::BigFloat->new(\$_)->is_inf;
});
};
}
elsif ($data->{value} eq '-inf') {
$src = qq{
use Test2::Tools::Compare qw(validator);
validator('Math::BigFloat->new(\$_)->is_inf' => sub{
require Math::BigFloat;
Math::BigFloat->new(\$_)->is_inf;
});
};
}
else {
$src = qq{
use Test2::Tools::Compare qw(validator);
validator('Math::BigFloat->new("$data->{value}")->beq(\$_)' => sub{
require Math::BigFloat;
my \$got = Math::BigFloat->new(\$_);
Math::BigFloat->new("$data->{value}")->beq(\$got);
});
};
}
my $result = eval $src;
$@ && die $@;
return $result;
}
default{ return $data->{value} }
}
}
my %object;
$object{$_} = deannotate($data->{$_}) for keys %$data;
return \%object;
}
when ('ARRAY') {
return [ map{ deannotate($_) } @$data ];
}
default{
return $data;
}
}
}
sub find_tests{
my $src = shift;
my %tests;
find {
no_chdir => 1,
wanted => sub {
return unless /\.toml$/;
my $abs = File::Spec->rel2abs( $_ );
my $rel = File::Spec->abs2rel( $abs, $src );
my $toml = $rel;
my $test = substr $rel, 0, -5;
$tests{$test} = $toml;
},
} => $src;
return %tests;
}
sub build_pospath_test_files{
my $src = shift;
my $dest = shift;
$src = "$src/tests/valid";
$dest = "$dest/t/toml-test/valid";
print "Generating positive path tests from $src\n";
my %TOML = find_tests( $src );
for (sort keys %TOML) {
copy("$src/$TOML{$_}", "$dest/$TOML{$_}");
my $json = substr( $TOML{$_}, 0, -4 ) . 'json';
my $data = deturd_json("$src/$json");
my $test = "$dest/$_.t";
my ( undef, $path ) = File::Spec->splitpath( $test );
unless (-f $test) {
system('mkdir', '-p', $path) == 0 || die $?;
}
open my $fh, '>', $test or die $!;
print $fh qq{# File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local \$Data::Dumper::Sortkeys = 1;
local \$Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my \$fh, '<', "$dest/$TOML{$_}" or die \$!;
binmode \$fh, ':encoding(UTF-8)';
my \$toml = do{ local \$/; <\$fh>; };
close \$fh;
my $data
my \$actual = from_toml(\$toml);
is(\$actual, \$expected1, '$_ - from_toml') or do{
diag 'TOML INPUT:';
diag "\$toml";
diag '';
diag 'EXPECTED:';
diag Dumper(\$expected1);
diag '';
diag 'ACTUAL:';
diag Dumper(\$actual);
};
my \$regenerated = to_toml \$actual;
my \$reparsed = eval{ scalar from_toml \$regenerated };
my \$error = \$@;
ok(!\$error, '$_ - to_toml - no errors')
or diag \$error;
is(\$reparsed, \$expected1, '$_ - to_toml') or do{
diag "ERROR: \$error" if \$error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper(\$actual);
diag '';
diag 'REGENERATED TOML:';
diag \$regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper(\$reparsed);
};
done_testing;};
close $fh;
}
}
sub build_negpath_test_files{
my $src = shift;
my $dest = shift;
$src = "$src/tests/invalid";
$dest = "$dest/t/toml-test/invalid";
print "Generating negative path tests from $src\n";
my %TOML = find_tests( $src );
for (sort keys %TOML) {
copy("$src/$TOML{$_}", "$dest/$TOML{$_}");
my $test = "$dest/$_.t";
my ( undef, $path ) = File::Spec->splitpath( $test );
unless (-f $test) {
system('mkdir', '-p', $path) == 0 || die $?;
}
open my $fh, '>', $test or die $!;
print $fh qq{# File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my \$fh, '<', "$dest/$TOML{$_}" or die \$!;
binmode \$fh, ':raw';
my \$toml = do{ local \$/; <\$fh>; };
close \$fh;
ok dies(sub{ scalar from_toml(\$toml, strict => 1) }), 'strict_mode dies on $_';
done_testing;};
close $fh;
}
}
my $usage = "usage: build-tests \$toml-test-repo-path \$toml-tiny-repo-path\n";
my $toml_test_path = shift @ARGV || die $usage;
my $toml_tiny_path = shift @ARGV || die $usage;
-d $toml_test_path || die "invalid path to BurntSushi/toml-test: $toml_test_path\n";
-d "$toml_test_path/tests" || die "invalid path to BurntSushi/toml-test: $toml_test_path\n";
-d $toml_tiny_path || die "invalid path to TOML::Tiny repo: $toml_tiny_path\n";
-d "$toml_tiny_path/t" || die "invalid path to TOML::Tiny repo: $toml_tiny_path\n";
print "Checking out master branch of BurntSushi/toml-test and pulling the latest commits\n";
system("cd $toml_test_path && git checkout master && git pull") == 0 || die $!;
build_pospath_test_files($toml_test_path, $toml_tiny_path);
build_negpath_test_files($toml_test_path, $toml_tiny_path);
work/TOML-Tiny/cpanfile 0000664 0000000 0000000 00000001125 14777226410 012141 0 ustar requires 'perl' => '>= 5.018';
requires 'Carp' => '0';
requires 'Data::Dumper' => '0';
requires 'Exporter' => '0';
requires 'Encode' => '0';
requires 'Math::BigInt' => '>= 1.999718';
recommends 'Types::Serialiser' => 0;
on test => sub{
requires 'Data::Dumper' => '0';
requires 'DateTime::Format::ISO8601' => '0';
requires 'TOML::Parser' => '0';
requires 'Test2::V0' => '0';
requires 'Test::Pod' => '0';
requires 'DateTime::Format::RFC3339' => '0';
recommends 'Unicode::GCString' => '0';
};
work/TOML-Tiny/dist.ini 0000664 0000000 0000000 00000000651 14777226410 012104 0 ustar name = TOML-Tiny
author = Jeff Ober
license = Perl_5
copyright_holder = Jeff Ober
[@Basic]
[Git::Check]
[Git::NextVersion]
first_version = 0.01
[NextRelease]
format = %v %{yyyy-MM-dd}d
[ReadmeAnyFromPod / ReadmePodInRoot]
type = pod
[GithubMeta]
issues = 1
[PkgVersion]
[PodSyntaxTests]
[Test::ReportPrereqs]
[Prereqs::FromCPANfile]
[MetaJSON]
[Git::Commit]
[Git::Tag]
[Git::Push]
[PodWeaver]
work/TOML-Tiny/lib/ 0000775 0000000 0000000 00000000000 14777226410 011204 5 ustar work/TOML-Tiny/lib/TOML/ 0000775 0000000 0000000 00000000000 14777226410 011757 5 ustar work/TOML-Tiny/lib/TOML/Tiny/ 0000775 0000000 0000000 00000000000 14777226410 012702 5 ustar work/TOML-Tiny/lib/TOML/Tiny/Faithful.pm 0000664 0000000 0000000 00000003136 14777226410 015005 0 ustar
package TOML::Tiny::Faithful;
use parent TOML::Tiny;
use DateTime::Format::ISO8601;
use DateTime::Format::RFC3339;
use DateTime;
use Types::Serialiser; # ensures that Parser DTRT with booleans
our @EXPORT = qw(
from_toml
to_toml
);
sub _options {
inflate_datetime => sub {
# RFC3339 bombs out if there is no timezone, so we parse with 8601
DateTime::Format::ISO8601->parse_datetime(shift)
},
no_string_guessing => 1,
}
sub new {
my ($class, %param) = @_;
bless TOML::Tiny->new(_options(), %param), $class;
}
sub from_toml {
my $source = shift;
TOML::Tiny::from_toml($source, _options(), @_);
}
sub to_toml {
my $source = shift;
TOML::Tiny::to_toml($source, _options(), @_);
}
package TOML::Tiny::Faithful::DateTime::Formatter;
use DateTime::Format::RFC3339;
our $base = DateTime::Format::RFC3339->new();
sub new ($) {
my ($class) = @_;
bless { }, $class;
}
1;
=head1 SYNOPSIS
use TOML::Tiny::Faithful qw(from_toml to_toml);
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
# Decoding TOML
my $toml = do{ local $/; };
my ($parsed, $error) = from_toml $toml;
# Encoding TOML
say to_toml({
stuff => {
about => ['other', 'stuff'],
},
});
# Object API
my $parser = TOML::Tiny::Faithful->new;
my $data = $parser->decode($toml);
say $parser->encode($data);
=head1 DESCRIPTION
C is a trivial wrapper around C
which sets C and C
to try to make the TOML output faithful to any input TOML.
=head1 SEE ALSO
=over
=item L
=back
work/TOML-Tiny/lib/TOML/Tiny/Grammar.pm 0000664 0000000 0000000 00000016045 14777226410 014634 0 ustar package TOML::Tiny::Grammar;
# ABSTRACT: exports regex definitions used to parse TOML source
use strict;
use warnings;
use v5.18;
use parent 'Exporter';
our @EXPORT = qw(
$WS
$CRLF
$EOL
$Comment
$NonASCII
$BareKey
$QuotedKey
$SimpleKey
$DottedKey
$Key
$Boolean
$Escape
$StringLiteral
$MultiLineStringLiteral
$BasicString
$MultiLineString
$String
$Date
$Time
$DateTime
$TimeOffset
$Hex
$Oct
$Bin
$Dec
$Integer
$Float
$SpecialFloat
);
#-------------------------------------------------------------------------------
# Primitives
#-------------------------------------------------------------------------------
our $WS = qr/[\x20\x09]/; # space, tab
our $CRLF = qr/\x0D?\x0A/; # cr? lf
our $CommentChar = qr/(?>[^[:cntrl:]]|\t)/; # non-control chars other than tab
our $Comment = qr/\x23$CommentChar*/; # #comment
our $EOL = qr/$Comment?$CRLF/; # crlf or comment + crlf
our $Boolean = qr/\b(?:true)|(?:false)\b/;
our $NonASCII = qr/[\x80-\x{D7FF}\x{E000}-\x{10FFFF}]/;
#-------------------------------------------------------------------------------
# Strings
#-------------------------------------------------------------------------------
our $Escape = qr{
\x5C # leading \
(?>
[\x5C"btfnr] # escapes: \\ \" \b \t \n \f \r
| (?> u [_0-9a-fA-F]{4}) # unicode (4 bytes)
| (?> U [_0-9a-fA-F]{8}) # unicode (8 bytes)
)
}x;
our $LiteralChar = qr{ [\x09\x20-\x26\x28-\x7E] | $NonASCII }x;
our $StringLiteral = qr{ ' (?: $LiteralChar )* ' }x;
our $MLLChar = qr{ [\x09\x20-\x26\x28-\x7E] | $NonASCII }x;
our $MLLContent = qr{ $MLLChar | $CRLF }x;
our $MLLQuotes = qr{ '{1,2} }x;
our $MLLBody = qr{ $MLLContent* (?: $MLLQuotes | $MLLContent{0,1} )*? $MLLQuotes? }x;
our $MultiLineStringLiteral = qr{ ''' (?: $CRLF? $MLLBody ) ''' }x;
our $BasicChar = qr{ $WS | [\x21\x23-\x5B\x5D-\x7E] | $NonASCII | $Escape }x;
our $BasicString = qr{ " (?: $BasicChar )* " }x;
our $MLBEscapedNL = qr{ \x5c $WS* $CRLF (?: $WS | $CRLF)* }x;
our $MLBUnescaped = qr{ $WS | [\x21\x23-\x5B\x5D-\x7E] | $NonASCII }x;
our $MLBQuotes = qr{ "{1,2} }x;
our $MLBChar = qr{ $MLBUnescaped | $Escape }x;
our $MLBContent = qr{ $MLBChar | $CRLF | $MLBEscapedNL }x;
our $MLBasicBody = qr{ $MLBContent* (?: $MLBQuotes | $MLBContent{0,1} )*? $MLBQuotes? }x;
our $MultiLineString = qr{ """ $CRLF? $MLBasicBody """ }x;
our $String = qr/$MultiLineString | $BasicString | $MultiLineStringLiteral | $StringLiteral/x;
#-------------------------------------------------------------------------------
# Keys
#-------------------------------------------------------------------------------
our $BareKey = qr/[-_\p{PosixAlnum}]+/;
our $QuotedKey = qr/$BasicString|$StringLiteral/;
our $SimpleKey = qr/$QuotedKey|$BareKey/;
our $DottedKey = qr/$SimpleKey (?: $WS* \. $WS* $SimpleKey)+/x;
our $Key = qr{ (?: $DottedKey | $SimpleKey ) }x;
#-----------------------------------------------------------------------------
# Dates (RFC 3339)
# 1985-04-12T23:20:50.52Z
#-----------------------------------------------------------------------------
our $DateFullYear = qr{ \d{4} }x;
our $DateMonth = qr{ (?: 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 ) }x;
our $DateDay = qr{ (?: 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 ) }x;
our $TimeDelim = qr{ (?: [tT] | \x20 ) }x;
our $TimeHour = qr{ (?: 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 ) }x;
our $TimeMinute = qr{ (?: 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 ) }x;
our $TimeSecond = qr{ (?: 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 ) }x; # may be 60 during leap second
our $TimeSecFrac = qr{ \. \d+ }x;
our $TimeNumOffset = qr{ (?: [-+] $TimeHour : $TimeMinute ) }x;
our $TimeOffset = qr{ (?: [zZ] | $TimeNumOffset ) }x;
our $PartialTime = qr{ (?: $TimeHour : $TimeMinute : $TimeSecond $TimeSecFrac? ) }x;
our $FullTime = qr{ (?: $PartialTime $TimeOffset ) }x;
our $FullDate = qr{ (?: $DateFullYear - $DateMonth - $DateDay ) }x;
our $OffsetDateTime = qr{ (?: $FullDate $TimeDelim $FullTime ) }x;
our $LocalDateTime = qr{ (?: $FullDate $TimeDelim $PartialTime ) }x;
our $LocalDate = qr{ (?: $FullDate ) }x;
our $LocalTime = qr{ (?: $PartialTime ) }x;
our $DateTime = qr{ (?: $OffsetDateTime | $LocalDateTime | $LocalDate | $LocalTime ) }x;
#-----------------------------------------------------------------------------
# Integer
#-----------------------------------------------------------------------------
our $DecFirstChar = qr/[1-9]/;
our $DecChar = qr/[0-9]/;
our $HexChar = qr/[0-9a-fA-F]/;
our $OctChar = qr/[0-7]/;
our $BinChar = qr/[01]/;
our $Zero = qr/[-+]? 0/x;
our $Hex = qr/0x $HexChar (?> _? $HexChar )*/x;
our $Oct = qr/0o $OctChar (?> _? $OctChar )*/x;
our $Bin = qr/0b $BinChar (?> _? $BinChar )*/x;
our $Dec = qr/$Zero | (?> [-+]? $DecFirstChar (?> _? $DecChar )* )/x;
our $Integer = qr/$Hex | $Oct | $Bin | $Dec/x;
#-----------------------------------------------------------------------------
# Float
#-----------------------------------------------------------------------------
our $SpecialFloat = qr/[-+]? (?: (?:inf) | (?:nan) | (?:NaN) )/x;
our $Fraction = qr/\. $DecChar (?> _? $DecChar)*/x;
our $Exponent = qr{
[eE]
(?>
$Zero+ # dec matches only one zero, but toml exponents apparently accept e00
| $Dec
)
}x;
our $Float = qr{
(?> $Dec (?> (?> $Fraction $Exponent?) | $Exponent ) )
| $SpecialFloat
}x;
1;
=head1 SYNOPSIS
use TOML::Tiny::Grammar;
if ($src =~ /$MultiLineString/) {
...
}
=head1 DESCRIPTION
Exports various regexex for parsing TOML source.
=head1 PATTERNS
=head2 White space and ignorables
=head3 $WS
=head3 $CRLF
=head3 $EOL
=head3 $Comment
=head2 Keys
=head3 $BareKey
=head3 $QuotedKey
=head3 $SimpleKey
=head3 $DottedKey
=head3 $Key
=head2 Values
=head3 $Boolean
=head3 $Escape
=head3 $StringLiteral
=head3 $MultiLineStringLiteral
=head3 $BasicString
=head3 $MultiLineString
=head3 $String
=head3 $Date
=head3 $Time
=head3 $DateTime
=head3 $Hex
=head3 $Oct
=head3 $Bin
=head3 $Dec
=head3 $Integer
=head3 $Float
=head2 $SpecialFloat
=cut
work/TOML-Tiny/lib/TOML/Tiny/Parser.pm 0000664 0000000 0000000 00000030302 14777226410 014472 0 ustar package TOML::Tiny::Parser;
# ABSTRACT: parser used by TOML::Tiny
use utf8;
use strict;
use warnings;
no warnings qw(experimental);
use v5.18;
use Carp qw(confess);
use Data::Dumper qw(Dumper);
use Encode qw(decode FB_CROAK);
use Math::BigFloat ();
use Math::BigInt ();
use TOML::Tiny::Grammar qw($TimeOffset);
use TOML::Tiny::Tokenizer ();
our $TRUE = 1;
our $FALSE = 0;
eval{
require Types::Serialiser;
$TRUE = Types::Serialiser::true();
$FALSE = Types::Serialiser::false();
};
sub new {
my ($class, %param) = @_;
bless{
inflate_integer => $param{inflate_integer},
inflate_float => $param{inflate_float},
inflate_datetime => $param{inflate_datetime} || sub{ shift },
inflate_boolean => $param{inflate_boolean} || sub{ shift eq 'true' ? $TRUE : $FALSE },
strict => $param{strict},
}, $class;
}
sub next_token {
my $self = shift;
my $token = $self->{tokenizer} && $self->{tokenizer}->next_token;
return $token;
}
sub parse {
my ($self, $toml) = @_;
if ($self->{strict}) {
$toml = decode('UTF-8', "$toml", FB_CROAK);
}
$self->{tokenizer} = TOML::Tiny::Tokenizer->new(source => $toml);
$self->{keys} = [];
$self->{root} = {};
$self->{tables} = {}; # "seen" hash of explicitly defined table names (e.g. [foo])
$self->{arrays} = {}; # "seen" hash of explicitly defined static arrays (e.g. foo=[])
$self->{array_tables} = {}; # "seen" hash of explicitly defined arrays of tables (e.g. [[foo]])
$self->parse_table;
my $result = $self->{root};
delete $self->{tokenizer};
delete $self->{keys};
delete $self->{root};
delete $self->{tables};
delete $self->{arrays};
delete $self->{array_tables};
return $result;
}
sub parse_error {
my ($self, $token, $msg) = @_;
my $line = $token ? $token->{line} : 'EOF';
if ($ENV{TOML_TINY_DEBUG}) {
my $root = Dumper($self->{root});
my $tok = Dumper($token);
my $src = substr $self->{tokenizer}{source}, $self->{tokenizer}{position}, 30;
confess qq{
toml parse error at line $line:
$msg
Current token:
$tok
Parse state:
$root
Source near location of error:
...
$src
...
};
} else {
die "toml parse error at line $line: $msg\n";
}
}
sub expect_type {
my ($self, $token, $expected) = @_;
my $actual = $token ? $token->{type} : 'EOF';
$self->parse_error($token, "expected $expected, but found $actual")
unless $actual =~ /$expected/;
}
sub current_key {
my $self = shift;
my @keys = $self->get_keys;
my $key = join '.', map{ qq{"$_"} } @keys;
return $key;
}
sub push_keys {
my ($self, $token) = @_;
push @{ $self->{keys} }, $token->{value};
}
sub pop_keys {
my $self = shift;
pop @{ $self->{keys} };
}
sub get_keys {
my $self = shift;
return map{ @$_ } @{ $self->{keys} };
}
sub set_key {
my ($self, $token) = @_;
my @keys = $self->get_keys;
my $key = pop @keys;
my $node = $self->scan_to_key(\@keys);
if ($key && exists $node->{$key}) {
$self->parse_error($token, 'duplicate key: ' . $self->current_key);
}
$node->{$key} = $self->parse_value($token);
}
sub declare_key {
my ($self, $token) = @_;
my $key = $self->current_key || return;
if ($token->{type} eq 'inline_array') {
$self->parse_error($token, "duplicate key: $key")
if exists $self->{array_tables}{$key};
$self->{arrays}{$key} = 1;
return;
}
if ($token->{type} eq 'array_table') {
if (exists $self->{arrays}{$key}) {
$self->parse_error($token, "duplicate key: $key");
}
$self->{array_tables}{$key} = 1;
return;
}
if ($token->{type} eq 'table') {
$self->parse_error($token, "duplicate key: $key")
if exists $self->{arrays}{$key}
|| exists $self->{array_tables}{$key};
if (exists $self->{tables}{$key}) {
# Tables cannot be redefined, *except* when doing so within a goddamn
# table array. Gawd I hate TOML.
my $in_a_stupid_table_array = 0;
my $node = $self->{root};
for my $key ($self->get_keys) {
if (exists $node->{$key} && ref($node->{$key}) eq 'ARRAY') {
$in_a_stupid_table_array = 1;
last;
} else {
$node = $node->{$key};
}
}
unless ($in_a_stupid_table_array) {
$self->parse_error($token, "duplicate key: $key");
}
return;
}
$self->{tables}{$key} = 1;
}
}
sub scan_to_key {
my $self = shift;
my $keys = shift // [ $self->get_keys ];
my $node = $self->{root};
KEY:
for my $key (@$keys) {
if (exists $node->{$key}) {
my $ref = ref $node->{$key};
if ( $ref eq 'HASH' ) {
$node = $node->{$key};
next KEY;
}
if ( $ref eq 'ARRAY' ) {
$node = $node->{$key}[-1];
next KEY;
}
my $full_key = join '.', @$keys;
die "$full_key is already defined\n";
}
else {
$node = $node->{$key} = {};
}
}
return $node;
}
sub parse_table {
my $self = shift;
my $token = shift // $self->next_token // return; # may be undef on first token in empty document
$self->expect_type($token, 'table');
$self->push_keys($token);
$self->scan_to_key;
$self->declare_key($token);
TOKEN: while (my $token = $self->next_token) {
my $type = $token->{type};
next TOKEN if $type eq 'EOL';
if ( $type eq 'key') {
$self->expect_type($self->next_token, 'assign');
$self->push_keys($token);
$self->set_key($self->next_token);
$self->pop_keys;
if (my $eol = $self->next_token) {
$self->expect_type($eol, 'EOL');
} else {
return;
}
next TOKEN;
}
if ($type eq 'array_table') {
$self->pop_keys;
@_ = ($self, $token);
goto \&parse_array_table;
}
if ( $type eq 'table') {
$self->pop_keys;
@_ = ($self, $token);
goto \&parse_table;
}
$self->parse_error($token, "expected key-value pair, table, or array of tables but got $type");
}
}
sub parse_array_table {
my $self = shift;
my $token = shift // $self->next_token;
$self->expect_type($token, 'array_table');
$self->push_keys($token);
$self->declare_key($token);
my @keys = $self->get_keys;
my $key = pop @keys;
my $node = $self->scan_to_key(\@keys);
$node->{$key} //= [];
push @{ $node->{$key} }, {};
TOKEN:
while (my $token = $self->next_token) {
my $type = $token->{type};
next TOKEN if $type eq 'EOL';
if ($type eq 'key') {
$self->expect_type($self->next_token, 'assign');
$self->push_keys($token);
$self->set_key($self->next_token);
$self->pop_keys;
next TOKEN;
}
if ($type eq 'array_table') {
$self->pop_keys;
@_ = ($self, $token);
goto \&parse_array_table;
}
if ($type eq 'table') {
$self->pop_keys;
@_ = ($self, $token);
goto \&parse_table;
}
$self->parse_error($token, "expected key-value pair, table, or array of tables but got $type");
}
}
sub parse_key {
my $self = shift;
my $token = shift // $self->next_token;
$self->expect_type($token, 'key');
return $token->{value};
}
sub parse_value {
my $self = shift;
my $token = shift;
my $type = $token->{type};
return $token->{value} if $type eq 'string';
return $self->inflate_float($token) if $type eq'float';
return $self->inflate_integer($token) if $type eq 'integer';
return $self->{inflate_boolean}->($token->{value}) if $type eq 'bool';
return $self->parse_datetime($token) if $type eq 'datetime';
return $self->parse_inline_table($token) if $type eq 'inline_table';
return $self->parse_array($token) if $type eq 'inline_array';
$self->parse_error($token, "value expected (bool, number, string, datetime, inline array, inline table), but found $type");
}
#-------------------------------------------------------------------------------
# TOML permits a space instead of a T, which RFC3339 does not allow. TOML (at
# least, according to BurntSushi/toml-tests) allows z instead of Z, which
# RFC3339 also does not permit. We will be flexible and allow them both, but
# fix them up. TOML also specifies millisecond precision. If fractional seconds
# are specified. Whatever.
#-------------------------------------------------------------------------------
sub parse_datetime {
my $self = shift;
my $token = shift;
my $value = $token->{value};
# Normalize
$value =~ tr/z/Z/;
$value =~ tr/ /T/;
$value =~ s/t/T/;
$value =~ s/(\.\d+)($TimeOffset)$/sprintf(".%09d%s", $1 * 1000000000, $2)/e;
return $self->{inflate_datetime}->($value);
}
sub parse_array {
my $self = shift;
my $token = shift;
$self->declare_key($token);
my @array;
my $expect = 'EOL|inline_array_close|string|float|integer|bool|datetime|inline_table|inline_array';
TOKEN: while (1) {
my $token = $self->next_token;
$self->expect_type($token, $expect);
if ( $token->{type} eq 'comma') {
$expect = 'EOL|inline_array_close|string|float|integer|bool|datetime|inline_table|inline_array';
next TOKEN;
}
next TOKEN if $token->{type} eq 'EOL';
last TOKEN if $token->{type} eq 'inline_array_close';
push @array, $self->parse_value($token);
$expect = 'comma|EOL|inline_array_close';
}
return \@array;
}
sub parse_inline_table {
my $self = shift;
my $token = shift;
my $table = {};
my $expect = 'EOL|inline_table_close|key';
TOKEN: while (1) {
my $token = $self->next_token;
$self->expect_type($token, $expect);
my $type = $token->{type};
if ($type eq 'comma') {
$expect = $self->{strict}
? 'EOL|key'
: 'EOL|key|inline_table_close';
next TOKEN;
}
if ($type eq 'key') {
$self->expect_type($self->next_token, 'assign');
my $node = $table;
my @keys = @{ $token->{value} };
my $key = pop @keys;
for (@keys) {
$node->{$_} ||= {};
$node = $node->{$_};
}
if (exists $node->{$key}) {
$self->parse_error($token, 'duplicate key: ' . join('.', map{ qq{"$_"} } @{ $token->{value} }));
} else {
$node->{ $key } = $self->parse_value($self->next_token);
}
$expect = 'comma|inline_table_close';
next TOKEN;
}
last TOKEN if $type eq 'inline_table_close';
$self->parse_error($token, "inline table expected key-value pair, but found $type");
}
return $table;
}
sub inflate_float {
my $self = shift;
my $token = shift;
my $value = $token->{value};
# Caller-defined inflation routine
if ($self->{inflate_float}) {
return $self->{inflate_float}->($value);
}
return 'NaN' if $value =~ /^[-+]?nan$/i;
return 'inf' if $value =~ /^\+?inf$/i;
return '-inf' if $value =~ /^-inf$/i;
# Not a bignum
if (0 + $value eq $value) {
return 0 + $value;
}
#-----------------------------------------------------------------------------
# Scientific notation is a hairier situation. In order to determine whether a
# value will fit inside a perl svnv, we can't just coerce the value to a
# number and then test it against the string, because, for example, this will
# always be false:
#
# 9 eq "3e2"
#
# Instead, we are forced to test the coerced value against a BigFloat, which
# is capable of holding the number.
#-----------------------------------------------------------------------------
if ($value =~ /[eE]/) {
if (Math::BigFloat->new($value)->beq(0 + $value)) {
return 0 + $value;
}
}
return Math::BigFloat->new($value);
}
sub inflate_integer {
my $self = shift;
my $token = shift;
my $value = $token->{value};
# Caller-defined inflation routine
if ($self->{inflate_integer}) {
return $self->{inflate_integer}->($value);
}
# Hex
if ($value =~ /^0x/) {
no warnings 'portable';
my $hex = hex $value;
my $big = Math::BigInt->new($value);
return $big->beq($hex) ? $hex : $big;
}
# Octal
if ($value =~ /^0o/) {
no warnings 'portable';
$value =~ s/^0o/0/;
my $oct = oct $value;
my $big = Math::BigInt->from_oct($value);
return $big->beq($oct) ? $oct : $big;
}
# Binary
if ($value =~ /^0b/) {
no warnings 'portable';
my $bin = oct $value; # oct handles 0b as binary
my $big = Math::BigInt->new($value);
return $big->beq($bin) ? $bin : $big;
}
# Not a bignum
if (0 + $value eq $value) {
return 0 + $value;
}
return Math::BigInt->new($value);
}
1;
work/TOML-Tiny/lib/TOML/Tiny/Tokenizer.pm 0000664 0000000 0000000 00000013206 14777226410 015214 0 ustar package TOML::Tiny::Tokenizer;
# ABSTRACT: tokenizer used by TOML::Tiny
use strict;
use warnings;
no warnings qw(experimental);
use charnames qw(:full);
use v5.18;
use TOML::Tiny::Grammar qw(
$Comment
$CRLF
$DateTime
$EOL
$Escape
$Float
$Integer
$Key
$SimpleKey
$String
$WS
);
sub new {
my ($class, %param) = @_;
my $self = bless{
source => $param{source},
last_position => length $param{source},
position => 0,
line => 1,
last_token => undef,
}, $class;
return $self;
}
sub last_token {
my $self = shift;
return $self->{last_token};
}
sub next_token {
my $self = shift;
return unless defined $self->{source}
&& $self->{position} < $self->{last_position};
if (!$self->{last_token}) {
return $self->{last_token} = {type => 'table', pos => 0, line => 1, value => []};
}
# Update the regex engine's position marker in case some other regex
# attempted to match against the source string and reset it.
pos($self->{source}) = $self->{position};
my $token;
my $type;
my $value;
state $key_set = qr/\G ($Key) $WS* (?= =)/x;
state $table = qr/\G \[ $WS* ($Key) $WS* \] $WS* (?:$EOL | $)/x;
state $array_table = qr/\G \[\[ $WS* ($Key) $WS* \]\] $WS* (?:$EOL | $)/x;
state $simple = {
'[' => 'inline_array',
']' => 'inline_array_close',
'{' => 'inline_table',
'}' => 'inline_table_close',
',' => 'comma',
'=' => 'assign',
'true' => 'bool',
'false' => 'bool',
};
# More complex matches with regexps
while ($self->{position} < $self->{last_position} && !defined($type)) {
my $prev = $self->{last_token} ? $self->{last_token}{type} : 'EOL';
my $newline = !!($prev eq 'EOL' || $prev eq 'table' || $prev eq 'array_table');
for ($self->{source}) {
/\G$WS+/gc; # ignore whitespace
/\G$Comment$/mgc && next; # ignore comments
last if /\G$/gc;
if (/\G$EOL/gc) {
++$self->{line};
$type = 'EOL';
last;
}
if ($newline) {
if (/$table/gc) {
$type = 'table';
$value = $self->tokenize_key($1);
last;
}
if (/$array_table/gc) {
$type = 'array_table';
$value = $self->tokenize_key($1);
last;
}
}
if (/$key_set/gc) {
$type = 'key';
$value = $1;
last;
}
if (/\G ( [\[\]{}=,] | true | false )/xgc) {
$value = $1;
$type = $simple->{$value};
last;
}
if (/\G($String)/gc) {
$type = 'string';
$value = $1;
last;
}
if (/\G($DateTime)/gc) {
$type = 'datetime';
$value = $1;
last;
}
if (/\G($Float)/gc) {
$type = 'float';
$value = $1;
last;
}
if (/\G($Integer)/gc) {
$type = 'integer';
$value = $1;
last;
}
my $substr = substr($self->{source}, $self->{position}, 30) // 'undef';
die "toml syntax error on line $self->{line}\n\t-->|$substr|\n";
}
if ($type) {
state $tokenizers = {};
my $tokenize = $tokenizers->{$type} //= $self->can("tokenize_$type") || 0;
$token = {
line => $self->{line},
pos => $self->{pos},
type => $type,
value => $tokenize ? $tokenize->($self, $value) : $value,
prev => $self->{last_token},
};
# Unset the previous token's 'prev' key to prevent keeping the entire
# chain of previously parsed tokens alive for the whole process.
undef $self->{last_token}{prev};
$self->{last_token} = $token;
}
$self->update_position;
}
return $token;
}
sub current_line {
my $self = shift;
my $rest = substr $self->{source}, $self->{position};
my $stop = index $rest, "\n";
substr $rest, 0, $stop;
}
sub update_position {
my $self = shift;
$self->{position} = pos($self->{source}) // 0;
}
sub error {
my $self = shift;
my $token = shift;
my $msg = shift // 'unknown';
my $line = $token ? $token->{line} : $self->{line};
die "toml: parse error at line $line: $msg\n";
}
sub tokenize_key {
my $self = shift;
my $toml = shift;
my @segs = $toml =~ /($SimpleKey)\.?/g;
my @keys;
for my $seg (@segs) {
$seg = $self->tokenize_string($seg) if $seg =~ m/^['"]/;
push @keys, $seg;
}
return \@keys;
}
sub tokenize_float {
$_[1] =~ tr/_//d;
$_[1];
}
sub tokenize_integer {
$_[1] =~ tr/_+//d;
$_[1];
}
sub tokenize_string {
my $self = shift;
my $toml = shift;
my $ml = index($toml, q{'''}) == 0
|| index($toml, q{"""}) == 0;
my $lit = index($toml, q{'}) == 0;
my $str = '';
if ($ml) {
$str = substr $toml, 3, length($toml) - 6;
my @newlines = $str =~ /($CRLF)/g;
$self->{line} += scalar @newlines;
$str =~ s/^$WS* $CRLF//x; # trim leading whitespace
$str =~ s/\\$EOL\s*//xgs; # trim newlines from lines ending in backslash
} else {
$str = substr($toml, 1, length($toml) - 2);
}
if (!$lit) {
$str = $self->unescape_str($str);
}
return $str;
}
sub unescape_chars {
state $esc = {
'\b' => "\x08",
'\t' => "\x09",
'\n' => "\x0A",
'\f' => "\x0C",
'\r' => "\x0D",
'\"' => "\x22",
'\/' => "\x2F",
'\\\\' => "\x5C",
};
if (exists $esc->{$_[0]}) {
return $esc->{$_[0]};
}
my $hex = hex substr($_[0], 2);
if ($hex < 0x10FFFF && charnames::viacode($hex)) {
return chr $hex;
}
return;
}
sub unescape_str {
state $re = qr/($Escape)/;
$_[1] =~ s|$re|unescape_chars($1) // $_[0]->error(undef, "invalid unicode escape: $1")|xge;
$_[1];
}
1;
work/TOML-Tiny/lib/TOML/Tiny/Util.pm 0000664 0000000 0000000 00000002134 14777226410 014155 0 ustar package TOML::Tiny::Util;
# ABSTRACT: utility functions used by TOML::Tiny
use strict;
use warnings;
no warnings 'experimental';
use v5.18;
use TOML::Tiny::Grammar;
use parent 'Exporter';
our @EXPORT_OK = qw(
is_strict_array
);
my @_type_map = (
[ qr{Float}, 'float' ],
[ qr{Int}, 'integer' ],
[ qr{Boolean}, 'bool' ],
[ qr{^$Boolean}, 'bool' ],
[ qr{^$Float}, 'float' ],
[ qr{^$Integer}, 'integer' ],
[ qr{^$DateTime}, 'float' ],
);
sub is_strict_array {
my $arr = shift;
my @types = map{
my $value = $_;
my $type;
my $ref = ref($value);
if ($ref eq 'ARRAY') {
$type = 'array';
}
elsif ($ref eq 'HASH') {
$type = 'table';
}
# Do a little heuristic guess-work
else {
for my $pair (@_type_map) {
if ( $ref =~ m{$pair->[0]} ) {
$type = $pair->[1];
}
last;
}
}
$type //= 'string';
return $type;
} @$arr;
my $t = shift @types;
for (@types) {
return (undef, "expected value of type $t, but found $_")
if $_ ne $t;
}
return (1, undef);
}
1;
work/TOML-Tiny/lib/TOML/Tiny/Writer.pm 0000664 0000000 0000000 00000015521 14777226410 014520 0 ustar package TOML::Tiny::Writer;
use strict;
use warnings;
no warnings qw(experimental);
use v5.18;
use B qw(SVf_IOK SVf_NOK svref_2object);
use Data::Dumper qw(Dumper);
use TOML::Tiny::Grammar qw($BareKey $DateTime $SpecialFloat);
use TOML::Tiny::Util qw(is_strict_array);
use constant CORE_BOOL => defined &builtin::is_bool;
my @KEYS;
sub to_toml {
my $data = shift;
die 'toml: data to encode must be a hashref' if ref $data ne 'HASH';
return _to_toml( $data, { @_ } );
}
sub _to_toml ($$);
sub _to_toml ($$) {
my $data = shift;
my $param = shift;
die 'toml: found undefined value, which is unsupported by TOML' if ! defined $data;
my $ref = ref $data;
if ($ref eq 'HASH') {
return to_toml_table($data, $param);
}
if ($ref eq 'ARRAY') {
return to_toml_array($data, $param);
}
if ($ref eq 'SCALAR') {
if ($$data eq '1') {
return 'true';
} elsif ($$data eq '0') {
return 'false';
} else {
return _to_toml($$_, $param);
}
}
if ($ref eq 'JSON::PP::Boolean') {
return $$data ? 'true' : 'false';
}
if ($ref eq 'Types::Serializer::Boolean') {
return $data ? 'true' : 'false';
}
if ($ref eq 'DateTime') {
return strftime_rfc3339($data);
}
if ($ref eq 'Math::BigInt') {
return $data->bstr;
}
if ($ref eq 'Math::BigFloat') {
if ($data->is_inf || $data->is_nan) {
return lc $data->bstr;
} else {
return $data->bstr;
}
}
if ($ref eq '') {
if (CORE_BOOL && builtin::is_bool($data)) {
return $data ? 'true' : 'false';
}
# Thanks to ikegami on Stack Overflow for the trick!
# https://stackoverflow.com/questions/12686335/how-to-tell-apart-numeric-scalars-and-string-scalars-in-perl/12693984#12693984
# note: this must come before any regex can flip this flag off
if (svref_2object(\$data)->FLAGS & (SVf_IOK | SVf_NOK)) {
return 'inf' if Math::BigFloat->new($data)->is_inf;
return '-inf' if Math::BigFloat->new($data)->is_inf('-');
return 'nan' if Math::BigFloat->new($data)->is_nan;
return $data;
}
return to_toml_string($data) if $param->{no_string_guessing};
#return $data if svref_2object(\$data)->FLAGS & (SVf_IOK | SVf_NOK);
return $data if $data =~ /^$DateTime$/;
return lc($data) if $data =~ /^$SpecialFloat$/;
return to_toml_string($data);
}
die 'unhandled: '.Dumper($ref);
}
sub to_toml_inline_table {
my ($data, $param) = @_;
my @buff;
for my $k (keys %$data) {
my $key = to_toml_key($k);
my $val = $data->{$k};
if (ref $val eq 'HASH') {
push @buff, $key . '=' . to_toml_inline_table($val);
} else {
push @buff, $key . '=' . _to_toml($val, $param);
}
}
return '{' . join(', ', @buff) . '}';
}
sub to_toml_table {
my ($data, $param) = @_;
my @buff_assign;
my @buff_tables;
# Generate simple key/value pairs for scalar data
for my $k (grep{ ref($data->{$_}) !~ /HASH|ARRAY/ } sort keys %$data) {
my $key = to_toml_key($k);
my $val = _to_toml($data->{$k}, $param);
push @buff_assign, "$key=$val";
}
# For arrays, generate an array of tables if all elements of the array are
# hashes. For mixed arrays, generate an inline array.
ARRAY: for my $k (grep{ ref $data->{$_} eq 'ARRAY' } sort keys %$data) {
# Empty table
if (!@{$data->{$k}}) {
my $key = to_toml_key($k);
push @buff_assign, "$key=[]";
next ARRAY;
}
# Mixed array
if (grep{ ref $_ ne 'HASH' } @{$data->{$k}}) {
my $key = to_toml_key($k);
my $val = _to_toml($data->{$k}, $param);
push @buff_assign, "$key=$val";
}
# Array of tables
else {
push @KEYS, $k;
for (@{ $data->{$k} }) {
push @buff_tables, '', '[[' . join('.', map{ to_toml_key($_) } @KEYS) . ']]';
push @buff_tables, _to_toml($_, $param);
}
pop @KEYS;
}
}
# Sub-tables
for my $k (grep{ ref $data->{$_} eq 'HASH' } sort keys %$data) {
if (!keys(%{$data->{$k}})) {
# Empty table
my $key = to_toml_key($k);
push @buff_assign, "$key={}";
} else {
# Generate [table]
push @KEYS, $k;
push @buff_tables, '', '[' . join('.', map{ to_toml_key($_) } @KEYS) . ']';
push @buff_tables, _to_toml($data->{$k}, $param);
pop @KEYS;
}
}
join "\n", @buff_assign, @buff_tables;
}
sub to_toml_array {
my ($data, $param) = @_;
if (@$data && $param->{strict}) {
my ($ok, $err) = is_strict_array($data);
die "toml: found heterogenous array, but strict is set ($err)\n" unless $ok;
}
my @items;
for my $item (@$data) {
if (ref $item eq 'HASH') {
push @items, to_toml_inline_table($item, $param);
} else {
push @items, _to_toml($item, $param);
}
}
return "[\n" . join("\n", map{ " $_," } @items) . "\n]";
}
sub to_toml_key {
my $str = shift;
if ($str =~ /^$BareKey$/) {
return $str;
} else {
# Not valid as a "bare key". Encode it as a "quoted key"
# (in TOML terminology), using the "literal string" format.
return to_toml_string($str);
}
}
sub to_toml_string {
state $escape = {
"\n" => '\n',
"\r" => '\r',
"\t" => '\t',
"\f" => '\f',
"\b" => '\b',
"\"" => '\"',
"\\" => '\\\\',
"\'" => '\\\'',
};
my ($arg) = @_;
$arg =~ s/(["\\\b\f\n\r\t])/$escape->{$1}/g;
$arg =~ s/([\p{General_Category=Control}])/'\\u00' . unpack('H2', $1)/eg;
return '"' . $arg . '"';
}
#-------------------------------------------------------------------------------
# Adapted from DateTime::Format::RFC3339.
#-------------------------------------------------------------------------------
sub strftime_rfc3339 {
my ($dt) = @_;
my $tz;
#-----------------------------------------------------------------------------
# Calculate the time zone offset for non-UTC time zones.
#
# TOML uses RFC3339 for datetimes, but supports a "local datetime" which
# excludes the timezone offset. A DateTime with a floating time zone
# indicates a TOML local datetime.
#
# DateTime::Format::RFC3339 requires a time zone, however, and defaults to
# +00:00 for floating time zones. To support local datetimes in output,
# format the datetime as RFC3339 and strip the timezone when encountering a
# floating time zone.
#-----------------------------------------------------------------------------
if ($dt->time_zone_short_name eq 'floating') {
$tz = '';
} elsif ($dt->time_zone->is_utc) {
$tz = 'Z';
} else {
my $sign = $dt->offset < 0 ? '-' : '+';
my $secs = abs $dt->offset;
my $mins = int($secs / 60);
$secs %= 60;
my $hours = int($mins / 60);
$mins %= 60;
if ($secs) {
$dt = $dt->clone;
$dt->set_time_zone('UTC');
$tz = 'Z';
} else {
$tz = sprintf '%s%02d:%02d', $sign, $hours, $mins;
}
}
my $format = $dt->nanosecond ? '%Y-%m-%dT%H:%M:%S.%9N' : '%Y-%m-%dT%H:%M:%S';
return $dt->strftime($format) . $tz;
}
1;
work/TOML-Tiny/lib/TOML/Tiny.pm 0000664 0000000 0000000 00000024314 14777226410 013244 0 ustar package TOML::Tiny;
# ABSTRACT: a minimal, pure perl TOML parser and serializer
use strict;
use warnings;
no warnings qw(experimental);
use v5.18;
use TOML::Tiny::Parser ();
use TOML::Tiny::Writer ();
use parent 'Exporter';
our @EXPORT = qw(
from_toml
to_toml
);
#-------------------------------------------------------------------------------
# TOML module compatibility
#-------------------------------------------------------------------------------
sub from_toml {
my ($source, %param) = @_;
# strict was previously strict_arrays; accept both for backward
# compatibility.
if (exists $param{strict_arrays}) {
$param{strict} = $param{strict_arrays};
delete $param{strict_arrays};
}
my $parser = TOML::Tiny::Parser->new(%param);
my $toml = eval{ $parser->parse($source) };
if (wantarray) {
return ($toml, $@);
} else {
die $@ if $@;
return $toml;
}
}
sub to_toml {
my ($data, %param) = @_;
# strict was previously strict_arrays; accept both for backward
# compatibility.
if (exists $param{strict_arrays}) {
$param{strict} = $param{strict_arrays};
delete $param{strict_arrays};
}
TOML::Tiny::Writer::to_toml($data, %param);
}
#-------------------------------------------------------------------------------
# Object API
#-------------------------------------------------------------------------------
sub new {
my ($class, %param) = @_;
bless{ %param, parser => TOML::Tiny::Parser->new(%param) }, $class;
}
sub decode {
my ($self, $source) = @_;
$self->{parser}->parse($source);
}
sub encode {
my ($self, $data) = @_;
TOML::Tiny::Writer::to_toml(
$data,
strict => $self->{strict},
no_string_guessing => $self->{no_string_guessing},
);
}
#-------------------------------------------------------------------------------
# For compatibility with TOML::from_toml's use of $TOML::Parser
#-------------------------------------------------------------------------------
sub parse {
goto \&decode;
}
1;
=head1 SYNOPSIS
use TOML::Tiny qw(from_toml to_toml);
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
# Decoding TOML
my $toml = do{ local $/; };
my ($parsed, $error) = from_toml $toml;
# Encoding TOML
say to_toml({
stuff => {
about => ['other', 'stuff'],
},
});
# Object API
my $parser = TOML::Tiny->new;
my $data = $parser->decode($toml);
say $parser->encode($data);
=head1 DESCRIPTION
=begin html
=end html
C implements a pure-perl parser and generator for the
L data format. It conforms to TOML v1.0
(with a few caveats; see L).
C strives to maintain an interface compatible to the L and
L modules, and could even be used to override C<$TOML::Parser>:
use TOML;
use TOML::Tiny;
local $TOML::Parser = TOML::Tiny->new(...);
say to_toml(...);
=head1 EXPORTS
C exports the following to functions for compatibility with the
L module. See L.
=head2 from_toml
Parses a string of C-formatted source and returns the resulting data
structure. Any arguments after the first are passed to L's
constructor.
If there is a syntax error in the C source, C will die with
an explanation which includes the line number of the error.
my $result = eval{ from_toml($toml_string) };
Alternately, this routine may be called in list context, in which case syntax
errors will result in returning two values, C and an error message.
my ($result, $error) = from_toml($toml_string);
Additional arguments may be passed after the toml source string; see L.
=head3 GOTCHAS
=over
=item Big integers and floats
C supports integers and floats larger than what many perls support. When
C encounters a value it may not be able to represent as a number,
it will instead return a L or L. This behavior
can be overridden by providing inflation routines:
my $toml = TOML::Tiny->new(
inflate_float => sub{
return do_something_else_with_floats( $_[0] );
};
);
=back
=head2 to_toml
Encodes a hash ref as a C-formatted string.
my $toml = to_toml({foo => {'bar' => 'bat'}});
# [foo]
# bar="bat"
=head3 mapping perl to TOML types
=head4 table
=over
=item C ref
=back
=head4 array
=over
=item C ref
=back
=head4 boolean
=over
=item C<\0> or C<\1>
=item L
=item L
=back
=head4 numeric types
These are tricky in perl. When encountering a C,
that representation is used.
If the value is a defined (non-ref) scalar with the C or C
flags set, the value will be emitted unchanged. This is in line with most
other packages, so the normal hinting hacks for typed output apply:
number => 0 + $number,
string => "" . $string,
=over
=item L
=item L
=item numerical scalars
=back
=head4 datetime
=over
=item RFC3339-formatted string
e.g., C<"1985-04-12T23:20:50.52Z">
=item L
Ls are formatted as C, as expected by C. However,
C supports the concept of a "local" time zone, which strays from
C by allowing a datetime without a time zone offset. This is
represented in perl by a C with a B.
=back
=head4 string
All other non-ref scalars are treated as strings.
=head1 OBJECT API
=head2 new
=over
=item inflate_datetime
By default, C treats TOML datetimes as strings in the generated
data structure. The C parameter allows the caller to provide
a routine to intercept those as they are generated:
use DateTime::Format::RFC3339;
my $parser = TOML::Tiny->new(
inflate_datetime => sub{
my ($dt_string) = @_;
# DateTime::Format::RFC3339 will set the resulting DateTime's formatter
# to itself. Fallback is the DateTime default, ISO8601, with a possibly
# floating time zone.
return eval{ DateTime::Format::RFC3339->parse_datetime($dt_string) }
|| DateTime::Format::ISO8601->parse_datetime($dt_string);
},
);
=item inflate_boolean
By default, boolean values in a C document result in a C<1> or C<0>.
If L is installed, they will instead be C
or C.
If you wish to override this, you can provide your own routine to generate values:
my $parser = TOML::Tiny->new(
inflate_boolean => sub{
my $bool = shift;
if ($bool eq 'true') {
return 'The Truth';
} else {
return 'A Lie';
}
},
);
=item inflate_integer
TOML integers are 64 bit and may not match the size of the compiled perl's
internal integer type. By default, C coerces numbers that fit
within a perl number by adding C<0>. For bignums, a L is
returned. This may be overridden by providing an inflation routine:
my $parser = TOML::Tiny->new(
inflate_integer => sub{
my $parsed = shift;
return sprintf 'the number "%d"', $parsed;
};
);
=item inflate_float
TOML floats are 64 bit and may not match the size of the compiled perl's
internal float type. As with integers, floats are coerced to numbers and large
floats are upgraded to Ls. The special strings C and
C may also be returned. You can override this by specifying an inflation
routine.
my $parser = TOML::Tiny->new(
inflate_float => sub{
my $parsed = shift;
return sprintf '"%0.8f" is a float', $parsed;
};
);
=item strict
C imposes some miscellaneous strictures on C input, such as
disallowing trailing commas in inline tables and failing on invalid UTF8 input.
B C was previously called C. Both are accepted
for backward compatibility, although enforcement of homogenous arrays is no
longer supported as it has been dropped from the spec.
=back
=head2 decode
Decodes C and returns a hash ref. Dies on parse error.
=head2 encode
Encodes a perl hash ref as a C-formatted string.
=head2 parse
Alias for C to provide compatibility with C when
overriding the parser by setting C<$TOML::Parser>.
=head1 DIFFERENCES FROM L AND L
C differs in a few significant ways from the L module,
particularly in adding support for newer C features and strictness.
L defaults to lax parsing and provides C to (slightly)
tighten things up. C defaults to (somewhat) stricter parsing,
enabling some extra strictures with L.
C supports a number of options which do not exist in L:
L, L, and L.
C ignores invalid surrogate pairs within basic and multiline
strings (L may attempt to decode an invalid pair). Additionally, only
those character escapes officially supported by TOML are interpreted as such by
C.
C supports stripping initial whitespace and handles lines
terminating with a backslash correctly in multilne strings:
# TOML input
x="""
foo"""
y="""\
how now \
brown \
bureaucrat.\
"""
# Perl output
{x => 'foo', y => 'how now brown bureaucrat.'}
C includes support for integers specified in binary, octal or hex
as well as the special float values C and C.
=head1 SEE ALSO
=over
=item L
Regexp scraps used by C to parse TOML source.
=back
=head1 ACKNOWLEDGEMENTS
Thanks to L for encouraging their
employees to contribute back to the open source ecosystem. Without their
dedication to quality software development this distribution would not exist.
A big thank you to those who have contributed code or bug reports:
=over
=item L
=item L
=item L
=item L
=back
work/TOML-Tiny/perlimports.toml 0000664 0000000 0000000 00000002112 14777226410 013707 0 ustar # Valid log levels are:
# debug, info, notice, warning, error, critical, alert, emergency
# critical, alert and emergency are not currently used.
#
# Please use boolean values in this config file. Negated options (--no-*) are
# not permitted here. Explicitly set options to true or false.
#
# Some of these values deviate from the regular perlimports defaults. In
# particular, you're encouraged to leave preserve_duplicates and
# preserve_unused disabled.
cache = false # setting this to true is currently discouraged
ignore_modules = ["Test2::V0"]
ignore_modules_filename = ""
ignore_modules_pattern = "" # regex like "^(Foo|Foo::Bar)"
ignore_modules_pattern_filename = ""
libs = ["lib", "t/lib"]
log_filename = ""
log_level = "warn"
never_export_modules = []
never_export_modules_filename = ""
padding = false
preserve_duplicates = false
preserve_unused = false
tidy_whitespace = true
work/TOML-Tiny/t/ 0000775 0000000 0000000 00000000000 14777226410 010701 5 ustar work/TOML-Tiny/t/faithful.t 0000664 0000000 0000000 00000002320 14777226410 012665 0 ustar use utf8;
use Test2::V0;
use Data::Dumper;
use DateTime::Format::ISO8601;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
my $input = q{
datetime=2020-05-04T16:37:02.905408062+01:00
datetimes="2020-05-04T16:37:02.905408062+01:00"
float=3.14
floats="3.14"
uint=3
uints="3"
nint=-4
nints="-4"
bigint=1852528528562625752750
bigints="1852528528562625752750"
hex=0x12
oct=0o751
bin=0b11010110
boolf=false
boolt=true
boolfs="false"
boolts="true"
dtlocal=1979-05-27T00:32:00.643144312
dtlocals="1979-05-27T00:32:00.643144312"
};
sub norm ($) {
join "\n", (
sort
map {
s{=0o(\d+)$}{ '='.oct($1) }e;
s{=(0[xb]\w+)$}{ '='.eval($1) }e;
$_;
}
grep /./,
split /\n/, $_[0]
), ''
}
my $coder = TOML::Tiny->new(
no_string_guessing => 1,
inflate_datetime => sub {
# RFC3339 bombs out if there is no timezone, so we parse with 8601
DateTime::Format::ISO8601->parse_datetime(shift)
},
);
my $parsed = $coder->decode($input);
my $actual = norm($coder->encode($parsed));
my $expected = norm($input);
is($actual, $expected, 'round trip') or do{
diag 'EXPECTED:';
diag Dumper($expected);
diag 'ACTUAL:';
diag Dumper($actual);
};
done_testing;
work/TOML-Tiny/t/numbers.t 0000664 0000000 0000000 00000010117 14777226410 012541 0 ustar use strict;
use warnings;
use Test2::V0;
use TOML::Tiny;
require Math::BigInt;
require Math::BigFloat;
subtest 'integers' => sub{
subtest 'decimal' => sub{
is from_toml('x=42'), {x => 42}, 'positive';
is from_toml('x=-42'), {x => -42}, 'negative';
is from_toml('x=42_42'), {x => 4242}, 'underscores';
is from_toml('x=9223372036854775807'), hash{
field x => validator(sub{
my %params = @_;
Math::BigInt->new('9223372036854775807')->beq($params{got});
});
end;
}, 'positive bignum';
is from_toml('x=-9223372036854775808'), hash{
field x => validator(sub{
my %params = @_;
Math::BigInt->new('-9223372036854775808')->beq($params{got});
});
end;
}, 'negative bignum';
};
subtest 'hexadecimal' => sub{
is from_toml('x=0xDEADBEEF'), {x => 0xDEADBEEF}, 'all caps';
is from_toml('x=0xdeadbeef'), {x => 0xDEADBEEF}, 'all lower';
is from_toml('x=0xDeAdBeEf'), {x => 0xDEADBEEF}, 'mixed caps';
is from_toml('x=0xDEAD_BEEF'), {x => 0xDEADBEEF}, 'underscores';
is from_toml('x=0xDEADBEEF '), {x => 0xDEADBEEF}, 'trailing space';
is from_toml('x=0x7fffffffffffffff'), hash{
field x => validator(sub{
my %params = @_;
Math::BigInt->new('0x7fffffffffffffff')->beq($params{got});
});
end;
}, 'bignum';
};
subtest 'binary' => sub{
is from_toml('x=0b1010'), {x => 0b1010}, 'binary';
is from_toml('x=0b10_10'), {x => 0b1010}, 'underscores';
is from_toml('x=0o777777777777777777777'), hash{
field x => validator(sub{
my %params = @_;
Math::BigInt->from_oct('0777777777777777777777')->beq($params{got});
});
end;
}, 'bignum';
};
subtest 'octal' => sub{
is from_toml('x=0o755'), {x => 0755}, 'octal';
is from_toml('x=0o7_55'), {x => 0755}, 'underscores';
is from_toml('x=0b111111111111111111111111111111111111111111111111111111111111111'), hash{
field x => validator(sub{
my %params = @_;
Math::BigInt->new('0b111111111111111111111111111111111111111111111111111111111111111')->beq($params{got});
});
end;
}, 'bignum';
};
};
subtest 'floats' => sub{
is from_toml('x=4.2'), {x => 4.2}, '4.2';
is from_toml('x=+4.2'), {x => 4.2}, '+4.2';
is from_toml('x=-4.2'), {x => -4.2}, '-4.2';
is from_toml('x=0.42'), {x => 0.42}, '0.42';
is from_toml('x=+0.42'), {x => 0.42}, '+0.42';
is from_toml('x=-0.42'), {x => -0.42}, '-0.42';
subtest 'exponent w/ lowercase e' => sub{
is from_toml('x=4.2e3'), {x => 4.2e3}, '4.2e3';
is from_toml('x=-4.2e3'), {x => -4.2e3}, '-4.2e3';
is from_toml('x=4.2e-3'), {x => 4.2e-3}, '4.2e-3';
is from_toml('x=-4.2e-3'), {x => -4.2e-3}, '-4.2e-3';
};
subtest 'exponent w/ uppercase e' => sub{
is from_toml('x=4.2E3'), {x => 4.2e3}, '4.2E3';
is from_toml('x=-4.2E3'), {x => -4.2e3}, '-4.2E3';
is from_toml('x=4.2E-3'), {x => 4.2e-3}, '4.2E-3';
is from_toml('x=-4.2E-3'), {x => -4.2e-3}, '-4.2E-3';
};
is from_toml('x=inf'), {x => 'inf'}, 'inf';
is from_toml('x=+inf'), {x => 'inf'}, '+inf';
is from_toml('x=-inf'), {x => -'inf'}, '-inf';
for (qw(nan +nan -nan)) {
is from_toml("x=$_"), hash{
field x => 'NaN';
end;
}, $_;
}
is from_toml('x=nan'), {x => 'NaN'}, 'nan';
is from_toml('x=+nan'), {x => 'NaN'}, '+nan';
is from_toml('x=-nan'), {x => 'NaN'}, '-nan';
is from_toml('x=42_42.42_42'), {x => 4242.4242}, 'underscores';
};
#-------------------------------------------------------------------------------
# Ensure that numbers survive the trip through to_toml(from_toml(...)) and are
# not coerced into strings by perl.
#-------------------------------------------------------------------------------
subtest 'round trip preserves numerical values' => sub{
is to_toml(scalar from_toml('port=1234')), 'port=1234', 'integers';
is to_toml(scalar from_toml('pi=3.14')), 'pi=3.14', 'floats';
is to_toml(scalar from_toml('nan=nan')), 'nan=nan', 'nan';
is to_toml(scalar from_toml('pos=inf')), 'pos=inf', 'inf';
is to_toml(scalar from_toml('neg=-inf')), 'neg=-inf', '-inf';
};
done_testing;
work/TOML-Tiny/t/parity.t 0000664 0000000 0000000 00000004306 14777226410 012401 0 ustar #-------------------------------------------------------------------------------
# Tests the results of parsing the example TOML from
# https://github.com/toml-lang/toml against the de facto standard TOML module
# on CPAN. Includes the array-of-tables example as well since that is not
# represented in the synopsis example
#-------------------------------------------------------------------------------
use Test2::V0;
use Data::Dumper;
use TOML::Tiny::Parser;
my $toml = do{ local $/; };
subtest 'TOML::Parser' => sub{
use TOML::Parser;
subtest 'defaults' => sub{
my $exp = TOML::Parser->new->parse($toml);
my $got = TOML::Tiny::Parser->new->parse($toml);
is $got, $exp, 'equivalence'
or diag Dumper({got => $got, expected => $exp});
};
subtest 'inflate_boolean' => sub{
my $inflate = sub{ shift eq 'true' ? 'yes' : 'no' };
my $exp = TOML::Parser->new(inflate_boolean => $inflate)->parse($toml);
my $got = TOML::Tiny::Parser->new(inflate_boolean => $inflate)->parse($toml);
is $got, $exp, 'equivalence'
or diag Dumper({got => $got, expected => $exp});
};
subtest 'inflate_datetime' => sub{
require DateTime::Format::RFC3339;
my $inflate = sub{ DateTime::Format::RFC3339->parse_datetime(shift) };
my $exp = TOML::Parser->new(inflate_datetime => $inflate)->parse($toml);
my $got = TOML::Tiny::Parser->new(inflate_datetime => $inflate)->parse($toml);
is $got, $exp, 'equivalence'
or diag Dumper({got => $got, expected => $exp});
};
};
done_testing;
__DATA__
# This is a TOML document.
title = "TOML Example"
[owner]
name = "Tom Preston-Werner"
dob = 1979-05-27T07:32:00-08:00 # First class dates
[database]
server = "192.168.1.1"
ports = [ 8001, 8001, 8002 ]
connection_max = 5000
enabled = true
options = {"quote-keys"=false}
[servers]
# Indentation (tabs and/or spaces) is allowed but not required
[servers.alpha]
ip = "10.0.0.1"
dc = "eqdc10"
[servers.beta]
ip = "10.0.0.2"
dc = "eqdc10"
[clients]
data = [ ["gamma", "delta"], [1, 2] ]
# Line breaks are OK when inside arrays
hosts = [
"alpha",
"omega"
]
[[products]]
name = "Hammer"
sku = 738594937
[[products]]
[[products]]
name = "Nail"
sku = 284758393
color = "gray"
work/TOML-Tiny/t/parser.t 0000664 0000000 0000000 00000003640 14777226410 012365 0 ustar use strict;
use warnings;
use Data::Dumper;
use Test2::V0;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
subtest 'oddballs and regressions' => sub{
subtest 'strings that look like numbers' => sub{
my $parser = TOML::Tiny->new(
inflate_integer => sub{
use Math::BigInt;
Math::BigInt->new(shift);
},
inflate_float => sub{
use Math::BigFloat;
Math::BigFloat->new(shift);
}
);
my $data = $parser->decode(q{
not_an_int = "42"
is_an_int = 42
not_a_flt = "4.2"
is_a_flt = 4.2
});
ok !ref($data->{not_an_int}), 'strings do not inflate as integers';
ok ref($data->{is_an_int}) && $data->{is_an_int}->isa('Math::BigInt'), 'integers do inflate with inflate_integer';
ok !ref($data->{not_a_flt}), 'strings do not inflate as floats';
ok ref($data->{is_a_flt}) && $data->{is_a_flt}->isa('Math::BigFloat'), 'floats do inflate with inflate_float';
};
subtest 'no dequoting of raw string keys' => sub {
my $funky_string = "a \\\\ \\x42 b \\\"";
my $toml = <(); diag $error; };
my $diag = sub {
};
ok $data->{key}{$funky_string} eq 'a', "key.funky" and
ok $data->{itable}{$funky_string} eq 'b', "not in inline table" and
ok $data->{table}{$funky_string}{x} eq 'c', "not in table heading" and
ok $data->{array}{$funky_string}[0]{y} eq 'd', "not in array item heading" or do {
$diag1->();
diag '';
diag 'PARSED AS';
diag Dumper($data);
}
};
};
done_testing;
work/TOML-Tiny/t/strict_arrays.t 0000664 0000000 0000000 00000000444 14777226410 013761 0 ustar use strict;
use warnings;
use Test2::V0;
use TOML::Tiny;
my $tt = TOML::Tiny->new(strict_arrays => 1);
subtest 'string containing int recognized as type=integer' => sub{
my $toml = q{
[test]
array = ["u", "u2"]
};
ok lives{ $tt->decode($toml) }, 'parse succeeds';
};
done_testing;
work/TOML-Tiny/t/toml-test/ 0000775 0000000 0000000 00000000000 14777226410 012631 5 ustar work/TOML-Tiny/t/toml-test/invalid/ 0000775 0000000 0000000 00000000000 14777226410 014257 5 ustar work/TOML-Tiny/t/toml-test/invalid/array/ 0000775 0000000 0000000 00000000000 14777226410 015375 5 ustar work/TOML-Tiny/t/toml-test/invalid/array/missing-separator.t 0000664 0000000 0000000 00000000665 14777226410 021240 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/missing-separator.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/missing-separator';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/missing-separator.toml 0000664 0000000 0000000 00000000022 14777226410 021733 0 ustar wrong = [ 1 2 3 ]
work/TOML-Tiny/t/toml-test/invalid/array/no-close-2.t 0000664 0000000 0000000 00000000647 14777226410 017447 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/no-close-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/no-close-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/no-close-2.toml 0000664 0000000 0000000 00000000012 14777226410 020141 0 ustar x = [42 #
work/TOML-Tiny/t/toml-test/invalid/array/no-close-table-2.t 0000664 0000000 0000000 00000000663 14777226410 020532 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/no-close-table-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/no-close-table-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/no-close-table-2.toml 0000664 0000000 0000000 00000000022 14777226410 021227 0 ustar x = [{ key = 42 #
work/TOML-Tiny/t/toml-test/invalid/array/no-close-table.t 0000664 0000000 0000000 00000000657 14777226410 020376 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/no-close-table.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/no-close-table';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/no-close-table.toml 0000664 0000000 0000000 00000000020 14777226410 021066 0 ustar x = [{ key = 42
work/TOML-Tiny/t/toml-test/invalid/array/no-close.t 0000664 0000000 0000000 00000000643 14777226410 017304 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/no-close.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/no-close';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/no-close.toml 0000664 0000000 0000000 00000000027 14777226410 020010 0 ustar long_array = [ 1, 2, 3
work/TOML-Tiny/t/toml-test/invalid/array/tables-1.t 0000664 0000000 0000000 00000000643 14777226410 017175 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/tables-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/tables-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/tables-1.toml 0000664 0000000 0000000 00000000067 14777226410 017705 0 ustar # INVALID TOML DOC
fruit = []
[[fruit]] # Not allowed
work/TOML-Tiny/t/toml-test/invalid/array/tables-2.t 0000664 0000000 0000000 00000000643 14777226410 017176 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/tables-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/tables-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/tables-2.toml 0000664 0000000 0000000 00000000274 14777226410 017706 0 ustar # INVALID TOML DOC
[[fruit]]
name = "apple"
[[fruit.variety]]
name = "red delicious"
# This table conflicts with the previous table
[fruit.variety]
name = "granny smith"
work/TOML-Tiny/t/toml-test/invalid/array/text-after-array-entries.t 0000664 0000000 0000000 00000000703 14777226410 022430 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/text-after-array-entries.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/text-after-array-entries';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/text-after-array-entries.toml 0000664 0000000 0000000 00000000106 14777226410 023135 0 ustar array = [
"Is there life after an array separator?", No
"Entry"
]
work/TOML-Tiny/t/toml-test/invalid/array/text-before-array-separator.t 0000664 0000000 0000000 00000000711 14777226410 023117 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/text-before-array-separator.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/text-before-array-separator';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/text-before-array-separator.toml 0000664 0000000 0000000 00000000107 14777226410 023626 0 ustar array = [
"Is there life before an array separator?" No,
"Entry"
]
work/TOML-Tiny/t/toml-test/invalid/array/text-in-array.t 0000664 0000000 0000000 00000000655 14777226410 020274 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/array/text-in-array.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on array/text-in-array';
done_testing; work/TOML-Tiny/t/toml-test/invalid/array/text-in-array.toml 0000664 0000000 0000000 00000000070 14777226410 020773 0 ustar array = [
"Entry 1",
I don't belong,
"Entry 2",
]
work/TOML-Tiny/t/toml-test/invalid/bool/ 0000775 0000000 0000000 00000000000 14777226410 015212 5 ustar work/TOML-Tiny/t/toml-test/invalid/bool/mixed-case.t 0000664 0000000 0000000 00000000645 14777226410 017423 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/bool/mixed-case.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on bool/mixed-case';
done_testing; work/TOML-Tiny/t/toml-test/invalid/bool/mixed-case.toml 0000664 0000000 0000000 00000000016 14777226410 020123 0 ustar valid = False
work/TOML-Tiny/t/toml-test/invalid/bool/wrong-case-false.t 0000664 0000000 0000000 00000000661 14777226410 020537 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/bool/wrong-case-false.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on bool/wrong-case-false';
done_testing; work/TOML-Tiny/t/toml-test/invalid/bool/wrong-case-false.toml 0000664 0000000 0000000 00000000012 14777226410 021235 0 ustar b = FALSE
work/TOML-Tiny/t/toml-test/invalid/bool/wrong-case-true.t 0000664 0000000 0000000 00000000657 14777226410 020431 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/bool/wrong-case-true.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on bool/wrong-case-true';
done_testing; work/TOML-Tiny/t/toml-test/invalid/bool/wrong-case-true.toml 0000664 0000000 0000000 00000000011 14777226410 021121 0 ustar a = TRUE
work/TOML-Tiny/t/toml-test/invalid/control/ 0000775 0000000 0000000 00000000000 14777226410 015737 5 ustar work/TOML-Tiny/t/toml-test/invalid/control/comment-del.t 0000664 0000000 0000000 00000000655 14777226410 020336 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/comment-del.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/comment-del';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/comment-del.toml 0000664 0000000 0000000 00000000031 14777226410 021032 0 ustar comment-del = "0x7f" #
work/TOML-Tiny/t/toml-test/invalid/control/comment-lf.t 0000664 0000000 0000000 00000000653 14777226410 020171 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/comment-lf.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/comment-lf';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/comment-lf.toml 0000664 0000000 0000000 00000000032 14777226410 020670 0 ustar comment-lf = "ctrl-P" #
work/TOML-Tiny/t/toml-test/invalid/control/comment-null.t 0000664 0000000 0000000 00000000657 14777226410 020546 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/comment-null.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/comment-null';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/comment-null.toml 0000664 0000000 0000000 00000000032 14777226410 021241 0 ustar comment-null = "null" #
work/TOML-Tiny/t/toml-test/invalid/control/comment-us.t 0000664 0000000 0000000 00000000653 14777226410 020217 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/comment-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/comment-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/comment-us.toml 0000664 0000000 0000000 00000000032 14777226410 020716 0 ustar comment-us = "ctrl-_" #
work/TOML-Tiny/t/toml-test/invalid/control/multi-del.t 0000664 0000000 0000000 00000000651 14777226410 020022 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/multi-del.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/multi-del';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/multi-del.toml 0000664 0000000 0000000 00000000030 14777226410 020521 0 ustar multi-del = """null"""
work/TOML-Tiny/t/toml-test/invalid/control/multi-lf.t 0000664 0000000 0000000 00000000647 14777226410 017664 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/multi-lf.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/multi-lf';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/multi-lf.toml 0000664 0000000 0000000 00000000027 14777226410 020364 0 ustar multi-lf = """null"""
work/TOML-Tiny/t/toml-test/invalid/control/multi-null.t 0000664 0000000 0000000 00000000653 14777226410 020232 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/multi-null.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/multi-null';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/multi-null.toml 0000664 0000000 0000000 00000000031 14777226410 020730 0 ustar multi-null = """null """
work/TOML-Tiny/t/toml-test/invalid/control/multi-us.t 0000664 0000000 0000000 00000000647 14777226410 017712 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/multi-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/multi-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/multi-us.toml 0000664 0000000 0000000 00000000027 14777226410 020412 0 ustar multi-us = """null"""
work/TOML-Tiny/t/toml-test/invalid/control/rawmulti-del.t 0000664 0000000 0000000 00000000657 14777226410 020542 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/rawmulti-del.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/rawmulti-del';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/rawmulti-del.toml 0000664 0000000 0000000 00000000033 14777226410 021236 0 ustar rawmulti-del = '''null'''
work/TOML-Tiny/t/toml-test/invalid/control/rawmulti-lf.t 0000664 0000000 0000000 00000000655 14777226410 020375 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/rawmulti-lf.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/rawmulti-lf';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/rawmulti-lf.toml 0000664 0000000 0000000 00000000032 14777226410 021072 0 ustar rawmulti-lf = '''null'''
work/TOML-Tiny/t/toml-test/invalid/control/rawmulti-null.t 0000664 0000000 0000000 00000000661 14777226410 020743 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/rawmulti-null.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/rawmulti-null';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/rawmulti-null.toml 0000664 0000000 0000000 00000000034 14777226410 021445 0 ustar rawmulti-null = '''null '''
work/TOML-Tiny/t/toml-test/invalid/control/rawmulti-us.t 0000664 0000000 0000000 00000000655 14777226410 020423 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/rawmulti-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/rawmulti-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/rawmulti-us.toml 0000664 0000000 0000000 00000000032 14777226410 021120 0 ustar rawmulti-us = '''null'''
work/TOML-Tiny/t/toml-test/invalid/control/rawstring-del.t 0000664 0000000 0000000 00000000661 14777226410 020711 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/rawstring-del.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/rawstring-del';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/rawstring-del.toml 0000664 0000000 0000000 00000000030 14777226410 021407 0 ustar rawstring-del = 'null'
work/TOML-Tiny/t/toml-test/invalid/control/rawstring-lf.t 0000664 0000000 0000000 00000000657 14777226410 020553 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/rawstring-lf.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/rawstring-lf';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/rawstring-lf.toml 0000664 0000000 0000000 00000000027 14777226410 021252 0 ustar rawstring-lf = 'null'
work/TOML-Tiny/t/toml-test/invalid/control/rawstring-null.t 0000664 0000000 0000000 00000000663 14777226410 021121 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/rawstring-null.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/rawstring-null';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/rawstring-null.toml 0000664 0000000 0000000 00000000031 14777226410 021616 0 ustar rawstring-null = 'null '
work/TOML-Tiny/t/toml-test/invalid/control/rawstring-us.t 0000664 0000000 0000000 00000000657 14777226410 020601 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/rawstring-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/rawstring-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/rawstring-us.toml 0000664 0000000 0000000 00000000027 14777226410 021300 0 ustar rawstring-us = 'null'
work/TOML-Tiny/t/toml-test/invalid/control/string-bs.t 0000664 0000000 0000000 00000000651 14777226410 020036 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/string-bs.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/string-bs';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/string-bs.toml 0000664 0000000 0000000 00000000031 14777226410 020536 0 ustar string-bs = "backspace"
work/TOML-Tiny/t/toml-test/invalid/control/string-del.t 0000664 0000000 0000000 00000000653 14777226410 020200 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/string-del.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/string-del';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/string-del.toml 0000664 0000000 0000000 00000000025 14777226410 020701 0 ustar string-del = "null"
work/TOML-Tiny/t/toml-test/invalid/control/string-lf.t 0000664 0000000 0000000 00000000651 14777226410 020033 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/string-lf.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/string-lf';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/string-lf.toml 0000664 0000000 0000000 00000000024 14777226410 020535 0 ustar string-lf = "null"
work/TOML-Tiny/t/toml-test/invalid/control/string-null.t 0000664 0000000 0000000 00000000655 14777226410 020410 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/string-null.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/string-null';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/string-null.toml 0000664 0000000 0000000 00000000026 14777226410 021110 0 ustar string-null = "null "
work/TOML-Tiny/t/toml-test/invalid/control/string-us.t 0000664 0000000 0000000 00000000651 14777226410 020061 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/control/string-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on control/string-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/control/string-us.toml 0000664 0000000 0000000 00000000024 14777226410 020563 0 ustar string-us = "null"
work/TOML-Tiny/t/toml-test/invalid/datetime/ 0000775 0000000 0000000 00000000000 14777226410 016053 5 ustar work/TOML-Tiny/t/toml-test/invalid/datetime/impossible-date.t 0000664 0000000 0000000 00000000667 14777226410 021332 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/datetime/impossible-date.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on datetime/impossible-date';
done_testing; work/TOML-Tiny/t/toml-test/invalid/datetime/impossible-date.toml 0000664 0000000 0000000 00000000031 14777226410 022023 0 ustar d = 2006-01-50T00:00:00Z
work/TOML-Tiny/t/toml-test/invalid/datetime/no-leads-with-milli.t 0000664 0000000 0000000 00000000677 14777226410 022031 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/datetime/no-leads-with-milli.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on datetime/no-leads-with-milli';
done_testing; work/TOML-Tiny/t/toml-test/invalid/datetime/no-leads-with-milli.toml 0000664 0000000 0000000 00000000044 14777226410 022525 0 ustar with-milli = 1987-07-5T17:45:00.12Z
work/TOML-Tiny/t/toml-test/invalid/datetime/no-leads.t 0000664 0000000 0000000 00000000651 14777226410 017744 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/datetime/no-leads.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on datetime/no-leads';
done_testing; work/TOML-Tiny/t/toml-test/invalid/datetime/no-leads.toml 0000664 0000000 0000000 00000000037 14777226410 020452 0 ustar no-leads = 1987-7-05T17:45:00Z
work/TOML-Tiny/t/toml-test/invalid/datetime/no-secs.t 0000664 0000000 0000000 00000000647 14777226410 017616 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/datetime/no-secs.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on datetime/no-secs';
done_testing; work/TOML-Tiny/t/toml-test/invalid/datetime/no-secs.toml 0000664 0000000 0000000 00000000034 14777226410 020314 0 ustar no-secs = 1987-07-05T17:45Z
work/TOML-Tiny/t/toml-test/invalid/datetime/no-t.t 0000664 0000000 0000000 00000000641 14777226410 017116 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/datetime/no-t.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on datetime/no-t';
done_testing; work/TOML-Tiny/t/toml-test/invalid/datetime/no-t.toml 0000664 0000000 0000000 00000000033 14777226410 017621 0 ustar no-t = 1987-07-0517:45:00Z
work/TOML-Tiny/t/toml-test/invalid/datetime/trailing-t.t 0000664 0000000 0000000 00000000655 14777226410 020320 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/datetime/trailing-t.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on datetime/trailing-t';
done_testing; work/TOML-Tiny/t/toml-test/invalid/datetime/trailing-t.toml 0000664 0000000 0000000 00000000020 14777226410 021012 0 ustar d = 2006-01-30T
work/TOML-Tiny/t/toml-test/invalid/encoding/ 0000775 0000000 0000000 00000000000 14777226410 016045 5 ustar work/TOML-Tiny/t/toml-test/invalid/encoding/bad-utf8-at-end.t 0000664 0000000 0000000 00000000667 14777226410 021023 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/encoding/bad-utf8-at-end.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on encoding/bad-utf8-at-end';
done_testing; work/TOML-Tiny/t/toml-test/invalid/encoding/bad-utf8-at-end.toml 0000664 0000000 0000000 00000000362 14777226410 021523 0 ustar # There is a 0xda at after the quotes, and no EOL at the end of the file.
#
# This is a bit of an edge case: This indicates there should be two bytes
# (0b1101_1010) but there is no byte to follow because it's the end of the file.
x = """"""Ú work/TOML-Tiny/t/toml-test/invalid/encoding/bad-utf8-in-comment.t 0000664 0000000 0000000 00000000677 14777226410 021722 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/encoding/bad-utf8-in-comment.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on encoding/bad-utf8-in-comment';
done_testing; work/TOML-Tiny/t/toml-test/invalid/encoding/bad-utf8-in-comment.toml 0000664 0000000 0000000 00000000004 14777226410 022412 0 ustar # Ã
work/TOML-Tiny/t/toml-test/invalid/encoding/bad-utf8-in-string.t 0000664 0000000 0000000 00000000675 14777226410 021564 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/encoding/bad-utf8-in-string.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on encoding/bad-utf8-in-string';
done_testing; work/TOML-Tiny/t/toml-test/invalid/encoding/bad-utf8-in-string.toml 0000664 0000000 0000000 00000000103 14777226410 022256 0 ustar # The following line contains an invalid UTF-8 sequence.
bad = "Ã"
work/TOML-Tiny/t/toml-test/invalid/encoding/bom-not-at-start-1.t 0000664 0000000 0000000 00000000675 14777226410 021510 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/encoding/bom-not-at-start-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on encoding/bom-not-at-start-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/encoding/bom-not-at-start-1.toml 0000664 0000000 0000000 00000000024 14777226410 022204 0 ustar bom-not-at-start ÿý
work/TOML-Tiny/t/toml-test/invalid/encoding/bom-not-at-start-2.t 0000664 0000000 0000000 00000000675 14777226410 021511 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/encoding/bom-not-at-start-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on encoding/bom-not-at-start-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/encoding/bom-not-at-start-2.toml 0000664 0000000 0000000 00000000025 14777226410 022206 0 ustar bom-not-at-start= ÿý
work/TOML-Tiny/t/toml-test/invalid/encoding/utf16-bom.t 0000664 0000000 0000000 00000000653 14777226410 017756 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/encoding/utf16-bom.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on encoding/utf16-bom';
done_testing; work/TOML-Tiny/t/toml-test/invalid/encoding/utf16-bom.toml 0000664 0000000 0000000 00000000046 14777226410 020462 0 ustar þÿ # U T F - 1 6 w i t h B O M
work/TOML-Tiny/t/toml-test/invalid/encoding/utf16.t 0000664 0000000 0000000 00000000643 14777226410 017202 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/encoding/utf16.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on encoding/utf16';
done_testing; work/TOML-Tiny/t/toml-test/invalid/encoding/utf16.toml 0000664 0000000 0000000 00000000052 14777226410 017704 0 ustar # U T F - 1 6 w i t h o u t B O M
work/TOML-Tiny/t/toml-test/invalid/float/ 0000775 0000000 0000000 00000000000 14777226410 015364 5 ustar work/TOML-Tiny/t/toml-test/invalid/float/double-point-1.t 0000664 0000000 0000000 00000000657 14777226410 020320 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/double-point-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/double-point-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/double-point-1.toml 0000664 0000000 0000000 00000000026 14777226410 021016 0 ustar double-point-1 = 0..1
work/TOML-Tiny/t/toml-test/invalid/float/double-point-2.t 0000664 0000000 0000000 00000000657 14777226410 020321 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/double-point-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/double-point-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/double-point-2.toml 0000664 0000000 0000000 00000000027 14777226410 021020 0 ustar double-point-2 = 0.1.2
work/TOML-Tiny/t/toml-test/invalid/float/exp-double-e-1.t 0000664 0000000 0000000 00000000657 14777226410 020205 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/exp-double-e-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/exp-double-e-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/exp-double-e-1.toml 0000664 0000000 0000000 00000000026 14777226410 020703 0 ustar exp-double-e-1 = 1ee2
work/TOML-Tiny/t/toml-test/invalid/float/exp-double-e-2.t 0000664 0000000 0000000 00000000657 14777226410 020206 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/exp-double-e-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/exp-double-e-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/exp-double-e-2.toml 0000664 0000000 0000000 00000000027 14777226410 020705 0 ustar exp-double-e-2 = 1e2e3
work/TOML-Tiny/t/toml-test/invalid/float/exp-double-us.t 0000664 0000000 0000000 00000000655 14777226410 020250 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/exp-double-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/exp-double-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/exp-double-us.toml 0000664 0000000 0000000 00000000027 14777226410 020751 0 ustar exp-double-us = 1e__23
work/TOML-Tiny/t/toml-test/invalid/float/exp-leading-us.t 0000664 0000000 0000000 00000000657 14777226410 020403 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/exp-leading-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/exp-leading-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/exp-leading-us.toml 0000664 0000000 0000000 00000000027 14777226410 021102 0 ustar exp-leading-us = 1e_23
work/TOML-Tiny/t/toml-test/invalid/float/exp-point-1.t 0000664 0000000 0000000 00000000651 14777226410 017634 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/exp-point-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/exp-point-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/exp-point-1.toml 0000664 0000000 0000000 00000000024 14777226410 020336 0 ustar exp-point-1 = 1e2.3
work/TOML-Tiny/t/toml-test/invalid/float/exp-point-2.t 0000664 0000000 0000000 00000000651 14777226410 017635 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/exp-point-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/exp-point-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/exp-point-2.toml 0000664 0000000 0000000 00000000023 14777226410 020336 0 ustar exp-point-2 = 1.e2
work/TOML-Tiny/t/toml-test/invalid/float/exp-trailing-us.t 0000664 0000000 0000000 00000000661 14777226410 020604 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/exp-trailing-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/exp-trailing-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/exp-trailing-us.toml 0000664 0000000 0000000 00000000031 14777226410 021303 0 ustar exp-trailing-us = 1e_23_
work/TOML-Tiny/t/toml-test/invalid/float/inf-incomplete-1.t 0000664 0000000 0000000 00000000663 14777226410 020625 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/inf-incomplete-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/inf-incomplete-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/inf-incomplete-1.toml 0000664 0000000 0000000 00000000026 14777226410 021326 0 ustar inf-incomplete-1 = in
work/TOML-Tiny/t/toml-test/invalid/float/inf-incomplete-2.t 0000664 0000000 0000000 00000000663 14777226410 020626 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/inf-incomplete-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/inf-incomplete-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/inf-incomplete-2.toml 0000664 0000000 0000000 00000000027 14777226410 021330 0 ustar inf-incomplete-2 = +in
work/TOML-Tiny/t/toml-test/invalid/float/inf-incomplete-3.t 0000664 0000000 0000000 00000000663 14777226410 020627 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/inf-incomplete-3.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/inf-incomplete-3';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/inf-incomplete-3.toml 0000664 0000000 0000000 00000000027 14777226410 021331 0 ustar inf-incomplete-3 = -in
work/TOML-Tiny/t/toml-test/invalid/float/inf_underscore.t 0000664 0000000 0000000 00000000657 14777226410 020566 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/inf_underscore.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/inf_underscore';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/inf_underscore.toml 0000664 0000000 0000000 00000000026 14777226410 021264 0 ustar inf_underscore = in_f
work/TOML-Tiny/t/toml-test/invalid/float/leading-point-neg.t 0000664 0000000 0000000 00000000665 14777226410 021061 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/leading-point-neg.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/leading-point-neg';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/leading-point-neg.toml 0000664 0000000 0000000 00000000034 14777226410 021557 0 ustar leading-point-neg = -.12345
work/TOML-Tiny/t/toml-test/invalid/float/leading-point-plus.t 0000664 0000000 0000000 00000000667 14777226410 021275 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/leading-point-plus.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/leading-point-plus';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/leading-point-plus.toml 0000664 0000000 0000000 00000000035 14777226410 021772 0 ustar leading-point-plus = +.12345
work/TOML-Tiny/t/toml-test/invalid/float/leading-point.t 0000664 0000000 0000000 00000000655 14777226410 020311 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/leading-point.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/leading-point';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/leading-point.toml 0000664 0000000 0000000 00000000027 14777226410 021012 0 ustar leading-point = .12345
work/TOML-Tiny/t/toml-test/invalid/float/leading-us.t 0000664 0000000 0000000 00000000647 14777226410 017610 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/leading-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/leading-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/leading-us.toml 0000664 0000000 0000000 00000000022 14777226410 020303 0 ustar leading-us = _1.2
work/TOML-Tiny/t/toml-test/invalid/float/leading-zero-neg.t 0000664 0000000 0000000 00000000663 14777226410 020705 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/leading-zero-neg.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/leading-zero-neg';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/leading-zero-neg.toml 0000664 0000000 0000000 00000000032 14777226410 021403 0 ustar leading-zero-neg = -03.14
work/TOML-Tiny/t/toml-test/invalid/float/leading-zero-plus.t 0000664 0000000 0000000 00000000665 14777226410 021121 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/leading-zero-plus.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/leading-zero-plus';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/leading-zero-plus.toml 0000664 0000000 0000000 00000000033 14777226410 021616 0 ustar leading-zero-plus = +03.14
work/TOML-Tiny/t/toml-test/invalid/float/leading-zero.t 0000664 0000000 0000000 00000000653 14777226410 020135 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/leading-zero.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/leading-zero';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/leading-zero.toml 0000664 0000000 0000000 00000000025 14777226410 020636 0 ustar leading-zero = 03.14
work/TOML-Tiny/t/toml-test/invalid/float/nan-incomplete-1.t 0000664 0000000 0000000 00000000663 14777226410 020625 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/nan-incomplete-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/nan-incomplete-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/nan-incomplete-1.toml 0000664 0000000 0000000 00000000026 14777226410 021326 0 ustar nan-incomplete-1 = na
work/TOML-Tiny/t/toml-test/invalid/float/nan-incomplete-2.t 0000664 0000000 0000000 00000000663 14777226410 020626 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/nan-incomplete-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/nan-incomplete-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/nan-incomplete-2.toml 0000664 0000000 0000000 00000000027 14777226410 021330 0 ustar nan-incomplete-2 = +na
work/TOML-Tiny/t/toml-test/invalid/float/nan-incomplete-3.t 0000664 0000000 0000000 00000000663 14777226410 020627 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/nan-incomplete-3.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/nan-incomplete-3';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/nan-incomplete-3.toml 0000664 0000000 0000000 00000000027 14777226410 021331 0 ustar nan-incomplete-3 = -na
work/TOML-Tiny/t/toml-test/invalid/float/nan_underscore.t 0000664 0000000 0000000 00000000657 14777226410 020566 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/nan_underscore.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/nan_underscore';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/nan_underscore.toml 0000664 0000000 0000000 00000000026 14777226410 021264 0 ustar nan_underscore = na_n
work/TOML-Tiny/t/toml-test/invalid/float/trailing-point-min.t 0000664 0000000 0000000 00000000667 14777226410 021303 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/trailing-point-min.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/trailing-point-min';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/trailing-point-min.toml 0000664 0000000 0000000 00000000031 14777226410 021774 0 ustar trailing-point-min = -1.
work/TOML-Tiny/t/toml-test/invalid/float/trailing-point-plus.t 0000664 0000000 0000000 00000000671 14777226410 021476 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/trailing-point-plus.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/trailing-point-plus';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/trailing-point-plus.toml 0000664 0000000 0000000 00000000032 14777226410 022175 0 ustar trailing-point-plus = +1.
work/TOML-Tiny/t/toml-test/invalid/float/trailing-point.t 0000664 0000000 0000000 00000000657 14777226410 020521 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/trailing-point.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/trailing-point';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/trailing-point.toml 0000664 0000000 0000000 00000000024 14777226410 021215 0 ustar trailing-point = 1.
work/TOML-Tiny/t/toml-test/invalid/float/trailing-us.t 0000664 0000000 0000000 00000000651 14777226410 020011 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/trailing-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/trailing-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/trailing-us.toml 0000664 0000000 0000000 00000000023 14777226410 020512 0 ustar trailing-us = 1.2_
work/TOML-Tiny/t/toml-test/invalid/float/us-after-point.t 0000664 0000000 0000000 00000000657 14777226410 020436 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/us-after-point.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/us-after-point';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/us-after-point.toml 0000664 0000000 0000000 00000000026 14777226410 021134 0 ustar us-after-point = 1._2
work/TOML-Tiny/t/toml-test/invalid/float/us-before-point.t 0000664 0000000 0000000 00000000661 14777226410 020572 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/float/us-before-point.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on float/us-before-point';
done_testing; work/TOML-Tiny/t/toml-test/invalid/float/us-before-point.toml 0000664 0000000 0000000 00000000027 14777226410 021276 0 ustar us-before-point = 1_.2
work/TOML-Tiny/t/toml-test/invalid/inline-table/ 0000775 0000000 0000000 00000000000 14777226410 016622 5 ustar work/TOML-Tiny/t/toml-test/invalid/inline-table/double-comma.t 0000664 0000000 0000000 00000000671 14777226410 021357 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/inline-table/double-comma.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on inline-table/double-comma';
done_testing; work/TOML-Tiny/t/toml-test/invalid/inline-table/double-comma.toml 0000664 0000000 0000000 00000000017 14777226410 022061 0 ustar t = {x=3,,y=4}
work/TOML-Tiny/t/toml-test/invalid/inline-table/empty.t 0000664 0000000 0000000 00000000653 14777226410 020151 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/inline-table/empty.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on inline-table/empty';
done_testing; work/TOML-Tiny/t/toml-test/invalid/inline-table/empty.toml 0000664 0000000 0000000 00000000010 14777226410 020644 0 ustar t = {,}
work/TOML-Tiny/t/toml-test/invalid/inline-table/linebreak-1.t 0000664 0000000 0000000 00000000667 14777226410 021112 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/inline-table/linebreak-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on inline-table/linebreak-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/inline-table/linebreak-1.toml 0000664 0000000 0000000 00000000157 14777226410 021614 0 ustar # No newlines are allowed between the curly braces unless they are valid within
# a value.
simple = { a = 1
}
work/TOML-Tiny/t/toml-test/invalid/inline-table/linebreak-2.t 0000664 0000000 0000000 00000000667 14777226410 021113 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/inline-table/linebreak-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on inline-table/linebreak-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/inline-table/linebreak-2.toml 0000664 0000000 0000000 00000000017 14777226410 021610 0 ustar t = {a=1,
b=2}
work/TOML-Tiny/t/toml-test/invalid/inline-table/linebreak-3.t 0000664 0000000 0000000 00000000667 14777226410 021114 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/inline-table/linebreak-3.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on inline-table/linebreak-3';
done_testing; work/TOML-Tiny/t/toml-test/invalid/inline-table/linebreak-3.toml 0000664 0000000 0000000 00000000017 14777226410 021611 0 ustar t = {a=1
,b=2}
work/TOML-Tiny/t/toml-test/invalid/inline-table/linebreak-4.t 0000664 0000000 0000000 00000000667 14777226410 021115 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/inline-table/linebreak-4.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on inline-table/linebreak-4';
done_testing; work/TOML-Tiny/t/toml-test/invalid/inline-table/linebreak-4.toml 0000664 0000000 0000000 00000000113 14777226410 021607 0 ustar json_like = {
first = "Tom",
last = "Preston-Werner"
}
work/TOML-Tiny/t/toml-test/invalid/inline-table/no-comma.t 0000664 0000000 0000000 00000000661 14777226410 020520 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/inline-table/no-comma.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on inline-table/no-comma';
done_testing; work/TOML-Tiny/t/toml-test/invalid/inline-table/no-comma.toml 0000664 0000000 0000000 00000000022 14777226410 021217 0 ustar t = {x = 3 y = 4}
work/TOML-Tiny/t/toml-test/invalid/inline-table/trailing-comma.t 0000664 0000000 0000000 00000000675 14777226410 021722 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/inline-table/trailing-comma.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on inline-table/trailing-comma';
done_testing; work/TOML-Tiny/t/toml-test/invalid/inline-table/trailing-comma.toml 0000664 0000000 0000000 00000000214 14777226410 022417 0 ustar # A terminating comma (also called trailing comma) is not permitted after the
# last key/value pair in an inline table
abc = { abc = 123, }
work/TOML-Tiny/t/toml-test/invalid/integer/ 0000775 0000000 0000000 00000000000 14777226410 015714 5 ustar work/TOML-Tiny/t/toml-test/invalid/integer/capital-bin.t 0000664 0000000 0000000 00000000655 14777226410 020272 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/capital-bin.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/capital-bin';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/capital-bin.toml 0000664 0000000 0000000 00000000022 14777226410 020766 0 ustar capital-bin = 0B0
work/TOML-Tiny/t/toml-test/invalid/integer/capital-hex.t 0000664 0000000 0000000 00000000655 14777226410 020306 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/capital-hex.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/capital-hex';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/capital-hex.toml 0000664 0000000 0000000 00000000022 14777226410 021002 0 ustar capital-hex = 0X1
work/TOML-Tiny/t/toml-test/invalid/integer/capital-oct.t 0000664 0000000 0000000 00000000655 14777226410 020307 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/capital-oct.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/capital-oct';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/capital-oct.toml 0000664 0000000 0000000 00000000022 14777226410 021003 0 ustar capital-oct = 0O0
work/TOML-Tiny/t/toml-test/invalid/integer/double-sign-nex.t 0000664 0000000 0000000 00000000665 14777226410 021110 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/double-sign-nex.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/double-sign-nex';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/double-sign-nex.toml 0000664 0000000 0000000 00000000027 14777226410 021610 0 ustar double-sign-nex = --99
work/TOML-Tiny/t/toml-test/invalid/integer/double-sign-plus.t 0000664 0000000 0000000 00000000667 14777226410 021303 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/double-sign-plus.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/double-sign-plus';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/double-sign-plus.toml 0000664 0000000 0000000 00000000030 14777226410 021773 0 ustar double-sign-plus = ++99
work/TOML-Tiny/t/toml-test/invalid/integer/double-us.t 0000664 0000000 0000000 00000000651 14777226410 020002 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/double-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/double-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/double-us.toml 0000664 0000000 0000000 00000000022 14777226410 020502 0 ustar double-us = 1__23
work/TOML-Tiny/t/toml-test/invalid/integer/invalid-bin.t 0000664 0000000 0000000 00000000655 14777226410 020303 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/invalid-bin.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/invalid-bin';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/invalid-bin.toml 0000664 0000000 0000000 00000000025 14777226410 021002 0 ustar invalid-bin = 0b0012
work/TOML-Tiny/t/toml-test/invalid/integer/invalid-hex.t 0000664 0000000 0000000 00000000655 14777226410 020317 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/invalid-hex.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/invalid-hex';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/invalid-hex.toml 0000664 0000000 0000000 00000000025 14777226410 021016 0 ustar invalid-hex = 0xaafz
work/TOML-Tiny/t/toml-test/invalid/integer/invalid-oct.t 0000664 0000000 0000000 00000000655 14777226410 020320 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/invalid-oct.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/invalid-oct';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/invalid-oct.toml 0000664 0000000 0000000 00000000024 14777226410 021016 0 ustar invalid-oct = 0o778
work/TOML-Tiny/t/toml-test/invalid/integer/leading-us-bin.t 0000664 0000000 0000000 00000000663 14777226410 020704 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/leading-us-bin.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/leading-us-bin';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/leading-us-bin.toml 0000664 0000000 0000000 00000000026 14777226410 021405 0 ustar leading-us-bin = _0o1
work/TOML-Tiny/t/toml-test/invalid/integer/leading-us-hex.t 0000664 0000000 0000000 00000000663 14777226410 020720 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/leading-us-hex.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/leading-us-hex';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/leading-us-hex.toml 0000664 0000000 0000000 00000000026 14777226410 021421 0 ustar leading-us-hex = _0o1
work/TOML-Tiny/t/toml-test/invalid/integer/leading-us-oct.t 0000664 0000000 0000000 00000000663 14777226410 020721 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/leading-us-oct.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/leading-us-oct';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/leading-us-oct.toml 0000664 0000000 0000000 00000000026 14777226410 021422 0 ustar leading-us-oct = _0o1
work/TOML-Tiny/t/toml-test/invalid/integer/leading-us.t 0000664 0000000 0000000 00000000653 14777226410 020135 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/leading-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/leading-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/leading-us.toml 0000664 0000000 0000000 00000000022 14777226410 020633 0 ustar leading-us = _123
work/TOML-Tiny/t/toml-test/invalid/integer/leading-zero-1.t 0000664 0000000 0000000 00000000663 14777226410 020624 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/leading-zero-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/leading-zero-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/leading-zero-1.toml 0000664 0000000 0000000 00000000024 14777226410 021323 0 ustar leading-zero-1 = 01
work/TOML-Tiny/t/toml-test/invalid/integer/leading-zero-2.t 0000664 0000000 0000000 00000000663 14777226410 020625 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/leading-zero-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/leading-zero-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/leading-zero-2.toml 0000664 0000000 0000000 00000000024 14777226410 021324 0 ustar leading-zero-2 = 00
work/TOML-Tiny/t/toml-test/invalid/integer/leading-zero-sign-1.t 0000664 0000000 0000000 00000000675 14777226410 021565 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/leading-zero-sign-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/leading-zero-sign-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/leading-zero-sign-1.toml 0000664 0000000 0000000 00000000032 14777226410 022260 0 ustar leading-zero-sign-1 = -01
work/TOML-Tiny/t/toml-test/invalid/integer/leading-zero-sign-2.t 0000664 0000000 0000000 00000000675 14777226410 021566 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/leading-zero-sign-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/leading-zero-sign-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/leading-zero-sign-2.toml 0000664 0000000 0000000 00000000032 14777226410 022261 0 ustar leading-zero-sign-2 = +01
work/TOML-Tiny/t/toml-test/invalid/integer/negative-bin.t 0000664 0000000 0000000 00000000657 14777226410 020461 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/negative-bin.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/negative-bin';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/negative-bin.toml 0000664 0000000 0000000 00000000033 14777226410 021155 0 ustar negative-bin = -0b11010110
work/TOML-Tiny/t/toml-test/invalid/integer/negative-hex.t 0000664 0000000 0000000 00000000657 14777226410 020475 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/negative-hex.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/negative-hex';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/negative-hex.toml 0000664 0000000 0000000 00000000025 14777226410 021172 0 ustar negative-hex = -0xff
work/TOML-Tiny/t/toml-test/invalid/integer/negative-oct.t 0000664 0000000 0000000 00000000657 14777226410 020476 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/negative-oct.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/negative-oct';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/negative-oct.toml 0000664 0000000 0000000 00000000025 14777226410 021173 0 ustar negative-oct = -0o99
work/TOML-Tiny/t/toml-test/invalid/integer/positive-bin.t 0000664 0000000 0000000 00000000657 14777226410 020521 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/positive-bin.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/positive-bin';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/positive-bin.toml 0000664 0000000 0000000 00000000033 14777226410 021215 0 ustar positive-bin = +0b11010110
work/TOML-Tiny/t/toml-test/invalid/integer/positive-hex.t 0000664 0000000 0000000 00000000657 14777226410 020535 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/positive-hex.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/positive-hex';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/positive-hex.toml 0000664 0000000 0000000 00000000025 14777226410 021232 0 ustar positive-hex = +0xff
work/TOML-Tiny/t/toml-test/invalid/integer/positive-oct.t 0000664 0000000 0000000 00000000657 14777226410 020536 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/positive-oct.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/positive-oct';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/positive-oct.toml 0000664 0000000 0000000 00000000025 14777226410 021233 0 ustar positive-oct = +0o99
work/TOML-Tiny/t/toml-test/invalid/integer/text-after-integer.t 0000664 0000000 0000000 00000000673 14777226410 021625 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/text-after-integer.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/text-after-integer';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/text-after-integer.toml 0000664 0000000 0000000 00000000041 14777226410 022322 0 ustar answer = 42 the ultimate answer?
work/TOML-Tiny/t/toml-test/invalid/integer/trailing-us-bin.t 0000664 0000000 0000000 00000000665 14777226410 021114 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/trailing-us-bin.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/trailing-us-bin';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/trailing-us-bin.toml 0000664 0000000 0000000 00000000027 14777226410 021614 0 ustar trailing-us-bin = 0b1_
work/TOML-Tiny/t/toml-test/invalid/integer/trailing-us-hex.t 0000664 0000000 0000000 00000000665 14777226410 021130 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/trailing-us-hex.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/trailing-us-hex';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/trailing-us-hex.toml 0000664 0000000 0000000 00000000027 14777226410 021630 0 ustar trailing-us-hex = 0x1_
work/TOML-Tiny/t/toml-test/invalid/integer/trailing-us-oct.t 0000664 0000000 0000000 00000000665 14777226410 021131 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/trailing-us-oct.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/trailing-us-oct';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/trailing-us-oct.toml 0000664 0000000 0000000 00000000027 14777226410 021631 0 ustar trailing-us-oct = 0o1_
work/TOML-Tiny/t/toml-test/invalid/integer/trailing-us.t 0000664 0000000 0000000 00000000655 14777226410 020345 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/trailing-us.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/trailing-us';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/trailing-us.toml 0000664 0000000 0000000 00000000023 14777226410 021042 0 ustar trailing-us = 123_
work/TOML-Tiny/t/toml-test/invalid/integer/us-after-bin.t 0000664 0000000 0000000 00000000657 14777226410 020405 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/us-after-bin.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/us-after-bin';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/us-after-bin.toml 0000664 0000000 0000000 00000000024 14777226410 021101 0 ustar us-after-bin = 0b_1
work/TOML-Tiny/t/toml-test/invalid/integer/us-after-hex.t 0000664 0000000 0000000 00000000657 14777226410 020421 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/us-after-hex.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/us-after-hex';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/us-after-hex.toml 0000664 0000000 0000000 00000000024 14777226410 021115 0 ustar us-after-hex = 0x_1
work/TOML-Tiny/t/toml-test/invalid/integer/us-after-oct.t 0000664 0000000 0000000 00000000657 14777226410 020422 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/integer/us-after-oct.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on integer/us-after-oct';
done_testing; work/TOML-Tiny/t/toml-test/invalid/integer/us-after-oct.toml 0000664 0000000 0000000 00000000024 14777226410 021116 0 ustar us-after-oct = 0o_1
work/TOML-Tiny/t/toml-test/invalid/key/ 0000775 0000000 0000000 00000000000 14777226410 015047 5 ustar work/TOML-Tiny/t/toml-test/invalid/key/after-array.t 0000664 0000000 0000000 00000000645 14777226410 017456 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/after-array.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/after-array';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/after-array.toml 0000664 0000000 0000000 00000000040 14777226410 020153 0 ustar [[agencies]] owner = "S Cjelli"
work/TOML-Tiny/t/toml-test/invalid/key/after-table.t 0000664 0000000 0000000 00000000645 14777226410 017427 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/after-table.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/after-table';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/after-table.toml 0000664 0000000 0000000 00000000044 14777226410 020130 0 ustar [error] this = "should not be here"
work/TOML-Tiny/t/toml-test/invalid/key/after-value.t 0000664 0000000 0000000 00000000645 14777226410 017454 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/after-value.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/after-value';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/after-value.toml 0000664 0000000 0000000 00000000060 14777226410 020153 0 ustar first = "Tom" last = "Preston-Werner" # INVALID
work/TOML-Tiny/t/toml-test/invalid/key/bare-invalid-character.t 0000664 0000000 0000000 00000000673 14777226410 021531 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/bare-invalid-character.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/bare-invalid-character';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/bare-invalid-character.toml 0000664 0000000 0000000 00000000017 14777226410 022231 0 ustar bare!key = 123
work/TOML-Tiny/t/toml-test/invalid/key/dotted-redefine-table.t 0000664 0000000 0000000 00000000671 14777226410 021367 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/dotted-redefine-table.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/dotted-redefine-table';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/dotted-redefine-table.toml 0000664 0000000 0000000 00000000114 14777226410 022067 0 ustar # Defined a.b as int
a.b = 1
# Tries to access it as table: error
a.b.c = 2
work/TOML-Tiny/t/toml-test/invalid/key/duplicate-keys.t 0000664 0000000 0000000 00000000653 14777226410 020163 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/duplicate-keys.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/duplicate-keys';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/duplicate-keys.toml 0000664 0000000 0000000 00000000031 14777226410 020661 0 ustar dupe = false
dupe = true
work/TOML-Tiny/t/toml-test/invalid/key/duplicate.t 0000664 0000000 0000000 00000000641 14777226410 017207 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/duplicate.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/duplicate';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/duplicate.toml 0000664 0000000 0000000 00000000057 14777226410 017720 0 ustar # DO NOT DO THIS
name = "Tom"
name = "Pradyun"
work/TOML-Tiny/t/toml-test/invalid/key/empty.t 0000664 0000000 0000000 00000000631 14777226410 016372 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/empty.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/empty';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/empty.toml 0000664 0000000 0000000 00000000005 14777226410 017075 0 ustar = 1
work/TOML-Tiny/t/toml-test/invalid/key/escape.t 0000664 0000000 0000000 00000000633 14777226410 016476 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/escape.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/escape';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/escape.toml 0000664 0000000 0000000 00000000055 14777226410 017204 0 ustar \u00c0 = "latin capital letter A with grave"
work/TOML-Tiny/t/toml-test/invalid/key/hash.t 0000664 0000000 0000000 00000000627 14777226410 016164 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/hash.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/hash';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/hash.toml 0000664 0000000 0000000 00000000007 14777226410 016664 0 ustar a# = 1
work/TOML-Tiny/t/toml-test/invalid/key/multiline.t 0000664 0000000 0000000 00000000641 14777226410 017237 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/multiline.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/multiline';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/multiline.toml 0000664 0000000 0000000 00000000023 14777226410 017741 0 ustar """long
key""" = 1
work/TOML-Tiny/t/toml-test/invalid/key/newline.t 0000664 0000000 0000000 00000000635 14777226410 016701 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/newline.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/newline';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/newline.toml 0000664 0000000 0000000 00000000021 14777226410 017376 0 ustar barekey
= 123
work/TOML-Tiny/t/toml-test/invalid/key/no-eol.t 0000664 0000000 0000000 00000000633 14777226410 016427 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/no-eol.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/no-eol';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/no-eol.toml 0000664 0000000 0000000 00000000014 14777226410 017130 0 ustar a = 1 b = 2
work/TOML-Tiny/t/toml-test/invalid/key/open-bracket.t 0000664 0000000 0000000 00000000647 14777226410 017615 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/open-bracket.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/open-bracket';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/open-bracket.toml 0000664 0000000 0000000 00000000011 14777226410 020306 0 ustar [abc = 1
work/TOML-Tiny/t/toml-test/invalid/key/partial-quoted.t 0000664 0000000 0000000 00000000653 14777226410 020173 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/partial-quoted.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/partial-quoted';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/partial-quoted.toml 0000664 0000000 0000000 00000000024 14777226410 020673 0 ustar partial"quoted" = 5
work/TOML-Tiny/t/toml-test/invalid/key/single-open-bracket.t 0000664 0000000 0000000 00000000665 14777226410 021074 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/single-open-bracket.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/single-open-bracket';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/single-open-bracket.toml 0000664 0000000 0000000 00000000002 14777226410 021565 0 ustar [
work/TOML-Tiny/t/toml-test/invalid/key/space.t 0000664 0000000 0000000 00000000631 14777226410 016327 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/space.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/space';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/space.toml 0000664 0000000 0000000 00000000010 14777226410 017026 0 ustar a b = 1
work/TOML-Tiny/t/toml-test/invalid/key/special-character.t 0000664 0000000 0000000 00000000661 14777226410 020611 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/special-character.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/special-character';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/special-character.toml 0000664 0000000 0000000 00000000035 14777226410 021314 0 ustar μ = "greek small letter mu"
work/TOML-Tiny/t/toml-test/invalid/key/start-bracket.t 0000664 0000000 0000000 00000000651 14777226410 020004 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/start-bracket.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/start-bracket';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/start-bracket.toml 0000664 0000000 0000000 00000000021 14777226410 020503 0 ustar [a]
[xyz = 5
[b]
work/TOML-Tiny/t/toml-test/invalid/key/two-equals.t 0000664 0000000 0000000 00000000643 14777226410 017340 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/two-equals.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/two-equals';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/two-equals.toml 0000664 0000000 0000000 00000000011 14777226410 020035 0 ustar key= = 1
work/TOML-Tiny/t/toml-test/invalid/key/two-equals2.t 0000664 0000000 0000000 00000000645 14777226410 017424 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/two-equals2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/two-equals2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/two-equals2.toml 0000664 0000000 0000000 00000000005 14777226410 020122 0 ustar a==1
work/TOML-Tiny/t/toml-test/invalid/key/two-equals3.t 0000664 0000000 0000000 00000000645 14777226410 017425 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/two-equals3.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/two-equals3';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/two-equals3.toml 0000664 0000000 0000000 00000000006 14777226410 020124 0 ustar a=b=1
work/TOML-Tiny/t/toml-test/invalid/key/without-value-1.t 0000664 0000000 0000000 00000000655 14777226410 020215 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/without-value-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/without-value-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/without-value-1.toml 0000664 0000000 0000000 00000000004 14777226410 020711 0 ustar key
work/TOML-Tiny/t/toml-test/invalid/key/without-value-2.t 0000664 0000000 0000000 00000000655 14777226410 020216 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/key/without-value-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on key/without-value-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/key/without-value-2.toml 0000664 0000000 0000000 00000000007 14777226410 020715 0 ustar key =
work/TOML-Tiny/t/toml-test/invalid/string/ 0000775 0000000 0000000 00000000000 14777226410 015565 5 ustar work/TOML-Tiny/t/toml-test/invalid/string/bad-byte-escape.t 0000664 0000000 0000000 00000000663 14777226410 020704 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/bad-byte-escape.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/bad-byte-escape';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/bad-byte-escape.toml 0000664 0000000 0000000 00000000021 14777226410 021400 0 ustar naughty = "\xAg"
work/TOML-Tiny/t/toml-test/invalid/string/bad-codepoint.t 0000664 0000000 0000000 00000000657 14777226410 020472 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/bad-codepoint.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/bad-codepoint';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/bad-codepoint.toml 0000664 0000000 0000000 00000000121 14777226410 021164 0 ustar invalid-codepoint = "This string contains a non scalar unicode codepoint \uD801"
work/TOML-Tiny/t/toml-test/invalid/string/bad-concat.t 0000664 0000000 0000000 00000000651 14777226410 017747 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/bad-concat.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/bad-concat';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/bad-concat.toml 0000664 0000000 0000000 00000000035 14777226410 020453 0 ustar no_concat = "first" "second"
work/TOML-Tiny/t/toml-test/invalid/string/bad-escape.t 0000664 0000000 0000000 00000000651 14777226410 017740 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/bad-escape.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/bad-escape';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/bad-escape.toml 0000664 0000000 0000000 00000000076 14777226410 020451 0 ustar invalid-escape = "This string has a bad \a escape character."
work/TOML-Tiny/t/toml-test/invalid/string/bad-multiline.t 0000664 0000000 0000000 00000000657 14777226410 020510 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/bad-multiline.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/bad-multiline';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/bad-multiline.toml 0000664 0000000 0000000 00000000041 14777226410 021203 0 ustar multi = "first line
second line"
work/TOML-Tiny/t/toml-test/invalid/string/bad-slash-escape.t 0000664 0000000 0000000 00000000665 14777226410 021055 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/bad-slash-escape.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/bad-slash-escape';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/bad-slash-escape.toml 0000664 0000000 0000000 00000000076 14777226410 021561 0 ustar invalid-escape = "This string has a bad \/ escape character."
work/TOML-Tiny/t/toml-test/invalid/string/bad-uni-esc.t 0000664 0000000 0000000 00000000653 14777226410 020045 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/bad-uni-esc.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/bad-uni-esc';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/bad-uni-esc.toml 0000664 0000000 0000000 00000000017 14777226410 020547 0 ustar str = "val\ue"
work/TOML-Tiny/t/toml-test/invalid/string/basic-byte-escapes.t 0000664 0000000 0000000 00000000671 14777226410 021421 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/basic-byte-escapes.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/basic-byte-escapes';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/basic-byte-escapes.toml 0000664 0000000 0000000 00000000020 14777226410 022115 0 ustar answer = "\x33"
work/TOML-Tiny/t/toml-test/invalid/string/basic-multiline-out-of-range-unicode-escape-1.t 0000664 0000000 0000000 00000000757 14777226410 026365 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/basic-multiline-out-of-range-unicode-escape-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/basic-multiline-out-of-range-unicode-escape-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/basic-multiline-out-of-range-unicode-escape-1.toml 0000664 0000000 0000000 00000000025 14777226410 027061 0 ustar a = """\UFFFFFFFF"""
work/TOML-Tiny/t/toml-test/invalid/string/basic-multiline-out-of-range-unicode-escape-2.t 0000664 0000000 0000000 00000000757 14777226410 026366 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/basic-multiline-out-of-range-unicode-escape-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/basic-multiline-out-of-range-unicode-escape-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/basic-multiline-out-of-range-unicode-escape-2.toml 0000664 0000000 0000000 00000000025 14777226410 027062 0 ustar a = """\U00D80000"""
work/TOML-Tiny/t/toml-test/invalid/string/basic-multiline-quotes.t 0000664 0000000 0000000 00000000701 14777226410 022347 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/basic-multiline-quotes.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/basic-multiline-quotes';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/basic-multiline-quotes.toml 0000664 0000000 0000000 00000000062 14777226410 023057 0 ustar str5 = """Here are three quotation marks: """."""
work/TOML-Tiny/t/toml-test/invalid/string/basic-multiline-unknown-escape.t 0000664 0000000 0000000 00000000721 14777226410 023766 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/basic-multiline-unknown-escape.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/basic-multiline-unknown-escape';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/basic-multiline-unknown-escape.toml 0000664 0000000 0000000 00000000015 14777226410 024472 0 ustar a = """\@"""
work/TOML-Tiny/t/toml-test/invalid/string/basic-out-of-range-unicode-escape-1.t 0000664 0000000 0000000 00000000733 14777226410 024357 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/basic-out-of-range-unicode-escape-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/basic-out-of-range-unicode-escape-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/basic-out-of-range-unicode-escape-1.toml 0000664 0000000 0000000 00000000021 14777226410 025055 0 ustar a = "\UFFFFFFFF"
work/TOML-Tiny/t/toml-test/invalid/string/basic-out-of-range-unicode-escape-2.t 0000664 0000000 0000000 00000000733 14777226410 024360 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/basic-out-of-range-unicode-escape-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/basic-out-of-range-unicode-escape-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/basic-out-of-range-unicode-escape-2.toml 0000664 0000000 0000000 00000000021 14777226410 025056 0 ustar a = "\U00D80000"
work/TOML-Tiny/t/toml-test/invalid/string/basic-unknown-escape.t 0000664 0000000 0000000 00000000675 14777226410 021776 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/basic-unknown-escape.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/basic-unknown-escape';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/basic-unknown-escape.toml 0000664 0000000 0000000 00000000011 14777226410 022466 0 ustar a = "\@"
work/TOML-Tiny/t/toml-test/invalid/string/literal-multiline-quotes-1.t 0000664 0000000 0000000 00000000711 14777226410 023061 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/literal-multiline-quotes-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/literal-multiline-quotes-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/literal-multiline-quotes-1.toml 0000664 0000000 0000000 00000000036 14777226410 023571 0 ustar a = '''6 apostrophes: ''''''
work/TOML-Tiny/t/toml-test/invalid/string/literal-multiline-quotes-2.t 0000664 0000000 0000000 00000000711 14777226410 023062 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/literal-multiline-quotes-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/literal-multiline-quotes-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/literal-multiline-quotes-2.toml 0000664 0000000 0000000 00000000052 14777226410 023570 0 ustar a = '''15 apostrophes: ''''''''''''''''''
work/TOML-Tiny/t/toml-test/invalid/string/missing-quotes.t 0000664 0000000 0000000 00000000661 14777226410 020744 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/missing-quotes.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/missing-quotes';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/missing-quotes.toml 0000664 0000000 0000000 00000000015 14777226410 021445 0 ustar name = value
work/TOML-Tiny/t/toml-test/invalid/string/multiline-escape-space.t 0000664 0000000 0000000 00000000701 14777226410 022301 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/multiline-escape-space.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/multiline-escape-space';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/multiline-escape-space.toml 0000664 0000000 0000000 00000000034 14777226410 023010 0 ustar a = """
foo \ \n
bar"""
work/TOML-Tiny/t/toml-test/invalid/string/multiline-no-close-2.t 0000664 0000000 0000000 00000000675 14777226410 021640 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/multiline-no-close-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/multiline-no-close-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/multiline-no-close-2.toml 0000664 0000000 0000000 00000000006 14777226410 022334 0 ustar x="""
work/TOML-Tiny/t/toml-test/invalid/string/multiline-no-close.t 0000664 0000000 0000000 00000000671 14777226410 021475 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/multiline-no-close.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/multiline-no-close';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/multiline-no-close.toml 0000664 0000000 0000000 00000000041 14777226410 022174 0 ustar invalid = """
this will fail
work/TOML-Tiny/t/toml-test/invalid/string/multiline-quotes-1.t 0000664 0000000 0000000 00000000671 14777226410 021434 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/multiline-quotes-1.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/multiline-quotes-1';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/multiline-quotes-1.toml 0000664 0000000 0000000 00000000030 14777226410 022131 0 ustar a = """6 quotes: """"""
work/TOML-Tiny/t/toml-test/invalid/string/multiline-quotes-2.t 0000664 0000000 0000000 00000000671 14777226410 021435 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/multiline-quotes-2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/multiline-quotes-2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/multiline-quotes-2.toml 0000664 0000000 0000000 00000000030 14777226410 022132 0 ustar a = """6 quotes: """"""
work/TOML-Tiny/t/toml-test/invalid/string/no-close.t 0000664 0000000 0000000 00000000645 14777226410 017476 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/no-close.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/no-close';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/no-close.toml 0000664 0000000 0000000 00000000052 14777226410 020176 0 ustar no-ending-quote = "One time, at band camp
work/TOML-Tiny/t/toml-test/invalid/string/text-after-string.t 0000664 0000000 0000000 00000000667 14777226410 021352 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/text-after-string.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/text-after-string';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/text-after-string.toml 0000664 0000000 0000000 00000000054 14777226410 022050 0 ustar string = "Is there life after strings?" No.
work/TOML-Tiny/t/toml-test/invalid/string/wrong-close.t 0000664 0000000 0000000 00000000653 14777226410 020215 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/string/wrong-close.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on string/wrong-close';
done_testing; work/TOML-Tiny/t/toml-test/invalid/string/wrong-close.toml 0000664 0000000 0000000 00000000047 14777226410 020722 0 ustar bad-ending-quote = "double and single'
work/TOML-Tiny/t/toml-test/invalid/table/ 0000775 0000000 0000000 00000000000 14777226410 015346 5 ustar work/TOML-Tiny/t/toml-test/invalid/table/array-empty.t 0000664 0000000 0000000 00000000651 14777226410 020007 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/array-empty.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/array-empty';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/array-empty.toml 0000664 0000000 0000000 00000000032 14777226410 020510 0 ustar [[]]
name = "Born to Run"
work/TOML-Tiny/t/toml-test/invalid/table/array-implicit.t 0000664 0000000 0000000 00000000657 14777226410 020471 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/array-implicit.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/array-implicit';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/array-implicit.toml 0000664 0000000 0000000 00000001156 14777226410 021174 0 ustar # This test is a bit tricky. It should fail because the first use of
# `[[albums.songs]]` without first declaring `albums` implies that `albums`
# must be a table. The alternative would be quite weird. Namely, it wouldn't
# comply with the TOML spec: "Each double-bracketed sub-table will belong to
# the most *recently* defined table element *above* it."
#
# This is in contrast to the *valid* test, table-array-implicit where
# `[[albums.songs]]` works by itself, so long as `[[albums]]` isn't declared
# later. (Although, `[albums]` could be.)
[[albums.songs]]
name = "Glory Days"
[[albums]]
name = "Born in the USA"
work/TOML-Tiny/t/toml-test/invalid/table/array-missing-bracket.t 0000664 0000000 0000000 00000000675 14777226410 021741 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/array-missing-bracket.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/array-missing-bracket';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/array-missing-bracket.toml 0000664 0000000 0000000 00000000037 14777226410 022441 0 ustar [[albums]
name = "Born to Run"
work/TOML-Tiny/t/toml-test/invalid/table/duplicate-key-table.t 0000664 0000000 0000000 00000000671 14777226410 021364 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/duplicate-key-table.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/duplicate-key-table';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/duplicate-key-table.toml 0000664 0000000 0000000 00000000063 14777226410 022067 0 ustar [fruit]
type = "apple"
[fruit.type]
apple = "yes"
work/TOML-Tiny/t/toml-test/invalid/table/duplicate-table-array.t 0000664 0000000 0000000 00000000675 14777226410 021716 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/duplicate-table-array.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/duplicate-table-array';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/duplicate-table-array.toml 0000664 0000000 0000000 00000000016 14777226410 022413 0 ustar [tbl]
[[tbl]]
work/TOML-Tiny/t/toml-test/invalid/table/duplicate-table-array2.t 0000664 0000000 0000000 00000000677 14777226410 022002 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/duplicate-table-array2.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/duplicate-table-array2';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/duplicate-table-array2.toml 0000664 0000000 0000000 00000000016 14777226410 022475 0 ustar [[tbl]]
[tbl]
work/TOML-Tiny/t/toml-test/invalid/table/duplicate.t 0000664 0000000 0000000 00000000645 14777226410 017512 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/duplicate.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/duplicate';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/duplicate.toml 0000664 0000000 0000000 00000000025 14777226410 020212 0 ustar [a]
b = 1
[a]
c = 2
work/TOML-Tiny/t/toml-test/invalid/table/empty-implicit-table.t 0000664 0000000 0000000 00000000673 14777226410 021574 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/empty-implicit-table.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/empty-implicit-table';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/empty-implicit-table.toml 0000664 0000000 0000000 00000000023 14777226410 022271 0 ustar [naughty..naughty]
work/TOML-Tiny/t/toml-test/invalid/table/empty.t 0000664 0000000 0000000 00000000635 14777226410 016675 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/empty.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/empty';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/empty.toml 0000664 0000000 0000000 00000000003 14777226410 017372 0 ustar []
work/TOML-Tiny/t/toml-test/invalid/table/equals-sign.t 0000664 0000000 0000000 00000000651 14777226410 017765 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/equals-sign.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/equals-sign';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/equals-sign.toml 0000664 0000000 0000000 00000000013 14777226410 020465 0 ustar [name=bad]
work/TOML-Tiny/t/toml-test/invalid/table/llbrace.t 0000664 0000000 0000000 00000000641 14777226410 017140 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/llbrace.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/llbrace';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/llbrace.toml 0000664 0000000 0000000 00000000013 14777226410 017641 0 ustar [ [table]]
work/TOML-Tiny/t/toml-test/invalid/table/nested-brackets-close.t 0000664 0000000 0000000 00000000675 14777226410 021724 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/nested-brackets-close.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/nested-brackets-close';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/nested-brackets-close.toml 0000664 0000000 0000000 00000000017 14777226410 022422 0 ustar [a]b]
zyx = 42
work/TOML-Tiny/t/toml-test/invalid/table/nested-brackets-open.t 0000664 0000000 0000000 00000000673 14777226410 021556 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/nested-brackets-open.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/nested-brackets-open';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/nested-brackets-open.toml 0000664 0000000 0000000 00000000017 14777226410 022256 0 ustar [a[b]
zyx = 42
work/TOML-Tiny/t/toml-test/invalid/table/quoted-no-close.t 0000664 0000000 0000000 00000000661 14777226410 020554 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/quoted-no-close.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/quoted-no-close';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/quoted-no-close.toml 0000664 0000000 0000000 00000000042 14777226410 021255 0 ustar ["where will it end]
name = value
work/TOML-Tiny/t/toml-test/invalid/table/redefine.t 0000664 0000000 0000000 00000000643 14777226410 017317 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/redefine.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/redefine';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/redefine.toml 0000664 0000000 0000000 00000000116 14777226410 020022 0 ustar # Define b as int, and try to use it as a table: error
[a]
b = 1
[a.b]
c = 2
work/TOML-Tiny/t/toml-test/invalid/table/rrbrace.t 0000664 0000000 0000000 00000000641 14777226410 017154 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/rrbrace.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/rrbrace';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/rrbrace.toml 0000664 0000000 0000000 00000000013 14777226410 017655 0 ustar [[table] ]
work/TOML-Tiny/t/toml-test/invalid/table/text-after-table.t 0000664 0000000 0000000 00000000663 14777226410 020710 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/text-after-table.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/text-after-table';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/text-after-table.toml 0000664 0000000 0000000 00000000037 14777226410 021413 0 ustar [error] this shouldn't be here
work/TOML-Tiny/t/toml-test/invalid/table/whitespace.t 0000664 0000000 0000000 00000000647 14777226410 017676 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/whitespace.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/whitespace';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/whitespace.toml 0000664 0000000 0000000 00000000016 14777226410 020374 0 ustar [invalid key]
work/TOML-Tiny/t/toml-test/invalid/table/with-pound.t 0000664 0000000 0000000 00000000647 14777226410 017640 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use TOML::Tiny;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/invalid/table/with-pound.toml" or die $!;
binmode $fh, ':raw';
my $toml = do{ local $/; <$fh>; };
close $fh;
ok dies(sub{ scalar from_toml($toml, strict => 1) }), 'strict_mode dies on table/with-pound';
done_testing; work/TOML-Tiny/t/toml-test/invalid/table/with-pound.toml 0000664 0000000 0000000 00000000030 14777226410 020332 0 ustar [key#group]
answer = 42
work/TOML-Tiny/t/toml-test/valid/ 0000775 0000000 0000000 00000000000 14777226410 013730 5 ustar work/TOML-Tiny/t/toml-test/valid/array/ 0000775 0000000 0000000 00000000000 14777226410 015046 5 ustar work/TOML-Tiny/t/toml-test/valid/array/array.t 0000664 0000000 0000000 00000026154 14777226410 016361 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/array.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"comments" => [
bless( {
"_file" => "(eval 116)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 117)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
],
"dates" => [
"1987-07-05T17:45:00Z",
"1979-05-27T07:32:00Z",
"2006-06-01T11:00:00Z"
],
"floats" => [
bless( {
"_file" => "(eval 118)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('1.1')->beq($got);
},
"name" => "Math::BigFloat->new(\"1.1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 119)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('2.1')->beq($got);
},
"name" => "Math::BigFloat->new(\"2.1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 120)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('3.1')->beq($got);
},
"name" => "Math::BigFloat->new(\"3.1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
],
"ints" => [
bless( {
"_file" => "(eval 48)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 114)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 115)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3')->beq($got);
},
"name" => "Math::BigInt->new(\"3\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
],
"strings" => [
"a",
"b",
"c"
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/array - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/array - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/array - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/array.toml 0000664 0000000 0000000 00000000315 14777226410 017060 0 ustar ints = [1, 2, 3, ]
floats = [1.1, 2.1, 3.1]
strings = ["a", "b", "c"]
dates = [
1987-07-05T17:45:00Z,
1979-05-27T07:32:00Z,
2006-06-01T11:00:00Z,
]
comments = [
1,
2, #this is ok
]
work/TOML-Tiny/t/toml-test/valid/array/bool.t 0000664 0000000 0000000 00000002466 14777226410 016176 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/bool.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => [
1,
0
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/bool - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/bool - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/bool - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/bool.toml 0000664 0000000 0000000 00000000022 14777226410 016670 0 ustar a = [true, false]
work/TOML-Tiny/t/toml-test/valid/array/empty.t 0000664 0000000 0000000 00000003004 14777226410 016366 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/empty.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"thevoid" => [
[
[
[
[]
]
]
]
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/empty - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/empty - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/empty - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/empty.toml 0000664 0000000 0000000 00000000025 14777226410 017076 0 ustar thevoid = [[[[[]]]]]
work/TOML-Tiny/t/toml-test/valid/array/hetergeneous.t 0000664 0000000 0000000 00000014466 14777226410 017743 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/hetergeneous.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"mixed" => [
[
bless( {
"_file" => "(eval 139)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 140)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
],
[
"a",
"b"
],
[
bless( {
"_file" => "(eval 141)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('1.1')->beq($got);
},
"name" => "Math::BigFloat->new(\"1.1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 142)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('2.1')->beq($got);
},
"name" => "Math::BigFloat->new(\"2.1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
]
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/hetergeneous - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/hetergeneous - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/hetergeneous - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/hetergeneous.toml 0000664 0000000 0000000 00000000051 14777226410 020434 0 ustar mixed = [[1, 2], ["a", "b"], [1.1, 2.1]]
work/TOML-Tiny/t/toml-test/valid/array/mixed-int-array.t 0000664 0000000 0000000 00000005443 14777226410 020253 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/mixed-int-array.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"arrays-and-ints" => [
bless( {
"_file" => "(eval 143)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
[
"Arrays are not integers."
]
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/mixed-int-array - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/mixed-int-array - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/mixed-int-array - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/mixed-int-array.toml 0000664 0000000 0000000 00000000065 14777226410 020756 0 ustar arrays-and-ints = [1, ["Arrays are not integers."]]
work/TOML-Tiny/t/toml-test/valid/array/mixed-int-float.t 0000664 0000000 0000000 00000007742 14777226410 020246 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/mixed-int-float.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"ints-and-floats" => [
bless( {
"_file" => "(eval 144)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 145)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('1.1')->beq($got);
},
"name" => "Math::BigFloat->new(\"1.1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/mixed-int-float - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/mixed-int-float - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/mixed-int-float - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/mixed-int-float.toml 0000664 0000000 0000000 00000000033 14777226410 020740 0 ustar ints-and-floats = [1, 1.1]
work/TOML-Tiny/t/toml-test/valid/array/mixed-int-string.t 0000664 0000000 0000000 00000005325 14777226410 020442 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/mixed-int-string.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"strings-and-ints" => [
"hi",
bless( {
"_file" => "(eval 146)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/mixed-int-string - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/mixed-int-string - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/mixed-int-string - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/mixed-int-string.toml 0000664 0000000 0000000 00000000036 14777226410 021144 0 ustar strings-and-ints = ["hi", 42]
work/TOML-Tiny/t/toml-test/valid/array/mixed-string-table.t 0000664 0000000 0000000 00000003246 14777226410 020737 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/mixed-string-table.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"contributors" => [
"Foo Bar ",
{
"email" => "bazqux\@example.com",
"name" => "Baz Qux",
"url" => "https://example.com/bazqux"
}
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/mixed-string-table - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/mixed-string-table - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/mixed-string-table - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/mixed-string-table.toml 0000664 0000000 0000000 00000000213 14777226410 021436 0 ustar contributors = [
"Foo Bar ",
{ name = "Baz Qux", email = "bazqux@example.com", url = "https://example.com/bazqux" }
]
work/TOML-Tiny/t/toml-test/valid/array/nested-double.t 0000664 0000000 0000000 00000012330 14777226410 017764 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/nested-double.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"nest" => [
[
[
"a"
],
[
bless( {
"_file" => "(eval 147)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 148)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
[
bless( {
"_file" => "(eval 149)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3')->beq($got);
},
"name" => "Math::BigInt->new(\"3\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
]
]
]
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/nested-double - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/nested-double - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/nested-double - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/nested-double.toml 0000664 0000000 0000000 00000000050 14777226410 020470 0 ustar nest = [
[
["a"],
[1, 2, [3]]
]
]
work/TOML-Tiny/t/toml-test/valid/array/nested-inline-table.t 0000664 0000000 0000000 00000002625 14777226410 021063 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/nested-inline-table.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => [
{
"b" => {}
}
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/nested-inline-table - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/nested-inline-table - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/nested-inline-table - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/nested-inline-table.toml 0000664 0000000 0000000 00000000023 14777226410 021561 0 ustar a = [ { b = {} } ]
work/TOML-Tiny/t/toml-test/valid/array/nested.t 0000664 0000000 0000000 00000002706 14777226410 016522 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/nested.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"nest" => [
[
"a"
],
[
"b"
]
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/nested - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/nested - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/nested - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/nested.toml 0000664 0000000 0000000 00000000026 14777226410 017223 0 ustar nest = [["a"], ["b"]]
work/TOML-Tiny/t/toml-test/valid/array/nospaces.t 0000664 0000000 0000000 00000011272 14777226410 017051 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/nospaces.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"ints" => [
bless( {
"_file" => "(eval 150)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 151)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 152)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3')->beq($got);
},
"name" => "Math::BigInt->new(\"3\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/nospaces - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/nospaces - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/nospaces - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/nospaces.toml 0000664 0000000 0000000 00000000017 14777226410 017554 0 ustar ints = [1,2,3]
work/TOML-Tiny/t/toml-test/valid/array/string-quote-comma-2.t 0000664 0000000 0000000 00000002555 14777226410 021134 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/string-quote-comma-2.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"title" => [
" \", "
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/string-quote-comma-2 - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/string-quote-comma-2 - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/string-quote-comma-2 - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/string-quote-comma-2.toml 0000664 0000000 0000000 00000000024 14777226410 021631 0 ustar title = [ " \", ",]
work/TOML-Tiny/t/toml-test/valid/array/string-quote-comma.t 0000664 0000000 0000000 00000002645 14777226410 020775 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/string-quote-comma.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"title" => [
"Client: \"XXXX\", Job: XXXX",
"Code: XXXX"
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/string-quote-comma - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/string-quote-comma - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/string-quote-comma - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/string-quote-comma.toml 0000664 0000000 0000000 00000000070 14777226410 021473 0 ustar title = [
"Client: \"XXXX\", Job: XXXX",
"Code: XXXX"
]
work/TOML-Tiny/t/toml-test/valid/array/string-with-comma.t 0000664 0000000 0000000 00000002635 14777226410 020612 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/string-with-comma.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"title" => [
"Client: XXXX, Job: XXXX",
"Code: XXXX"
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/string-with-comma - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/string-with-comma - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/string-with-comma - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/string-with-comma.toml 0000664 0000000 0000000 00000000064 14777226410 021314 0 ustar title = [
"Client: XXXX, Job: XXXX",
"Code: XXXX"
]
work/TOML-Tiny/t/toml-test/valid/array/strings.t 0000664 0000000 0000000 00000002730 14777226410 016726 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/strings.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"string_array" => [
"all",
"strings",
"are the same",
"type"
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/strings - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/strings - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/strings - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/strings.toml 0000664 0000000 0000000 00000000103 14777226410 017426 0 ustar string_array = [ "all", 'strings', """are the same""", '''type''']
work/TOML-Tiny/t/toml-test/valid/array/table-array-string-backslash.t 0000664 0000000 0000000 00000002720 14777226410 022674 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/array/table-array-string-backslash.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"foo" => [
{
"bar" => "\"{{baz}}\""
}
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'array/table-array-string-backslash - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'array/table-array-string-backslash - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'array/table-array-string-backslash - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/array/table-array-string-backslash.toml 0000664 0000000 0000000 00000000037 14777226410 023403 0 ustar foo = [ { bar="\"{{baz}}\""} ]
work/TOML-Tiny/t/toml-test/valid/bool/ 0000775 0000000 0000000 00000000000 14777226410 014663 5 ustar work/TOML-Tiny/t/toml-test/valid/bool/bool.t 0000664 0000000 0000000 00000002775 14777226410 016016 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
use constant CORE_BOOL => defined &builtin::is_bool;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/bool/bool.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"f" => 0,
"t" => 1
};
my $actual = from_toml($toml);
is($actual, $expected1, 'bool/bool - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'bool/bool - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'bool/bool - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
subtest 'builtin booleans' => sub {
plan skip_all => 'No builtin::is_bool', unless CORE_BOOL;
my $data = { t => !!1, f => !!0 };
my $toml = to_toml($data);
is $toml, $regenerated;
};
done_testing;
work/TOML-Tiny/t/toml-test/valid/bool/bool.toml 0000664 0000000 0000000 00000000023 14777226410 016506 0 ustar t = true
f = false
work/TOML-Tiny/t/toml-test/valid/comment/ 0000775 0000000 0000000 00000000000 14777226410 015372 5 ustar work/TOML-Tiny/t/toml-test/valid/comment/at-eof.t 0000664 0000000 0000000 00000002401 14777226410 016727 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/comment/at-eof.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"key" => "value"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'comment/at-eof - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'comment/at-eof - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'comment/at-eof - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/comment/at-eof.toml 0000664 0000000 0000000 00000000125 14777226410 017440 0 ustar # This is a full-line comment
key = "value" # This is a comment at the end of a line
work/TOML-Tiny/t/toml-test/valid/comment/at-eof2.t 0000664 0000000 0000000 00000002405 14777226410 017015 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/comment/at-eof2.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"key" => "value"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'comment/at-eof2 - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'comment/at-eof2 - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'comment/at-eof2 - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/comment/at-eof2.toml 0000664 0000000 0000000 00000000125 14777226410 017522 0 ustar # This is a full-line comment
key = "value" # This is a comment at the end of a line
work/TOML-Tiny/t/toml-test/valid/comment/everywhere.t 0000664 0000000 0000000 00000012771 14777226410 017754 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/comment/everywhere.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"group" => {
"answer" => bless( {
"_file" => "(eval 155)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"d" => "1979-05-27T07:32:12-07:00",
"more" => [
bless( {
"_file" => "(eval 153)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 154)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
]
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'comment/everywhere - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'comment/everywhere - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'comment/everywhere - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/comment/everywhere.toml 0000664 0000000 0000000 00000001054 14777226410 020454 0 ustar # Top comment.
# Top comment.
# Top comment.
# [no-extraneous-groups-please]
[group] # Comment
answer = 42 # Comment
# no-extraneous-keys-please = 999
# Inbetween comment.
more = [ # Comment
# What about multiple # comments?
# Can you handle it?
#
# Evil.
# Evil.
42, 42, # Comments within arrays are fun.
# What about multiple # comments?
# Can you handle it?
#
# Evil.
# Evil.
# ] Did I fool you?
] # Hopefully not.
# Make sure the space between the datetime and "#" isn't lexed.
d = 1979-05-27T07:32:12-07:00 # c
work/TOML-Tiny/t/toml-test/valid/comment/tricky.t 0000664 0000000 0000000 00000033264 14777226410 017074 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/comment/tricky.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"hash#tag" => {
"#!" => "hash bang",
"arr3" => [
"#",
"#",
"###"
],
"arr4" => [
bless( {
"_file" => "(eval 160)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 161)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 162)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3')->beq($got);
},
"name" => "Math::BigInt->new(\"3\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 163)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('4')->beq($got);
},
"name" => "Math::BigInt->new(\"4\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
],
"arr5" => [
[
[
[
[
"#"
]
]
]
]
],
"tbl1" => {
"#" => "}#"
}
},
"section" => {
"8" => "eight",
"eleven" => bless( {
"_file" => "(eval 158)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('11.1')->beq($got);
},
"name" => "Math::BigFloat->new(\"11.1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"five" => bless( {
"_file" => "(eval 156)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('5.5')->beq($got);
},
"name" => "Math::BigFloat->new(\"5.5\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"four" => "# no comment\n# nor this\n#also not comment",
"one" => 11,
"six" => bless( {
"_file" => "(eval 157)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('6')->beq($got);
},
"name" => "Math::BigInt->new(\"6\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"ten" => bless( {
"_file" => "(eval 159)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('1000.0')->beq($got);
},
"name" => "Math::BigFloat->new(\"1000.0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"three" => "#",
"two" => "22#"
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'comment/tricky - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'comment/tricky - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'comment/tricky - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/comment/tricky.toml 0000664 0000000 0000000 00000000601 14777226410 017571 0 ustar [section]#attached comment
#[notsection]
one = "11"#cmt
two = "22#"
three = '#'
four = """# no comment
# nor this
#also not comment"""#is_comment
five = 5.5#66
six = 6#7
8 = "eight"
#nine = 99
ten = 10e2#1
eleven = 1.11e1#23
["hash#tag"]
"#!" = "hash bang"
arr3 = [ "#", '#', """###""" ]
arr4 = [ 1,# 9, 9,
2#,9
,#9
3#]
,4]
arr5 = [[[[#["#"],
["#"]]]]#]
]
tbl1 = { "#" = '}#'}#}}
work/TOML-Tiny/t/toml-test/valid/datetime/ 0000775 0000000 0000000 00000000000 14777226410 015524 5 ustar work/TOML-Tiny/t/toml-test/valid/datetime/datetime.t 0000664 0000000 0000000 00000002520 14777226410 017504 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/datetime/datetime.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"lower" => "1987-07-05T17:45:00Z",
"space" => "1987-07-05T17:45:00Z"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'datetime/datetime - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'datetime/datetime - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'datetime/datetime - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/datetime/datetime.toml 0000664 0000000 0000000 00000000072 14777226410 020214 0 ustar space = 1987-07-05 17:45:00Z
lower = 1987-07-05t17:45:00z
work/TOML-Tiny/t/toml-test/valid/datetime/local-date.t 0000664 0000000 0000000 00000002442 14777226410 017720 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/datetime/local-date.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"bestdayever" => "1987-07-05"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'datetime/local-date - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'datetime/local-date - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'datetime/local-date - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/datetime/local-date.toml 0000664 0000000 0000000 00000000031 14777226410 020420 0 ustar bestdayever = 1987-07-05
work/TOML-Tiny/t/toml-test/valid/datetime/local-time.t 0000664 0000000 0000000 00000002522 14777226410 017740 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/datetime/local-time.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"besttimeever" => "17:45:00",
"milliseconds" => "10:32:00.555"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'datetime/local-time - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'datetime/local-time - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'datetime/local-time - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/datetime/local-time.toml 0000664 0000000 0000000 00000000064 14777226410 020447 0 ustar besttimeever = 17:45:00
milliseconds = 10:32:00.555
work/TOML-Tiny/t/toml-test/valid/datetime/local.t 0000664 0000000 0000000 00000002567 14777226410 017015 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/datetime/local.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"local" => "1987-07-05T17:45:00",
"milli" => "1977-12-21T10:32:00.555",
"space" => "1987-07-05T17:45:00"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'datetime/local - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'datetime/local - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'datetime/local - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/datetime/local.toml 0000664 0000000 0000000 00000000130 14777226410 017505 0 ustar local = 1987-07-05T17:45:00
milli = 1977-12-21T10:32:00.555
space = 1987-07-05 17:45:00
work/TOML-Tiny/t/toml-test/valid/datetime/milliseconds.t 0000664 0000000 0000000 00000002764 14777226410 020407 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/datetime/milliseconds.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"utc1" => "1987-07-05T17:45:56.123456000Z",
"utc2" => "1987-07-05T17:45:56.600000000Z",
"wita1" => "1987-07-05T17:45:56.123456000+08:00",
"wita2" => "1987-07-05T17:45:56.600000000+08:00"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'datetime/milliseconds - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'datetime/milliseconds - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'datetime/milliseconds - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/datetime/milliseconds.toml 0000664 0000000 0000000 00000000220 14777226410 021100 0 ustar utc1 = 1987-07-05T17:45:56.123456Z
utc2 = 1987-07-05T17:45:56.6Z
wita1 = 1987-07-05T17:45:56.123456+08:00
wita2 = 1987-07-05T17:45:56.6+08:00
work/TOML-Tiny/t/toml-test/valid/datetime/timezone.t 0000664 0000000 0000000 00000002675 14777226410 017555 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/datetime/timezone.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"nzdt" => "1987-07-05T17:45:56+13:00",
"nzst" => "1987-07-05T17:45:56+12:00",
"pdt" => "1987-07-05T17:45:56-05:00",
"utc" => "1987-07-05T17:45:56Z"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'datetime/timezone - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'datetime/timezone - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'datetime/timezone - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/datetime/timezone.toml 0000664 0000000 0000000 00000000206 14777226410 020251 0 ustar utc = 1987-07-05T17:45:56Z
pdt = 1987-07-05T17:45:56-05:00
nzst = 1987-07-05T17:45:56+12:00
nzdt = 1987-07-05T17:45:56+13:00 # DST
work/TOML-Tiny/t/toml-test/valid/empty-file.t 0000664 0000000 0000000 00000002303 14777226410 016166 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/empty-file.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {};
my $actual = from_toml($toml);
is($actual, $expected1, 'empty-file - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'empty-file - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'empty-file - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/empty-file.toml 0000664 0000000 0000000 00000000000 14777226410 016666 0 ustar work/TOML-Tiny/t/toml-test/valid/example.t 0000664 0000000 0000000 00000014021 14777226410 015546 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/example.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"best-day-ever" => "1987-07-05T17:45:00Z",
"numtheory" => {
"boring" => 0,
"perfection" => [
bless( {
"_file" => "(eval 164)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('6')->beq($got);
},
"name" => "Math::BigInt->new(\"6\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 165)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('28')->beq($got);
},
"name" => "Math::BigInt->new(\"28\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 166)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('496')->beq($got);
},
"name" => "Math::BigInt->new(\"496\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
]
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'example - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'example - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'example - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing;
work/TOML-Tiny/t/toml-test/valid/example.toml 0000664 0000000 0000000 00000000133 14777226410 016255 0 ustar best-day-ever = 1987-07-05T17:45:00Z
[numtheory]
boring = false
perfection = [6, 28, 496]
work/TOML-Tiny/t/toml-test/valid/float/ 0000775 0000000 0000000 00000000000 14777226410 015035 5 ustar work/TOML-Tiny/t/toml-test/valid/float/exponent.t 0000664 0000000 0000000 00000024732 14777226410 017072 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/float/exponent.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"lower" => bless( {
"_file" => "(eval 173)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('300.0')->beq($got);
},
"name" => "Math::BigFloat->new(\"300.0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"minustenth" => bless( {
"_file" => "(eval 170)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('-0.1')->beq($got);
},
"name" => "Math::BigFloat->new(\"-0.1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"neg" => bless( {
"_file" => "(eval 167)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('0.03')->beq($got);
},
"name" => "Math::BigFloat->new(\"0.03\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"pointlower" => bless( {
"_file" => "(eval 172)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('310.0')->beq($got);
},
"name" => "Math::BigFloat->new(\"310.0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"pointupper" => bless( {
"_file" => "(eval 169)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('310.0')->beq($got);
},
"name" => "Math::BigFloat->new(\"310.0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"pos" => bless( {
"_file" => "(eval 171)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('300.0')->beq($got);
},
"name" => "Math::BigFloat->new(\"300.0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"upper" => bless( {
"_file" => "(eval 174)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('300.0')->beq($got);
},
"name" => "Math::BigFloat->new(\"300.0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"zero" => bless( {
"_file" => "(eval 168)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('3.0')->beq($got);
},
"name" => "Math::BigFloat->new(\"3.0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'float/exponent - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'float/exponent - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'float/exponent - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/float/exponent.toml 0000664 0000000 0000000 00000000162 14777226410 017571 0 ustar lower = 3e2
upper = 3E2
neg = 3e-2
pos = 3E+2
zero = 3e0
pointlower = 3.1e2
pointupper = 3.1E2
minustenth = -1E-1
work/TOML-Tiny/t/toml-test/valid/float/float.t 0000664 0000000 0000000 00000013500 14777226410 016326 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/float/float.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"negpi" => bless( {
"_file" => "(eval 175)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('-3.14')->beq($got);
},
"name" => "Math::BigFloat->new(\"-3.14\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"pi" => bless( {
"_file" => "(eval 176)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('3.14')->beq($got);
},
"name" => "Math::BigFloat->new(\"3.14\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"pospi" => bless( {
"_file" => "(eval 178)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('3.14')->beq($got);
},
"name" => "Math::BigFloat->new(\"3.14\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"zero-intpart" => bless( {
"_file" => "(eval 177)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('0.123')->beq($got);
},
"name" => "Math::BigFloat->new(\"0.123\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'float/float - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'float/float - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'float/float - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/float/float.toml 0000664 0000000 0000000 00000000073 14777226410 017037 0 ustar pi = 3.14
pospi = +3.14
negpi = -3.14
zero-intpart = 0.123
work/TOML-Tiny/t/toml-test/valid/float/inf-and-nan.t 0000664 0000000 0000000 00000017606 14777226410 017322 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/float/inf-and-nan.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"infinity" => bless( {
"_file" => "(eval 181)",
"_lines" => [
6
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
'Math::BigFloat'->new($_)->is_inf;
},
"name" => "Math::BigFloat->new(\$_)->is_inf",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"infinity_neg" => bless( {
"_file" => "(eval 180)",
"_lines" => [
6
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
'Math::BigFloat'->new($_)->is_inf;
},
"name" => "Math::BigFloat->new(\$_)->is_inf",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"infinity_plus" => bless( {
"_file" => "(eval 184)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('+inf')->beq($got);
},
"name" => "Math::BigFloat->new(\"+inf\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"nan" => bless( {
"_file" => "(eval 183)",
"_lines" => [
6
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
'Math::BigFloat'->new($_)->is_nan;
},
"name" => "Math::BigFloat->new(\$_)->is_nan",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"nan_neg" => bless( {
"_file" => "(eval 179)",
"_lines" => [
6
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
'Math::BigFloat'->new($_)->is_nan;
},
"name" => "Math::BigFloat->new(\$_)->is_nan",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"nan_plus" => bless( {
"_file" => "(eval 182)",
"_lines" => [
6
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
'Math::BigFloat'->new($_)->is_nan;
},
"name" => "Math::BigFloat->new(\$_)->is_nan",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'float/inf-and-nan - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'float/inf-and-nan - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'float/inf-and-nan - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/float/inf-and-nan.toml 0000664 0000000 0000000 00000000350 14777226410 020016 0 ustar # We don't encode +nan and -nan back with the signs; many languages don't
# support a sign on NaN (it doesn't really make much sense).
nan = nan
nan_neg = -nan
nan_plus = +nan
infinity = inf
infinity_neg = -inf
infinity_plus = +inf
work/TOML-Tiny/t/toml-test/valid/float/long.t 0000664 0000000 0000000 00000007155 14777226410 016171 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/float/long.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"longpi" => bless( {
"_file" => "(eval 185)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('3.141592653589793')->beq($got);
},
"name" => "Math::BigFloat->new(\"3.141592653589793\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"neglongpi" => bless( {
"_file" => "(eval 186)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('-3.141592653589793')->beq($got);
},
"name" => "Math::BigFloat->new(\"-3.141592653589793\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'float/long - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'float/long - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'float/long - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/float/long.toml 0000664 0000000 0000000 00000000072 14777226410 016670 0 ustar longpi = 3.141592653589793
neglongpi = -3.141592653589793
work/TOML-Tiny/t/toml-test/valid/float/underscore.t 0000664 0000000 0000000 00000011337 14777226410 017400 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/float/underscore.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"after" => bless( {
"_file" => "(eval 187)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('3141.5927')->beq($got);
},
"name" => "Math::BigFloat->new(\"3141.5927\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"before" => bless( {
"_file" => "(eval 189)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('3141.5927')->beq($got);
},
"name" => "Math::BigFloat->new(\"3141.5927\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"exponent" => bless( {
"_file" => "(eval 188)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('3.0e14')->beq($got);
},
"name" => "Math::BigFloat->new(\"3.0e14\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'float/underscore - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'float/underscore - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'float/underscore - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/float/underscore.toml 0000664 0000000 0000000 00000000070 14777226410 020100 0 ustar before = 3_141.5927
after = 3141.592_7
exponent = 3e1_4
work/TOML-Tiny/t/toml-test/valid/float/zero.t 0000664 0000000 0000000 00000021400 14777226410 016176 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/float/zero.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"f1" => bless( {
"_file" => "(eval 194)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('0')->beq($got);
},
"name" => "Math::BigFloat->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"f2" => bless( {
"_file" => "(eval 196)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('0')->beq($got);
},
"name" => "Math::BigFloat->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"f3" => bless( {
"_file" => "(eval 192)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('0')->beq($got);
},
"name" => "Math::BigFloat->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"f4" => bless( {
"_file" => "(eval 193)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('0')->beq($got);
},
"name" => "Math::BigFloat->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"f5" => bless( {
"_file" => "(eval 195)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('0')->beq($got);
},
"name" => "Math::BigFloat->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"f6" => bless( {
"_file" => "(eval 191)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('0')->beq($got);
},
"name" => "Math::BigFloat->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"f7" => bless( {
"_file" => "(eval 190)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('0')->beq($got);
},
"name" => "Math::BigFloat->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'float/zero - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'float/zero - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'float/zero - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/float/zero.toml 0000664 0000000 0000000 00000000104 14777226410 016704 0 ustar f1 = 0.0
f2 = +0.0
f3 = -0.0
f4 = 0e0
f5 = 0e00
f6 = +0e0
f7 = -0e0
work/TOML-Tiny/t/toml-test/valid/implicit-and-explicit-after.t 0000664 0000000 0000000 00000010532 14777226410 021406 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/implicit-and-explicit-after.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
"b" => {
"c" => {
"answer" => bless( {
"_file" => "(eval 198)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"better" => bless( {
"_file" => "(eval 197)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('43')->beq($got);
},
"name" => "Math::BigInt->new(\"43\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'implicit-and-explicit-after - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'implicit-and-explicit-after - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'implicit-and-explicit-after - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/implicit-and-explicit-after.toml 0000664 0000000 0000000 00000000045 14777226410 022114 0 ustar [a.b.c]
answer = 42
[a]
better = 43
work/TOML-Tiny/t/toml-test/valid/implicit-and-explicit-before.t 0000664 0000000 0000000 00000010536 14777226410 021553 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/implicit-and-explicit-before.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
"b" => {
"c" => {
"answer" => bless( {
"_file" => "(eval 200)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"better" => bless( {
"_file" => "(eval 199)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('43')->beq($got);
},
"name" => "Math::BigInt->new(\"43\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'implicit-and-explicit-before - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'implicit-and-explicit-before - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'implicit-and-explicit-before - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/implicit-and-explicit-before.toml 0000664 0000000 0000000 00000000045 14777226410 022255 0 ustar [a]
better = 43
[a.b.c]
answer = 42
work/TOML-Tiny/t/toml-test/valid/implicit-groups.t 0000664 0000000 0000000 00000006003 14777226410 017243 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/implicit-groups.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
"b" => {
"c" => {
"answer" => bless( {
"_file" => "(eval 201)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'implicit-groups - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'implicit-groups - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'implicit-groups - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/implicit-groups.toml 0000664 0000000 0000000 00000000024 14777226410 017750 0 ustar [a.b.c]
answer = 42
work/TOML-Tiny/t/toml-test/valid/inline-table/ 0000775 0000000 0000000 00000000000 14777226410 016273 5 ustar work/TOML-Tiny/t/toml-test/valid/inline-table/array.t 0000664 0000000 0000000 00000003466 14777226410 017607 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/inline-table/array.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"people" => [
{
"first_name" => "Bruce",
"last_name" => "Springsteen"
},
{
"first_name" => "Eric",
"last_name" => "Clapton"
},
{
"first_name" => "Bob",
"last_name" => "Seger"
}
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'inline-table/array - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'inline-table/array - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'inline-table/array - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/inline-table/array.toml 0000664 0000000 0000000 00000000252 14777226410 020305 0 ustar people = [{first_name = "Bruce", last_name = "Springsteen"},
{first_name = "Eric", last_name = "Clapton"},
{first_name = "Bob", last_name = "Seger"}]
work/TOML-Tiny/t/toml-test/valid/inline-table/bool.t 0000664 0000000 0000000 00000002540 14777226410 017414 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/inline-table/bool.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
"a" => 1,
"b" => 0
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'inline-table/bool - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'inline-table/bool - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'inline-table/bool - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/inline-table/bool.toml 0000664 0000000 0000000 00000000032 14777226410 020116 0 ustar a = {a = true, b = false}
work/TOML-Tiny/t/toml-test/valid/inline-table/empty.t 0000664 0000000 0000000 00000012235 14777226410 017621 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/inline-table/empty.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"empty1" => {},
"empty2" => {},
"empty_in_array" => [
{
"not_empty" => bless( {
"_file" => "(eval 203)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
},
{}
],
"empty_in_array2" => [
{},
{
"not_empty" => bless( {
"_file" => "(eval 202)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
],
"many_empty" => [
{},
{},
{}
],
"nested_empty" => {
"empty" => {}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'inline-table/empty - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'inline-table/empty - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'inline-table/empty - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/inline-table/empty.toml 0000664 0000000 0000000 00000000235 14777226410 020326 0 ustar empty1 = {}
empty2 = { }
empty_in_array = [ { not_empty = 1 }, {} ]
empty_in_array2 = [{},{not_empty=1}]
many_empty = [{},{},{}]
nested_empty = {"empty"={}}
work/TOML-Tiny/t/toml-test/valid/inline-table/end-in-bool.t 0000664 0000000 0000000 00000002733 14777226410 020570 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/inline-table/end-in-bool.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"black" => {
"allow_prereleases" => 1,
"python" => ">3.6",
"version" => ">=18.9b0"
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'inline-table/end-in-bool - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'inline-table/end-in-bool - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'inline-table/end-in-bool - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/inline-table/end-in-bool.toml 0000664 0000000 0000000 00000000106 14777226410 021270 0 ustar black = { python=">3.6", version=">=18.9b0", allow_prereleases=true }
work/TOML-Tiny/t/toml-test/valid/inline-table/inline-table.t 0000664 0000000 0000000 00000023343 14777226410 021030 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/inline-table/inline-table.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"name" => {
"first" => "Tom",
"last" => "Preston-Werner"
},
"point" => {
"x" => bless( {
"_file" => "(eval 207)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"y" => bless( {
"_file" => "(eval 208)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
},
"simple" => {
"a" => bless( {
"_file" => "(eval 209)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
},
"str-key" => {
"a" => bless( {
"_file" => "(eval 204)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
},
"table-array" => [
{
"a" => bless( {
"_file" => "(eval 205)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
},
{
"b" => bless( {
"_file" => "(eval 206)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'inline-table/inline-table - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'inline-table/inline-table - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'inline-table/inline-table - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/inline-table/inline-table.toml 0000664 0000000 0000000 00000000235 14777226410 021533 0 ustar name = { first = "Tom", last = "Preston-Werner" }
point = { x = 1, y = 2 }
simple = { a = 1 }
str-key = { "a" = 1 }
table-array = [{ "a" = 1 }, { "b" = 2 }]
work/TOML-Tiny/t/toml-test/valid/inline-table/key-dotted.t 0000664 0000000 0000000 00000070026 14777226410 020536 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/inline-table/key-dotted.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
"a" => {
"b" => bless( {
"_file" => "(eval 222)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"arr" => [
{
"T" => {
"a" => {
"b" => bless( {
"_file" => "(eval 219)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"t" => {
"a" => {
"b" => bless( {
"_file" => "(eval 218)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
},
{
"T" => {
"a" => {
"b" => bless( {
"_file" => "(eval 221)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"t" => {
"a" => {
"b" => bless( {
"_file" => "(eval 220)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
],
"b" => {
"a" => {
"b" => bless( {
"_file" => "(eval 223)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"c" => {
"a" => {
"b" => bless( {
"_file" => "(eval 211)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"d" => {
"a" => {
"b" => bless( {
"_file" => "(eval 210)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"e" => {
"a" => {
"b" => bless( {
"_file" => "(eval 212)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"inline" => {
"a" => {
"b" => bless( {
"_file" => "(eval 215)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"many" => {
"dots" => {
"here" => {
"dot" => {
"dot" => {
"dot" => {
"a" => {
"b" => {
"c" => bless( {
"_file" => "(eval 213)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"d" => bless( {
"_file" => "(eval 214)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
}
}
}
}
},
"tbl" => {
"a" => {
"b" => {
"c" => {
"d" => {
"e" => bless( {
"_file" => "(eval 217)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
},
"x" => {
"a" => {
"b" => {
"c" => {
"d" => {
"e" => bless( {
"_file" => "(eval 216)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
}
}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'inline-table/key-dotted - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'inline-table/key-dotted - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'inline-table/key-dotted - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/inline-table/key-dotted.toml 0000664 0000000 0000000 00000000464 14777226410 021245 0 ustar inline = {a.b = 42}
many.dots.here.dot.dot.dot = {a.b.c = 1, a.b.d = 2}
a = { a.b = 1 }
b = { "a"."b" = 1 }
c = { a . b = 1 }
d = { 'a' . "b" = 1 }
e = {a.b=1}
[tbl]
a.b.c = {d.e=1}
[tbl.x]
a.b.c = {d.e=1}
[[arr]]
t = {a.b=1}
T = {a.b=1}
[[arr]]
t = {a.b=2}
T = {a.b=2}
work/TOML-Tiny/t/toml-test/valid/inline-table/multiline.t 0000664 0000000 0000000 00000010376 14777226410 020471 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/inline-table/multiline.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"tbl_multiline" => {
"a" => bless( {
"_file" => "(eval 224)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"b" => "multiline\n",
"c" => "and yet\nanother line",
"d" => bless( {
"_file" => "(eval 225)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('4')->beq($got);
},
"name" => "Math::BigInt->new(\"4\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'inline-table/multiline - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'inline-table/multiline - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'inline-table/multiline - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/inline-table/multiline.toml 0000664 0000000 0000000 00000000130 14777226410 021164 0 ustar tbl_multiline = { a = 1, b = """
multiline
""", c = """and yet
another line""", d = 4 }
work/TOML-Tiny/t/toml-test/valid/inline-table/nest.t 0000664 0000000 0000000 00000030242 14777226410 017432 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/inline-table/nest.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"arr_arr_tbl_empty" => [
[
{}
]
],
"arr_arr_tbl_val" => [
[
{
"one" => bless( {
"_file" => "(eval 228)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
]
],
"arr_arr_tbls" => [
[
{
"one" => bless( {
"_file" => "(eval 226)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
},
{
"two" => bless( {
"_file" => "(eval 227)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
]
],
"arr_tbl_tbl" => [
{
"tbl" => {
"one" => bless( {
"_file" => "(eval 230)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
],
"tbl_arr_tbl" => {
"arr_tbl" => [
{
"one" => bless( {
"_file" => "(eval 231)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
]
},
"tbl_tbl_empty" => {
"tbl_0" => {}
},
"tbl_tbl_val" => {
"tbl_1" => {
"one" => bless( {
"_file" => "(eval 229)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'inline-table/nest - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'inline-table/nest - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'inline-table/nest - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/inline-table/nest.toml 0000664 0000000 0000000 00000000564 14777226410 020146 0 ustar tbl_tbl_empty = { tbl_0 = {} }
tbl_tbl_val = { tbl_1 = { one = 1 } }
tbl_arr_tbl = { arr_tbl = [ { one = 1 } ] }
arr_tbl_tbl = [ { tbl = { one = 1 } } ]
# Array-of-array-of-table is interesting because it can only
# be represented in inline form.
arr_arr_tbl_empty = [ [ {} ] ]
arr_arr_tbl_val = [ [ { one = 1 } ] ]
arr_arr_tbls = [ [ { one = 1 }, { two = 2 } ] ]
work/TOML-Tiny/t/toml-test/valid/integer/ 0000775 0000000 0000000 00000000000 14777226410 015365 5 ustar work/TOML-Tiny/t/toml-test/valid/integer/integer.t 0000664 0000000 0000000 00000013540 14777226410 017212 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/integer/integer.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"answer" => bless( {
"_file" => "(eval 234)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"neganswer" => bless( {
"_file" => "(eval 233)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('-42')->beq($got);
},
"name" => "Math::BigInt->new(\"-42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"posanswer" => bless( {
"_file" => "(eval 235)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"zero" => bless( {
"_file" => "(eval 232)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'integer/integer - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'integer/integer - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'integer/integer - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/integer/integer.toml 0000664 0000000 0000000 00000000065 14777226410 017720 0 ustar answer = 42
posanswer = +42
neganswer = -42
zero = 0
work/TOML-Tiny/t/toml-test/valid/integer/literals.t 0000664 0000000 0000000 00000026364 14777226410 017404 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/integer/literals.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"bin1" => bless( {
"_file" => "(eval 236)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('214')->beq($got);
},
"name" => "Math::BigInt->new(\"214\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"bin2" => bless( {
"_file" => "(eval 244)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('5')->beq($got);
},
"name" => "Math::BigInt->new(\"5\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"hex1" => bless( {
"_file" => "(eval 237)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3735928559')->beq($got);
},
"name" => "Math::BigInt->new(\"3735928559\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"hex2" => bless( {
"_file" => "(eval 242)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3735928559')->beq($got);
},
"name" => "Math::BigInt->new(\"3735928559\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"hex3" => bless( {
"_file" => "(eval 243)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3735928559')->beq($got);
},
"name" => "Math::BigInt->new(\"3735928559\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"hex4" => bless( {
"_file" => "(eval 240)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2439')->beq($got);
},
"name" => "Math::BigInt->new(\"2439\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"oct1" => bless( {
"_file" => "(eval 241)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('342391')->beq($got);
},
"name" => "Math::BigInt->new(\"342391\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"oct2" => bless( {
"_file" => "(eval 239)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('493')->beq($got);
},
"name" => "Math::BigInt->new(\"493\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"oct3" => bless( {
"_file" => "(eval 238)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('501')->beq($got);
},
"name" => "Math::BigInt->new(\"501\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'integer/literals - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'integer/literals - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'integer/literals - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/integer/literals.toml 0000664 0000000 0000000 00000000227 14777226410 020102 0 ustar bin1 = 0b11010110
bin2 = 0b1_0_1
oct1 = 0o01234567
oct2 = 0o755
oct3 = 0o7_6_5
hex1 = 0xDEADBEEF
hex2 = 0xdeadbeef
hex3 = 0xdead_beef
hex4 = 0x00987
work/TOML-Tiny/t/toml-test/valid/integer/long.t 0000664 0000000 0000000 00000007344 14777226410 016521 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/integer/long.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"int64-max" => bless( {
"_file" => "(eval 245)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('9223372036854775807')->beq($got);
},
"name" => "Math::BigInt->new(\"9223372036854775807\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"int64-max-neg" => bless( {
"_file" => "(eval 246)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('-9223372036854775808')->beq($got);
},
"name" => "Math::BigInt->new(\"-9223372036854775808\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'integer/long - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'integer/long - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'integer/long - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/integer/long.toml 0000664 0000000 0000000 00000000105 14777226410 017215 0 ustar int64-max = 9223372036854775807
int64-max-neg = -9223372036854775808
work/TOML-Tiny/t/toml-test/valid/integer/underscore.t 0000664 0000000 0000000 00000006635 14777226410 017735 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/integer/underscore.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"kilo" => bless( {
"_file" => "(eval 247)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1000')->beq($got);
},
"name" => "Math::BigInt->new(\"1000\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"x" => bless( {
"_file" => "(eval 248)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1111')->beq($got);
},
"name" => "Math::BigInt->new(\"1111\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'integer/underscore - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'integer/underscore - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'integer/underscore - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/integer/underscore.toml 0000664 0000000 0000000 00000000031 14777226410 020425 0 ustar kilo = 1_000
x = 1_1_1_1
work/TOML-Tiny/t/toml-test/valid/integer/zero.t 0000664 0000000 0000000 00000034070 14777226410 016535 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/integer/zero.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a2" => bless( {
"_file" => "(eval 258)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"a3" => bless( {
"_file" => "(eval 249)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"b1" => bless( {
"_file" => "(eval 253)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"b2" => bless( {
"_file" => "(eval 260)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"b3" => bless( {
"_file" => "(eval 252)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"d1" => bless( {
"_file" => "(eval 256)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"d2" => bless( {
"_file" => "(eval 250)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"d3" => bless( {
"_file" => "(eval 259)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"h1" => bless( {
"_file" => "(eval 251)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"h2" => bless( {
"_file" => "(eval 255)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"h3" => bless( {
"_file" => "(eval 254)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"o1" => bless( {
"_file" => "(eval 257)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('0')->beq($got);
},
"name" => "Math::BigInt->new(\"0\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'integer/zero - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'integer/zero - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'integer/zero - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/integer/zero.toml 0000664 0000000 0000000 00000000172 14777226410 017241 0 ustar d1 = 0
d2 = +0
d3 = -0
h1 = 0x0
h2 = 0x00
h3 = 0x00000
o1 = 0o0
a2 = 0o00
a3 = 0o00000
b1 = 0b0
b2 = 0b00
b3 = 0b00000
work/TOML-Tiny/t/toml-test/valid/key/ 0000775 0000000 0000000 00000000000 14777226410 014520 5 ustar work/TOML-Tiny/t/toml-test/valid/key/alphanum.t 0000664 0000000 0000000 00000010110 14777226410 016503 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/alphanum.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"000111" => "leading",
"10e3" => "false float",
"123" => "num",
"2018_10" => {
"001" => bless( {
"_file" => "(eval 262)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
},
"34-11" => bless( {
"_file" => "(eval 261)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('23')->beq($got);
},
"name" => "Math::BigInt->new(\"23\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"a-a-a" => {
"_" => 0
},
"alpha" => "a",
"one1two2" => "mixed",
"under_score" => "___",
"with-dash" => "dashed"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/alphanum - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/alphanum - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/alphanum - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/alphanum.toml 0000664 0000000 0000000 00000000255 14777226410 017224 0 ustar alpha = "a"
123 = "num"
000111 = "leading"
10e3 = "false float"
one1two2 = "mixed"
with-dash = "dashed"
under_score = "___"
34-11 = 23
[2018_10]
001 = 1
[a-a-a]
_ = false
work/TOML-Tiny/t/toml-test/valid/key/case-sensitive.t 0000664 0000000 0000000 00000003443 14777226410 017633 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/case-sensitive.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"Section" => {
"M" => "latin letter M",
"name" => "different section!!",
"\x{39c}" => "greek capital letter MU",
"\x{3bc}" => "greek small letter mu"
},
"sectioN" => "NN",
"section" => {
"NAME" => "upper",
"Name" => "capitalized",
"name" => "lower"
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/case-sensitive - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/case-sensitive - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/case-sensitive - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/case-sensitive.toml 0000664 0000000 0000000 00000000313 14777226410 020334 0 ustar sectioN = "NN"
[section]
name = "lower"
NAME = "upper"
Name = "capitalized"
[Section]
name = "different section!!"
"μ" = "greek small letter mu"
"Μ" = "greek capital letter MU"
M = "latin letter M"
work/TOML-Tiny/t/toml-test/valid/key/dotted.t 0000664 0000000 0000000 00000070274 14777226410 016202 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/dotted.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
"few" => {
"dots" => {
"polka" => {
"dance-with" => "Dot",
"dot" => "again?"
}
}
}
},
"arr" => [
{
"a" => {
"b" => {
"c" => bless( {
"_file" => "(eval 263)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"d" => bless( {
"_file" => "(eval 264)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
},
{
"a" => {
"b" => {
"c" => bless( {
"_file" => "(eval 266)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3')->beq($got);
},
"name" => "Math::BigInt->new(\"3\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"d" => bless( {
"_file" => "(eval 265)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('4')->beq($got);
},
"name" => "Math::BigInt->new(\"4\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
],
"count" => {
"a" => bless( {
"_file" => "(eval 274)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"b" => bless( {
"_file" => "(eval 275)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"c" => bless( {
"_file" => "(eval 270)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3')->beq($got);
},
"name" => "Math::BigInt->new(\"3\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"d" => bless( {
"_file" => "(eval 271)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('4')->beq($got);
},
"name" => "Math::BigInt->new(\"4\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"e" => bless( {
"_file" => "(eval 278)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('5')->beq($got);
},
"name" => "Math::BigInt->new(\"5\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"f" => bless( {
"_file" => "(eval 276)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('6')->beq($got);
},
"name" => "Math::BigInt->new(\"6\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"g" => bless( {
"_file" => "(eval 279)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('7')->beq($got);
},
"name" => "Math::BigInt->new(\"7\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"h" => bless( {
"_file" => "(eval 277)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('8')->beq($got);
},
"name" => "Math::BigInt->new(\"8\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"i" => bless( {
"_file" => "(eval 272)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('9')->beq($got);
},
"name" => "Math::BigInt->new(\"9\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"j" => bless( {
"_file" => "(eval 273)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('10')->beq($got);
},
"name" => "Math::BigInt->new(\"10\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"k" => bless( {
"_file" => "(eval 280)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('11')->beq($got);
},
"name" => "Math::BigInt->new(\"11\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"l" => bless( {
"_file" => "(eval 269)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('12')->beq($got);
},
"name" => "Math::BigInt->new(\"12\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
},
"many" => {
"dots" => {
"here" => {
"dot" => {
"dot" => {
"dot" => bless( {
"_file" => "(eval 268)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
}
},
"name" => {
"first" => "Arthur",
"last" => "Dent"
},
"tbl" => {
"a" => {
"b" => {
"c" => bless( {
"_file" => "(eval 267)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigFloat;
my $got = 'Math::BigFloat'->new($_);
'Math::BigFloat'->new('42.666')->beq($got);
},
"name" => "Math::BigFloat->new(\"42.666\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/dotted - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/dotted - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/dotted - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/dotted.toml 0000664 0000000 0000000 00000001027 14777226410 016700 0 ustar # Note: this file contains literal tab characters.
name.first = "Arthur"
"name".'last' = "Dent"
many.dots.here.dot.dot.dot = 42
# Space are ignored, and key parts can be quoted.
count.a = 1
count . b = 2
"count"."c" = 3
"count" . "d" = 4
'count'.'e' = 5
'count' . 'f' = 6
"count".'g' = 7
"count" . 'h' = 8
count.'i' = 9
count . 'j' = 10
"count".k = 11
"count" . l = 12
[tbl]
a.b.c = 42.666
[a.few.dots]
polka.dot = "again?"
polka.dance-with = "Dot"
[[arr]]
a.b.c=1
a.b.d=2
[[arr]]
a.b.c=3
a.b.d=4
work/TOML-Tiny/t/toml-test/valid/key/empty.t 0000664 0000000 0000000 00000002352 14777226410 016045 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/empty.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"" => "blank"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/empty - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/empty - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/empty - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/empty.toml 0000664 0000000 0000000 00000000015 14777226410 016547 0 ustar "" = "blank"
work/TOML-Tiny/t/toml-test/valid/key/equals-nospace.t 0000664 0000000 0000000 00000004576 14777226410 017641 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/equals-nospace.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"answer" => bless( {
"_file" => "(eval 281)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/equals-nospace - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/equals-nospace - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/equals-nospace - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/equals-nospace.toml 0000664 0000000 0000000 00000000012 14777226410 020326 0 ustar answer=42
work/TOML-Tiny/t/toml-test/valid/key/escapes.t 0000664 0000000 0000000 00000003117 14777226410 016332 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/escapes.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"\n" => "newline",
"\"" => "just a quote",
"\"quoted\"" => {
"quote" => 1
},
"a.b" => {
"\x{c0}" => {}
},
"backsp\b\b" => {},
"\x{c0}" => "latin capital letter A with grave"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/escapes - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/escapes - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/escapes - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/escapes.toml 0000664 0000000 0000000 00000000225 14777226410 017037 0 ustar "\n" = "newline"
"\u00c0" = "latin capital letter A with grave"
"\"" = "just a quote"
["backsp\b\b"]
["\"quoted\""]
quote = true
["a.b"."\u00c0"]
work/TOML-Tiny/t/toml-test/valid/key/numeric-dotted.t 0000664 0000000 0000000 00000004760 14777226410 017637 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/numeric-dotted.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"1" => {
"2" => bless( {
"_file" => "(eval 283)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3')->beq($got);
},
"name" => "Math::BigInt->new(\"3\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/numeric-dotted - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/numeric-dotted - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/numeric-dotted - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/numeric-dotted.toml 0000664 0000000 0000000 00000000010 14777226410 020327 0 ustar 1.2 = 3
work/TOML-Tiny/t/toml-test/valid/key/numeric.t 0000664 0000000 0000000 00000004413 14777226410 016351 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/numeric.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"1" => bless( {
"_file" => "(eval 282)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/numeric - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/numeric - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/numeric - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/numeric.toml 0000664 0000000 0000000 00000000006 14777226410 017053 0 ustar 1 = 1
work/TOML-Tiny/t/toml-test/valid/key/quoted-dots.t 0000664 0000000 0000000 00000023704 14777226410 017163 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/quoted-dots.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"plain" => bless( {
"_file" => "(eval 289)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"plain_table" => {
"plain" => bless( {
"_file" => "(eval 287)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('3')->beq($got);
},
"name" => "Math::BigInt->new(\"3\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"with.dot" => bless( {
"_file" => "(eval 288)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('4')->beq($got);
},
"name" => "Math::BigInt->new(\"4\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
},
"table" => {
"withdot" => {
"key.with.dots" => bless( {
"_file" => "(eval 285)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('6')->beq($got);
},
"name" => "Math::BigInt->new(\"6\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"plain" => bless( {
"_file" => "(eval 286)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('5')->beq($got);
},
"name" => "Math::BigInt->new(\"5\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
},
"with.dot" => bless( {
"_file" => "(eval 284)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/quoted-dots - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/quoted-dots - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/quoted-dots - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/quoted-dots.toml 0000664 0000000 0000000 00000000160 14777226410 017662 0 ustar plain = 1
"with.dot" = 2
[plain_table]
plain = 3
"with.dot" = 4
[table.withdot]
plain = 5
"key.with.dots" = 6
work/TOML-Tiny/t/toml-test/valid/key/space.t 0000664 0000000 0000000 00000004445 14777226410 016007 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/space.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a b" => bless( {
"_file" => "(eval 290)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/space - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/space - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/space - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/space.toml 0000664 0000000 0000000 00000000012 14777226410 016501 0 ustar "a b" = 1
work/TOML-Tiny/t/toml-test/valid/key/special-chars.t 0000664 0000000 0000000 00000005607 14777226410 017433 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/special-chars.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"~!\@\$^&*()_+-`1234567890[]|/?><.,;:'" => bless( {
"_file" => "(eval 291)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/special-chars - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/special-chars - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/special-chars - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/special-chars.toml 0000664 0000000 0000000 00000000052 14777226410 020130 0 ustar "~!@$^&*()_+-`1234567890[]|/?><.,;:'" = 1
work/TOML-Tiny/t/toml-test/valid/key/special-word.t 0000664 0000000 0000000 00000007014 14777226410 017300 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/key/special-word.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"false" => 0,
"inf" => bless( {
"_file" => "(eval 292)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('100000000')->beq($got);
},
"name" => "Math::BigInt->new(\"100000000\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"nan" => "ceci n'est pas un nombre",
"true" => bless( {
"_file" => "(eval 293)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
};
my $actual = from_toml($toml);
is($actual, $expected1, 'key/special-word - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'key/special-word - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'key/special-word - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/key/special-word.toml 0000664 0000000 0000000 00000000111 14777226410 017777 0 ustar false = false
true = 1
inf = 100000000
nan = "ceci n'est pas un nombre"
work/TOML-Tiny/t/toml-test/valid/newline-crlf.t 0000664 0000000 0000000 00000002432 14777226410 016503 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/newline-crlf.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"newline" => "crlf",
"os" => "DOS"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'newline-crlf - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'newline-crlf - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'newline-crlf - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/newline-crlf.toml 0000664 0000000 0000000 00000000036 14777226410 017211 0 ustar os = "DOS"
newline = "crlf"
work/TOML-Tiny/t/toml-test/valid/newline-lf.t 0000664 0000000 0000000 00000002421 14777226410 016154 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/newline-lf.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"newline" => "lf",
"os" => "unix"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'newline-lf - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'newline-lf - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'newline-lf - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/newline-lf.toml 0000664 0000000 0000000 00000000033 14777226410 016661 0 ustar os = "unix"
newline = "lf"
work/TOML-Tiny/t/toml-test/valid/spec-example-1-compact.t 0000664 0000000 0000000 00000026674 14777226410 020301 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/spec-example-1-compact.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"clients" => {
"data" => [
[
"gamma",
"delta"
],
[
bless( {
"_file" => "(eval 304)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 305)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
]
],
"hosts" => [
"alpha",
"omega"
]
},
"database" => {
"connection_max" => bless( {
"_file" => "(eval 303)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('5000')->beq($got);
},
"name" => "Math::BigInt->new(\"5000\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"enabled" => 1,
"ports" => [
bless( {
"_file" => "(eval 300)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('8001')->beq($got);
},
"name" => "Math::BigInt->new(\"8001\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 301)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('8001')->beq($got);
},
"name" => "Math::BigInt->new(\"8001\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 302)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('8002')->beq($got);
},
"name" => "Math::BigInt->new(\"8002\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
],
"server" => "192.168.1.1"
},
"owner" => {
"dob" => "1979-05-27T07:32:00-08:00",
"name" => "Lance Uppercut"
},
"servers" => {
"alpha" => {
"dc" => "eqdc10",
"ip" => "10.0.0.1"
},
"beta" => {
"dc" => "eqdc10",
"ip" => "10.0.0.2"
}
},
"title" => "TOML Example"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'spec-example-1-compact - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'spec-example-1-compact - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'spec-example-1-compact - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/spec-example-1-compact.toml 0000664 0000000 0000000 00000000570 14777226410 020774 0 ustar #Useless spaces eliminated.
title="TOML Example"
[owner]
name="Lance Uppercut"
dob=1979-05-27T07:32:00-08:00#First class dates
[database]
server="192.168.1.1"
ports=[8001,8001,8002]
connection_max=5000
enabled=true
[servers]
[servers.alpha]
ip="10.0.0.1"
dc="eqdc10"
[servers.beta]
ip="10.0.0.2"
dc="eqdc10"
[clients]
data=[["gamma","delta"],[1,2]]
hosts=[
"alpha",
"omega"
]
work/TOML-Tiny/t/toml-test/valid/spec-example-1.t 0000664 0000000 0000000 00000026634 14777226410 016651 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/spec-example-1.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"clients" => {
"data" => [
[
"gamma",
"delta"
],
[
bless( {
"_file" => "(eval 298)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('1')->beq($got);
},
"name" => "Math::BigInt->new(\"1\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 299)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('2')->beq($got);
},
"name" => "Math::BigInt->new(\"2\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
]
],
"hosts" => [
"alpha",
"omega"
]
},
"database" => {
"connection_max" => bless( {
"_file" => "(eval 297)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('5000')->beq($got);
},
"name" => "Math::BigInt->new(\"5000\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
"enabled" => 1,
"ports" => [
bless( {
"_file" => "(eval 294)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('8001')->beq($got);
},
"name" => "Math::BigInt->new(\"8001\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 295)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('8001')->beq($got);
},
"name" => "Math::BigInt->new(\"8001\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' ),
bless( {
"_file" => "(eval 296)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('8002')->beq($got);
},
"name" => "Math::BigInt->new(\"8002\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
],
"server" => "192.168.1.1"
},
"owner" => {
"dob" => "1979-05-27T07:32:00-08:00",
"name" => "Lance Uppercut"
},
"servers" => {
"alpha" => {
"dc" => "eqdc10",
"ip" => "10.0.0.1"
},
"beta" => {
"dc" => "eqdc10",
"ip" => "10.0.0.2"
}
},
"title" => "TOML Example"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'spec-example-1 - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'spec-example-1 - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'spec-example-1 - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/spec-example-1.toml 0000664 0000000 0000000 00000001057 14777226410 017351 0 ustar # This is a TOML document. Boom.
title = "TOML Example"
[owner]
name = "Lance Uppercut"
dob = 1979-05-27T07:32:00-08:00 # First class dates? Why not?
[database]
server = "192.168.1.1"
ports = [ 8001, 8001, 8002 ]
connection_max = 5000
enabled = true
[servers]
# You can indent as you please. Tabs or spaces. TOML don't care.
[servers.alpha]
ip = "10.0.0.1"
dc = "eqdc10"
[servers.beta]
ip = "10.0.0.2"
dc = "eqdc10"
[clients]
data = [ ["gamma", "delta"], [1, 2] ]
# Line breaks are OK when inside arrays
hosts = [
"alpha",
"omega"
]
work/TOML-Tiny/t/toml-test/valid/string/ 0000775 0000000 0000000 00000000000 14777226410 015236 5 ustar work/TOML-Tiny/t/toml-test/valid/string/double-quote-escape.t 0000664 0000000 0000000 00000002464 14777226410 021274 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/double-quote-escape.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"test" => "\"one\""
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/double-quote-escape - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/double-quote-escape - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/double-quote-escape - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/double-quote-escape.toml 0000664 0000000 0000000 00000000021 14777226410 021767 0 ustar test = "\"one\""
work/TOML-Tiny/t/toml-test/valid/string/empty.t 0000664 0000000 0000000 00000002367 14777226410 016571 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/empty.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"answer" => ""
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/empty - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/empty - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/empty - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/empty.toml 0000664 0000000 0000000 00000000014 14777226410 017264 0 ustar answer = ""
work/TOML-Tiny/t/toml-test/valid/string/escape-tricky.t 0000664 0000000 0000000 00000003260 14777226410 020167 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/escape-tricky.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"end_esc" => "String does not end here\" but ends here\\",
"lit_end_esc" => "String ends here\\",
"lit_multiline_end" => "There is no escape\\",
"lit_multiline_not_unicode" => "\\u007f",
"multiline_end_esc" => "When will it end? \"\"\"...\"\"\" should be here\"",
"multiline_not_unicode" => "\\u0041",
"multiline_unicode" => "\x{a0}"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/escape-tricky - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/escape-tricky - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/escape-tricky - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/escape-tricky.toml 0000664 0000000 0000000 00000000510 14777226410 020672 0 ustar end_esc = "String does not end here\" but ends here\\"
lit_end_esc = 'String ends here\'
multiline_unicode = """
\u00a0"""
multiline_not_unicode = """
\\u0041"""
multiline_end_esc = """When will it end? \"""...""\" should be here\""""
lit_multiline_not_unicode = '''
\u007f'''
lit_multiline_end = '''There is no escape\'''
work/TOML-Tiny/t/toml-test/valid/string/escaped-escape.t 0000664 0000000 0000000 00000002440 14777226410 020265 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/escaped-escape.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"answer" => "\\x64"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/escaped-escape - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/escaped-escape - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/escaped-escape - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/escaped-escape.toml 0000664 0000000 0000000 00000000021 14777226410 020766 0 ustar answer = "\\x64"
work/TOML-Tiny/t/toml-test/valid/string/escapes.t 0000664 0000000 0000000 00000004314 14777226410 017050 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/escapes.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"backslash" => "This string has a \\ backslash character.",
"backspace" => "This string has a \b backspace character.",
"carriage" => "This string has a \r carriage return character.",
"delete" => "This string has a \177 delete control code.",
"formfeed" => "This string has a \f form feed character.",
"newline" => "This string has a \n new line character.",
"notunicode1" => "This string does not have a unicode \\u escape.",
"notunicode2" => "This string does not have a unicode \\u escape.",
"notunicode3" => "This string does not have a unicode \\u0075 escape.",
"notunicode4" => "This string does not have a unicode \\u escape.",
"quote" => "This string has a \" quote character.",
"tab" => "This string has a \t tab character.",
"unitseparator" => "This string has a \37 unit separator control code."
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/escapes - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/escapes - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/escapes - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/escapes.toml 0000664 0000000 0000000 00000001403 14777226410 017554 0 ustar backspace = "This string has a \b backspace character."
tab = "This string has a \t tab character."
newline = "This string has a \n new line character."
formfeed = "This string has a \f form feed character."
carriage = "This string has a \r carriage return character."
quote = "This string has a \" quote character."
backslash = "This string has a \\ backslash character."
notunicode1 = "This string does not have a unicode \\u escape."
notunicode2 = "This string does not have a unicode \u005Cu escape."
notunicode3 = "This string does not have a unicode \\u0075 escape."
notunicode4 = "This string does not have a unicode \\\u0075 escape."
delete = "This string has a \u007F delete control code."
unitseparator = "This string has a \u001F unit separator control code."
work/TOML-Tiny/t/toml-test/valid/string/multiline-quotes.t 0000664 0000000 0000000 00000003335 14777226410 020747 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/multiline-quotes.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"lit_one" => "'one quote'",
"lit_one_space" => " 'one quote' ",
"lit_two" => "''two quotes''",
"lit_two_space" => " ''two quotes'' ",
"mismatch1" => "aaa'''bbb",
"mismatch2" => "aaa\"\"\"bbb",
"one" => "\"one quote\"",
"one_space" => " \"one quote\" ",
"two" => "\"\"two quotes\"\"",
"two_space" => " \"\"two quotes\"\" "
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/multiline-quotes - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/multiline-quotes - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/multiline-quotes - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/multiline-quotes.toml 0000664 0000000 0000000 00000000700 14777226410 021450 0 ustar # Make sure that quotes inside multiline strings are allowed, including right
# after the opening '''/""" and before the closing '''/"""
lit_one = ''''one quote''''
lit_two = '''''two quotes'''''
lit_one_space = ''' 'one quote' '''
lit_two_space = ''' ''two quotes'' '''
one = """"one quote""""
two = """""two quotes"""""
one_space = """ "one quote" """
two_space = """ ""two quotes"" """
mismatch1 = """aaa'''bbb"""
mismatch2 = '''aaa"""bbb'''
work/TOML-Tiny/t/toml-test/valid/string/nl.t 0000664 0000000 0000000 00000002630 14777226410 016035 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/nl.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"lit_nl_end" => "value\\n",
"lit_nl_mid" => "val\\nue",
"lit_nl_uni" => "val\\ue",
"nl_end" => "value\n",
"nl_mid" => "val\nue"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/nl - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/nl - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/nl - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/nl.toml 0000664 0000000 0000000 00000000163 14777226410 016544 0 ustar nl_mid = "val\nue"
nl_end = """value\n"""
lit_nl_end = '''value\n'''
lit_nl_mid = 'val\nue'
lit_nl_uni = 'val\ue'
work/TOML-Tiny/t/toml-test/valid/string/raw-multiline.t 0000664 0000000 0000000 00000002752 14777226410 020222 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/raw-multiline.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"firstnl" => "This string has a ' quote character.",
"multiline" => "This string\nhas ' a quote character\nand more than\none newline\nin it.",
"oneline" => "This string has a ' quote character."
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/raw-multiline - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/raw-multiline - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/raw-multiline - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/raw-multiline.toml 0000664 0000000 0000000 00000000303 14777226410 020720 0 ustar oneline = '''This string has a ' quote character.'''
firstnl = '''
This string has a ' quote character.'''
multiline = '''
This string
has ' a quote character
and more than
one newline
in it.'''
work/TOML-Tiny/t/toml-test/valid/string/raw.t 0000664 0000000 0000000 00000003322 14777226410 016214 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/raw.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"backslash" => "This string has a \\\\ backslash character.",
"backspace" => "This string has a \\b backspace character.",
"carriage" => "This string has a \\r carriage return character.",
"formfeed" => "This string has a \\f form feed character.",
"newline" => "This string has a \\n new line character.",
"slash" => "This string has a \\/ slash character.",
"tab" => "This string has a \\t tab character."
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/raw - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/raw - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/raw - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/raw.toml 0000664 0000000 0000000 00000000565 14777226410 016732 0 ustar backspace = 'This string has a \b backspace character.'
tab = 'This string has a \t tab character.'
newline = 'This string has a \n new line character.'
formfeed = 'This string has a \f form feed character.'
carriage = 'This string has a \r carriage return character.'
slash = 'This string has a \/ slash character.'
backslash = 'This string has a \\ backslash character.'
work/TOML-Tiny/t/toml-test/valid/string/simple.t 0000664 0000000 0000000 00000002436 14777226410 016721 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/simple.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"answer" => "You are not drinking enough whisky."
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/simple - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/simple - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/simple - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/simple.toml 0000664 0000000 0000000 00000000057 14777226410 017426 0 ustar answer = "You are not drinking enough whisky."
work/TOML-Tiny/t/toml-test/valid/string/unicode-escape.t 0000664 0000000 0000000 00000002512 14777226410 020307 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/unicode-escape.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"answer4" => "\x{3b4}",
"answer8" => "\x{3b4}"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/unicode-escape - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/unicode-escape - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/unicode-escape - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/unicode-escape.toml 0000664 0000000 0000000 00000000052 14777226410 021014 0 ustar answer4 = "\u03B4"
answer8 = "\U000003B4"
work/TOML-Tiny/t/toml-test/valid/string/unicode-literal.t 0000664 0000000 0000000 00000002446 14777226410 020511 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/unicode-literal.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"answer" => "\x{3b4}"
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/unicode-literal - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/unicode-literal - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/unicode-literal - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/unicode-literal.toml 0000664 0000000 0000000 00000000016 14777226410 021210 0 ustar answer = "δ"
work/TOML-Tiny/t/toml-test/valid/string/with-pound.t 0000664 0000000 0000000 00000002554 14777226410 017527 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/string/with-pound.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"pound" => "We see no # comments here.",
"poundcomment" => "But there are # some comments here."
};
my $actual = from_toml($toml);
is($actual, $expected1, 'string/with-pound - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'string/with-pound - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'string/with-pound - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/string/with-pound.toml 0000664 0000000 0000000 00000000161 14777226410 020227 0 ustar pound = "We see no # comments here."
poundcomment = "But there are # some comments here." # Did I # mess you up?
work/TOML-Tiny/t/toml-test/valid/table/ 0000775 0000000 0000000 00000000000 14777226410 015017 5 ustar work/TOML-Tiny/t/toml-test/valid/table/array-implicit.t 0000664 0000000 0000000 00000003042 14777226410 020131 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/array-implicit.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"albums" => {
"songs" => [
{
"name" => "Glory Days"
}
]
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/array-implicit - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/array-implicit - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/array-implicit - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/array-implicit.toml 0000664 0000000 0000000 00000000045 14777226410 020641 0 ustar [[albums.songs]]
name = "Glory Days"
work/TOML-Tiny/t/toml-test/valid/table/array-many.t 0000664 0000000 0000000 00000003456 14777226410 017274 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/array-many.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"people" => [
{
"first_name" => "Bruce",
"last_name" => "Springsteen"
},
{
"first_name" => "Eric",
"last_name" => "Clapton"
},
{
"first_name" => "Bob",
"last_name" => "Seger"
}
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/array-many - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/array-many - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/array-many - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/array-many.toml 0000664 0000000 0000000 00000000243 14777226410 017773 0 ustar [[people]]
first_name = "Bruce"
last_name = "Springsteen"
[[people]]
first_name = "Eric"
last_name = "Clapton"
[[people]]
first_name = "Bob"
last_name = "Seger"
work/TOML-Tiny/t/toml-test/valid/table/array-nest.t 0000664 0000000 0000000 00000004541 14777226410 017275 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/array-nest.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"albums" => [
{
"name" => "Born to Run",
"songs" => [
{
"name" => "Jungleland"
},
{
"name" => "Meeting Across the River"
}
]
},
{
"name" => "Born in the USA",
"songs" => [
{
"name" => "Glory Days"
},
{
"name" => "Dancing in the Dark"
}
]
}
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/array-nest - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/array-nest - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/array-nest - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/array-nest.toml 0000664 0000000 0000000 00000000406 14777226410 020001 0 ustar [[albums]]
name = "Born to Run"
[[albums.songs]]
name = "Jungleland"
[[albums.songs]]
name = "Meeting Across the River"
[[albums]]
name = "Born in the USA"
[[albums.songs]]
name = "Glory Days"
[[albums.songs]]
name = "Dancing in the Dark"
work/TOML-Tiny/t/toml-test/valid/table/array-one.t 0000664 0000000 0000000 00000002721 14777226410 017103 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/array-one.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"people" => [
{
"first_name" => "Bruce",
"last_name" => "Springsteen"
}
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/array-one - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/array-one - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/array-one - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/array-one.toml 0000664 0000000 0000000 00000000072 14777226410 017610 0 ustar [[people]]
first_name = "Bruce"
last_name = "Springsteen"
work/TOML-Tiny/t/toml-test/valid/table/array-table-array.t 0000664 0000000 0000000 00000003564 14777226410 020533 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/array-table-array.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => [
{
"b" => [
{
"c" => {
"d" => "val0"
}
},
{
"c" => {
"d" => "val1"
}
}
]
}
]
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/array-table-array - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/array-table-array - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/array-table-array - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/array-table-array.toml 0000664 0000000 0000000 00000000154 14777226410 021233 0 ustar [[a]]
[[a.b]]
[a.b.c]
d = "val0"
[[a.b]]
[a.b.c]
d = "val1"
work/TOML-Tiny/t/toml-test/valid/table/empty.t 0000664 0000000 0000000 00000002356 14777226410 016350 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/empty.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/empty - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/empty - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/empty - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/empty.toml 0000664 0000000 0000000 00000000004 14777226410 017044 0 ustar [a]
work/TOML-Tiny/t/toml-test/valid/table/keyword.t 0000664 0000000 0000000 00000002517 14777226410 016675 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/keyword.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"false" => {},
"inf" => {},
"nan" => {},
"true" => {}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/keyword - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/keyword - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/keyword - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/keyword.toml 0000664 0000000 0000000 00000000040 14777226410 017372 0 ustar [true]
[false]
[inf]
[nan]
work/TOML-Tiny/t/toml-test/valid/table/names.t 0000664 0000000 0000000 00000004153 14777226410 016312 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/names.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
" x " => {},
"b" => {
"c" => {}
},
"b.c" => {},
"d.e" => {}
},
"d" => {
"e" => {
"f" => {}
}
},
"g" => {
"h" => {
"i" => {}
}
},
"j" => {
"\x{29e}" => {
"l" => {}
}
},
"x" => {
"1" => {
"2" => {}
}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/names - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/names - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/names - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/names.toml 0000664 0000000 0000000 00000000132 14777226410 017013 0 ustar [a.b.c]
[a."b.c"]
[a.'d.e']
[a.' x ']
[ d.e.f ]
[ g . h . i ]
[ j . "Êž" . 'l' ]
[x.1.2]
work/TOML-Tiny/t/toml-test/valid/table/no-eol.t 0000664 0000000 0000000 00000002366 14777226410 016404 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/no-eol.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"table" => {}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/no-eol - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/no-eol - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/no-eol - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/no-eol.toml 0000664 0000000 0000000 00000000010 14777226410 017074 0 ustar [table]
work/TOML-Tiny/t/toml-test/valid/table/sub-empty.t 0000664 0000000 0000000 00000002467 14777226410 017142 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/sub-empty.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
"b" => {}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/sub-empty - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/sub-empty - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/sub-empty - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/sub-empty.toml 0000664 0000000 0000000 00000000012 14777226410 017632 0 ustar [a]
[a.b]
work/TOML-Tiny/t/toml-test/valid/table/whitespace.t 0000664 0000000 0000000 00000002412 14777226410 017337 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/whitespace.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"valid key" => {}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/whitespace - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/whitespace - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/whitespace - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/whitespace.toml 0000664 0000000 0000000 00000000016 14777226410 020045 0 ustar ["valid key"]
work/TOML-Tiny/t/toml-test/valid/table/with-literal-string.t 0000664 0000000 0000000 00000006177 14777226410 021130 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/with-literal-string.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
"\"b\"" => {
"c" => {
"answer" => bless( {
"_file" => "(eval 306)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/with-literal-string - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/with-literal-string - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/with-literal-string - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/with-literal-string.toml 0000664 0000000 0000000 00000000051 14777226410 021621 0 ustar ['a']
[a.'"b"']
[a.'"b"'.c]
answer = 42
work/TOML-Tiny/t/toml-test/valid/table/with-pound.t 0000664 0000000 0000000 00000005327 14777226410 017311 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/with-pound.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"key#group" => {
"answer" => bless( {
"_file" => "(eval 307)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/with-pound - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/with-pound - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/with-pound - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/with-pound.toml 0000664 0000000 0000000 00000000032 14777226410 020005 0 ustar ["key#group"]
answer = 42
work/TOML-Tiny/t/toml-test/valid/table/with-single-quotes.t 0000664 0000000 0000000 00000006047 14777226410 020763 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/with-single-quotes.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"a" => {
"b" => {
"c" => {
"answer" => bless( {
"_file" => "(eval 308)",
"_lines" => [
7
],
"code" => sub {
BEGIN {${^WARNING_BITS} = "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15\x00\x04\x40\x05\x04\x50"}
use strict;
no feature ':all';
use feature ':5.16';
require Math::BigInt;
my $got = 'Math::BigInt'->new($_);
'Math::BigInt'->new('42')->beq($got);
},
"name" => "Math::BigInt->new(\"42\")->beq(\$_)",
"operator" => "CODE(...)"
}, 'Test2::Compare::Custom' )
}
}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/with-single-quotes - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/with-single-quotes - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/with-single-quotes - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/with-single-quotes.toml 0000664 0000000 0000000 00000000045 14777226410 021463 0 ustar ['a']
[a.'b']
[a.'b'.c]
answer = 42
work/TOML-Tiny/t/toml-test/valid/table/without-super.t 0000664 0000000 0000000 00000002757 14777226410 020056 0 ustar # File automatically generated from BurntSushi/toml-test
use utf8;
use Test2::V0;
use Data::Dumper;
use Math::BigInt;
use Math::BigFloat;
use TOML::Tiny;
local $Data::Dumper::Sortkeys = 1;
local $Data::Dumper::Useqq = 1;
binmode STDIN, ':encoding(UTF-8)';
binmode STDOUT, ':encoding(UTF-8)';
open my $fh, '<', "./t/toml-test/valid/table/without-super.toml" or die $!;
binmode $fh, ':encoding(UTF-8)';
my $toml = do{ local $/; <$fh>; };
close $fh;
my $expected1 = {
"x" => {
"y" => {
"z" => {
"w" => {}
}
}
}
};
my $actual = from_toml($toml);
is($actual, $expected1, 'table/without-super - from_toml') or do{
diag 'TOML INPUT:';
diag "$toml";
diag '';
diag 'EXPECTED:';
diag Dumper($expected1);
diag '';
diag 'ACTUAL:';
diag Dumper($actual);
};
my $regenerated = to_toml $actual;
my $reparsed = eval{ scalar from_toml $regenerated };
my $error = $@;
ok(!$error, 'table/without-super - to_toml - no errors')
or diag $error;
is($reparsed, $expected1, 'table/without-super - to_toml') or do{
diag "ERROR: $error" if $error;
diag '';
diag 'PARSED FROM TEST SOURCE TOML:';
diag Dumper($actual);
diag '';
diag 'REGENERATED TOML:';
diag $regenerated;
diag '';
diag 'REPARSED FROM REGENERATED TOML:';
diag Dumper($reparsed);
};
done_testing; work/TOML-Tiny/t/toml-test/valid/table/without-super.toml 0000664 0000000 0000000 00000000170 14777226410 020551 0 ustar # [x] you
# [x.y] don't
# [x.y.z] need these
[x.y.z.w] # for this to work
[x] # defining a super-table afterwards is ok
work/TOML-Tiny/t/writer.t 0000664 0000000 0000000 00000010635 14777226410 012407 0 ustar use strict;
use warnings;
use DateTime ();
use Test2::V0;
use TOML::Tiny qw(from_toml to_toml);
use TOML::Tiny::Writer ();
my $src = do{ local $/; };
subtest basics => sub{
my $data = from_toml($src);
my $toml = to_toml($data);
my $got = from_toml($toml);
is $got, $data, 'to_toml <=> from_toml';
};
#-------------------------------------------------------------------------------
# Adapted from DateTime::Format::RFC3339.
#-------------------------------------------------------------------------------
subtest 'rfc3339 datetimes' => sub{
my $dt;
$dt = DateTime->new(year => 2002, month => 7, day => 1, hour => 13, minute => 50, second => 5, time_zone => 'UTC');
is TOML::Tiny::Writer::strftime_rfc3339($dt), '2002-07-01T13:50:05Z', 'UTC';
$dt = DateTime->new(year => 2002, month => 7, day => 1, hour => 13, minute => 50, second => 5, time_zone => 'Europe/London');
is TOML::Tiny::Writer::strftime_rfc3339($dt), '2002-07-01T13:50:05+01:00', 'positive offset';
$dt = DateTime->new(year => 2002, month => 1, day => 1, hour => 13, minute => 50, second => 5, time_zone => 'Europe/London');
is TOML::Tiny::Writer::strftime_rfc3339($dt), '2002-01-01T13:50:05+00:00', 'zero offset';
$dt = DateTime->new(year => 2002, month => 1, day => 1, hour => 13, minute => 50, second => 5, time_zone => 'America/New_York');
is TOML::Tiny::Writer::strftime_rfc3339($dt), '2002-01-01T13:50:05-05:00', 'negative offset';
$dt = DateTime->new(year => 1880, month => 1, day => 1, hour => 0, minute => 0, second => 0, time_zone => 'America/New_York');
is TOML::Tiny::Writer::strftime_rfc3339($dt), '1880-01-01T04:56:02Z', 'offset with non-integral minutes';
$dt = DateTime->new(year => 2002, month => 1, day => 1, hour => 13, minute => 50, second => 5, time_zone => 'floating');
is TOML::Tiny::Writer::strftime_rfc3339($dt), '2002-01-01T13:50:05', 'floating time zone';
};
subtest 'oddballs and regressions' => sub{
subtest 'strings that look like numbers' => sub{
my $data = {
is_inf => 'inf',
not_inf => 'to infinity and beyond',
is_nan => 'nan',
not_nan => 'no nan here',
};
is to_toml({a => 'no inf here'}), 'a="no inf here"', '"inf" present in string is string';
is to_toml({a => 'no nan here'}), 'a="no nan here"', '"nan" present in string is string';
};
subtest 'strings that contain DateTime but are not DateTime' => sub {
my $data = {
not_a_dt => 'Not a 2024-05-31T17:08:44',
};
is to_toml( $data ), 'not_a_dt="Not a 2024-05-31T17:08:44"',
$data->{not_a_dt};
};
subtest 'values which are undefined' => sub {
my $data = { deep => { in => { an => [ undef ] } } };
eval { to_toml( $data ) };
like $@, qr/found undefined value/;
};
subtest 'quoted inline table keys' => sub {
my $data = { q{foo} => [ q{bar}, { q{<=} => 33 } ] } ;
my $encoded = to_toml( $data );
my $decoded;
ok( lives { $decoded = from_toml( $encoded ) },
'decode succeeded' ) or note $@;
is ( $decoded, $data, 'round trip successful' );
};
subtest 'encoding a non-hashref' => sub {
eval { to_toml( q{} ) };
like $@, qr/must be a hashref/, 'scalar';
eval { to_toml( [] ) };
like $@, qr/must be a hashref/, 'array';
};
};
subtest 'to_toml_array' => sub{
my @to_toml = [1,2,3];
my $toml = TOML::Tiny::Writer::to_toml_array(\@to_toml, {strict => 1});
ok($toml, 'no exception in strict mode');
};
done_testing;
__DATA__
# This is a TOML document.
title = "TOML Example"
hetero_array = ["life", "universe", "everything", 42]
[owner]
name = "Tom Preston-Werner"
dob = 1979-05-27T07:32:00-08:00 # First class dates
[database]
server = "192.168.1.1"
ports = [ 8001, 8001, 8002 ]
connection_max = 5000
enabled = true
options = {"quote-keys"=false}
[servers]
# Indentation (tabs and/or spaces) is allowed but not required
[servers.alpha]
ip = "10.0.0.1"
dc = "eqdc10"
[servers.beta]
ip = "10.0.0.2"
dc = "eqdc10"
[clients]
data = [ ["gamma", "delta"], [1, 2] ]
# Line breaks are OK when inside arrays
hosts = [
"alpha",
"omega"
]
[cfg."something with a 'single-quote'".nested]
inner = "forty-one"
[cfg.'something with a "double-quote"'.nested]
inner = "forty-two"
[cfg."something with a 'single-quote' and a \"double-quote\"".nested]
inner = "forty-three"
[[products]]
name = "Hammer"
sku = 738594937
[[products]]
[[products]]
name = "Nail"
sku = 284758393
color = "gray"
work/debian/ 0000775 0000000 0000000 00000000000 14777226410 010164 5 ustar work/debian/.gitignore 0000664 0000000 0000000 00000000120 14777226410 012145 0 ustar files
*-stamp
nailing-cargo
nailing-cargo.debhelper.log
nailing-cargo.substvars
work/debian/README.source 0000664 0000000 0000000 00000000517 14777226410 012346 0 ustar nailing-cargo is maintained upstream on Salsa:
https://salsa.debian.org/iwj/nailing-cargo
The subdirectory TOML-Tiny is a fork of TOML-Tiny 0.06 from 2020,
which currently still exists because of bugs which are still present
in TOML-Tiny upstream 0.19. We are working on that.
The TOML-Tiny directory is managed with git-subtree.
work/debian/changelog 0000664 0000000 0000000 00000006112 14777226410 012036 0 ustar nailing-cargo (1.1.2) unstable; urgency=medium
* Set RUSTUP_AUTO_INSTALL along with CARGO_NET_OFFLINE.
Improves behaviour with Rustup >= 1.28. Closes: #1103157.
-- Ian Jackson Mon, 14 Apr 2025 16:43:04 +0100
nailing-cargo (1.1.1) unstable; urgency=medium
* If Cargo.nail doesn't exist, treat it as empty, and adjust docs.
Fixes gitlab nailing-cargo#4, nailing-cargo#14. [Sean Whitton]
-- Ian Jackson Fri, 28 Mar 2025 16:47:06 +0000
nailing-cargo (1.1.0) unstable; urgency=medium
Significant new features:
* New --git mode, selected automatically if .git exists.
* oot: Add support for sudo. [Sean Whitton]
* New subdir option for running in a subdirectory of the tree.
* New raw chdir option for changing directory.
Other new features and improvements:
* Add option for overriding Cargo.nail filename.
* Pass NAILINGCARGO_TOOLCHAIN.
* Support usual_toolchain in Cargo.nail.
* Fix bugs with unborn branches; make cargo init work.
* Set CARGO_NET_OFFLINE unless --online.
* Recognise `cargo audit` subcommand.
* Recognise abbreviated form of preclean option, --[no-]preclean[=...].
* Introduce pristine-git subcomd property and use it for publish.
* Make build directory regardless of cargo lock update mode.
Bugfixes:
* Fix bugs in argument parser.
* docs: Fix help message for --chdir=.
* Don't assume that `git-*' are on the caller's path. [Mark Wooding]
* Fix OOT with SSH, which was just broken. [Mark Wooding]
* Arrange to git add Cargo.lock even when it's ignored.
* Toolchain selection: fix subcmd detection.
* Transfer -E output back even if command fails.
* Always overwrite edit, so as to avoid trashing real working tree.
* Improvements to messages (including fixing some warnings).
* Cope with wider range of initial states.
* Don't try to return files with -E if not out-of-tree build.
* Improve interaction of -EE with linkfarming.
* Bugfixes relating to unusual pathnames in the build tree.
* Better handle Cargo.lock: fix if the build dir loses it.
* Fix handling of root workspace member.
Packaging and disstribution:
* Updated embedded TOML::Tiny copy to upstream v0.20;
that has the needed bug fixes (and corresponding tests).
[Assistance with upstream from Sean Whitton]
* In Debian binary package, no longer ship embedded TOML::Tiny;
instead, Depend on, and use, the system package.
(We will must ship TOML::Tiny::Faithful, which is not in TOML::Tiny
at all, having been rejected by upstream.)
* Declare this a native package, unifying upstream and Debian work.
* CI: Use the Debian Salsa CI Team pipeline.
* Upload to unstable, now the embedded code copy is gone from the .debs.
-- Ian Jackson Wed, 26 Mar 2025 11:42:40 +0000
nailing-cargo (1.0.0+git20250110.3a8b82f2-1) experimental; urgency=medium
* Initial upload to Debian.
- Uploading to experimental while we figure out the TOML::Tiny situation.
-- Ian Jackson Tue, 04 Mar 2025 01:11:18 +0000
work/debian/control 0000664 0000000 0000000 00000002105 14777226410 011565 0 ustar Source: nailing-cargo
Section: devel
Priority: optional
Maintainer: Ian Jackson
Standards-Version: 4.7.2.0
Build-Depends: debhelper-compat (= 13)
Vcs-Git: https://salsa.debian.org/iwj/nailing-cargo.git
Vcs-Browser: https://salsa.debian.org/iwj/nailing-cargo
Homepage: https://salsa.debian.org/iwj/nailing-cargo
Package: nailing-cargo
Depends: perl,
libtypes-serialiser-perl,
libtoml-tiny-perl (>= 0.20~),
libdatetime-format-iso8601-perl,
libdatetime-format-rfc3339-perl,
${misc:Depends}
Architecture: all
Description: privilege separation for Rust builds
nailing-cargo allows you to run download and run the Rust toolchain
and dependencies from crates.io, all as a separate user.
.
This can help limit the security impact of hostile or compromised crates.
It is suitable for use with upstream tooling from rustup.rs.
.
It supports Debian-shipped cargo and rustc too. (But the combination
of Debian toolchain and upstream dependencies is not the outcome of
a sensible security posture, so is not recommended by this author.)
work/debian/copyright 0000664 0000000 0000000 00000107241 14777226410 012124 0 ustar Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: nailing-cargo
Upstream-Contact:
Ian Jackson
Source: https://salsa.debian.org/iwj/nailing-cargo
Files: *
Copyright:
2019-2025 Ian Jackson
2020-2023 Mark Wooding
2024 Sean Whitton
Comment:
SPDX-License-Identifier: AGPL-3.0-or-later
.
Copyright (C) 2019 and later Ian Jackson and contributors
.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
License: AGPL-3+
This program is free software:
you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License
as published by the Free Software Foundation,
either version 3 of the License, or (at your option) any later version.
Files: TOML-Tiny/*
Copyright:
2020 Jeff Ober
2020,2024 Ian Jackson
Comment:
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
License: GPL-1+ or Artistic
The GPL version 1 can be found in /usr/share/common-licenses/GPL-1
and the Artistic Licence in /usr/share/common-licenses/Artistic.
License: AGPL-3+
GNU AFFERO GENERAL PUBLIC LICENSE
Version 3, 19 November 2007
.
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute
verbatim copies of this license document,
but changing it is not allowed.
.
Preamble
.
The GNU Affero General Public License is a free, copyleft license
for software and other kinds of works,
specifically designed to ensure cooperation with the community
in the case of network server software.
.
The licenses for most software and other practical works
are designed to take away your freedom to share and change the works.
By contrast, our General Public Licenses are intended
to guarantee your freedom to share
and change all versions of a program--
to make sure it remains free software for all its users.
.
When we speak of free software,
we are referring to freedom, not price.
Our General Public Licenses are designed
to make sure that you have the freedom
to distribute copies of free software
(and charge for them if you wish),
that you receive source code or can get it if you want it,
that you can change the software
or use pieces of it in new free programs,
and that you know you can do these things.
.
Developers that use our General Public Licenses
protect your rights with two steps:
(1) assert copyright on the software,
and (2) offer you this License
which gives you legal permission
to copy, distribute and/or modify the software.
.
A secondary benefit of defending all users' freedom is
that improvements made in alternate versions of the program,
if they receive widespread use,
become available for other developers to incorporate.
Many developers of free software are heartened and encouraged
by the resulting cooperation.
However, in the case of software used on network servers,
this result may fail to come about.
The GNU General Public License permits
making a modified version and letting the public access it on a server
without ever releasing its source code to the public.
.
The GNU Affero General Public License is designed
specifically to ensure that, in such cases,
the modified source code becomes available to the community.
It requires the operator of a network server to provide
the source code of the modified version running there
to the users of that server.
Therefore, public use of a modified version,
on a publicly accessible server,
gives the public access to the source code of the modified version.
.
An older license,
called the Affero General Public License and published by Affero,
was designed to accomplish similar goals.
This is a different license, not a version of the Affero GPL,
but Affero has released a new version of the Affero GPL
which permits relicensing under this license.
.
The precise terms and conditions
for copying, distribution and modification follow.
.
TERMS AND CONDITIONS
.
0. Definitions.
.
"This License" refers to version 3
of the GNU Affero General Public License.
.
"Copyright" also means copyright-like laws that apply
to other kinds of works, such as semiconductor masks.
.
"The Program" refers to any copyrightable work
licensed under this License.
Each licensee is addressed as "you".
"Licensees" and "recipients" may be individuals or organizations.
.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission,
other than the making of an exact copy.
The resulting work is called a "modified version" of the earlier work
or a work "based on" the earlier work.
.
A "covered work" means either the unmodified Program
or a work based on the Program.
.
To "propagate" a work means to do anything with it
that, without permission, would make you directly or secondarily liable
for infringement under applicable copyright law,
except executing it on a computer or modifying a private copy.
Propagation includes copying,
distribution (with or without modification),
making available to the public,
and in some countries other activities as well.
.
To "convey" a work means any kind of propagation
that enables other parties to make or receive copies.
Mere interaction with a user through a computer network,
with no transfer of a copy,
is not conveying.
.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes
a convenient and prominently visible feature
that (1) displays an appropriate copyright notice,
and (2) tells the user that there is no warranty for the work
(except to the extent that warranties are provided),
that licensees may convey the work under this License,
and how to view a copy of this License.
If the interface presents
a list of user commands or options, such as a menu,
a prominent item in the list meets this criterion.
.
1. Source Code.
.
The "source code" for a work means
the preferred form of the work for making modifications to it.
"Object code" means any non-source form of a work.
.
A "Standard Interface" means
an interface that either is an official standard
defined by a recognized standards body,
or, in the case of interfaces
specified for a particular programming language,
one that is widely used among developers working in that language.
.
The "System Libraries" of an executable work include anything,
other than the work as a whole,
that (a) is included in the normal form of packaging a Major Component,
but which is not part of that Major Component,
and (b) serves only
to enable use of the work with that Major Component,
or to implement a Standard Interface
for which an implementation is available to the public
in source code form.
A "Major Component", in this context, means
a major essential component (kernel, window system, and so on)
of the specific operating system (if any)
on which the executable work runs,
or a compiler used to produce the work,
or an object code interpreter used to run it.
.
The "Corresponding Source" for a work in object code form means
all the source code needed to generate, install,
and (for an executable work) run the object code
and to modify the work,
including scripts to control those activities.
However, it does not include the work's System Libraries,
or general-purpose tools or generally available free programs
which are used unmodified in performing those activities
but which are not part of the work.
For example, Corresponding Source includes
interface definition files associated with source files for the work,
and the source code for shared libraries
and dynamically linked subprograms
that the work is specifically designed to require,
such as by intimate data communication or control flow
between those subprograms and other parts of the work.
.
The Corresponding Source need not include
anything that users can regenerate automatically
from other parts of the Corresponding Source.
.
The Corresponding Source for a work in source code form
is that same work.
.
2. Basic Permissions.
.
All rights granted under this License are granted
for the term of copyright on the Program,
and are irrevocable provided the stated conditions are met.
This License explicitly affirms your unlimited permission
to run the unmodified Program.
The output from running a covered work is covered by this License
only if the output, given its content, constitutes a covered work.
This License acknowledges your rights of fair use
or other equivalent, as provided by copyright law.
.
You may make, run and propagate
covered works that you do not convey,
without conditions
so long as your license otherwise remains in force.
You may convey covered works to others
for the sole purpose of having them
make modifications exclusively for you,
or provide you with facilities for running those works,
provided that you comply with the terms of this License
in conveying all material
for which you do not control copyright.
Those thus making or running the covered works for you
must do so exclusively on your behalf,
under your direction and control,
on terms that prohibit them from making any copies
of your copyrighted material
outside their relationship with you.
.
Conveying under any other circumstances is permitted
solely under the conditions stated below.
Sublicensing is not allowed;
section 10 makes it unnecessary.
.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
.
No covered work shall be deemed
part of an effective technological measure
under any applicable law fulfilling obligations
under article 11 of the WIPO copyright treaty
adopted on 20 December 1996,
or similar laws prohibiting or restricting
circumvention of such measures.
.
When you convey a covered work,
you waive any legal power
to forbid circumvention of technological measures
to the extent such circumvention is effected
by exercising rights under this License
with respect to the covered work,
and you disclaim any intention
to limit operation or modification of the work
as a means of enforcing, against the work's users,
your or third parties' legal rights
to forbid circumvention of technological measures.
.
4. Conveying Verbatim Copies.
.
You may convey verbatim copies of the Program's source code
as you receive it, in any medium,
provided that you conspicuously and appropriately publish
on each copy an appropriate copyright notice;
keep intact all notices
stating that this License and any non-permissive terms
added in accord with section 7 apply to the code;
keep intact all notices
of the absence of any warranty;
and give all recipients a copy of this License
along with the Program.
.
You may charge any price or no price
for each copy that you convey,
and you may offer support or warranty protection for a fee.
.
5. Conveying Modified Source Versions.
.
You may convey a work based on the Program,
or the modifications to produce it from the Program,
in the form of source code
under the terms of section 4,
provided that you also meet all of these conditions:
.
a) The work must carry prominent notices
stating that you modified it, and giving a relevant date.
.
b) The work must carry prominent notices
stating that it is released under this License
and any conditions added under section 7.
This requirement modifies
the requirement in section 4 to "keep intact all notices".
.
c) You must license the entire work, as a whole, under this License
to anyone who comes into possession of a copy.
This License will therefore apply,
along with any applicable section 7 additional terms,
to the whole of the work, and all its parts,
regardless of how they are packaged.
This License gives no permission
to license the work in any other way,
but it does not invalidate such permission
if you have separately received it.
.
d) If the work has interactive user interfaces,
each must display Appropriate Legal Notices;
however, if the Program has interactive interfaces
that do not display Appropriate Legal Notices,
your work need not make them do so.
.
A compilation of a covered work
with other separate and independent works,
which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium,
is called an "aggregate"
if the compilation and its resulting copyright are not used
to limit the access or legal rights of the compilation's users
beyond what the individual works permit.
Inclusion of a covered work in an aggregate
does not cause this License to apply
to the other parts of the aggregate.
.
6. Conveying Non-Source Forms.
.
You may convey a covered work in object code form
under the terms of sections 4 and 5,
provided that you also convey the machine-readable Corresponding Source
under the terms of this License,
in one of these ways:
.
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium),
accompanied by the Corresponding Source
fixed on a durable physical medium
customarily used for software interchange.
.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium),
accompanied by a written offer,
valid for at least three years
and valid for as long as you offer spare parts or customer support
for that product model,
to give anyone who possesses the object code
either (1) a copy of the Corresponding Source
for all the software in the product that is covered by this License,
on a durable physical medium
customarily used for software interchange,
for a price no more than your reasonable cost
of physically performing this conveying of source,
or (2) access to copy the Corresponding Source
from a network server at no charge.
.
c) Convey individual copies of the object code
with a copy of the written offer to provide the Corresponding Source.
This alternative is allowed only occasionally and noncommercially,
and only if you received the object code with such an offer,
in accord with subsection 6b.
.
d) Convey the object code by offering access from a designated place
(gratis or for a charge),
and offer equivalent access to the Corresponding Source
in the same way through the same place at no further charge.
You need not require recipients to copy the Corresponding Source
along with the object code.
If the place to copy the object code is a network server,
the Corresponding Source may be on a different server
(operated by you or a third party)
that supports equivalent copying facilities,
provided you maintain clear directions next to the object code
saying where to find the Corresponding Source.
Regardless of what server hosts the Corresponding Source,
you remain obligated to ensure that it is available
for as long as needed to satisfy these requirements.
.
e) Convey the object code using peer-to-peer transmission,
provided you inform other peers
where the object code and Corresponding Source of the work
are being offered to the general public
at no charge under subsection 6d.
.
A separable portion of the object code,
whose source code is excluded
from the Corresponding Source as a System Library,
need not be included in conveying the object code work.
.
A "User Product" is either (1) a "consumer product",
which means any tangible personal property
which is normally used for personal, family, or household purposes,
or (2) anything designed or sold for incorporation into a dwelling.
In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.
For a particular product received by a particular user,
"normally used" refers to a typical or common use
of that class of product,
regardless of the status of the particular user
or of the way in which the particular user actually uses,
or expects or is expected to use,
the product.
A product is a consumer product
regardless of whether the product has substantial commercial,
industrial or non-consumer uses,
unless such uses represent the only significant mode
of use of the product.
.
"Installation Information" for a User Product means
any methods, procedures, authorization keys, or other information
required to install and execute modified versions of a covered work
in that User Product
from a modified version of its Corresponding Source.
The information must suffice to ensure
that the continued functioning of the modified object code
is in no case prevented or interfered with
solely because modification has been made.
.
If you convey an object code work under this section
in, or with, or specifically for use in, a User Product,
and the conveying occurs as part of a transaction
in which the right of possession and use of the User Product
is transferred to the recipient
in perpetuity or for a fixed term
(regardless of how the transaction is characterized),
the Corresponding Source conveyed under this section must
be accompanied by the Installation Information.
But this requirement does not apply
if neither you nor any third party retains
the ability to install modified object code on the User Product
(for example, the work has been installed in ROM).
.
The requirement to provide Installation Information does not include
a requirement to continue to provide support service, warranty,
or updates for a work
that has been modified or installed by the recipient,
or for the User Product in which it has been modified or installed.
Access to a network may be denied
when the modification itself materially and adversely affects
the operation of the network
or violates the rules and protocols
for communication across the network.
.
Corresponding Source conveyed,
and Installation Information provided,
in accord with this section must be in a format
that is publicly documented
(and with an implementation available to the public
in source code form),
and must require no special password or key
for unpacking, reading or copying.
.
7. Additional Terms.
.
"Additional permissions" are terms
that supplement the terms of this License
by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program
shall be treated as though they were included in this License,
to the extent that they are valid under applicable law.
If additional permissions apply only to part of the Program,
that part may be used separately under those permissions,
but the entire Program remains governed by this License
without regard to the additional permissions.
.
When you convey a copy of a covered work,
you may at your option remove any additional permissions
from that copy, or from any part of it.
(Additional permissions may be written to require their own removal
in certain cases when you modify the work.)
You may place additional permissions on material,
added by you to a covered work,
for which you have or can give appropriate copyright permission.
.
Notwithstanding any other provision of this License,
for material you add to a covered work, you may
(if authorized by the copyright holders of that material)
supplement the terms of this License with terms:
.
a) Disclaiming warranty or limiting liability
differently from the terms of sections 15 and 16 of this License; or
.
b) Requiring preservation
of specified reasonable legal notices
or author attributions in that material
or in the Appropriate Legal Notices
displayed by works containing it; or
.
c) Prohibiting misrepresentation of the origin of that material,
or requiring that modified versions of such material be marked
in reasonable ways as different from the original version; or
.
d) Limiting the use for publicity purposes
of names of licensors or authors of the material; or
.
e) Declining to grant rights under trademark law
for use of some trade names, trademarks, or service marks; or
.
f) Requiring indemnification
of licensors and authors of that material
by anyone who conveys the material (or modified versions of it)
with contractual assumptions of liability to the recipient,
for any liability that these contractual assumptions directly impose
on those licensors and authors.
.
All other non-permissive additional terms
are considered "further restrictions"
within the meaning of section 10.
If the Program as you received it, or any part of it,
contains a notice stating that it is governed by this License
along with a term that is a further restriction,
you may remove that term.
If a license document contains a further restriction
but permits relicensing or conveying under this License,
you may add to a covered work material governed
by the terms of that license document,
provided that the further restriction does not survive
such relicensing or conveying.
.
If you add terms to a covered work in accord with this section,
you must place, in the relevant source files, a statement
of the additional terms that apply to those files,
or a notice indicating where to find the applicable terms.
.
Additional terms, permissive or non-permissive, may be stated
in the form of a separately written license,
or stated as exceptions;
the above requirements apply either way.
.
8. Termination.
.
You may not propagate or modify a covered work
except as expressly provided under this License.
Any attempt otherwise to propagate or modify it is void,
and will automatically terminate your rights under this License
(including any patent licenses granted
under the third paragraph of section 11).
.
However, if you cease all violation of this License,
then your license from a particular copyright holder is reinstated
(a) provisionally,
unless and until the copyright holder explicitly and finally
terminates your license,
and (b) permanently,
if the copyright holder fails to notify you of the violation
by some reasonable means prior to 60 days after the cessation.
.
Moreover, your license from a particular copyright holder
is reinstated permanently
if the copyright holder notifies you
of the violation by some reasonable means,
this is the first time you have received notice
of violation of this License (for any work)
from that copyright holder,
and you cure the violation
prior to 30 days after your receipt of the notice.
.
Termination of your rights under this section does not terminate
the licenses of parties who have received copies or rights
from you under this License.
If your rights have been terminated and not permanently reinstated,
you do not qualify to receive new licenses for the same material
under section 10.
.
9. Acceptance Not Required for Having Copies.
.
You are not required to accept this License
in order to receive or run a copy of the Program.
Ancillary propagation
of a covered work occurring solely as a consequence
of using peer-to-peer transmission to receive a copy
likewise does not require acceptance.
However, nothing other than this License grants you
permission to propagate or modify any covered work.
These actions infringe copyright
if you do not accept this License.
Therefore, by modifying or propagating a covered work,
you indicate your acceptance of this License to do so.
.
10. Automatic Licensing of Downstream Recipients.
.
Each time you convey a covered work,
the recipient automatically receives
a license from the original licensors,
to run, modify and propagate that work,
subject to this License.
You are not responsible for enforcing compliance by third parties
with this License.
.
An "entity transaction" is a transaction transferring control
of an organization, or substantially all assets of one,
or subdividing an organization,
or merging organizations.
If propagation of a covered work results from an entity transaction,
each party to that transaction who receives a copy of the work
also receives whatever licenses to the work
the party's predecessor in interest had or could give
under the previous paragraph,
plus a right to possession of the Corresponding Source of the work
from the predecessor in interest,
if the predecessor has it or can get it with reasonable efforts.
.
You may not impose any further restrictions
on the exercise of the rights granted or affirmed under this License.
For example, you may not impose
a license fee, royalty, or other charge
for exercise of rights granted under this License,
and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit)
alleging that any patent claim is infringed
by making, using, selling, offering for sale, or importing
the Program or any portion of it.
.
11. Patents.
.
A "contributor" is a copyright holder
who authorizes use under this License of the Program
or a work on which the Program is based.
The work thus licensed is called
the contributor's "contributor version".
.
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor,
whether already acquired or hereafter acquired,
that would be infringed by some manner,
permitted by this License,
of making, using, or selling its contributor version,
but do not include claims
that would be infringed only as a consequence
of further modification of the contributor version.
For purposes of this definition, "control" includes the right
to grant patent sublicenses in a manner
consistent with the requirements of this License.
.
Each contributor grants you
a non-exclusive, worldwide, royalty-free patent license
under the contributor's essential patent claims,
to make, use, sell, offer for sale, import and otherwise run, modify
and propagate the contents of its contributor version.
.
In the following three paragraphs,
a "patent license" is any express agreement or commitment,
however denominated, not to enforce a patent
(such as an express permission to practice a patent
or covenant not to sue for patent infringement).
To "grant" such a patent license to a party means
to make such an agreement or commitment
not to enforce a patent against the party.
.
If you convey a covered work,
knowingly relying on a patent license,
and the Corresponding Source of the work is not available
for anyone to copy,
free of charge and under the terms of this License,
through a publicly available network server
or other readily accessible means,
then you must either
(1) cause the Corresponding Source to be so available,
or (2) arrange to deprive yourself of the benefit
of the patent license for this particular work,
or (3) arrange,
in a manner consistent with the requirements of this License,
to extend the patent license to downstream recipients.
"Knowingly relying" means
you have actual knowledge that, but for the patent license,
your conveying the covered work in a country,
or your recipient's use of the covered work in a country,
would infringe one or more identifiable patents in that country
that you have reason to believe are valid.
.
If, pursuant to or in connection
with a single transaction or arrangement,
you convey, or propagate by procuring conveyance of, a covered work,
and grant a patent license to some of the parties
receiving the covered work authorizing them
to use, propagate, modify or convey a specific copy of the covered work,
then the patent license you grant is automatically extended
to all recipients of the covered work and works based on it.
.
A patent license is "discriminatory"
if it does not include within the scope of its coverage,
prohibits the exercise of, or is conditioned on
the non-exercise of one or more of the rights
that are specifically granted under this License.
You may not convey a covered work
if you are a party to an arrangement with a third party
that is in the business of distributing software,
under which you make payment to the third party
based on the extent of your activity of conveying the work,
and under which the third party grants,
to any of the parties who would receive the covered work from you,
a discriminatory patent license
(a) in connection with copies of the covered work conveyed by you
(or copies made from those copies),
or (b) primarily for and in connection with specific products
or compilations that contain the covered work,
unless you entered into that arrangement,
or that patent license was granted,
prior to 28 March 2007.
.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement
that may otherwise be available to you under applicable patent law.
.
12. No Surrender of Others' Freedom.
.
If conditions are imposed on you
(whether by court order, agreement or otherwise)
that contradict the conditions of this License,
they do not excuse you from the conditions of this License.
If you cannot convey a covered work
so as to satisfy simultaneously your obligations
under this License and any other pertinent obligations,
then as a consequence you may not convey it at all.
For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those
to whom you convey the Program,
the only way you could satisfy both those terms and this License
would be to refrain entirely from conveying the Program.
.
13. Remote Network Interaction;
Use with the GNU General Public License.
.
Notwithstanding any other provision of this License,
if you modify the Program,
your modified version must prominently offer
all users interacting with it remotely through a computer network
(if your version supports such interaction)
an opportunity to receive the Corresponding Source of your version
by providing access to the Corresponding Source
from a network server at no charge,
through some standard or customary means
of facilitating copying of software.
This Corresponding Source shall include
the Corresponding Source for any work covered
by version 3 of the GNU General Public License
that is incorporated pursuant to the following paragraph.
.
Notwithstanding any other provision of this License,
you have permission to link or combine any covered work
with a work licensed
under version 3 of the GNU General Public License
into a single combined work, and to convey the resulting work.
The terms of this License will continue to apply
to the part which is the covered work,
but the work with which it is combined will remain governed
by version 3 of the GNU General Public License.
.
14. Revised Versions of this License.
.
The Free Software Foundation may publish revised and/or new versions
of the GNU Affero General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
.
Each version is given a distinguishing version number.
If the Program specifies that a certain numbered version
of the GNU Affero General Public License
"or any later version" applies to it,
you have the option of following the terms and conditions
either of that numbered version
or of any later version
published by the Free Software Foundation.
If the Program does not specify a version number
of the GNU Affero General Public License,
you may choose any version ever
published by the Free Software Foundation.
.
If the Program specifies that a proxy can decide
which future versions
of the GNU Affero General Public License can be used,
that proxy's public statement of acceptance of a version
permanently authorizes you to choose that version for the Program.
.
Later license versions may give you
additional or different permissions.
However, no additional obligations are imposed
on any author or copyright holder
as a result of your choosing to follow a later version.
.
15. Disclaimer of Warranty.
.
THERE IS NO WARRANTY FOR THE PROGRAM,
TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING
THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
WITHOUT WARRANTY OF ANY KIND,
EITHER EXPRESSED OR IMPLIED,
INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.
THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.
SHOULD THE PROGRAM PROVE DEFECTIVE,
YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
.
16. Limitation of Liability.
.
IN NO EVENT
UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY
WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE,
BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM
(INCLUDING BUT NOT LIMITED TO
LOSS OF DATA OR DATA BEING RENDERED INACCURATE
OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES
OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED
OF THE POSSIBILITY OF SUCH DAMAGES.
.
17. Interpretation of Sections 15 and 16.
.
If the disclaimer
of warranty and limitation of liability provided above
cannot be given local legal effect according to their terms,
reviewing courts shall apply local law
that most closely approximates an absolute waiver
of all civil liability in connection with the Program,
unless a warranty or assumption of liability accompanies
a copy of the Program in return for a fee.
.
END OF TERMS AND CONDITIONS
.
How to Apply These Terms to Your New Programs
.
If you develop a new program,
and you want it to be of the greatest possible use to the public,
the best way to achieve this is to make it free software
which everyone can redistribute and change under these terms.
.
To do so, attach the following notices to the program.
It is safest to attach them to the start of each source file
to most effectively state the exclusion of warranty;
and each file should have at least the "copyright" line
and a pointer to where the full notice is found.
.
Copyright (C)
.
This program is free software:
you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License
as published by the Free Software Foundation,
either version 3 of the License, or (at your option) any later version.
.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY;
without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Affero General Public License for more details.
.
You should have received
a copy of the GNU Affero General Public License
along with this program.
If not, see .
.
Also add information on how to contact you
by electronic and paper mail.
.
If your software can interact with users
remotely through a computer network,
you should also make sure that it provides
a way for users to get its source.
For example, if your program is a web application,
its interface could display a "Source" link
that leads users to an archive of the code.
There are many ways you could offer source,
and different solutions will be better for different programs;
see section 13 for the specific requirements.
.
You should also get your employer (if you work as a programmer)
or school, if any, to sign
a "copyright disclaimer" for the program, if necessary.
For more information on this,
and how to apply and follow the GNU AGPL,
see .
work/debian/dirs 0000664 0000000 0000000 00000000010 14777226410 011037 0 ustar usr/bin
work/debian/install 0000664 0000000 0000000 00000000241 14777226410 011552 0 ustar nailing-cargo usr/share/nailing-cargo
TOML-Tiny/lib//TOML/Tiny/Faithful.pm usr/share/nailing-cargo/TOML-Tiny/lib/TOML/Tiny
README.md usr/share/doc/nailing-cargo
work/debian/links 0000664 0000000 0000000 00000000110 14777226410 011217 0 ustar usr/share/doc/nailing-cargo/README.md usr/share/nailing-cargo/README.md
work/debian/rules 0000775 0000000 0000000 00000000766 14777226410 011255 0 ustar #! /usr/bin/make -f
%:
dh "$@"
# nailing-cargo expects to find its TOML::Tiny fork, and README.md via $0.
# This is pretty nasty, but we hope to get rid of the fork entirely,
# which will make the TOML::Tinyh part redundant. This works and will do.
execute_after_dh_install:
install -m755 debian/wrapper debian/nailing-cargo/usr/bin/nailing-cargo
# nailing-cargo's --doc option doesn't work with a compressed README
# The file is only 12k, anyway.
override_dh_compress:
dh_compress -X README.md
work/debian/source/ 0000775 0000000 0000000 00000000000 14777226410 011464 5 ustar work/debian/source/format 0000664 0000000 0000000 00000000004 14777226410 012671 0 ustar 1.0
work/debian/source.lintian-overrides 0000664 0000000 0000000 00000000212 14777226410 015037 0 ustar # lintian hates non-native versions with native packaging,
# even though this is fine (by TC decision)
malformed-debian-changelog-version
work/debian/tests/ 0000775 0000000 0000000 00000000000 14777226410 011326 5 ustar work/debian/tests/basic 0000775 0000000 0000000 00000000254 14777226410 012336 0 ustar #!/bin/bash
set -e
cd "$AUTOPKGTEST_TMP"
HOME=$(pwd)
touch Cargo.nail
mkdir x
cd x
nailing-cargo -EE init --vcs none pkg
mv pkg ..
cd ../pkg
find -ls
nailing-cargo -u run
work/debian/tests/control 0000664 0000000 0000000 00000000101 14777226410 012721 0 ustar Tests: basic
Depends: @, cargo, rustc
Restrictions: allow-stderr
work/debian/wrapper 0000775 0000000 0000000 00000000102 14777226410 011563 0 ustar #!/bin/sh
set -e
exec /usr/share/nailing-cargo/nailing-cargo "$@"
work/markdown-toc-filter 0000775 0000000 0000000 00000001272 14777226410 012562 0 ustar #!/usr/bin/perl -wn
use strict;
use autodie;
our (@doc, @toc);
our $last;
sub scanline () {
if (m/^-+$/ || m/^=+$/) {
my $lev = $& =~ m/^=/ ? ' ' : ' ';
my $href = $last;
$href =~ y/ A-Z/-a-z/;
$href =~ y/-._a-z//cd;
my $text = $last;
$text = 'Introduction' if $. == 2;
push @toc, "${lev}* [$text](#$href)\n";
}
$last = $_;
chomp $last;
}
if (1..(m/^[A-Z]/ && m/table of contents/i)) {
# before TOC
scanline();
print;
} elsif (m/^\w/..0) {
# after TOC
push @doc, $_;
scanline();
} else {
# in TOC
print if m/^===|^---/;
scanline();
}
END {
print <
END
print @doc;
}
work/nailing-cargo 0000775 0000000 0000000 00000130432 14777226410 011405 0 ustar #!/usr/bin/perl -w
# nailing-cargo: wrapper to use unpublished local crates
# SPDX-License-Identifier: AGPL-3.0-or-later
our $usage = <<'END';
usages:
nailing-cargo [--] ...
nailing-cargo --- [--] ...
nailing-cargo --- [--] ...
options:
-v Increase verbosity. (Default is 1)
-q Set verbosity to 0
-D Increase amount of debugging dump.
-n "No action": stop after writing Cargo.toml.nailing~
everywhere, and do not run any build command
-c Do add cargo command line options } default is add if
-C Do not add cargo command line options } command is cargo
-o --online -O --offline
-u --cargo-lock-update -U --no-cargo-lock-update
-T --target= Specify target architecture
-h --help Print this message
--doc --man --manual Display complete manual (in w3m)
--leave-nailed Leave the nailed Cargo.toml in place
-E | --edits-sources Allow source edits (repeat: file creation)
-f | --force Override some warnings
--linkfarm[=no|shallow|git|full] (default varies, usually "no")
--[no-]git Instead of linkfarming, use git
--just-linkfarm | --clean-linkfarm | --keep-linkfarm (default is keep)
--just-git Implies --git, only does the update
--[no-]preclean[=no|src|full] (default is no)
--just-run Run the command, don't do cargo/git stuff
--subdir=DIR Relative cd, right at the beginning
--chdir=DIR Relative cd, just before running command
--no-nail Do not nail, just run the command.
--no-cargo-lock-manip Do not manipulate Cargo.lock.
--no-concurrency-lock Do not take the concurrency lock.
-s Treat command as `cargo `
--subcommand-props=,... Override command props (see docs)
END
our $self;
use strict;
use POSIX;
use Types::Serialiser;
use File::Glob qw(bsd_glob GLOB_ERR GLOB_BRACE GLOB_NOMAGIC);
use Cwd qw(realpath);
our $base_path;
our %archmap = (
RPI => 'arm-unknown-linux-gnueabihf',
WASM => 'wasm32-unknown-unknown',
);
BEGIN {
$self = $0; $self =~ s{^.*/(?=.)}{};
my $deref = $0;
our $base_path;
while ($deref =~ m{^/}) {
my $link = readlink $deref;
if (!defined $link) {
$! == EINVAL
or die "$self: checking our script location $deref: $!\n";
$deref =~ s{/[^/]+$}{}
or die "$self: unexpected script path: $deref\n";
$base_path = $deref;
unshift @INC, $deref."/TOML-Tiny/lib";
last;
}
last if $link !~ m{^/};
$deref = $link;
}
}
use Fcntl qw(LOCK_EX);
use File::Compare;
use TOML::Tiny::Faithful;
our ($src_absdir, $worksphere, $subdir);
our $lockfile = "../.nailing-cargo.lock";
our $nailfile = "../Cargo.nail";
our @args_preface;
our $arg_toolchain;
our $cargo_subcmd;
our $command_is_cargo;
our $alt_cargo_lock;
our $cargo_lock_update;
our $pass_options;
our $online;
our $just_linkfarm;
our $edits_sources=0;
our $leave_nailed;
our $oot_clean;
our $oot_preclean;
our $do_nail=1;
our $do_cargo_lock=1;
our $do_lock=1;
our $linkfarm_depth; # ignored if $gitxfer
our $chdir=undef;
our $clisubdir='';
our $gitxfer; # --git (not the same as --linkfarm=git, see docs)
#
our %subcmd_props = (
# build (default) =>[qw( )],
audit =>[qw( !locked linkfarm-shallow )],
fetch =>[qw( online !target-dir )],
fmt =>[qw( !locked !target !offline !target-dir edits )],
'generate-lockfile'=>[qw( lock-update !target !target-dir )],
init =>[qw( creates )],
metadata =>[qw( !target-dir )],
miri =>[qw( !locked !offline linkfarm-shallow )],
publish =>[qw( !offline pristine-git )],
update =>[qw( lock-update !target online )],
upgrades =>[qw( !locked !target-dir )],
);
our @subcmd_xprops = qw(!manifest-path);
our @configs;
our $verbose=1;
our $force=0;
our $forced=0;
our ($noact,$dump);
our $target;
sub print_usage () {
print $usage or die $!;
exit 0;
}
sub show_manual () {
my $manual = ($base_path // '.').'/README.md';
stat $manual or die "$self: manual not found at $manual: $!\n";;
exec 'sh','-ec', 'pandoc -- "$1" 2>&1 | w3m -T text/html', '--', $manual;
die "$self: exec sh failed: $!";
}
sub forceable_warning ($) {
my ($m) = @_;
print STDERR "$self: *WARNING*: $m\n";
if ($force) {
print STDERR "$self: continuing because of --force...\n" unless $forced++;
return;
} else {
die "$self: Stopping due to warning (override with -f | --force)\n";
}
}
sub shell_quotify (@) {
return join ' ', map {
if (m/\W/) {
s/\'/\'\\'\'/g;
$_ = "'$_'";
}
$_
} @_;
}
sub read_or_enoent ($) {
my ($fn) = @_;
if (!open R, '<', $fn) {
return undef if $!==ENOENT;
die "$self: open $fn: $!\n";
}
local ($/) = undef;
my ($r) = // die "$self: read $fn: $!\n";
$r;
}
sub stat_exists ($$) {
my ($fn, $what) = @_;
if (stat $fn) { return 1; }
$!==ENOENT or die "$self: stat $what: $fn: $!\n";
return 0;
}
sub subcmd_p ($) {
print STDERR " subcmd_p ".(join ' ', keys %$cargo_subcmd)." | @_\n"
if $dump;
$cargo_subcmd->{$_[0]}
}
sub toml_or_enoent ($$) {
my ($f,$what) = @_;
my $toml = read_or_enoent($f) // return;
print STDERR "Read TOML from $f\n" if $dump;
my ($v,$e) = from_toml($toml);
if (!defined $v) {
chomp $e;
die "$self: parse TOML: $what: $f: $e\n";
}
die "$e ?" if length $e;
$v;
}
sub load1config ($) {
my ($f) = @_;
my $toml = toml_or_enoent($f, "config file");
push @configs, $toml if defined $toml;
}
sub loadconfigs () {
my $dotfile = ".nailing-cargo.toml";
load1config("../Nailing-Cargo.toml");
load1config($dotfile);
load1config("$ENV{HOME}/$dotfile") if defined $ENV{HOME};
load1config("/etc/nailing-cargo/cfg.toml");
}
sub unlink_or_enoent ($) { unlink $_[0] or $!==ENOENT; }
sub same_file ($$) {
my ($x,$y) = @_;
"@$x[0..5]" eq "@$y[0..5]";
}
sub takelock () {
return unless $do_lock;
for (;;) {
open LOCK, ">", $lockfile or die "$self: open/create $lockfile: $!\n";
flock LOCK, LOCK_EX or die "$self: lock $lockfile: $!\n";
my @fstat = stat LOCK or die "$self: fstat: $!\n";
my @stat = stat $lockfile;
if (!@stat) {
next if $! == ENOENT;
die "$self: stat $lockfile: $!\n";
}
last if same_file(\@fstat,\@stat);
}
}
sub unlock () {
unlink $lockfile or die "$self: removing lockfile: $!\n";
}
our $nail;
sub badcfg {
my $m = pop @_;
$" = '.';
die "$self: config key \`@_': $m\n";
}
sub cfg_uc {
foreach my $cfg (@configs) {
my $v = $cfg;
foreach my $k (@_) {
last unless defined $v;
ref($v) eq 'HASH' or badcfg @_, "parent key \`$k' is not a hash";
$v = $v->{$k};
}
return $v if defined $v;
}
return undef;
}
sub cfge {
my $exp = shift @_;
my $v = cfg_uc @_;
my $got = ref($v) || 'scalar';
return $v if !defined($v) || $got eq $exp;
badcfg @_, "found \L$got\E, expected \L$exp\E";
# ^ toml doesn't make refs to scalars, so this is unambiguous
}
sub cfgn {
my $exp = shift @_;
(cfge $exp, @_) // badcfg @_, "missing";
}
sub cfgs { cfge 'scalar', @_ }
sub cfgsn { cfgn 'scalar', @_ }
sub cfg_bool {
my $v = cfg_uc @_;
return $v if !defined($v) || Types::Serialiser::is_bool $v;
badcfg @_, "expected boolean";
}
sub cfgn_list {
my $l = cfge 'ARRAY', @_;
foreach my $x (@$l) {
!ref $x or badcfg @_, "list contains non-scalar element";
}
@$l
}
sub readnail () {
if (open N, '<', $nailfile) {
local ($/) = undef;
my $toml = // die "$self: read $nailfile: $!";
my $transformed;
if ($toml !~ m{^\s*\[/}m &&
$toml !~ m{^[^\n\#]*\=}m &&
# old non-toml syntax
$toml =~ s{^[ \t]*([-_0-9a-z]+)[ \t]+(\S+)[ \t]*$}{$1 = \"$2\"}mig) {
$toml =~ s{^}{[packages\]\n};
my @sd;
$toml =~ s{^[ \t]*\-[ \t]*\=[ \t]*(\"[-_0-9a-z]+\"\n?)$}{
push @sd, $1; '';
}mige;
$toml = "subdirs = [\n".(join '', map { "$_\n" } @sd)."]\n".$toml;
$transformed = 1;
}
my $e;
($nail,$e) = from_toml($toml);
if (!defined $nail) {
if ($transformed) {
$toml =~ s/^/ /mg;
print STDERR "$self: $nailfile transformed into TOML:\n$toml\n";
}
$/="\n"; chomp $e;
die "$self: parse $nailfile: $e\n";
}
die "$e ?" if length $e;
} elsif ($! != ENOENT) {
die "$self: open $nailfile: $!\n";
}
$nail->{subdirs} //= [ ];
if (!ref $nail->{subdirs}) {
$nail->{subdirs} = [
grep /^[^\#]/,
map { s/^\s+//; s/\s+$//; $_; }
split m{\n},
$nail->{subdirs}
];
}
unshift @configs, $nail;
}
sub get_dependency_tables ($) {
my ($toml) = @_;
my @keys = qw(dependencies build-dependencies dev-dependencies);
my @r;
my $process = sub {
my ($node) = @_;
foreach my $k (@keys) {
my $deps = $node->{$k};
push @r, $deps if $deps;
}
};
$process->($toml);
foreach my $target_node (values %{ $toml->{target} // { } }) {
$process->($target_node);
}
@r;
}
our @alt_cargo_lock_stat;
sub consider_alt_cargo_lock () {
my @ck = qw(alt_cargo_lock);
# User should *either* have Cargo.lock in .gitignore,
# or expect to commit Cargo.lock.example ($alt_cargo_lock)
return unless $do_cargo_lock;
$alt_cargo_lock = (cfg_uc @ck);
my $force = 0;
if (defined($alt_cargo_lock) && ref($alt_cargo_lock) eq 'HASH') {
$force = cfg_bool qw(alt_cargo_lock force);
my @ck = qw(alt_cargo_lock file);
$alt_cargo_lock = cfg_uc @ck;
}
$alt_cargo_lock //= Types::Serialiser::true;
if (Types::Serialiser::is_bool $alt_cargo_lock) {
if (!$alt_cargo_lock) { $alt_cargo_lock = undef; return; }
$alt_cargo_lock = 'Cargo.lock.example';
}
if (ref($alt_cargo_lock) || $alt_cargo_lock =~ m{/}) {
badcfg @ck, "expected boolean, or leafname";
}
my $check = $alt_cargo_lock;
$check = "$chdir/$check" if length $chdir;
if (!stat_exists $check, "alt_cargo_lock") {
$alt_cargo_lock = undef unless $force;
return;
}
@alt_cargo_lock_stat = stat _;
}
our $oot_dir; # oot.dir or "Build"
our $oot_absdir;
sub consider_oot () {
$oot_dir = cfgs qw(oot dir);
my $use = cfgs qw(oot use);
unless (defined($oot_dir) || defined($use) ||
defined(cfg_uc qw(oot user))) {
return;
}
if (($use//'') eq 'disable') {
$oot_dir = undef;
return;
}
# OOT
$oot_clean //= cfg_bool qw(oot clean);
$oot_dir //= 'Build';
$oot_absdir = ($oot_dir !~ m{^/} ? "$worksphere/" : ""). $oot_dir;
if (subcmd_p('pristine-git')) {
$gitxfer = 1 if stat_exists('.git', 'source .git directory');
$oot_preclean //= 'full';
}
}
our %manifests;
our %packagemap;
our %workspaces;
our @queued_paths;
sub read_manifest ($$$) {
my ($subdir, $org_subdir, $why) = @_;
my $manifest = "../$subdir/Cargo.toml";
print STDERR "$self: reading $manifest...\n" if $verbose>=4;
if (defined $manifests{$manifest}) {
print STDERR
"$self: warning: $subdir: specified more than once!".
" (ignoring $why)\n";
return undef;
}
foreach my $try ("$manifest.unnailed", "$manifest") {
my $toml = toml_or_enoent($try, "manifest, in $why") // next;
my $ws = $toml->{workspace};
if ($ws) {
queue_workspace_members($subdir, $org_subdir, $ws, "$subdir, $why");
}
my $p = $toml->{package}{name};
if (!defined $p and !defined $ws) {
print STDERR
"$self: warning: $subdir, $why: missing package.name in $try, ignoring\n";
next;
}
$manifests{$manifest} = [ $toml, $org_subdir ] if $p;
foreach my $dep (get_dependency_tables $toml) {
next unless defined $dep->{path};
queue_referenced_path($dep->{path}, $org_subdir,
"dependency of $subdir, $why");
}
return ($p, $ws);
}
return undef;
}
sub queue_workspace_members ($$) {
my ($subdir, $org_subdir, $ws_toml, $what) = @_;
# We need to (more or less) reimplement the cargo workspace
# membership algorithm (see the "workspaces" section of the cargo
# reference). How tiresome.
#
# It's not quite the same for us because we aren't interested in
# whether cargo thinks things are "in the workspace". But we do
# need to do the automatic discover.
my @include = @{ $ws_toml->{members} // [ ] };
my $exclude = $ws_toml->{exclude} // [ ];
my @exclude = map {
s/[^*?0-9a-zA-Z_]/\\$&/g;
s/\?/./g;
s/\*/.*/g;
} @$exclude;
foreach my $spec (@include) {
if ($spec =~ m{^/}) {
print STDERR
"$self: warning: absolute workspace member $spec in $what (not nailing, but cargo will probably use it)\n";
next;
}
my $spec_glob_prefix = "../$subdir/";
my $spec_glob = "$spec_glob_prefix$spec";
my $globflags = GLOB_ERR|GLOB_BRACE|GLOB_NOMAGIC;
foreach my $globent (bsd_glob($spec_glob, $globflags)) {
my $ent_prefix = substr($globent, 0, length $spec_glob_prefix);
if ($ent_prefix ne $spec_glob_prefix) {
print STDERR
"$self: warning: $globent ($spec_glob, $what) points outside $spec_glob_prefix, not following so not nailing (although cargo probably will follow it)\n";
next;
}
next if grep { $globent =~ m{^$_$} } @exclude;
queue_referenced_path($globent, $org_subdir,
"member of workspace $what");
}
}
}
sub queue_referenced_path ($$$) {
my ($spec_path, $org_subdir, $why) = @_;
open REALPATH, "-|",
qw(realpath), "--relative-to=../$org_subdir", "--", $spec_path
or die "$self: fork/pipe/exec for realpath(1)\n";
my $rel_path = do { local $/=undef; ; };
$?=0; $!=0;
my $r = close(REALPATH);
die "$self: reap realpath: $!\n" if $!;
if (!chomp($rel_path) or $?) {
print STDERR
"$self: warning: failed to determine realpath for $spec_path in $org_subdir (exit code $?)\n";
return;
}
my $q_subdir = "$org_subdir/$rel_path";
print STDERR "$self: making a note to look at $q_subdir, $why)\n"
if $verbose >= 4;
push @queued_paths, [ "$q_subdir", $org_subdir, $why ];
}
sub readorigs () {
# We (and our callees) populate %packagemap and %manifest, so if we
# don't run, they remain empty and nothing is nailed.
return unless $do_nail;
foreach my $p (keys %{ $nail->{packages} }) {
my $v = $nail->{packages}{$p};
my $subdir = ref($v) ? $v->{subdir} : $v;
my ($gotpackage, $ws) = read_manifest($subdir, $subdir, "from [packages]");
$gotpackage //= '';
if ($gotpackage ne $p) {
print STDERR
"$self: warning: honouring Cargo.nail packages.$subdir=$p even though $subdir contains package $gotpackage!\n";
}
die if defined $packagemap{$p};
$packagemap{$p} = [ $subdir, $subdir ];
}
foreach my $subdir (@{ $nail->{subdirs} }) {
my ($gotpackage,$ws) = read_manifest($subdir, $subdir, "from [subdirs]");
if (!defined $gotpackage) {
print STDERR
"$self: warning: ignoring subdir $subdir which has no (suitable) Cargo.toml\n"
unless $ws;
next;
}
$packagemap{$gotpackage} //= [ $subdir, $subdir ];
}
while (my ($subdir, $org_subdir, $why) = @{ shift @queued_paths or [] }) {
$subdir =~ s{/\.$}{};
next if $manifests{"../$subdir/Cargo.toml"};
my ($gotpackage, $ws) = read_manifest($subdir, $org_subdir, $why);
next unless $gotpackage;
$packagemap{$gotpackage} //= [ $subdir, $org_subdir ];
}
}
sub calculate () {
foreach my $p (sort keys %packagemap) {
print STDERR "$self: package $p in $packagemap{$p}[0]\n" if $verbose>=2;
}
foreach my $mf (keys %manifests) {
die "internal error" unless $do_nail; # belt and braces
my ($toml, $mf_org_subdir) = @{ $manifests{$mf} };
foreach my $deps (get_dependency_tables $toml) {
next unless $deps;
foreach my $dep_key (keys %$deps) {
my $info = $deps->{$dep_key};
my $p = (ref $info ? $info->{package} : undef) // $dep_key;
next unless defined $packagemap{$p};
next if $packagemap{$p}[1] eq $mf_org_subdir;
$deps->{$dep_key} = $info = { } unless ref $info; # was just version
my $oldpath = $info->{path};
delete $info->{version};
my $newpath = $worksphere.'/'.$packagemap{$p}[0];
print STDERR "in $mf set $p path=$newpath (was ".
($oldpath // '').")\n"
if $verbose >= 4;
$info->{path} = $newpath;
delete $info->{git};
delete $info->{branch};
}
}
my $nailing = "$mf.nailing~";
unlink_or_enoent $nailing or die "$self: remove old $nailing: $!\n";
open N, '>', $nailing or die "$self: create new $nailing: $!\n";
print N to_toml($toml) or die "$self: write new $nailing: $!\n";
close N or die "$self: close new $nailing: $!\n";
}
}
sub addargs () {
# TODO $gitxfer support!
if ($edits_sources==1) {
$linkfarm_depth = 'copy-edit';
} elsif ($edits_sources>=2) {
$linkfarm_depth = 'copy-edit-all';
}
if ($just_linkfarm) {
die "$self: --just-linkfarm but not doing out-of-tree builds!\n"
unless defined $oot_dir;
@ARGV = ();
return;
}
if (!defined $online) {
$_ = cfg_uc qw(misc online);
if (!defined $_) {
} elsif (Types::Serialiser::is_bool $_) {
$online = $_;
} elsif (ref $_) {
} elsif (m/^a/) {
$online = undef;
} elsif (m/^[1ty]/) { # allow booleanish strings
$online = 1; # for less user frustration
} elsif (m/^[0fn]/) {
$online = 0;
} else {
badcfg qw(misc online), "expected boolean or 'auto', found '$_'";
}
}
$online //= 1 if subcmd_p('online');
$online //= 0;
if ($edits_sources>=2) {
$oot_preclean //= 'src';
if ($oot_preclean !~ m/^(?:src|full)$/) {
forceable_warning
"-EE specified, but also --preclean=no; will probably leave your source tree full of junk";
}
}
if (subcmd_p('linkfarm-gitclean')) {
$linkfarm_depth //= 'git';
$oot_preclean //= 'src';
}
$cargo_lock_update //= subcmd_p('lock-update');
$linkfarm_depth //=
subcmd_p('pristine-git') ? 'git' :
subcmd_p('linkfarm-shallow') ? 'shallow' :
$cargo_lock_update ? 'shallow' :
'';
$oot_preclean //= $gitxfer ? 'src' : 'no';
my $toolchain = cfgs qw(misc usual_toolchain);
$toolchain =~ s{^\+}{} if defined $toolchain;
@args_preface = map {
$_ ne "\0+" ? $_ :
defined $toolchain ? "+$toolchain" :
()
} @args_preface;
print STDERR "toolchain ".($toolchain // '')." \n" if $dump;
if (defined $toolchain) {
$ENV{NAILINGCARGO_TOOLCHAIN} = "+$toolchain";
} elsif (defined $arg_toolchain) {
$ENV{NAILINGCARGO_TOOLCHAIN} = $arg_toolchain;
}
our @add;
if (!$cargo_lock_update) {
push @add, qw(--locked) unless subcmd_p('!locked');
}
if ($linkfarm_depth eq '' && !$gitxfer) {
if (defined($oot_dir) && !subcmd_p('!manifest-path')) {
my $cargotoml = "${src_absdir}/Cargo.toml";
push @args_preface, "--manifest-path=$cargotoml" if $pass_options;
push @add, qw(--target-dir=target) unless subcmd_p('!target-dir');
}
}
if (defined($target) && !subcmd_p('!target')) {
if ($target =~ m{^[A-Z]}) {
$target = (cfgs 'arch', $target) // $archmap{$target}
// die "$self: --target=$target alias specified; not in cfg or map\n";
}
push @add, "--target=$target";
}
push @add, "--offline" unless $online || subcmd_p('!offline');
if (subcmd_p('creates') && $edits_sources < 2) {
forceable_warning
"this subcommand expects to create new source files; you probably want to specify --edits-sources twice aka -EE (which is not the default even now, for safety reasons)";
} elsif (subcmd_p('edits') && !$edits_sources) {
forceable_warning
"this subcommand expects to edit the source code; you probably want to specify --edits-sources aka -E (which is not the default even now, for safety reasons)";
}
push @args_preface, @add if $pass_options;
die if grep { m/ / } @add;
$ENV{NAILINGCARGO_CARGO_OPTIONS} = "@add";
unshift @ARGV, @args_preface;
}
our $build_absdir; # .../Build/
sub oot_massage_cmdline () {
return unless defined $oot_dir;
my $use = cfgs qw(oot use);
$use // die "$self: out-of-tree build, but \`oot.use' not configured\n";
$build_absdir = "$oot_absdir/$subdir";
my ($pre,$post) = ('','');
my @xargs;
$pre .= "set -x;" if $dump;
my $std_pre = sub {
push @xargs, $oot_absdir, $subdir, $src_absdir;
$pre .= <<'END_BOTH';
bld="$1"; shift; sd="$1"; shift; src="$1"; shift;
cd "$bld"; mkdir -p -- "$sd"; cd "$sd";
END_BOTH
};
if ($gitxfer) {
$std_pre->();
$pre .= <<'END_GIT_XFER_PREP';
if test -d .git; then :; else
git init;
fi;
mkdir -p .git/nailing-cargo .git/logs/refs/nailing-cargo;
>>.git/logs/refs/nailing-cargo/src;
parent_exists=$(set -e; cd "$src/"; git rev-parse --verify -q HEAD~0 || test $? = 1);
if [ "$parent_exists" ]; then
git fetch "$src" +HEAD:refs/nailing-cargo/src;
fi;
branch_exists=$(git rev-parse --verify -q HEAD~0 || test $? = 1);
if [ "$branch_exists" ]; then git checkout --quiet --detach; fi;
END_GIT_XFER_PREP
if ($oot_preclean ne 'no') {
$pre.= "git clean -xdf".
( $oot_preclean =~ /full/ ? ''
: ' -e/target'.
( $clisubdir ne ''
? " -e/".(shell_quotify "$clisubdir")."target"
: '' )
).
';';
}
$pre.= "git reset -q --hard;";
$pre .= <<'END_GIT_XFER_MKTREE';
if [ "$parent_exists" ]; then
git checkout --quiet refs/nailing-cargo/src~0 --;
fi;
cp .git/index .git/nailing-cargo/index;
exec 3>&1;
exec >.git/nailing-cargo/commit;
printf 'tree ';
(set -e; cd "$src";
GIT_DIR="$bld/$sd"/.git;
GIT_INDEX_FILE="$GIT_DIR/nailing-cargo/index";
export GIT_DIR GIT_INDEX_FILE;
git add . >&2;
if test -f Cargo.lock; then git add -f Cargo.lock >&2; fi;
git write-tree);
read <.git/nailing-cargo/commit our_tree;
if [ "$parent_exists" ]; then
their_tree=$(git cat-file commit refs/nailing-cargo/src | sed 1q);
fi;
if [ "x$our_tree" = "x$their_tree" ]; then
git checkout --quiet refs/nailing-cargo/src --;
else
END_GIT_XFER_MKTREE
if (subcmd_p('pristine-git')) {
$pre .= <<'END_GIT_XFER_CLEAN';
echo >&2 '*** original source working tree is dirty - refusing! ***';
exit 12;
END_GIT_XFER_CLEAN
} else {
$pre .= <<'END_GIT_XFER_DIRTY';
if [ "$parent_exists" ]; then
printf 'parent ';
git rev-parse HEAD~0;
fi;
authline=$(date +'nailing-cargo %s %z');
printf "author %s\ncommitter %s\n\nnailing-cargo autocommit dirty working tree\n" "$authline" "$authline";
obj=$(git hash-object -t commit -w .git/nailing-cargo/commit);
exec >&2;
git checkout --quiet "$obj";
END_GIT_XFER_DIRTY
}
$pre .= <<'END_GIT_XFER';
fi;
exec >&3;
END_GIT_XFER
if ($edits_sources) {
$pre .= <<'END_GIT_XFER_EDITS_CLEANUP';
git update-ref refs/nailing-cargo/edited HEAD~0:;
END_GIT_XFER_EDITS_CLEANUP
$post .= ':;'; # forces us to not use exec
$pre .= <<'END_GIT_XFER_EDITS_CAPTURE';
trap '
rc=$?;
git add -A .;
tree=$(git write-tree);
git update-ref refs/nailing-cargo/edited $tree;
exit $rc;
' 0;
END_GIT_XFER_EDITS_CAPTURE
}
} elsif ($linkfarm_depth eq '') {
push @xargs, $build_absdir;
$pre .= 'cd "$1"; shift; ';
$post .= '';
} else { # not $gitxfer, some $linkfarm_depth
$std_pre->();
if ($oot_preclean ne 'no') {
$pre.= "find . -maxdepth 1 ! -path .";
$pre.= " ! -path ./target" if $oot_preclean ne 'full';
$pre.= " -print0 | xargs -0r rm -r --;"
}
if ($linkfarm_depth eq 'shallow') {
$pre.= <<'END_SHALLOW';
clean () { find -lname "$src/*" -print0 | xargs -0r rm --; }; clean;
find "$src" -maxdepth 1 \! -name Cargo.lock -print0 |
xargs -0r sh -ec 'for f in "$@"; do
rm -rf -- "${f##*/}";
ln -sf -- "$f" .;
done';
END_SHALLOW
} elsif ($linkfarm_depth =~ /full|git/) {
$pre .= <<'END_EITHER_DEEP_DIRS';
clean () { find -follow -lname "$src/*" -print0 | xargs -0r rm --; };
(set -e; cd "$src"; find . \! -name Cargo.lock \! \( -name .git -prune \) \! -path . \! -name .git -type d -print0) |
xargs -0r sh -ec 'for f in "$@"; do
rm -f -- "$f" 2>/dev/null ||:;
mkdir -p "$f";
done' x;
END_EITHER_DEEP_DIRS
if ($linkfarm_depth eq 'git') {
$pre .= <<'END_FILES_GIT'
(set -e; cd "$src"; git ls-files --exclude-standard -co -z) |
END_FILES_GIT
} elsif ($linkfarm_depth eq 'full') {
$pre .= <<'END_FILES_FULL'
(set -e; cd "$src"; find . \! -name Cargo.lock \! \( -name .git -prune \) \! -type d -print0) |
END_FILES_FULL
}
$pre .= <<'END_DEEP';
perl -0 -ne '
BEGIN { $src=shift @ARGV; }
next if (readlink "$_"//"") eq "$src/$_";
unlink "$_";
symlink "$src/$_", "$_" or die "$_ $!";
' "$src";
END_DEEP
} elsif ($linkfarm_depth =~ m/^copy-edit/) {
$pre .= <<'END_COPY_EDIT_PRE';
find -lname "$src/*" -print0 | xargs -0r rm --;
(set -e; cd "$src"; git ls-files -c -z |
cpio --quiet -p0m --no-preserve-owner -u --make-directories "$bld/$sd");
END_COPY_EDIT_PRE
} else {
die "$linkfarm_depth ?";
}
if ($linkfarm_depth =~ m/^copy-edit/) {
$pre .= <<'END_COPY_EDIT';
clean () {
(set -e; cd "$src"; git ls-files -c -z) | xargs -0r rm -df --;
};
END_COPY_EDIT
if ($linkfarm_depth eq 'copy-edit-all') {
$post .= <<'END_COPY_EDIT_GENFILES_ALL';
find -xdev \( \( -name .git -o -path ./target -o -path ./nailing-cargo-update.tar \) -prune \) -o
\( -type l -o -type f \) -print0 |
END_COPY_EDIT_GENFILES_ALL
} else {
$post .= <<'END_COPY_EDIT_GENFILES_GIT';
(set -e; cd "$src"; git ls-files -c -z) |
END_COPY_EDIT_GENFILES_GIT
}
$post .= <<'END_COPY_EDIT_BUNDLE';
cpio -Hustar -o0 --quiet >"nailing-cargo-update.tar";
END_COPY_EDIT_BUNDLE
$pre .= <<'ENDLK' if $do_cargo_lock;
if test -e Cargo.lock || test -e "$src"/Cargo.lock; then
rm -f Cargo.lock;
cp -- "$src"/Cargo.lock .;
fi;
ENDLK
} # endif copy-edit
$post .= <<'ENDCLEAN' if $oot_clean && !$just_linkfarm;
clean;
ENDCLEAN
}
my $addpath = (cfg_uc qw(oot path_add)) //
$use eq 'really' || $use eq 'sudo'
? Types::Serialiser::true : Types::Serialiser::false;
$addpath =
!Types::Serialiser::is_bool $addpath ? $addpath :
$addpath ? '$HOME/.cargo/bin' :
undef;
if (defined $addpath) {
$pre .= <= 2 ? 'xe' : 'e';
my $sh_ec = sub {
if (!length $post) {
@command = (@_, 'sh',"-${xe}c",$pre.'exec "$@"','--',@xargs);
} else {
@command = (@_, 'sh',"-${xe}c",$pre.'"$@"; '.$post,'--',@xargs);
}
my $eff_chdir = "$clisubdir$chdir";
if (length $eff_chdir) {
push @command, "env", "--chdir=$eff_chdir", "--";
}
push @command, @ARGV;
};
my $command_sh = sub {
my $quoted = shell_quotify @ARGV;
my $qargs = shell_quotify @xargs;
@command = (@_, "set -${xe}; set -- $qargs; $pre $quoted; $post");
};
if ($verbose) {
if ($gitxfer) {
print STDERR "$self: out-of-tree, git, building in: \`$build_absdir'\n";
} else {
print STDERR "$self: out-of-tree, raw, building in: \`$build_absdir'\n";
}
}
if ($use eq 'really') {
my $user = $getuser->();
my @pw = getpwnam $user or die "$self: oot.user \`$user' lookup failed\n";
my $homedir = $pw[7];
$sh_ec->('really','-u',$user,'env',"HOME=$homedir");
print STDERR "$self: using really to run as user \`$user'\n" if $verbose;
} elsif ($use eq 'sudo') {
my $user = $getuser->();
$sh_ec->(qw(sudo -u), $user);
print STDERR "$self: using sudo to run as user \`$user'\n" if $verbose;
} elsif ($use eq 'ssh') {
my $user = $getuser->();
$user .= '@localhost' unless $user =~ m/\@/;
$command_sh->('ssh',$user);
print STDERR "$self: using ssh to run as \`$user'\n" if $verbose;
} elsif ($use eq 'command_args') {
my @c = cfgn_list qw(oot command);
$sh_ec->(@c);
print STDERR "$self: out-of-tree, adverbial command: @c\n" if $verbose;
} elsif ($use eq 'command_sh') {
my @c = cfgn_list qw(oot command);
$command_sh->(@c);
print STDERR "$self: out-of-tree, ssh'ish command: @c\n" if $verbose;
} elsif ($use eq 'null') {
$sh_ec->();
} else {
die "$self: oot.use mode $use not recognised\n";
}
die unless @command;
@ARGV = @command;
}
sub setenvs () {
$ENV{CARGO_MANIFEST_DIR} = $src_absdir.$clisubdir unless !$gitxfer && $linkfarm_depth;
$ENV{NAILINGCARGO_MANIFEST_DIR} = $src_absdir.$clisubdir;
$ENV{NAILINGCARGO_WORKSPHERE} = $worksphere;
$ENV{NAILINGCARGO_BUILDSPHERE} = $oot_absdir;
delete $ENV{NAILINGCARGO_BUILDSPHERE} unless $oot_absdir;
$ENV{NAILINGCARGO_BUILD_DIR} = ($build_absdir // $src_absdir).$clisubdir;
}
our $want_uninstall;
END {
if ($want_uninstall) {
local ($?);
foreach my $mf (keys %manifests) {
eval { uninstall1($mf,1); 1; } or warn "$@";
}
eval { unaltcargolock(1); 1; } or warn "$@";
}
}
sub consider_directories () {
return unless defined $oot_dir;
my $bsubdir = "../$oot_dir/$subdir";
return if stat $bsubdir;
die "$0: build directory $bsubdir inaccessible\n"
unless $!==ENOENT;
}
our $cleanup_cargo_lock;
sub makebackups () {
foreach my $mf (keys %manifests) {
link "$mf", "$mf.unnailed" or $!==EEXIST
or die "$self: make backup link $mf.unnailed: $!\n";
}
if (defined($alt_cargo_lock)) {
die 'internal error' unless $do_cargo_lock;
if (@alt_cargo_lock_stat) {
print STDERR "$self: using alt_cargo_lock `$alt_cargo_lock'..."
if $verbose>=3;
if (link $alt_cargo_lock, 'Cargo.lock') {
print STDERR " linked\n" if $verbose>=3;
} elsif ($! != EEXIST) {
print STDERR "\n" if $verbose>=3;
die "$self: make \`Cargo.lock' available as \`$alt_cargo_lock': $!\n";
} else {
print STDERR "checking quality." if $verbose>=3;
my @lock_stat = stat 'Cargo.lock'
or die "$self: stat Cargo.lock (for alt check: $!\n";
same_file(\@alt_cargo_lock_stat, \@lock_stat)
or die
"$self: \`Cargo.lock' and alt file \`$alt_cargo_lock' both exist and are not the same file!\n";
}
$cleanup_cargo_lock = 1;
} else {
$cleanup_cargo_lock = 1;
# If Cargo.lock exists and alt doesn't, that means either
# that a previous run was interrupted, or that the user has
# messed up.
}
}
}
sub nailed ($) {
my ($mf) = @_;
my $nailed = "$mf.nailed~"; $nailed =~ s{/([^/]+)$}{/.$1} or die;
$nailed;
}
sub install () {
my @our_unfound_stab = stat_exists('Cargo.toml', 'local Cargo.toml')
? (stat _) : ();
foreach my $mf (keys %manifests) {
if (@our_unfound_stab) {
if (stat_exists $mf, "manifest in to-be-nailed directory") {
my @mf_stab = stat _ ;
if ("@mf_stab[0..1]" eq "@our_unfound_stab[0..1]") {
@our_unfound_stab = ();
}
}
}
my $nailing = "$mf.nailing~";
my $nailed = nailed($mf);
my ($use, $rm);
my $diff;
if (open NN, '<', $nailed) {
$diff = compare($nailing, \*NN);
die "$self: compare $nailing and $nailed: $!" if $diff<0;
} else {
$!==ENOENT or die "$self: check previous $nailed: $!\n";
$diff = 1;
}
if ($diff) {
$use = $nailing;
$rm = $nailed;
} else {
$use = $nailed;
$rm = $nailing;
}
rename $use, $mf or die "$self: install nailed $use: $!\n";
unlink_or_enoent $rm or die "$self: remove old $rm: $!\n";
print STDERR "$self: nailed $mf\n" if $verbose>=3;
}
# Warn only if subdirs had something in it.
if (@our_unfound_stab && %manifests) {
print STDERR
"$self: *WARNING* cwd is not in Cargo.nail though it has Cargo.toml!\n";
}
}
sub invoke () {
my $r = system @ARGV;
if (!$r) {
return 0;
} elsif ($r<0) {
print STDERR "$self: could not execute $ARGV[0]: $!\n";
return 127;
} elsif ($r & 0xff00) {
print STDERR "$self: $ARGV[0] failed (exit status $r)\n";
return $r >> 8;
} else {
print STDERR "$self: $ARGV[0] died due to signal! (wait status $r)\n";
return 125;
}
}
sub files_return_after_update () {
return unless defined $oot_dir;
if ($edits_sources) {
if ($gitxfer) {
my $cmd = '';
$cmd .= "set -x;" if $verbose >= 2;
$cmd .= ': in source tree;';
$cmd .= <<'END_GIT_XFER_RETURN';
git_dir=$(git rev-parse --git-dir);
mkdir -p -- "$git_dir"/nailing-cargo;
rm -rf "$git_dir"/nailing-cargo/stunt-copy;
mkdir -- "$git_dir"/nailing-cargo/stunt-copy;
GIT_DIR="$git_dir"/nailing-cargo/stunt-copy git init;
mkdir -p -- "$git_dir"/nailing-cargo/stunt-copy/info;
rm -rf "$git_dir"/nailing-cargo/stunt-copy/objects "$git_dir"/nailing-cargo/stunt-copy/info/refs "$git_dir"/nailing-cargo/stunt-copy/refs;
ln -s "$1"/.git/objects "$git_dir"/nailing-cargo/stunt-copy/objects;
ln -s "$1"/.git/refs "$git_dir"/nailing-cargo/stunt-copy/refs;
ln -s "$1"/.git/info/refs "$git_dir"/nailing-cargo/stunt-copy/info/refs;
git fetch -q "$git_dir"/nailing-cargo/stunt-copy +refs/nailing-cargo/edited:refs/nailing-cargo/edited;
if test -e "$git_dir"/index; then
cp -- "$git_dir"/index "$git_dir"/nailing-cargo/index;
fi;
export GIT_INDEX_FILE="$git_dir"/nailing-cargo/index;
END_GIT_XFER_RETURN
if ($edits_sources >= 2) {
$cmd .= <<'END_GIT_XFER_CHECKOUT_ALL'
git checkout refs/nailing-cargo/edited -- .;
END_GIT_XFER_CHECKOUT_ALL
} else {
# This horrible rune involving grep and perl is there to exclude
# submodules, which appear in git ls-files but which can't be fed
# to git checkout.
$cmd .= <<'END_GIT_XFER_CHECKOUT_EXISTING'
git ls-files -c -z |
grep -z -v -F -f <(git ls-tree -zr HEAD | perl -0 -ne 'print if s{^\d+ commit \w+\t}{}') |
xargs -0r git checkout refs/nailing-cargo/edited --;
END_GIT_XFER_CHECKOUT_EXISTING
}
$cmd =~ s/^\s+//mg; $cmd =~ s/\s+/ /g;
if ($dump) {
eval '
use Data::Dumper;
print STDERR Dumper($build_absdir, $cmd);
' or die $@;
}
system qw(bash -ec), $cmd, 'x', $build_absdir;
} else {
my $tar_source_opts;
my $tar_stdin;
if ($edits_sources >= 2) {
$tar_source_opts = '--null --files-from=-';
$tar_stdin = <<'END_GIT_FILES';
git ls-files -c -z | \
END_GIT_FILES
} else {
$tar_source_opts = '--anchored --exclude=.git --exclude="*/.git" --exclude=target --exclude=nailing-cargo-update.tar';
$tar_stdin = '';
}
system qw(sh -ec), $tar_stdin . <<'END', 'x', "$build_absdir";
tar -x --keep-newer-files --no-same-permissions --no-same-owner \
--no-acls --no-selinux --no-xattrs --warning=no-ignore-newer \
-Hustar $tar_source_opts --force-local \
-f "$1/nailing-cargo-update.tar"
END
}
} elsif ($do_cargo_lock && $cargo_lock_update && !$just_linkfarm) {
# avoids importing File::Copy and the error handling is about as good
$!=0; $?=0;
my $r= system qw(cp --), "$build_absdir/Cargo.lock", "Cargo.lock";
die "$self: run cp: $! $?" if $r<0 || $r & 0xff;
die "$self: failed to update local Cargo.lock (wait status $r)\n" if $r;
}
}
sub uninstall1 ($$) {
my ($mf, $enoentok) = @_;
my $unnailed = "$mf.unnailed";
rename $unnailed, $mf or ($enoentok && $!==ENOENT)
or die "$self: failed to restore: rename $unnailed back to $mf: $!\n";
}
sub unaltcargolock ($) {
my ($enoentok) = @_;
return unless $cleanup_cargo_lock;
die 'internal error!' unless $do_cargo_lock && defined $alt_cargo_lock;
# we ignore $enoentok because we don't know if one was supposed to
# have been created.
rename('Cargo.lock', $alt_cargo_lock) or $!==ENOENT or die
"$self: cleanup: rename possibly-updated \`Cargo.lock' to \`$alt_cargo_lock': $!\n";
unlink 'Cargo.lock' or $!==ENOENT or die
"$self: cleanup: remove \`Cargo.lock' in favour of \`$alt_cargo_lock': $!\n";
# ^ this also helps clean up the stupid rename() corner case
}
sub uninstall () {
foreach my $mf (keys %manifests) {
my $nailed = nailed($mf);
link $mf, $nailed or die "$self: preserve (link) $mf as $nailed: $!\n";
uninstall1($mf,0);
}
unaltcargolock(0);
}
sub parse_args () {
my $is_cargo;
# Loop exit condition:
# $is_cargo is set
# @ARGV contains
# $is_cargo==1 [--] ...
# $is_cargo==0 ...
OPTS: for (;;) {
if (!@ARGV) {
die "$self: need cargo subcommand\n"
unless $noact || $just_linkfarm;;
push @ARGV, "CARGO-SUBCOMMAND"; # dummy, user may see it
}
$_ = shift @ARGV;
my $orgopt = $_;
my $not_a_nailing_opt = sub { # usage 1
unshift @ARGV, $orgopt;
if ($orgopt =~ m{^\+}) {
# We don't have the usual_toolchain here since we haven't
# read the config yet. Insert this dummy argument which
# we'll substitute later. This can't occur some other way
# because no-one can pass nuls into arguments.
$arg_toolchain = $&;
} else {
unshift @ARGV, "\0+";
}
unshift @ARGV, 'cargo';
$is_cargo = 1;
no warnings qw(exiting);
last OPTS;
};
$not_a_nailing_opt->() unless m{^-};
$not_a_nailing_opt->() if $_ eq '--';
if ($_ eq '---') { # usage 2 or 3
if (!@ARGV) {
die "$self: --- must be followed by build command\n" unless $noact;
push @ARGV, 'BUILD-COMMAND';
}
if ($ARGV[0] eq '--') { # usage 3
shift @ARGV;
$is_cargo = 0;
} elsif (grep { $_ eq '--' } @ARGV) { # usage 2
$is_cargo = 1;
} elsif ($ARGV[0] =~ m{[^/]*cargo[^/]*$}) { # usage 2
$is_cargo = 1;
} else { # usage 3
$is_cargo = 0;
}
last;
}
if (m{^-[^-]}) {
while (m{^-.}) {
if (s{^-h}{-}) {
print_usage();
} elsif (s{^-v}{-}) {
$verbose++;
} elsif (s{^-q}{-}) {
$verbose=0;
} elsif (s{^-n}{-}) {
$noact++;
} elsif (s{^-f}{-}) {
$force++;
} elsif (s{^-s(.+)}{-}s) {
$cargo_subcmd = $1;
} elsif (s{^-([uU])}{-}) {
$cargo_lock_update = $1=~m/[a-z]/;
} elsif (s{^-([cC])}{-}) {
$pass_options = $1=~m/[a-z]/;
} elsif (s{^-D}{-}) {
$dump++;
} elsif (s{^-E}{-}) {
$edits_sources++;
} elsif (s{^-T(.+)}{-}s) {
$target = $1;
} elsif (s{^-([oO])}{-}) {
$online = $1=~m/[a-z]/;
} else {
die "$self: unknown short option(s) $_\n" unless $_ eq $orgopt;
$not_a_nailing_opt->();
}
}
} elsif (s{^--help$}{}) {
print_usage();
} elsif (s{^--(?:doc|man|manual)?$}{}) {
show_manual();
} elsif (s{^--target=}{}) {
$target = $_;
} elsif (m{^--(on|off)line$}) {
$online = $1 eq 'on';
} elsif (m{^--(no-)?git$}) {
$gitxfer = !$1;
} elsif (m{^--just-git$}) {
$just_linkfarm = 1;
$cargo_lock_update= 1; # will set $linkfarm_detph to 1 by default
$linkfarm_depth = 'git';
$gitxfer = 1;
} elsif (m{^--just-linkfarm(?:=(shallow|git|full))?$}) {
$just_linkfarm = 1;
$linkfarm_depth = $1 if $1;
$cargo_lock_update= 1; # will set $linkfarm_detph to 1 by default
} elsif (m{^--linkfarm(?:=(no|shallow|git|full))?$}) {
$linkfarm_depth = $1 || 'git';
} elsif (m{^--edits?-sources?$}) {
$edits_sources++;
} elsif (m{^--force$}) {
$force++;
} elsif (m{^--just-run$}) {
$do_nail = $do_cargo_lock = $do_lock = $gitxfer = 0;
} elsif (m{^--subdir=(.*)$}) {
$clisubdir = $1;
die "$self: --subdir value must be relative\n" if $clisubdir =~ m,^/,;
$clisubdir =~ s,/$,,;
$clisubdir = $clisubdir.'/';
} elsif (m{^--chdir=(.*)$}) {
$chdir = $1;
} elsif (m{^--(clean|keep)-linkfarm$}) {
$oot_clean = $1 eq 'clean';
} elsif (m{^--(no-)?preclean-build$}) {
$oot_preclean = $1 ? 'no' : 'src';
} elsif (m{^--preclean(?:-build)?(?:=(no|src|full))?$}) {
$oot_preclean = $1 // 'src';
} elsif (m{^--(no-)?nail$}) {
$do_nail = !$1;
} elsif (m{^--(no-)?cargo-lock-manip$}) {
$do_cargo_lock = !$1;
} elsif (m{^--(no-)?concurrency-lock$}) {
$do_lock = !$1;
} elsif (m{^--leave-nailed$}) {
$leave_nailed = 1;
} elsif (s{^--nailfile=}{}) {
$nailfile = $_;
} elsif (s{^--subcommand-props=}{}) {
my @props = split /\,/, $_;
our %subcmd_prop_ok;
if (!%subcmd_prop_ok) {
foreach my $v (\@subcmd_xprops, values %subcmd_props) {
$subcmd_prop_ok{$_}=1 foreach @$v;
};
}
$subcmd_prop_ok{$_}
or die "$self: unknown subcommand property \`$_'\n"
foreach @props;
$cargo_subcmd = \@props;
} elsif (m{^--(no-)?cargo-lock-update}) {
$cargo_lock_update= !!$1;
} else {
$not_a_nailing_opt->();
}
}
$is_cargo // die;
@ARGV || die;
if (defined $gitxfer) {
} elsif (stat ".git") {
$gitxfer = 1;
} elsif ($! == ENOENT) {
$gitxfer = 0;
} else {
die "$self: checking for .git (for default value of --git): $!\n";
}
$src_absdir = getcwd() // die "$self: getcwd failed: $!\n";
if ($gitxfer) {
$?=0; $!=0;
my $cdup = `git rev-parse --show-cdup` // die $!;
$? and die "git rev-parse --show-cdup: $?";
chomp $cdup;
if (length $cdup) {
chdir $cdup // die "cd $cdup (from $subdir) $!";
my $topdir = getcwd; $topdir // die "getcwd topdir $!";
my $prefix = "$topdir/";
print STDERR "nailing-cargo: toplevel is $topdir ($cdup)\n";
substr($src_absdir, 0, length $prefix) eq $prefix
or die "dir confusion: $src_absdir doesn't start with $prefix ?";
$chdir //= substr($src_absdir, length $prefix);
$src_absdir = $topdir;
}
}
$worksphere = $src_absdir;
$worksphere =~ s{/([^/]+)$}{}
or die "$self: cwd \`$worksphere' unsupported!\n";
$subdir = $1; # leafname
$chdir //= '';
if ($is_cargo) {
@args_preface = shift @ARGV;
while (defined($_ = shift @ARGV)) {
if (!m{^-|^\0?\+}) { unshift @ARGV, $_; last; }
if ($_ eq '--') { last; }
push @args_preface, $_;
}
@ARGV || die "$self: need cargo subcommand\n";
$cargo_subcmd //= $ARGV[0];
$pass_options //= 1;
} else {
$cargo_subcmd //= '';
$pass_options //= 0;
}
push @args_preface, shift @ARGV;
if (!ref($cargo_subcmd)) {
print STDERR " cargo_subcmd lookup $cargo_subcmd\n" if $dump;
$cargo_subcmd = $subcmd_props{$cargo_subcmd} // [ ];
}
print STDERR " cargo_subcmd props @$cargo_subcmd\n" if $dump;
my %cargo_subcmd;
$cargo_subcmd{$_} = 1 foreach @$cargo_subcmd;
$cargo_subcmd = \%cargo_subcmd;
}
parse_args();
loadconfigs();
readnail();
takelock();
consider_alt_cargo_lock();
consider_oot();
readorigs();
calculate();
addargs();
consider_directories();
our @display_cmd = @ARGV;
oot_massage_cmdline();
setenvs();
if ($dump) {
eval '
use Data::Dumper;
print STDERR Dumper(\%manifests) if $dump>=2;
print STDERR Dumper(\%packagemap, \@args_preface, \@ARGV,
{ src_absdir => $src_absdir,
worksphere => $worksphere,
subdir => $subdir,
oot_dir => $oot_dir,
oot_absdir => $oot_absdir,
build_absdir => $build_absdir,
gitxfer => $gitxfer,
linkfarm_depth => $linkfarm_depth,
oot_preclean => $oot_preclean,
force => $force,,
forced => $forced,});
' or die $@;
}
exit 0 if $noact;
$want_uninstall = !$leave_nailed;
makebackups();
install();
printf STDERR "$self: nailed (%s manifests, %s packages)%s\n",
(scalar keys %manifests), (scalar keys %packagemap),
(defined($alt_cargo_lock) and ", using `$alt_cargo_lock'")
if $verbose && $do_nail;
print STDERR "$self: invoking: @display_cmd\n" if $verbose;
my $estatus = invoke();
files_return_after_update();
uninstall() unless $leave_nailed;
$want_uninstall = 0;
print STDERR "$self: ".(%manifests ? "unnailed" : "finished")
.". status $estatus.\n" if $verbose;
exit $estatus;
work/update-readme-toc 0000775 0000000 0000000 00000000137 14777226410 012171 0 ustar #!/bin/sh
set -e
./markdown-toc-filter README.md.tmp
mv -f README.md.tmp README.md