diff --git a/COPYRIGHT b/COPYRIGHT
index 05f9cc9..8f17499 100644
--- a/COPYRIGHT
+++ b/COPYRIGHT
@@ -31,40 +31,40 @@ Files: inc/Module/Install/TrustMetaYml.pm
 Copyright: This software is copyright (c) 2011-2012 by Toby Inkster.
 License: GPL-1.0+ or Artistic-1.0
 
-Files: inc/Module/Install/Base.pm
-Copyright: Copyright 2003, 2004 by Audrey Tang <autrijus@autrijus.org>.
-License: GPL-1.0+ or Artistic-1.0
+Files: COPYRIGHT
+Copyright: None
+License: public-domain
+Comment: This file! Automatically generated.
 
-Files: inc/Module/Install/Makefile.pm
-Copyright: Copyright 2002, 2003, 2004 Audrey Tang and Brian Ingerson.
+Files: inc/Module/Install/Package.pm
+Copyright: Copyright (c) 2011. Ingy doet Net.
 License: GPL-1.0+ or Artistic-1.0
 
 Files: inc/YAML/Tiny.pm
-Copyright: Copyright 2006 - 2012 Adam Kennedy.
+Copyright: Copyright 2006 - 2013 Adam Kennedy.
 License: GPL-1.0+ or Artistic-1.0
 
-Files: inc/Module/Install/Package.pm
-Copyright: Copyright (c) 2011. Ingy doet Net.
+Files: inc/Module/Install/Makefile.pm
+Copyright: Copyright 2002, 2003, 2004 Audrey Tang and Brian Ingerson.
+License: GPL-1.0+ or Artistic-1.0
+
+Files: inc/Module/Install/Base.pm
+Copyright: Copyright 2003, 2004 by Audrey Tang <autrijus@autrijus.org>.
 License: GPL-1.0+ or Artistic-1.0
 
 Files: lib/Module/Install/DOAP.pm
 Copyright: Copyright (C) 2011 by Toby Inkster.
 License: GPL-1.0+ or Artistic-1.0
 
-Files: COPYRIGHT
-Copyright: None
-License: public-domain
-Comment: This file! Automatically generated.
-
 License: Artistic-1.0
- This software is Copyright (c) 2013 by the copyright holder(s).
+ This software is Copyright (c) 2022 by the copyright holder(s).
  
  This is free software, licensed under:
  
    The Artistic License 1.0
 
 License: GPL-1.0
- This software is Copyright (c) 2013 by the copyright holder(s).
+ This software is Copyright (c) 2022 by the copyright holder(s).
  
  This is free software, licensed under:
  
diff --git a/LICENSE b/LICENSE
index 12bbbcb..195381c 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-This software is copyright (c) 2013 by Toby Inkster <tobyink@cpan.org>.
+This software is copyright (c) 2022 by Toby Inkster <tobyink@cpan.org>.
 
 This is free software; you can redistribute it and/or modify it under
 the same terms as the Perl 5 programming language system itself.
@@ -12,7 +12,7 @@ b) the "Artistic License"
 
 --- The GNU General Public License, Version 1, February 1989 ---
 
-This software is Copyright (c) 2013 by Toby Inkster <tobyink@cpan.org>.
+This software is Copyright (c) 2022 by Toby Inkster <tobyink@cpan.org>.
 
 This is free software, licensed under:
 
@@ -22,7 +22,7 @@ This is free software, licensed under:
                      Version 1, February 1989
 
  Copyright (C) 1989 Free Software Foundation, Inc.
- 51 Franklin St, Suite 500, Boston, MA  02110-1335  USA
+ 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
@@ -272,7 +272,7 @@ That's all there is to it!
 
 --- The Artistic License 1.0 ---
 
-This software is Copyright (c) 2013 by Toby Inkster <tobyink@cpan.org>.
+This software is Copyright (c) 2022 by Toby Inkster <tobyink@cpan.org>.
 
 This is free software, licensed under:
 
@@ -292,21 +292,21 @@ Definitions:
 
   - "Package" refers to the collection of files distributed by the Copyright
     Holder, and derivatives of that collection of files created through
-    textual modification. 
+    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. 
+    Holder.
   - "Copyright Holder" is whoever is named in the copyright or copyrights for
-    the package. 
+    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.) 
+    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. 
+    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
@@ -373,7 +373,7 @@ 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.
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
 The End
 
diff --git a/MANIFEST b/MANIFEST
index a0ba364..0669961 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -29,6 +29,41 @@ meta/changes.ttl
 meta/deps.ttl
 meta/doap.ttl
 meta/makefile.ttl
+Module-Install-DOAP-0.006/Changes
+Module-Install-DOAP-0.006/COPYRIGHT
+Module-Install-DOAP-0.006/CREDITS
+Module-Install-DOAP-0.006/inc/Module/AutoInstall.pm
+Module-Install-DOAP-0.006/inc/Module/Install.pm
+Module-Install-DOAP-0.006/inc/Module/Install/AutoInstall.pm
+Module-Install-DOAP-0.006/inc/Module/Install/AutoManifest.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Base.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Can.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Fetch.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Include.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Makefile.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Metadata.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Package.pm
+Module-Install-DOAP-0.006/inc/Module/Install/TrustMetaYml.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Win32.pm
+Module-Install-DOAP-0.006/inc/Module/Install/WriteAll.pm
+Module-Install-DOAP-0.006/inc/Module/Package.pm
+Module-Install-DOAP-0.006/inc/Module/Package/Dist/RDF.pm
+Module-Install-DOAP-0.006/inc/YAML/Tiny.pm
+Module-Install-DOAP-0.006/lib/Module/Install/Admin/DOAP.pm
+Module-Install-DOAP-0.006/lib/Module/Install/DOAP.pm
+Module-Install-DOAP-0.006/LICENSE
+Module-Install-DOAP-0.006/Makefile.PL
+Module-Install-DOAP-0.006/MANIFEST
+Module-Install-DOAP-0.006/META.ttl
+Module-Install-DOAP-0.006/META.yml
+Module-Install-DOAP-0.006/meta/changes.ttl
+Module-Install-DOAP-0.006/meta/deps.ttl
+Module-Install-DOAP-0.006/meta/doap.ttl
+Module-Install-DOAP-0.006/meta/makefile.ttl
+Module-Install-DOAP-0.006/README
+Module-Install-DOAP-0.006/SIGNATURE
+Module-Install-DOAP-0.006/t/01basic.t
+Module-Install-DOAP-0.006/TODO
 README
 t/01basic.t
 TODO
diff --git a/META.ttl b/META.ttl
index 39103c2..625fa24 100644
--- a/META.ttl
+++ b/META.ttl
@@ -1,137 +1,108 @@
-@prefix cpan:  <http://purl.org/NET/cpan-uri/person/> .
+@prefix bugs: <http://ontologi.es/doap-bugs#> .
+@prefix cpan: <http://purl.org/NET/cpan-uri/person/> .
 @prefix cpant: <http://purl.org/NET/cpan-uri/terms#> .
-@prefix dc:    <http://purl.org/dc/terms/> .
-@prefix dcs:   <http://ontologi.es/doap-changeset#> .
-@prefix deps:  <http://ontologi.es/doap-deps#> .
-@prefix dist:  <http://purl.org/NET/cpan-uri/dist/Module-Install-DOAP/> .
-@prefix doap:  <http://usefulinc.com/ns/doap#> .
-@prefix foaf:  <http://xmlns.com/foaf/0.1/> .
-@prefix nfo:   <http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#> .
-@prefix owl:   <http://www.w3.org/2002/07/owl#> .
-@prefix rdfs:  <http://www.w3.org/2000/01/rdf-schema#> .
-@prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .
-
-dist:project
-	a                 doap:Project;
-	doap:name         "Module-Install-DOAP";
-	cpant:perl_version_from _:B1;
-	cpant:readme_from _:B1;
-	cpant:version_from _:B1;
-	deps:runtime-requirement [ deps:on "Module::Install 1.00"^^deps:CpanId ];
-	deps:runtime-requirement [
-		deps:on "Module::Install::RDF 0.004"^^deps:CpanId;
-	];
-	deps:runtime-requirement [
-		deps:on "Module::Install::Admin::RDF 0.004"^^deps:CpanId;
-	];
-	deps:runtime-requirement [ deps:on "RDF::Trine 0.133"^^deps:CpanId ];
-	deps:test-requirement [ deps:on "Test::More 0.96"^^deps:CpanId ];
-	doap:bug-database <http://rt.cpan.org/Dist/Display.html?Queue=Module-Install-DOAP>;
-	doap:category     [ rdfs:label "RDF" ];
-	doap:category     [ rdfs:label "Semantic Web" ];
-	doap:category     [ rdfs:label "CPAN" ];
-	doap:category     [ rdfs:label "DOAP" ];
-	doap:category     [ rdfs:label "Metadata" ];
-	doap:category     [ rdfs:label "Packaging" ];
-	doap:created      "2011-09-30"^^xsd:date;
-	doap:developer    <http://tobyinkster.co.uk/#i>;
-	doap:documenter   <http://tobyinkster.co.uk/#i>;
-	doap:download-page <https://metacpan.org/release/Module-Install-DOAP>;
-	doap:homepage     <https://metacpan.org/release/Module-Install-DOAP>;
-	doap:license      <http://dev.perl.org/licenses/>;
-	doap:maintainer   <http://tobyinkster.co.uk/#i>;
-	doap:programming-language "Perl";
-	doap:release      dist:v_0-001;
-	doap:release      dist:v_0-002;
-	doap:release      dist:v_0-003;
-	doap:release      dist:v_0-004;
-	doap:release      dist:v_0-005;
-	doap:release      dist:v_0-006;
-	doap:repository   [
-		a doap:GitRepository;
-		doap:browse <https://github.com/tobyink/p5-module-install-doap>;
-	];
-	doap:shortdesc    "generate META.yml data from DOAP"@en;
-	doap:tester       <http://tobyinkster.co.uk/#i>.
-
-dist:v_0-001
-	a                 doap:Version;
-	rdfs:label        "Initial release";
-	dc:issued         "2011-10-01"^^xsd:date;
-	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.001.tar.gz>;
-	doap:revision     "0.001"^^xsd:string.
-
-dist:v_0-002
-	a                 doap:Version;
-	dc:issued         "2011-10-06"^^xsd:date;
-	dcs:changeset     [
-		dcs:item [
-			a dcs:Packaging;
-			rdfs:label "Upgrade Module::Package::RDF version."@en;
-		];
-		dcs:versus dist:v_0-001;
-	];
-	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.002.tar.gz>;
-	doap:revision     "0.002"^^xsd:string.
-
-dist:v_0-003
-	a                 doap:Version;
-	dc:issued         "2011-11-26"^^xsd:date;
-	dcs:changeset     [
-		dcs:item [
-			rdfs:label "Use Module::Install::RDF's new heuristics for detecting the doap:Project URI."@en;
-		];
-		dcs:item [ a dcs:Regression; rdfs:label "use parent" ];
-		dcs:versus dist:v_0-002;
-	];
-	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.003.tar.gz>;
-	doap:revision     "0.003"^^xsd:string.
-
-dist:v_0-004
-	a                 doap:Version;
-	dc:issued         "2011-12-03"^^xsd:date;
-	dcs:changeset     [
-		dcs:item [ a dcs:Bugfix; rdfs:label "use base" ];
-		dcs:versus dist:v_0-003;
-	];
-	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.004.tar.gz>;
-	doap:revision     "0.004"^^xsd:string.
-
-dist:v_0-005
-	a                 doap:Version;
-	dc:issued         "2013-07-31"^^xsd:date;
-	dcs:changeset     [
-		dcs:item [
-			a dcs:Update;
-			rdfs:label "Support http://ontologi.es/doap-deps, and deprecate old dependency predicates.";
-		];
-		dcs:versus dist:v_0-004;
-	];
-	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.005.tar.gz>;
-	doap:revision     "0.005"^^xsd:string.
-
-dist:v_0-006
-	a                 doap:Version;
-	dc:issued         "2013-07-31"^^xsd:date;
-	dcs:changeset     [
-		dcs:item [
-			a dcs:Bugfix;
-			a dcs:Packaging;
-			rdfs:label "Oops; hyphens.";
-		];
-		dcs:versus dist:v_0-005;
-	];
-	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.006.tar.gz>;
-	doap:revision     "0.006"^^xsd:string.
-
-<http://tobyinkster.co.uk/#i>
-	a                 foaf:Person;
-	foaf:name         "Toby Inkster";
-	foaf:homepage     <http://tobyinkster.co.uk/>;
-	foaf:mbox         <mailto:tobyink@cpan.org>;
-	foaf:page         <https://metacpan.org/author/TOBYINK>;
-	owl:sameAs        cpan:tobyink.
-
-_:B1
-	nfo:fileName      "lib/Module/Install/DOAP.pm".
+@prefix dcs: <http://ontologi.es/doap-changeset#> .
+@prefix deps: <http://ontologi.es/doap-deps#> .
+@prefix dist: <http://purl.org/NET/cpan-uri/dist/Module-Install-DOAP/> .
+@prefix doap: <http://usefulinc.com/ns/doap#> .
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
 
+_:main <http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#fileName> "lib/Module/Install/DOAP.pm" .
+_:r1650023872r0 dcs:item [
+		a dcs:Packaging ;
+		rdfs:label "Upgrade Module::Package::RDF version."@en
+	] ;
+	dcs:versus dist:v_0-001 .
+_:r1650023872r10 a dcs:Bugfix, dcs:Packaging ;
+	rdfs:label "Oops; hyphens." .
+_:r1650023872r11 deps:on "Module::Install 1.00"^^deps:CpanId .
+_:r1650023872r12 deps:on "Module::Install::RDF 0.004"^^deps:CpanId .
+_:r1650023872r13 deps:on "Module::Install::Admin::RDF 0.004"^^deps:CpanId .
+_:r1650023872r14 deps:on "RDF::Trine 0.133"^^deps:CpanId .
+_:r1650023872r15 deps:on "Test::More 0.96"^^deps:CpanId .
+_:r1650023872r16 doap:browse <https://github.com/tobyink/p5-module-install-doap> ;
+	a doap:GitRepository .
+_:r1650023872r17 rdfs:label "RDF" .
+_:r1650023872r18 rdfs:label "Semantic Web" .
+_:r1650023872r19 rdfs:label "CPAN" .
+_:r1650023872r2 dcs:item [
+		rdfs:label "Use Module::Install::RDF's new heuristics for detecting the doap:Project URI."@en
+	], [
+		a dcs:Regression ;
+		rdfs:label "use parent"
+	] ;
+	dcs:versus dist:v_0-002 .
+_:r1650023872r20 rdfs:label "DOAP" .
+_:r1650023872r21 rdfs:label "Metadata" .
+_:r1650023872r22 rdfs:label "Packaging" .
+_:r1650023872r5 dcs:item [
+		a dcs:Bugfix ;
+		rdfs:label "use base"
+	] ;
+	dcs:versus dist:v_0-003 .
+_:r1650023872r7 dcs:item [
+		a dcs:Update ;
+		rdfs:label "Support http://ontologi.es/doap-deps, and deprecate old dependency predicates."
+	] ;
+	dcs:versus dist:v_0-004 .
+_:r1650023872r9 dcs:item _:r1650023872r10 ;
+	dcs:versus dist:v_0-005 .
+dist:project deps:runtime-requirement _:r1650023872r11, _:r1650023872r12, _:r1650023872r13, _:r1650023872r14 ;
+	deps:test-requirement _:r1650023872r15 ;
+	cpant:perl_version_from _:main ;
+	cpant:readme_from _:main ;
+	cpant:version_from _:main ;
+	doap:bug-database <http://rt.cpan.org/Dist/Display.html?Queue=Module-Install-DOAP> ;
+	doap:category _:r1650023872r17, _:r1650023872r18, _:r1650023872r19, _:r1650023872r20, _:r1650023872r21, _:r1650023872r22 ;
+	doap:created "2011-09-30"^^<http://www.w3.org/2001/XMLSchema#date> ;
+	doap:developer <http://tobyinkster.co.uk/#i> ;
+	doap:documenter <http://tobyinkster.co.uk/#i> ;
+	doap:download-page <https://metacpan.org/release/Module-Install-DOAP> ;
+	doap:homepage <https://metacpan.org/release/Module-Install-DOAP> ;
+	doap:license <http://dev.perl.org/licenses/> ;
+	doap:maintainer <http://tobyinkster.co.uk/#i> ;
+	doap:name "Module-Install-DOAP" ;
+	doap:programming-language "Perl" ;
+	doap:release dist:v_0-001, dist:v_0-002, dist:v_0-003, dist:v_0-004, dist:v_0-005, dist:v_0-006 ;
+	doap:repository _:r1650023872r16 ;
+	doap:shortdesc "generate META.yml data from DOAP"@en ;
+	doap:tester <http://tobyinkster.co.uk/#i> ;
+	a doap:Project .
+dist:v_0-001 <http://purl.org/dc/terms/issued> "2011-10-01"^^<http://www.w3.org/2001/XMLSchema#date> ;
+	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.001.tar.gz> ;
+	doap:revision "0.001"^^<http://www.w3.org/2001/XMLSchema#string> ;
+	a doap:Version ;
+	rdfs:label "Initial release" .
+dist:v_0-002 dcs:changeset _:r1650023872r0 ;
+	<http://purl.org/dc/terms/issued> "2011-10-06"^^<http://www.w3.org/2001/XMLSchema#date> ;
+	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.002.tar.gz> ;
+	doap:revision "0.002"^^<http://www.w3.org/2001/XMLSchema#string> ;
+	a doap:Version .
+dist:v_0-003 dcs:changeset _:r1650023872r2 ;
+	<http://purl.org/dc/terms/issued> "2011-11-26"^^<http://www.w3.org/2001/XMLSchema#date> ;
+	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.003.tar.gz> ;
+	doap:revision "0.003"^^<http://www.w3.org/2001/XMLSchema#string> ;
+	a doap:Version .
+dist:v_0-004 dcs:changeset _:r1650023872r5 ;
+	<http://purl.org/dc/terms/issued> "2011-12-03"^^<http://www.w3.org/2001/XMLSchema#date> ;
+	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.004.tar.gz> ;
+	doap:revision "0.004"^^<http://www.w3.org/2001/XMLSchema#string> ;
+	a doap:Version .
+dist:v_0-005 dcs:changeset _:r1650023872r7 ;
+	<http://purl.org/dc/terms/issued> "2013-07-31"^^<http://www.w3.org/2001/XMLSchema#date> ;
+	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.005.tar.gz> ;
+	doap:revision "0.005"^^<http://www.w3.org/2001/XMLSchema#string> ;
+	a doap:Version .
+dist:v_0-006 dcs:changeset _:r1650023872r9 ;
+	<http://purl.org/dc/terms/issued> "2013-07-31"^^<http://www.w3.org/2001/XMLSchema#date> ;
+	doap:file-release <http://backpan.cpan.org/authors/id/T/TO/TOBYINK/Module-Install-DOAP-0.006.tar.gz> ;
+	doap:revision "0.006"^^<http://www.w3.org/2001/XMLSchema#string> ;
+	a doap:Version .
+<http://tobyinkster.co.uk/#i> a foaf:Person ;
+	<http://www.w3.org/2002/07/owl#sameAs> cpan:tobyink ;
+	foaf:homepage <http://tobyinkster.co.uk/> ;
+	foaf:mbox <mailto:tobyink@cpan.org> ;
+	foaf:name "Toby Inkster" ;
+	foaf:page <https://metacpan.org/author/TOBYINK> .
diff --git a/META.yml b/META.yml
index dfa9352..ace3cb5 100644
--- a/META.yml
+++ b/META.yml
@@ -4,12 +4,12 @@ author:
   - 'Toby Inkster <tobyink@cpan.org>'
 build_requires:
   ExtUtils::MakeMaker: 6.59
-  Test::More: 0.96
+  Test::More: '0.96'
 configure_requires:
   ExtUtils::MakeMaker: 6.59
 distribution_type: module
 dynamic_config: 0
-generated_by: 'Module::Install version 1.06'
+generated_by: 'Module::Install version 1.19'
 keywords:
   - CPAN
   - DOAP
@@ -28,14 +28,14 @@ no_index:
     - inc
     - t
 requires:
-  Module::Install: 1.00
-  Module::Install::Admin::RDF: 0.004
-  Module::Install::RDF: 0.004
-  RDF::Trine: 0.133
+  Module::Install: '1.00'
+  Module::Install::Admin::RDF: '0.004'
+  Module::Install::RDF: '0.004'
+  RDF::Trine: '0.133'
   perl: 5.8.0
 resources:
   bugtracker: http://rt.cpan.org/Dist/Display.html?Queue=Module-Install-DOAP
   homepage: https://metacpan.org/release/Module-Install-DOAP
   license: http://dev.perl.org/licenses/
   repository: https://github.com/tobyink/p5-module-install-doap
