YAML-Tiny-1.56/000755 000767 000024 00000000000 12220446251 013402 5ustar00etherstaff000000 000000 YAML-Tiny-1.56/Build.PL000644 000767 000024 00000000066 12220446250 014677 0ustar00etherstaff000000 000000 use 5.006; use Module::Build::Tiny 0.027; Build_PL(); YAML-Tiny-1.56/Changes000644 000767 000024 00000025167 12220446250 014707 0ustar00etherstaff000000 000000 Revision history for YAML-Tiny 1.56 2013-09-25 02:38:19Z (Karen Etheridge) - read_string documentation error fixed (RT#74409, thanks Tim Heaney!) - re-release with fixed compile test 1.55 2013-09-19 04:07:32Z (Karen Etheridge) - again packaging with ExtUtils::MakeMaker 1.54 2013-08-22 03:55:41Z (Karen Etheridge) - convert to Dist::Zilla - Updated format to conform to CPAN::Changes::Spec 1.53 2013-08-20 - really fixed metadata 1.52 2013-08-20 - updated repository metadata to reflect move to github 1.51 2012-03-11 - The fix described in 1.48 was incorrect. Removing an additional if $@ to fix it properly. - Make the Scalar::Util version check resistant to bugs caused by development versions. 1.50 2011-06-23 - Major bug fix, all code that writes arbitrary data should upgrade. - Simple scalars with no whitespace but ending in a colon like ABC: were not being quoted, which results in the parser confusing it with a mapping key and crashing. 1.49 2011-03-08 - No functional changes. - Don't depend on the YAML modules in RELEASE_TESTING, as it can pollute the advisory META.yml. 1.48 2011-02-01 - Fix to the refaddr compatibility where Scalar::Util is installed but is older than 1.18. 1.47 2011-01-31 - No functional changes - Only depend on the YAML implementations when we are release testing 1.46 2010-12-16 - No functional changes - Moving to a production release now CPAN Testers is green again 1.45_02 2010-12-07 - Adding experimental support for exception->errstr conversion - Updating test suite yaml_error to not expect exceptions 1.45_01 2010-12-07 - Added support for trailing line comments (INGY) - Added checks for some characters that are illegal or reserved in plain scalars (INGY) - Minor cleaning up of some out of date POD (ADAMK) - Updated AUTOMATED_TESTING dependencies to new versions (ADAMK) 1.44 2010-08-08 - No functional changes, upgrading is not required - Minor tweaks to Makefile.PL - Minor cleanup around the refaddr emulation code 1.43 2010-07-10 - No functional changes, upgrading is not required - Don't import Carp 'croak' any more, saving a few K 1.42 2010-06-25 - No functional changes, upgrading is not required - Clarified documation to explain that YAML::Tiny escapes "bool" keywords when it writes them as strings so that YAML parsers in other languages won't get confused, but this does not mean that YAML::Tiny actually supports boolean types itself. - Added an extra test case for boolean keyword escaping. - YAML::Perl comparison tests were loading the file back in with YAML.pm by mistake. Corrected this and added an additional case that YAML::Perl doesn't support that I wasn't catching. - Author tests updated and moved into xt/ - Updated the versions of the other YAML parsers we test ourselves against to the most recent versions of each. 1.41 2009-12-11 - Fixes a performance bug reported by Apocalypse. Single line double-quoted strings longer than 32,000ish characters resulted in the regular expression engine crashing due to excessive recursion. Changed to a different regex that will most likely only crash after 32,000 ESCAPED characters. If I could use negative look-behind assertions (I can't because I need 5.004) this whole issue would be MUCH simpler to fix. 1.40 2009-07-31 - Dear Ruby Community. Thank you so much for your bug report to the "Ruby Talk" mailing list regarding the lack of true/false support in Perl YAML modules. http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/169943 This flaw has now been resolved, around 2 hours after we were made aware of it. Next time, we recommend you report these bugs to the people who can actually fix your problem. 1.39 2009-05-21 - Even though utf8 starts at 5.7+ there's no is_utf till 5.8.1 so skip in the tests if needed (ADAMK) 1.38 2009-05-16 - Moving the test suite style closer to Parse::CPAN::Meta - Changed exceptions closer to Parse::CPAN::Meta - Fixed Changes file date for 1.37 :) 1.37 2009-05-16 - Call $self->_error instead of $class->_error when we can - Refactoring away some of the code other people have been contributing lately that most certainly NOT ::Tiny style. - Avoid the need to do '' escaping by moving it to "'" - Added comparative testing with YAML::Perl 1.36 2009-01-07 - Fixing missing feature reported by H.Merijn Brand 1.35 2008-12-17 - Production release for changes in 1.34_01 - No other changes 1.34_01 2008-11-19 - Improving sub-classability by passing the indent level through to the ->_write_scalar method. 1.33 2008-07-24 - Export Load and Dump functions by default. 1.32 2008-05-14 - Adding a test to check for correct exceptions - ONLY do comparative tests when the modules to compare to are current. (Prevents false failures in some cases) 1.31 2008-05-08 - Emergency bugfix release 1.30 2008-05-04 - Better error reporting of unsupported features - Heavily bump automated testing deps to remove false errors 1.29 2008-04-12 - CPAN Testers passes ok, moving to production version 1.28_01 2008-04-05 - Adding support for document terminators (To support YAML embedded in TAP streams) 1.27 2008-03-31 - Skip 04_scalar.t if no YAML.pm - Implement YAML compatibility + tests for LoadFile - Remove the LICENSE key from Makefile.PL (Which failed on some CPAN Testers setups) 1.26 2008-03-20 - Added extra test cases to validate RT bugs that were fixed previous, but not closed at the time. - Always quote when serialising anything that starts with a non-word - YAML::Tiny::Load is now fully compatible with YAML.pm in scalar context (returns the LAST parsed document). 1.25 2008-01-14 - Wrote the specification section 1.24_01 2008-01-11 - Adding additional test cases - Adding support for YAML header for META.yml - Adding support for YAML header for YAML 1.0 - Adding support for YAML header for YAML 1.1 1.23 2008-01-10 - Identical to 1.22_01 - CPAN Testers results positive, pushing to production version 1.22_01 2008-01-09 - Correcting handling of single quote escaping - Adding protection for infinite loops caused by circular references during serializing. - Confirmed support for toolbar.yml sample 1.21 2007-12-06 - Fixing support for unprintable characters 1.20 2007-11-19 - Correcting class name in @EXPORT_OK declaration (Demetrios Biskinis) 1.19 2007-11-16 - Removing the invalid perl dep 1.18 2007-11-05 - Adding a new test file 1.17 2007-11-01 - Updating from Module::Install to the tinier ExtUtils::MakeMaker 1.16 2007-10-22 - Updating to newer AUTOMATED_TESTING tests 1.15 2007-08-25 - Incremental release to include an updated version of 99_author.t - Replace a few CODE INCOMPLETE errors with real errors (those parts of the module are now complete) 1.14 2007-08-16 - Adding support for empty reference documents 1.13 2007-07-09 - Adding a test case for support of multi-byte characters 1.12 2007-06-05 - Adding support for open hash/array at EOF 1.11 2007-06-05 - Forgot to string trailing whitespace in a few cases - 'hashkey: This was mistaken as a hash entry, not a string' - Adding explicit tests from #yaml for single quote escaping 1.10 2007-06-05 - Adding support for null hash/arrays 1.09 2007-05-21 - Fixing a bug in the trivial scalar case 1.08 2007-05-16 - Adding support for |- trimming multiline scalars 1.07 2007-05-15 - Adding support for whitespace after document headers 1.06 2007-05-14 - Bug fix to support an additional variant of null hashes 1.05 2007-05-02 - Bug fix to allow support for keys with spaces - Bug fix to allow empty comments 1.04 2007-02-21 - Adding support for LoadFile, DumpFile, freeze and thaw 1.03 2007-01-14 - Removing the forward-looking part of the preamble 1.02 2007-01-14 - Fixing exporting 1.01 2007-01-14 - Removed the ugly bold warning 1.00 2007-01-14 - What the hell, I'm as close as is needed I think 0.90 2007-01-13 - Adding support for inline multi-lines 0.11 2006-09-25 - Fixed bug in regex that detects unheadered ARRAY|HASH 0.10 2006-08-24 - Added double-quote support, making YAML::Tiny a lot more usable - Added Load and Dump for YAML.pm compatibility - Added tests for verifying compatibility with YAML::Syck 0.06 2006-07-09 - Added more tests 0.05 2006-07-08 - Added support for nested inline hashes (parse only) - Added support for naked undef array and hash entries - Can now handle sample Plagger configs from Miyagawa-san's talk - Can now handle vanilla.yml from Perl::Dist::Vanilla 0.04 2006-07-08 - Added support for implicit document start for array/hash types - Added support for colons in hash keys - Added support for simple single quotes - Can now handle our own META.yml file 0.03 2006-07-08 - Got all of the trivial test cases to pass - Good enough for an initial usable release, but still expected to fail a lot 0.02 2006-04-26 - Added support for a single root-level hash - Correcting POD bugs 0.01 2006-04-26 - Initial version - Handles only document headers and non-wrapping scalar documents YAML-Tiny-1.56/dist.ini000644 000767 000024 00000001445 12220446250 015051 0ustar00etherstaff000000 000000 name = YAML-Tiny author = Adam Kennedy copyright_holder = Adam Kennedy copyright_year = 2006 license = Perl_5 abstract = Read/Write YAML files with as little code as possible ; version is derived automatically from git tags, and inserted ; into Changes and all .pm files [@Author::ETHER] :version = 0.025 -remove = PodWeaver -remove = Test::CheckDeps ; keep our test prereqs core-only AutoPrereqs.skip = ^YAML Authority.authority = cpan:ADAMK Test::MinimumVersion.max_target_perl = 5.008001 [Prereqs / RuntimeRequires] strict = 0 [Prereqs / TestRequires] File::Spec = 0.80 Test::More = 0.47 [OnlyCorePrereqs] :version = 0.008 check_dual_life_versions = 0 starting_version = 5.007003 ; when Scalar::Util was first cored YAML-Tiny-1.56/INSTALL000644 000767 000024 00000002306 12220446250 014433 0ustar00etherstaff000000 000000 This is the Perl distribution YAML-Tiny. Installing YAML-Tiny is straightforward. ## Installation with cpanm If you have cpanm, you only need one line: % cpanm YAML::Tiny If you are installing into a system-wide directory, you may need to pass the "-S" flag to cpanm, which uses sudo to install the module: % cpanm -S YAML::Tiny ## Installing with the CPAN shell Alternatively, if your CPAN shell is set up, you should just be able to do: % cpan YAML::Tiny ## Manual installation As a last resort, you can manually install it. Download the tarball, untar it, then build it: % perl Makefile.PL % make && make test Then install it: % make install If you are installing into a system-wide directory, you may need to run: % sudo make install As a last resort, you can manually install it. Download the tarball, untar it, then build it: % perl Build.PL % ./Build && ./Build test Then install it: % ./Build install If you are installing into a system-wide directory, you may need to run: % sudo ./Build install ## Documentation YAML-Tiny documentation is available as POD. You can run perldoc from a shell to read the documentation: % perldoc YAML::Tiny YAML-Tiny-1.56/lib/000755 000767 000024 00000000000 12220446251 014150 5ustar00etherstaff000000 000000 YAML-Tiny-1.56/LICENSE000644 000767 000024 00000043653 12220446250 014421 0ustar00etherstaff000000 000000 This software is copyright (c) 2006 by Adam Kennedy. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. Terms of the Perl programming language system itself a) the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version, or b) the "Artistic License" --- The GNU General Public License, Version 1, February 1989 --- This software is Copyright (c) 2006 by Adam Kennedy. This is free software, licensed under: The GNU General Public License, Version 1, February 1989 GNU GENERAL PUBLIC LICENSE Version 1, February 1989 Copyright (C) 1989 Free Software Foundation, Inc. 51 Franklin St, Suite 500, Boston, MA 02110-1335 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The license agreements of most software companies try to keep users at the mercy of those companies. By contrast, our General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. The General Public License applies to the Free Software Foundation's software and to any other program whose authors commit to using it. You can use it for your programs, too. When we speak of free software, we are referring to freedom, not price. Specifically, the General Public License is designed to make sure that you have the freedom to give away or sell copies of free software, 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. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of a such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any work containing the Program or a portion of it, either verbatim or with modifications. Each licensee is addressed as "you". 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the notices that refer to this General Public License and to the absence of any warranty; and give any other recipients of the Program a copy of this General Public License along with the Program. You may charge a fee for the physical act of transferring a copy. 2. You may modify your copy or copies of the Program or any portion of it, and copy and distribute such modifications under the terms of Paragraph 1 above, provided that you also do the following: a) cause the modified files to carry prominent notices stating that you changed the files and the date of any change; and b) cause the whole of any work that you distribute or publish, that in whole or in part contains the Program or any part thereof, either with or without modifications, to be licensed at no charge to all third parties under the terms of this General Public License (except that you may choose to grant warranty protection to some or all third parties, at your option). c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the simplest and most usual way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this General Public License. d) You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. Mere aggregation of another independent work with the Program (or its derivative) on a volume of a storage or distribution medium does not bring the other work under the scope of these terms. 3. You may copy and distribute the Program (or a portion or derivative of it, under Paragraph 2) in object code or executable form under the terms of Paragraphs 1 and 2 above provided that you also do one of the following: a) accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Paragraphs 1 and 2 above; or, b) accompany it with a written offer, valid for at least three years, to give any third party free (except for a nominal charge for the cost of distribution) a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Paragraphs 1 and 2 above; or, c) accompany it with the information you received as to where the corresponding source code may be obtained. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form alone.) Source code for a work means the preferred form of the work for making modifications to it. For an executable file, complete source code means all the source code for all modules it contains; but, as a special exception, it need not include source code for modules which are standard libraries that accompany the operating system on which the executable file runs, or for standard header files or definitions files that accompany that operating system. 4. You may not copy, modify, sublicense, distribute or transfer the Program except as expressly provided under this General Public License. Any attempt otherwise to copy, modify, sublicense, distribute or transfer the Program is void, and will automatically terminate your rights to use the Program under this License. However, parties who have received copies, or rights to use copies, from you under this General Public License will not have their licenses terminated so long as such parties remain in full compliance. 5. By copying, distributing or modifying the Program (or any work based on the Program) you indicate your acceptance of this license to do so, and all its terms and conditions. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. 7. The Free Software Foundation may publish revised and/or new versions of the 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 a version number of the license which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the license, you may choose any version ever published by the Free Software Foundation. 8. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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. 10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE 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. END OF TERMS AND CONDITIONS Appendix: 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 humanity, 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 convey 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) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19xx name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (a program to direct compilers to make passes at assemblers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice That's all there is to it! --- The Artistic License 1.0 --- This software is Copyright (c) 2006 by Adam Kennedy. This is free software, licensed under: The Artistic License 1.0 The Artistic License Preamble The intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications. Definitions: - "Package" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification. - "Standard Version" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder. - "Copyright Holder" is whoever is named in the copyright or copyrights for the package. - "You" is you, if you're thinking about copying or distributing this Package. - "Reasonable copying fee" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.) - "Freely Available" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it. 1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers. 2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version. 3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following: a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as ftp.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package. b) use the modified Package only within your corporation or organization. c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version. d) make other distribution arrangements with the Copyright Holder. 4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following: a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version. b) accompany the distribution with the machine-readable source of the Package with your modifications. c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version. d) make other distribution arrangements with the Copyright Holder. 5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own. 6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package. 7. C or perl subroutines supplied by you and linked into this Package shall not be considered part of this Package. 8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission. 9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End YAML-Tiny-1.56/Makefile.PL000644 000767 000024 00000005256 12220446251 015364 0ustar00etherstaff000000 000000 warn <<'EOW'; *** WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING *** If you're seeing this warning, your toolchain is really, really old and you'll almost certainly have problems installing CPAN modules from this century. But never fear, dear user, for we have the technology to fix this! If you're using CPAN.pm to install things, then you can upgrade it using: cpan CPAN If you're using CPANPLUS to install things, then you can upgrade it using: cpanp CPANPLUS If you're using cpanminus, you shouldn't be seeing this message in the first place, so please file an issue on github. If you're installing manually, please retrain your fingers to run Build.PL when present instead. This public service announcement was brought to you by the Perl Toolchain Gang, the irc.perl.org #toolchain IRC channel, and the number 42. EOW sleep 10 if -t STDIN; # This Makefile.PL for was generated by Dist::Zilla::Plugin::MakeMaker::Fallback 0.002. # Don't edit it but the dist.ini used to construct it. use strict; use warnings; use 5.006; use ExtUtils::MakeMaker 6.30; my %WriteMakefileArgs = ( "ABSTRACT" => "Read/Write YAML files with as little code as possible", "AUTHOR" => "Adam Kennedy ", "BUILD_REQUIRES" => {}, "CONFIGURE_REQUIRES" => { "ExtUtils::MakeMaker" => "6.30", "Module::Build::Tiny" => "0.027" }, "DISTNAME" => "YAML-Tiny", "EXE_FILES" => [], "LICENSE" => "perl", "NAME" => "YAML::Tiny", "PREREQ_PM" => { "Carp" => 0, "Exporter" => 0, "Scalar::Util" => 0, "strict" => 0, "warnings" => 0 }, "TEST_REQUIRES" => { "ExtUtils::MakeMaker" => 0, "File::Spec" => "0.80", "File::Spec::Functions" => 0, "IO::Handle" => 0, "IPC::Open3" => 0, "List::Util" => 0, "Test::More" => "0.94", "vars" => 0 }, "VERSION" => "1.56", "test" => { "TESTS" => "t/*.t" } ); unless ( eval { ExtUtils::MakeMaker->VERSION(6.63_03) } ) { my $tr = delete $WriteMakefileArgs{TEST_REQUIRES}; my $br = $WriteMakefileArgs{BUILD_REQUIRES}; for my $mod ( keys %$tr ) { if ( exists $br->{$mod} ) { $br->{$mod} = $tr->{$mod} if $tr->{$mod} > $br->{$mod}; } else { $br->{$mod} = $tr->{$mod}; } } } unless ( eval { ExtUtils::MakeMaker->VERSION(6.56) } ) { my $br = delete $WriteMakefileArgs{BUILD_REQUIRES}; my $pp = $WriteMakefileArgs{PREREQ_PM}; for my $mod ( keys %$br ) { if ( exists $pp->{$mod} ) { $pp->{$mod} = $br->{$mod} if $br->{$mod} > $pp->{$mod}; } else { $pp->{$mod} = $br->{$mod}; } } } delete $WriteMakefileArgs{CONFIGURE_REQUIRES} unless eval { ExtUtils::MakeMaker->VERSION(6.52) }; WriteMakefile(%WriteMakefileArgs); YAML-Tiny-1.56/MANIFEST000644 000767 000024 00000001724 12220446250 014536 0ustar00etherstaff000000 000000 Build.PL Changes INSTALL LICENSE MANIFEST META.json META.yml Makefile.PL README dist.ini lib/YAML/Tiny.pm t/00-compile.t t/00-report-prereqs.t t/01_compile.t t/02_basic.t t/03_regression.t t/04_scalar.t t/05_export.t t/11_meta_yml.t t/12_plagger.t t/13_perl_smith.t t/14_yaml_org.t t/15_multibyte.t t/16_nullrefs.t t/17_toolbar.t t/18_tap.t t/19_errors.t t/20_subclass.t t/21_bom.t t/22_comments.t t/data/HTML-WebDAO.yml t/data/Spreadsheet-Read.yml t/data/Template-Provider-Unicode-Japanese.yml t/data/multibyte.yml t/data/one.yml t/data/sample.yml t/data/toolbar.yml t/data/two.yml t/data/utf_16_le_bom.yml t/data/vanilla.yml t/lib/Test.pm xt/author/pod-spell.t xt/release/changes_has_content.t xt/release/cpan-changes.t xt/release/distmeta.t xt/release/eol.t xt/release/kwalitee.t xt/release/minimum-version.t xt/release/mojibake.t xt/release/no-tabs.t xt/release/pod-coverage.t xt/release/pod-no404s.t xt/release/pod-syntax.t xt/release/test-version.t xt/release/unused-vars.t YAML-Tiny-1.56/META.json000644 000767 000024 00000040204 12220446251 015023 0ustar00etherstaff000000 000000 { "abstract" : "Read/Write YAML files with as little code as possible", "author" : [ "Adam Kennedy " ], "dynamic_config" : 0, "generated_by" : "Dist::Zilla version 4.300039, CPAN::Meta::Converter version 2.132620", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "YAML-Tiny", "no_index" : { "directory" : [ "t", "xt", "examples" ] }, "prereqs" : { "configure" : { "requires" : { "ExtUtils::MakeMaker" : "6.30", "Module::Build::Tiny" : "0.027" } }, "develop" : { "requires" : { "Dist::Zilla" : "4.300039", "Dist::Zilla::Plugin::MakeMaker::Fallback" : "0", "Dist::Zilla::Plugin::ModuleBuildTiny" : "0.004", "Dist::Zilla::PluginBundle::Author::ETHER" : "0.025", "Pod::Coverage::TrustPod" : "0", "Test::CPAN::Changes" : "0.19", "Test::CPAN::Meta" : "0", "Test::Kwalitee" : "1.08", "Test::More" : "0", "Test::NoTabs" : "0", "Test::Pod" : "1.41", "Test::Pod::Coverage" : "1.08" } }, "runtime" : { "requires" : { "Carp" : "0", "Exporter" : "0", "Scalar::Util" : "0", "perl" : "5.006", "strict" : "0", "warnings" : "0" } }, "test" : { "requires" : { "ExtUtils::MakeMaker" : "0", "File::Spec" : "0.80", "File::Spec::Functions" : "0", "IO::Handle" : "0", "IPC::Open3" : "0", "List::Util" : "0", "Test::More" : "0.94", "vars" : "0" } } }, "provides" : { "YAML::Tiny" : { "file" : "lib/YAML/Tiny.pm", "version" : "1.56" } }, "release_status" : "stable", "resources" : { "bugtracker" : { "mailto" : "bug-YAML-Tiny@rt.cpan.org", "web" : "https://rt.cpan.org/Public/Dist/Display.html?Name=YAML-Tiny" }, "homepage" : "https://github.com/Perl-Toolchain-Gang/YAML-Tiny", "repository" : { "type" : "git", "url" : "https://github.com/Perl-Toolchain-Gang/YAML-Tiny.git", "web" : "https://github.com/Perl-Toolchain-Gang/YAML-Tiny" } }, "version" : "1.56", "x_Dist_Zilla" : { "perl" : { "version" : "5.019004" }, "plugins" : [ { "class" : "Dist::Zilla::Plugin::Git::NextVersion", "name" : "@Author::ETHER/Git::NextVersion", "version" : "2.014" }, { "class" : "Dist::Zilla::Plugin::PromptIfStale", "name" : "@Author::ETHER/build", "version" : "0.006" }, { "class" : "Dist::Zilla::Plugin::PromptIfStale", "name" : "@Author::ETHER/release", "version" : "0.006" }, { "class" : "Dist::Zilla::Plugin::ExecDir", "name" : "@Author::ETHER/ExecDir", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::ShareDir", "name" : "@Author::ETHER/ShareDir", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::FileFinder::ByName", "name" : "@Author::ETHER/Examples", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Git::GatherDir", "name" : "@Author::ETHER/Git::GatherDir", "version" : "2.014" }, { "class" : "Dist::Zilla::Plugin::MetaYAML", "name" : "@Author::ETHER/MetaYAML", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::MetaJSON", "name" : "@Author::ETHER/MetaJSON", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::License", "name" : "@Author::ETHER/License", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Readme", "name" : "@Author::ETHER/Readme", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Manifest", "name" : "@Author::ETHER/Manifest", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Test::Compile", "config" : { "Dist::Zilla::Plugin::Test::Compile" : { "module_finder" : [ ":InstallModules" ], "script_finder" : [ ":ExecFiles", "@Author::ETHER/Examples" ] } }, "name" : "@Author::ETHER/Test::Compile", "version" : "2.033" }, { "class" : "Dist::Zilla::Plugin::Test::NoTabs", "config" : { "Dist::Zilla::Plugin::Test::NoTabs" : { "module_finder" : [ ":InstallModules" ], "script_finder" : [ ":ExecFiles", "@Author::ETHER/Examples" ] } }, "name" : "@Author::ETHER/Test::NoTabs", "version" : "0.02" }, { "class" : "Dist::Zilla::Plugin::EOLTests", "name" : "@Author::ETHER/EOLTests", "version" : "0.02" }, { "class" : "Dist::Zilla::Plugin::MetaTests", "name" : "@Author::ETHER/MetaTests", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Test::Version", "name" : "@Author::ETHER/Test::Version", "version" : "0.002004" }, { "class" : "Dist::Zilla::Plugin::Test::CPAN::Changes", "name" : "@Author::ETHER/Test::CPAN::Changes", "version" : "0.008" }, { "class" : "Dist::Zilla::Plugin::Test::ChangesHasContent", "name" : "@Author::ETHER/Test::ChangesHasContent", "version" : "0.006" }, { "class" : "Dist::Zilla::Plugin::Test::UnusedVars", "name" : "@Author::ETHER/Test::UnusedVars", "version" : "2.000005" }, { "class" : "Dist::Zilla::Plugin::Test::MinimumVersion", "name" : "@Author::ETHER/Test::MinimumVersion", "version" : "2.000005" }, { "class" : "Dist::Zilla::Plugin::PodSyntaxTests", "name" : "@Author::ETHER/PodSyntaxTests", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::PodCoverageTests", "name" : "@Author::ETHER/PodCoverageTests", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Test::PodSpelling", "name" : "@Author::ETHER/Test::PodSpelling", "version" : "2.006001" }, { "class" : "Dist::Zilla::Plugin::Test::Pod::No404s", "name" : "@Author::ETHER/Test::Pod::No404s", "version" : "1.001" }, { "class" : "Dist::Zilla::Plugin::Test::Kwalitee", "name" : "@Author::ETHER/Test::Kwalitee", "version" : "2.06" }, { "class" : "Dist::Zilla::Plugin::MojibakeTests", "name" : "@Author::ETHER/MojibakeTests", "version" : "0.5" }, { "class" : "Dist::Zilla::Plugin::Test::ReportPrereqs", "name" : "@Author::ETHER/Test::ReportPrereqs", "version" : "0.006" }, { "class" : "Dist::Zilla::Plugin::PruneCruft", "name" : "@Author::ETHER/PruneCruft", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::ManifestSkip", "name" : "@Author::ETHER/ManifestSkip", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Git::Describe", "name" : "@Author::ETHER/Git::Describe", "version" : "0.003" }, { "class" : "Dist::Zilla::Plugin::PkgVersion", "name" : "@Author::ETHER/PkgVersion", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::NextRelease", "name" : "@Author::ETHER/NextRelease", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::GithubMeta", "name" : "@Author::ETHER/GithubMeta", "version" : "0.38" }, { "class" : "Dist::Zilla::Plugin::AutoMetaResources", "name" : "@Author::ETHER/AutoMetaResources", "version" : "1.20" }, { "class" : "Dist::Zilla::Plugin::Authority", "name" : "@Author::ETHER/Authority", "version" : "1.006" }, { "class" : "Dist::Zilla::Plugin::MetaNoIndex", "name" : "@Author::ETHER/MetaNoIndex", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::FinderCode", "name" : "@Author::ETHER/MetaProvides::Package/AUTOVIV/:InstallModulesPM", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::MetaProvides::Package", "config" : { "Dist::Zilla::Plugin::MetaProvides::Package" : {}, "Dist::Zilla::Role::MetaProvider::Provider" : { "inherit_missing" : "1", "inherit_version" : "1", "meta_noindex" : "1" } }, "name" : "@Author::ETHER/MetaProvides::Package", "version" : "1.15000000" }, { "class" : "Dist::Zilla::Plugin::MetaConfig", "name" : "@Author::ETHER/MetaConfig", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::AutoPrereqs", "name" : "@Author::ETHER/AutoPrereqs", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::MinimumPerl", "name" : "@Author::ETHER/MinimumPerl", "version" : "1.003" }, { "class" : "Dist::Zilla::Plugin::Prereqs", "config" : { "Dist::Zilla::Plugin::Prereqs" : { "phase" : "develop", "type" : "requires" } }, "name" : "@Author::ETHER/installer_requirements", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::ReadmeAnyFromPod", "name" : "@Author::ETHER/ReadmeAnyFromPod", "version" : "0.131500" }, { "class" : "Dist::Zilla::Plugin::MakeMaker::Fallback", "name" : "@Author::ETHER/MakeMaker::Fallback", "version" : "0.002" }, { "class" : "Dist::Zilla::Plugin::ModuleBuildTiny", "name" : "@Author::ETHER/ModuleBuildTiny", "version" : "0.005" }, { "class" : "Dist::Zilla::Plugin::InstallGuide", "name" : "@Author::ETHER/InstallGuide", "version" : "1.200000" }, { "class" : "Dist::Zilla::Plugin::CopyFilesFromBuild", "name" : "@Author::ETHER/CopyFilesFromBuild", "version" : "0.103510" }, { "class" : "Dist::Zilla::Plugin::Run::AfterBuild", "name" : "@Author::ETHER/Run::AfterBuild", "version" : "0.020" }, { "class" : "Dist::Zilla::Plugin::RunExtraTests", "name" : "@Author::ETHER/RunExtraTests", "version" : "0.011" }, { "class" : "Dist::Zilla::Plugin::Git::Check", "name" : "@Author::ETHER/Git::Check", "version" : "2.014" }, { "class" : "Dist::Zilla::Plugin::Git::CheckFor::MergeConflicts", "name" : "@Author::ETHER/Git::CheckFor::MergeConflicts", "version" : "0.006" }, { "class" : "Dist::Zilla::Plugin::Git::CheckFor::CorrectBranch", "name" : "@Author::ETHER/Git::CheckFor::CorrectBranch", "version" : "0.006" }, { "class" : "Dist::Zilla::Plugin::Git::Remote::Check", "name" : "@Author::ETHER/Git::Remote::Check", "version" : "0.1.2" }, { "class" : "Dist::Zilla::Plugin::CheckPrereqsIndexed", "name" : "@Author::ETHER/CheckPrereqsIndexed", "version" : "0.009" }, { "class" : "Dist::Zilla::Plugin::TestRelease", "name" : "@Author::ETHER/TestRelease", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::UploadToCPAN", "name" : "@Author::ETHER/UploadToCPAN", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Git::Commit", "name" : "@Author::ETHER/Git::Commit", "version" : "2.014" }, { "class" : "Dist::Zilla::Plugin::Git::Tag", "name" : "@Author::ETHER/Git::Tag", "version" : "2.014" }, { "class" : "Dist::Zilla::Plugin::GitHub::Update", "name" : "@Author::ETHER/GitHub::Update", "version" : "0.35" }, { "class" : "Dist::Zilla::Plugin::Git::Push", "name" : "@Author::ETHER/Git::Push", "version" : "2.014" }, { "class" : "Dist::Zilla::Plugin::InstallRelease", "name" : "@Author::ETHER/InstallRelease", "version" : "0.008" }, { "class" : "Dist::Zilla::Plugin::ConfirmRelease", "name" : "@Author::ETHER/ConfirmRelease", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Prereqs", "config" : { "Dist::Zilla::Plugin::Prereqs" : { "phase" : "runtime", "type" : "requires" } }, "name" : "RuntimeRequires", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::Prereqs", "config" : { "Dist::Zilla::Plugin::Prereqs" : { "phase" : "test", "type" : "requires" } }, "name" : "TestRequires", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::OnlyCorePrereqs", "name" : "OnlyCorePrereqs", "version" : "0.008" }, { "class" : "Dist::Zilla::Plugin::FinderCode", "name" : ":InstallModules", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::FinderCode", "name" : ":IncModules", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::FinderCode", "name" : ":TestFiles", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::FinderCode", "name" : ":ExecFiles", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::FinderCode", "name" : ":ShareFiles", "version" : "4.300039" }, { "class" : "Dist::Zilla::Plugin::FinderCode", "name" : ":MainModule", "version" : "4.300039" } ], "zilla" : { "class" : "Dist::Zilla::Dist::Builder", "config" : { "is_trial" : "0" }, "version" : "4.300039" } }, "x_authority" : "cpan:ADAMK" } YAML-Tiny-1.56/META.yml000644 000767 000024 00000024611 12220446250 014656 0ustar00etherstaff000000 000000 --- abstract: 'Read/Write YAML files with as little code as possible' author: - 'Adam Kennedy ' build_requires: ExtUtils::MakeMaker: 0 File::Spec: 0.80 File::Spec::Functions: 0 IO::Handle: 0 IPC::Open3: 0 List::Util: 0 Test::More: 0.94 vars: 0 configure_requires: ExtUtils::MakeMaker: 6.30 Module::Build::Tiny: 0.027 dynamic_config: 0 generated_by: 'Dist::Zilla version 4.300039, CPAN::Meta::Converter version 2.132620' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: YAML-Tiny no_index: directory: - t - xt - examples provides: YAML::Tiny: file: lib/YAML/Tiny.pm version: 1.56 requires: Carp: 0 Exporter: 0 Scalar::Util: 0 perl: 5.006 strict: 0 warnings: 0 resources: bugtracker: https://rt.cpan.org/Public/Dist/Display.html?Name=YAML-Tiny homepage: https://github.com/Perl-Toolchain-Gang/YAML-Tiny repository: https://github.com/Perl-Toolchain-Gang/YAML-Tiny.git version: 1.56 x_Dist_Zilla: perl: version: 5.019004 plugins: - class: Dist::Zilla::Plugin::Git::NextVersion name: '@Author::ETHER/Git::NextVersion' version: 2.014 - class: Dist::Zilla::Plugin::PromptIfStale name: '@Author::ETHER/build' version: 0.006 - class: Dist::Zilla::Plugin::PromptIfStale name: '@Author::ETHER/release' version: 0.006 - class: Dist::Zilla::Plugin::ExecDir name: '@Author::ETHER/ExecDir' version: 4.300039 - class: Dist::Zilla::Plugin::ShareDir name: '@Author::ETHER/ShareDir' version: 4.300039 - class: Dist::Zilla::Plugin::FileFinder::ByName name: '@Author::ETHER/Examples' version: 4.300039 - class: Dist::Zilla::Plugin::Git::GatherDir name: '@Author::ETHER/Git::GatherDir' version: 2.014 - class: Dist::Zilla::Plugin::MetaYAML name: '@Author::ETHER/MetaYAML' version: 4.300039 - class: Dist::Zilla::Plugin::MetaJSON name: '@Author::ETHER/MetaJSON' version: 4.300039 - class: Dist::Zilla::Plugin::License name: '@Author::ETHER/License' version: 4.300039 - class: Dist::Zilla::Plugin::Readme name: '@Author::ETHER/Readme' version: 4.300039 - class: Dist::Zilla::Plugin::Manifest name: '@Author::ETHER/Manifest' version: 4.300039 - class: Dist::Zilla::Plugin::Test::Compile config: Dist::Zilla::Plugin::Test::Compile: module_finder: - ':InstallModules' script_finder: - ':ExecFiles' - '@Author::ETHER/Examples' name: '@Author::ETHER/Test::Compile' version: 2.033 - class: Dist::Zilla::Plugin::Test::NoTabs config: Dist::Zilla::Plugin::Test::NoTabs: module_finder: - ':InstallModules' script_finder: - ':ExecFiles' - '@Author::ETHER/Examples' name: '@Author::ETHER/Test::NoTabs' version: 0.02 - class: Dist::Zilla::Plugin::EOLTests name: '@Author::ETHER/EOLTests' version: 0.02 - class: Dist::Zilla::Plugin::MetaTests name: '@Author::ETHER/MetaTests' version: 4.300039 - class: Dist::Zilla::Plugin::Test::Version name: '@Author::ETHER/Test::Version' version: 0.002004 - class: Dist::Zilla::Plugin::Test::CPAN::Changes name: '@Author::ETHER/Test::CPAN::Changes' version: 0.008 - class: Dist::Zilla::Plugin::Test::ChangesHasContent name: '@Author::ETHER/Test::ChangesHasContent' version: 0.006 - class: Dist::Zilla::Plugin::Test::UnusedVars name: '@Author::ETHER/Test::UnusedVars' version: 2.000005 - class: Dist::Zilla::Plugin::Test::MinimumVersion name: '@Author::ETHER/Test::MinimumVersion' version: 2.000005 - class: Dist::Zilla::Plugin::PodSyntaxTests name: '@Author::ETHER/PodSyntaxTests' version: 4.300039 - class: Dist::Zilla::Plugin::PodCoverageTests name: '@Author::ETHER/PodCoverageTests' version: 4.300039 - class: Dist::Zilla::Plugin::Test::PodSpelling name: '@Author::ETHER/Test::PodSpelling' version: 2.006001 - class: Dist::Zilla::Plugin::Test::Pod::No404s name: '@Author::ETHER/Test::Pod::No404s' version: 1.001 - class: Dist::Zilla::Plugin::Test::Kwalitee name: '@Author::ETHER/Test::Kwalitee' version: 2.06 - class: Dist::Zilla::Plugin::MojibakeTests name: '@Author::ETHER/MojibakeTests' version: 0.5 - class: Dist::Zilla::Plugin::Test::ReportPrereqs name: '@Author::ETHER/Test::ReportPrereqs' version: 0.006 - class: Dist::Zilla::Plugin::PruneCruft name: '@Author::ETHER/PruneCruft' version: 4.300039 - class: Dist::Zilla::Plugin::ManifestSkip name: '@Author::ETHER/ManifestSkip' version: 4.300039 - class: Dist::Zilla::Plugin::Git::Describe name: '@Author::ETHER/Git::Describe' version: 0.003 - class: Dist::Zilla::Plugin::PkgVersion name: '@Author::ETHER/PkgVersion' version: 4.300039 - class: Dist::Zilla::Plugin::NextRelease name: '@Author::ETHER/NextRelease' version: 4.300039 - class: Dist::Zilla::Plugin::GithubMeta name: '@Author::ETHER/GithubMeta' version: 0.38 - class: Dist::Zilla::Plugin::AutoMetaResources name: '@Author::ETHER/AutoMetaResources' version: 1.20 - class: Dist::Zilla::Plugin::Authority name: '@Author::ETHER/Authority' version: 1.006 - class: Dist::Zilla::Plugin::MetaNoIndex name: '@Author::ETHER/MetaNoIndex' version: 4.300039 - class: Dist::Zilla::Plugin::FinderCode name: '@Author::ETHER/MetaProvides::Package/AUTOVIV/:InstallModulesPM' version: 4.300039 - class: Dist::Zilla::Plugin::MetaProvides::Package config: Dist::Zilla::Plugin::MetaProvides::Package: {} Dist::Zilla::Role::MetaProvider::Provider: inherit_missing: 1 inherit_version: 1 meta_noindex: 1 name: '@Author::ETHER/MetaProvides::Package' version: 1.15000000 - class: Dist::Zilla::Plugin::MetaConfig name: '@Author::ETHER/MetaConfig' version: 4.300039 - class: Dist::Zilla::Plugin::AutoPrereqs name: '@Author::ETHER/AutoPrereqs' version: 4.300039 - class: Dist::Zilla::Plugin::MinimumPerl name: '@Author::ETHER/MinimumPerl' version: 1.003 - class: Dist::Zilla::Plugin::Prereqs config: Dist::Zilla::Plugin::Prereqs: phase: develop type: requires name: '@Author::ETHER/installer_requirements' version: 4.300039 - class: Dist::Zilla::Plugin::ReadmeAnyFromPod name: '@Author::ETHER/ReadmeAnyFromPod' version: 0.131500 - class: Dist::Zilla::Plugin::MakeMaker::Fallback name: '@Author::ETHER/MakeMaker::Fallback' version: 0.002 - class: Dist::Zilla::Plugin::ModuleBuildTiny name: '@Author::ETHER/ModuleBuildTiny' version: 0.005 - class: Dist::Zilla::Plugin::InstallGuide name: '@Author::ETHER/InstallGuide' version: 1.200000 - class: Dist::Zilla::Plugin::CopyFilesFromBuild name: '@Author::ETHER/CopyFilesFromBuild' version: 0.103510 - class: Dist::Zilla::Plugin::Run::AfterBuild name: '@Author::ETHER/Run::AfterBuild' version: 0.020 - class: Dist::Zilla::Plugin::RunExtraTests name: '@Author::ETHER/RunExtraTests' version: 0.011 - class: Dist::Zilla::Plugin::Git::Check name: '@Author::ETHER/Git::Check' version: 2.014 - class: Dist::Zilla::Plugin::Git::CheckFor::MergeConflicts name: '@Author::ETHER/Git::CheckFor::MergeConflicts' version: 0.006 - class: Dist::Zilla::Plugin::Git::CheckFor::CorrectBranch name: '@Author::ETHER/Git::CheckFor::CorrectBranch' version: 0.006 - class: Dist::Zilla::Plugin::Git::Remote::Check name: '@Author::ETHER/Git::Remote::Check' version: 0.1.2 - class: Dist::Zilla::Plugin::CheckPrereqsIndexed name: '@Author::ETHER/CheckPrereqsIndexed' version: 0.009 - class: Dist::Zilla::Plugin::TestRelease name: '@Author::ETHER/TestRelease' version: 4.300039 - class: Dist::Zilla::Plugin::UploadToCPAN name: '@Author::ETHER/UploadToCPAN' version: 4.300039 - class: Dist::Zilla::Plugin::Git::Commit name: '@Author::ETHER/Git::Commit' version: 2.014 - class: Dist::Zilla::Plugin::Git::Tag name: '@Author::ETHER/Git::Tag' version: 2.014 - class: Dist::Zilla::Plugin::GitHub::Update name: '@Author::ETHER/GitHub::Update' version: 0.35 - class: Dist::Zilla::Plugin::Git::Push name: '@Author::ETHER/Git::Push' version: 2.014 - class: Dist::Zilla::Plugin::InstallRelease name: '@Author::ETHER/InstallRelease' version: 0.008 - class: Dist::Zilla::Plugin::ConfirmRelease name: '@Author::ETHER/ConfirmRelease' version: 4.300039 - class: Dist::Zilla::Plugin::Prereqs config: Dist::Zilla::Plugin::Prereqs: phase: runtime type: requires name: RuntimeRequires version: 4.300039 - class: Dist::Zilla::Plugin::Prereqs config: Dist::Zilla::Plugin::Prereqs: phase: test type: requires name: TestRequires version: 4.300039 - class: Dist::Zilla::Plugin::OnlyCorePrereqs name: OnlyCorePrereqs version: 0.008 - class: Dist::Zilla::Plugin::FinderCode name: ':InstallModules' version: 4.300039 - class: Dist::Zilla::Plugin::FinderCode name: ':IncModules' version: 4.300039 - class: Dist::Zilla::Plugin::FinderCode name: ':TestFiles' version: 4.300039 - class: Dist::Zilla::Plugin::FinderCode name: ':ExecFiles' version: 4.300039 - class: Dist::Zilla::Plugin::FinderCode name: ':ShareFiles' version: 4.300039 - class: Dist::Zilla::Plugin::FinderCode name: ':MainModule' version: 4.300039 zilla: class: Dist::Zilla::Dist::Builder config: is_trial: 0 version: 4.300039 x_authority: cpan:ADAMK YAML-Tiny-1.56/README000644 000767 000024 00000000473 12220446250 014265 0ustar00etherstaff000000 000000 This archive contains the distribution YAML-Tiny, version 1.56: Read/Write YAML files with as little code as possible This software is copyright (c) 2006 by Adam Kennedy. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. YAML-Tiny-1.56/t/000755 000767 000024 00000000000 12220446251 013645 5ustar00etherstaff000000 000000 YAML-Tiny-1.56/xt/000755 000767 000024 00000000000 12220446251 014035 5ustar00etherstaff000000 000000 YAML-Tiny-1.56/xt/author/000755 000767 000024 00000000000 12220446251 015337 5ustar00etherstaff000000 000000 YAML-Tiny-1.56/xt/release/000755 000767 000024 00000000000 12220446251 015455 5ustar00etherstaff000000 000000 YAML-Tiny-1.56/xt/release/changes_has_content.t000644 000767 000024 00000002010 12220446251 021630 0ustar00etherstaff000000 000000 #!perl use Test::More tests => 2; note 'Checking Changes'; my $changes_file = 'Changes'; my $newver = '1.56'; my $trial_token = '-TRIAL'; SKIP: { ok(-e $changes_file, "$changes_file file exists") or skip 'Changes is missing', 1; ok(_get_changes($newver), "$changes_file has content for $newver"); } done_testing; # _get_changes copied and adapted from Dist::Zilla::Plugin::Git::Commit # by Jerome Quelin sub _get_changes { my $newver = shift; # parse changelog to find commit message open(my $fh, '<', $changes_file) or die "cannot open $changes_file: $!"; my $changelog = join('', <$fh>); close $fh; my @content = grep { /^$newver(?:$trial_token)?(?:\s+|$)/ ... /^\S/ } # from newver to un-indented split /\n/, $changelog; shift @content; # drop the version line # drop unindented last line and trailing blank lines pop @content while ( @content && $content[-1] =~ /^(?:\S|\s*$)/ ); # return number of non-blank lines return scalar @content; } YAML-Tiny-1.56/xt/release/cpan-changes.t000644 000767 000024 00000000263 12220446251 020172 0ustar00etherstaff000000 000000 #!perl use strict; use warnings; use Test::More 0.96 tests => 2; use_ok('Test::CPAN::Changes'); subtest 'changes_ok' => sub { changes_file_ok('Changes'); }; done_testing(); YAML-Tiny-1.56/xt/release/distmeta.t000644 000767 000024 00000000217 12220446251 017454 0ustar00etherstaff000000 000000 #!perl use Test::More; eval "use Test::CPAN::Meta"; plan skip_all => "Test::CPAN::Meta required for testing META.yml" if $@; meta_yaml_ok(); YAML-Tiny-1.56/xt/release/eol.t000644 000767 000024 00000000240 12220446251 016415 0ustar00etherstaff000000 000000 use strict; use warnings; use Test::More; eval 'use Test::EOL'; plan skip_all => 'Test::EOL required' if $@; all_perl_files_ok({ trailing_whitespace => 1 }); YAML-Tiny-1.56/xt/release/kwalitee.t000644 000767 000024 00000000156 12220446251 017451 0ustar00etherstaff000000 000000 # This test is generated by Dist::Zilla::Plugin::Test::Kwalitee use strict; use warnings; use Test::Kwalitee; YAML-Tiny-1.56/xt/release/minimum-version.t000644 000767 000024 00000000271 12220446251 021000 0ustar00etherstaff000000 000000 #!perl use Test::More; eval "use Test::MinimumVersion"; plan skip_all => "Test::MinimumVersion required for testing minimum versions" if $@; all_minimum_version_ok( qq{5.008001} ); YAML-Tiny-1.56/xt/release/mojibake.t000644 000767 000024 00000000406 12220446251 017423 0ustar00etherstaff000000 000000 #!perl use strict; use warnings qw(all); use Test::More; ## no critic (ProhibitStringyEval, RequireCheckingReturnValueOfEval) eval q(use Test::Mojibake); plan skip_all => q(Test::Mojibake required for source encoding testing) if $@; all_files_encoding_ok(); YAML-Tiny-1.56/xt/release/no-tabs.t000644 000767 000024 00000000337 12220446251 017210 0ustar00etherstaff000000 000000 use strict; use warnings; # this test was generated with Dist::Zilla::Plugin::Test::NoTabs 0.02 use Test::More 0.88; use Test::NoTabs; my @files = ( 'lib/YAML/Tiny.pm' ); notabs_ok($_) foreach @files; done_testing; YAML-Tiny-1.56/xt/release/pod-coverage.t000644 000767 000024 00000000527 12220446251 020221 0ustar00etherstaff000000 000000 #!perl use Test::More; eval "use Test::Pod::Coverage 1.08"; plan skip_all => "Test::Pod::Coverage 1.08 required for testing POD coverage" if $@; eval "use Pod::Coverage::TrustPod"; plan skip_all => "Pod::Coverage::TrustPod required for testing POD coverage" if $@; all_pod_coverage_ok({ coverage_class => 'Pod::Coverage::TrustPod' }); YAML-Tiny-1.56/xt/release/pod-no404s.t000644 000767 000024 00000000527 12220446251 017455 0ustar00etherstaff000000 000000 #!perl use strict; use warnings; use Test::More; foreach my $env_skip ( qw( SKIP_POD_NO404S AUTOMATED_TESTING ) ){ plan skip_all => "\$ENV{$env_skip} is set, skipping" if $ENV{$env_skip}; } eval "use Test::Pod::No404s"; if ( $@ ) { plan skip_all => 'Test::Pod::No404s required for testing POD'; } else { all_pod_files_ok(); } YAML-Tiny-1.56/xt/release/pod-syntax.t000644 000767 000024 00000000212 12220446251 017743 0ustar00etherstaff000000 000000 #!perl use Test::More; eval "use Test::Pod 1.41"; plan skip_all => "Test::Pod 1.41 required for testing POD" if $@; all_pod_files_ok(); YAML-Tiny-1.56/xt/release/test-version.t000644 000767 000024 00000000643 12220446251 020307 0ustar00etherstaff000000 000000 use strict; use warnings; use Test::More; # generated by Dist::Zilla::Plugin::Test::Version 0.002004 BEGIN { eval "use Test::Version; 1;" or die $@; } my @imports = ( 'version_all_ok' ); my $params = { is_strict => 1, has_version => 1, }; push @imports, $params if version->parse( $Test::Version::VERSION ) >= version->parse('1.002'); Test::Version->import(@imports); version_all_ok; done_testing; YAML-Tiny-1.56/xt/release/unused-vars.t000644 000767 000024 00000000207 12220446251 020115 0ustar00etherstaff000000 000000 #!perl use Test::More; eval "use Test::Vars"; plan skip_all => "Test::Vars required for testing unused vars" if $@; all_vars_ok(); YAML-Tiny-1.56/xt/author/pod-spell.t000644 000767 000024 00000000406 12220446251 017423 0ustar00etherstaff000000 000000 use strict; use warnings; use Test::More; # generated by Dist::Zilla::Plugin::Test::PodSpelling 2.006001 use Test::Spelling 0.12; use Pod::Wordlist; add_stopwords(); all_pod_files_spelling_ok( qw( bin lib ) ); __DATA__ Adam Kennedy adamk lib YAML Tiny YAML-Tiny-1.56/t/00-compile.t000644 000767 000024 00000001737 12220446251 015707 0ustar00etherstaff000000 000000 use strict; use warnings; # this test was generated with Dist::Zilla::Plugin::Test::Compile 2.033 use Test::More 0.94 tests => 1 + ($ENV{AUTHOR_TESTING} ? 1 : 0); my @module_files = ( 'YAML/Tiny.pm' ); # no fake home requested use File::Spec; use IPC::Open3; use IO::Handle; my @warnings; for my $lib (@module_files) { # see L open my $stdin, '<', File::Spec->devnull or die "can't open devnull: $!"; my $stderr = IO::Handle->new; my $pid = open3($stdin, '>&STDERR', $stderr, $^X, '-Mblib', '-e', "require q[$lib]"); binmode $stderr, ':crlf' if $^O eq 'MSWin32'; my @_warnings = <$stderr>; waitpid($pid, 0); is($? >> 8, 0, "$lib loaded ok"); if (@_warnings) { warn @_warnings; push @warnings, @_warnings; } } is(scalar(@warnings), 0, 'no warnings found') if $ENV{AUTHOR_TESTING}; BAIL_OUT("Compilation problems") if !Test::More->builder->is_passing; YAML-Tiny-1.56/t/00-report-prereqs.t000644 000767 000024 00000003132 12220446251 017240 0ustar00etherstaff000000 000000 #!perl use strict; use warnings; use Test::More tests => 1; use ExtUtils::MakeMaker; use File::Spec::Functions; use List::Util qw/max/; my @modules = qw( Carp Exporter ExtUtils::MakeMaker File::Spec File::Spec::Functions IO::Handle IPC::Open3 List::Util Module::Build::Tiny Scalar::Util Test::More perl strict vars warnings ); # replace modules with dynamic results from MYMETA.json if we can # (hide CPAN::Meta from prereq scanner) my $cpan_meta = "CPAN::Meta"; if ( -f "MYMETA.json" && eval "require $cpan_meta" ) { ## no critic if ( my $meta = eval { CPAN::Meta->load_file("MYMETA.json") } ) { my $prereqs = $meta->prereqs; delete $prereqs->{develop}; my %uniq = map {$_ => 1} map { keys %$_ } map { values %$_ } values %$prereqs; $uniq{$_} = 1 for @modules; # don't lose any static ones @modules = sort keys %uniq; } } my @reports = [qw/Version Module/]; for my $mod ( @modules ) { next if $mod eq 'perl'; my $file = $mod; $file =~ s{::}{/}g; $file .= ".pm"; my ($prefix) = grep { -e catfile($_, $file) } @INC; if ( $prefix ) { my $ver = MM->parse_version( catfile($prefix, $file) ); $ver = "undef" unless defined $ver; # Newer MM should do this anyway push @reports, [$ver, $mod]; } else { push @reports, ["missing", $mod]; } } if ( @reports ) { my $vl = max map { length $_->[0] } @reports; my $ml = max map { length $_->[1] } @reports; splice @reports, 1, 0, ["-" x $vl, "-" x $ml]; diag "Prerequisite Report:\n", map {sprintf(" %*s %*s\n",$vl,$_->[0],-$ml,$_->[1])} @reports; } pass; # vim: ts=2 sts=2 sw=2 et: YAML-Tiny-1.56/t/01_compile.t000644 000767 000024 00000000462 12220446251 015764 0ustar00etherstaff000000 000000 # Load testing for YAML::Tiny use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use Test::More tests => 3; # Check their perl version ok( $] >= 5.004, "Your perl is new enough" ); # Does the module load use_ok( 'YAML::Tiny' ); use_ok( 't::lib::Test' ); YAML-Tiny-1.56/t/02_basic.t000644 000767 000024 00000007164 12220446251 015424 0ustar00etherstaff000000 000000 # Testing of basic document structures use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(30); use YAML::Tiny; ##################################################################### # Sample Testing # Test a completely empty document yaml_ok( '', [ ], 'empty', ); # Just a newline ### YAML.pm has a bug where it dies on a single newline yaml_ok( "\n\n", [ ], 'only_newlines', ); # Just a comment yaml_ok( "# comment\n", [ ], 'only_comment', ); # Empty documents yaml_ok( "---\n", [ undef ], 'only_header', noyamlperl => 1, ); yaml_ok( "---\n---\n", [ undef, undef ], 'two_header', noyamlperl => 1, ); yaml_ok( "--- ~\n", [ undef ], 'one_undef', noyamlperl => 1, ); yaml_ok( "--- ~\n", [ undef ], 'one_undef2', noyamlperl => 1, ); yaml_ok( "--- ~\n---\n", [ undef, undef ], 'two_undef', noyamlperl => 1, ); # Just a scalar yaml_ok( "--- foo\n", [ 'foo' ], 'one_scalar', ); yaml_ok( "--- foo\n", [ 'foo' ], 'one_scalar2', ); yaml_ok( "--- foo\n--- bar\n", [ 'foo', 'bar' ], 'two_scalar', noyamlperl => 1, ); # Simple lists yaml_ok( "---\n- foo\n", [ [ 'foo' ] ], 'one_list1', ); yaml_ok( "---\n- foo\n- bar\n", [ [ 'foo', 'bar' ] ], 'one_list2', ); yaml_ok( "---\n- ~\n- bar\n", [ [ undef, 'bar' ] ], 'one_listundef', noyamlperl => 1, ); # Simple hashs yaml_ok( "---\nfoo: bar\n", [ { foo => 'bar' } ], 'one_hash1', ); yaml_ok( "---\nfoo: bar\nthis: ~\n", [ { this => undef, foo => 'bar' } ], 'one_hash2', noyamlperl => 1, ); # Simple array inside a hash with an undef yaml_ok( <<'END_YAML', --- foo: - bar - ~ - baz END_YAML [ { foo => [ 'bar', undef, 'baz' ] } ], 'array_in_hash', noyamlperl => 1, ); # Simple hash inside a hash with an undef yaml_ok( <<'END_YAML', --- foo: ~ bar: foo: bar END_YAML [ { foo => undef, bar => { foo => 'bar' } } ], 'hash_in_hash', noyamlperl => 1, ); # Mixed hash and scalars inside an array yaml_ok( <<'END_YAML', --- - foo: ~ this: that - foo - ~ - foo: bar this: that END_YAML [ [ { foo => undef, this => 'that' }, 'foo', undef, { foo => 'bar', this => 'that' }, ] ], 'hash_in_array', noyamlperl => 1, ); # Simple single quote yaml_ok( "---\n- 'foo'\n", [ [ 'foo' ] ], 'single_quote1', ); yaml_ok( "---\n- ' '\n", [ [ ' ' ] ], 'single_spaces', ); yaml_ok( "---\n- ''\n", [ [ '' ] ], 'single_null', ); # Double quotes yaml_ok( "--- \" \"\n", [ ' ' ], "only_spaces", noyamlpm => 1, noyamlperl => 1, ); yaml_ok( "--- \" foo\"\n--- \"bar \"\n", [ " foo", "bar " ], "leading_trailing_spaces", noyamlpm => 1, noyamlperl => 1, ); # Implicit document start yaml_ok( "foo: bar\n", [ { foo => 'bar' } ], 'implicit_hash', ); yaml_ok( "- foo\n", [ [ 'foo' ] ], 'implicit_array', ); # Inline nested hash yaml_ok( <<'END_YAML', --- - ~ - foo: bar this: that - baz END_YAML [ [ undef, { foo => 'bar', this => 'that' }, 'baz' ] ], 'inline_nested_hash', noyamlperl => 1, ); # Empty comments yaml_ok( "---\n- foo\n#\n- bar\n", [ [ 'foo', 'bar' ] ], 'empty_comment_in_list', ); yaml_ok( "---\nfoo: bar\n# foo\none: two\n", [ { foo => 'bar', one => 'two' } ], 'empty_comment_in_hash', ); # Complex keys yaml_ok( "---\na b: c d\n", [ { 'a b' => 'c d' } ], 'key_with_whitespace', ); YAML-Tiny-1.56/t/03_regression.t000755 000767 000024 00000025632 12220446251 016527 0ustar00etherstaff000000 000000 # Testing of common META.yml examples use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(37, 0, 13); use YAML::Tiny qw{ Load Dump LoadFile DumpFile freeze thaw }; ##################################################################### # Check Exports ok( defined(&Load), 'Found exported Load function' ); ok( defined(&Dump), 'Found exported Dump function' ); ok( defined(&LoadFile), 'Found exported LoadFile function' ); ok( defined(&DumpFile), 'Found exported DumpFile function' ); ok( defined(&freeze), 'Found exported freeze function' ); ok( defined(&thaw), 'Found exported thaw functiona' ); ##################################################################### # In META.yml files, some hash keys contain module names # Hash key legally containing a colon yaml_ok( "---\nFoo::Bar: 1\n", [ { 'Foo::Bar' => 1 } ], 'module_hash_key', ); # Hash indented yaml_ok( "---\n" . " foo: bar\n", [ { foo => "bar" } ], 'hash_indented', ); ##################################################################### # Support for literal multi-line scalars # Declarative multi-line scalar yaml_ok( "---\n" . " foo: >\n" . " bar\n" . " baz\n", [ { foo => "bar baz\n" } ], 'simple_multiline', ); # Piped multi-line scalar yaml_ok( <<'END_YAML', --- - | foo bar - 1 END_YAML [ [ "foo\nbar\n", 1 ] ], 'indented', ); # ... with a pointless hyphen yaml_ok( <<'END_YAML', --- - |- foo bar - 1 END_YAML [ [ "foo\nbar", 1 ] ], 'indented', ); ##################################################################### # Support for YAML version directives # Simple inline case (comment variant) yaml_ok( <<'END_YAML', --- #YAML:1.0 foo: bar END_YAML [ { foo => 'bar' } ], 'simple_doctype_comment', nosyck => 1, ); # Simple inline case (percent variant) yaml_ok( <<'END_YAML', --- %YAML:1.0 foo: bar END_YAML [ { foo => 'bar' } ], 'simple_doctype_percent', noyamlpm => 1, noxs => 1, noyamlperl => 1, ); # Simple header (comment variant) yaml_ok( <<'END_YAML', %YAML:1.0 --- foo: bar END_YAML [ { foo => 'bar' } ], 'predocument_1_0', noyamlpm => 1, nosyck => 1, noxs => 1, noyamlperl => 1, ); # Simple inline case (comment variant) yaml_ok( <<'END_YAML', %YAML 1.1 --- foo: bar END_YAML [ { foo => 'bar' } ], 'predocument_1_1', noyamlpm => 1, nosyck => 1, noyamlperl => 1, ); # Multiple inline documents (comment variant) yaml_ok( <<'END_YAML', --- #YAML:1.0 foo: bar --- #YAML:1.0 - 1 --- #YAML:1.0 foo: bar END_YAML [ { foo => 'bar' }, [ 1 ], { foo => 'bar' } ], 'multi_doctype_comment', ); # Simple pre-document case (comment variant) yaml_ok( <<'END_YAML', %YAML 1.1 --- foo: bar END_YAML [ { foo => 'bar' } ], 'predocument_percent', noyamlpm => 1, nosyck => 1, noyamlperl => 1, ); # Simple pre-document case (comment variant) yaml_ok( <<'END_YAML', #YAML 1.1 --- foo: bar END_YAML [ { foo => 'bar' } ], 'predocument_comment', ); ##################################################################### # Hitchhiker Scalar yaml_ok( <<'END_YAML', --- 42 END_YAML [ 42 ], 'hitchhiker scalar', serializes => 1, ); ##################################################################### # Null HASH/ARRAY yaml_ok( <<'END_YAML', --- - foo - {} - bar END_YAML [ [ 'foo', {}, 'bar' ] ], 'null hash in array', ); yaml_ok( <<'END_YAML', --- - foo - [] - bar END_YAML [ [ 'foo', [], 'bar' ] ], 'null array in array', ); yaml_ok( <<'END_YAML', --- foo: {} bar: 1 END_YAML [ { foo => {}, bar => 1 } ], 'null hash in hash', ); yaml_ok( <<'END_YAML', --- foo: [] bar: 1 END_YAML [ { foo => [], bar => 1 } ], 'null array in hash', ); ##################################################################### # Trailing Whitespace yaml_ok( <<'END_YAML', --- abstract: Generate fractal curves foo: ~ arr: - foo - ~ - 'bar' END_YAML [ { abstract => 'Generate fractal curves', foo => undef, arr => [ 'foo', undef, 'bar' ], } ], 'trailing whitespace', noyamlperl => 1, ); ##################################################################### # Quote vs Hash yaml_ok( <<'END_YAML', --- author: - 'mst: Matt S. Trout ' END_YAML [ { author => [ 'mst: Matt S. Trout ' ] } ], 'hash-like quote', ); ##################################################################### # Quote and Escaping Idiosyncracies yaml_ok( <<'END_YAML', --- name1: 'O''Reilly' name2: 'O''Reilly O''Tool' name3: 'Double '''' Quote' END_YAML [ { name1 => "O'Reilly", name2 => "O'Reilly O'Tool", name3 => "Double '' Quote", } ], 'single quote subtleties', ); yaml_ok( <<'END_YAML', --- slash1: '\\' slash2: '\\foo' slash3: '\\foo\\\\' END_YAML [ { slash1 => "\\\\", slash2 => "\\\\foo", slash3 => "\\\\foo\\\\\\\\", } ], 'single quote subtleties', ); ##################################################################### # Empty Values and Premature EOF yaml_ok( <<'END_YAML', --- foo: 0 requires: build_requires: END_YAML [ { foo => 0, requires => undef, build_requires => undef } ], 'empty hash keys', noyamlpm => 1, noyamlperl => 1, ); yaml_ok( <<'END_YAML', --- - foo - - END_YAML [ [ 'foo', undef, undef ] ], 'empty array keys', noyamlpm => 1, noyamlperl => 1, ); ##################################################################### # Comment on the Document Line yaml_ok( <<'END_YAML', --- # Comment foo: bar END_YAML [ { foo => 'bar' } ], 'comment header', noyamlpm => 1, noyamlperl => 1, ); ##################################################################### # Newlines and tabs yaml_ok( <<'END_YAML', foo: "foo\\\n\tbar" END_YAML [ { foo => "foo\\\n\tbar" } ], 'special characters', ); ##################################################################### # Circular Reference Protection SCOPE: { my $foo = { a => 'b' }; my $bar = [ $foo, 2 ]; $foo->{c} = $bar; my $circ = YAML::Tiny->new( [ $foo, $bar ] ); isa_ok( $circ, 'YAML::Tiny' ); # When we try to serialize, it should NOT infinite loop my $string = undef; $string = eval { $circ->write_string; }; is( $string, undef, '->write_string does not return a value' ); ok( $@, 'Error string is defined' ); ok( $@ =~ /does not support circular references/, 'Got the expected error message', ); } ##################################################################### # Confirm we can read the synopsis yaml_ok( <<'END_YAML', --- rootproperty: blah section: one: two three: four Foo: Bar empty: ~ END_YAML [ { rootproperty => 'blah', section => { one => 'two', three => 'four', Foo => 'Bar', empty => undef, }, } ], 'synopsis', noyamlperl => 1, ); ##################################################################### # Unprintable Characters yaml_ok( "--- \"foo\\n\\x00\"\n", [ "foo\n\0" ], 'unprintable', ); ##################################################################### # Empty Quote Line yaml_ok( <<'END_YAML', --- - foo # - bar END_YAML [ [ "foo", "bar" ] ], ); ##################################################################### # Indentation after empty hash value yaml_ok( <<'END_YAML', --- Test: optmods: Bad: 0 Foo: 1 Long: 0 version: 5 Test_IncludeA: optmods: Test_IncludeB: optmods: _meta: name: 'test profile' note: 'note this test profile' END_YAML [ { Test => { optmods => { Bad => 0, Foo => 1, Long => 0, }, version => 5, }, Test_IncludeA => { optmods => undef, }, Test_IncludeB => { optmods => undef, }, _meta => { name => 'test profile', note => 'note this test profile', }, } ], 'Indentation after empty hash value', noyamlperl => 1, ); ##################################################################### # Spaces in the Key yaml_ok( <<'END_YAML', --- the key: the value END_YAML [ { 'the key' => 'the value' } ], ); ##################################################################### # Ticker #32402 # Tests a particular pathological case yaml_ok( <<'END_YAML', --- - value - '><' END_YAML [ [ 'value', '><' ] ], 'Pathological >< case', ); ##################################################################### # Special Characters #yaml_ok( # <<'END_YAML', #--- #- "Ingy d\xC3\xB6t Net" #END_YAML # [ [ "Ingy d\xC3\xB6t Net" ] ], #); ###################################################################### # Non-Indenting Sub-List yaml_ok( <<'END_YAML', --- foo: - list bar: value END_YAML [ { foo => [ 'list' ], bar => 'value' } ], 'Non-indenting sub-list', noyamlpm => 1, noyamlperl => 1, ); ##################################################################### # Check Multiple-Escaping # RT #42119: write of two single quotes yaml_ok( "--- \"A'B'C\"\n", [ "A'B'C" ], 'Multiple escaping of quote ok', ); # Escapes without whitespace yaml_ok( "--- A\\B\\C\n", [ "A\\B\\C" ], 'Multiple escaping of escape ok', ); # Escapes with whitespace yaml_ok( "--- 'A\\B \\C'\n", [ "A\\B \\C" ], 'Multiple escaping of escape with whitespace ok', ); ###################################################################### # Check illegal characters that are in legal places yaml_ok( "--- 'Wow!'\n", [ "Wow!" ], 'Bang in a quote', ); yaml_ok( "--- 'This&that'\n", [ "This&that" ], 'Ampersand in a quote', ); ###################################################################### # Check for unescaped boolean keywords is_deeply( YAML::Tiny->new( 'True' )->write_string, "--- 'True'\n", 'Idiomatic trivial boolean string is escaped', ); is_deeply( YAML::Tiny->new( [ qw{ null Null NULL y Y yes Yes YES n N no No NO true True TRUE false False FALSE on On ON off Off OFF } ] )->write_string, <<'END_YAML' ); --- - 'null' - 'Null' - 'NULL' - 'y' - 'Y' - 'yes' - 'Yes' - 'YES' - 'n' - 'N' - 'no' - 'No' - 'NO' - 'true' - 'True' - 'TRUE' - 'false' - 'False' - 'FALSE' - 'on' - 'On' - 'ON' - 'off' - 'Off' - 'OFF' END_YAML ###################################################################### # Always quote for scalars ending with : is_deeply( YAML::Tiny->new( [ 'A:' ] )->write_string, "---\n- 'A:'\n", 'Simple scalar ending in a colon is correctly quoted', ); YAML-Tiny-1.56/t/04_scalar.t000644 000767 000024 00000006334 12220446251 015610 0ustar00etherstaff000000 000000 # Testing of scalar-context calls to the compatibility functions use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More; BEGIN { if ( t::lib::Test->have_yamlpm ) { plan( tests => 18 ); } else { plan( skip_all => 'Requires YAML.pm' ); exit(0); } } use YAML (); use YAML::Tiny (); ##################################################################### # Sample documents my $one = <<'END_YAML'; --- - foo END_YAML my $two = <<'END_YAML'; --- - foo --- - bar END_YAML ##################################################################### # Match Listwise Behaviour SCOPE: { my $one_list_pm = [ YAML::Load( $one ) ]; my $two_list_pm = [ YAML::Load( $two ) ]; my $one_list_tiny = [ YAML::Tiny::Load( $one ) ]; my $two_list_tiny = [ YAML::Tiny::Load( $two ) ]; is_deeply( $one_list_pm, [ [ 'foo' ] ], 'one: Parsed correctly' ); is_deeply( $one_list_pm, $one_list_tiny, 'one: List context matches' ); is_deeply( $two_list_pm, [ [ 'foo' ], [ 'bar' ] ], 'two: Parsed correctly' ); is_deeply( $two_list_pm, $two_list_tiny, 'two: List context matches' ); } ##################################################################### # Match Scalar Behaviour SCOPE: { my $one_scalar_pm = YAML::Load( $one ); my $two_scalar_pm = YAML::Load( $two ); my $one_scalar_tiny = YAML::Tiny::Load( $one ); my $two_scalar_tiny = YAML::Tiny::Load( $two ); is_deeply( $one_scalar_pm, [ 'foo' ], 'one: Parsed correctly' ); is_deeply( $one_scalar_pm, $one_scalar_tiny, 'one: Scalar context matches' ); is_deeply( $two_scalar_pm, [ 'bar' ], 'two: Parsed correctly' ); is_deeply( $two_scalar_pm, $two_scalar_tiny, 'two: Scalar context matches' ); } ##################################################################### # Repeat for LoadFile my $one_file = catfile(qw{ t data one.yml }); my $two_file = catfile(qw{ t data two.yml }); ok( -f $one_file, "Found $one_file" ); ok( -f $two_file, "Found $two_file" ); SCOPE: { my $one_list_pm = [ YAML::LoadFile( $one_file ) ]; my $two_list_pm = [ YAML::LoadFile( $two_file ) ]; my $one_list_tiny = [ YAML::Tiny::LoadFile( $one_file ) ]; my $two_list_tiny = [ YAML::Tiny::LoadFile( $two_file ) ]; is_deeply( $one_list_pm, [ [ 'foo' ] ], 'one: Parsed correctly' ); is_deeply( $one_list_pm, $one_list_tiny, 'one: List context matches' ); is_deeply( $two_list_pm, [ [ 'foo' ], [ 'bar' ] ], 'two: Parsed correctly' ); is_deeply( $two_list_pm, $two_list_tiny, 'two: List context matches' ); } SCOPE: { my $one_scalar_pm = YAML::LoadFile( $one_file ); my $two_scalar_pm = YAML::LoadFile( $two_file ); my $one_scalar_tiny = YAML::Tiny::LoadFile( $one_file ); my $two_scalar_tiny = YAML::Tiny::LoadFile( $two_file ); is_deeply( $one_scalar_pm, [ 'foo' ], 'one: Parsed correctly' ); is_deeply( $one_scalar_pm, $one_scalar_tiny, 'one: Scalar context matches' ); is_deeply( $two_scalar_pm, [ 'bar' ], 'two: Parsed correctly' ); is_deeply( $two_scalar_pm, $two_scalar_tiny, 'two: Scalar context matches' ); } YAML-Tiny-1.56/t/05_export.t000644 000767 000024 00000000723 12220446251 015661 0ustar00etherstaff000000 000000 # Testing of basic document structures use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use Test::More tests => 6; use YAML::Tiny; ok defined &main::Load, 'Load is exported'; ok defined &main::Dump, 'Dump is exported'; ok not(defined &main::LoadFile), 'Load is exported'; ok not(defined &main::DumpFile), 'Dump is exported'; ok \&main::Load == \&YAML::Tiny::Load, 'Load is YAML::Tiny'; ok \&main::Dump == \&YAML::Tiny::Dump, 'Dump is YAML::Tiny'; YAML-Tiny-1.56/t/11_meta_yml.t000755 000767 000024 00000025034 12220446251 016151 0ustar00etherstaff000000 000000 # Testing of common META.yml examples use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(8, 3); use YAML::Tiny; ##################################################################### # Testing YAML::Tiny's own META.yml file yaml_ok( <<'END_YAML', abstract: Read/Write YAML files with as little code as possible author: 'Adam Kennedy ' build_requires: File::Spec: 0.80 Test::More: 0.47 distribution_type: module generated_by: Module::Install version 0.63 license: perl name: YAML-Tiny no_index: directory: - inc - t requires: perl: 5.005 version: 0.03 END_YAML [ { abstract => 'Read/Write YAML files with as little code as possible', author => 'Adam Kennedy ', build_requires => { 'File::Spec' => '0.80', 'Test::More' => '0.47', }, distribution_type => 'module', generated_by => 'Module::Install version 0.63', license => 'perl', name => 'YAML-Tiny', no_index => { directory => [ qw{inc t} ], }, requires => { perl => '5.005', }, version => '0.03', } ], 'YAML::Tiny', ); ##################################################################### # Testing a META.yml from a commercial project that crashed yaml_ok( <<'END_YAML', # http://module-build.sourceforge.net/META-spec.html #XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX# name: ITS-SIN-FIDS-Content-XML version: 0.01 version_from: lib/ITS/SIN/FIDS/Content/XML.pm installdirs: site requires: Test::More: 0.45 XML::Simple: 2 distribution_type: module generated_by: ExtUtils::MakeMaker version 6.30 END_YAML [ { name => 'ITS-SIN-FIDS-Content-XML', version => "0.01", # this kludge is to prevent floating point comparison errors version_from => 'lib/ITS/SIN/FIDS/Content/XML.pm', installdirs => 'site', requires => { 'Test::More' => 0.45, 'XML::Simple' => 2, }, distribution_type => 'module', generated_by => 'ExtUtils::MakeMaker version 6.30', } ], 'YAML::Tiny', ); ##################################################################### # Testing various failing META.yml files from CPAN yaml_ok( <<'END_YAML', --- abstract: Mii in Nintendo Wii data parser and builder author: Toru Yamaguchi distribution_type: module generated_by: Module::Install version 0.65 license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.3.html version: 1.3 name: Games-Nintendo-Wii-Mii no_index: directory: - inc - t requires: Carp: 1.03 Class::Accessor::Fast: 0.3 File::Slurp: 9999.12 IO::File: 1.1 Readonly: 0 Tie::IxHash: 1.21 URI: 1.35 XML::LibXML: 1.62 version: 0.02 END_YAML [ { abstract => 'Mii in Nintendo Wii data parser and builder', author => 'Toru Yamaguchi ', distribution_type => 'module', generated_by => 'Module::Install version 0.65', license => 'perl', 'meta-spec' => { url => 'http://module-build.sourceforge.net/META-spec-v1.3.html', version => '1.3', }, name => 'Games-Nintendo-Wii-Mii', no_index => { directory => [ qw{ inc t } ], }, requires => { 'Carp' => '1.03', 'Class::Accessor::Fast' => '0.3', 'File::Slurp' => '9999.12', 'IO::File' => '1.1', 'Readonly' => '0', 'Tie::IxHash' => '1.21', 'URI' => '1.35', 'XML::LibXML' => '1.62', }, version => '0.02', } ], 'Games-Nintendo-Wii-Mii', ); yaml_ok( <<'END_YAML', # http://module-build.sourceforge.net/META-spec.html #XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX# name: Acme-Time-Baby version: 2.106 version_from: Baby.pm installdirs: site requires: warnings: distribution_type: module generated_by: ExtUtils::MakeMaker version 6.17 END_YAML [ { name => 'Acme-Time-Baby', version => '2.106', version_from => 'Baby.pm', installdirs => 'site', requires => { warnings => undef, }, distribution_type => 'module', generated_by => 'ExtUtils::MakeMaker version 6.17', } ], 'Acme-Time-Baby', noyamlperl => 1, ); ##################################################################### # File with a YAML header yaml_ok( <<'END_YAML', --- #YAML:1.0 name: Data-Swap version: 0.05 license: perl distribution_type: module requires: perl: 5.6.0 dynamic_config: 0 END_YAML [ { name => 'Data-Swap', version => '0.05', license => 'perl', distribution_type => 'module', requires => { perl => '5.6.0', }, dynamic_config => '0', } ], 'Data-Swap', nosyck => 1, ); ##################################################################### # Various files that fail for unknown reasons SCOPE: { my $content = load_ok( 'Template-Provider-Unicode-Japanese.yml', catfile( test_data_directory(), 'Template-Provider-Unicode-Japanese.yml' ), 100 ); yaml_ok( $content, [ { abstract => 'Decode all templates by Unicode::Japanese', author => 'Hironori Yoshida C<< >>', distribution_type => 'module', generated_by => 'Module::Install version 0.65', license => 'perl', 'meta-spec' => { url => 'http://module-build.sourceforge.net/META-spec-v1.3.html', version => '1.3', }, name => 'Template-Provider-Unicode-Japanese', no_index => { directory => [ qw{ inc t } ], }, requires => { 'Template::Config' => 0, 'Unicode::Japanese' => 0, perl => '5.6.0', version => '0', }, version => '1.2.1', } ], 'Template-Provider-Unicode-Japanese', noyamlperl => 1, ); } SCOPE: { my $content = load_ok( 'HTML-WebDAO.yml', catfile( test_data_directory(), 'HTML-WebDAO.yml' ), 100 ); yaml_ok( $content, [ { abstract => 'Perl extension for create complex web application', author => [ 'Zahatski Aliaksandr, Ezagap@users.sourceforge.netE', ], license => 'perl', name => 'HTML-WebDAO', version => '0.04', } ], 'HTML-WebDAO', nosyck => 1, ); } SCOPE: { my $content = load_ok( 'Spreadsheet-Read.yml', catfile( test_data_directory(), 'Spreadsheet-Read.yml' ), 100 ); yaml_ok( $content, [ { 'resources' => { 'license' => 'http://dev.perl.org/licenses/' }, 'meta-spec' => { 'version' => '1.4', 'url' => 'http://module-build.sourceforge.net/META-spec-v1.4.html' }, 'distribution_type' => 'module', 'generated_by' => 'Author', 'version' => 'VERSION', 'name' => 'Read', 'author' => [ 'H.Merijn Brand ' ], 'license' => 'perl', 'build_requires' => { 'Test::More' => '0', 'Test::Harness' => '0', 'perl' => '5.006' }, 'provides' => { 'Spreadsheet::Read' => { 'version' => 'VERSION', 'file' => 'Read.pm' } }, 'optional_features' => [ { 'opt_csv' => { 'requires' => { 'Text::CSV_XS' => '0.23' }, 'recommends' => { 'Text::CSV_PP' => '1.10', 'Text::CSV_XS' => '0.58', 'Text::CSV' => '1.10' }, 'description' => 'Provides parsing of CSV streams' } }, { 'opt_excel' => { 'requires' => { 'Spreadsheet::ParseExcel' => '0.26', 'Spreadsheet::ParseExcel::FmtDefault' => '0' }, 'recommends' => { 'Spreadsheet::ParseExcel' => '0.42' }, 'description' => 'Provides parsing of Microsoft Excel files' } }, { 'opt_excelx' => { 'requires' => { 'Spreadsheet::XLSX' => '0.07' }, 'description' => 'Provides parsing of Microsoft Excel 2007 files' } }, { 'opt_oo' => { 'requires' => { 'Spreadsheet::ReadSXC' => '0.2' }, 'description' => 'Provides parsing of OpenOffice spreadsheets' } }, { 'opt_tools' => { 'recommends' => { 'Tk::TableMatrix::Spreadsheet' => '0', 'Tk::NoteBook' => '0', 'Tk' => '0' }, 'description' => 'Spreadsheet tools' } } ], 'requires' => { 'perl' => '5.006', 'Data::Dumper' => '0', 'Exporter' => '0', 'Carp' => '0' }, 'recommends' => { 'perl' => '5.008005', 'IO::Scalar' => '0', 'File::Temp' => '0.14' }, 'abstract' => 'Meta-Wrapper for reading spreadsheet data' } ], 'Spreadsheet-Read', noyamlpm => 1, noyamlperl => 1, ); } YAML-Tiny-1.56/t/12_plagger.t000755 000767 000024 00000005151 12220446251 015762 0ustar00etherstaff000000 000000 # Testing Plagger config samples from Miyagawa-san's YAPC::NA 2006 talk use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(2); use YAML::Tiny; ##################################################################### # Example Plagger Configuration 1 yaml_ok( <<'END_YAML', plugins: - module: Subscription::Bloglines config: username: you@example.pl password: foobar mark_read: 1 - module: Publish::Gmail config: mailto: example@gmail.com mailfrom: miyagawa@example.com mailroute: via: smtp host: smtp.example.com END_YAML [ { plugins => [ { module => 'Subscription::Bloglines', config => { username => 'you@example.pl', password => 'foobar', mark_read => 1, }, }, { module => 'Publish::Gmail', config => { mailto => 'example@gmail.com', mailfrom => 'miyagawa@example.com', mailroute => { via => 'smtp', host => 'smtp.example.com', }, }, }, ] } ], 'Plagger', ); ##################################################################### # Example Plagger Configuration 2 yaml_ok( <<'END_YAML', plugins: - module: Subscription::Config config: feed: # Trac's feed for changesets - http://plagger.org/.../rss # I don't like to be notified of the same items # more than once - module: Filter::Rule rule: module: Fresh mtime: path: /tmp/rssbot.time autoupdate: 1 - module: Notify::IRC config: daemon_port: 9999 nickname: plaggerbot server_host: chat.freenode.net server_channels: - '#plagger-ja' - '#plagger' END_YAML [ { plugins => [ { module => 'Subscription::Config', config => { feed => [ 'http://plagger.org/.../rss' ], }, }, { module => 'Filter::Rule', rule => { module => 'Fresh', mtime => { path => '/tmp/rssbot.time', autoupdate => 1, }, }, }, { module => 'Notify::IRC', config => { daemon_port => 9999, nickname => 'plaggerbot', server_host => 'chat.freenode.net', server_channels => [ '#plagger-ja', '#plagger', ], }, } ] } ], 'plagger2', ); YAML-Tiny-1.56/t/13_perl_smith.t000755 000767 000024 00000011775 12220446251 016521 0ustar00etherstaff000000 000000 # Testing of common META.yml examples use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(1, 1); use YAML::Tiny; ##################################################################### # Testing that Perl::Smith config files work my $vanilla_file = catfile( test_data_directory(), 'vanilla.yml' ); my $vanilla = load_ok( 'yanilla.yml', $vanilla_file, 1000 ); yaml_ok( $vanilla, [ { package_name => 'VanillaPerl', package_version => 5, download_dir => 'c:\temp\vp_sources', build_dir => 'c:\temp\vp_build', image_dir => 'c:\vanilla-perl', binary => [ { name => 'dmake', url => 'http://search.cpan.org/CPAN/authors/id/S/SH/SHAY/dmake-4.5-20060619-SHAY.zip', license => { 'dmake/COPYING' => 'dmake/COPYING', 'dmake/readme/license.txt' => 'dmake/license.txt', }, install_to => { 'dmake/dmake.exe' => 'dmake/bin/dmake.exe', 'dmake/startup' => 'dmake/bin/startup', }, }, { name => 'gcc-core', url => 'http://umn.dl.sourceforge.net/mingw/gcc-core-3.4.5-20060117-1.tar.gz', license => { 'COPYING' => 'gcc/COPYING', 'COPYING.lib' => 'gcc/COPYING.lib', }, install_to => 'mingw', }, { name => 'gcc-g++', url => 'http://umn.dl.sourceforge.net/mingw/gcc-g++-3.4.5-20060117-1.tar.gz', license => undef, install_to => 'mingw', }, { name => 'binutils', url => 'http://umn.dl.sourceforge.net/mingw/binutils-2.16.91-20060119-1.tar.gz', license => { 'Copying' => 'binutils/Copying', 'Copying.lib' => 'binutils/Copying.lib', }, install_to => 'mingw', }, { name => 'mingw-runtime', url => 'http://umn.dl.sourceforge.net/mingw/mingw-runtime-3.10.tar.gz', license => { 'doc/mingw-runtime/Contributors' => 'mingw/Contributors', 'doc/mingw-runtime/Disclaimer' => 'mingw/Disclaimer', }, install_to => 'mingw', }, { name => 'w32api', url => 'http://umn.dl.sourceforge.net/mingw/w32api-3.6.tar.gz', license => undef, install_to => 'mingw', extra => { 'extra\README.w32api' => 'licenses\win32api\README.w32api', }, } ], source => [ { name => 'perl', url => 'http://mirrors.kernel.org/CPAN/src/perl-5.8.8.tar.gz', license => { 'perl-5.8.8/Readme' => 'perl/Readme', 'perl-5.8.8/Artistic' => 'perl/Artistic', 'perl-5.8.8/Copying' => 'perl/Copying', }, unpack_to => 'perl', install_to => 'perl', after => { 'extra\Config.pm' => 'lib\CPAN\Config.pm', }, } ], modules => [ { name => 'Win32::Job', unpack_to => { APIFile => 'Win32API-File', }, }, { name => 'IO', force => 1, }, { name => 'Compress::Zlib', }, { name => 'IO::Zlib', }, { name => 'Archive::Tar', }, { name => 'Net::FTP', extra => { 'extra\libnet.cfg' => 'libnet.cfg', }, }, ], extra => { 'README' => 'README.txt', 'LICENSE.txt' => 'LICENSE.txt', 'Changes' => 'Release-Notes.txt', 'extra\Config.pm' => 'perl\lib\CPAN\Config.pm', 'extra\links\Perl-Documentation.url' => 'links\Perl Documentation.url', 'extra\links\Perl-Homepage.url' => 'links\Perl Homepage.url', 'extra\links\Perl-Mailing-Lists.url' => 'links\Perl Mailing Lists.url', 'extra\links\Perlmonks-Community-Forum.url' => 'links\Perlmonks Community Forum.url', 'extra\links\Search-CPAN-Modules.url' => 'links\Search CPAN Modules.url', 'extra\links\Vanilla-Perl-Homepage.url' => 'links\Vanilla Perl Homepage.url', }, } ], 'vanilla.yml', nosyck => 1, noyamlperl => 1, ); YAML-Tiny-1.56/t/14_yaml_org.t000755 000767 000024 00000002712 12220446251 016154 0ustar00etherstaff000000 000000 # Testing of common META.yml examples use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(1, 1); use YAML::Tiny; ##################################################################### # Testing that Perl::Smith config files work my $sample_file = catfile( test_data_directory(), 'sample.yml' ); my $sample = load_ok( 'sample.yml', $sample_file, 500 ); yaml_ok( $sample, [ { invoice => 34843, date => '2001-01-23', 'bill-to' => { given => 'Chris', family => 'Dumars', address => { lines => "458 Walkman Dr.\nSuite #292\n", city => 'Royal Oak', state => 'MI', postal => 48046, }, }, product => [ { sku => 'BL394D', quantity => '4', description => 'Basketball', price => '450.00', }, { sku => 'BL4438H', quantity => '1', description => 'Super Hoop', price => '2392.00', }, ], tax => '251.42', total => '4443.52', comments => <<'END_TEXT', Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338. END_TEXT } ], 'sample.yml', # nosyck => 1, ); YAML-Tiny-1.56/t/15_multibyte.t000755 000767 000024 00000002516 12220446251 016364 0ustar00etherstaff000000 000000 # Testing of META.yml containing AVAR's name use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(0, 1, 6); use YAML::Tiny; ##################################################################### # Testing that Perl::Smith config files work my $sample_file = catfile( test_data_directory(), 'multibyte.yml' ); my $sample = load_ok( 'multibyte.yml', $sample_file, 450 ); # Does the string parse to the structure my $name = "multibyte"; my $yaml_copy = $sample; my $yaml = eval { YAML::Tiny->read_string( $yaml_copy ); }; is( $@, '', "$name: YAML::Tiny parses without error" ); is( $yaml_copy, $sample, "$name: YAML::Tiny does not modify the input string" ); SKIP: { skip( "Shortcutting after failure", 2 ) if $@; isa_ok( $yaml, 'YAML::Tiny' ); is_deeply( $yaml->[0]->{build_requires}, { 'Config' => 0, 'Test::More' => 0, 'XSLoader' => 0, }, 'build_requires ok' ); } SKIP: { unless ( YAML::Tiny::HAVE_UTF8() ) { skip("no utf8 support", 2 ); } eval { utf8::is_utf8('') }; if ( $@ ) { skip("no is_utf8 to test with until 5.8.1", 2); } ok( utf8::is_utf8($yaml->[0]->{author}), "utf8 decoded" ); is( length($yaml->[0]->{author}), 39, "utf8 decoded as characters" ); } YAML-Tiny-1.56/t/16_nullrefs.t000644 000767 000024 00000000600 12220446251 016166 0ustar00etherstaff000000 000000 # Testing for null references use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(1); use YAML::Tiny; ##################################################################### # Example Empty References yaml_ok( <<'END_YAML', --- [] --- {} END_YAML [ [], {} ], 'Empty references', ); YAML-Tiny-1.56/t/17_toolbar.t000644 000767 000024 00000002116 12220446251 016003 0ustar00etherstaff000000 000000 # Testing of a known-bad file from an editor use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; # use Test::More skip_all => 'Temporarily ignoring failing test'; use Test::More tests(1, 1); use YAML::Tiny; ##################################################################### # Testing that Perl::Smith config files work my $toolbar_file = catfile( test_data_directory(), 'toolbar.yml' ); my $toolbar = load_ok( 'toolbar.yml', $toolbar_file, 100 ); yaml_ok( $toolbar, [ { main_toolbar => [ 'item file-new', 'item file-open', 'item file-print#', 'item file-close#', 'item file-save-all', 'item file-save', undef, 'item edit-changes-undo', 'item edit-changes-redo', undef, 'item edit-cut', 'item edit-copy', 'item edit-paste', 'item edit-replace', 'item edit-delete', ] } ], 'toolbar.yml', noyamlperl => 1, ); YAML-Tiny-1.56/t/18_tap.t000644 000767 000024 00000002416 12220446251 015131 0ustar00etherstaff000000 000000 # Testing relating to functionality in the Test Anything Protocol use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(5, 0, 0); use YAML::Tiny (); ##################################################################### # TAP Tests # Make sure we support x-foo keys yaml_ok( "---\nx-foo: 1\n", [ { 'x-foo' => 1 } ], 'x-foo key', ); # Document ending (hash) yaml_ok( "---\n" . " foo: bar\n" . "...\n", [ { foo => "bar" } ], 'document_end_hash', noyamlpm => 1, nosyck => 1, noyamlperl => 1, ); # Document ending (array) yaml_ok( "---\n" . "- foo\n" . "...\n", [ [ 'foo' ] ], 'document_end_array', noyamlpm => 1, noyamlperl => 1, ); # Multiple documents (simple) yaml_ok( "---\n" . "- foo\n" . "...\n" . "---\n" . "- foo\n" . "...\n", [ [ 'foo' ], [ 'foo' ] ], 'multi_document_simple', noyamlpm => 1, noyamlperl => 1, ); # Multiple documents (whitespace-separated) yaml_ok( "---\n" . "- foo\n" . "...\n" . "\n" . "---\n" . "- foo\n" . "...\n", [ [ 'foo' ], [ 'foo' ] ], 'multi_document_space', noyamlpm => 1, noyamlperl => 1, ); YAML-Tiny-1.56/t/19_errors.t000644 000767 000024 00000002051 12220446251 015655 0ustar00etherstaff000000 000000 # Testing documents that should fail use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests => 20; use YAML::Tiny (); my $FEATURE = 'does not support a feature'; my $PLAIN = 'illegal characters in plain scalar'; ##################################################################### # Syntactic Errors yaml_error( <<'END_YAML', $FEATURE ); - 'Multiline quote' END_YAML yaml_error( <<'END_YAML', $FEATURE ); - "Multiline quote" END_YAML yaml_error( <<'END_YAML', $FEATURE ); --- version: !!perl/hash:version original: v2.0.2 qv: 1 version: - 2 - 0 - 2 END_YAML yaml_error( <<'END_YAML', $PLAIN ); - - 2 END_YAML yaml_error( <<'END_YAML', $PLAIN ); foo: - END_YAML yaml_error( <<'END_YAML', $PLAIN ); foo: @INC END_YAML yaml_error( <<'END_YAML', $PLAIN ); foo: %INC END_YAML yaml_error( <<'END_YAML', $PLAIN ); foo: bar: END_YAML yaml_error( <<'END_YAML', $PLAIN ); foo: bar: baz END_YAML yaml_error( <<'END_YAML', $PLAIN ); foo: `perl -V` END_YAML YAML-Tiny-1.56/t/20_subclass.t000644 000767 000024 00000001524 12220446251 016154 0ustar00etherstaff000000 000000 # Testing documents that should fail use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests => 1; ##################################################################### # Customized Class SCOPE: { package Foo; use YAML::Tiny; use vars qw{@ISA}; BEGIN { @ISA = 'YAML::Tiny'; } sub _write_scalar { my $self = shift; my $string = shift; my $indent = shift; if ( defined $indent ) { return "'$indent'"; } else { return 'undef'; } } 1; } ##################################################################### # Generate the value my $object = Foo->new( { foo => 'bar' } ); is( $object->write_string, "---\nfoo: '1'\n", 'Subclassing works' ); YAML-Tiny-1.56/t/21_bom.t000755 000767 000024 00000001572 12220446251 015121 0ustar00etherstaff000000 000000 use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(0, 1, 4); use YAML::Tiny; ##################################################################### # Testing that Perl::Smith config files work my $sample_file = catfile( 't', 'data', 'utf_16_le_bom.yml' ); my $sample = load_ok( 'utf_16_le_bom.yml', $sample_file, 3 ); # Does the string parse to the structure my $name = "utf-16"; my $yaml_copy = $sample; my $yaml = eval { YAML::Tiny->read_string( $yaml_copy ); }; is( $@, '', "$name: YAML::Tiny parses without error" ); is( $yaml_copy, $sample, "$name: YAML::Tiny does not modify the input string" ); SKIP: { skip( "Shortcutting after failure", 2 ) if $@; is( $yaml, undef, "file not parsed" ); is( YAML::Tiny->errstr, "Stream has a non UTF-8 BOM", "correct error" ); } YAML-Tiny-1.56/t/22_comments.t000644 000767 000024 00000004446 12220446251 016172 0ustar00etherstaff000000 000000 # Testing of inline comments. These comments can be quite useful in config # files and people will expect them to work. use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use File::Spec::Functions ':ALL'; use t::lib::Test; use Test::More tests(2); use YAML::Tiny; ##################################################################### # Main Tests yaml_ok( <<'END_YAML', --- a: b#content c: d #comment e: - f #comment - g# content h: 'single' # comment h2: 'single # content' # comment i: "double" # comment i2: "double # content" # comment j: | # comment literal # content block # content k: {} # comment l: [] # comment m: # comment n: o END_YAML [ { a => 'b#content', c => 'd', e => [ 'f', 'g# content', ], h => 'single', h2 => 'single # content', i => 'double', i2 => 'double # content', j => "literal # content\nblock # content\n", k => {}, l => [], m => { n => 'o', }, }, ], 'Properly ignore comments', noyamlpm => 1, ); # Repeat, with otherwise illegal characters in the comments yaml_ok( <<'END_YAML', --- a: b#content c: d #comment '"!&@%` e: - f #comment '"!&@%` - g# content h: 'single' # comment '"!&@%` h2: 'single # content' # comment '"!&@%` i: "double" # comment '"!&@%` i2: "double # content" # comment '"!&@%` j: | # comment '"!&@%` literal # content block # content k: {} # comment '"!&@%` l: [] # comment '"!&@%` m: # comment '"!&@%` n: o END_YAML [ { a => 'b#content', c => 'd', e => [ 'f', 'g# content', ], h => 'single', h2 => 'single # content', i => 'double', i2 => 'double # content', j => "literal # content\nblock # content\n", k => {}, l => [], m => { n => 'o', }, }, ], 'Properly ignore comments (with otherwise illegal characters)', noyamlpm => 1, ); YAML-Tiny-1.56/t/data/000755 000767 000024 00000000000 12220446251 014556 5ustar00etherstaff000000 000000 YAML-Tiny-1.56/t/lib/000755 000767 000024 00000000000 12220446251 014413 5ustar00etherstaff000000 000000 YAML-Tiny-1.56/t/lib/Test.pm000755 000767 000024 00000025722 12220446251 015703 0ustar00etherstaff000000 000000 package t::lib::Test; use strict; use warnings; use Exporter (); use File::Spec (); use Test::More (); use vars qw{@ISA @EXPORT}; BEGIN { @ISA = qw{ Exporter }; @EXPORT = qw{ tests yaml_ok yaml_error slurp load_ok test_data_directory }; } # Do we have the authorative YAML to test against eval { require YAML; # This doesn't currently work, but is documented to. # So if it ever turns up, use it. $YAML::UseVersion = 1; }; my $HAVE_YAMLPM = !! ( $YAML::VERSION and $YAML::VERSION >= 0.66 ); sub have_yamlpm { $HAVE_YAMLPM } # Do we have YAML::Perl to test against? eval { require YAML::Perl; }; my $HAVE_YAMLPERL = !! ( $YAML::Perl::VERSION and $YAML::Perl::VERSION >= 0.02 ); sub have_yamlperl { $HAVE_YAMLPERL } # Do we have YAML::Syck to test against? eval { require YAML::Syck; }; my $HAVE_SYCK = !! ( $YAML::Syck::VERSION and $YAML::Syck::VERSION >= 1.05 ); sub have_syck { $HAVE_SYCK } # Do we have YAML::XS to test against? eval { require YAML::XS; }; my $HAVE_XS = !! ( $YAML::XS::VERSION and $YAML::XS::VERSION >= 0.29 ); sub have_xs{ $HAVE_XS } # 22 tests per call to yaml_ok # 4 tests per call to load_ok sub tests { return ( tests => count(@_) ); } sub test_data_directory { return File::Spec->catdir( 't', 'data' ); } sub count { my $yaml_ok = shift || 0; my $load_ok = shift || 0; my $single = shift || 0; my $count = $yaml_ok * 38 + $load_ok * 4 + $single; return $count; } sub yaml_ok { my $string = shift; my $object = shift; my $name = shift || 'unnamed'; my %options = ( @_ ); bless $object, 'YAML::Tiny'; # If YAML itself is available, test with it SKIP: { unless ( $HAVE_YAMLPM ) { Test::More::skip( "Skipping YAML.pm, not available for testing", 7 ); } if ( $options{noyamlpm} ) { Test::More::skip( "Skipping YAML.pm for known-broken feature", 7 ); } # Test writing with YAML.pm my $yamlpm_out = eval { YAML::Dump( @$object ) }; Test::More::is( $@, '', "$name: YAML.pm saves without error" ); SKIP: { Test::More::skip( "Shortcutting after failure", 4 ) if $@; Test::More::ok( !!(defined $yamlpm_out and ! ref $yamlpm_out), "$name: YAML.pm serializes correctly", ); my @yamlpm_round = eval { YAML::Load( $yamlpm_out ) }; Test::More::is( $@, '', "$name: YAML.pm round-trips without error" ); Test::More::skip( "Shortcutting after failure", 2 ) if $@; my $round = bless [ @yamlpm_round ], 'YAML::Tiny'; Test::More::is_deeply( $round, $object, "$name: YAML.pm round-trips correctly" ); } # Test reading with YAML.pm my $yamlpm_copy = $string; my @yamlpm_in = eval { YAML::Load( $yamlpm_copy ) }; Test::More::is( $@, '', "$name: YAML.pm loads without error" ); Test::More::is( $yamlpm_copy, $string, "$name: YAML.pm does not modify the input string" ); SKIP: { Test::More::skip( "Shortcutting after failure", 1 ) if $@; Test::More::is_deeply( \@yamlpm_in, $object, "$name: YAML.pm parses correctly" ); } } # If YAML::Syck itself is available, test with it SKIP: { unless ( $HAVE_SYCK ) { Test::More::skip( "Skipping YAML::Syck, not available for testing", 7 ); } if ( $options{nosyck} ) { Test::More::skip( "Skipping YAML::Syck for known-broken feature", 7 ); } unless ( @$object == 1 ) { Test::More::skip( "Skipping YAML::Syck for unsupported feature", 7 ); } # Test writing with YAML::Syck my $syck_out = eval { YAML::Syck::Dump( @$object ) }; Test::More::is( $@, '', "$name: YAML::Syck saves without error" ); SKIP: { Test::More::skip( "Shortcutting after failure", 4 ) if $@; Test::More::ok( !!(defined $syck_out and ! ref $syck_out), "$name: YAML::Syck serializes correctly", ); my @syck_round = eval { YAML::Syck::Load( $syck_out ) }; Test::More::is( $@, '', "$name: YAML::Syck round-trips without error" ); Test::More::skip( "Shortcutting after failure", 2 ) if $@; my $round = bless [ @syck_round ], 'YAML::Tiny'; Test::More::is_deeply( $round, $object, "$name: YAML::Syck round-trips correctly" ); } # Test reading with YAML::Syck my $syck_copy = $string; my @syck_in = eval { YAML::Syck::Load( $syck_copy ) }; Test::More::is( $@, '', "$name: YAML::Syck loads without error" ); Test::More::is( $syck_copy, $string, "$name: YAML::Syck does not modify the input string" ); SKIP: { Test::More::skip( "Shortcutting after failure", 1 ) if $@; Test::More::is_deeply( \@syck_in, $object, "$name: YAML::Syck parses correctly" ); } } # If YAML::XS itself is available, test with it SKIP: { unless ( $HAVE_XS ) { Test::More::skip( "Skipping YAML::XS, not available for testing", 7 ); } if ( $options{noxs} ) { Test::More::skip( "Skipping YAML::XS for known-broken feature", 7 ); } # Test writing with YAML::XS my $xs_out = eval { YAML::XS::Dump( @$object ) }; Test::More::is( $@, '', "$name: YAML::XS saves without error" ); SKIP: { Test::More::skip( "Shortcutting after failure", 4 ) if $@; Test::More::ok( !!(defined $xs_out and ! ref $xs_out), "$name: YAML::XS serializes correctly", ); my @xs_round = eval { YAML::XS::Load( $xs_out ) }; Test::More::is( $@, '', "$name: YAML::XS round-trips without error" ); Test::More::skip( "Shortcutting after failure", 2 ) if $@; my $round = bless [ @xs_round ], 'YAML::Tiny'; Test::More::is_deeply( $round, $object, "$name: YAML::XS round-trips correctly" ); } # Test reading with YAML::XS my $xs_copy = $string; my @xs_in = eval { YAML::XS::Load( $xs_copy ) }; Test::More::is( $@, '', "$name: YAML::XS loads without error" ); Test::More::is( $xs_copy, $string, "$name: YAML::XS does not modify the input string" ); SKIP: { Test::More::skip( "Shortcutting after failure", 1 ) if $@; Test::More::is_deeply( \@xs_in, $object, "$name: YAML::XS parses correctly" ); } } # If YAML::Perl is available, test with it SKIP: { unless ( $HAVE_YAMLPERL ) { Test::More::skip( "Skipping YAML::Perl, not available for testing", 7 ); } if ( $options{noyamlperl} ) { Test::More::skip( "Skipping YAML::Perl for known-broken feature", 7 ); } # Test writing with YAML.pm my $yamlperl_out = eval { YAML::Perl::Dump( @$object ) }; Test::More::is( $@, '', "$name: YAML::Perl saves without error" ); SKIP: { Test::More::skip( "Shortcutting after failure", 4 ) if $@; Test::More::ok( !!(defined $yamlperl_out and ! ref $yamlperl_out), "$name: YAML::Perl serializes correctly", ); my @yamlperl_round = eval { YAML::Perl::Load( $yamlperl_out ) }; Test::More::is( $@, '', "$name: YAML::Perl round-trips without error" ); Test::More::skip( "Shortcutting after failure", 2 ) if $@; my $round = bless [ @yamlperl_round ], 'YAML::Tiny'; Test::More::is_deeply( $round, $object, "$name: YAML::Perl round-trips correctly" ); } # Test reading with YAML::Perl my $yamlperl_copy = $string; my @yamlperl_in = eval { YAML::Perl::Load( $yamlperl_copy ) }; Test::More::is( $@, '', "$name: YAML::Perl loads without error" ); Test::More::is( $yamlperl_copy, $string, "$name: YAML::Perl does not modify the input string" ); SKIP: { Test::More::skip( "Shortcutting after failure", 1 ) if $@; Test::More::is_deeply( \@yamlperl_in, $object, "$name: YAML::Perl parses correctly" ); } } # Does the string parse to the structure my $yaml_copy = $string; my $yaml = eval { YAML::Tiny->read_string( $yaml_copy ); }; Test::More::is( $@, '', "$name: YAML::Tiny parses without error" ); Test::More::is( $yaml_copy, $string, "$name: YAML::Tiny does not modify the input string" ); SKIP: { Test::More::skip( "Shortcutting after failure", 2 ) if $@; Test::More::isa_ok( $yaml, 'YAML::Tiny' ); Test::More::is_deeply( $yaml, $object, "$name: YAML::Tiny parses correctly" ); } # Does the structure serialize to the string. # We can't test this by direct comparison, because any # whitespace or comments would be lost. # So instead we parse back in. my $output = eval { $object->write_string }; Test::More::is( $@, '', "$name: YAML::Tiny serializes without error" ); SKIP: { Test::More::skip( "Shortcutting after failure", 5 ) if $@; Test::More::ok( !!(defined $output and ! ref $output), "$name: YAML::Tiny serializes correctly", ); my $roundtrip = eval { YAML::Tiny->read_string( $output ) }; Test::More::is( $@, '', "$name: YAML::Tiny round-trips without error" ); Test::More::skip( "Shortcutting after failure", 2 ) if $@; Test::More::isa_ok( $roundtrip, 'YAML::Tiny' ); Test::More::is_deeply( $roundtrip, $object, "$name: YAML::Tiny round-trips correctly" ); # Testing the serialization Test::More::skip( "Shortcutting perfect serialization tests", 1 ) unless $options{serializes}; Test::More::is( $output, $string, 'Serializes ok' ); } # Return true as a convenience return 1; } sub yaml_error { my $string = shift; my $like = shift; my $yaml = YAML::Tiny->read_string( $string ); Test::More::is( $yaml, undef, '->read_string returns undef' ); Test::More::ok( YAML::Tiny->errstr =~ /$like/, "Got expected error" ); # NOTE: like() gives better diagnostics (but requires 5.005) # Test::More::like( $@, qr/$_[0]/, "YAML::Tiny throws expected error" ); } sub slurp { my $file = shift; local $/ = undef; open( FILE, " $file" ) or die "open($file) failed: $!"; binmode( FILE, $_[0] ) if @_ > 0 && $] > 5.006; # binmode(FILE); # disable perl's BOM interpretation my $source = ; close( FILE ) or die "close($file) failed: $!"; $source; } sub load_ok { my $name = shift; my $file = shift; my $size = shift; Test::More::ok( -f $file, "Found $name" ); Test::More::ok( -r $file, "Can read $name" ); my $content = slurp( $file ); Test::More::ok( (defined $content and ! ref $content), "Loaded $name" ); Test::More::ok( ($size < length $content), "Content of $name larger than $size bytes" ); return $content; } 1; YAML-Tiny-1.56/t/data/HTML-WebDAO.yml000755 000767 000024 00000000306 12220446251 017106 0ustar00etherstaff000000 000000 --- #YAML:1.0 name: HTML-WebDAO version: 0.04 author: - |- Zahatski Aliaksandr, Ezagap@users.sourceforge.netE abstract: Perl extension for create complex web application license: perl YAML-Tiny-1.56/t/data/multibyte.yml000755 000767 000024 00000000722 12220446251 017323 0ustar00etherstaff000000 000000 --- abstract: Perl-compatible regular expression engine author: "Ævar Arnfjörð Bjarmason " build_requires: Config: 0 Test::More: 0 XSLoader: 0 distribution_type: module generated_by: Module::Install version 0.65 license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.3.html version: 1.3 name: re-engine-PCRE no_index: directory: - inc - t requires: perl: 5.9.5 tests: t/*.t t/*/*.t version: 0.10 YAML-Tiny-1.56/t/data/one.yml000644 000767 000024 00000000012 12220446251 016053 0ustar00etherstaff000000 000000 --- - foo YAML-Tiny-1.56/t/data/sample.yml000755 000767 000024 00000001114 12220446251 016562 0ustar00etherstaff000000 000000 --- invoice: 34843 date : 2001-01-23 bill-to: given : Chris family : Dumars address: lines: | 458 Walkman Dr. Suite #292 city : Royal Oak state : MI postal : 48046 product: - sku : BL394D quantity : 4 description : Basketball price : 450.00 - sku : BL4438H quantity : 1 description : Super Hoop price : 2392.00 tax : 251.42 total: 4443.52 comments: > Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338. YAML-Tiny-1.56/t/data/Spreadsheet-Read.yml000644 000767 000024 00000003405 12220446251 020423 0ustar00etherstaff000000 000000 --- #YAML:1.1 name: Read version: VERSION abstract: Meta-Wrapper for reading spreadsheet data license: perl author: - H.Merijn Brand generated_by: Author distribution_type: module provides: Spreadsheet::Read: file: Read.pm version: VERSION requires: perl: 5.006 Exporter: 0 Carp: 0 Data::Dumper: 0 recommends: perl: 5.008005 File::Temp: 0.14 IO::Scalar: 0 build_requires: perl: 5.006 Test::Harness: 0 Test::More: 0 optional_features: - opt_csv: description: Provides parsing of CSV streams requires: Text::CSV_XS: 0.23 recommends: Text::CSV: 1.10 Text::CSV_PP: 1.10 Text::CSV_XS: 0.58 - opt_excel: description: Provides parsing of Microsoft Excel files requires: Spreadsheet::ParseExcel: 0.26 Spreadsheet::ParseExcel::FmtDefault: 0 recommends: Spreadsheet::ParseExcel: 0.42 - opt_excelx: description: Provides parsing of Microsoft Excel 2007 files requires: Spreadsheet::XLSX: 0.07 - opt_oo: description: Provides parsing of OpenOffice spreadsheets requires: Spreadsheet::ReadSXC: 0.2 - opt_tools: description: Spreadsheet tools recommends: Tk: 0 Tk::NoteBook: 0 Tk::TableMatrix::Spreadsheet: 0 resources: license: http://dev.perl.org/licenses/ meta-spec: version: 1.4 url: http://module-build.sourceforge.net/META-spec-v1.4.html YAML-Tiny-1.56/t/data/Template-Provider-Unicode-Japanese.yml000755 000767 000024 00000000717 12220446251 023764 0ustar00etherstaff000000 000000 --- abstract: Decode all templates by Unicode::Japanese author: Hironori Yoshida C<< >> distribution_type: module generated_by: Module::Install version 0.65 license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.3.html version: 1.3 name: Template-Provider-Unicode-Japanese no_index: directory: - inc - t requires: Template::Config: 0 Unicode::Japanese: 0 perl: 5.6.0 version: 0 version: 1.2.1 YAML-Tiny-1.56/t/data/toolbar.yml000644 000767 000024 00000000451 12220446251 016743 0ustar00etherstaff000000 000000 main_toolbar: - item file-new - item file-open - item file-print# - item file-close# - item file-save-all - item file-save - - item edit-changes-undo - item edit-changes-redo - - item edit-cut - item edit-copy - item edit-paste - item edit-replace - item edit-delete YAML-Tiny-1.56/t/data/two.yml000644 000767 000024 00000000024 12220446251 016106 0ustar00etherstaff000000 000000 --- - foo --- - bar YAML-Tiny-1.56/t/data/utf_16_le_bom.yml000644 000767 000024 00000000026 12220446251 017720 0ustar00etherstaff000000 000000 ÿþ--- - foo YAML-Tiny-1.56/t/data/vanilla.yml000755 000767 000024 00000006064 12220446251 016740 0ustar00etherstaff000000 000000 # VanillaPerl YAML config file --- # package info package_name: VanillaPerl package_version: 5 # directories download_dir: c:\temp\vp_sources build_dir: c:\temp\vp_build image_dir: c:\vanilla-perl # Binary components binary: - name: dmake url: http://search.cpan.org/CPAN/authors/id/S/SH/SHAY/dmake-4.5-20060619-SHAY.zip license: dmake/COPYING : dmake/COPYING dmake/readme/license.txt: dmake/license.txt install_to: dmake/dmake.exe: dmake/bin/dmake.exe dmake/startup: dmake/bin/startup - name: gcc-core url: http://umn.dl.sourceforge.net/mingw/gcc-core-3.4.5-20060117-1.tar.gz license: COPYING: gcc/COPYING COPYING.lib: gcc/COPYING.lib install_to: mingw - name: gcc-g++ url: http://umn.dl.sourceforge.net/mingw/gcc-g++-3.4.5-20060117-1.tar.gz license: install_to: mingw - name: binutils url: http://umn.dl.sourceforge.net/mingw/binutils-2.16.91-20060119-1.tar.gz license: Copying: binutils/Copying Copying.lib: binutils/Copying.lib install_to: mingw - name: mingw-runtime url: http://umn.dl.sourceforge.net/mingw/mingw-runtime-3.10.tar.gz license: doc/mingw-runtime/Contributors: mingw/Contributors doc/mingw-runtime/Disclaimer: mingw/Disclaimer install_to: mingw - name: w32api url: http://umn.dl.sourceforge.net/mingw/w32api-3.6.tar.gz license: install_to: mingw extra: extra\README.w32api: licenses\win32api\README.w32api # Source components source: - name: perl url: http://mirrors.kernel.org/CPAN/src/perl-5.8.8.tar.gz license: perl-5.8.8/Readme: perl/Readme perl-5.8.8/Artistic: perl/Artistic perl-5.8.8/Copying: perl/Copying unpack_to: perl install_to: perl after: extra\Config.pm: lib\CPAN\Config.pm # Additional modules to bundle in site\lib modules: # i.e. not used, but gets us the libwin32 dist - name: Win32::Job unpack_to: APIFile: Win32API-File - name: IO force: 1 - name: Compress::Zlib - name: IO::Zlib - name: Archive::Tar - name: Net::FTP extra: extra\libnet.cfg: libnet.cfg # Extra files to be placed # Signature.pm: perl\site\lib\Module\Signature.pm extra: README: README.txt LICENSE.txt: LICENSE.txt Changes: Release-Notes.txt extra\Config.pm: perl\lib\CPAN\Config.pm # reset this again extra\links\Perl-Documentation.url: links\Perl Documentation.url extra\links\Perl-Homepage.url: links\Perl Homepage.url extra\links\Perl-Mailing-Lists.url: links\Perl Mailing Lists.url extra\links\Perlmonks-Community-Forum.url: links\Perlmonks Community Forum.url extra\links\Search-CPAN-Modules.url: links\Search CPAN Modules.url extra\links\Vanilla-Perl-Homepage.url: links\Vanilla Perl Homepage.url YAML-Tiny-1.56/lib/YAML/000755 000767 000024 00000000000 12220446251 014712 5ustar00etherstaff000000 000000 YAML-Tiny-1.56/lib/YAML/Tiny.pm000644 000767 000024 00000103564 12220446251 016204 0ustar00etherstaff000000 000000 package YAML::Tiny; BEGIN { $YAML::Tiny::AUTHORITY = 'cpan:ADAMK'; } { $YAML::Tiny::VERSION = '1.56'; } # git description: v1.55-3-gc945058 use strict; use warnings; # UTF Support? sub HAVE_UTF8 () { $] >= 5.007003 } BEGIN { if ( HAVE_UTF8 ) { # The string eval helps hide this from Test::MinimumVersion eval "require utf8;"; die "Failed to load UTF-8 support" if $@; } # Class structure require 5.004; require Exporter; require Carp; @YAML::Tiny::ISA = qw{ Exporter }; @YAML::Tiny::EXPORT = qw{ Load Dump }; @YAML::Tiny::EXPORT_OK = qw{ LoadFile DumpFile freeze thaw }; # Error storage $YAML::Tiny::errstr = ''; } # The character class of all characters we need to escape # NOTE: Inlined, since it's only used once # my $RE_ESCAPE = '[\\x00-\\x08\\x0b-\\x0d\\x0e-\\x1f\"\n]'; # Printed form of the unprintable characters in the lowest range # of ASCII characters, listed by ASCII ordinal position. my @UNPRINTABLE = qw( z x01 x02 x03 x04 x05 x06 a x08 t n v f r x0e x0f x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x1a e x1c x1d x1e x1f ); # Printable characters for escapes my %UNESCAPES = ( z => "\x00", a => "\x07", t => "\x09", n => "\x0a", v => "\x0b", f => "\x0c", r => "\x0d", e => "\x1b", '\\' => '\\', ); # Special magic boolean words my %QUOTE = map { $_ => 1 } qw{ null Null NULL y Y yes Yes YES n N no No NO true True TRUE false False FALSE on On ON off Off OFF }; ##################################################################### # Implementation # Create an empty YAML::Tiny object sub new { my $class = shift; bless [ @_ ], $class; } # Create an object from a file sub read { my $class = ref $_[0] ? ref shift : shift; # Check the file my $file = shift or return $class->_error( 'You did not specify a file name' ); return $class->_error( "File '$file' does not exist" ) unless -e $file; return $class->_error( "'$file' is a directory, not a file" ) unless -f _; return $class->_error( "Insufficient permissions to read '$file'" ) unless -r _; # Slurp in the file local $/ = undef; local *CFG; unless ( open(CFG, $file) ) { return $class->_error("Failed to open file '$file': $!"); } my $contents = ; unless ( close(CFG) ) { return $class->_error("Failed to close file '$file': $!"); } $class->read_string( $contents ); } # Create an object from a string sub read_string { my $class = ref $_[0] ? ref shift : shift; my $self = bless [], $class; my $string = $_[0]; eval { unless ( defined $string ) { die \"Did not provide a string to load"; } # Byte order marks # NOTE: Keeping this here to educate maintainers # my %BOM = ( # "\357\273\277" => 'UTF-8', # "\376\377" => 'UTF-16BE', # "\377\376" => 'UTF-16LE', # "\377\376\0\0" => 'UTF-32LE' # "\0\0\376\377" => 'UTF-32BE', # ); if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) { die \"Stream has a non UTF-8 BOM"; } else { # Strip UTF-8 bom if found, we'll just ignore it $string =~ s/^\357\273\277//; } # Try to decode as utf8 utf8::decode($string) if HAVE_UTF8; # Check for some special cases return $self unless length $string; unless ( $string =~ /[\012\015]+\z/ ) { die \"Stream does not end with newline character"; } # Split the file into lines my @lines = grep { ! /^\s*(?:\#.*)?\z/ } split /(?:\015{1,2}\012|\015|\012)/, $string; # Strip the initial YAML header @lines and $lines[0] =~ /^\%YAML[: ][\d\.]+.*\z/ and shift @lines; # A nibbling parser while ( @lines ) { # Do we have a document header? if ( $lines[0] =~ /^---\s*(?:(.+)\s*)?\z/ ) { # Handle scalar documents shift @lines; if ( defined $1 and $1 !~ /^(?:\#.+|\%YAML[: ][\d\.]+)\z/ ) { push @$self, $self->_read_scalar( "$1", [ undef ], \@lines ); next; } } if ( ! @lines or $lines[0] =~ /^(?:---|\.\.\.)/ ) { # A naked document push @$self, undef; while ( @lines and $lines[0] !~ /^---/ ) { shift @lines; } } elsif ( $lines[0] =~ /^\s*\-/ ) { # An array at the root my $document = [ ]; push @$self, $document; $self->_read_array( $document, [ 0 ], \@lines ); } elsif ( $lines[0] =~ /^(\s*)\S/ ) { # A hash at the root my $document = { }; push @$self, $document; $self->_read_hash( $document, [ length($1) ], \@lines ); } else { die \"YAML::Tiny failed to classify the line '$lines[0]'"; } } }; if ( ref $@ eq 'SCALAR' ) { return $self->_error(${$@}); } elsif ( $@ ) { require Carp; Carp::croak($@); } return $self; } # Deparse a scalar string to the actual scalar sub _read_scalar { my ($self, $string, $indent, $lines) = @_; # Trim trailing whitespace $string =~ s/\s*\z//; # Explitic null/undef return undef if $string eq '~'; # Single quote if ( $string =~ /^\'(.*?)\'(?:\s+\#.*)?\z/ ) { return '' unless defined $1; $string = $1; $string =~ s/\'\'/\'/g; return $string; } # Double quote. # The commented out form is simpler, but overloaded the Perl regex # engine due to recursion and backtracking problems on strings # larger than 32,000ish characters. Keep it for reference purposes. # if ( $string =~ /^\"((?:\\.|[^\"])*)\"\z/ ) { if ( $string =~ /^\"([^\\"]*(?:\\.[^\\"]*)*)\"(?:\s+\#.*)?\z/ ) { # Reusing the variable is a little ugly, # but avoids a new variable and a string copy. $string = $1; $string =~ s/\\"/"/g; $string =~ s/\\([never\\fartz]|x([0-9a-fA-F]{2}))/(length($1)>1)?pack("H2",$2):$UNESCAPES{$1}/gex; return $string; } # Special cases if ( $string =~ /^[\'\"!&]/ ) { die \"YAML::Tiny does not support a feature in line '$string'"; } return {} if $string =~ /^{}(?:\s+\#.*)?\z/; return [] if $string =~ /^\[\](?:\s+\#.*)?\z/; # Regular unquoted string if ( $string !~ /^[>|]/ ) { if ( $string =~ /^(?:-(?:\s|$)|[\@\%\`])/ or $string =~ /:(?:\s|$)/ ) { die \"YAML::Tiny found illegal characters in plain scalar: '$string'"; } $string =~ s/\s+#.*\z//; return $string; } # Error die \"YAML::Tiny failed to find multi-line scalar content" unless @$lines; # Check the indent depth $lines->[0] =~ /^(\s*)/; $indent->[-1] = length("$1"); if ( defined $indent->[-2] and $indent->[-1] <= $indent->[-2] ) { die \"YAML::Tiny found bad indenting in line '$lines->[0]'"; } # Pull the lines my @multiline = (); while ( @$lines ) { $lines->[0] =~ /^(\s*)/; last unless length($1) >= $indent->[-1]; push @multiline, substr(shift(@$lines), length($1)); } my $j = (substr($string, 0, 1) eq '>') ? ' ' : "\n"; my $t = (substr($string, 1, 1) eq '-') ? '' : "\n"; return join( $j, @multiline ) . $t; } # Parse an array sub _read_array { my ($self, $array, $indent, $lines) = @_; while ( @$lines ) { # Check for a new document if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) { while ( @$lines and $lines->[0] !~ /^---/ ) { shift @$lines; } return 1; } # Check the indent level $lines->[0] =~ /^(\s*)/; if ( length($1) < $indent->[-1] ) { return 1; } elsif ( length($1) > $indent->[-1] ) { die \"YAML::Tiny found bad indenting in line '$lines->[0]'"; } if ( $lines->[0] =~ /^(\s*\-\s+)[^\'\"]\S*\s*:(?:\s+|$)/ ) { # Inline nested hash my $indent2 = length("$1"); $lines->[0] =~ s/-/ /; push @$array, { }; $self->_read_hash( $array->[-1], [ @$indent, $indent2 ], $lines ); } elsif ( $lines->[0] =~ /^\s*\-(\s*)(.+?)\s*\z/ ) { # Array entry with a value shift @$lines; push @$array, $self->_read_scalar( "$2", [ @$indent, undef ], $lines ); } elsif ( $lines->[0] =~ /^\s*\-\s*\z/ ) { shift @$lines; unless ( @$lines ) { push @$array, undef; return 1; } if ( $lines->[0] =~ /^(\s*)\-/ ) { my $indent2 = length("$1"); if ( $indent->[-1] == $indent2 ) { # Null array entry push @$array, undef; } else { # Naked indenter push @$array, [ ]; $self->_read_array( $array->[-1], [ @$indent, $indent2 ], $lines ); } } elsif ( $lines->[0] =~ /^(\s*)\S/ ) { push @$array, { }; $self->_read_hash( $array->[-1], [ @$indent, length("$1") ], $lines ); } else { die \"YAML::Tiny failed to classify line '$lines->[0]'"; } } elsif ( defined $indent->[-2] and $indent->[-1] == $indent->[-2] ) { # This is probably a structure like the following... # --- # foo: # - list # bar: value # # ... so lets return and let the hash parser handle it return 1; } else { die \"YAML::Tiny failed to classify line '$lines->[0]'"; } } return 1; } # Parse an array sub _read_hash { my ($self, $hash, $indent, $lines) = @_; while ( @$lines ) { # Check for a new document if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) { while ( @$lines and $lines->[0] !~ /^---/ ) { shift @$lines; } return 1; } # Check the indent level $lines->[0] =~ /^(\s*)/; if ( length($1) < $indent->[-1] ) { return 1; } elsif ( length($1) > $indent->[-1] ) { die \"YAML::Tiny found bad indenting in line '$lines->[0]'"; } # Get the key unless ( $lines->[0] =~ s/^\s*([^\'\" ][^\n]*?)\s*:(\s+(?:\#.*)?|$)// ) { if ( $lines->[0] =~ /^\s*[?\'\"]/ ) { die \"YAML::Tiny does not support a feature in line '$lines->[0]'"; } die \"YAML::Tiny failed to classify line '$lines->[0]'"; } my $key = $1; # Do we have a value? if ( length $lines->[0] ) { # Yes $hash->{$key} = $self->_read_scalar( shift(@$lines), [ @$indent, undef ], $lines ); } else { # An indent shift @$lines; unless ( @$lines ) { $hash->{$key} = undef; return 1; } if ( $lines->[0] =~ /^(\s*)-/ ) { $hash->{$key} = []; $self->_read_array( $hash->{$key}, [ @$indent, length($1) ], $lines ); } elsif ( $lines->[0] =~ /^(\s*)./ ) { my $indent2 = length("$1"); if ( $indent->[-1] >= $indent2 ) { # Null hash entry $hash->{$key} = undef; } else { $hash->{$key} = {}; $self->_read_hash( $hash->{$key}, [ @$indent, length($1) ], $lines ); } } } } return 1; } # Save an object to a file sub write { my $self = shift; my $file = shift or return $self->_error('No file name provided'); # Write it to the file open( CFG, '>' . $file ) or return $self->_error( "Failed to open file '$file' for writing: $!" ); print CFG $self->write_string; close CFG; return 1; } # Save an object to a string sub write_string { my $self = shift; return '' unless @$self; # Iterate over the documents my $indent = 0; my @lines = (); foreach my $cursor ( @$self ) { push @lines, '---'; # An empty document if ( ! defined $cursor ) { # Do nothing # A scalar document } elsif ( ! ref $cursor ) { $lines[-1] .= ' ' . $self->_write_scalar( $cursor, $indent ); # A list at the root } elsif ( ref $cursor eq 'ARRAY' ) { unless ( @$cursor ) { $lines[-1] .= ' []'; next; } push @lines, $self->_write_array( $cursor, $indent, {} ); # A hash at the root } elsif ( ref $cursor eq 'HASH' ) { unless ( %$cursor ) { $lines[-1] .= ' {}'; next; } push @lines, $self->_write_hash( $cursor, $indent, {} ); } else { Carp::croak("Cannot serialize " . ref($cursor)); } } join '', map { "$_\n" } @lines; } sub _write_scalar { my $string = $_[1]; return '~' unless defined $string; return "''" unless length $string; if ( $string =~ /[\x00-\x08\x0b-\x0d\x0e-\x1f\"\'\n]/ ) { $string =~ s/\\/\\\\/g; $string =~ s/"/\\"/g; $string =~ s/\n/\\n/g; $string =~ s/([\x00-\x1f])/\\$UNPRINTABLE[ord($1)]/g; return qq|"$string"|; } if ( $string =~ /(?:^\W|\s|:\z)/ or $QUOTE{$string} ) { return "'$string'"; } return $string; } sub _write_array { my ($self, $array, $indent, $seen) = @_; if ( $seen->{refaddr($array)}++ ) { die "YAML::Tiny does not support circular references"; } my @lines = (); foreach my $el ( @$array ) { my $line = (' ' x $indent) . '-'; my $type = ref $el; if ( ! $type ) { $line .= ' ' . $self->_write_scalar( $el, $indent + 1 ); push @lines, $line; } elsif ( $type eq 'ARRAY' ) { if ( @$el ) { push @lines, $line; push @lines, $self->_write_array( $el, $indent + 1, $seen ); } else { $line .= ' []'; push @lines, $line; } } elsif ( $type eq 'HASH' ) { if ( keys %$el ) { push @lines, $line; push @lines, $self->_write_hash( $el, $indent + 1, $seen ); } else { $line .= ' {}'; push @lines, $line; } } else { die "YAML::Tiny does not support $type references"; } } @lines; } sub _write_hash { my ($self, $hash, $indent, $seen) = @_; if ( $seen->{refaddr($hash)}++ ) { die "YAML::Tiny does not support circular references"; } my @lines = (); foreach my $name ( sort keys %$hash ) { my $el = $hash->{$name}; my $line = (' ' x $indent) . "$name:"; my $type = ref $el; if ( ! $type ) { $line .= ' ' . $self->_write_scalar( $el, $indent + 1 ); push @lines, $line; } elsif ( $type eq 'ARRAY' ) { if ( @$el ) { push @lines, $line; push @lines, $self->_write_array( $el, $indent + 1, $seen ); } else { $line .= ' []'; push @lines, $line; } } elsif ( $type eq 'HASH' ) { if ( keys %$el ) { push @lines, $line; push @lines, $self->_write_hash( $el, $indent + 1, $seen ); } else { $line .= ' {}'; push @lines, $line; } } else { die "YAML::Tiny does not support $type references"; } } @lines; } # Set error sub _error { $YAML::Tiny::errstr = $_[1]; undef; } # Retrieve error sub errstr { $YAML::Tiny::errstr; } ##################################################################### # YAML Compatibility sub Dump { YAML::Tiny->new(@_)->write_string; } sub Load { my $self = YAML::Tiny->read_string(@_); unless ( $self ) { Carp::croak("Failed to load YAML document from string"); } if ( wantarray ) { return @$self; } else { # To match YAML.pm, return the last document return $self->[-1]; } } BEGIN { *freeze = *Dump; *thaw = *Load; } sub DumpFile { my $file = shift; YAML::Tiny->new(@_)->write($file); } sub LoadFile { my $self = YAML::Tiny->read($_[0]); unless ( $self ) { Carp::croak("Failed to load YAML document from '" . ($_[0] || '') . "'"); } if ( wantarray ) { return @$self; } else { # Return only the last document to match YAML.pm, return $self->[-1]; } } ##################################################################### # Use Scalar::Util if possible, otherwise emulate it BEGIN { local $@; eval { require Scalar::Util; }; my $v = eval("$Scalar::Util::VERSION") || 0; if ( $@ or $v < 1.18 ) { eval <<'END_PERL'; # Scalar::Util failed to load or too old sub refaddr { my $pkg = ref($_[0]) or return undef; if ( !! UNIVERSAL::can($_[0], 'can') ) { bless $_[0], 'Scalar::Util::Fake'; } else { $pkg = undef; } "$_[0]" =~ /0x(\w+)/; my $i = do { local $^W; hex $1 }; bless $_[0], $pkg if defined $pkg; $i; } END_PERL } else { *refaddr = *Scalar::Util::refaddr; } } 1; __END__ =pod =head1 NAME YAML::Tiny - Read/Write YAML files with as little code as possible =head1 PREAMBLE The YAML specification is huge. Really, B huge. It contains all the functionality of XML, except with flexibility and choice, which makes it easier to read, but with a formal specification that is more complex than XML. The original pure-Perl implementation L costs just over 4 megabytes of memory to load. Just like with Windows F<.ini> files (3 meg to load) and CSS (3.5 meg to load) the situation is just asking for a B module, an incomplete but correct and usable subset of the functionality, in as little code as possible. Like the other C<::Tiny> modules, YAML::Tiny has no non-core dependencies, does not require a compiler to install, is back-compatible to Perl 5.004, and can be inlined into other modules if needed. In exchange for this adding this extreme flexibility, it provides support for only a limited subset of YAML. But the subset supported contains most of the features for the more common uses of YAML. =head1 SYNOPSIS ############################################# # In your file --- rootproperty: blah section: one: two three: four Foo: Bar empty: ~ ############################################# # In your program use YAML::Tiny; # Create a YAML file my $yaml = YAML::Tiny->new; # Open the config $yaml = YAML::Tiny->read( 'file.yml' ); # Reading properties my $root = $yaml->[0]->{rootproperty}; my $one = $yaml->[0]->{section}->{one}; my $Foo = $yaml->[0]->{section}->{Foo}; # Changing data $yaml->[0]->{newsection} = { this => 'that' }; # Add a section $yaml->[0]->{section}->{Foo} = 'Not Bar!'; # Change a value delete $yaml->[0]->{section}; # Delete a value # Add an entire document $yaml->[1] = [ 'foo', 'bar', 'baz' ]; # Save the file $yaml->write( 'file.conf' ); =head1 DESCRIPTION B is a perl class for reading and writing YAML-style files, written with as little code as possible, reducing load time and memory overhead. Most of the time it is accepted that Perl applications use a lot of memory and modules. The B<::Tiny> family of modules is specifically intended to provide an ultralight and zero-dependency alternative to many more-thorough standard modules. This module is primarily for reading human-written files (like simple config files) and generating very simple human-readable files. Note that I said B and not B. The sort of files that your average manager or secretary should be able to look at and make sense of. =for stopwords normalise L does not generate comments, it won't necessarily preserve the order of your hashes, and it will normalise if reading in and writing out again. It only supports a very basic subset of the full YAML specification. =for stopwords embeddable Usage is targeted at files like Perl's META.yml, for which a small and easily-embeddable module is extremely attractive. Features will only be added if they are human readable, and can be written in a few lines of code. Please don't be offended if your request is refused. Someone has to draw the line, and for YAML::Tiny that someone is me. If you need something with more power move up to L (4 megabytes of memory overhead) or L (275k, but requires F and a C compiler). To restate, L does B preserve your comments, whitespace, or the order of your YAML data. But it should round-trip from Perl structure to file and back again just fine. =head1 YAML TINY SPECIFICATION This section of the documentation provides a specification for "YAML Tiny", a subset of the YAML specification. It is based on and described comparatively to the YAML 1.1 Working Draft 2004-12-28 specification, located at L. Terminology and chapter numbers are based on that specification. =head2 1. Introduction and Goals The purpose of the YAML Tiny specification is to describe a useful subset of the YAML specification that can be used for typical document-oriented use cases such as configuration files and simple data structure dumps. =for stopwords extensibility Many specification elements that add flexibility or extensibility are intentionally removed, as is support for complex data structures, class and object-orientation. In general, the YAML Tiny language targets only those data structures available in JSON, with the additional limitation that only simple keys are supported. As a result, all possible YAML Tiny documents should be able to be transformed into an equivalent JSON document, although the reverse is not necessarily true (but will be true in simple cases). =for stopwords PCRE As a result of these simplifications the YAML Tiny specification should be implementable in a (relatively) small amount of code in any language that supports Perl Compatible Regular Expressions (PCRE). =head2 2. Introduction YAML Tiny supports three data structures. These are scalars (in a variety of forms), block-form sequences and block-form mappings. Flow-style sequences and mappings are not supported, with some minor exceptions detailed later. The use of three dashes "---" to indicate the start of a new document is supported, and multiple documents per file/stream is allowed. Both line and inline comments are supported. Scalars are supported via the plain style, single quote and double quote, as well as literal-style and folded-style multi-line scalars. The use of explicit tags is not supported. The use of "null" type scalars is supported via the ~ character. The use of "bool" type scalars is not supported. =for stopwords serializer However, serializer implementations should take care to explicitly escape strings that match a "bool" keyword in the following set to prevent other implementations that do support "bool" accidentally reading a string as a boolean y|Y|yes|Yes|YES|n|N|no|No|NO |true|True|TRUE|false|False|FALSE |on|On|ON|off|Off|OFF The use of anchors and aliases is not supported. The use of directives is supported only for the %YAML directive. =head2 3. Processing YAML Tiny Information B =for stopwords deserialization The YAML specification dictates three-phase serialization and three-phase deserialization. The YAML Tiny specification does not mandate any particular methodology or mechanism for parsing. Any compliant parser is only required to parse a single document at a time. The ability to support streaming documents is optional and most likely non-typical. =for stopwords acyclic Because anchors and aliases are not supported, the resulting representation graph is thus directed but (unlike the main YAML specification) B. Circular references/pointers are not possible, and any YAML Tiny serializer detecting a circular reference should error with an appropriate message. B =for stopwords unicode YAML Tiny is notionally unicode, but support for unicode is required if the underlying language or system being used to implement a parser does not support Unicode. If unicode is encountered in this case an error should be returned. B =for stopwords modality =for stopwords parsers YAML Tiny parsers and emitters are not expected to recover from adapt to errors. The specific error modality of any implementation is not dictated (return codes, exceptions, etc) but is expected to be consistent. =head2 4. Syntax B YAML Tiny streams are implemented primarily using the ASCII character set, although the use of Unicode inside strings is allowed if support by the implementation. Specific YAML Tiny encoded document types aiming for maximum compatibility should restrict themselves to ASCII. The escaping and unescaping of the 8-bit YAML escapes is required. The escaping and unescaping of 16-bit and 32-bit YAML escapes is not required. B Support for the "~" null/undefined indicator is required. Implementations may represent this as appropriate for the underlying language. Support for the "-" block sequence indicator is required. Support for the "?" mapping key indicator is B required. Support for the ":" mapping value indicator is required. Support for the "," flow collection indicator is B required. Support for the "[" flow sequence indicator is B required, with one exception (detailed below). Support for the "]" flow sequence indicator is B required, with one exception (detailed below). Support for the "{" flow mapping indicator is B required, with one exception (detailed below). Support for the "}" flow mapping indicator is B required, with one exception (detailed below). Support for the "#" comment indicator is required. Support for the "&" anchor indicator is B required. Support for the "*" alias indicator is B required. Support for the "!" tag indicator is B required. Support for the "|" literal block indicator is required. Support for the ">" folded block indicator is required. Support for the "'" single quote indicator is required. Support for the """ double quote indicator is required. Support for the "%" directive indicator is required, but only for the special case of a %YAML version directive before the "---" document header, or on the same line as the document header. For example: %YAML 1.1 --- - A sequence with a single element Special Exception: To provide the ability to support empty sequences and mappings, support for the constructs [] (empty sequence) and {} (empty mapping) are required. For example, %YAML 1.1 # A document consisting of only an empty mapping --- {} # A document consisting of only an empty sequence --- [] # A document consisting of an empty mapping within a sequence - foo - {} - bar B Other than the empty sequence and mapping cases described above, YAML Tiny supports only the indentation-based block-style group of contexts. All five scalar contexts are supported. Indentation spaces work as per the YAML specification in all cases. Comments work as per the YAML specification in all simple cases. Support for indented multi-line comments is B required. Separation spaces work as per the YAML specification in all cases. B The only directive supported by the YAML Tiny specification is the %YAML language/version identifier. Although detected, this directive will have no control over the parsing itself. =for stopwords recognise The parser must recognise both the YAML 1.0 and YAML 1.1+ formatting of this directive (as well as the commented form, although no explicit code should be needed to deal with this case, being a comment anyway) That is, all of the following should be supported. --- #YAML:1.0 - foo %YAML:1.0 --- - foo % YAML 1.1 --- - foo Support for the %TAG directive is B required. Support for additional directives is B required. Support for the document boundary marker "---" is required. Support for the document boundary market "..." is B required. If necessary, a document boundary should simply by indicated with a "---" marker, with not preceding "..." marker. Support for empty streams (containing no documents) is required. Support for implicit document starts is required. That is, the following must be equivalent. # Full form %YAML 1.1 --- foo: bar # Implicit form foo: bar B Support for nodes optional anchor and tag properties are B required. Support for node anchors is B required. Support for node tags is B required. Support for alias nodes is B required. Support for flow nodes is B required. Support for block nodes is required. B Support for all five scalar styles are required as per the YAML specification, although support for quoted scalars spanning more than one line is B required. Support for the chomping indicators on multi-line scalar styles is required. B Support for block-style sequences is required. Support for flow-style sequences is B required. Support for block-style mappings is required. Support for flow-style mappings is B required. Both sequences and mappings should be able to be arbitrarily nested. Support for plain-style mapping keys is required. Support for quoted keys in mappings is B required. Support for "?"-indicated explicit keys is B required. =for stopwords endeth Here endeth the specification. =head2 Additional Perl-Specific Notes For some Perl applications, it's important to know if you really have a number and not a string. That is, in some contexts is important that 3 the number is distinctive from "3" the string. Because even Perl itself is not trivially able to understand the difference (certainly without XS-based modules) Perl implementations of the YAML Tiny specification are not required to retain the distinctiveness of 3 vs "3". =head1 METHODS =for Pod::Coverage HAVE_UTF8 refaddr =head2 new The constructor C creates and returns an empty C object. =head2 read $filename The C constructor reads a YAML file from a file name, and returns a new C object containing the parsed content. Returns the object on success, or C on error. When C fails, C sets an error message internally you can recover via C<< YAML::Tiny->errstr >>. Although in B cases a failed C will also set the operating system error variable C<$!>, not all errors do and you should not rely on using the C<$!> variable. =head2 read_string $string; The C constructor reads YAML data from a string, and returns a new C object containing the parsed content. Returns the object on success, or C on error. =head2 write $filename The C method generates the file content for the properties, and writes it to disk to the filename specified. Returns true on success or C on error. =head2 write_string Generates the file content for the object and returns it as a string. =for stopwords errstr =head2 errstr When an error occurs, you can retrieve the error message either from the C<$YAML::Tiny::errstr> variable, or using the C method. =head1 FUNCTIONS YAML::Tiny implements a number of functions to add compatibility with the L API. These should be a drop-in replacement, except that YAML::Tiny will B export functions by default, and so you will need to explicitly import the functions. =head2 Dump my $string = Dump(list-of-Perl-data-structures); Turn Perl data into YAML. This function works very much like Data::Dumper::Dumper(). It takes a list of Perl data structures and dumps them into a serialized form. It returns a string containing the YAML stream. The structures can be references or plain scalars. =head2 Load my @documents = Load(string-containing-a-YAML-stream); Turn YAML into Perl data. This is the opposite of Dump. Just like L's thaw() function or the eval() function in relation to L. It parses a string containing a valid YAML stream into a list of Perl data structures. =head2 freeze() and thaw() Aliases to Dump() and Load() for L fans. This will also allow YAML::Tiny to be plugged directly into modules like POE.pm, that use the freeze/thaw API for internal serialization. =head2 DumpFile(filepath, list) Writes the YAML stream to a file instead of just returning a string. =head2 LoadFile(filepath) Reads the YAML stream from a file instead of a string. =head1 SUPPORT Bugs should be reported via the CPAN bug tracker at L =begin html For other issues, or commercial enhancement or support, please contact Adam Kennedy directly. =end html =head1 AUTHOR Adam Kennedy Eadamk@cpan.orgE =head1 SEE ALSO =over 4 =item * L =item * L =item * L =item * L =item * L =item * L =back =head1 COPYRIGHT Copyright 2006 - 2012 Adam Kennedy. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. The full text of the license can be found in the LICENSE file included with this module. =cut