CPAN-Meta-YAML-0.010/000755 000765 000024 00000000000 12220073077 014111 5ustar00davidstaff000000 000000 CPAN-Meta-YAML-0.010/Changes000644 000765 000024 00000003377 12220073077 015416 0ustar00davidstaff000000 000000 Revision history for CPAN-Meta-YAML 0.010 2013-09-23 13:11:20 America/New_York - Generated from ETHER/YAML-Tiny-1.55.tar.gz - Fix broken test when copying from YAML-Tiny - updated Makefile.PL logic to support PERL_NO_HIGHLANDER 0.009 2013-09-23 10:16:19 America/New_York - Generated from ETHER/YAML-Tiny-1.55.tar.gz - Makefile.PL will use UNINST=1 on old perls that might have an old version incorrectly installed into the core library path 0.008 2012-03-14 17:13:24 EST5EDT - Generated from ADAMK/YAML-Tiny-1.51.tar.gz - Updated from YAML-Tiny to fix compatibility with older Scalar::Utils 0.007 2012-02-07 22:42:42 EST5EDT - Generated from ADAMK/YAML-Tiny-1.50.tar.gz - Documentation fix to replace missing abstract 0.006 2012-02-06 20:51:47 EST5EDT - Generated from ADAMK/YAML-Tiny-1.50.tar.gz - Set back configure_requires prerequisite for ExtUtils::MakeMaker from 6.30 to 6.17 (per request from Andreas Koenig) 0.005 2011-12-13 12:57:24 EST5EDT - Generated from ADAMK/YAML-Tiny-1.50.tar.gz - Fix documentation to clarify that users are responsible for UTF-8 encoding/decoding 0.004 2011-09-06 09:42:52 America/New_York - Generated from ADAMK/YAML-Tiny-1.50.tar.gz 0.003 2011-01-02 17:32:05 EST5EDT - Generated from ADAMK/YAML-Tiny-1.46.tar.gz - Updated SEE ALSO documentation at Ingy's request - Remove CompileTests plugin from dist.ini 0.002 2010-12-17 12:31:12 EST5EDT - Generated from ADAMK/YAML-Tiny-1.46.tar.gz - Removed source $VERSION and replaced with our own - Added a SYNOPSIS to the generated Pod - Omits the dist.ini from the distribution 0.001 2010-12-17 08:53:42 EST5EDT - Generated from ADAMK/YAML-Tiny-1.46.tar.gz # vim: ts=2 sts=2 sw=2 et: CPAN-Meta-YAML-0.010/cpanfile000644 000765 000024 00000001061 12220073077 015613 0ustar00davidstaff000000 000000 requires "Carp" => "0"; requires "Exporter" => "0"; requires "Scalar::Util" => "0"; requires "perl" => "5.006"; requires "warnings" => "0"; on 'test' => sub { requires "File::Spec" => "0"; requires "File::Spec::Functions" => "0"; requires "IO::Handle" => "0"; requires "IPC::Open3" => "0"; requires "Test::More" => "0.94"; requires "strict" => "0"; requires "vars" => "0"; }; on 'configure' => sub { requires "ExtUtils::MakeMaker" => "6.17"; }; on 'develop' => sub { requires "Test::CPAN::Meta" => "0"; requires "Test::Pod" => "1.41"; }; CPAN-Meta-YAML-0.010/lib/000755 000765 000024 00000000000 12220073077 014657 5ustar00davidstaff000000 000000 CPAN-Meta-YAML-0.010/LICENSE000644 000765 000024 00000043653 12220073077 015131 0ustar00davidstaff000000 000000 This software is copyright (c) 2010 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) 2010 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) 2010 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 CPAN-Meta-YAML-0.010/Makefile.PL000644 000765 000024 00000003610 12220073077 016063 0ustar00davidstaff000000 000000 use strict; use warnings; use 5.006; use ExtUtils::MakeMaker 6.17; my %WriteMakefileArgs = ( "ABSTRACT" => "Read and write a subset of YAML for CPAN Meta files", "AUTHOR" => "Adam Kennedy , David Golden ", "BUILD_REQUIRES" => {}, "CONFIGURE_REQUIRES" => { "ExtUtils::MakeMaker" => "6.17" }, "DISTNAME" => "CPAN-Meta-YAML", "EXE_FILES" => [], "LICENSE" => "perl", "NAME" => "CPAN::Meta::YAML", "PREREQ_PM" => { "Carp" => 0, "Exporter" => 0, "Scalar::Util" => 0, "warnings" => 0 }, "TEST_REQUIRES" => { "File::Spec" => 0, "File::Spec::Functions" => 0, "IO::Handle" => 0, "IPC::Open3" => 0, "Test::More" => "0.94", "strict" => 0, "vars" => 0 }, "VERSION" => "0.010", "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) }; # Added by Dist::Zilla::Plugin::MakeMaker::Highlander if ( $] < 5.012 && ! $ENV{PERL_NO_HIGHLANDER} && ! ( $ENV{PERL_MM_OPT} && $ENV{PERL_MM_OPT} =~ /(?:INSTALL_BASE|PREFIX)/ ) && ! grep { /INSTALL_BASE/ || /PREFIX/ } @ARGV ) { $WriteMakefileArgs{UNINST} = 1; } WriteMakefile(%WriteMakefileArgs); CPAN-Meta-YAML-0.010/MANIFEST000644 000765 000024 00000001316 12220073077 015243 0ustar00davidstaff000000 000000 Changes LICENSE MANIFEST MANIFEST.SKIP META.json META.yml Makefile.PL README cpanfile lib/CPAN/Meta/YAML.pm t/00-compile.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/release/distmeta.t xt/release/pod-syntax.t xt/release/portability.t xt/release/test-version.t CPAN-Meta-YAML-0.010/MANIFEST.SKIP000644 000765 000024 00000000013 12220073077 016001 0ustar00davidstaff000000 000000 ^dist\.ini CPAN-Meta-YAML-0.010/META.json000644 000765 000024 00000003727 12220073077 015543 0ustar00davidstaff000000 000000 { "abstract" : "Read and write a subset of YAML for CPAN Meta files", "author" : [ "Adam Kennedy ", "David Golden " ], "dynamic_config" : 0, "generated_by" : "Dist::Zilla version 4.300039, CPAN::Meta::Converter version 2.132660", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "CPAN-Meta-YAML", "no_index" : { "directory" : [ "t", "xt", "examples", "corpus" ], "package" : [ "DB" ] }, "prereqs" : { "configure" : { "requires" : { "ExtUtils::MakeMaker" : "6.17" } }, "develop" : { "requires" : { "Test::CPAN::Meta" : "0", "Test::Pod" : "1.41" } }, "runtime" : { "requires" : { "Carp" : "0", "Exporter" : "0", "Scalar::Util" : "0", "perl" : "5.006", "warnings" : "0" } }, "test" : { "requires" : { "File::Spec" : "0", "File::Spec::Functions" : "0", "IO::Handle" : "0", "IPC::Open3" : "0", "Test::More" : "0.94", "strict" : "0", "vars" : "0" } } }, "provides" : { "CPAN::Meta::YAML" : { "file" : "lib/CPAN/Meta/YAML.pm", "version" : "0.010" } }, "release_status" : "stable", "resources" : { "bugtracker" : { "web" : "https://github.com/dagolden/CPAN-Meta-YAML/issues" }, "homepage" : "https://github.com/dagolden/CPAN-Meta-YAML", "repository" : { "type" : "git", "url" : "https://github.com/dagolden/CPAN-Meta-YAML.git", "web" : "https://github.com/dagolden/CPAN-Meta-YAML" } }, "version" : "0.010", "x_authority" : "cpan:DAGOLDEN" } CPAN-Meta-YAML-0.010/META.yml000644 000765 000024 00000002020 12220073077 015354 0ustar00davidstaff000000 000000 --- abstract: 'Read and write a subset of YAML for CPAN Meta files' author: - 'Adam Kennedy ' - 'David Golden ' build_requires: File::Spec: 0 File::Spec::Functions: 0 IO::Handle: 0 IPC::Open3: 0 Test::More: 0.94 strict: 0 vars: 0 configure_requires: ExtUtils::MakeMaker: 6.17 dynamic_config: 0 generated_by: 'Dist::Zilla version 4.300039, CPAN::Meta::Converter version 2.132660' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: CPAN-Meta-YAML no_index: directory: - t - xt - examples - corpus package: - DB provides: CPAN::Meta::YAML: file: lib/CPAN/Meta/YAML.pm version: 0.010 requires: Carp: 0 Exporter: 0 Scalar::Util: 0 perl: 5.006 warnings: 0 resources: bugtracker: https://github.com/dagolden/CPAN-Meta-YAML/issues homepage: https://github.com/dagolden/CPAN-Meta-YAML repository: https://github.com/dagolden/CPAN-Meta-YAML.git version: 0.010 x_authority: cpan:DAGOLDEN CPAN-Meta-YAML-0.010/README000644 000765 000024 00000004240 12220073077 014771 0ustar00davidstaff000000 000000 NAME CPAN::Meta::YAML - Read and write a subset of YAML for CPAN Meta files VERSION version 0.010 SYNOPSIS use CPAN::Meta::YAML; # reading a META file open $fh, "<:utf8", "META.yml"; $yaml_text = do { local $/; <$fh> }; $yaml = CPAN::Meta::YAML->read_string($yaml_text) or die CPAN::Meta::YAML->errstr; # finding the metadata $meta = $yaml->[0]; # writing a META file $yaml_text = $yaml->write_string or die CPAN::Meta::YAML->errstr; open $fh, ">:utf8", "META.yml"; print $fh $yaml_text; DESCRIPTION This module implements a subset of the YAML specification for use in reading and writing CPAN metadata files like META.yml and MYMETA.yml. It should not be used for any other general YAML parsing or generation task. NOTE: META.yml (and MYMETA.yml) files should be UTF-8 encoded. Users are responsible for proper encoding and decoding. In particular, the "read" and "write" methods do not support UTF-8 and should not be used. SUPPORT This module is currently derived from YAML::Tiny by Adam Kennedy. If there are bugs in how it parses a particular META.yml file, please file a bug report in the YAML::Tiny bugtracker: SEE ALSO YAML::Tiny, YAML, YAML::XS SUPPORT Bugs / Feature Requests Please report any bugs or feature requests through the issue tracker at . You will be notified automatically of any progress on your issue. Source Code This is open source software. The code repository is available for public review and contribution under the terms of the license. git clone https://github.com/dagolden/CPAN-Meta-YAML.git AUTHORS * Adam Kennedy * David Golden COPYRIGHT AND LICENSE This software is copyright (c) 2010 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. CPAN-Meta-YAML-0.010/t/000755 000765 000024 00000000000 12220073077 014354 5ustar00davidstaff000000 000000 CPAN-Meta-YAML-0.010/xt/000755 000765 000024 00000000000 12220073077 014544 5ustar00davidstaff000000 000000 CPAN-Meta-YAML-0.010/xt/release/000755 000765 000024 00000000000 12220073077 016164 5ustar00davidstaff000000 000000 CPAN-Meta-YAML-0.010/xt/release/distmeta.t000644 000765 000024 00000000217 12220073077 020163 0ustar00davidstaff000000 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(); CPAN-Meta-YAML-0.010/xt/release/pod-syntax.t000644 000765 000024 00000000212 12220073077 020452 0ustar00davidstaff000000 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(); CPAN-Meta-YAML-0.010/xt/release/portability.t000644 000765 000024 00000000332 12220073077 020711 0ustar00davidstaff000000 000000 #!perl use strict; use warnings; use Test::More; eval 'use Test::Portability::Files'; plan skip_all => 'Test::Portability::Files required for testing portability' if $@; options(test_one_dot => 0); run_tests(); CPAN-Meta-YAML-0.010/xt/release/test-version.t000644 000765 000024 00000000643 12220073077 021016 0ustar00davidstaff000000 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 => 0, 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; CPAN-Meta-YAML-0.010/t/00-compile.t000644 000765 000024 00000001656 12220073077 016416 0ustar00davidstaff000000 000000 use strict; use warnings; # this test was generated with Dist::Zilla::Plugin::Test::Compile 2.030 use Test::More 0.94 tests => 1 + ($ENV{AUTHOR_TESTING} ? 1 : 0); my @module_files = ( 'CPAN/Meta/YAML.pm' ); # no fake home requested use IPC::Open3; use IO::Handle; my @warnings; for my $lib (@module_files) { # see L my $stdin = ''; # converted to a gensym by open3 my $stderr = IO::Handle->new; my $pid = open3($stdin, '>&STDERR', $stderr, qq{$^X -Mblib -e"require q[$lib]"}); binmode $stderr, ':crlf' if $^O; # eq 'MSWin32'; waitpid($pid, 0); is($? >> 8, 0, "$lib loaded ok"); if (my @_warnings = <$stderr>) { 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; CPAN-Meta-YAML-0.010/t/01_compile.t000644 000765 000024 00000000476 12220073077 016500 0ustar00davidstaff000000 000000 # Load testing for CPAN::Meta::YAML 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( 'CPAN::Meta::YAML' ); use_ok( 't::lib::Test' ); CPAN-Meta-YAML-0.010/t/02_basic.t000644 000765 000024 00000007172 12220073077 016132 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # 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', ); CPAN-Meta-YAML-0.010/t/03_regression.t000755 000765 000024 00000025676 12220073077 017246 0ustar00davidstaff000000 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 CPAN::Meta::YAML 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 = CPAN::Meta::YAML->new( [ $foo, $bar ] ); isa_ok( $circ, 'CPAN::Meta::YAML' ); # 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( CPAN::Meta::YAML->new( 'True' )->write_string, "--- 'True'\n", 'Idiomatic trivial boolean string is escaped', ); is_deeply( CPAN::Meta::YAML->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( CPAN::Meta::YAML->new( [ 'A:' ] )->write_string, "---\n- 'A:'\n", 'Simple scalar ending in a colon is correctly quoted', ); CPAN-Meta-YAML-0.010/t/04_scalar.t000644 000765 000024 00000006422 12220073077 016315 0ustar00davidstaff000000 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 CPAN::Meta::YAML (); ##################################################################### # 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 = [ CPAN::Meta::YAML::Load( $one ) ]; my $two_list_tiny = [ CPAN::Meta::YAML::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 = CPAN::Meta::YAML::Load( $one ); my $two_scalar_tiny = CPAN::Meta::YAML::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 = [ CPAN::Meta::YAML::LoadFile( $one_file ) ]; my $two_list_tiny = [ CPAN::Meta::YAML::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 = CPAN::Meta::YAML::LoadFile( $one_file ); my $two_scalar_tiny = CPAN::Meta::YAML::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' ); } CPAN-Meta-YAML-0.010/t/05_export.t000644 000765 000024 00000000761 12220073077 016372 0ustar00davidstaff000000 000000 # Testing of basic document structures use strict; use warnings; BEGIN { $| = 1; $^W = 1; } use Test::More tests => 6; use CPAN::Meta::YAML; 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 == \&CPAN::Meta::YAML::Load, 'Load is CPAN::Meta::YAML'; ok \&main::Dump == \&CPAN::Meta::YAML::Dump, 'Dump is CPAN::Meta::YAML'; CPAN-Meta-YAML-0.010/t/11_meta_yml.t000755 000765 000024 00000025064 12220073077 016663 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # Testing CPAN::Meta::YAML'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', } ], 'CPAN::Meta::YAML', ); ##################################################################### # 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', } ], 'CPAN::Meta::YAML', ); ##################################################################### # 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, ); } CPAN-Meta-YAML-0.010/t/12_plagger.t000755 000765 000024 00000005157 12220073077 016477 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # 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', ); CPAN-Meta-YAML-0.010/t/13_perl_smith.t000755 000765 000024 00000012003 12220073077 017211 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # 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, ); CPAN-Meta-YAML-0.010/t/14_yaml_org.t000755 000765 000024 00000002720 12220073077 016662 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # 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, ); CPAN-Meta-YAML-0.010/t/15_multibyte.t000755 000765 000024 00000002562 12220073077 017074 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # 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 { CPAN::Meta::YAML->read_string( $yaml_copy ); }; is( $@, '', "$name: CPAN::Meta::YAML parses without error" ); is( $yaml_copy, $sample, "$name: CPAN::Meta::YAML does not modify the input string" ); SKIP: { skip( "Shortcutting after failure", 2 ) if $@; isa_ok( $yaml, 'CPAN::Meta::YAML' ); is_deeply( $yaml->[0]->{build_requires}, { 'Config' => 0, 'Test::More' => 0, 'XSLoader' => 0, }, 'build_requires ok' ); } SKIP: { unless ( CPAN::Meta::YAML::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" ); } CPAN-Meta-YAML-0.010/t/16_nullrefs.t000644 000765 000024 00000000606 12220073077 016703 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # Example Empty References yaml_ok( <<'END_YAML', --- [] --- {} END_YAML [ [], {} ], 'Empty references', ); CPAN-Meta-YAML-0.010/t/17_toolbar.t000644 000765 000024 00000002124 12220073077 016511 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # 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, ); CPAN-Meta-YAML-0.010/t/18_tap.t000644 000765 000024 00000002424 12220073077 015637 0ustar00davidstaff000000 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 CPAN::Meta::YAML (); ##################################################################### # 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, ); CPAN-Meta-YAML-0.010/t/19_errors.t000644 000765 000024 00000002057 12220073077 016372 0ustar00davidstaff000000 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 CPAN::Meta::YAML (); 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 CPAN-Meta-YAML-0.010/t/20_subclass.t000644 000765 000024 00000001540 12220073077 016661 0ustar00davidstaff000000 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 CPAN::Meta::YAML; use vars qw{@ISA}; BEGIN { @ISA = 'CPAN::Meta::YAML'; } 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' ); CPAN-Meta-YAML-0.010/t/21_bom.t000755 000765 000024 00000001630 12220073077 015623 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # 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 { CPAN::Meta::YAML->read_string( $yaml_copy ); }; is( $@, '', "$name: CPAN::Meta::YAML parses without error" ); is( $yaml_copy, $sample, "$name: CPAN::Meta::YAML does not modify the input string" ); SKIP: { skip( "Shortcutting after failure", 2 ) if $@; is( $yaml, undef, "file not parsed" ); is( CPAN::Meta::YAML->errstr, "Stream has a non UTF-8 BOM", "correct error" ); } CPAN-Meta-YAML-0.010/t/22_comments.t000644 000765 000024 00000004454 12220073077 016700 0ustar00davidstaff000000 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 CPAN::Meta::YAML; ##################################################################### # 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, ); CPAN-Meta-YAML-0.010/t/data/000755 000765 000024 00000000000 12220073077 015265 5ustar00davidstaff000000 000000 CPAN-Meta-YAML-0.010/t/lib/000755 000765 000024 00000000000 12220073077 015122 5ustar00davidstaff000000 000000 CPAN-Meta-YAML-0.010/t/lib/Test.pm000755 000765 000024 00000026104 12220073077 016405 0ustar00davidstaff000000 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, 'CPAN::Meta::YAML'; # 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 ], 'CPAN::Meta::YAML'; 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 ], 'CPAN::Meta::YAML'; 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 ], 'CPAN::Meta::YAML'; 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 ], 'CPAN::Meta::YAML'; 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 { CPAN::Meta::YAML->read_string( $yaml_copy ); }; Test::More::is( $@, '', "$name: CPAN::Meta::YAML parses without error" ); Test::More::is( $yaml_copy, $string, "$name: CPAN::Meta::YAML does not modify the input string" ); SKIP: { Test::More::skip( "Shortcutting after failure", 2 ) if $@; Test::More::isa_ok( $yaml, 'CPAN::Meta::YAML' ); Test::More::is_deeply( $yaml, $object, "$name: CPAN::Meta::YAML 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: CPAN::Meta::YAML serializes without error" ); SKIP: { Test::More::skip( "Shortcutting after failure", 5 ) if $@; Test::More::ok( !!(defined $output and ! ref $output), "$name: CPAN::Meta::YAML serializes correctly", ); my $roundtrip = eval { CPAN::Meta::YAML->read_string( $output ) }; Test::More::is( $@, '', "$name: CPAN::Meta::YAML round-trips without error" ); Test::More::skip( "Shortcutting after failure", 2 ) if $@; Test::More::isa_ok( $roundtrip, 'CPAN::Meta::YAML' ); Test::More::is_deeply( $roundtrip, $object, "$name: CPAN::Meta::YAML 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 = CPAN::Meta::YAML->read_string( $string ); Test::More::is( $yaml, undef, '->read_string returns undef' ); Test::More::ok( CPAN::Meta::YAML->errstr =~ /$like/, "Got expected error" ); # NOTE: like() gives better diagnostics (but requires 5.005) # Test::More::like( $@, qr/$_[0]/, "CPAN::Meta::YAML 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; CPAN-Meta-YAML-0.010/t/data/HTML-WebDAO.yml000755 000765 000024 00000000306 12220073077 017615 0ustar00davidstaff000000 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 CPAN-Meta-YAML-0.010/t/data/multibyte.yml000755 000765 000024 00000000722 12220073077 020032 0ustar00davidstaff000000 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 CPAN-Meta-YAML-0.010/t/data/one.yml000644 000765 000024 00000000012 12220073077 016562 0ustar00davidstaff000000 000000 --- - foo CPAN-Meta-YAML-0.010/t/data/sample.yml000755 000765 000024 00000001114 12220073077 017271 0ustar00davidstaff000000 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. CPAN-Meta-YAML-0.010/t/data/Spreadsheet-Read.yml000644 000765 000024 00000003405 12220073077 021132 0ustar00davidstaff000000 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 CPAN-Meta-YAML-0.010/t/data/Template-Provider-Unicode-Japanese.yml000755 000765 000024 00000000717 12220073077 024473 0ustar00davidstaff000000 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 CPAN-Meta-YAML-0.010/t/data/toolbar.yml000644 000765 000024 00000000451 12220073077 017452 0ustar00davidstaff000000 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 CPAN-Meta-YAML-0.010/t/data/two.yml000644 000765 000024 00000000024 12220073077 016615 0ustar00davidstaff000000 000000 --- - foo --- - bar CPAN-Meta-YAML-0.010/t/data/utf_16_le_bom.yml000644 000765 000024 00000000026 12220073077 020427 0ustar00davidstaff000000 000000 ÿþ--- - foo CPAN-Meta-YAML-0.010/t/data/vanilla.yml000755 000765 000024 00000006064 12220073077 017447 0ustar00davidstaff000000 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 CPAN-Meta-YAML-0.010/lib/CPAN/000755 000765 000024 00000000000 12220073077 015400 5ustar00davidstaff000000 000000 CPAN-Meta-YAML-0.010/lib/CPAN/Meta/000755 000765 000024 00000000000 12220073077 016266 5ustar00davidstaff000000 000000 CPAN-Meta-YAML-0.010/lib/CPAN/Meta/YAML.pm000644 000765 000024 00000050401 12220073077 017366 0ustar00davidstaff000000 000000 package CPAN::Meta::YAML; { $CPAN::Meta::YAML::VERSION = '0.010'; } BEGIN { $CPAN::Meta::YAML::AUTHORITY = 'cpan:ADAMK'; } { ; # original $VERSION removed by Doppelgaenger } # git description: v1.54-8-g4c3002d 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; @CPAN::Meta::YAML::ISA = qw{ Exporter }; @CPAN::Meta::YAML::EXPORT = qw{ Load Dump }; @CPAN::Meta::YAML::EXPORT_OK = qw{ LoadFile DumpFile freeze thaw }; # Error storage $CPAN::Meta::YAML::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 CPAN::Meta::YAML 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 \"CPAN::Meta::YAML 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 \"CPAN::Meta::YAML 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 \"CPAN::Meta::YAML found illegal characters in plain scalar: '$string'"; } $string =~ s/\s+#.*\z//; return $string; } # Error die \"CPAN::Meta::YAML 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 \"CPAN::Meta::YAML 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 \"CPAN::Meta::YAML 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 \"CPAN::Meta::YAML 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 \"CPAN::Meta::YAML 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 \"CPAN::Meta::YAML found bad indenting in line '$lines->[0]'"; } # Get the key unless ( $lines->[0] =~ s/^\s*([^\'\" ][^\n]*?)\s*:(\s+(?:\#.*)?|$)// ) { if ( $lines->[0] =~ /^\s*[?\'\"]/ ) { die \"CPAN::Meta::YAML does not support a feature in line '$lines->[0]'"; } die \"CPAN::Meta::YAML 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 "CPAN::Meta::YAML 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 "CPAN::Meta::YAML does not support $type references"; } } @lines; } sub _write_hash { my ($self, $hash, $indent, $seen) = @_; if ( $seen->{refaddr($hash)}++ ) { die "CPAN::Meta::YAML 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 "CPAN::Meta::YAML does not support $type references"; } } @lines; } # Set error sub _error { $CPAN::Meta::YAML::errstr = $_[1]; undef; } # Retrieve error sub errstr { $CPAN::Meta::YAML::errstr; } ##################################################################### # YAML Compatibility sub Dump { CPAN::Meta::YAML->new(@_)->write_string; } sub Load { my $self = CPAN::Meta::YAML->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; CPAN::Meta::YAML->new(@_)->write($file); } sub LoadFile { my $self = CPAN::Meta::YAML->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; =pod =encoding utf-8 =head1 NAME CPAN::Meta::YAML - Read and write a subset of YAML for CPAN Meta files =head1 VERSION version 0.010 =head1 SYNOPSIS use CPAN::Meta::YAML; # reading a META file open $fh, "<:utf8", "META.yml"; $yaml_text = do { local $/; <$fh> }; $yaml = CPAN::Meta::YAML->read_string($yaml_text) or die CPAN::Meta::YAML->errstr; # finding the metadata $meta = $yaml->[0]; # writing a META file $yaml_text = $yaml->write_string or die CPAN::Meta::YAML->errstr; open $fh, ">:utf8", "META.yml"; print $fh $yaml_text; =head1 DESCRIPTION This module implements a subset of the YAML specification for use in reading and writing CPAN metadata files like F and F. It should not be used for any other general YAML parsing or generation task. NOTE: F (and F) files should be UTF-8 encoded. Users are responsible for proper encoding and decoding. In particular, the C and C methods do B support UTF-8 and should not be used. =head1 SUPPORT This module is currently derived from L by Adam Kennedy. If there are bugs in how it parses a particular META.yml file, please file a bug report in the YAML::Tiny bugtracker: L =head1 SEE ALSO L, L, L =for :stopwords cpan testmatrix url annocpan anno bugtracker rt cpants kwalitee diff irc mailto metadata placeholders metacpan =head1 SUPPORT =head2 Bugs / Feature Requests Please report any bugs or feature requests through the issue tracker at L. You will be notified automatically of any progress on your issue. =head2 Source Code This is open source software. The code repository is available for public review and contribution under the terms of the license. L git clone https://github.com/dagolden/CPAN-Meta-YAML.git =head1 AUTHORS =over 4 =item * Adam Kennedy =item * David Golden =back =head1 COPYRIGHT AND LICENSE This software is copyright (c) 2010 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. =cut __END__ # ABSTRACT: Read and write a subset of YAML for CPAN Meta files