-version: 0.006
+version: '0.006'
diff --git a/Module-Install-DOAP-0.006/CREDITS b/Module-Install-DOAP-0.006/CREDITS
new file mode 100644
index 0000000..7268638
--- /dev/null
+++ b/Module-Install-DOAP-0.006/CREDITS
@@ -0,0 +1,3 @@
+Maintainer:
+- Toby Inkster <mailto:tobyink@cpan.org>
+
diff --git a/Module-Install-DOAP-0.006/Changes b/Module-Install-DOAP-0.006/Changes
new file mode 100644
index 0000000..dd13d73
--- /dev/null
+++ b/Module-Install-DOAP-0.006/Changes
@@ -0,0 +1,34 @@
+Module-Install-DOAP
+===================
+
+Created:      2011-09-30
+Home page:    <https://metacpan.org/release/Module-Install-DOAP>
+Bug tracker:  <http://rt.cpan.org/Dist/Display.html?Queue=Module-Install-DOAP>
+Maintainer:   Toby Inkster <mailto:tobyink@cpan.org>
+
+0.006  2013-07-31
+
+ - (Bugfix Packaging) Oops; hyphens.
+
+0.005  2013-07-31
+
+ - (Update) Support http://ontologi.es/doap-deps, and deprecate old
+   dependency predicates.
+
+0.004  2011-12-03
+
+ - (Bugfix) use base
+
+0.003  2011-11-26
+
+ - (Regression) use parent
+ - Use Module::Install::RDF's new heuristics for detecting the doap:Project
+   URI.
+
+0.002  2011-10-06
+
+ - (Packaging) Upgrade Module::Package::RDF version.
+
+0.001  2011-10-01  Initial release
+
+
diff --git a/Module-Install-DOAP-0.006/LICENSE b/Module-Install-DOAP-0.006/LICENSE
new file mode 100644
index 0000000..195381c
--- /dev/null
+++ b/Module-Install-DOAP-0.006/LICENSE
@@ -0,0 +1,379 @@
+This software is copyright (c) 2022 by Toby Inkster <tobyink@cpan.org>.
+
+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) 2022 by Toby Inkster <tobyink@cpan.org>.
+
+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, Fifth Floor, Boston, MA  02110-1301  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.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    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.
+
+  <signature of Ty Coon>, 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) 2022 by Toby Inkster <tobyink@cpan.org>.
+
+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
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+The End
+
diff --git a/Module-Install-DOAP-0.006/MANIFEST b/Module-Install-DOAP-0.006/MANIFEST
new file mode 100644
index 0000000..6fb49f8
--- /dev/null
+++ b/Module-Install-DOAP-0.006/MANIFEST
@@ -0,0 +1,69 @@
+Changes
+COPYRIGHT
+CREDITS
+inc/Module/AutoInstall.pm
+inc/Module/Install.pm
+inc/Module/Install/AutoInstall.pm
+inc/Module/Install/AutoManifest.pm
+inc/Module/Install/Base.pm
+inc/Module/Install/Can.pm
+inc/Module/Install/Fetch.pm
+inc/Module/Install/Include.pm
+inc/Module/Install/Makefile.pm
+inc/Module/Install/Metadata.pm
+inc/Module/Install/Package.pm
+inc/Module/Install/TrustMetaYml.pm
+inc/Module/Install/Win32.pm
+inc/Module/Install/WriteAll.pm
+inc/Module/Package.pm
+inc/Module/Package/Dist/RDF.pm
+inc/YAML/Tiny.pm
+lib/Module/Install/Admin/DOAP.pm
+lib/Module/Install/DOAP.pm
+LICENSE
+Makefile.PL
+MANIFEST			This list of files
+META.ttl
+META.yml
+meta/changes.ttl
+meta/deps.ttl
+meta/doap.ttl
+meta/makefile.ttl
+Module-Install-DOAP-0.006/Changes
+Module-Install-DOAP-0.006/COPYRIGHT
+Module-Install-DOAP-0.006/CREDITS
+Module-Install-DOAP-0.006/inc/Module/AutoInstall.pm
+Module-Install-DOAP-0.006/inc/Module/Install.pm
+Module-Install-DOAP-0.006/inc/Module/Install/AutoInstall.pm
+Module-Install-DOAP-0.006/inc/Module/Install/AutoManifest.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Base.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Can.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Fetch.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Include.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Makefile.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Metadata.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Package.pm
+Module-Install-DOAP-0.006/inc/Module/Install/TrustMetaYml.pm
+Module-Install-DOAP-0.006/inc/Module/Install/Win32.pm
+Module-Install-DOAP-0.006/inc/Module/Install/WriteAll.pm
+Module-Install-DOAP-0.006/inc/Module/Package.pm
+Module-Install-DOAP-0.006/inc/Module/Package/Dist/RDF.pm
+Module-Install-DOAP-0.006/inc/YAML/Tiny.pm
+Module-Install-DOAP-0.006/lib/Module/Install/Admin/DOAP.pm
+Module-Install-DOAP-0.006/lib/Module/Install/DOAP.pm
+Module-Install-DOAP-0.006/LICENSE
+Module-Install-DOAP-0.006/Makefile.PL
+Module-Install-DOAP-0.006/MANIFEST
+Module-Install-DOAP-0.006/META.ttl
+Module-Install-DOAP-0.006/META.yml
+Module-Install-DOAP-0.006/meta/changes.ttl
+Module-Install-DOAP-0.006/meta/deps.ttl
+Module-Install-DOAP-0.006/meta/doap.ttl
+Module-Install-DOAP-0.006/meta/makefile.ttl
+Module-Install-DOAP-0.006/README
+Module-Install-DOAP-0.006/SIGNATURE
+Module-Install-DOAP-0.006/t/01basic.t
+Module-Install-DOAP-0.006/TODO
+README
+t/01basic.t
+TODO
diff --git a/Module-Install-DOAP-0.006/META.yml b/Module-Install-DOAP-0.006/META.yml
new file mode 100644
index 0000000..ace3cb5
--- /dev/null
+++ b/Module-Install-DOAP-0.006/META.yml
@@ -0,0 +1,41 @@
+---
+abstract: 'generate META.yml data from DOAP'
+author:
+  - 'Toby Inkster <tobyink@cpan.org>'
+build_requires:
+  ExtUtils::MakeMaker: 6.59
+  Test::More: '0.96'
+configure_requires:
+  ExtUtils::MakeMaker: 6.59
+distribution_type: module
+dynamic_config: 0
+generated_by: 'Module::Install version 1.19'
+keywords:
+  - CPAN
+  - DOAP
+  - Metadata
+  - Packaging
+  - RDF
+  - 'Semantic Web'
+license: perl
+meta-spec:
+  url: http://module-build.sourceforge.net/META-spec-v1.4.html
+  version: 1.4
+module_name: Module::Install::DOAP
+name: Module-Install-DOAP
+no_index:
+  directory:
+    - inc
+    - t
+requires:
+  Module::Install: '1.00'
+  Module::Install::Admin::RDF: '0.004'
+  Module::Install::RDF: '0.004'
+  RDF::Trine: '0.133'
+  perl: 5.8.0
+resources:
+  bugtracker: http://rt.cpan.org/Dist/Display.html?Queue=Module-Install-DOAP
+  homepage: https://metacpan.org/release/Module-Install-DOAP
+  license: http://dev.perl.org/licenses/
+  repository: https://github.com/tobyink/p5-module-install-doap
+version: '0.006'
diff --git a/Module-Install-DOAP-0.006/Makefile.PL b/Module-Install-DOAP-0.006/Makefile.PL
new file mode 100644
index 0000000..e7f29c8
--- /dev/null
+++ b/Module-Install-DOAP-0.006/Makefile.PL
@@ -0,0 +1 @@
+use inc::Module::Package 'RDF:standard 0.003';
diff --git a/Module-Install-DOAP-0.006/TODO b/Module-Install-DOAP-0.006/TODO
new file mode 100644
index 0000000..db324e8
--- /dev/null
+++ b/Module-Install-DOAP-0.006/TODO
@@ -0,0 +1,2 @@
+- Document which parts of DOAP, and which extension vocabularies this module uses, and how that's mapped to META.yml, etc.
+- Look at a better way of representing dependencies.
diff --git a/Module-Install-DOAP-0.006/inc/Module/AutoInstall.pm b/Module-Install-DOAP-0.006/inc/Module/AutoInstall.pm
new file mode 100644
index 0000000..8852e0b
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/AutoInstall.pm
@@ -0,0 +1,934 @@
+#line 1
+package Module::AutoInstall;
+
+use strict;
+use Cwd                 ();
+use File::Spec          ();
+use ExtUtils::MakeMaker ();
+
+use vars qw{$VERSION};
+BEGIN {
+	$VERSION = '1.19';
+}
+
+# special map on pre-defined feature sets
+my %FeatureMap = (
+    ''      => 'Core Features',    # XXX: deprecated
+    '-core' => 'Core Features',
+);
+
+# various lexical flags
+my ( @Missing, @Existing,  %DisabledTests, $UnderCPAN, $InstallDepsTarget, $HasCPANPLUS );
+my (
+    $Config, $CheckOnly, $SkipInstall, $AcceptDefault, $TestOnly, $AllDeps,
+    $UpgradeDeps
+);
+my ( $PostambleActions, $PostambleActionsNoTest, $PostambleActionsUpgradeDeps,
+    $PostambleActionsUpgradeDepsNoTest, $PostambleActionsListDeps,
+    $PostambleActionsListAllDeps, $PostambleUsed, $NoTest);
+
+# See if it's a testing or non-interactive session
+_accept_default( $ENV{AUTOMATED_TESTING} or ! -t STDIN ); 
+_init();
+
+sub _accept_default {
+    $AcceptDefault = shift;
+}
+
+sub _installdeps_target {
+    $InstallDepsTarget = shift;
+}
+
+sub missing_modules {
+    return @Missing;
+}
+
+sub do_install {
+    __PACKAGE__->install(
+        [
+            $Config
+            ? ( UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} )
+            : ()
+        ],
+        @Missing,
+    );
+}
+
+# initialize various flags, and/or perform install
+sub _init {
+    foreach my $arg (
+        @ARGV,
+        split(
+            /[\s\t]+/,
+            $ENV{PERL_AUTOINSTALL} || $ENV{PERL_EXTUTILS_AUTOINSTALL} || ''
+        )
+      )
+    {
+        if ( $arg =~ /^--config=(.*)$/ ) {
+            $Config = [ split( ',', $1 ) ];
+        }
+        elsif ( $arg =~ /^--installdeps=(.*)$/ ) {
+            __PACKAGE__->install( $Config, @Missing = split( /,/, $1 ) );
+            exit 0;
+        }
+	elsif ( $arg =~ /^--upgradedeps=(.*)$/ ) {
+	    $UpgradeDeps = 1;
+	    __PACKAGE__->install( $Config, @Missing = split( /,/, $1 ) );
+	    exit 0;
+	}
+        elsif ( $arg =~ /^--default(?:deps)?$/ ) {
+            $AcceptDefault = 1;
+        }
+        elsif ( $arg =~ /^--check(?:deps)?$/ ) {
+            $CheckOnly = 1;
+        }
+        elsif ( $arg =~ /^--skip(?:deps)?$/ ) {
+            $SkipInstall = 1;
+        }
+        elsif ( $arg =~ /^--test(?:only)?$/ ) {
+            $TestOnly = 1;
+        }
+        elsif ( $arg =~ /^--all(?:deps)?$/ ) {
+            $AllDeps = 1;
+        }
+    }
+}
+
+# overrides MakeMaker's prompt() to automatically accept the default choice
+sub _prompt {
+    goto &ExtUtils::MakeMaker::prompt unless $AcceptDefault;
+
+    my ( $prompt, $default ) = @_;
+    my $y = ( $default =~ /^[Yy]/ );
+
+    print $prompt, ' [', ( $y ? 'Y' : 'y' ), '/', ( $y ? 'n' : 'N' ), '] ';
+    print "$default\n";
+    return $default;
+}
+
+# the workhorse
+sub import {
+    my $class = shift;
+    my @args  = @_ or return;
+    my $core_all;
+
+    print "*** $class version " . $class->VERSION . "\n";
+    print "*** Checking for Perl dependencies...\n";
+
+    my $cwd = Cwd::getcwd();
+
+    $Config = [];
+
+    my $maxlen = length(
+        (
+            sort   { length($b) <=> length($a) }
+              grep { /^[^\-]/ }
+              map  {
+                ref($_)
+                  ? ( ( ref($_) eq 'HASH' ) ? keys(%$_) : @{$_} )
+                  : ''
+              }
+              map { +{@args}->{$_} }
+              grep { /^[^\-]/ or /^-core$/i } keys %{ +{@args} }
+        )[0]
+    );
+
+    # We want to know if we're under CPAN early to avoid prompting, but
+    # if we aren't going to try and install anything anyway then skip the
+    # check entirely since we don't want to have to load (and configure)
+    # an old CPAN just for a cosmetic message
+
+    $UnderCPAN = _check_lock(1) unless $SkipInstall || $InstallDepsTarget;
+
+    while ( my ( $feature, $modules ) = splice( @args, 0, 2 ) ) {
+        my ( @required, @tests, @skiptests );
+        my $default  = 1;
+        my $conflict = 0;
+
+        if ( $feature =~ m/^-(\w+)$/ ) {
+            my $option = lc($1);
+
+            # check for a newer version of myself
+            _update_to( $modules, @_ ) and return if $option eq 'version';
+
+            # sets CPAN configuration options
+            $Config = $modules if $option eq 'config';
+
+            # promote every features to core status
+            $core_all = ( $modules =~ /^all$/i ) and next
+              if $option eq 'core';
+
+            next unless $option eq 'core';
+        }
+
+        print "[" . ( $FeatureMap{ lc($feature) } || $feature ) . "]\n";
+
+        $modules = [ %{$modules} ] if UNIVERSAL::isa( $modules, 'HASH' );
+
+        unshift @$modules, -default => &{ shift(@$modules) }
+          if ( ref( $modules->[0] ) eq 'CODE' );    # XXX: bugward compatibility
+
+        while ( my ( $mod, $arg ) = splice( @$modules, 0, 2 ) ) {
+            if ( $mod =~ m/^-(\w+)$/ ) {
+                my $option = lc($1);
+
+                $default   = $arg    if ( $option eq 'default' );
+                $conflict  = $arg    if ( $option eq 'conflict' );
+                @tests     = @{$arg} if ( $option eq 'tests' );
+                @skiptests = @{$arg} if ( $option eq 'skiptests' );
+
+                next;
+            }
+
+            printf( "- %-${maxlen}s ...", $mod );
+
+            if ( $arg and $arg =~ /^\D/ ) {
+                unshift @$modules, $arg;
+                $arg = 0;
+            }
+
+            # XXX: check for conflicts and uninstalls(!) them.
+            my $cur = _version_of($mod);
+            if (_version_cmp ($cur, $arg) >= 0)
+            {
+                print "loaded. ($cur" . ( $arg ? " >= $arg" : '' ) . ")\n";
+                push @Existing, $mod => $arg;
+                $DisabledTests{$_} = 1 for map { glob($_) } @skiptests;
+            }
+            else {
+                if (not defined $cur)   # indeed missing
+                {
+                    print "missing." . ( $arg ? " (would need $arg)" : '' ) . "\n";
+                }
+                else
+                {
+                    # no need to check $arg as _version_cmp ($cur, undef) would satisfy >= above
+                    print "too old. ($cur < $arg)\n";
+                }
+
+                push @required, $mod => $arg;
+            }
+        }
+
+        next unless @required;
+
+        my $mandatory = ( $feature eq '-core' or $core_all );
+
+        if (
+            !$SkipInstall
+            and (
+                $CheckOnly
+                or ($mandatory and $UnderCPAN)
+                or $AllDeps
+                or $InstallDepsTarget
+                or _prompt(
+                    qq{==> Auto-install the }
+                      . ( @required / 2 )
+                      . ( $mandatory ? ' mandatory' : ' optional' )
+                      . qq{ module(s) from CPAN?},
+                    $default ? 'y' : 'n',
+                ) =~ /^[Yy]/
+            )
+          )
+        {
+            push( @Missing, @required );
+            $DisabledTests{$_} = 1 for map { glob($_) } @skiptests;
+        }
+
+        elsif ( !$SkipInstall
+            and $default
+            and $mandatory
+            and
+            _prompt( qq{==> The module(s) are mandatory! Really skip?}, 'n', )
+            =~ /^[Nn]/ )
+        {
+            push( @Missing, @required );
+            $DisabledTests{$_} = 1 for map { glob($_) } @skiptests;
+        }
+
+        else {
+            $DisabledTests{$_} = 1 for map { glob($_) } @tests;
+        }
+    }
+
+    if ( @Missing and not( $CheckOnly or $UnderCPAN) ) {
+        require Config;
+        my $make = $Config::Config{make};
+        if ($InstallDepsTarget) {
+            print
+"*** To install dependencies type '$make installdeps' or '$make installdeps_notest'.\n";
+        }
+        else {
+            print
+"*** Dependencies will be installed the next time you type '$make'.\n";
+        }
+
+        # make an educated guess of whether we'll need root permission.
+        print "    (You may need to do that as the 'root' user.)\n"
+          if eval '$>';
+    }
+    print "*** $class configuration finished.\n";
+
+    chdir $cwd;
+
+    # import to main::
+    no strict 'refs';
+    *{'main::WriteMakefile'} = \&Write if caller(0) eq 'main';
+
+    return (@Existing, @Missing);
+}
+
+sub _running_under {
+    my $thing = shift;
+    print <<"END_MESSAGE";
+*** Since we're running under ${thing}, I'll just let it take care
+    of the dependency's installation later.
+END_MESSAGE
+    return 1;
+}
+
+# Check to see if we are currently running under CPAN.pm and/or CPANPLUS;
+# if we are, then we simply let it taking care of our dependencies
+sub _check_lock {
+    return unless @Missing or @_;
+
+    if ($ENV{PERL5_CPANM_IS_RUNNING}) {
+        return _running_under('cpanminus');
+    }
+
+    my $cpan_env = $ENV{PERL5_CPAN_IS_RUNNING};
+
+    if ($ENV{PERL5_CPANPLUS_IS_RUNNING}) {
+        return _running_under($cpan_env ? 'CPAN' : 'CPANPLUS');
+    }
+
+    require CPAN;
+
+    if ($CPAN::VERSION > '1.89') {
+        if ($cpan_env) {
+            return _running_under('CPAN');
+        }
+        return; # CPAN.pm new enough, don't need to check further
+    }
+
+    # last ditch attempt, this -will- configure CPAN, very sorry
+
+    _load_cpan(1); # force initialize even though it's already loaded
+
+    # Find the CPAN lock-file
+    my $lock = MM->catfile( $CPAN::Config->{cpan_home}, ".lock" );
+    return unless -f $lock;
+
+    # Check the lock
+    local *LOCK;
+    return unless open(LOCK, $lock);
+
+    if (
+            ( $^O eq 'MSWin32' ? _under_cpan() : <LOCK> == getppid() )
+        and ( $CPAN::Config->{prerequisites_policy} || '' ) ne 'ignore'
+    ) {
+        print <<'END_MESSAGE';
+
+*** Since we're running under CPAN, I'll just let it take care
+    of the dependency's installation later.
+END_MESSAGE
+        return 1;
+    }
+
+    close LOCK;
+    return;
+}
+
+sub install {
+    my $class = shift;
+
+    my $i;    # used below to strip leading '-' from config keys
+    my @config = ( map { s/^-// if ++$i; $_ } @{ +shift } );
+
+	my ( @modules, @installed, @modules_to_upgrade );
+	while (my ($pkg, $ver) = splice(@_, 0, 2)) {
+
+		# grep out those already installed
+		if (_version_cmp(_version_of($pkg), $ver) >= 0) {
+			push @installed, $pkg;
+			if ($UpgradeDeps) {
+				push @modules_to_upgrade, $pkg, $ver;
+			}
+		}
+		else {
+			push @modules, $pkg, $ver;
+		}
+	}
+
+	if ($UpgradeDeps) {
+		push @modules, @modules_to_upgrade;
+		@installed          = ();
+		@modules_to_upgrade = ();
+	}
+
+    return @installed unless @modules;  # nothing to do
+    return @installed if _check_lock(); # defer to the CPAN shell
+
+    print "*** Installing dependencies...\n";
+
+    return unless _connected_to('cpan.org');
+
+    my %args = @config;
+    my %failed;
+    local *FAILED;
+    if ( $args{do_once} and open( FAILED, '.#autoinstall.failed' ) ) {
+        while (<FAILED>) { chomp; $failed{$_}++ }
+        close FAILED;
+
+        my @newmod;
+        while ( my ( $k, $v ) = splice( @modules, 0, 2 ) ) {
+            push @newmod, ( $k => $v ) unless $failed{$k};
+        }
+        @modules = @newmod;
+    }
+
+    if ( _has_cpanplus() and not $ENV{PERL_AUTOINSTALL_PREFER_CPAN} ) {
+        _install_cpanplus( \@modules, \@config );
+    } else {
+        _install_cpan( \@modules, \@config );
+    }
+
+    print "*** $class installation finished.\n";
+
+    # see if we have successfully installed them
+    while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) {
+        if ( _version_cmp( _version_of($pkg), $ver ) >= 0 ) {
+            push @installed, $pkg;
+        }
+        elsif ( $args{do_once} and open( FAILED, '>> .#autoinstall.failed' ) ) {
+            print FAILED "$pkg\n";
+        }
+    }
+
+    close FAILED if $args{do_once};
+
+    return @installed;
+}
+
+sub _install_cpanplus {
+    my @modules   = @{ +shift };
+    my @config    = _cpanplus_config( @{ +shift } );
+    my $installed = 0;
+
+    require CPANPLUS::Backend;
+    my $cp   = CPANPLUS::Backend->new;
+    my $conf = $cp->configure_object;
+
+    return unless $conf->can('conf') # 0.05x+ with "sudo" support
+               or _can_write($conf->_get_build('base'));  # 0.04x
+
+    # if we're root, set UNINST=1 to avoid trouble unless user asked for it.
+    my $makeflags = $conf->get_conf('makeflags') || '';
+    if ( UNIVERSAL::isa( $makeflags, 'HASH' ) ) {
+        # 0.03+ uses a hashref here
+        $makeflags->{UNINST} = 1 unless exists $makeflags->{UNINST};
+
+    } else {
+        # 0.02 and below uses a scalar
+        $makeflags = join( ' ', split( ' ', $makeflags ), 'UNINST=1' )
+          if ( $makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' } );
+
+    }
+    $conf->set_conf( makeflags => $makeflags );
+    $conf->set_conf( prereqs   => 1 );
+
+    
+
+    while ( my ( $key, $val ) = splice( @config, 0, 2 ) ) {
+        $conf->set_conf( $key, $val );
+    }
+
+    my $modtree = $cp->module_tree;
+    while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) {
+        print "*** Installing $pkg...\n";
+
+        MY::preinstall( $pkg, $ver ) or next if defined &MY::preinstall;
+
+        my $success;
+        my $obj = $modtree->{$pkg};
+
+        if ( $obj and _version_cmp( $obj->{version}, $ver ) >= 0 ) {
+            my $pathname = $pkg;
+            $pathname =~ s/::/\\W/;
+
+            foreach my $inc ( grep { m/$pathname.pm/i } keys(%INC) ) {
+                delete $INC{$inc};
+            }
+
+            my $rv = $cp->install( modules => [ $obj->{module} ] );
+
+            if ( $rv and ( $rv->{ $obj->{module} } or $rv->{ok} ) ) {
+                print "*** $pkg successfully installed.\n";
+                $success = 1;
+            } else {
+                print "*** $pkg installation cancelled.\n";
+                $success = 0;
+            }
+
+            $installed += $success;
+        } else {
+            print << ".";
+*** Could not find a version $ver or above for $pkg; skipping.
+.
+        }
+
+        MY::postinstall( $pkg, $ver, $success ) if defined &MY::postinstall;
+    }
+
+    return $installed;
+}
+
+sub _cpanplus_config {
+	my @config = ();
+	while ( @_ ) {
+		my ($key, $value) = (shift(), shift());
+		if ( $key eq 'prerequisites_policy' ) {
+			if ( $value eq 'follow' ) {
+				$value = CPANPLUS::Internals::Constants::PREREQ_INSTALL();
+			} elsif ( $value eq 'ask' ) {
+				$value = CPANPLUS::Internals::Constants::PREREQ_ASK();
+			} elsif ( $value eq 'ignore' ) {
+				$value = CPANPLUS::Internals::Constants::PREREQ_IGNORE();
+			} else {
+				die "*** Cannot convert option $key = '$value' to CPANPLUS version.\n";
+			}
+			push @config, 'prereqs', $value;
+		} elsif ( $key eq 'force' ) {
+		    push @config, $key, $value;
+		} elsif ( $key eq 'notest' ) {
+		    push @config, 'skiptest', $value;
+		} else {
+			die "*** Cannot convert option $key to CPANPLUS version.\n";
+		}
+	}
+	return @config;
+}
+
+sub _install_cpan {
+    my @modules   = @{ +shift };
+    my @config    = @{ +shift };
+    my $installed = 0;
+    my %args;
+
+    _load_cpan();
+    require Config;
+
+    if (CPAN->VERSION < 1.80) {
+        # no "sudo" support, probe for writableness
+        return unless _can_write( MM->catfile( $CPAN::Config->{cpan_home}, 'sources' ) )
+                  and _can_write( $Config::Config{sitelib} );
+    }
+
+    # if we're root, set UNINST=1 to avoid trouble unless user asked for it.
+    my $makeflags = $CPAN::Config->{make_install_arg} || '';
+    $CPAN::Config->{make_install_arg} =
+      join( ' ', split( ' ', $makeflags ), 'UNINST=1' )
+      if ( $makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' } );
+
+    # don't show start-up info
+    $CPAN::Config->{inhibit_startup_message} = 1;
+
+    # set additional options
+    while ( my ( $opt, $arg ) = splice( @config, 0, 2 ) ) {
+        ( $args{$opt} = $arg, next )
+          if $opt =~ /^(?:force|notest)$/;    # pseudo-option
+        $CPAN::Config->{$opt} = $opt eq 'urllist' ? [$arg] : $arg;
+    }
+
+    if ($args{notest} && (not CPAN::Shell->can('notest'))) {
+	die "Your version of CPAN is too old to support the 'notest' pragma";
+    }
+
+    local $CPAN::Config->{prerequisites_policy} = 'follow';
+
+    while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) {
+        MY::preinstall( $pkg, $ver ) or next if defined &MY::preinstall;
+
+        print "*** Installing $pkg...\n";
+
+        my $obj     = CPAN::Shell->expand( Module => $pkg );
+        my $success = 0;
+
+        if ( $obj and _version_cmp( $obj->cpan_version, $ver ) >= 0 ) {
+            my $pathname = $pkg;
+            $pathname =~ s/::/\\W/;
+
+            foreach my $inc ( grep { m/$pathname.pm/i } keys(%INC) ) {
+                delete $INC{$inc};
+            }
+
+            my $rv = do {
+		if ($args{force}) {
+		    CPAN::Shell->force( install => $pkg )
+		} elsif ($args{notest}) {
+		    CPAN::Shell->notest( install => $pkg )
+		} else {
+		    CPAN::Shell->install($pkg)
+		}
+	    };
+
+            $rv ||= eval {
+                $CPAN::META->instance( 'CPAN::Distribution', $obj->cpan_file, )
+                  ->{install}
+                  if $CPAN::META;
+            };
+
+            if ( $rv eq 'YES' ) {
+                print "*** $pkg successfully installed.\n";
+                $success = 1;
+            }
+            else {
+                print "*** $pkg installation failed.\n";
+                $success = 0;
+            }
+
+            $installed += $success;
+        }
+        else {
+            print << ".";
+*** Could not find a version $ver or above for $pkg; skipping.
+.
+        }
+
+        MY::postinstall( $pkg, $ver, $success ) if defined &MY::postinstall;
+    }
+
+    return $installed;
+}
+
+sub _has_cpanplus {
+    return (
+        $HasCPANPLUS = (
+            $INC{'CPANPLUS/Config.pm'}
+              or _load('CPANPLUS::Shell::Default')
+        )
+    );
+}
+
+# make guesses on whether we're under the CPAN installation directory
+sub _under_cpan {
+    require Cwd;
+    require File::Spec;
+
+    my $cwd  = File::Spec->canonpath( Cwd::getcwd() );
+    my $cpan = File::Spec->canonpath( $CPAN::Config->{cpan_home} );
+
+    return ( index( $cwd, $cpan ) > -1 );
+}
+
+sub _update_to {
+    my $class = __PACKAGE__;
+    my $ver   = shift;
+
+    return
+      if _version_cmp( _version_of($class), $ver ) >= 0;  # no need to upgrade
+
+    if (
+        _prompt( "==> A newer version of $class ($ver) is required. Install?",
+            'y' ) =~ /^[Nn]/
+      )
+    {
+        die "*** Please install $class $ver manually.\n";
+    }
+
+    print << ".";
+*** Trying to fetch it from CPAN...
+.
+
+    # install ourselves
+    _load($class) and return $class->import(@_)
+      if $class->install( [], $class, $ver );
+
+    print << '.'; exit 1;
+
+*** Cannot bootstrap myself. :-( Installation terminated.
+.
+}
+
+# check if we're connected to some host, using inet_aton
+sub _connected_to {
+    my $site = shift;
+
+    return (
+        ( _load('Socket') and Socket::inet_aton($site) ) or _prompt(
+            qq(
+*** Your host cannot resolve the domain name '$site', which
+    probably means the Internet connections are unavailable.
+==> Should we try to install the required module(s) anyway?), 'n'
+          ) =~ /^[Yy]/
+    );
+}
+
+# check if a directory is writable; may create it on demand
+sub _can_write {
+    my $path = shift;
+    mkdir( $path, 0755 ) unless -e $path;
+
+    return 1 if -w $path;
+
+    print << ".";
+*** You are not allowed to write to the directory '$path';
+    the installation may fail due to insufficient permissions.
+.
+
+    if (
+        eval '$>' and lc(`sudo -V`) =~ /version/ and _prompt(
+            qq(
+==> Should we try to re-execute the autoinstall process with 'sudo'?),
+            ((-t STDIN) ? 'y' : 'n')
+        ) =~ /^[Yy]/
+      )
+    {
+
+        # try to bootstrap ourselves from sudo
+        print << ".";
+*** Trying to re-execute the autoinstall process with 'sudo'...
+.
+        my $missing = join( ',', @Missing );
+        my $config = join( ',',
+            UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} )
+          if $Config;
+
+        return
+          unless system( 'sudo', $^X, $0, "--config=$config",
+            "--installdeps=$missing" );
+
+        print << ".";
+*** The 'sudo' command exited with error!  Resuming...
+.
+    }
+
+    return _prompt(
+        qq(
+==> Should we try to install the required module(s) anyway?), 'n'
+    ) =~ /^[Yy]/;
+}
+
+# load a module and return the version it reports
+sub _load {
+    my $mod  = pop; # method/function doesn't matter
+    my $file = $mod;
+    $file =~ s|::|/|g;
+    $file .= '.pm';
+    local $@;
+    return eval { require $file; $mod->VERSION } || ( $@ ? undef: 0 );
+}
+
+# report version without loading a module
+sub _version_of {
+    my $mod = pop; # method/function doesn't matter
+    my $file = $mod;
+    $file =~ s|::|/|g;
+    $file .= '.pm';
+    foreach my $dir ( @INC ) {
+        next if ref $dir;
+        my $path = File::Spec->catfile($dir, $file);
+        next unless -e $path;
+        require ExtUtils::MM_Unix;
+        return ExtUtils::MM_Unix->parse_version($path);
+    }
+    return undef;
+}
+
+# Load CPAN.pm and it's configuration
+sub _load_cpan {
+    return if $CPAN::VERSION and $CPAN::Config and not @_;
+    require CPAN;
+
+    # CPAN-1.82+ adds CPAN::Config::AUTOLOAD to redirect to
+    #    CPAN::HandleConfig->load. CPAN reports that the redirection
+    #    is deprecated in a warning printed at the user.
+
+    # CPAN-1.81 expects CPAN::HandleConfig->load, does not have
+    #   $CPAN::HandleConfig::VERSION but cannot handle
+    #   CPAN::Config->load
+
+    # Which "versions expect CPAN::Config->load?
+
+    if ( $CPAN::HandleConfig::VERSION
+        || CPAN::HandleConfig->can('load')
+    ) {
+        # Newer versions of CPAN have a HandleConfig module
+        CPAN::HandleConfig->load;
+    } else {
+    	# Older versions had the load method in Config directly
+        CPAN::Config->load;
+    }
+}
+
+# compare two versions, either use Sort::Versions or plain comparison
+# return values same as <=>
+sub _version_cmp {
+    my ( $cur, $min ) = @_;
+    return -1 unless defined $cur;  # if 0 keep comparing
+    return 1 unless $min;
+
+    $cur =~ s/\s+$//;
+
+    # check for version numbers that are not in decimal format
+    if ( ref($cur) or ref($min) or $cur =~ /v|\..*\./ or $min =~ /v|\..*\./ ) {
+        if ( ( $version::VERSION or defined( _load('version') )) and
+             version->can('new') 
+            ) {
+
+            # use version.pm if it is installed.
+            return version->new($cur) <=> version->new($min);
+        }
+        elsif ( $Sort::Versions::VERSION or defined( _load('Sort::Versions') ) )
+        {
+
+            # use Sort::Versions as the sorting algorithm for a.b.c versions
+            return Sort::Versions::versioncmp( $cur, $min );
+        }
+
+        warn "Cannot reliably compare non-decimal formatted versions.\n"
+          . "Please install version.pm or Sort::Versions.\n";
+    }
+
+    # plain comparison
+    local $^W = 0;    # shuts off 'not numeric' bugs
+    return $cur <=> $min;
+}
+
+# nothing; this usage is deprecated.
+sub main::PREREQ_PM { return {}; }
+
+sub _make_args {
+    my %args = @_;
+
+    $args{PREREQ_PM} = { %{ $args{PREREQ_PM} || {} }, @Existing, @Missing }
+      if $UnderCPAN or $TestOnly;
+
+    if ( $args{EXE_FILES} and -e 'MANIFEST' ) {
+        require ExtUtils::Manifest;
+        my $manifest = ExtUtils::Manifest::maniread('MANIFEST');
+
+        $args{EXE_FILES} =
+          [ grep { exists $manifest->{$_} } @{ $args{EXE_FILES} } ];
+    }
+
+    $args{test}{TESTS} ||= 't/*.t';
+    $args{test}{TESTS} = join( ' ',
+        grep { !exists( $DisabledTests{$_} ) }
+          map { glob($_) } split( /\s+/, $args{test}{TESTS} ) );
+
+    my $missing = join( ',', @Missing );
+    my $config =
+      join( ',', UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} )
+      if $Config;
+
+    $PostambleActions = (
+        ($missing and not $UnderCPAN)
+        ? "\$(PERL) $0 --config=$config --installdeps=$missing"
+        : "\$(NOECHO) \$(NOOP)"
+    );
+
+    my $deps_list = join( ',', @Missing, @Existing );
+
+    $PostambleActionsUpgradeDeps =
+        "\$(PERL) $0 --config=$config --upgradedeps=$deps_list";
+
+    my $config_notest =
+      join( ',', (UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config}),
+	  'notest', 1 )
+      if $Config;
+
+    $PostambleActionsNoTest = (
+        ($missing and not $UnderCPAN)
+        ? "\$(PERL) $0 --config=$config_notest --installdeps=$missing"
+        : "\$(NOECHO) \$(NOOP)"
+    );
+
+    $PostambleActionsUpgradeDepsNoTest =
+        "\$(PERL) $0 --config=$config_notest --upgradedeps=$deps_list";
+
+    $PostambleActionsListDeps =
+        '@$(PERL) -le "print for @ARGV" '
+            . join(' ', map $Missing[$_], grep $_ % 2 == 0, 0..$#Missing);
+
+    my @all = (@Missing, @Existing);
+
+    $PostambleActionsListAllDeps =
+        '@$(PERL) -le "print for @ARGV" '
+            . join(' ', map $all[$_], grep $_ % 2 == 0, 0..$#all);
+
+    return %args;
+}
+
+# a wrapper to ExtUtils::MakeMaker::WriteMakefile
+sub Write {
+    require Carp;
+    Carp::croak "WriteMakefile: Need even number of args" if @_ % 2;
+
+    if ($CheckOnly) {
+        print << ".";
+*** Makefile not written in check-only mode.
+.
+        return;
+    }
+
+    my %args = _make_args(@_);
+
+    no strict 'refs';
+
+    $PostambleUsed = 0;
+    local *MY::postamble = \&postamble unless defined &MY::postamble;
+    ExtUtils::MakeMaker::WriteMakefile(%args);
+
+    print << "." unless $PostambleUsed;
+*** WARNING: Makefile written with customized MY::postamble() without
+    including contents from Module::AutoInstall::postamble() --
+    auto installation features disabled.  Please contact the author.
+.
+
+    return 1;
+}
+
+sub postamble {
+    $PostambleUsed = 1;
+    my $fragment;
+
+    $fragment .= <<"AUTO_INSTALL" if !$InstallDepsTarget;
+
+config :: installdeps
+\t\$(NOECHO) \$(NOOP)
+AUTO_INSTALL
+
+    $fragment .= <<"END_MAKE";
+
+checkdeps ::
+\t\$(PERL) $0 --checkdeps
+
+installdeps ::
+\t$PostambleActions
+
+installdeps_notest ::
+\t$PostambleActionsNoTest
+
+upgradedeps ::
+\t$PostambleActionsUpgradeDeps
+
+upgradedeps_notest ::
+\t$PostambleActionsUpgradeDepsNoTest
+
+listdeps ::
+\t$PostambleActionsListDeps
+
+listalldeps ::
+\t$PostambleActionsListAllDeps
+
+END_MAKE
+
+    return $fragment;
+}
+
+1;
+
+__END__
+
+#line 1197
diff --git a/Module-Install-DOAP-0.006/inc/Module/Install.pm b/Module-Install-DOAP-0.006/inc/Module/Install.pm
new file mode 100644
index 0000000..7ba98c2
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Install.pm
@@ -0,0 +1,451 @@
+#line 1
+package Module::Install;
+
+# For any maintainers:
+# The load order for Module::Install is a bit magic.
+# It goes something like this...
+#
+# IF ( host has Module::Install installed, creating author mode ) {
+#     1. Makefile.PL calls "use inc::Module::Install"
+#     2. $INC{inc/Module/Install.pm} set to installed version of inc::Module::Install
+#     3. The installed version of inc::Module::Install loads
+#     4. inc::Module::Install calls "require Module::Install"
+#     5. The ./inc/ version of Module::Install loads
+# } ELSE {
+#     1. Makefile.PL calls "use inc::Module::Install"
+#     2. $INC{inc/Module/Install.pm} set to ./inc/ version of Module::Install
+#     3. The ./inc/ version of Module::Install loads
+# }
+
+use 5.006;
+use strict 'vars';
+use Cwd        ();
+use File::Find ();
+use File::Path ();
+
+use vars qw{$VERSION $MAIN};
+BEGIN {
+	# All Module::Install core packages now require synchronised versions.
+	# This will be used to ensure we don't accidentally load old or
+	# different versions of modules.
+	# This is not enforced yet, but will be some time in the next few
+	# releases once we can make sure it won't clash with custom
+	# Module::Install extensions.
+	$VERSION = '1.19';
+
+	# Storage for the pseudo-singleton
+	$MAIN    = undef;
+
+	*inc::Module::Install::VERSION = *VERSION;
+	@inc::Module::Install::ISA     = __PACKAGE__;
+
+}
+
+sub import {
+	my $class = shift;
+	my $self  = $class->new(@_);
+	my $who   = $self->_caller;
+
+	#-------------------------------------------------------------
+	# all of the following checks should be included in import(),
+	# to allow "eval 'require Module::Install; 1' to test
+	# installation of Module::Install. (RT #51267)
+	#-------------------------------------------------------------
+
+	# Whether or not inc::Module::Install is actually loaded, the
+	# $INC{inc/Module/Install.pm} is what will still get set as long as
+	# the caller loaded module this in the documented manner.
+	# If not set, the caller may NOT have loaded the bundled version, and thus
+	# they may not have a MI version that works with the Makefile.PL. This would
+	# result in false errors or unexpected behaviour. And we don't want that.
+	my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm';
+	unless ( $INC{$file} ) { die <<"END_DIE" }
+
+Please invoke ${\__PACKAGE__} with:
+
+	use inc::${\__PACKAGE__};
+
+not:
+
+	use ${\__PACKAGE__};
+
+END_DIE
+
+	# This reportedly fixes a rare Win32 UTC file time issue, but
+	# as this is a non-cross-platform XS module not in the core,
+	# we shouldn't really depend on it. See RT #24194 for detail.
+	# (Also, this module only supports Perl 5.6 and above).
+	eval "use Win32::UTCFileTime" if $^O eq 'MSWin32' && $] >= 5.006;
+
+	# If the script that is loading Module::Install is from the future,
+	# then make will detect this and cause it to re-run over and over
+	# again. This is bad. Rather than taking action to touch it (which
+	# is unreliable on some platforms and requires write permissions)
+	# for now we should catch this and refuse to run.
+	if ( -f $0 ) {
+		my $s = (stat($0))[9];
+
+		# If the modification time is only slightly in the future,
+		# sleep briefly to remove the problem.
+		my $a = $s - time;
+		if ( $a > 0 and $a < 5 ) { sleep 5 }
+
+		# Too far in the future, throw an error.
+		my $t = time;
+		if ( $s > $t ) { die <<"END_DIE" }
+
+Your installer $0 has a modification time in the future ($s > $t).
+
+This is known to create infinite loops in make.
+
+Please correct this, then run $0 again.
+
+END_DIE
+	}
+
+
+	# Build.PL was formerly supported, but no longer is due to excessive
+	# difficulty in implementing every single feature twice.
+	if ( $0 =~ /Build.PL$/i ) { die <<"END_DIE" }
+
+Module::Install no longer supports Build.PL.
+
+It was impossible to maintain duel backends, and has been deprecated.
+
+Please remove all Build.PL files and only use the Makefile.PL installer.
+
+END_DIE
+
+	#-------------------------------------------------------------
+
+	# To save some more typing in Module::Install installers, every...
+	# use inc::Module::Install
+	# ...also acts as an implicit use strict.
+	$^H |= strict::bits(qw(refs subs vars));
+
+	#-------------------------------------------------------------
+
+	unless ( -f $self->{file} ) {
+		foreach my $key (keys %INC) {
+			delete $INC{$key} if $key =~ /Module\/Install/;
+		}
+
+		local $^W;
+		require "$self->{path}/$self->{dispatch}.pm";
+		File::Path::mkpath("$self->{prefix}/$self->{author}");
+		$self->{admin} = "$self->{name}::$self->{dispatch}"->new( _top => $self );
+		$self->{admin}->init;
+		@_ = ($class, _self => $self);
+		goto &{"$self->{name}::import"};
+	}
+
+	local $^W;
+	*{"${who}::AUTOLOAD"} = $self->autoload;
+	$self->preload;
+
+	# Unregister loader and worker packages so subdirs can use them again
+	delete $INC{'inc/Module/Install.pm'};
+	delete $INC{'Module/Install.pm'};
+
+	# Save to the singleton
+	$MAIN = $self;
+
+	return 1;
+}
+
+sub autoload {
+	my $self = shift;
+	my $who  = $self->_caller;
+	my $cwd  = Cwd::getcwd();
+	my $sym  = "${who}::AUTOLOAD";
+	$sym->{$cwd} = sub {
+		my $pwd = Cwd::getcwd();
+		if ( my $code = $sym->{$pwd} ) {
+			# Delegate back to parent dirs
+			goto &$code unless $cwd eq $pwd;
+		}
+		unless ($$sym =~ s/([^:]+)$//) {
+			# XXX: it looks like we can't retrieve the missing function
+			# via $$sym (usually $main::AUTOLOAD) in this case.
+			# I'm still wondering if we should slurp Makefile.PL to
+			# get some context or not ...
+			my ($package, $file, $line) = caller;
+			die <<"EOT";
+Unknown function is found at $file line $line.
+Execution of $file aborted due to runtime errors.
+
+If you're a contributor to a project, you may need to install
+some Module::Install extensions from CPAN (or other repository).
+If you're a user of a module, please contact the author.
+EOT
+		}
+		my $method = $1;
+		if ( uc($method) eq $method ) {
+			# Do nothing
+			return;
+		} elsif ( $method =~ /^_/ and $self->can($method) ) {
+			# Dispatch to the root M:I class
+			return $self->$method(@_);
+		}
+
+		# Dispatch to the appropriate plugin
+		unshift @_, ( $self, $1 );
+		goto &{$self->can('call')};
+	};
+}
+
+sub preload {
+	my $self = shift;
+	unless ( $self->{extensions} ) {
+		$self->load_extensions(
+			"$self->{prefix}/$self->{path}", $self
+		);
+	}
+
+	my @exts = @{$self->{extensions}};
+	unless ( @exts ) {
+		@exts = $self->{admin}->load_all_extensions;
+	}
+
+	my %seen;
+	foreach my $obj ( @exts ) {
+		while (my ($method, $glob) = each %{ref($obj) . '::'}) {
+			next unless $obj->can($method);
+			next if $method =~ /^_/;
+			next if $method eq uc($method);
+			$seen{$method}++;
+		}
+	}
+
+	my $who = $self->_caller;
+	foreach my $name ( sort keys %seen ) {
+		local $^W;
+		*{"${who}::$name"} = sub {
+			${"${who}::AUTOLOAD"} = "${who}::$name";
+			goto &{"${who}::AUTOLOAD"};
+		};
+	}
+}
+
+sub new {
+	my ($class, %args) = @_;
+
+	delete $INC{'FindBin.pm'};
+	{
+		# to suppress the redefine warning
+		local $SIG{__WARN__} = sub {};
+		require FindBin;
+	}
+
+	# ignore the prefix on extension modules built from top level.
+	my $base_path = Cwd::abs_path($FindBin::Bin);
+	unless ( Cwd::abs_path(Cwd::getcwd()) eq $base_path ) {
+		delete $args{prefix};
+	}
+	return $args{_self} if $args{_self};
+
+	$base_path = VMS::Filespec::unixify($base_path) if $^O eq 'VMS';
+
+	$args{dispatch} ||= 'Admin';
+	$args{prefix}   ||= 'inc';
+	$args{author}   ||= ($^O eq 'VMS' ? '_author' : '.author');
+	$args{bundle}   ||= 'inc/BUNDLES';
+	$args{base}     ||= $base_path;
+	$class =~ s/^\Q$args{prefix}\E:://;
+	$args{name}     ||= $class;
+	$args{version}  ||= $class->VERSION;
+	unless ( $args{path} ) {
+		$args{path}  = $args{name};
+		$args{path}  =~ s!::!/!g;
+	}
+	$args{file}     ||= "$args{base}/$args{prefix}/$args{path}.pm";
+	$args{wrote}      = 0;
+
+	bless( \%args, $class );
+}
+
+sub call {
+	my ($self, $method) = @_;
+	my $obj = $self->load($method) or return;
+        splice(@_, 0, 2, $obj);
+	goto &{$obj->can($method)};
+}
+
+sub load {
+	my ($self, $method) = @_;
+
+	$self->load_extensions(
+		"$self->{prefix}/$self->{path}", $self
+	) unless $self->{extensions};
+
+	foreach my $obj (@{$self->{extensions}}) {
+		return $obj if $obj->can($method);
+	}
+
+	my $admin = $self->{admin} or die <<"END_DIE";
+The '$method' method does not exist in the '$self->{prefix}' path!
+Please remove the '$self->{prefix}' directory and run $0 again to load it.
+END_DIE
+
+	my $obj = $admin->load($method, 1);
+	push @{$self->{extensions}}, $obj;
+
+	$obj;
+}
+
+sub load_extensions {
+	my ($self, $path, $top) = @_;
+
+	my $should_reload = 0;
+	unless ( grep { ! ref $_ and lc $_ eq lc $self->{prefix} } @INC ) {
+		unshift @INC, $self->{prefix};
+		$should_reload = 1;
+	}
+
+	foreach my $rv ( $self->find_extensions($path) ) {
+		my ($file, $pkg) = @{$rv};
+		next if $self->{pathnames}{$pkg};
+
+		local $@;
+		my $new = eval { local $^W; require $file; $pkg->can('new') };
+		unless ( $new ) {
+			warn $@ if $@;
+			next;
+		}
+		$self->{pathnames}{$pkg} =
+			$should_reload ? delete $INC{$file} : $INC{$file};
+		push @{$self->{extensions}}, &{$new}($pkg, _top => $top );
+	}
+
+	$self->{extensions} ||= [];
+}
+
+sub find_extensions {
+	my ($self, $path) = @_;
+
+	my @found;
+	File::Find::find( {no_chdir => 1, wanted => sub {
+		my $file = $File::Find::name;
+		return unless $file =~ m!^\Q$path\E/(.+)\.pm\Z!is;
+		my $subpath = $1;
+		return if lc($subpath) eq lc($self->{dispatch});
+
+		$file = "$self->{path}/$subpath.pm";
+		my $pkg = "$self->{name}::$subpath";
+		$pkg =~ s!/!::!g;
+
+		# If we have a mixed-case package name, assume case has been preserved
+		# correctly.  Otherwise, root through the file to locate the case-preserved
+		# version of the package name.
+		if ( $subpath eq lc($subpath) || $subpath eq uc($subpath) ) {
+			my $content = Module::Install::_read($File::Find::name);
+			my $in_pod  = 0;
+			foreach ( split /\n/, $content ) {
+				$in_pod = 1 if /^=\w/;
+				$in_pod = 0 if /^=cut/;
+				next if ($in_pod || /^=cut/);  # skip pod text
+				next if /^\s*#/;               # and comments
+				if ( m/^\s*package\s+($pkg)\s*;/i ) {
+					$pkg = $1;
+					last;
+				}
+			}
+		}
+
+		push @found, [ $file, $pkg ];
+	}}, $path ) if -d $path;
+
+	@found;
+}
+
+
+
+
+
+#####################################################################
+# Common Utility Functions
+
+sub _caller {
+	my $depth = 0;
+	my $call  = caller($depth);
+	while ( $call eq __PACKAGE__ ) {
+		$depth++;
+		$call = caller($depth);
+	}
+	return $call;
+}
+
+sub _read {
+	local *FH;
+	open( FH, '<', $_[0] ) or die "open($_[0]): $!";
+	binmode FH;
+	my $string = do { local $/; <FH> };
+	close FH or die "close($_[0]): $!";
+	return $string;
+}
+
+sub _readperl {
+	my $string = Module::Install::_read($_[0]);
+	$string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg;
+	$string =~ s/(\n)\n*__(?:DATA|END)__\b.*\z/$1/s;
+	$string =~ s/\n\n=\w+.+?\n\n=cut\b.+?\n+/\n\n/sg;
+	return $string;
+}
+
+sub _readpod {
+	my $string = Module::Install::_read($_[0]);
+	$string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg;
+	return $string if $_[0] =~ /\.pod\z/;
+	$string =~ s/(^|\n=cut\b.+?\n+)[^=\s].+?\n(\n=\w+|\z)/$1$2/sg;
+	$string =~ s/\n*=pod\b[^\n]*\n+/\n\n/sg;
+	$string =~ s/\n*=cut\b[^\n]*\n+/\n\n/sg;
+	$string =~ s/^\n+//s;
+	return $string;
+}
+
+sub _write {
+	local *FH;
+	open( FH, '>', $_[0] ) or die "open($_[0]): $!";
+	binmode FH;
+	foreach ( 1 .. $#_ ) {
+		print FH $_[$_] or die "print($_[0]): $!";
+	}
+	close FH or die "close($_[0]): $!";
+}
+
+# _version is for processing module versions (eg, 1.03_05) not
+# Perl versions (eg, 5.8.1).
+sub _version {
+	my $s = shift || 0;
+	my $d =()= $s =~ /(\.)/g;
+	if ( $d >= 2 ) {
+		# Normalise multipart versions
+		$s =~ s/(\.)(\d{1,3})/sprintf("$1%03d",$2)/eg;
+	}
+	$s =~ s/^(\d+)\.?//;
+	my $l = $1 || 0;
+	my @v = map {
+		$_ . '0' x (3 - length $_)
+	} $s =~ /(\d{1,3})\D?/g;
+	$l = $l . '.' . join '', @v if @v;
+	return $l + 0;
+}
+
+sub _cmp {
+	_version($_[1]) <=> _version($_[2]);
+}
+
+# Cloned from Params::Util::_CLASS
+sub _CLASS {
+	(
+		defined $_[0]
+		and
+		! ref $_[0]
+		and
+		$_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s
+	) ? $_[0] : undef;
+}
+
+1;
+
+# Copyright 2008 - 2012 Adam Kennedy.
diff --git a/Module-Install-DOAP-0.006/inc/Module/Install/Base.pm b/Module-Install-DOAP-0.006/inc/Module/Install/Base.pm
new file mode 100644
index 0000000..9fa42c2
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Install/Base.pm
@@ -0,0 +1,83 @@
+#line 1
+package Module::Install::Base;
+
+use strict 'vars';
+use vars qw{$VERSION};
+BEGIN {
+	$VERSION = '1.19';
+}
+
+# Suspend handler for "redefined" warnings
+BEGIN {
+	my $w = $SIG{__WARN__};
+	$SIG{__WARN__} = sub { $w };
+}
+
+#line 42
+
+sub new {
+	my $class = shift;
+	unless ( defined &{"${class}::call"} ) {
+		*{"${class}::call"} = sub { shift->_top->call(@_) };
+	}
+	unless ( defined &{"${class}::load"} ) {
+		*{"${class}::load"} = sub { shift->_top->load(@_) };
+	}
+	bless { @_ }, $class;
+}
+
+#line 61
+
+sub AUTOLOAD {
+	local $@;
+	my $func = eval { shift->_top->autoload } or return;
+	goto &$func;
+}
+
+#line 75
+
+sub _top {
+	$_[0]->{_top};
+}
+
+#line 90
+
+sub admin {
+	$_[0]->_top->{admin}
+	or
+	Module::Install::Base::FakeAdmin->new;
+}
+
+#line 106
+
+sub is_admin {
+	! $_[0]->admin->isa('Module::Install::Base::FakeAdmin');
+}
+
+sub DESTROY {}
+
+package Module::Install::Base::FakeAdmin;
+
+use vars qw{$VERSION};
+BEGIN {
+	$VERSION = $Module::Install::Base::VERSION;
+}
+
+my $fake;
+
+sub new {
+	$fake ||= bless(\@_, $_[0]);
+}
+
+sub AUTOLOAD {}
+
+sub DESTROY {}
+
+# Restore warning handler
+BEGIN {
+	$SIG{__WARN__} = $SIG{__WARN__}->();
+}
+
+1;
+
+#line 159
diff --git a/Module-Install-DOAP-0.006/inc/Module/Install/Can.pm b/Module-Install-DOAP-0.006/inc/Module/Install/Can.pm
new file mode 100644
index 0000000..d65c753
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Install/Can.pm
@@ -0,0 +1,163 @@
+#line 1
+package Module::Install::Can;
+
+use strict;
+use Config                ();
+use ExtUtils::MakeMaker   ();
+use Module::Install::Base ();
+
+use vars qw{$VERSION @ISA $ISCORE};
+BEGIN {
+	$VERSION = '1.19';
+	@ISA     = 'Module::Install::Base';
+	$ISCORE  = 1;
+}
+
+# check if we can load some module
+### Upgrade this to not have to load the module if possible
+sub can_use {
+	my ($self, $mod, $ver) = @_;
+	$mod =~ s{::|\\}{/}g;
+	$mod .= '.pm' unless $mod =~ /\.pm$/i;
+
+	my $pkg = $mod;
+	$pkg =~ s{/}{::}g;
+	$pkg =~ s{\.pm$}{}i;
+
+	local $@;
+	eval { require $mod; $pkg->VERSION($ver || 0); 1 };
+}
+
+# Check if we can run some command
+sub can_run {
+	my ($self, $cmd) = @_;
+
+	my $_cmd = $cmd;
+	return $_cmd if (-x $_cmd or $_cmd = MM->maybe_command($_cmd));
+
+	for my $dir ((split /$Config::Config{path_sep}/, $ENV{PATH}), '.') {
+		next if $dir eq '';
+		require File::Spec;
+		my $abs = File::Spec->catfile($dir, $cmd);
+		return $abs if (-x $abs or $abs = MM->maybe_command($abs));
+	}
+
+	return;
+}
+
+# Can our C compiler environment build XS files
+sub can_xs {
+	my $self = shift;
+
+	# Ensure we have the CBuilder module
+	$self->configure_requires( 'ExtUtils::CBuilder' => 0.27 );
+
+	# Do we have the configure_requires checker?
+	local $@;
+	eval "require ExtUtils::CBuilder;";
+	if ( $@ ) {
+		# They don't obey configure_requires, so it is
+		# someone old and delicate. Try to avoid hurting
+		# them by falling back to an older simpler test.
+		return $self->can_cc();
+	}
+
+	# Do we have a working C compiler
+	my $builder = ExtUtils::CBuilder->new(
+		quiet => 1,
+	);
+	unless ( $builder->have_compiler ) {
+		# No working C compiler
+		return 0;
+	}
+
+	# Write a C file representative of what XS becomes
+	require File::Temp;
+	my ( $FH, $tmpfile ) = File::Temp::tempfile(
+		"compilexs-XXXXX",
+		SUFFIX => '.c',
+	);
+	binmode $FH;
+	print $FH <<'END_C';
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+int main(int argc, char **argv) {
+    return 0;
+}
+
+int boot_sanexs() {
+    return 1;
+}
+
+END_C
+	close $FH;
+
+	# Can the C compiler access the same headers XS does
+	my @libs   = ();
+	my $object = undef;
+	eval {
+		local $^W = 0;
+		$object = $builder->compile(
+			source => $tmpfile,
+		);
+		@libs = $builder->link(
+			objects     => $object,
+			module_name => 'sanexs',
+		);
+	};
+	my $result = $@ ? 0 : 1;
+
+	# Clean up all the build files
+	foreach ( $tmpfile, $object, @libs ) {
+		next unless defined $_;
+		1 while unlink;
+	}
+
+	return $result;
+}
+
+# Can we locate a (the) C compiler
+sub can_cc {
+	my $self   = shift;
+
+	if ($^O eq 'VMS') {
+		require ExtUtils::CBuilder;
+		my $builder = ExtUtils::CBuilder->new(
+		quiet => 1,
+		);
+		return $builder->have_compiler;
+	}
+
+	my @chunks = split(/ /, $Config::Config{cc}) or return;
+
+	# $Config{cc} may contain args; try to find out the program part
+	while (@chunks) {
+		return $self->can_run("@chunks") || (pop(@chunks), next);
+	}
+
+	return;
+}
+
+# Fix Cygwin bug on maybe_command();
+if ( $^O eq 'cygwin' ) {
+	require ExtUtils::MM_Cygwin;
+	require ExtUtils::MM_Win32;
+	if ( ! defined(&ExtUtils::MM_Cygwin::maybe_command) ) {
+		*ExtUtils::MM_Cygwin::maybe_command = sub {
+			my ($self, $file) = @_;
+			if ($file =~ m{^/cygdrive/}i and ExtUtils::MM_Win32->can('maybe_command')) {
+				ExtUtils::MM_Win32->maybe_command($file);
+			} else {
+				ExtUtils::MM_Unix->maybe_command($file);
+			}
+		}
+	}
+}
+
+1;
+
+__END__
+
+#line 245
diff --git a/Module-Install-DOAP-0.006/inc/Module/Install/Fetch.pm b/Module-Install-DOAP-0.006/inc/Module/Install/Fetch.pm
new file mode 100644
index 0000000..3072b08
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Install/Fetch.pm
@@ -0,0 +1,93 @@
+#line 1
+package Module::Install::Fetch;
+
+use strict;
+use Module::Install::Base ();
+
+use vars qw{$VERSION @ISA $ISCORE};
+BEGIN {
+	$VERSION = '1.19';
+	@ISA     = 'Module::Install::Base';
+	$ISCORE  = 1;
+}
+
+sub get_file {
+    my ($self, %args) = @_;
+    my ($scheme, $host, $path, $file) =
+        $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return;
+
+    if ( $scheme eq 'http' and ! eval { require LWP::Simple; 1 } ) {
+        $args{url} = $args{ftp_url}
+            or (warn("LWP support unavailable!\n"), return);
+        ($scheme, $host, $path, $file) =
+            $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return;
+    }
+
+    $|++;
+    print "Fetching '$file' from $host... ";
+
+    unless (eval { require Socket; Socket::inet_aton($host) }) {
+        warn "'$host' resolve failed!\n";
+        return;
+    }
+
+    return unless $scheme eq 'ftp' or $scheme eq 'http';
+
+    require Cwd;
+    my $dir = Cwd::getcwd();
+    chdir $args{local_dir} or return if exists $args{local_dir};
+
+    if (eval { require LWP::Simple; 1 }) {
+        LWP::Simple::mirror($args{url}, $file);
+    }
+    elsif (eval { require Net::FTP; 1 }) { eval {
+        # use Net::FTP to get past firewall
+        my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600);
+        $ftp->login("anonymous", 'anonymous@example.com');
+        $ftp->cwd($path);
+        $ftp->binary;
+        $ftp->get($file) or (warn("$!\n"), return);
+        $ftp->quit;
+    } }
+    elsif (my $ftp = $self->can_run('ftp')) { eval {
+        # no Net::FTP, fallback to ftp.exe
+        require FileHandle;
+        my $fh = FileHandle->new;
+
+        local $SIG{CHLD} = 'IGNORE';
+        unless ($fh->open("|$ftp -n")) {
+            warn "Couldn't open ftp: $!\n";
+            chdir $dir; return;
+        }
+
+        my @dialog = split(/\n/, <<"END_FTP");
+open $host
+user anonymous anonymous\@example.com
+cd $path
+binary
+get $file $file
+quit
+END_FTP
+        foreach (@dialog) { $fh->print("$_\n") }
+        $fh->close;
+    } }
+    else {
+        warn "No working 'ftp' program available!\n";
+        chdir $dir; return;
+    }
+
+    unless (-f $file) {
+        warn "Fetching failed: $@\n";
+        chdir $dir; return;
+    }
+
+    return if exists $args{size} and -s $file != $args{size};
+    system($args{run}) if exists $args{run};
+    unlink($file) if $args{remove};
+
+    print(((!exists $args{check_for} or -e $args{check_for})
+        ? "done!" : "failed! ($!)"), "\n");
+    chdir $dir; return !$?;
+}
+
+1;
diff --git a/Module-Install-DOAP-0.006/inc/Module/Install/Include.pm b/Module-Install-DOAP-0.006/inc/Module/Install/Include.pm
new file mode 100644
index 0000000..13fdcd0
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Install/Include.pm
@@ -0,0 +1,34 @@
+#line 1
+package Module::Install::Include;
+
+use strict;
+use Module::Install::Base ();
+
+use vars qw{$VERSION @ISA $ISCORE};
+BEGIN {
+	$VERSION = '1.19';
+	@ISA     = 'Module::Install::Base';
+	$ISCORE  = 1;
+}
+
+sub include {
+	shift()->admin->include(@_);
+}
+
+sub include_deps {
+	shift()->admin->include_deps(@_);
+}
+
+sub auto_include {
+	shift()->admin->auto_include(@_);
+}
+
+sub auto_include_deps {
+	shift()->admin->auto_include_deps(@_);
+}
+
+sub auto_include_dependent_dists {
+	shift()->admin->auto_include_dependent_dists(@_);
+}
+
+1;
diff --git a/Module-Install-DOAP-0.006/inc/Module/Install/Metadata.pm b/Module-Install-DOAP-0.006/inc/Module/Install/Metadata.pm
new file mode 100644
index 0000000..11bf971
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Install/Metadata.pm
@@ -0,0 +1,722 @@
+#line 1
+package Module::Install::Metadata;
+
+use strict 'vars';
+use Module::Install::Base ();
+
+use vars qw{$VERSION @ISA $ISCORE};
+BEGIN {
+	$VERSION = '1.19';
+	@ISA     = 'Module::Install::Base';
+	$ISCORE  = 1;
+}
+
+my @boolean_keys = qw{
+	sign
+};
+
+my @scalar_keys = qw{
+	name
+	module_name
+	abstract
+	version
+	distribution_type
+	tests
+	installdirs
+};
+
+my @tuple_keys = qw{
+	configure_requires
+	build_requires
+	requires
+	recommends
+	bundles
+	resources
+};
+
+my @resource_keys = qw{
+	homepage
+	bugtracker
+	repository
+};
+
+my @array_keys = qw{
+	keywords
+	author
+};
+
+*authors = \&author;
+
+sub Meta              { shift          }
+sub Meta_BooleanKeys  { @boolean_keys  }
+sub Meta_ScalarKeys   { @scalar_keys   }
+sub Meta_TupleKeys    { @tuple_keys    }
+sub Meta_ResourceKeys { @resource_keys }
+sub Meta_ArrayKeys    { @array_keys    }
+
+foreach my $key ( @boolean_keys ) {
+	*$key = sub {
+		my $self = shift;
+		if ( defined wantarray and not @_ ) {
+			return $self->{values}->{$key};
+		}
+		$self->{values}->{$key} = ( @_ ? $_[0] : 1 );
+		return $self;
+	};
+}
+
+foreach my $key ( @scalar_keys ) {
+	*$key = sub {
+		my $self = shift;
+		return $self->{values}->{$key} if defined wantarray and !@_;
+		$self->{values}->{$key} = shift;
+		return $self;
+	};
+}
+
+foreach my $key ( @array_keys ) {
+	*$key = sub {
+		my $self = shift;
+		return $self->{values}->{$key} if defined wantarray and !@_;
+		$self->{values}->{$key} ||= [];
+		push @{$self->{values}->{$key}}, @_;
+		return $self;
+	};
+}
+
+foreach my $key ( @resource_keys ) {
+	*$key = sub {
+		my $self = shift;
+		unless ( @_ ) {
+			return () unless $self->{values}->{resources};
+			return map  { $_->[1] }
+			       grep { $_->[0] eq $key }
+			       @{ $self->{values}->{resources} };
+		}
+		return $self->{values}->{resources}->{$key} unless @_;
+		my $uri = shift or die(
+			"Did not provide a value to $key()"
+		);
+		$self->resources( $key => $uri );
+		return 1;
+	};
+}
+
+foreach my $key ( grep { $_ ne "resources" } @tuple_keys) {
+	*$key = sub {
+		my $self = shift;
+		return $self->{values}->{$key} unless @_;
+		my @added;
+		while ( @_ ) {
+			my $module  = shift or last;
+			my $version = shift || 0;
+			push @added, [ $module, $version ];
+		}
+		push @{ $self->{values}->{$key} }, @added;
+		return map {@$_} @added;
+	};
+}
+
+# Resource handling
+my %lc_resource = map { $_ => 1 } qw{
+	homepage
+	license
+	bugtracker
+	repository
+};
+
+sub resources {
+	my $self = shift;
+	while ( @_ ) {
+		my $name  = shift or last;
+		my $value = shift or next;
+		if ( $name eq lc $name and ! $lc_resource{$name} ) {
+			die("Unsupported reserved lowercase resource '$name'");
+		}
+		$self->{values}->{resources} ||= [];
+		push @{ $self->{values}->{resources} }, [ $name, $value ];
+	}
+	$self->{values}->{resources};
+}
+
+# Aliases for build_requires that will have alternative
+# meanings in some future version of META.yml.
+sub test_requires     { shift->build_requires(@_) }
+sub install_requires  { shift->build_requires(@_) }
+
+# Aliases for installdirs options
+sub install_as_core   { $_[0]->installdirs('perl')   }
+sub install_as_cpan   { $_[0]->installdirs('site')   }
+sub install_as_site   { $_[0]->installdirs('site')   }
+sub install_as_vendor { $_[0]->installdirs('vendor') }
+
+sub dynamic_config {
+	my $self  = shift;
+	my $value = @_ ? shift : 1;
+	if ( $self->{values}->{dynamic_config} ) {
+		# Once dynamic we never change to static, for safety
+		return 0;
+	}
+	$self->{values}->{dynamic_config} = $value ? 1 : 0;
+	return 1;
+}
+
+# Convenience command
+sub static_config {
+	shift->dynamic_config(0);
+}
+
+sub perl_version {
+	my $self = shift;
+	return $self->{values}->{perl_version} unless @_;
+	my $version = shift or die(
+		"Did not provide a value to perl_version()"
+	);
+
+	# Normalize the version
+	$version = $self->_perl_version($version);
+
+	# We don't support the really old versions
+	unless ( $version >= 5.005 ) {
+		die "Module::Install only supports 5.005 or newer (use ExtUtils::MakeMaker)\n";
+	}
+
+	$self->{values}->{perl_version} = $version;
+}
+
+sub all_from {
+	my ( $self, $file ) = @_;
+
+	unless ( defined($file) ) {
+		my $name = $self->name or die(
+			"all_from called with no args without setting name() first"
+		);
+		$file = join('/', 'lib', split(/-/, $name)) . '.pm';
+		$file =~ s{.*/}{} unless -e $file;
+		unless ( -e $file ) {
+			die("all_from cannot find $file from $name");
+		}
+	}
+	unless ( -f $file ) {
+		die("The path '$file' does not exist, or is not a file");
+	}
+
+	$self->{values}{all_from} = $file;
+
+	# Some methods pull from POD instead of code.
+	# If there is a matching .pod, use that instead
+	my $pod = $file;
+	$pod =~ s/\.pm$/.pod/i;
+	$pod = $file unless -e $pod;
+
+	# Pull the different values
+	$self->name_from($file)         unless $self->name;
+	$self->version_from($file)      unless $self->version;
+	$self->perl_version_from($file) unless $self->perl_version;
+	$self->author_from($pod)        unless @{$self->author || []};
+	$self->license_from($pod)       unless $self->license;
+	$self->abstract_from($pod)      unless $self->abstract;
+
+	return 1;
+}
+
+sub provides {
+	my $self     = shift;
+	my $provides = ( $self->{values}->{provides} ||= {} );
+	%$provides = (%$provides, @_) if @_;
+	return $provides;
+}
+
+sub auto_provides {
+	my $self = shift;
+	return $self unless $self->is_admin;
+	unless (-e 'MANIFEST') {
+		warn "Cannot deduce auto_provides without a MANIFEST, skipping\n";
+		return $self;
+	}
+	# Avoid spurious warnings as we are not checking manifest here.
+	local $SIG{__WARN__} = sub {1};
+	require ExtUtils::Manifest;
+	local *ExtUtils::Manifest::manicheck = sub { return };
+
+	require Module::Build;
+	my $build = Module::Build->new(
+		dist_name    => $self->name,
+		dist_version => $self->version,
+		license      => $self->license,
+	);
+	$self->provides( %{ $build->find_dist_packages || {} } );
+}
+
+sub feature {
+	my $self     = shift;
+	my $name     = shift;
+	my $features = ( $self->{values}->{features} ||= [] );
+	my $mods;
+
+	if ( @_ == 1 and ref( $_[0] ) ) {
+		# The user used ->feature like ->features by passing in the second
+		# argument as a reference.  Accomodate for that.
+		$mods = $_[0];
+	} else {
+		$mods = \@_;
+	}
+
+	my $count = 0;
+	push @$features, (
+		$name => [
+			map {
+				ref($_) ? ( ref($_) eq 'HASH' ) ? %$_ : @$_ : $_
+			} @$mods
+		]
+	);
+
+	return @$features;
+}
+
+sub features {
+	my $self = shift;
+	while ( my ( $name, $mods ) = splice( @_, 0, 2 ) ) {
+		$self->feature( $name, @$mods );
+	}
+	return $self->{values}->{features}
+		? @{ $self->{values}->{features} }
+		: ();
+}
+
+sub no_index {
+	my $self = shift;
+	my $type = shift;
+	push @{ $self->{values}->{no_index}->{$type} }, @_ if $type;
+	return $self->{values}->{no_index};
+}
+
+sub read {
+	my $self = shift;
+	$self->include_deps( 'YAML::Tiny', 0 );
+
+	require YAML::Tiny;
+	my $data = YAML::Tiny::LoadFile('META.yml');
+
+	# Call methods explicitly in case user has already set some values.
+	while ( my ( $key, $value ) = each %$data ) {
+		next unless $self->can($key);
+		if ( ref $value eq 'HASH' ) {
+			while ( my ( $module, $version ) = each %$value ) {
+				$self->can($key)->($self, $module => $version );
+			}
+		} else {
+			$self->can($key)->($self, $value);
+		}
+	}
+	return $self;
+}
+
+sub write {
+	my $self = shift;
+	return $self unless $self->is_admin;
+	$self->admin->write_meta;
+	return $self;
+}
+
+sub version_from {
+	require ExtUtils::MM_Unix;
+	my ( $self, $file ) = @_;
+	$self->version( ExtUtils::MM_Unix->parse_version($file) );
+
+	# for version integrity check
+	$self->makemaker_args( VERSION_FROM => $file );
+}
+
+sub abstract_from {
+	require ExtUtils::MM_Unix;
+	my ( $self, $file ) = @_;
+	$self->abstract(
+		bless(
+			{ DISTNAME => $self->name },
+			'ExtUtils::MM_Unix'
+		)->parse_abstract($file)
+	);
+}
+
+# Add both distribution and module name
+sub name_from {
+	my ($self, $file) = @_;
+	if (
+		Module::Install::_read($file) =~ m/
+		^ \s*
+		package \s*
+		([\w:]+)
+		[\s|;]*
+		/ixms
+	) {
+		my ($name, $module_name) = ($1, $1);
+		$name =~ s{::}{-}g;
+		$self->name($name);
+		unless ( $self->module_name ) {
+			$self->module_name($module_name);
+		}
+	} else {
+		die("Cannot determine name from $file\n");
+	}
+}
+
+sub _extract_perl_version {
+	if (
+		$_[0] =~ m/
+		^\s*
+		(?:use|require) \s*
+		v?
+		([\d_\.]+)
+		\s* ;
+		/ixms
+	) {
+		my $perl_version = $1;
+		$perl_version =~ s{_}{}g;
+		return $perl_version;
+	} else {
+		return;
+	}
+}
+
+sub perl_version_from {
+	my $self = shift;
+	my $perl_version=_extract_perl_version(Module::Install::_read($_[0]));
+	if ($perl_version) {
+		$self->perl_version($perl_version);
+	} else {
+		warn "Cannot determine perl version info from $_[0]\n";
+		return;
+	}
+}
+
+sub author_from {
+	my $self    = shift;
+	my $content = Module::Install::_read($_[0]);
+	if ($content =~ m/
+		=head \d \s+ (?:authors?)\b \s*
+		([^\n]*)
+		|
+		=head \d \s+ (?:licen[cs]e|licensing|copyright|legal)\b \s*
+		.*? copyright .*? \d\d\d[\d.]+ \s* (?:\bby\b)? \s*
+		([^\n]*)
+	/ixms) {
+		my $author = $1 || $2;
+
+		# XXX: ugly but should work anyway...
+		if (eval "require Pod::Escapes; 1") {
+			# Pod::Escapes has a mapping table.
+			# It's in core of perl >= 5.9.3, and should be installed
+			# as one of the Pod::Simple's prereqs, which is a prereq
+			# of Pod::Text 3.x (see also below).
+			$author =~ s{ E<( (\d+) | ([A-Za-z]+) )> }
+			{
+				defined $2
+				? chr($2)
+				: defined $Pod::Escapes::Name2character_number{$1}
+				? chr($Pod::Escapes::Name2character_number{$1})
+				: do {
+					warn "Unknown escape: E<$1>";
+					"E<$1>";
+				};
+			}gex;
+		}
+		elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
+			# Pod::Text < 3.0 has yet another mapping table,
+			# though the table name of 2.x and 1.x are different.
+			# (1.x is in core of Perl < 5.6, 2.x is in core of
+			# Perl < 5.9.3)
+			my $mapping = ($Pod::Text::VERSION < 2)
+				? \%Pod::Text::HTML_Escapes
+				: \%Pod::Text::ESCAPES;
+			$author =~ s{ E<( (\d+) | ([A-Za-z]+) )> }
+			{
+				defined $2
+				? chr($2)
+				: defined $mapping->{$1}
+				? $mapping->{$1}
+				: do {
+					warn "Unknown escape: E<$1>";
+					"E<$1>";
+				};
+			}gex;
+		}
+		else {
+			$author =~ s{E<lt>}{<}g;
+			$author =~ s{E<gt>}{>}g;
+		}
+		$self->author($author);
+	} else {
+		warn "Cannot determine author info from $_[0]\n";
+	}
+}
+
+#Stolen from M::B
+my %license_urls = (
+    perl         => 'http://dev.perl.org/licenses/',
+    apache       => 'http://apache.org/licenses/LICENSE-2.0',
+    apache_1_1   => 'http://apache.org/licenses/LICENSE-1.1',
+    artistic     => 'http://opensource.org/licenses/artistic-license.php',
+    artistic_2   => 'http://opensource.org/licenses/artistic-license-2.0.php',
+    lgpl         => 'http://opensource.org/licenses/lgpl-license.php',
+    lgpl2        => 'http://opensource.org/licenses/lgpl-2.1.php',
+    lgpl3        => 'http://opensource.org/licenses/lgpl-3.0.html',
+    bsd          => 'http://opensource.org/licenses/bsd-license.php',
+    gpl          => 'http://opensource.org/licenses/gpl-license.php',
+    gpl2         => 'http://opensource.org/licenses/gpl-2.0.php',
+    gpl3         => 'http://opensource.org/licenses/gpl-3.0.html',
+    mit          => 'http://opensource.org/licenses/mit-license.php',
+    mozilla      => 'http://opensource.org/licenses/mozilla1.1.php',
+    open_source  => undef,
+    unrestricted => undef,
+    restrictive  => undef,
+    unknown      => undef,
+);
+
+sub license {
+	my $self = shift;
+	return $self->{values}->{license} unless @_;
+	my $license = shift or die(
+		'Did not provide a value to license()'
+	);
+	$license = __extract_license($license) || lc $license;
+	$self->{values}->{license} = $license;
+
+	# Automatically fill in license URLs
+	if ( $license_urls{$license} ) {
+		$self->resources( license => $license_urls{$license} );
+	}
+
+	return 1;
+}
+
+sub _extract_license {
+	my $pod = shift;
+	my $matched;
+	return __extract_license(
+		($matched) = $pod =~ m/
+			(=head \d \s+ L(?i:ICEN[CS]E|ICENSING)\b.*?)
+			(=head \d.*|=cut.*|)\z
+		/xms
+	) || __extract_license(
+		($matched) = $pod =~ m/
+			(=head \d \s+ (?:C(?i:OPYRIGHTS?)|L(?i:EGAL))\b.*?)
+			(=head \d.*|=cut.*|)\z
+		/xms
+	);
+}
+
+sub __extract_license {
+	my $license_text = shift or return;
+	my @phrases      = (
+		'(?:under )?the same (?:terms|license) as (?:perl|the perl (?:\d )?programming language)' => 'perl', 1,
+		'(?:under )?the terms of (?:perl|the perl programming language) itself' => 'perl', 1,
+		'Artistic and GPL'                   => 'perl',         1,
+		'GNU general public license'         => 'gpl',          1,
+		'GNU public license'                 => 'gpl',          1,
+		'GNU lesser general public license'  => 'lgpl',         1,
+		'GNU lesser public license'          => 'lgpl',         1,
+		'GNU library general public license' => 'lgpl',         1,
+		'GNU library public license'         => 'lgpl',         1,
+		'GNU Free Documentation license'     => 'unrestricted', 1,
+		'GNU Affero General Public License'  => 'open_source',  1,
+		'(?:Free)?BSD license'               => 'bsd',          1,
+		'Artistic license 2\.0'              => 'artistic_2',   1,
+		'Artistic license'                   => 'artistic',     1,
+		'Apache (?:Software )?license'       => 'apache',       1,
+		'GPL'                                => 'gpl',          1,
+		'LGPL'                               => 'lgpl',         1,
+		'BSD'                                => 'bsd',          1,
+		'Artistic'                           => 'artistic',     1,
+		'MIT'                                => 'mit',          1,
+		'Mozilla Public License'             => 'mozilla',      1,
+		'Q Public License'                   => 'open_source',  1,
+		'OpenSSL License'                    => 'unrestricted', 1,
+		'SSLeay License'                     => 'unrestricted', 1,
+		'zlib License'                       => 'open_source',  1,
+		'proprietary'                        => 'proprietary',  0,
+	);
+	while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) ) {
+		$pattern =~ s#\s+#\\s+#gs;
+		if ( $license_text =~ /\b$pattern\b/i ) {
+			return $license;
+		}
+	}
+	return '';
+}
+
+sub license_from {
+	my $self = shift;
+	if (my $license=_extract_license(Module::Install::_read($_[0]))) {
+		$self->license($license);
+	} else {
+		warn "Cannot determine license info from $_[0]\n";
+		return 'unknown';
+	}
+}
+
+sub _extract_bugtracker {
+	my @links   = $_[0] =~ m#L<(
+	 https?\Q://rt.cpan.org/\E[^>]+|
+	 https?\Q://github.com/\E[\w_]+/[\w_]+/issues|
+	 https?\Q://code.google.com/p/\E[\w_\-]+/issues/list
+	 )>#gx;
+	my %links;
+	@links{@links}=();
+	@links=keys %links;
+	return @links;
+}
+
+sub bugtracker_from {
+	my $self    = shift;
+	my $content = Module::Install::_read($_[0]);
+	my @links   = _extract_bugtracker($content);
+	unless ( @links ) {
+		warn "Cannot determine bugtracker info from $_[0]\n";
+		return 0;
+	}
+	if ( @links > 1 ) {
+		warn "Found more than one bugtracker link in $_[0]\n";
+		return 0;
+	}
+
+	# Set the bugtracker
+	bugtracker( $links[0] );
+	return 1;
+}
+
+sub requires_from {
+	my $self     = shift;
+	my $content  = Module::Install::_readperl($_[0]);
+	my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+(v?[\d\.]+)/mg;
+	while ( @requires ) {
+		my $module  = shift @requires;
+		my $version = shift @requires;
+		$self->requires( $module => $version );
+	}
+}
+
+sub test_requires_from {
+	my $self     = shift;
+	my $content  = Module::Install::_readperl($_[0]);
+	my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+([\d\.]+)/mg;
+	while ( @requires ) {
+		my $module  = shift @requires;
+		my $version = shift @requires;
+		$self->test_requires( $module => $version );
+	}
+}
+
+# Convert triple-part versions (eg, 5.6.1 or 5.8.9) to
+# numbers (eg, 5.006001 or 5.008009).
+# Also, convert double-part versions (eg, 5.8)
+sub _perl_version {
+	my $v = $_[-1];
+	$v =~ s/^([1-9])\.([1-9]\d?\d?)$/sprintf("%d.%03d",$1,$2)/e;
+	$v =~ s/^([1-9])\.([1-9]\d?\d?)\.(0|[1-9]\d?\d?)$/sprintf("%d.%03d%03d",$1,$2,$3 || 0)/e;
+	$v =~ s/(\.\d\d\d)000$/$1/;
+	$v =~ s/_.+$//;
+	if ( ref($v) ) {
+		# Numify
+		$v = $v + 0;
+	}
+	return $v;
+}
+
+sub add_metadata {
+    my $self = shift;
+    my %hash = @_;
+    for my $key (keys %hash) {
+        warn "add_metadata: $key is not prefixed with 'x_'.\n" .
+             "Use appopriate function to add non-private metadata.\n" unless $key =~ /^x_/;
+        $self->{values}->{$key} = $hash{$key};
+    }
+}
+
+
+######################################################################
+# MYMETA Support
+
+sub WriteMyMeta {
+	die "WriteMyMeta has been deprecated";
+}
+
+sub write_mymeta_yaml {
+	my $self = shift;
+
+	# We need YAML::Tiny to write the MYMETA.yml file
+	unless ( eval { require YAML::Tiny; 1; } ) {
+		return 1;
+	}
+
+	# Generate the data
+	my $meta = $self->_write_mymeta_data or return 1;
+
+	# Save as the MYMETA.yml file
+	print "Writing MYMETA.yml\n";
+	YAML::Tiny::DumpFile('MYMETA.yml', $meta);
+}
+
+sub write_mymeta_json {
+	my $self = shift;
+
+	# We need JSON to write the MYMETA.json file
+	unless ( eval { require JSON; 1; } ) {
+		return 1;
+	}
+
+	# Generate the data
+	my $meta = $self->_write_mymeta_data or return 1;
+
+	# Save as the MYMETA.yml file
+	print "Writing MYMETA.json\n";
+	Module::Install::_write(
+		'MYMETA.json',
+		JSON->new->pretty(1)->canonical->encode($meta),
+	);
+}
+
+sub _write_mymeta_data {
+	my $self = shift;
+
+	# If there's no existing META.yml there is nothing we can do
+	return undef unless -f 'META.yml';
+
+	# We need Parse::CPAN::Meta to load the file
+	unless ( eval { require Parse::CPAN::Meta; 1; } ) {
+		return undef;
+	}
+
+	# Merge the perl version into the dependencies
+	my $val  = $self->Meta->{values};
+	my $perl = delete $val->{perl_version};
+	if ( $perl ) {
+		$val->{requires} ||= [];
+		my $requires = $val->{requires};
+
+		# Canonize to three-dot version after Perl 5.6
+		if ( $perl >= 5.006 ) {
+			$perl =~ s{^(\d+)\.(\d\d\d)(\d*)}{join('.', $1, int($2||0), int($3||0))}e
+		}
+		unshift @$requires, [ perl => $perl ];
+	}
+
+	# Load the advisory META.yml file
+	my @yaml = Parse::CPAN::Meta::LoadFile('META.yml');
+	my $meta = $yaml[0];
+
+	# Overwrite the non-configure dependency hashes
+	delete $meta->{requires};
+	delete $meta->{build_requires};
+	delete $meta->{recommends};
+	if ( exists $val->{requires} ) {
+		$meta->{requires} = { map { @$_ } @{ $val->{requires} } };
+	}
+	if ( exists $val->{build_requires} ) {
+		$meta->{build_requires} = { map { @$_ } @{ $val->{build_requires} } };
+	}
+
+	return $meta;
+}
+
+1;
diff --git a/Module-Install-DOAP-0.006/inc/Module/Install/Package.pm b/Module-Install-DOAP-0.006/inc/Module/Install/Package.pm
new file mode 100644
index 0000000..47d5178
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Install/Package.pm
@@ -0,0 +1,323 @@
+#line 1
+##
+# name:      Module::Install::Package
+# abstract:  Module::Install support for Module::Package
+# author:    Ingy döt Net <ingy@cpan.org>
+# license:   perl
+# copyright: 2011
+# see:
+# - Module::Package
+
+# This module contains the Module::Package logic that must be available to
+# both the Author and the End User. Author-only logic goes in a
+# Module::Package::Plugin subclass.
+package Module::Install::Package;
+use strict;
+use Module::Install::Base;
+use vars qw'@ISA $VERSION';
+@ISA = 'Module::Install::Base';
+$VERSION = '0.30';
+
+#-----------------------------------------------------------------------------#
+# XXX BOOTBUGHACK
+# This is here to try to get us out of Module-Package-0.11 cpantesters hell...
+# Remove this when the situation has blown over.
+sub pkg {
+    *inc::Module::Package::VERSION = sub { $VERSION };
+    my $self = shift;
+    $self->module_package_internals_init($@);
+}
+
+#-----------------------------------------------------------------------------#
+# We allow the author to specify key/value options after the plugin. These
+# options need to be available both at author time and install time.
+#-----------------------------------------------------------------------------#
+# OO accessor for command line options:
+sub package_options {
+    @_>1?($_[0]->{package_options}=$_[1]):$_[0]->{package_options}}
+
+my $default_options = {
+    deps_list => 1,
+    install_bin => 1,
+    install_share => 1,
+    manifest_skip => 1,
+    requires_from => 1,
+};
+
+#-----------------------------------------------------------------------------#
+# Module::Install plugin directives. Use long, ugly names to not pollute the
+# Module::Install plugin namespace. These are only intended to be called from
+# Module::Package.
+#-----------------------------------------------------------------------------#
+
+# Module::Package starts off life as a normal call to this Module::Install
+# plugin directive:
+my $module_install_plugin;
+my $module_package_plugin;
+my $module_package_dist_plugin;
+# XXX ARGVHACK This @argv thing is a temporary fix for an ugly bug somewhere in the
+# Wikitext module usage.
+my @argv;
+sub module_package_internals_init {
+    my $self = $module_install_plugin = shift;
+    my ($plugin_spec, %options) = @_;
+    $self->package_options({%$default_options, %options});
+
+    if ($module_install_plugin->is_admin) {
+        $module_package_plugin = $self->_load_plugin($plugin_spec);
+        $module_package_plugin->mi($module_install_plugin);
+        $module_package_plugin->version_check($VERSION);
+    }
+    else {
+        $module_package_dist_plugin = $self->_load_dist_plugin($plugin_spec);
+        $module_package_dist_plugin->mi($module_install_plugin) if ref $module_package_dist_plugin;
+    }
+    # NOTE - This is the point in time where the body of Makefile.PL runs...
+    return;
+
+    sub INIT {
+        return unless $module_install_plugin;
+        return if $Module::Package::ERROR;
+        eval {
+            if ($module_install_plugin->is_admin) {
+                $module_package_plugin->initial();
+                $module_package_plugin->main();
+            }
+            else {
+                $module_install_plugin->_initial();
+                $module_package_dist_plugin->_initial() if ref $module_package_dist_plugin;
+                $module_install_plugin->_main();
+                $module_package_dist_plugin->_main() if ref $module_package_dist_plugin;
+            }
+        };
+        if ($@) {
+            $Module::Package::ERROR = $@;
+            die $@;
+        }
+        @argv = @ARGV; # XXX ARGVHACK
+    }
+
+    # If this Module::Install plugin was used (by Module::Package) then wrap
+    # up any loose ends. This will get called after Makefile.PL has completed.
+    sub END {
+        @ARGV = @argv; # XXX ARGVHACK
+        return unless $module_install_plugin;
+        return if $Module::Package::ERROR;
+        $module_package_plugin
+            ? do {
+                $module_package_plugin->final;
+                $module_package_plugin->replicate_module_package;
+            }
+            : do {
+                $module_install_plugin->_final;
+                $module_package_dist_plugin->_final() if ref $module_package_dist_plugin;
+            }
+    }
+}
+
+# Module::Package, Module::Install::Package and Module::Package::Plugin
+# must all have the same version. Seems wise.
+sub module_package_internals_version_check {
+    my ($self, $version) = @_;
+    return if $version < 0.1800001;   # XXX BOOTBUGHACK!!
+    die <<"..." unless $version == $VERSION;
+
+Error! Something has gone awry:
+    Module::Package version=$version is using 
+    Module::Install::Package version=$VERSION
+If you are the author of this module, try upgrading Module::Package.
+Otherwise, please notify the author of this error.
+
+...
+}
+
+# Find and load the author side plugin:
+sub _load_plugin {
+    my ($self, $spec, $namespace) = @_;
+    $spec ||= '';
+    $namespace ||= 'Module::Package';
+    my $version = '';
+    $Module::Package::plugin_version = 0;
+    if ($spec =~ s/\s+(\S+)\s*//) {
+        $version = $1;
+        $Module::Package::plugin_version = $version;
+    }
+    my ($module, $plugin) =
+        not($spec) ? ('Plugin', "Plugin::basic") :
+        ($spec =~ /^\w(\w|::)*$/) ? ($spec, $spec) :
+        ($spec =~ /^:(\w+)$/) ? ('Plugin', "Plugin::$1") :
+        ($spec =~ /^(\S*\w):(\w+)$/) ? ($1, "$1::$2") :
+        die "$spec is invalid";
+    $module = "${namespace}::${module}";
+    $plugin = "${namespace}::${plugin}";
+    eval "use $module $version (); 1" or die $@;
+    return $plugin->new();
+}
+
+# Find and load the user side plugin:
+sub _load_dist_plugin {
+    my ($self, $spec, $namespace) = @_;
+    $spec ||= '';
+    $namespace ||= 'Module::Package::Dist';
+    my $r = eval { $self->_load_plugin($spec, $namespace); };
+    return $r if ref $r;
+    return;
+}
+
+#-----------------------------------------------------------------------------#
+# These are the user side analogs to the author side plugin API calls.
+# Prefix with '_' to not pollute Module::Install plugin space.
+#-----------------------------------------------------------------------------#
+sub _initial {
+    my ($self) = @_;
+}
+
+sub _main {
+    my ($self) = @_;
+}
+
+# NOTE These must match Module::Package::Plugin::final.
+sub _final {
+    my ($self) = @_;
+    $self->_all_from;
+    $self->_requires_from;
+    $self->_install_bin;
+    $self->_install_share;
+    $self->_WriteAll;
+}
+
+#-----------------------------------------------------------------------------#
+# This section is where all the useful code bits go. These bits are needed by
+# both Author and User side runs.
+#-----------------------------------------------------------------------------#
+
+my $all_from = 0;
+sub _all_from {
+    my $self = shift;
+    return if $all_from++;
+    return if $self->name;
+    my $file = shift || "$main::PM" or die "all_from has no file";
+    $self->all_from($file);
+}
+
+my $requires_from = 0;
+sub _requires_from {
+    my $self = shift;
+    return if $requires_from++;
+    return unless $self->package_options->{requires_from};
+    my $file = shift || "$main::PM" or die "requires_from has no file";
+    $self->requires_from($main::PM)
+}
+
+my $install_bin = 0;
+sub _install_bin {
+    my $self = shift;
+    return if $install_bin++;
+    return unless $self->package_options->{install_bin};
+    return unless -d 'bin';
+    my @bin;
+    File::Find::find(sub {
+        return unless -f $_;
+        push @bin, $File::Find::name;
+    }, 'bin');
+    $self->install_script($_) for @bin;
+}
+
+my $install_share = 0;
+sub _install_share {
+    my $self = shift;
+    return if $install_share++;
+    return unless $self->package_options->{install_share};
+    return unless -d 'share';
+    $self->install_share;
+}
+
+my $WriteAll = 0;
+sub _WriteAll {
+    my $self = shift;
+    return if $WriteAll++;
+    $self->WriteAll(@_);
+}
+
+# Base package for Module::Package plugin distributed components.
+package Module::Package::Dist;
+
+sub new {
+    my ($class, %args) = @_;
+    bless \%args, $class;
+}
+
+sub mi {
+    @_ > 1 ? ($_[0]->{mi}=$_[1]) : $_[0]->{mi};
+}
+
+sub _initial {
+    my ($self) = @_;
+}
+
+sub _main {
+    my ($self) = @_;
+}
+
+sub _final {
+    my ($self) = @_;
+}
+
+1;
+
+#-----------------------------------------------------------------------------#
+# Take a guess at the primary .pm and .pod files for 'all_from', and friends.
+# Put them in global magical vars in the main:: namespace.
+#-----------------------------------------------------------------------------#
+package Module::Package::PM;
+use overload '""' => sub {
+    $_[0]->guess_pm unless @{$_[0]};
+    return $_[0]->[0];
+};
+sub set { $_[0]->[0] = $_[1] }
+sub guess_pm {
+    my $pm = '';
+    my $self = shift;
+    if (-e 'META.yml') {
+        open META, 'META.yml' or die "Can't open 'META.yml' for input:\n$!";
+        my $meta = do { local $/; <META> };
+        close META;
+        $meta =~ /^module_name: (\S+)$/m
+            or die "Can't get module_name from META.yml";
+        $pm = $1;
+        $pm =~ s!::!/!g;
+        $pm = "lib/$pm.pm";
+    }
+    else {
+        require File::Find;
+        my @array = ();
+        File::Find::find(sub {
+            return unless /\.pm$/;
+            my $name = $File::Find::name;
+            my $num = ($name =~ s!/+!/!g);
+            my $ary = $array[$num] ||= [];
+            push @$ary, $name;
+        }, 'lib');
+        shift @array while @array and not defined $array[0];
+        die "Can't guess main module" unless @array;
+        (($pm) = sort @{$array[0]}) or
+            die "Can't guess main module";
+    }
+    my $pmc = $pm . 'c';
+    $pm = $pmc if -e $pmc;
+    $self->set($pm);
+}
+$main::PM = bless [$main::PM ? ($main::PM) : ()], __PACKAGE__;
+
+package Module::Package::POD;
+use overload '""' => sub {
+    return $_[0]->[0] if @{$_[0]};
+    (my $pod = "$main::PM") =~ s/\.pm/.pod/
+        or die "Module::Package's \$main::PM value should end in '.pm'";
+    return -e $pod ? $pod : '';
+};
+sub set { $_[0][0] = $_[1] }
+$main::POD = bless [$main::POD ? ($main::POD) : ()], __PACKAGE__;
+
+1;
+
diff --git a/Module-Install-DOAP-0.006/inc/Module/Install/TrustMetaYml.pm b/Module-Install-DOAP-0.006/inc/Module/Install/TrustMetaYml.pm
new file mode 100644
index 0000000..5e9d70d
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Install/TrustMetaYml.pm
@@ -0,0 +1,50 @@
+#line 1
+package Module::Install::TrustMetaYml;
+
+use 5.005;
+use strict;
+
+BEGIN {
+	$Module::Install::TrustMetaYml::AUTHORITY = 'cpan:TOBYINK';
+	$Module::Install::TrustMetaYml::VERSION   = '0.003';
+}
+
+use base qw(Module::Install::Base);
+
+sub trust_meta_yml
+{
+	my ($self, $where) = @_;
+	$where ||= 'META.yml';
+
+	$self->perl_version('5.005') unless defined $self->perl_version;
+	
+	$self->include('YAML::Tiny', 0);
+	return $self if $self->is_admin;
+
+	require YAML::Tiny;
+	my $data = YAML::Tiny::LoadFile($where);
+
+	$self->perl_version($data->{requires}{perl} || '5.005');
+	
+	KEY: foreach my $key (qw(requires recommends build_requires))
+	{
+		next KEY unless ref $data->{$key} eq 'HASH';
+		my %deps = %{$data->{$key}};
+		DEP: while (my ($pkg, $ver) = each %deps)
+		{
+			next if $pkg eq 'perl';
+			$self->$key($pkg, $ver);
+		}
+	}
+	
+	return $self;
+}
+
+*trust_meta_yaml = \&trust_meta_yml;
+
+1;
+
+__END__
+
+=encoding utf8
+
diff --git a/Module-Install-DOAP-0.006/inc/Module/Install/WriteAll.pm b/Module-Install-DOAP-0.006/inc/Module/Install/WriteAll.pm
new file mode 100644
index 0000000..2db861a
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Install/WriteAll.pm
@@ -0,0 +1,63 @@
+#line 1
+package Module::Install::WriteAll;
+
+use strict;
+use Module::Install::Base ();
+
+use vars qw{$VERSION @ISA $ISCORE};
+BEGIN {
+	$VERSION = '1.19';
+	@ISA     = qw{Module::Install::Base};
+	$ISCORE  = 1;
+}
+
+sub WriteAll {
+	my $self = shift;
+	my %args = (
+		meta        => 1,
+		sign        => 0,
+		inline      => 0,
+		check_nmake => 1,
+		@_,
+	);
+
+	$self->sign(1)                if $args{sign};
+	$self->admin->WriteAll(%args) if $self->is_admin;
+
+	$self->check_nmake if $args{check_nmake};
+	unless ( $self->makemaker_args->{PL_FILES} ) {
+		# XXX: This still may be a bit over-defensive...
+		unless ($self->makemaker(6.25)) {
+			$self->makemaker_args( PL_FILES => {} ) if -f 'Build.PL';
+		}
+	}
+
+	# Until ExtUtils::MakeMaker support MYMETA.yml, make sure
+	# we clean it up properly ourself.
+	$self->realclean_files('MYMETA.yml');
+
+	if ( $args{inline} ) {
+		$self->Inline->write;
+	} else {
+		$self->Makefile->write;
+	}
+
+	# The Makefile write process adds a couple of dependencies,
+	# so write the META.yml files after the Makefile.
+	if ( $args{meta} ) {
+		$self->Meta->write;
+	}
+
+	# Experimental support for MYMETA
+	if ( $ENV{X_MYMETA} ) {
+		if ( $ENV{X_MYMETA} eq 'JSON' ) {
+			$self->Meta->write_mymeta_json;
+		} else {
+			$self->Meta->write_mymeta_yaml;
+		}
+	}
+
+	return 1;
+}
+
+1;
diff --git a/Module-Install-DOAP-0.006/inc/Module/Package.pm b/Module-Install-DOAP-0.006/inc/Module/Package.pm
new file mode 100644
index 0000000..7ea98a9
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Package.pm
@@ -0,0 +1,71 @@
+#line 1
+##
+# name:      Module::Package
+# abstract:  Postmodern Perl Module Packaging
+# author:    Ingy döt Net <ingy@cpan.org>
+# license:   perl
+# copyright: 2011
+# see:
+# - Module::Package::Plugin
+# - Module::Install::Package
+# - Module::Package::Tutorial
+
+package Module::Package;
+use 5.005;
+use strict;
+
+BEGIN {
+    $Module::Package::VERSION = '0.30';
+    $inc::Module::Package::VERSION ||= $Module::Package::VERSION;
+    @inc::Module::Package::ISA = __PACKAGE__;
+}
+
+sub import {
+    my $class = shift;
+    $INC{'inc/Module/Install.pm'} = __FILE__;
+    unshift @INC, 'inc' unless $INC[0] eq 'inc';
+    eval "use Module::Install 1.01 (); 1" or $class->error($@);
+
+    package main;
+    Module::Install->import();
+    eval {
+        module_package_internals_version_check($Module::Package::VERSION);
+        module_package_internals_init(@_);
+    };
+    if ($@) {
+        $Module::Package::ERROR = $@;
+        die $@;
+    }
+}
+
+# XXX Remove this when things are stable.
+sub error {
+    my ($class, $error) = @_;
+    if (-e 'inc' and not -e 'inc/.author') {
+        require Data::Dumper;
+        $Data::Dumper::Sortkeys = 1;
+        my $dump1 = Data::Dumper::Dumper(\%INC);
+        my $dump2 = Data::Dumper::Dumper(\@INC);
+        die <<"...";
+This should not have happened. Hopefully this dump will explain the problem:
+
+inc::Module::Package: $inc::Module::Package::VERSION
+Module::Package: $Module::Package::VERSION
+inc::Module::Install: $inc::Module::Install::VERSION
+Module::Install: $Module::Install::VERSION
+
+Error: $error
+
+%INC:
+$dump1
+\@INC:
+$dump2
+...
+    }
+    else {
+        die $error;
+    }
+}
+
+1;
+
diff --git a/Module-Install-DOAP-0.006/inc/Module/Package/Dist/RDF.pm b/Module-Install-DOAP-0.006/inc/Module/Package/Dist/RDF.pm
new file mode 100644
index 0000000..69df1ee
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/Module/Package/Dist/RDF.pm
@@ -0,0 +1,48 @@
+#line 1
+package Module::Package::Dist::RDF;
+
+my $explanation = q<
+	This is the component of Module::Package::RDF which gets
+	bundled with the distribution.
+>;
+
+use 5.005;
+use strict;
+
+BEGIN {
+	$Module::Package::Dist::RDF::AUTHORITY = 'cpan:TOBYINK';
+	$Module::Package::Dist::RDF::VERSION   = '0.014';
+	@Module::Package::Dist::RDF::ISA       = 'Module::Package::Dist';
+}
+
+sub _main
+{
+	my ($self) = @_;
+	$self->mi->trust_meta_yml;
+	$self->mi->auto_install
+		unless $ENV{NO_AUTO_INSTALL};
+}
+
+{
+	package Module::Package::Dist::RDF::standard;
+	use 5.005;
+	use strict;
+	BEGIN {
+		$Module::Package::Dist::RDF::standard::AUTHORITY = 'cpan:TOBYINK';
+		$Module::Package::Dist::RDF::standard::VERSION   = '0.014';
+		@Module::Package::Dist::RDF::standard::ISA       = 'Module::Package::Dist::RDF';
+	}
+}
+
+{
+	package Module::Package::Dist::RDF::tobyink;
+	use 5.005;
+	use strict;
+	BEGIN {
+		$Module::Package::Dist::RDF::tobyink::AUTHORITY = 'cpan:TOBYINK';
+		$Module::Package::Dist::RDF::tobyink::VERSION   = '0.014';
+		@Module::Package::Dist::RDF::tobyink::ISA       = 'Module::Package::Dist::RDF';
+	}
+}
+
+1;
diff --git a/Module-Install-DOAP-0.006/inc/YAML/Tiny.pm b/Module-Install-DOAP-0.006/inc/YAML/Tiny.pm
new file mode 100644
index 0000000..fb157a6
--- /dev/null
+++ b/Module-Install-DOAP-0.006/inc/YAML/Tiny.pm
@@ -0,0 +1,872 @@
+#line 1
+use 5.008001; # sane UTF-8 support
+use strict;
+use warnings;
+package YAML::Tiny; # git description: v1.72-7-g8682f63
+# XXX-INGY is 5.8.1 too old/broken for utf8?
+# XXX-XDG Lancaster consensus was that it was sufficient until
+# proven otherwise
+
+our $VERSION = '1.73';
+
+#####################################################################
+# The YAML::Tiny API.
+#
+# These are the currently documented API functions/methods and
+# exports:
+
+use Exporter;
+our @ISA       = qw{ Exporter  };
+our @EXPORT    = qw{ Load Dump };
+our @EXPORT_OK = qw{ LoadFile DumpFile freeze thaw };
+
+###
+# Functional/Export API:
+
+sub Dump {
+    return YAML::Tiny->new(@_)->_dump_string;
+}
+
+# XXX-INGY Returning last document seems a bad behavior.
+# XXX-XDG I think first would seem more natural, but I don't know
+# that it's worth changing now
+sub Load {
+    my $self = YAML::Tiny->_load_string(@_);
+    if ( wantarray ) {
+        return @$self;
+    } else {
+        # To match YAML.pm, return the last document
+        return $self->[-1];
+    }
+}
+
+# XXX-INGY Do we really need freeze and thaw?
+# XXX-XDG I don't think so.  I'd support deprecating them.
+BEGIN {
+    *freeze = \&Dump;
+    *thaw   = \&Load;
+}
+
+sub DumpFile {
+    my $file = shift;
+    return YAML::Tiny->new(@_)->_dump_file($file);
+}
+
+sub LoadFile {
+    my $file = shift;
+    my $self = YAML::Tiny->_load_file($file);
+    if ( wantarray ) {
+        return @$self;
+    } else {
+        # Return only the last document to match YAML.pm,
+        return $self->[-1];
+    }
+}
+
+
+###
+# Object Oriented API:
+
+# Create an empty YAML::Tiny object
+# XXX-INGY Why do we use ARRAY object?
+# NOTE: I get it now, but I think it's confusing and not needed.
+# Will change it on a branch later, for review.
+#
+# XXX-XDG I don't support changing it yet.  It's a very well-documented
+# "API" of YAML::Tiny.  I'd support deprecating it, but Adam suggested
+# we not change it until YAML.pm's own OO API is established so that
+# users only have one API change to digest, not two
+sub new {
+    my $class = shift;
+    bless [ @_ ], $class;
+}
+
+# XXX-INGY It probably doesn't matter, and it's probably too late to
+# change, but 'read/write' are the wrong names. Read and Write
+# are actions that take data from storage to memory
+# characters/strings. These take the data to/from storage to native
+# Perl objects, which the terms dump and load are meant. As long as
+# this is a legacy quirk to YAML::Tiny it's ok, but I'd prefer not
+# to add new {read,write}_* methods to this API.
+
+sub read_string {
+    my $self = shift;
+    $self->_load_string(@_);
+}
+
+sub write_string {
+    my $self = shift;
+    $self->_dump_string(@_);
+}
+
+sub read {
+    my $self = shift;
+    $self->_load_file(@_);
+}
+
+sub write {
+    my $self = shift;
+    $self->_dump_file(@_);
+}
+
+
+
+
+#####################################################################
+# Constants
+
+# Printed form of the unprintable characters in the lowest range
+# of ASCII characters, listed by ASCII ordinal position.
+my @UNPRINTABLE = qw(
+    0    x01  x02  x03  x04  x05  x06  a
+    b    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 = (
+    0 => "\x00", z => "\x00", N    => "\x85",
+    a => "\x07", b => "\x08", t    => "\x09",
+    n => "\x0a", v => "\x0b", f    => "\x0c",
+    r => "\x0d", e => "\x1b", '\\' => '\\',
+);
+
+# XXX-INGY
+# I(ngy) need to decide if these values should be quoted in
+# YAML::Tiny or not. Probably yes.
+
+# These 3 values have special meaning when unquoted and using the
+# default YAML schema. They need quotes if they are strings.
+my %QUOTE = map { $_ => 1 } qw{
+    null true false
+};
+
+# 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.
+# qr/\"((?:\\.|[^\"])*)\"/
+my $re_capture_double_quoted = qr/\"([^\\"]*(?:\\.[^\\"]*)*)\"/;
+my $re_capture_single_quoted = qr/\'([^\']*(?:\'\'[^\']*)*)\'/;
+# unquoted re gets trailing space that needs to be stripped
+my $re_capture_unquoted_key  = qr/([^:]+(?::+\S(?:[^:]*|.*?(?=:)))*)(?=\s*\:(?:\s+|$))/;
+my $re_trailing_comment      = qr/(?:\s+\#.*)?/;
+my $re_key_value_separator   = qr/\s*:(?:\s+(?:\#.*)?|$)/;
+
+
+
+
+
+#####################################################################
+# YAML::Tiny Implementation.
+#
+# These are the private methods that do all the work. They may change
+# at any time.
+
+
+###
+# Loader functions:
+
+# Create an object from a file
+sub _load_file {
+    my $class = ref $_[0] ? ref shift : shift;
+
+    # Check the file
+    my $file = shift or $class->_error( 'You did not specify a file name' );
+    $class->_error( "File '$file' does not exist" )
+        unless -e $file;
+    $class->_error( "'$file' is a directory, not a file" )
+        unless -f _;
+    $class->_error( "Insufficient permissions to read '$file'" )
+        unless -r _;
+
+    # Open unbuffered with strict UTF-8 decoding and no translation layers
+    open( my $fh, "<:unix:encoding(UTF-8)", $file );
+    unless ( $fh ) {
+        $class->_error("Failed to open file '$file': $!");
+    }
+
+    # flock if available (or warn if not possible for OS-specific reasons)
+    if ( _can_flock() ) {
+        flock( $fh, Fcntl::LOCK_SH() )
+            or warn "Couldn't lock '$file' for reading: $!";
+    }
+
+    # slurp the contents
+    my $contents = eval {
+        use warnings FATAL => 'utf8';
+        local $/;
+        <$fh>
+    };
+    if ( my $err = $@ ) {
+        $class->_error("Error reading from file '$file': $err");
+    }
+
+    # close the file (release the lock)
+    unless ( close $fh ) {
+        $class->_error("Failed to close file '$file': $!");
+    }
+
+    $class->_load_string( $contents );
+}
+
+# Create an object from a string
+sub _load_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";
+        }
+
+        # Check if Perl has it marked as characters, but it's internally
+        # inconsistent.  E.g. maybe latin1 got read on a :utf8 layer
+        if ( utf8::is_utf8($string) && ! utf8::valid($string) ) {
+            die \<<'...';
+Read an invalid UTF-8 string (maybe mixed UTF-8 and 8-bit character set).
+Did you decode with lax ":utf8" instead of strict ":encoding(UTF-8)"?
+...
+        }
+
+        # Ensure Unicode character semantics, even for 0x80-0xff
+        utf8::upgrade($string);
+
+        # Check for and strip any leading UTF-8 BOM
+        $string =~ s/^\x{FEFF}//;
+
+        # Check for some special cases
+        return $self unless length $string;
+
+        # 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
+        my $in_document = 0;
+        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->_load_scalar( "$1", [ undef ], \@lines );
+                    next;
+                }
+                $in_document = 1;
+            }
+
+            if ( ! @lines or $lines[0] =~ /^(?:---|\.\.\.)/ ) {
+                # A naked document
+                push @$self, undef;
+                while ( @lines and $lines[0] !~ /^---/ ) {
+                    shift @lines;
+                }
+                $in_document = 0;
+
+            # XXX The final '-+$' is to look for -- which ends up being an
+            # error later.
+            } elsif ( ! $in_document && @$self ) {
+                # only the first document can be explicit
+                die \"YAML::Tiny failed to classify the line '$lines[0]'";
+            } elsif ( $lines[0] =~ /^\s*\-(?:\s|$|-+$)/ ) {
+                # An array at the root
+                my $document = [ ];
+                push @$self, $document;
+                $self->_load_array( $document, [ 0 ], \@lines );
+
+            } elsif ( $lines[0] =~ /^(\s*)\S/ ) {
+                # A hash at the root
+                my $document = { };
+                push @$self, $document;
+                $self->_load_hash( $document, [ length($1) ], \@lines );
+
+            } else {
+                # Shouldn't get here.  @lines have whitespace-only lines
+                # stripped, and previous match is a line with any
+                # non-whitespace.  So this clause should only be reachable via
+                # a perlbug where \s is not symmetric with \S
+
+                # uncoverable statement
+                die \"YAML::Tiny failed to classify the line '$lines[0]'";
+            }
+        }
+    };
+    my $err = $@;
+    if ( ref $err eq 'SCALAR' ) {
+        $self->_error(${$err});
+    } elsif ( $err ) {
+        $self->_error($err);
+    }
+
+    return $self;
+}
+
+sub _unquote_single {
+    my ($self, $string) = @_;
+    return '' unless length $string;
+    $string =~ s/\'\'/\'/g;
+    return $string;
+}
+
+sub _unquote_double {
+    my ($self, $string) = @_;
+    return '' unless length $string;
+    $string =~ s/\\"/"/g;
+    $string =~
+        s{\\([Nnever\\fartz0b]|x([0-9a-fA-F]{2}))}
+         {(length($1)>1)?pack("H2",$2):$UNESCAPES{$1}}gex;
+    return $string;
+}
+
+# Load a YAML scalar string to the actual Perl scalar
+sub _load_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 =~ /^$re_capture_single_quoted$re_trailing_comment\z/ ) {
+        return $self->_unquote_single($1);
+    }
+
+    # Double quote.
+    if ( $string =~ /^$re_capture_double_quoted$re_trailing_comment\z/ ) {
+        return $self->_unquote_double($1);
+    }
+
+    # Special cases
+    if ( $string =~ /^[\'\"!&]/ ) {
+        die \"YAML::Tiny does not support a feature in line '$string'";
+    }
+    return {} if $string =~ /^{}(?:\s+\#.*)?\z/;
+    return [] if $string =~ /^\[\](?:\s+\#.*)?\z/;
+
+    # Regular unquoted string
+    if ( $string !~ /^[>|]/ ) {
+        die \"YAML::Tiny found illegal characters in plain scalar: '$string'"
+            if $string =~ /^(?:-(?:\s|$)|[\@\%\`])/ or
+                $string =~ /:(?:\s|$)/;
+        $string =~ s/\s+#.*\z//;
+        return $string;
+    }
+
+    # Error
+    die \"YAML::Tiny failed to find multi-line scalar content" unless @$lines;
+
+    # Check the indent depth
+    $lines->[0]   =~ /^(\s*)/;
+    $indent->[-1] = length("$1");
+    if ( defined $indent->[-2] and $indent->[-1] <= $indent->[-2] ) {
+        die \"YAML::Tiny found bad indenting in line '$lines->[0]'";
+    }
+
+    # Pull the lines
+    my @multiline = ();
+    while ( @$lines ) {
+        $lines->[0] =~ /^(\s*)/;
+        last unless length($1) >= $indent->[-1];
+        push @multiline, substr(shift(@$lines), $indent->[-1]);
+    }
+
+    my $j = (substr($string, 0, 1) eq '>') ? ' ' : "\n";
+    my $t = (substr($string, 1, 1) eq '-') ? ''  : "\n";
+    return join( $j, @multiline ) . $t;
+}
+
+# Load an array
+sub _load_array {
+    my ($self, $array, $indent, $lines) = @_;
+
+    while ( @$lines ) {
+        # Check for a new document
+        if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) {
+            while ( @$lines and $lines->[0] !~ /^---/ ) {
+                shift @$lines;
+            }
+            return 1;
+        }
+
+        # Check the indent level
+        $lines->[0] =~ /^(\s*)/;
+        if ( length($1) < $indent->[-1] ) {
+            return 1;
+        } elsif ( length($1) > $indent->[-1] ) {
+            die \"YAML::Tiny found bad indenting in line '$lines->[0]'";
+        }
+
+        if ( $lines->[0] =~ /^(\s*\-\s+)[^\'\"]\S*\s*:(?:\s+|$)/ ) {
+            # Inline nested hash
+            my $indent2 = length("$1");
+            $lines->[0] =~ s/-/ /;
+            push @$array, { };
+            $self->_load_hash( $array->[-1], [ @$indent, $indent2 ], $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->_load_array(
+                        $array->[-1], [ @$indent, $indent2 ], $lines
+                    );
+                }
+
+            } elsif ( $lines->[0] =~ /^(\s*)\S/ ) {
+                push @$array, { };
+                $self->_load_hash(
+                    $array->[-1], [ @$indent, length("$1") ], $lines
+                );
+
+            } else {
+                die \"YAML::Tiny failed to classify line '$lines->[0]'";
+            }
+
+        } elsif ( $lines->[0] =~ /^\s*\-(\s*)(.+?)\s*\z/ ) {
+            # Array entry with a value
+            shift @$lines;
+            push @$array, $self->_load_scalar(
+                "$2", [ @$indent, undef ], $lines
+            );
+
+        } elsif ( defined $indent->[-2] and $indent->[-1] == $indent->[-2] ) {
+            # This is probably a structure like the following...
+            # ---
+            # foo:
+            # - list
+            # bar: value
+            #
+            # ... so lets return and let the hash parser handle it
+            return 1;
+
+        } else {
+            die \"YAML::Tiny failed to classify line '$lines->[0]'";
+        }
+    }
+
+    return 1;
+}
+
+# Load a hash
+sub _load_hash {
+    my ($self, $hash, $indent, $lines) = @_;
+
+    while ( @$lines ) {
+        # Check for a new document
+        if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) {
+            while ( @$lines and $lines->[0] !~ /^---/ ) {
+                shift @$lines;
+            }
+            return 1;
+        }
+
+        # Check the indent level
+        $lines->[0] =~ /^(\s*)/;
+        if ( length($1) < $indent->[-1] ) {
+            return 1;
+        } elsif ( length($1) > $indent->[-1] ) {
+            die \"YAML::Tiny found bad indenting in line '$lines->[0]'";
+        }
+
+        # Find the key
+        my $key;
+
+        # Quoted keys
+        if ( $lines->[0] =~
+            s/^\s*$re_capture_single_quoted$re_key_value_separator//
+        ) {
+            $key = $self->_unquote_single($1);
+        }
+        elsif ( $lines->[0] =~
+            s/^\s*$re_capture_double_quoted$re_key_value_separator//
+        ) {
+            $key = $self->_unquote_double($1);
+        }
+        elsif ( $lines->[0] =~
+            s/^\s*$re_capture_unquoted_key$re_key_value_separator//
+        ) {
+            $key = $1;
+            $key =~ s/\s+$//;
+        }
+        elsif ( $lines->[0] =~ /^\s*\?/ ) {
+            die \"YAML::Tiny does not support a feature in line '$lines->[0]'";
+        }
+        else {
+            die \"YAML::Tiny failed to classify line '$lines->[0]'";
+        }
+
+        if ( exists $hash->{$key} ) {
+            warn "YAML::Tiny found a duplicate key '$key' in line '$lines->[0]'";
+        }
+
+        # Do we have a value?
+        if ( length $lines->[0] ) {
+            # Yes
+            $hash->{$key} = $self->_load_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->_load_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->_load_hash(
+                        $hash->{$key}, [ @$indent, length($1) ], $lines
+                    );
+                }
+            }
+        }
+    }
+
+    return 1;
+}
+
+
+###
+# Dumper functions:
+
+# Save an object to a file
+sub _dump_file {
+    my $self = shift;
+
+    require Fcntl;
+
+    # Check the file
+    my $file = shift or $self->_error( 'You did not specify a file name' );
+
+    my $fh;
+    # flock if available (or warn if not possible for OS-specific reasons)
+    if ( _can_flock() ) {
+        # Open without truncation (truncate comes after lock)
+        my $flags = Fcntl::O_WRONLY()|Fcntl::O_CREAT();
+        sysopen( $fh, $file, $flags )
+            or $self->_error("Failed to open file '$file' for writing: $!");
+
+        # Use no translation and strict UTF-8
+        binmode( $fh, ":raw:encoding(UTF-8)");
+
+        flock( $fh, Fcntl::LOCK_EX() )
+            or warn "Couldn't lock '$file' for reading: $!";
+
+        # truncate and spew contents
+        truncate $fh, 0;
+        seek $fh, 0, 0;
+    }
+    else {
+        open $fh, ">:unix:encoding(UTF-8)", $file;
+    }
+
+    # serialize and spew to the handle
+    print {$fh} $self->_dump_string;
+
+    # close the file (release the lock)
+    unless ( close $fh ) {
+        $self->_error("Failed to close file '$file': $!");
+    }
+
+    return 1;
+}
+
+# Save an object to a string
+sub _dump_string {
+    my $self = shift;
+    return '' unless ref $self && @$self;
+
+    # Iterate over the documents
+    my $indent = 0;
+    my @lines  = ();
+
+    eval {
+        foreach my $cursor ( @$self ) {
+            push @lines, '---';
+
+            # An empty document
+            if ( ! defined $cursor ) {
+                # Do nothing
+
+            # A scalar document
+            } elsif ( ! ref $cursor ) {
+                $lines[-1] .= ' ' . $self->_dump_scalar( $cursor );
+
+            # A list at the root
+            } elsif ( ref $cursor eq 'ARRAY' ) {
+                unless ( @$cursor ) {
+                    $lines[-1] .= ' []';
+                    next;
+                }
+                push @lines, $self->_dump_array( $cursor, $indent, {} );
+
+            # A hash at the root
+            } elsif ( ref $cursor eq 'HASH' ) {
+                unless ( %$cursor ) {
+                    $lines[-1] .= ' {}';
+                    next;
+                }
+                push @lines, $self->_dump_hash( $cursor, $indent, {} );
+
+            } else {
+                die \("Cannot serialize " . ref($cursor));
+            }
+        }
+    };
+    if ( ref $@ eq 'SCALAR' ) {
+        $self->_error(${$@});
+    } elsif ( $@ ) {
+        $self->_error($@);
+    }
+
+    join '', map { "$_\n" } @lines;
+}
+
+sub _has_internal_string_value {
+    my $value = shift;
+    my $b_obj = B::svref_2object(\$value);  # for round trip problem
+    return $b_obj->FLAGS & B::SVf_POK();
+}
+
+sub _dump_scalar {
+    my $string = $_[1];
+    my $is_key = $_[2];
+    # Check this before checking length or it winds up looking like a string!
+    my $has_string_flag = _has_internal_string_value($string);
+    return '~'  unless defined $string;
+    return "''" unless length  $string;
+    if (Scalar::Util::looks_like_number($string)) {
+        # keys and values that have been used as strings get quoted
+        if ( $is_key || $has_string_flag ) {
+            return qq['$string'];
+        }
+        else {
+            return $string;
+        }
+    }
+    if ( $string =~ /[\x00-\x09\x0b-\x0d\x0e-\x1f\x7f-\x9f\'\n]/ ) {
+        $string =~ s/\\/\\\\/g;
+        $string =~ s/"/\\"/g;
+        $string =~ s/\n/\\n/g;
+        $string =~ s/[\x85]/\\N/g;
+        $string =~ s/([\x00-\x1f])/\\$UNPRINTABLE[ord($1)]/g;
+        $string =~ s/([\x7f-\x9f])/'\x' . sprintf("%X",ord($1))/ge;
+        return qq|"$string"|;
+    }
+    if ( $string =~ /(?:^[~!@#%&*|>?:,'"`{}\[\]]|^-+$|\s|:\z)/ or
+        $QUOTE{$string}
+    ) {
+        return "'$string'";
+    }
+    return $string;
+}
+
+sub _dump_array {
+    my ($self, $array, $indent, $seen) = @_;
+    if ( $seen->{refaddr($array)}++ ) {
+        die \"YAML::Tiny does not support circular references";
+    }
+    my @lines  = ();
+    foreach my $el ( @$array ) {
+        my $line = ('  ' x $indent) . '-';
+        my $type = ref $el;
+        if ( ! $type ) {
+            $line .= ' ' . $self->_dump_scalar( $el );
+            push @lines, $line;
+
+        } elsif ( $type eq 'ARRAY' ) {
+            if ( @$el ) {
+                push @lines, $line;
+                push @lines, $self->_dump_array( $el, $indent + 1, $seen );
+            } else {
+                $line .= ' []';
+                push @lines, $line;
+            }
+
+        } elsif ( $type eq 'HASH' ) {
+            if ( keys %$el ) {
+                push @lines, $line;
+                push @lines, $self->_dump_hash( $el, $indent + 1, $seen );
+            } else {
+                $line .= ' {}';
+                push @lines, $line;
+            }
+
+        } else {
+            die \"YAML::Tiny does not support $type references";
+        }
+    }
+
+    @lines;
+}
+
+sub _dump_hash {
+    my ($self, $hash, $indent, $seen) = @_;
+    if ( $seen->{refaddr($hash)}++ ) {
+        die \"YAML::Tiny does not support circular references";
+    }
+    my @lines  = ();
+    foreach my $name ( sort keys %$hash ) {
+        my $el   = $hash->{$name};
+        my $line = ('  ' x $indent) . $self->_dump_scalar($name, 1) . ":";
+        my $type = ref $el;
+        if ( ! $type ) {
+            $line .= ' ' . $self->_dump_scalar( $el );
+            push @lines, $line;
+
+        } elsif ( $type eq 'ARRAY' ) {
+            if ( @$el ) {
+                push @lines, $line;
+                push @lines, $self->_dump_array( $el, $indent + 1, $seen );
+            } else {
+                $line .= ' []';
+                push @lines, $line;
+            }
+
+        } elsif ( $type eq 'HASH' ) {
+            if ( keys %$el ) {
+                push @lines, $line;
+                push @lines, $self->_dump_hash( $el, $indent + 1, $seen );
+            } else {
+                $line .= ' {}';
+                push @lines, $line;
+            }
+
+        } else {
+            die \"YAML::Tiny does not support $type references";
+        }
+    }
+
+    @lines;
+}
+
+
+
+#####################################################################
+# DEPRECATED API methods:
+
+# Error storage (DEPRECATED as of 1.57)
+our $errstr    = '';
+
+# Set error
+sub _error {
+    require Carp;
+    $errstr = $_[1];
+    $errstr =~ s/ at \S+ line \d+.*//;
+    Carp::croak( $errstr );
+}
+
+# Retrieve error
+my $errstr_warned;
+sub errstr {
+    require Carp;
+    Carp::carp( "YAML::Tiny->errstr and \$YAML::Tiny::errstr is deprecated" )
+        unless $errstr_warned++;
+    $errstr;
+}
+
+
+
+
+#####################################################################
+# Helper functions. Possibly not needed.
+
+
+# Use to detect nv or iv
+use B;
+
+# XXX-INGY Is flock YAML::Tiny's responsibility?
+# Some platforms can't flock :-(
+# XXX-XDG I think it is.  When reading and writing files, we ought
+# to be locking whenever possible.  People (foolishly) use YAML
+# files for things like session storage, which has race issues.
+my $HAS_FLOCK;
+sub _can_flock {
+    if ( defined $HAS_FLOCK ) {
+        return $HAS_FLOCK;
+    }
+    else {
+        require Config;
+        my $c = \%Config::Config;
+        $HAS_FLOCK = grep { $c->{$_} } qw/d_flock d_fcntl_can_lock d_lockf/;
+        require Fcntl if $HAS_FLOCK;
+        return $HAS_FLOCK;
+    }
+}
+
+
+# XXX-INGY Is this core in 5.8.1? Can we remove this?
+# XXX-XDG Scalar::Util 1.18 didn't land until 5.8.8, so we need this
+#####################################################################
+# Use Scalar::Util if possible, otherwise emulate it
+
+use Scalar::Util ();
+BEGIN {
+    local $@;
+    if ( eval { Scalar::Util->VERSION(1.18); } ) {
+        *refaddr = *Scalar::Util::refaddr;
+    }
+    else {
+        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 { no warnings 'portable'; hex $1 };
+    bless $_[0], $pkg if defined $pkg;
+    $i;
+}
+END_PERL
+    }
+}
+
+delete $YAML::Tiny::{refaddr};
+
+1;
+
+# XXX-INGY Doc notes I'm putting up here. Changing the doc when it's wrong
+# but leaving grey area stuff up here.
+#
+# I would like to change Read/Write to Load/Dump below without
+# changing the actual API names.
+#
+# It might be better to put Load/Dump API in the SYNOPSIS instead of the
+# dubious OO API.
+#
+# null and bool explanations may be outdated.
+
+__END__
+
+#line 1487
diff --git a/Module-Install-DOAP-0.006/lib/Module/Install/Admin/DOAP.pm b/Module-Install-DOAP-0.006/lib/Module/Install/Admin/DOAP.pm
new file mode 100644
index 0000000..f2fe4e9
--- /dev/null
+++ b/Module-Install-DOAP-0.006/lib/Module/Install/Admin/DOAP.pm
@@ -0,0 +1,284 @@
+package Module::Install::Admin::DOAP;
+
+use 5.008;
+use base qw(Module::Install::Base);
+use strict;
+
+use Module::Install::Admin::RDF 0.003;
+use RDF::Trine;
+
+our $VERSION = '0.006';
+
+use RDF::Trine::Namespace qw[RDF RDFS OWL XSD];
+my $CPAN = RDF::Trine::Namespace->new('http://purl.org/NET/cpan-uri/terms#');
+my $DC   = RDF::Trine::Namespace->new('http://purl.org/dc/terms/');
+my $DOAP = RDF::Trine::Namespace->new('http://usefulinc.com/ns/doap#');
+my $DEPS = RDF::Trine::Namespace->new('http://ontologi.es/doap-deps#');
+my $FOAF = RDF::Trine::Namespace->new('http://xmlns.com/foaf/0.1/');
+my $NFO  = RDF::Trine::Namespace->new('http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#');
+my $SKOS = RDF::Trine::Namespace->new('http://www.w3.org/2004/02/skos/core#');
+
+sub doap_metadata
+{
+	my ($self, $uri) = @_;
+	
+	unless (defined $uri)
+	{
+		$uri = Module::Install::Admin::RDF::rdf_project_uri($self);
+	}
+	unless (ref $uri)
+	{
+		$uri = RDF::Trine::Node::Resource->new($uri);
+	}
+
+	my $metadata = sub {
+		$self->_top->call(@_);
+		};
+
+	my $model = Module::Install::Admin::RDF::rdf_metadata($self);
+
+	my $name;
+	NAME: foreach ($model->objects_for_predicate_list($uri, $DOAP->name, $FOAF->name, $RDFS->label))
+	{
+		next NAME unless $_->is_literal;
+		$name = $_->literal_value;
+		$metadata->(name => $_->literal_value);
+		last NAME;
+	}
+
+	my $mname;
+	MNAME: foreach ($model->objects_for_predicate_list($uri, $CPAN->module_name))
+	{
+		next MNAME unless $_->is_literal;
+		$mname = $_->literal_value;
+		$metadata->(module_name => $_->literal_value);
+		last MNAME;
+	}
+	if (defined $name and !defined $mname)
+	{
+		$mname = $name;
+		$mname =~ s/-/::/g;
+		$metadata->(module_name => $mname);
+	}
+
+	DESC: foreach ($model->objects_for_predicate_list($uri, $DOAP->shortdesc, $DC->abstract))
+	{
+		next DESC unless $_->is_literal;
+		$metadata->(abstract => $_->literal_value);
+		last DESC;
+	}
+
+	LICENSE: foreach ($model->objects_for_predicate_list($uri, $DOAP->license, $DC->license))
+	{
+		next LICENSE unless $_->is_resource;
+		
+		my $license_code = {
+			'http://www.gnu.org/licenses/agpl-3.0.txt'              => 'open_source',
+			'http://www.apache.org/licenses/LICENSE-1.1'            => 'apache_1_1',
+			'http://www.apache.org/licenses/LICENSE-2.0'            => 'apache',
+			'http://www.apache.org/licenses/LICENSE-2.0.txt'        => 'apache',
+			'http://www.perlfoundation.org/artistic_license_1_0'    => 'artistic',
+			'http://opensource.org/licenses/artistic-license.php'   => 'artistic',
+			'http://www.perlfoundation.org/artistic_license_2_0'    => 'artistic_2',
+			'http://opensource.org/licenses/artistic-license-2.0.php'  => 'artistic_2',
+			'http://www.opensource.org/licenses/bsd-license.php'    => 'bsd',
+			'http://creativecommons.org/publicdomain/zero/1.0/'     => 'unrestricted',
+			'http://www.freebsd.org/copyright/freebsd-license.html' => 'open_source',
+			'http://www.gnu.org/copyleft/fdl.html'                  => 'open_source',
+			'http://www.opensource.org/licenses/gpl-license.php'    => 'gpl',
+			'http://www.gnu.org/licenses/old-licenses/gpl-1.0.txt'  => 'gpl',
+			'http://www.opensource.org/licenses/gpl-2.0.php'        => 'gpl2',
+			'http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt'  => 'gpl2',
+			'http://www.opensource.org/licenses/gpl-3.0.html'       => 'gpl3',
+			'http://www.gnu.org/licenses/gpl-3.0.txt'               => 'gpl3',
+			'http://www.opensource.org/licenses/lgpl-license.php'   => 'lgpl',
+			'http://www.opensource.org/licenses/lgpl-2.1.php'       => 'lgpl2',
+			'http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt' => 'lgpl2',
+			'http://www.opensource.org/licenses/lgpl-3.0.html'      => 'lgpl3',
+			'http://www.gnu.org/licenses/lgpl-3.0.txt'              => 'lgpl3',
+			'http://www.opensource.org/licenses/mit-license.php'    => 'mit',
+			'http://www.mozilla.org/MPL/MPL-1.0.txt'                => 'mozilla',
+			'http://www.mozilla.org/MPL/MPL-1.1.txt'                => 'mozilla',
+			'http://opensource.org/licenses/mozilla1.1.php'         => 'mozilla',
+			'http://www.openssl.org/source/license.html'            => 'open_source',
+			'http://dev.perl.org/licenses/'                         => 'perl',
+			'http://www.opensource.org/licenses/postgresql'         => 'open_source',
+			'http://trolltech.com/products/qt/licenses/licensing/qpl'  => 'open_source',
+			'http://h71000.www7.hp.com/doc/83final/BA554_90007/apcs02.html'  => 'unrestricted',
+			'http://www.openoffice.org/licenses/sissl_license.html' => 'open_source',
+			'http://www.zlib.net/zlib_license.html'                 => 'open_source',
+			}->{ $_->uri } || undef;
+
+		$metadata->(license => $license_code);
+		last LICENSE;
+	}
+	
+	my %resources;
+	($resources{license}) = 
+		map  { $_->uri }
+		grep { $_->is_resource }
+		$model->objects_for_predicate_list($uri, $DOAP->license, $DC->license);
+	($resources{homepage}) = 
+		map  { $_->uri }
+		grep { $_->is_resource }
+		$model->objects_for_predicate_list($uri, $DOAP->homepage, $FOAF->homepage, $FOAF->page);
+	($resources{bugtracker}) = 
+		map  { $_->uri }
+		grep { $_->is_resource }
+		$model->objects($uri, $DOAP->uri('bug-database'));
+	REPO: foreach my $repo ($model->objects($uri, $DOAP->repository))
+	{
+		next REPO if $repo->is_literal;
+		($resources{repository}) = 
+			map  { $_->uri }
+			grep { $_->is_resource }
+			$model->objects($repo, $DOAP->uri('browse'));
+		last REPO if $resources{repository};
+	}
+	($resources{MailingList}) = 
+		map  { $_->uri }
+		grep { $_->is_resource }
+		$model->objects($uri, $DOAP->uri('mailing-list'));
+	($resources{Wiki}) = 
+		map  { $_->uri }
+		grep { $_->is_resource }
+		$model->objects($uri, $DOAP->uri('wiki'));
+	$metadata->(resources => %resources);
+
+	my %keywords;
+	CATEGORY: foreach my $cat ($model->objects_for_predicate_list($uri, $DOAP->category, $DC->subject))
+	{
+		if ($cat->is_literal)
+		{
+			$keywords{ uc $cat->literal_value } = $cat->literal_value;
+		}
+		else
+		{
+			LABEL: foreach my $label ($model->objects_for_predicate_list($cat, $SKOS->prefLabel, $RDFS->label, $DOAP->name, $FOAF->name))
+			{
+				next LABEL unless $label->is_literal;
+				$keywords{ uc $label->literal_value } = $label->literal_value;
+				next CATEGORY;
+			}
+		}
+	}
+	$metadata->(keywords => sort values %keywords);
+	
+	my %authors;
+	AUTHOR: foreach my $author ($model->objects_for_predicate_list($uri, $DOAP->developer, $DOAP->maintainer, $FOAF->maker, $DC->creator))
+	{
+		my ($name) =
+			map  { $_->literal_value }
+			grep { $_->is_literal }
+			$model->objects_for_predicate_list($author, $FOAF->name, $RDFS->label);
+		my ($mbox) =
+			map  { my $x = $_->uri; $x =~ s/^mailto://i; $x; }
+			grep { $_->is_resource }
+			$model->objects_for_predicate_list($author, $FOAF->mbox);
+		
+		my $str = do
+			{
+				if ($name and $mbox)
+					{ "$name <$mbox>"; }
+				elsif ($name)
+					{ $name; }
+				elsif ($mbox)
+					{ $mbox; }
+				else
+					{ "$author"; }
+			};
+		$authors{uc $str} = $str;
+	}
+	$metadata->(authors => sort values %authors);
+
+	{
+		my @terms = qw(requires build_requires configure_requires test_requires recommends provides);
+		foreach my $term (@terms)
+		{
+			foreach my $dep ($model->objects($uri, $CPAN->$term))
+			{
+				warn "$term is deprecated in favour of http://ontologi.es/doap-deps#";
+				if ($dep->is_literal)
+				{
+					my ($mod, $ver) = split /\s+/, $dep->literal_value;
+					$ver ||= 0;
+					$metadata->($term => $mod => $ver);
+				}
+				else
+				{
+					warn "Dunno what to do with ${dep}... we'll figure something out eventually.";
+				}
+			}
+		}
+	}
+
+	foreach my $phase (qw/ configure build test runtime develop /)
+	{
+		foreach my $level (qw/ requirement recommendation suggestion /)
+		{
+			my $term = "${phase}-${level}";
+			my $mi_term = {
+				'configure-requirement'  => 'configure_requires',
+				'build-requirement'      => 'build_requires',
+				'test-requirement'       => 'test_requires',
+				'runtime-requirement'    => 'requires',
+				'build-recommendation'   => 'recommends',
+				'test-recommendation'    => 'recommends',
+				'runtime-recommendation' => 'recommends',
+			}->{$term} or next;
+			
+			foreach my $dep ( $model->objects($uri, $DEPS->uri($term)) )
+			{
+				if ($dep->is_literal)
+				{
+					warn $DEPS->$term . " expects a resource, not literal $dep!";
+					next;
+				}
+				
+				foreach my $ident ( $model->objects($dep, $DEPS->on) )
+				{
+					unless ($ident->is_literal
+					and     $ident->has_datatype
+					and     $ident->literal_datatype eq $DEPS->CpanId->uri)
+					{
+						warn "Dunno what to do with ${ident}... we'll figure something out eventually.";
+						next;
+					}
+					
+					my ($mod, $ver) = split /\s+/, $ident->literal_value;
+					$ver ||= 0;
+					$metadata->($mi_term => $mod => $ver);
+				}
+			}
+		}			
+	}
+
+	{
+		my @terms = qw(abstract_from author_from license_from perl_version_from readme_from requires_from version_from
+			no_index install_script requires_external_bin);
+		TERM: foreach my $term (@terms)
+		{
+			foreach my $val ($model->objects($uri, $CPAN->$term))
+			{
+				if ($val->is_literal)
+				{
+					$metadata->($term => $val->literal_value);
+					next TERM;
+				}
+				else
+				{
+					foreach my $name ($model->objects($val, $NFO->fileName))
+					{
+						if ($name->is_literal)
+						{
+							$metadata->($term => $name->literal_value);
+							next TERM;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+1;
diff --git a/Module-Install-DOAP-0.006/meta/deps.ttl b/Module-Install-DOAP-0.006/meta/deps.ttl
new file mode 100644
index 0000000..fdb3997
--- /dev/null
+++ b/Module-Install-DOAP-0.006/meta/deps.ttl
@@ -0,0 +1,19 @@
+@prefix : <http://ontologi.es/doap-deps#> .
+
+<http://purl.org/NET/cpan-uri/dist/Module-Install-DOAP/project>
+	:runtime-requirement [
+		:on "Module::Install 1.00"^^:CpanId;
+	];
+	:runtime-requirement [
+		:on "Module::Install::RDF 0.004"^^:CpanId;
+	];
+	:runtime-requirement [
+		:on "Module::Install::Admin::RDF 0.004"^^:CpanId;
+	];
+	:runtime-requirement [
+		:on "RDF::Trine 0.133"^^:CpanId;
+	];
+	:test-requirement [
+		:on "Test::More 0.96"^^:CpanId;
+	];
+.
diff --git a/Module-Install-DOAP-0.006/meta/makefile.ttl b/Module-Install-DOAP-0.006/meta/makefile.ttl
new file mode 100644
index 0000000..923944b
--- /dev/null
+++ b/Module-Install-DOAP-0.006/meta/makefile.ttl
@@ -0,0 +1,8 @@
+@prefix : <http://purl.org/NET/cpan-uri/terms#> .
+
+<http://purl.org/NET/cpan-uri/dist/Module-Install-DOAP/project>
+	:perl_version_from _:main ;
+	:version_from _:main ;
+	:readme_from _:main .
+
+_:main <http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#fileName> "lib/Module/Install/DOAP.pm" .
diff --git a/SIGNATURE b/SIGNATURE
index de5910d..4a097d8 100644
--- a/SIGNATURE
+++ b/SIGNATURE
@@ -1,5 +1,5 @@
 This file contains message digests of all files listed in MANIFEST,
-signed via the Module::Signature module, version 0.70.
+signed via the Module::Signature module, version 0.88.
 
 To verify the content in this distribution, first make sure you have
 Module::Signature installed, then type:
@@ -12,46 +12,62 @@ the distribution may already have been compromised, and you should
 not run its Makefile.PL or Build.PL.
 
 -----BEGIN PGP SIGNED MESSAGE-----
-Hash: SHA1
+Hash: RIPEMD160
 
-SHA1 b6b6a8bb1a8a0c29a4ee492f4c47544dd12ad774 COPYRIGHT
-SHA1 47d579fe59012339100575f5eb64833086a25c39 CREDITS
-SHA1 2457eebfd5ccce8ea60133f9a5a88b53a5aaf8f6 Changes
-SHA1 937d452c5c4069f4cda9ffaf45a33f1eb5f060e8 LICENSE
-SHA1 e5d3a7d7630f0cf0cf348f6e06a31e922aedf3d8 MANIFEST
-SHA1 7f0c8ca034cdfc9df77cb031ff11cf4b93ca4407 META.ttl
-SHA1 12ad52673022bccbc74cc2620ad2bfb1beb53a67 META.yml
-SHA1 8f452dee44933e5140932f37b3094ab8993c7c16 Makefile.PL
-SHA1 bdf77536e13e031e24ea940c18047e77f63ab0bb README
-SHA1 eb3697add6a6a8660e5c3d7f042e126f618965fa TODO
-SHA1 06c410f05488c1612ed66b06d3a86b2580581e4a inc/Module/AutoInstall.pm
-SHA1 8a924add836b60fb23b25c8506d45945e02f42f4 inc/Module/Install.pm
-SHA1 61ab1dd37e33ddbe155907ce51df8a3e56ac8bbf inc/Module/Install/AutoInstall.pm
-SHA1 c04f94f91fa97b9f8cfb5a36071098ab0e6c78e3 inc/Module/Install/AutoManifest.pm
-SHA1 2d0fad3bf255f8c1e7e1e34eafccc4f595603ddc inc/Module/Install/Base.pm
-SHA1 f0e01fff7d73cd145fbf22331579918d4628ddb0 inc/Module/Install/Can.pm
-SHA1 7328966e4fda0c8451a6d3850704da0b84ac1540 inc/Module/Install/Fetch.pm
-SHA1 66d3d335a03492583a3be121a7d888f63f08412c inc/Module/Install/Include.pm
-SHA1 b62ca5e2d58fa66766ccf4d64574f9e1a2250b34 inc/Module/Install/Makefile.pm
-SHA1 1aa925be410bb3bfcd84a16985921f66073cc1d2 inc/Module/Install/Metadata.pm
-SHA1 3b9281ddf7dd6d6f5de0a9642c69333023193c80 inc/Module/Install/Package.pm
-SHA1 41f76ff6b39368a65da86377e43b34bacc2fb0eb inc/Module/Install/TrustMetaYml.pm
-SHA1 e4196994fa75e98bdfa2be0bdeeffef66de88171 inc/Module/Install/Win32.pm
-SHA1 c3a6d0d5b84feb3280622e9599e86247d58b0d18 inc/Module/Install/WriteAll.pm
-SHA1 26d58a041cd6b3d21db98b32e8fd1841aae21204 inc/Module/Package.pm
-SHA1 525571d472cd910a920155ed667e45948ecac349 inc/Module/Package/Dist/RDF.pm
-SHA1 feb933cefe2e3762e8322bd6071a2499f3440da1 inc/YAML/Tiny.pm
-SHA1 c1c7500a40fd1e608b27c27f3825d08cfc0d062a lib/Module/Install/Admin/DOAP.pm
-SHA1 6b86bd9404672f4b79b86b8ff464eae07866a040 lib/Module/Install/DOAP.pm
-SHA1 20b0df7fca20cbdee7db5994c114d9ef44b10a57 meta/changes.ttl
-SHA1 5d722d14677630d02d87687e1d72887818aca46b meta/deps.ttl
-SHA1 4723f57852e3a91da01a260da31b500722fd2b99 meta/doap.ttl
-SHA1 d17efea51d585e01d271f57beb307e288fe4a626 meta/makefile.ttl
-SHA1 ff5a2dcd4a17e0a5ca53c1b36a6291c8fe0b02c8 t/01basic.t
------BEGIN PGP SIGNATURE-----
-Version: GnuPG v1.4.12 (GNU/Linux)
-
-iEYEARECAAYFAlH47WsACgkQzr+BKGoqfTn0yQCcC/IwIG7Tp0ZQ0BH+kJ98Sq/3
-03IAnjMI76YvCCM8wpjvr+fYgMcyu0ZK
-=TEbd
------END PGP SIGNATURE-----
+SHA256 faf67a2a11bfadbbe23b795f44c363caede2283107885c9d98e164d02e55dfb5 COPYRIGHT
+SHA256 7a6dc7bc9d15d8671117c5974ab4dd48b4d9e086f977d117e3ec1b274616f337 CREDITS
+SHA256 2172e989a7fa1397c6abf721ae9688907abaa56507c47851415271ddcc030e77 Changes
+SHA256 7e013d3faa2c04d13cce9375ac89f627f883c00e58fd20fccafb0b227e878a6f LICENSE
+SHA256 3329393b6630f05f48a375e8f70220cb1e53a7c6e48ab731d82dbb00f671dcd9 MANIFEST
+SHA256 30fef381eff9b4e104be757cfcceca0e2044ea574a4b71ea30d6376c316da6a4 META.ttl
+SHA256 3f9e92cfaf36533f1d3ba9ada80906a1ca59448687972c10355afb31017db993 META.yml
+SHA256 72432bfa5229e079bdb54012301318a9e864ba12a8ba79d8844c2c6ebd162d9a Makefile.PL
+SHA256 7a6dc7bc9d15d8671117c5974ab4dd48b4d9e086f977d117e3ec1b274616f337 Module-Install-DOAP-0.006/CREDITS
+SHA256 2172e989a7fa1397c6abf721ae9688907abaa56507c47851415271ddcc030e77 Module-Install-DOAP-0.006/Changes
+SHA256 7e013d3faa2c04d13cce9375ac89f627f883c00e58fd20fccafb0b227e878a6f Module-Install-DOAP-0.006/LICENSE
+SHA256 d4156506c3610cb5c2448f8806a2e9513e5f30b09953c6e50e2b412ffe36dd11 Module-Install-DOAP-0.006/MANIFEST
+SHA256 3f9e92cfaf36533f1d3ba9ada80906a1ca59448687972c10355afb31017db993 Module-Install-DOAP-0.006/META.yml
+SHA256 72432bfa5229e079bdb54012301318a9e864ba12a8ba79d8844c2c6ebd162d9a Module-Install-DOAP-0.006/Makefile.PL
+SHA256 34d385cc69a3f8cd102c316565701db57903ee84807a8fffa9026a96e804c374 Module-Install-DOAP-0.006/TODO
+SHA256 7fe8013fad8ecb0b9ef8bad3fd7287486c1c61c776f76beb7d9d24e06ee3ab44 Module-Install-DOAP-0.006/inc/Module/AutoInstall.pm
+SHA256 67d139199c03b8bf8447a5a62f0d0b6dc1bd5bf6dbe04de6d21998c577823ed6 Module-Install-DOAP-0.006/inc/Module/Install.pm
+SHA256 6ebcc53a161dd5dc0aae69e4704575f2b00181901d768a82e26722a309cfdbe4 Module-Install-DOAP-0.006/inc/Module/Install/Base.pm
+SHA256 d3f8c839d03fd21c197d05362dbb277cd7cadb15da6390d124b61e851f15146e Module-Install-DOAP-0.006/inc/Module/Install/Can.pm
+SHA256 e9e72e18921c10c87bc4ea4c20af83e52015b9f5775d00ac64073042403717ca Module-Install-DOAP-0.006/inc/Module/Install/Fetch.pm
+SHA256 a97bf661b739643c3adee064addf7a85f22e25e1bbffc137974cd8754ffa5c66 Module-Install-DOAP-0.006/inc/Module/Install/Include.pm
+SHA256 aa887fa65a5eb6bbd1805706ce298b3f3cd55b353ecfd37aa7d35ae419331a49 Module-Install-DOAP-0.006/inc/Module/Install/Metadata.pm
+SHA256 4f3968e504200c6456f6dd41d3cd24e5366a4848042dc2cb7c346c3165ef3e25 Module-Install-DOAP-0.006/inc/Module/Install/Package.pm
+SHA256 10b9bb7cebcfe617d71f30b31a0a390a72336881ea20ee48826501550c2fe716 Module-Install-DOAP-0.006/inc/Module/Install/TrustMetaYml.pm
+SHA256 5f73a6851a91ea44e65b924f918743ad6e860620ad7a38a39d0295e0c5652a9f Module-Install-DOAP-0.006/inc/Module/Install/WriteAll.pm
+SHA256 59d9db60b1bf7e664805b8c573df7a4009b975dd003046468817e44d04847940 Module-Install-DOAP-0.006/inc/Module/Package.pm
+SHA256 b166ff639e047174c108ab048e9bdc2b0cb8f64441c8b683c34bde60442b6818 Module-Install-DOAP-0.006/inc/Module/Package/Dist/RDF.pm
+SHA256 3164c32202bf4604ab1f90b926a81e15493b191e0bc2f90ae42d8358f18259d6 Module-Install-DOAP-0.006/inc/YAML/Tiny.pm
+SHA256 65fb1f3fda60799a0540ba02dcc1eb89cfd1394ee7322e42d2ac7e0eb9209881 Module-Install-DOAP-0.006/lib/Module/Install/Admin/DOAP.pm
+SHA256 5a9015f0cfa366e6741e913ea0a105f5505ed217ce4345f0546347f7b0a2273d Module-Install-DOAP-0.006/meta/deps.ttl
+SHA256 03bbaa7569afe405e155b778feef5e6c982e53b79af5f887a93cbcedfd5bd16e Module-Install-DOAP-0.006/meta/makefile.ttl
+SHA256 abcfe4051d733052361ef777ae9d99c72c96a05013c259cd58f9db9baaed343d README
+SHA256 34d385cc69a3f8cd102c316565701db57903ee84807a8fffa9026a96e804c374 TODO
+SHA256 7fe8013fad8ecb0b9ef8bad3fd7287486c1c61c776f76beb7d9d24e06ee3ab44 inc/Module/AutoInstall.pm
+SHA256 67d139199c03b8bf8447a5a62f0d0b6dc1bd5bf6dbe04de6d21998c577823ed6 inc/Module/Install.pm
+SHA256 1e48ae2cb24e1d16193d476e735579dfcd0eefb3685921ad4736390df75d939b inc/Module/Install/AutoInstall.pm
+SHA256 5ba8a77513f5cf4e60d0e84bd64c1b8316b23d74af42272ac528a4dd1609b708 inc/Module/Install/AutoManifest.pm
+SHA256 6ebcc53a161dd5dc0aae69e4704575f2b00181901d768a82e26722a309cfdbe4 inc/Module/Install/Base.pm
+SHA256 d3f8c839d03fd21c197d05362dbb277cd7cadb15da6390d124b61e851f15146e inc/Module/Install/Can.pm
+SHA256 e9e72e18921c10c87bc4ea4c20af83e52015b9f5775d00ac64073042403717ca inc/Module/Install/Fetch.pm
+SHA256 a97bf661b739643c3adee064addf7a85f22e25e1bbffc137974cd8754ffa5c66 inc/Module/Install/Include.pm
+SHA256 a7a681bf2c9eee58a372cb642ffe42b0301d1200432ba8de9f7791cd1ecc9827 inc/Module/Install/Makefile.pm
+SHA256 aa887fa65a5eb6bbd1805706ce298b3f3cd55b353ecfd37aa7d35ae419331a49 inc/Module/Install/Metadata.pm
+SHA256 4f3968e504200c6456f6dd41d3cd24e5366a4848042dc2cb7c346c3165ef3e25 inc/Module/Install/Package.pm
+SHA256 10b9bb7cebcfe617d71f30b31a0a390a72336881ea20ee48826501550c2fe716 inc/Module/Install/TrustMetaYml.pm
+SHA256 26b166ff62aacdb55317d1659f160aa4935097eea9810ea980e6d747206b5dc0 inc/Module/Install/Win32.pm
+SHA256 5f73a6851a91ea44e65b924f918743ad6e860620ad7a38a39d0295e0c5652a9f inc/Module/Install/WriteAll.pm
+SHA256 59d9db60b1bf7e664805b8c573df7a4009b975dd003046468817e44d04847940 inc/Module/Package.pm
+SHA256 b166ff639e047174c108ab048e9bdc2b0cb8f64441c8b683c34bde60442b6818 inc/Module/Package/Dist/RDF.pm
+SHA256 3164c32202bf4604ab1f90b926a81e15493b191e0bc2f90ae42d8358f18259d6 inc/YAML/Tiny.pm
+SHA256 65fb1f3fda60799a0540ba02dcc1eb89cfd1394ee7322e42d2ac7e0eb9209881 lib/Module/Install/Admin/DOAP.pm
+SHA256 a7a9d0bf114e495387065997c96b63fbcf5e52fa7ced1f821b0549de055e6426 lib/Module/Install/DOAP.pm
+SHA256 dd78a4b0a0524c17e13474ab624652d35f3e86f0a75bdbcbb6cf3fd9b6d11320 meta/changes.ttl
+SHA256 5a9015f0cfa366e6741e913ea0a105f5505ed217ce4345f0546347f7b0a2273d meta/deps.ttl
+SHA256 4f1548f0cbb26f959201291898cf94da0abe358f4f4cea8734ae824c170ba77e meta/doap.ttl
+SHA256 03bbaa7569afe405e155b778feef5e6c982e53b79af5f887a93cbcedfd5bd16e meta/makefile.ttl
+SHA256 0c0f1cd5f7afcd77812c56cfe3292267f903960bb864649bc4755f235faae57d t/01basic.t
diff --git a/debian/changelog b/debian/changelog
index 3e19686..cf0f83b 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,4 +1,4 @@
-libmodule-install-doap-perl (0.006-2) UNRELEASED; urgency=medium
+libmodule-install-doap-perl (0.006+git20130807.1.3df265c-1) UNRELEASED; urgency=medium
 
   [ Salvatore Bonaccorso ]
   * Update Vcs-Browser URL to cgit web frontend
@@ -13,8 +13,9 @@ libmodule-install-doap-perl (0.006-2) UNRELEASED; urgency=medium
   * Set upstream metadata fields: Bug-Database, Repository, Repository-
     Browse.
   * Set Testsuite header for perl package.
+  * New upstream snapshot.
 
- -- Salvatore Bonaccorso <carnil@debian.org>  Sat, 16 Aug 2014 09:33:14 +0200
+ -- Salvatore Bonaccorso <carnil@debian.org>  Fri, 15 Apr 2022 11:58:20 -0000
 
 libmodule-install-doap-perl (0.006-1.1) unstable; urgency=medium
 
diff --git a/inc/Module/AutoInstall.pm b/inc/Module/AutoInstall.pm
index aa7aa92..8852e0b 100644
--- a/inc/Module/AutoInstall.pm
+++ b/inc/Module/AutoInstall.pm
@@ -8,7 +8,7 @@ use ExtUtils::MakeMaker ();
 
 use vars qw{$VERSION};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 }
 
 # special map on pre-defined feature sets
@@ -115,7 +115,7 @@ sub import {
     print "*** $class version " . $class->VERSION . "\n";
     print "*** Checking for Perl dependencies...\n";
 
-    my $cwd = Cwd::cwd();
+    my $cwd = Cwd::getcwd();
 
     $Config = [];
 
@@ -166,7 +166,7 @@ sub import {
         $modules = [ %{$modules} ] if UNIVERSAL::isa( $modules, 'HASH' );
 
         unshift @$modules, -default => &{ shift(@$modules) }
-          if ( ref( $modules->[0] ) eq 'CODE' );    # XXX: bugward combatability
+          if ( ref( $modules->[0] ) eq 'CODE' );    # XXX: bugward compatibility
 
         while ( my ( $mod, $arg ) = splice( @$modules, 0, 2 ) ) {
             if ( $mod =~ m/^-(\w+)$/ ) {
@@ -345,22 +345,26 @@ sub install {
     my $i;    # used below to strip leading '-' from config keys
     my @config = ( map { s/^-// if ++$i; $_ } @{ +shift } );
 
-    my ( @modules, @installed );
-    while ( my ( $pkg, $ver ) = splice( @_, 0, 2 ) ) {
+	my ( @modules, @installed, @modules_to_upgrade );
+	while (my ($pkg, $ver) = splice(@_, 0, 2)) {
 
-        # grep out those already installed
-        if ( _version_cmp( _version_of($pkg), $ver ) >= 0 ) {
-            push @installed, $pkg;
-        }
-        else {
-            push @modules, $pkg, $ver;
-        }
-    }
+		# grep out those already installed
+		if (_version_cmp(_version_of($pkg), $ver) >= 0) {
+			push @installed, $pkg;
+			if ($UpgradeDeps) {
+				push @modules_to_upgrade, $pkg, $ver;
+			}
+		}
+		else {
+			push @modules, $pkg, $ver;
+		}
+	}
 
-    if ($UpgradeDeps) {
-        push @modules, @installed;
-        @installed = ();
-    }
+	if ($UpgradeDeps) {
+		push @modules, @modules_to_upgrade;
+		@installed          = ();
+		@modules_to_upgrade = ();
+	}
 
     return @installed unless @modules;  # nothing to do
     return @installed if _check_lock(); # defer to the CPAN shell
@@ -533,7 +537,7 @@ sub _install_cpan {
     while ( my ( $opt, $arg ) = splice( @config, 0, 2 ) ) {
         ( $args{$opt} = $arg, next )
           if $opt =~ /^(?:force|notest)$/;    # pseudo-option
-        $CPAN::Config->{$opt} = $arg;
+        $CPAN::Config->{$opt} = $opt eq 'urllist' ? [$arg] : $arg;
     }
 
     if ($args{notest} && (not CPAN::Shell->can('notest'))) {
@@ -611,7 +615,7 @@ sub _under_cpan {
     require Cwd;
     require File::Spec;
 
-    my $cwd  = File::Spec->canonpath( Cwd::cwd() );
+    my $cwd  = File::Spec->canonpath( Cwd::getcwd() );
     my $cpan = File::Spec->canonpath( $CPAN::Config->{cpan_home} );
 
     return ( index( $cwd, $cpan ) > -1 );
@@ -927,4 +931,4 @@ END_MAKE
 
 __END__
 
-#line 1193
+#line 1197
diff --git a/inc/Module/Install.pm b/inc/Module/Install.pm
index 4ecf46b..7ba98c2 100644
--- a/inc/Module/Install.pm
+++ b/inc/Module/Install.pm
@@ -17,7 +17,7 @@ package Module::Install;
 #     3. The ./inc/ version of Module::Install loads
 # }
 
-use 5.005;
+use 5.006;
 use strict 'vars';
 use Cwd        ();
 use File::Find ();
@@ -31,7 +31,7 @@ BEGIN {
 	# This is not enforced yet, but will be some time in the next few
 	# releases once we can make sure it won't clash with custom
 	# Module::Install extensions.
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 
 	# Storage for the pseudo-singleton
 	$MAIN    = undef;
@@ -156,10 +156,10 @@ END_DIE
 sub autoload {
 	my $self = shift;
 	my $who  = $self->_caller;
-	my $cwd  = Cwd::cwd();
+	my $cwd  = Cwd::getcwd();
 	my $sym  = "${who}::AUTOLOAD";
 	$sym->{$cwd} = sub {
-		my $pwd = Cwd::cwd();
+		my $pwd = Cwd::getcwd();
 		if ( my $code = $sym->{$pwd} ) {
 			# Delegate back to parent dirs
 			goto &$code unless $cwd eq $pwd;
@@ -239,11 +239,13 @@ sub new {
 
 	# ignore the prefix on extension modules built from top level.
 	my $base_path = Cwd::abs_path($FindBin::Bin);
-	unless ( Cwd::abs_path(Cwd::cwd()) eq $base_path ) {
+	unless ( Cwd::abs_path(Cwd::getcwd()) eq $base_path ) {
 		delete $args{prefix};
 	}
 	return $args{_self} if $args{_self};
 
+	$base_path = VMS::Filespec::unixify($base_path) if $^O eq 'VMS';
+
 	$args{dispatch} ||= 'Admin';
 	$args{prefix}   ||= 'inc';
 	$args{author}   ||= ($^O eq 'VMS' ? '_author' : '.author');
@@ -322,7 +324,7 @@ sub find_extensions {
 	my ($self, $path) = @_;
 
 	my @found;
-	File::Find::find( sub {
+	File::Find::find( {no_chdir => 1, wanted => sub {
 		my $file = $File::Find::name;
 		return unless $file =~ m!^\Q$path\E/(.+)\.pm\Z!is;
 		my $subpath = $1;
@@ -336,9 +338,9 @@ sub find_extensions {
 		# correctly.  Otherwise, root through the file to locate the case-preserved
 		# version of the package name.
 		if ( $subpath eq lc($subpath) || $subpath eq uc($subpath) ) {
-			my $content = Module::Install::_read($subpath . '.pm');
+			my $content = Module::Install::_read($File::Find::name);
 			my $in_pod  = 0;
-			foreach ( split //, $content ) {
+			foreach ( split /\n/, $content ) {
 				$in_pod = 1 if /^=\w/;
 				$in_pod = 0 if /^=cut/;
 				next if ($in_pod || /^=cut/);  # skip pod text
@@ -351,7 +353,7 @@ sub find_extensions {
 		}
 
 		push @found, [ $file, $pkg ];
-	}, $path ) if -d $path;
+	}}, $path ) if -d $path;
 
 	@found;
 }
@@ -373,24 +375,14 @@ sub _caller {
 	return $call;
 }
 
-# Done in evals to avoid confusing Perl::MinimumVersion
-eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@;
 sub _read {
 	local *FH;
 	open( FH, '<', $_[0] ) or die "open($_[0]): $!";
+	binmode FH;
 	my $string = do { local $/; <FH> };
 	close FH or die "close($_[0]): $!";
 	return $string;
 }
-END_NEW
-sub _read {
-	local *FH;
-	open( FH, "< $_[0]"  ) or die "open($_[0]): $!";
-	my $string = do { local $/; <FH> };
-	close FH or die "close($_[0]): $!";
-	return $string;
-}
-END_OLD
 
 sub _readperl {
 	my $string = Module::Install::_read($_[0]);
@@ -411,30 +403,19 @@ sub _readpod {
 	return $string;
 }
 
-# Done in evals to avoid confusing Perl::MinimumVersion
-eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@;
 sub _write {
 	local *FH;
 	open( FH, '>', $_[0] ) or die "open($_[0]): $!";
+	binmode FH;
 	foreach ( 1 .. $#_ ) {
 		print FH $_[$_] or die "print($_[0]): $!";
 	}
 	close FH or die "close($_[0]): $!";
 }
-END_NEW
-sub _write {
-	local *FH;
-	open( FH, "> $_[0]"  ) or die "open($_[0]): $!";
-	foreach ( 1 .. $#_ ) {
-		print FH $_[$_] or die "print($_[0]): $!";
-	}
-	close FH or die "close($_[0]): $!";
-}
-END_OLD
 
 # _version is for processing module versions (eg, 1.03_05) not
 # Perl versions (eg, 5.8.1).
-sub _version ($) {
+sub _version {
 	my $s = shift || 0;
 	my $d =()= $s =~ /(\.)/g;
 	if ( $d >= 2 ) {
@@ -450,12 +431,12 @@ sub _version ($) {
 	return $l + 0;
 }
 
-sub _cmp ($$) {
+sub _cmp {
 	_version($_[1]) <=> _version($_[2]);
 }
 
 # Cloned from Params::Util::_CLASS
-sub _CLASS ($) {
+sub _CLASS {
 	(
 		defined $_[0]
 		and
diff --git a/inc/Module/Install/AutoInstall.pm b/inc/Module/Install/AutoInstall.pm
index 6efe4fe..0e3dada 100644
--- a/inc/Module/Install/AutoInstall.pm
+++ b/inc/Module/Install/AutoInstall.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 	@ISA     = 'Module::Install::Base';
 	$ISCORE  = 1;
 }
diff --git a/inc/Module/Install/Base.pm b/inc/Module/Install/Base.pm
index 802844a..9fa42c2 100644
--- a/inc/Module/Install/Base.pm
+++ b/inc/Module/Install/Base.pm
@@ -4,7 +4,7 @@ package Module::Install::Base;
 use strict 'vars';
 use vars qw{$VERSION};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 }
 
 # Suspend handler for "redefined" warnings
diff --git a/inc/Module/Install/Can.pm b/inc/Module/Install/Can.pm
index 22167b8..d65c753 100644
--- a/inc/Module/Install/Can.pm
+++ b/inc/Module/Install/Can.pm
@@ -8,7 +8,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 	@ISA     = 'Module::Install::Base';
 	$ISCORE  = 1;
 }
@@ -121,6 +121,15 @@ END_C
 # Can we locate a (the) C compiler
 sub can_cc {
 	my $self   = shift;
+
+	if ($^O eq 'VMS') {
+		require ExtUtils::CBuilder;
+		my $builder = ExtUtils::CBuilder->new(
+		quiet => 1,
+		);
+		return $builder->have_compiler;
+	}
+
 	my @chunks = split(/ /, $Config::Config{cc}) or return;
 
 	# $Config{cc} may contain args; try to find out the program part
@@ -151,4 +160,4 @@ if ( $^O eq 'cygwin' ) {
 
 __END__
 
-#line 236
+#line 245
diff --git a/inc/Module/Install/Fetch.pm b/inc/Module/Install/Fetch.pm
index bee0c4f..3072b08 100644
--- a/inc/Module/Install/Fetch.pm
+++ b/inc/Module/Install/Fetch.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 	@ISA     = 'Module::Install::Base';
 	$ISCORE  = 1;
 }
diff --git a/inc/Module/Install/Include.pm b/inc/Module/Install/Include.pm
index 8310e4c..13fdcd0 100644
--- a/inc/Module/Install/Include.pm
+++ b/inc/Module/Install/Include.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 	@ISA     = 'Module::Install::Base';
 	$ISCORE  = 1;
 }
diff --git a/inc/Module/Install/Makefile.pm b/inc/Module/Install/Makefile.pm
index 7052f36..13a4464 100644
--- a/inc/Module/Install/Makefile.pm
+++ b/inc/Module/Install/Makefile.pm
@@ -8,7 +8,7 @@ use Fcntl qw/:flock :seek/;
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 	@ISA     = 'Module::Install::Base';
 	$ISCORE  = 1;
 }
@@ -133,7 +133,7 @@ sub makemaker_args {
 	return $args;
 }
 
-# For mm args that take multiple space-seperated args,
+# For mm args that take multiple space-separated args,
 # append an argument to the current list.
 sub makemaker_append {
 	my $self = shift;
diff --git a/inc/Module/Install/Metadata.pm b/inc/Module/Install/Metadata.pm
index 58430f3..11bf971 100644
--- a/inc/Module/Install/Metadata.pm
+++ b/inc/Module/Install/Metadata.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 	@ISA     = 'Module::Install::Base';
 	$ISCORE  = 1;
 }
@@ -347,7 +347,7 @@ sub name_from {
 		^ \s*
 		package \s*
 		([\w:]+)
-		\s* ;
+		[\s|;]*
 		/ixms
 	) {
 		my ($name, $module_name) = ($1, $1);
@@ -705,7 +705,7 @@ sub _write_mymeta_data {
 	my @yaml = Parse::CPAN::Meta::LoadFile('META.yml');
 	my $meta = $yaml[0];
 
-	# Overwrite the non-configure dependency hashs
+	# Overwrite the non-configure dependency hashes
 	delete $meta->{requires};
 	delete $meta->{build_requires};
 	delete $meta->{recommends};
diff --git a/inc/Module/Install/Win32.pm b/inc/Module/Install/Win32.pm
index eeaa3fe..f7aa615 100644
--- a/inc/Module/Install/Win32.pm
+++ b/inc/Module/Install/Win32.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 	@ISA     = 'Module::Install::Base';
 	$ISCORE  = 1;
 }
diff --git a/inc/Module/Install/WriteAll.pm b/inc/Module/Install/WriteAll.pm
index 85d8018..2db861a 100644
--- a/inc/Module/Install/WriteAll.pm
+++ b/inc/Module/Install/WriteAll.pm
@@ -6,7 +6,7 @@ use Module::Install::Base ();
 
 use vars qw{$VERSION @ISA $ISCORE};
 BEGIN {
-	$VERSION = '1.06';
+	$VERSION = '1.19';
 	@ISA     = qw{Module::Install::Base};
 	$ISCORE  = 1;
 }
diff --git a/inc/Module/Package/Dist/RDF.pm b/inc/Module/Package/Dist/RDF.pm
index 0ef32aa..69df1ee 100644
--- a/inc/Module/Package/Dist/RDF.pm
+++ b/inc/Module/Package/Dist/RDF.pm
@@ -11,7 +11,7 @@ use strict;
 
 BEGIN {
 	$Module::Package::Dist::RDF::AUTHORITY = 'cpan:TOBYINK';
-	$Module::Package::Dist::RDF::VERSION   = '0.013';
+	$Module::Package::Dist::RDF::VERSION   = '0.014';
 	@Module::Package::Dist::RDF::ISA       = 'Module::Package::Dist';
 }
 
@@ -19,7 +19,8 @@ sub _main
 {
 	my ($self) = @_;
 	$self->mi->trust_meta_yml;
-	$self->mi->auto_install;
+	$self->mi->auto_install
+		unless $ENV{NO_AUTO_INSTALL};
 }
 
 {
@@ -28,7 +29,7 @@ sub _main
 	use strict;
 	BEGIN {
 		$Module::Package::Dist::RDF::standard::AUTHORITY = 'cpan:TOBYINK';
-		$Module::Package::Dist::RDF::standard::VERSION   = '0.013';
+		$Module::Package::Dist::RDF::standard::VERSION   = '0.014';
 		@Module::Package::Dist::RDF::standard::ISA       = 'Module::Package::Dist::RDF';
 	}
 }
@@ -39,7 +40,7 @@ sub _main
 	use strict;
 	BEGIN {
 		$Module::Package::Dist::RDF::tobyink::AUTHORITY = 'cpan:TOBYINK';
-		$Module::Package::Dist::RDF::tobyink::VERSION   = '0.013';
+		$Module::Package::Dist::RDF::tobyink::VERSION   = '0.014';
 		@Module::Package::Dist::RDF::tobyink::ISA       = 'Module::Package::Dist::RDF';
 	}
 }
diff --git a/inc/YAML/Tiny.pm b/inc/YAML/Tiny.pm
index c0c2a22..fb157a6 100644
--- a/inc/YAML/Tiny.pm
+++ b/inc/YAML/Tiny.pm
@@ -1,643 +1,872 @@
 #line 1
-package YAML::Tiny;
-
+use 5.008001; # sane UTF-8 support
 use strict;
+use warnings;
+package YAML::Tiny; # git description: v1.72-7-g8682f63
+# XXX-INGY is 5.8.1 too old/broken for utf8?
+# XXX-XDG Lancaster consensus was that it was sufficient until
+# proven otherwise
+
+our $VERSION = '1.73';
+
+#####################################################################
+# The YAML::Tiny API.
+#
+# These are the currently documented API functions/methods and
+# exports:
+
+use Exporter;
+our @ISA       = qw{ Exporter  };
+our @EXPORT    = qw{ Load Dump };
+our @EXPORT_OK = qw{ LoadFile DumpFile freeze thaw };
+
+###
+# Functional/Export API:
+
+sub Dump {
+    return YAML::Tiny->new(@_)->_dump_string;
+}
+
+# XXX-INGY Returning last document seems a bad behavior.
+# XXX-XDG I think first would seem more natural, but I don't know
+# that it's worth changing now
+sub Load {
+    my $self = YAML::Tiny->_load_string(@_);
+    if ( wantarray ) {
+        return @$self;
+    } else {
+        # To match YAML.pm, return the last document
+        return $self->[-1];
+    }
+}
 
-# UTF Support?
-sub HAVE_UTF8 () { $] >= 5.007003 }
+# XXX-INGY Do we really need freeze and thaw?
+# XXX-XDG I don't think so.  I'd support deprecating them.
 BEGIN {
-	if ( HAVE_UTF8 ) {
-		# The string eval helps hide this from Test::MinimumVersion
-		eval "require utf8;";
-		die "Failed to load UTF-8 support" if $@;
-	}
-
-	# Class structure
-	require 5.004;
-	require Exporter;
-	require Carp;
-	$YAML::Tiny::VERSION   = '1.51';
-	# $YAML::Tiny::VERSION   = eval $YAML::Tiny::VERSION;
-	@YAML::Tiny::ISA       = qw{ Exporter  };
-	@YAML::Tiny::EXPORT    = qw{ Load Dump };
-	@YAML::Tiny::EXPORT_OK = qw{ LoadFile DumpFile freeze thaw };
-
-	# Error storage
-	$YAML::Tiny::errstr    = '';
+    *freeze = \&Dump;
+    *thaw   = \&Load;
 }
 
-# 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]';
+sub DumpFile {
+    my $file = shift;
+    return YAML::Tiny->new(@_)->_dump_file($file);
+}
+
+sub LoadFile {
+    my $file = shift;
+    my $self = YAML::Tiny->_load_file($file);
+    if ( wantarray ) {
+        return @$self;
+    } else {
+        # Return only the last document to match YAML.pm,
+        return $self->[-1];
+    }
+}
+
+
+###
+# Object Oriented API:
+
+# Create an empty YAML::Tiny object
+# XXX-INGY Why do we use ARRAY object?
+# NOTE: I get it now, but I think it's confusing and not needed.
+# Will change it on a branch later, for review.
+#
+# XXX-XDG I don't support changing it yet.  It's a very well-documented
+# "API" of YAML::Tiny.  I'd support deprecating it, but Adam suggested
+# we not change it until YAML.pm's own OO API is established so that
+# users only have one API change to digest, not two
+sub new {
+    my $class = shift;
+    bless [ @_ ], $class;
+}
+
+# XXX-INGY It probably doesn't matter, and it's probably too late to
+# change, but 'read/write' are the wrong names. Read and Write
+# are actions that take data from storage to memory
+# characters/strings. These take the data to/from storage to native
+# Perl objects, which the terms dump and load are meant. As long as
+# this is a legacy quirk to YAML::Tiny it's ok, but I'd prefer not
+# to add new {read,write}_* methods to this API.
+
+sub read_string {
+    my $self = shift;
+    $self->_load_string(@_);
+}
+
+sub write_string {
+    my $self = shift;
+    $self->_dump_string(@_);
+}
+
+sub read {
+    my $self = shift;
+    $self->_load_file(@_);
+}
+
+sub write {
+    my $self = shift;
+    $self->_dump_file(@_);
+}
+
+
+
+
+#####################################################################
+# Constants
 
 # 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
+    0    x01  x02  x03  x04  x05  x06  a
+    b    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", '\\' => '\\',
+    0 => "\x00", z => "\x00", N    => "\x85",
+    a => "\x07", b => "\x08", t    => "\x09",
+    n => "\x0a", v => "\x0b", f    => "\x0c",
+    r => "\x0d", e => "\x1b", '\\' => '\\',
 );
 
-# Special magic boolean words
+# XXX-INGY
+# I(ngy) need to decide if these values should be quoted in
+# YAML::Tiny or not. Probably yes.
+
+# These 3 values have special meaning when unquoted and using the
+# default YAML schema. They need quotes if they are strings.
 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
+    null true false
 };
 
+# 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.
+# qr/\"((?:\\.|[^\"])*)\"/
+my $re_capture_double_quoted = qr/\"([^\\"]*(?:\\.[^\\"]*)*)\"/;
+my $re_capture_single_quoted = qr/\'([^\']*(?:\'\'[^\']*)*)\'/;
+# unquoted re gets trailing space that needs to be stripped
+my $re_capture_unquoted_key  = qr/([^:]+(?::+\S(?:[^:]*|.*?(?=:)))*)(?=\s*\:(?:\s+|$))/;
+my $re_trailing_comment      = qr/(?:\s+\#.*)?/;
+my $re_key_value_separator   = qr/\s*:(?:\s+(?:\#.*)?|$)/;
+
 
 
 
 
 #####################################################################
-# Implementation
+# YAML::Tiny Implementation.
+#
+# These are the private methods that do all the work. They may change
+# at any time.
 
-# Create an empty YAML::Tiny object
-sub new {
-	my $class = shift;
-	bless [ @_ ], $class;
-}
+
+###
+# Loader functions:
 
 # 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 = <CFG>;
-	unless ( close(CFG) ) {
-		return $class->_error("Failed to close file '$file': $!");
-	}
-
-	$class->read_string( $contents );
+sub _load_file {
+    my $class = ref $_[0] ? ref shift : shift;
+
+    # Check the file
+    my $file = shift or $class->_error( 'You did not specify a file name' );
+    $class->_error( "File '$file' does not exist" )
+        unless -e $file;
+    $class->_error( "'$file' is a directory, not a file" )
+        unless -f _;
+    $class->_error( "Insufficient permissions to read '$file'" )
+        unless -r _;
+
+    # Open unbuffered with strict UTF-8 decoding and no translation layers
+    open( my $fh, "<:unix:encoding(UTF-8)", $file );
+    unless ( $fh ) {
+        $class->_error("Failed to open file '$file': $!");
+    }
+
+    # flock if available (or warn if not possible for OS-specific reasons)
+    if ( _can_flock() ) {
+        flock( $fh, Fcntl::LOCK_SH() )
+            or warn "Couldn't lock '$file' for reading: $!";
+    }
+
+    # slurp the contents
+    my $contents = eval {
+        use warnings FATAL => 'utf8';
+        local $/;
+        <$fh>
+    };
+    if ( my $err = $@ ) {
+        $class->_error("Error reading from file '$file': $err");
+    }
+
+    # close the file (release the lock)
+    unless ( close $fh ) {
+        $class->_error("Failed to close file '$file': $!");
+    }
+
+    $class->_load_string( $contents );
 }
 
 # Create an object from a string
-sub read_string {
-	my $class  = ref $_[0] ? ref shift : shift;
-	my $self   = bless [], $class;
-	my $string = $_[0];
-	eval {
-		unless ( defined $string ) {
-			die \"Did not provide a string to load";
-		}
-
-		# Byte order marks
-		# NOTE: Keeping this here to educate maintainers
-		# my %BOM = (
-		#     "\357\273\277" => 'UTF-8',
-		#     "\376\377"     => 'UTF-16BE',
-		#     "\377\376"     => 'UTF-16LE',
-		#     "\377\376\0\0" => 'UTF-32LE'
-		#     "\0\0\376\377" => 'UTF-32BE',
-		# );
-		if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
-			die \"Stream has a non UTF-8 BOM";
-		} else {
-			# Strip UTF-8 bom if found, we'll just ignore it
-			$string =~ s/^\357\273\277//;
-		}
-
-		# Try to decode as utf8
-		utf8::decode($string) if HAVE_UTF8;
-
-		# Check for some special cases
-		return $self unless length $string;
-		unless ( $string =~ /[\012\015]+\z/ ) {
-			die \"Stream does not end with newline character";
-		}
-
-		# Split the file into lines
-		my @lines = grep { ! /^\s*(?:\#.*)?\z/ }
-			    split /(?:\015{1,2}\012|\015|\012)/, $string;
-
-		# Strip the initial YAML header
-		@lines and $lines[0] =~ /^\%YAML[: ][\d\.]+.*\z/ and shift @lines;
-
-		# A nibbling parser
-		while ( @lines ) {
-			# Do we have a document header?
-			if ( $lines[0] =~ /^---\s*(?:(.+)\s*)?\z/ ) {
-				# Handle scalar documents
-				shift @lines;
-				if ( defined $1 and $1 !~ /^(?:\#.+|\%YAML[: ][\d\.]+)\z/ ) {
-					push @$self, $self->_read_scalar( "$1", [ undef ], \@lines );
-					next;
-				}
-			}
-
-			if ( ! @lines or $lines[0] =~ /^(?:---|\.\.\.)/ ) {
-				# A naked document
-				push @$self, undef;
-				while ( @lines and $lines[0] !~ /^---/ ) {
-					shift @lines;
-				}
-
-			} elsif ( $lines[0] =~ /^\s*\-/ ) {
-				# An array at the root
-				my $document = [ ];
-				push @$self, $document;
-				$self->_read_array( $document, [ 0 ], \@lines );
-
-			} elsif ( $lines[0] =~ /^(\s*)\S/ ) {
-				# A hash at the root
-				my $document = { };
-				push @$self, $document;
-				$self->_read_hash( $document, [ length($1) ], \@lines );
-
-			} else {
-				die \"YAML::Tiny failed to classify the line '$lines[0]'";
-			}
-		}
-	};
-	if ( ref $@ eq 'SCALAR' ) {
-		return $self->_error(${$@});
-	} elsif ( $@ ) {
-		require Carp;
-		Carp::croak($@);
-	}
-
-	return $self;
+sub _load_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";
+        }
+
+        # Check if Perl has it marked as characters, but it's internally
+        # inconsistent.  E.g. maybe latin1 got read on a :utf8 layer
+        if ( utf8::is_utf8($string) && ! utf8::valid($string) ) {
+            die \<<'...';
+Read an invalid UTF-8 string (maybe mixed UTF-8 and 8-bit character set).
+Did you decode with lax ":utf8" instead of strict ":encoding(UTF-8)"?
+...
+        }
+
+        # Ensure Unicode character semantics, even for 0x80-0xff
+        utf8::upgrade($string);
+
+        # Check for and strip any leading UTF-8 BOM
+        $string =~ s/^\x{FEFF}//;
+
+        # Check for some special cases
+        return $self unless length $string;
+
+        # 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
+        my $in_document = 0;
+        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->_load_scalar( "$1", [ undef ], \@lines );
+                    next;
+                }
+                $in_document = 1;
+            }
+
+            if ( ! @lines or $lines[0] =~ /^(?:---|\.\.\.)/ ) {
+                # A naked document
+                push @$self, undef;
+                while ( @lines and $lines[0] !~ /^---/ ) {
+                    shift @lines;
+                }
+                $in_document = 0;
+
+            # XXX The final '-+$' is to look for -- which ends up being an
+            # error later.
+            } elsif ( ! $in_document && @$self ) {
+                # only the first document can be explicit
+                die \"YAML::Tiny failed to classify the line '$lines[0]'";
+            } elsif ( $lines[0] =~ /^\s*\-(?:\s|$|-+$)/ ) {
+                # An array at the root
+                my $document = [ ];
+                push @$self, $document;
+                $self->_load_array( $document, [ 0 ], \@lines );
+
+            } elsif ( $lines[0] =~ /^(\s*)\S/ ) {
+                # A hash at the root
+                my $document = { };
+                push @$self, $document;
+                $self->_load_hash( $document, [ length($1) ], \@lines );
+
+            } else {
+                # Shouldn't get here.  @lines have whitespace-only lines
+                # stripped, and previous match is a line with any
+                # non-whitespace.  So this clause should only be reachable via
+                # a perlbug where \s is not symmetric with \S
+
+                # uncoverable statement
+                die \"YAML::Tiny failed to classify the line '$lines[0]'";
+            }
+        }
+    };
+    my $err = $@;
+    if ( ref $err eq 'SCALAR' ) {
+        $self->_error(${$err});
+    } elsif ( $err ) {
+        $self->_error($err);
+    }
+
+    return $self;
+}
+
+sub _unquote_single {
+    my ($self, $string) = @_;
+    return '' unless length $string;
+    $string =~ s/\'\'/\'/g;
+    return $string;
 }
 
-# Deparse a scalar string to the actual scalar
-sub _read_scalar {
-	my ($self, $string, $indent, $lines) = @_;
-
-	# Trim trailing whitespace
-	$string =~ s/\s*\z//;
-
-	# Explitic null/undef
-	return undef if $string eq '~';
-
-	# Single quote
-	if ( $string =~ /^\'(.*?)\'(?:\s+\#.*)?\z/ ) {
-		return '' unless defined $1;
-		$string = $1;
-		$string =~ s/\'\'/\'/g;
-		return $string;
-	}
-
-	# Double quote.
-	# The commented out form is simpler, but overloaded the Perl regex
-	# engine due to recursion and backtracking problems on strings
-	# larger than 32,000ish characters. Keep it for reference purposes.
-	# if ( $string =~ /^\"((?:\\.|[^\"])*)\"\z/ ) {
-	if ( $string =~ /^\"([^\\"]*(?:\\.[^\\"]*)*)\"(?:\s+\#.*)?\z/ ) {
-		# Reusing the variable is a little ugly,
-		# but avoids a new variable and a string copy.
-		$string = $1;
-		$string =~ s/\\"/"/g;
-		$string =~ s/\\([never\\fartz]|x([0-9a-fA-F]{2}))/(length($1)>1)?pack("H2",$2):$UNESCAPES{$1}/gex;
-		return $string;
-	}
-
-	# Special cases
-	if ( $string =~ /^[\'\"!&]/ ) {
-		die \"YAML::Tiny does not support a feature in line '$string'";
-	}
-	return {} if $string =~ /^{}(?:\s+\#.*)?\z/;
-	return [] if $string =~ /^\[\](?:\s+\#.*)?\z/;
-
-	# Regular unquoted string
-	if ( $string !~ /^[>|]/ ) {
-		if (
-			$string =~ /^(?:-(?:\s|$)|[\@\%\`])/
-			or
-			$string =~ /:(?:\s|$)/
-		) {
-			die \"YAML::Tiny found illegal characters in plain scalar: '$string'";
-		}
-		$string =~ s/\s+#.*\z//;
-		return $string;
-	}
-
-	# Error
-	die \"YAML::Tiny failed to find multi-line scalar content" unless @$lines;
-
-	# Check the indent depth
-	$lines->[0]   =~ /^(\s*)/;
-	$indent->[-1] = length("$1");
-	if ( defined $indent->[-2] and $indent->[-1] <= $indent->[-2] ) {
-		die \"YAML::Tiny found bad indenting in line '$lines->[0]'";
-	}
-
-	# Pull the lines
-	my @multiline = ();
-	while ( @$lines ) {
-		$lines->[0] =~ /^(\s*)/;
-		last unless length($1) >= $indent->[-1];
-		push @multiline, substr(shift(@$lines), length($1));
-	}
-
-	my $j = (substr($string, 0, 1) eq '>') ? ' ' : "\n";
-	my $t = (substr($string, 1, 1) eq '-') ? ''  : "\n";
-	return join( $j, @multiline ) . $t;
+sub _unquote_double {
+    my ($self, $string) = @_;
+    return '' unless length $string;
+    $string =~ s/\\"/"/g;
+    $string =~
+        s{\\([Nnever\\fartz0b]|x([0-9a-fA-F]{2}))}
+         {(length($1)>1)?pack("H2",$2):$UNESCAPES{$1}}gex;
+    return $string;
 }
 
-# Parse an array
-sub _read_array {
-	my ($self, $array, $indent, $lines) = @_;
-
-	while ( @$lines ) {
-		# Check for a new document
-		if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) {
-			while ( @$lines and $lines->[0] !~ /^---/ ) {
-				shift @$lines;
-			}
-			return 1;
-		}
-
-		# Check the indent level
-		$lines->[0] =~ /^(\s*)/;
-		if ( length($1) < $indent->[-1] ) {
-			return 1;
-		} elsif ( length($1) > $indent->[-1] ) {
-			die \"YAML::Tiny found bad indenting in line '$lines->[0]'";
-		}
-
-		if ( $lines->[0] =~ /^(\s*\-\s+)[^\'\"]\S*\s*:(?:\s+|$)/ ) {
-			# Inline nested hash
-			my $indent2 = length("$1");
-			$lines->[0] =~ s/-/ /;
-			push @$array, { };
-			$self->_read_hash( $array->[-1], [ @$indent, $indent2 ], $lines );
-
-		} elsif ( $lines->[0] =~ /^\s*\-(\s*)(.+?)\s*\z/ ) {
-			# Array entry with a value
-			shift @$lines;
-			push @$array, $self->_read_scalar( "$2", [ @$indent, undef ], $lines );
-
-		} elsif ( $lines->[0] =~ /^\s*\-\s*\z/ ) {
-			shift @$lines;
-			unless ( @$lines ) {
-				push @$array, undef;
-				return 1;
-			}
-			if ( $lines->[0] =~ /^(\s*)\-/ ) {
-				my $indent2 = length("$1");
-				if ( $indent->[-1] == $indent2 ) {
-					# Null array entry
-					push @$array, undef;
-				} else {
-					# Naked indenter
-					push @$array, [ ];
-					$self->_read_array( $array->[-1], [ @$indent, $indent2 ], $lines );
-				}
-
-			} elsif ( $lines->[0] =~ /^(\s*)\S/ ) {
-				push @$array, { };
-				$self->_read_hash( $array->[-1], [ @$indent, length("$1") ], $lines );
-
-			} else {
-				die \"YAML::Tiny failed to classify line '$lines->[0]'";
-			}
-
-		} elsif ( defined $indent->[-2] and $indent->[-1] == $indent->[-2] ) {
-			# This is probably a structure like the following...
-			# ---
-			# foo:
-			# - list
-			# bar: value
-			#
-			# ... so lets return and let the hash parser handle it
-			return 1;
-
-		} else {
-			die \"YAML::Tiny failed to classify line '$lines->[0]'";
-		}
-	}
-
-	return 1;
+# Load a YAML scalar string to the actual Perl scalar
+sub _load_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 =~ /^$re_capture_single_quoted$re_trailing_comment\z/ ) {
+        return $self->_unquote_single($1);
+    }
+
+    # Double quote.
+    if ( $string =~ /^$re_capture_double_quoted$re_trailing_comment\z/ ) {
+        return $self->_unquote_double($1);
+    }
+
+    # Special cases
+    if ( $string =~ /^[\'\"!&]/ ) {
+        die \"YAML::Tiny does not support a feature in line '$string'";
+    }
+    return {} if $string =~ /^{}(?:\s+\#.*)?\z/;
+    return [] if $string =~ /^\[\](?:\s+\#.*)?\z/;
+
+    # Regular unquoted string
+    if ( $string !~ /^[>|]/ ) {
+        die \"YAML::Tiny found illegal characters in plain scalar: '$string'"
+            if $string =~ /^(?:-(?:\s|$)|[\@\%\`])/ or
+                $string =~ /:(?:\s|$)/;
+        $string =~ s/\s+#.*\z//;
+        return $string;
+    }
+
+    # Error
+    die \"YAML::Tiny failed to find multi-line scalar content" unless @$lines;
+
+    # Check the indent depth
+    $lines->[0]   =~ /^(\s*)/;
+    $indent->[-1] = length("$1");
+    if ( defined $indent->[-2] and $indent->[-1] <= $indent->[-2] ) {
+        die \"YAML::Tiny found bad indenting in line '$lines->[0]'";
+    }
+
+    # Pull the lines
+    my @multiline = ();
+    while ( @$lines ) {
+        $lines->[0] =~ /^(\s*)/;
+        last unless length($1) >= $indent->[-1];
+        push @multiline, substr(shift(@$lines), $indent->[-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_hash {
-	my ($self, $hash, $indent, $lines) = @_;
-
-	while ( @$lines ) {
-		# Check for a new document
-		if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) {
-			while ( @$lines and $lines->[0] !~ /^---/ ) {
-				shift @$lines;
-			}
-			return 1;
-		}
-
-		# Check the indent level
-		$lines->[0] =~ /^(\s*)/;
-		if ( length($1) < $indent->[-1] ) {
-			return 1;
-		} elsif ( length($1) > $indent->[-1] ) {
-			die \"YAML::Tiny found bad indenting in line '$lines->[0]'";
-		}
-
-		# Get the key
-		unless ( $lines->[0] =~ s/^\s*([^\'\" ][^\n]*?)\s*:(\s+(?:\#.*)?|$)// ) {
-			if ( $lines->[0] =~ /^\s*[?\'\"]/ ) {
-				die \"YAML::Tiny does not support a feature in line '$lines->[0]'";
-			}
-			die \"YAML::Tiny failed to classify line '$lines->[0]'";
-		}
-		my $key = $1;
-
-		# Do we have a value?
-		if ( length $lines->[0] ) {
-			# Yes
-			$hash->{$key} = $self->_read_scalar( shift(@$lines), [ @$indent, undef ], $lines );
-		} else {
-			# An indent
-			shift @$lines;
-			unless ( @$lines ) {
-				$hash->{$key} = undef;
-				return 1;
-			}
-			if ( $lines->[0] =~ /^(\s*)-/ ) {
-				$hash->{$key} = [];
-				$self->_read_array( $hash->{$key}, [ @$indent, length($1) ], $lines );
-			} elsif ( $lines->[0] =~ /^(\s*)./ ) {
-				my $indent2 = length("$1");
-				if ( $indent->[-1] >= $indent2 ) {
-					# Null hash entry
-					$hash->{$key} = undef;
-				} else {
-					$hash->{$key} = {};
-					$self->_read_hash( $hash->{$key}, [ @$indent, length($1) ], $lines );
-				}
-			}
-		}
-	}
-
-	return 1;
+# Load an array
+sub _load_array {
+    my ($self, $array, $indent, $lines) = @_;
+
+    while ( @$lines ) {
+        # Check for a new document
+        if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) {
+            while ( @$lines and $lines->[0] !~ /^---/ ) {
+                shift @$lines;
+            }
+            return 1;
+        }
+
+        # Check the indent level
+        $lines->[0] =~ /^(\s*)/;
+        if ( length($1) < $indent->[-1] ) {
+            return 1;
+        } elsif ( length($1) > $indent->[-1] ) {
+            die \"YAML::Tiny found bad indenting in line '$lines->[0]'";
+        }
+
+        if ( $lines->[0] =~ /^(\s*\-\s+)[^\'\"]\S*\s*:(?:\s+|$)/ ) {
+            # Inline nested hash
+            my $indent2 = length("$1");
+            $lines->[0] =~ s/-/ /;
+            push @$array, { };
+            $self->_load_hash( $array->[-1], [ @$indent, $indent2 ], $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->_load_array(
+                        $array->[-1], [ @$indent, $indent2 ], $lines
+                    );
+                }
+
+            } elsif ( $lines->[0] =~ /^(\s*)\S/ ) {
+                push @$array, { };
+                $self->_load_hash(
+                    $array->[-1], [ @$indent, length("$1") ], $lines
+                );
+
+            } else {
+                die \"YAML::Tiny failed to classify line '$lines->[0]'";
+            }
+
+        } elsif ( $lines->[0] =~ /^\s*\-(\s*)(.+?)\s*\z/ ) {
+            # Array entry with a value
+            shift @$lines;
+            push @$array, $self->_load_scalar(
+                "$2", [ @$indent, undef ], $lines
+            );
+
+        } elsif ( defined $indent->[-2] and $indent->[-1] == $indent->[-2] ) {
+            # This is probably a structure like the following...
+            # ---
+            # foo:
+            # - list
+            # bar: value
+            #
+            # ... so lets return and let the hash parser handle it
+            return 1;
+
+        } else {
+            die \"YAML::Tiny failed to classify line '$lines->[0]'";
+        }
+    }
+
+    return 1;
 }
 
+# Load a hash
+sub _load_hash {
+    my ($self, $hash, $indent, $lines) = @_;
+
+    while ( @$lines ) {
+        # Check for a new document
+        if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) {
+            while ( @$lines and $lines->[0] !~ /^---/ ) {
+                shift @$lines;
+            }
+            return 1;
+        }
+
+        # Check the indent level
+        $lines->[0] =~ /^(\s*)/;
+        if ( length($1) < $indent->[-1] ) {
+            return 1;
+        } elsif ( length($1) > $indent->[-1] ) {
+            die \"YAML::Tiny found bad indenting in line '$lines->[0]'";
+        }
+
+        # Find the key
+        my $key;
+
+        # Quoted keys
+        if ( $lines->[0] =~
+            s/^\s*$re_capture_single_quoted$re_key_value_separator//
+        ) {
+            $key = $self->_unquote_single($1);
+        }
+        elsif ( $lines->[0] =~
+            s/^\s*$re_capture_double_quoted$re_key_value_separator//
+        ) {
+            $key = $self->_unquote_double($1);
+        }
+        elsif ( $lines->[0] =~
+            s/^\s*$re_capture_unquoted_key$re_key_value_separator//
+        ) {
+            $key = $1;
+            $key =~ s/\s+$//;
+        }
+        elsif ( $lines->[0] =~ /^\s*\?/ ) {
+            die \"YAML::Tiny does not support a feature in line '$lines->[0]'";
+        }
+        else {
+            die \"YAML::Tiny failed to classify line '$lines->[0]'";
+        }
+
+        if ( exists $hash->{$key} ) {
+            warn "YAML::Tiny found a duplicate key '$key' in line '$lines->[0]'";
+        }
+
+        # Do we have a value?
+        if ( length $lines->[0] ) {
+            # Yes
+            $hash->{$key} = $self->_load_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->_load_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->_load_hash(
+                        $hash->{$key}, [ @$indent, length($1) ], $lines
+                    );
+                }
+            }
+        }
+    }
+
+    return 1;
+}
+
+
+###
+# Dumper functions:
+
 # Save an object to a file
-sub write {
-	my $self = shift;
-	my $file = shift or return $self->_error('No file name provided');
+sub _dump_file {
+    my $self = shift;
 
-	# 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;
+    require Fcntl;
 
-	return 1;
-}
+    # Check the file
+    my $file = shift or $self->_error( 'You did not specify a file name' );
 
-# 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;
-}
+    my $fh;
+    # flock if available (or warn if not possible for OS-specific reasons)
+    if ( _can_flock() ) {
+        # Open without truncation (truncate comes after lock)
+        my $flags = Fcntl::O_WRONLY()|Fcntl::O_CREAT();
+        sysopen( $fh, $file, $flags )
+            or $self->_error("Failed to open file '$file' for writing: $!");
 
-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;
-}
+        # Use no translation and strict UTF-8
+        binmode( $fh, ":raw:encoding(UTF-8)");
+
+        flock( $fh, Fcntl::LOCK_EX() )
+            or warn "Couldn't lock '$file' for reading: $!";
 
-sub _write_array {
-	my ($self, $array, $indent, $seen) = @_;
-	if ( $seen->{refaddr($array)}++ ) {
-		die "YAML::Tiny does not support circular references";
-	}
-	my @lines  = ();
-	foreach my $el ( @$array ) {
-		my $line = ('  ' x $indent) . '-';
-		my $type = ref $el;
-		if ( ! $type ) {
-			$line .= ' ' . $self->_write_scalar( $el, $indent + 1 );
-			push @lines, $line;
-
-		} elsif ( $type eq 'ARRAY' ) {
-			if ( @$el ) {
-				push @lines, $line;
-				push @lines, $self->_write_array( $el, $indent + 1, $seen );
-			} else {
-				$line .= ' []';
-				push @lines, $line;
-			}
-
-		} elsif ( $type eq 'HASH' ) {
-			if ( keys %$el ) {
-				push @lines, $line;
-				push @lines, $self->_write_hash( $el, $indent + 1, $seen );
-			} else {
-				$line .= ' {}';
-				push @lines, $line;
-			}
-
-		} else {
-			die "YAML::Tiny does not support $type references";
-		}
-	}
-
-	@lines;
+        # truncate and spew contents
+        truncate $fh, 0;
+        seek $fh, 0, 0;
+    }
+    else {
+        open $fh, ">:unix:encoding(UTF-8)", $file;
+    }
+
+    # serialize and spew to the handle
+    print {$fh} $self->_dump_string;
+
+    # close the file (release the lock)
+    unless ( close $fh ) {
+        $self->_error("Failed to close file '$file': $!");
+    }
+
+    return 1;
 }
 
-sub _write_hash {
-	my ($self, $hash, $indent, $seen) = @_;
-	if ( $seen->{refaddr($hash)}++ ) {
-		die "YAML::Tiny does not support circular references";
-	}
-	my @lines  = ();
-	foreach my $name ( sort keys %$hash ) {
-		my $el   = $hash->{$name};
-		my $line = ('  ' x $indent) . "$name:";
-		my $type = ref $el;
-		if ( ! $type ) {
-			$line .= ' ' . $self->_write_scalar( $el, $indent + 1 );
-			push @lines, $line;
-
-		} elsif ( $type eq 'ARRAY' ) {
-			if ( @$el ) {
-				push @lines, $line;
-				push @lines, $self->_write_array( $el, $indent + 1, $seen );
-			} else {
-				$line .= ' []';
-				push @lines, $line;
-			}
-
-		} elsif ( $type eq 'HASH' ) {
-			if ( keys %$el ) {
-				push @lines, $line;
-				push @lines, $self->_write_hash( $el, $indent + 1, $seen );
-			} else {
-				$line .= ' {}';
-				push @lines, $line;
-			}
-
-		} else {
-			die "YAML::Tiny does not support $type references";
-		}
-	}
-
-	@lines;
+# Save an object to a string
+sub _dump_string {
+    my $self = shift;
+    return '' unless ref $self && @$self;
+
+    # Iterate over the documents
+    my $indent = 0;
+    my @lines  = ();
+
+    eval {
+        foreach my $cursor ( @$self ) {
+            push @lines, '---';
+
+            # An empty document
+            if ( ! defined $cursor ) {
+                # Do nothing
+
+            # A scalar document
+            } elsif ( ! ref $cursor ) {
+                $lines[-1] .= ' ' . $self->_dump_scalar( $cursor );
+
+            # A list at the root
+            } elsif ( ref $cursor eq 'ARRAY' ) {
+                unless ( @$cursor ) {
+                    $lines[-1] .= ' []';
+                    next;
+                }
+                push @lines, $self->_dump_array( $cursor, $indent, {} );
+
+            # A hash at the root
+            } elsif ( ref $cursor eq 'HASH' ) {
+                unless ( %$cursor ) {
+                    $lines[-1] .= ' {}';
+                    next;
+                }
+                push @lines, $self->_dump_hash( $cursor, $indent, {} );
+
+            } else {
+                die \("Cannot serialize " . ref($cursor));
+            }
+        }
+    };
+    if ( ref $@ eq 'SCALAR' ) {
+        $self->_error(${$@});
+    } elsif ( $@ ) {
+        $self->_error($@);
+    }
+
+    join '', map { "$_\n" } @lines;
 }
 
-# Set error
-sub _error {
-	$YAML::Tiny::errstr = $_[1];
-	undef;
+sub _has_internal_string_value {
+    my $value = shift;
+    my $b_obj = B::svref_2object(\$value);  # for round trip problem
+    return $b_obj->FLAGS & B::SVf_POK();
 }
 
-# Retrieve error
-sub errstr {
-	$YAML::Tiny::errstr;
+sub _dump_scalar {
+    my $string = $_[1];
+    my $is_key = $_[2];
+    # Check this before checking length or it winds up looking like a string!
+    my $has_string_flag = _has_internal_string_value($string);
+    return '~'  unless defined $string;
+    return "''" unless length  $string;
+    if (Scalar::Util::looks_like_number($string)) {
+        # keys and values that have been used as strings get quoted
+        if ( $is_key || $has_string_flag ) {
+            return qq['$string'];
+        }
+        else {
+            return $string;
+        }
+    }
+    if ( $string =~ /[\x00-\x09\x0b-\x0d\x0e-\x1f\x7f-\x9f\'\n]/ ) {
+        $string =~ s/\\/\\\\/g;
+        $string =~ s/"/\\"/g;
+        $string =~ s/\n/\\n/g;
+        $string =~ s/[\x85]/\\N/g;
+        $string =~ s/([\x00-\x1f])/\\$UNPRINTABLE[ord($1)]/g;
+        $string =~ s/([\x7f-\x9f])/'\x' . sprintf("%X",ord($1))/ge;
+        return qq|"$string"|;
+    }
+    if ( $string =~ /(?:^[~!@#%&*|>?:,'"`{}\[\]]|^-+$|\s|:\z)/ or
+        $QUOTE{$string}
+    ) {
+        return "'$string'";
+    }
+    return $string;
 }
 
+sub _dump_array {
+    my ($self, $array, $indent, $seen) = @_;
+    if ( $seen->{refaddr($array)}++ ) {
+        die \"YAML::Tiny does not support circular references";
+    }
+    my @lines  = ();
+    foreach my $el ( @$array ) {
+        my $line = ('  ' x $indent) . '-';
+        my $type = ref $el;
+        if ( ! $type ) {
+            $line .= ' ' . $self->_dump_scalar( $el );
+            push @lines, $line;
+
+        } elsif ( $type eq 'ARRAY' ) {
+            if ( @$el ) {
+                push @lines, $line;
+                push @lines, $self->_dump_array( $el, $indent + 1, $seen );
+            } else {
+                $line .= ' []';
+                push @lines, $line;
+            }
+
+        } elsif ( $type eq 'HASH' ) {
+            if ( keys %$el ) {
+                push @lines, $line;
+                push @lines, $self->_dump_hash( $el, $indent + 1, $seen );
+            } else {
+                $line .= ' {}';
+                push @lines, $line;
+            }
+
+        } else {
+            die \"YAML::Tiny does not support $type references";
+        }
+    }
+
+    @lines;
+}
 
+sub _dump_hash {
+    my ($self, $hash, $indent, $seen) = @_;
+    if ( $seen->{refaddr($hash)}++ ) {
+        die \"YAML::Tiny does not support circular references";
+    }
+    my @lines  = ();
+    foreach my $name ( sort keys %$hash ) {
+        my $el   = $hash->{$name};
+        my $line = ('  ' x $indent) . $self->_dump_scalar($name, 1) . ":";
+        my $type = ref $el;
+        if ( ! $type ) {
+            $line .= ' ' . $self->_dump_scalar( $el );
+            push @lines, $line;
+
+        } elsif ( $type eq 'ARRAY' ) {
+            if ( @$el ) {
+                push @lines, $line;
+                push @lines, $self->_dump_array( $el, $indent + 1, $seen );
+            } else {
+                $line .= ' []';
+                push @lines, $line;
+            }
+
+        } elsif ( $type eq 'HASH' ) {
+            if ( keys %$el ) {
+                push @lines, $line;
+                push @lines, $self->_dump_hash( $el, $indent + 1, $seen );
+            } else {
+                $line .= ' {}';
+                push @lines, $line;
+            }
+
+        } else {
+            die \"YAML::Tiny does not support $type references";
+        }
+    }
+
+    @lines;
+}
 
 
 
 #####################################################################
-# YAML Compatibility
+# DEPRECATED API methods:
 
-sub Dump {
-	YAML::Tiny->new(@_)->write_string;
-}
+# Error storage (DEPRECATED as of 1.57)
+our $errstr    = '';
 
-sub Load {
-	my $self = YAML::Tiny->read_string(@_);
-	unless ( $self ) {
-		Carp::croak("Failed to load YAML document from string");
-	}
-	if ( wantarray ) {
-		return @$self;
-	} else {
-		# To match YAML.pm, return the last document
-		return $self->[-1];
-	}
-}
-
-BEGIN {
-	*freeze = *Dump;
-	*thaw   = *Load;
+# Set error
+sub _error {
+    require Carp;
+    $errstr = $_[1];
+    $errstr =~ s/ at \S+ line \d+.*//;
+    Carp::croak( $errstr );
 }
 
-sub DumpFile {
-	my $file = shift;
-	YAML::Tiny->new(@_)->write($file);
+# Retrieve error
+my $errstr_warned;
+sub errstr {
+    require Carp;
+    Carp::carp( "YAML::Tiny->errstr and \$YAML::Tiny::errstr is deprecated" )
+        unless $errstr_warned++;
+    $errstr;
 }
 
-sub LoadFile {
-	my $self = YAML::Tiny->read($_[0]);
-	unless ( $self ) {
-		Carp::croak("Failed to load YAML document from '" . ($_[0] || '') . "'");
-	}
-	if ( wantarray ) {
-		return @$self;
-	} else {
-		# Return only the last document to match YAML.pm, 
-		return $self->[-1];
-	}
-}
 
 
 
+#####################################################################
+# Helper functions. Possibly not needed.
+
+
+# Use to detect nv or iv
+use B;
+
+# XXX-INGY Is flock YAML::Tiny's responsibility?
+# Some platforms can't flock :-(
+# XXX-XDG I think it is.  When reading and writing files, we ought
+# to be locking whenever possible.  People (foolishly) use YAML
+# files for things like session storage, which has race issues.
+my $HAS_FLOCK;
+sub _can_flock {
+    if ( defined $HAS_FLOCK ) {
+        return $HAS_FLOCK;
+    }
+    else {
+        require Config;
+        my $c = \%Config::Config;
+        $HAS_FLOCK = grep { $c->{$_} } qw/d_flock d_fcntl_can_lock d_lockf/;
+        require Fcntl if $HAS_FLOCK;
+        return $HAS_FLOCK;
+    }
+}
 
 
+# XXX-INGY Is this core in 5.8.1? Can we remove this?
+# XXX-XDG Scalar::Util 1.18 didn't land until 5.8.8, so we need this
 #####################################################################
 # Use Scalar::Util if possible, otherwise emulate it
 
+use Scalar::Util ();
 BEGIN {
-	local $@;
-	eval {
-		require Scalar::Util;
-	};
-	my $v = eval("$Scalar::Util::VERSION") || 0;
-	if ( $@ or $v < 1.18 ) {
-		eval <<'END_PERL';
+    local $@;
+    if ( eval { Scalar::Util->VERSION(1.18); } ) {
+        *refaddr = *Scalar::Util::refaddr;
+    }
+    else {
+        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;
+    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 { no warnings 'portable'; hex $1 };
+    bless $_[0], $pkg if defined $pkg;
+    $i;
 }
 END_PERL
-	} else {
-		*refaddr = *Scalar::Util::refaddr;
-	}
+    }
 }
 
+delete $YAML::Tiny::{refaddr};
+
 1;
 
+# XXX-INGY Doc notes I'm putting up here. Changing the doc when it's wrong
+# but leaving grey area stuff up here.
+#
+# I would like to change Read/Write to Load/Dump below without
+# changing the actual API names.
+#
+# It might be better to put Load/Dump API in the SYNOPSIS instead of the
+# dubious OO API.
+#
+# null and bool explanations may be outdated.
+
 __END__
 
-#line 1175
+#line 1487