Date: Wed, 21 Nov 2001 13:15:15 +0300 From: skv@protey.ru To: FreeBSD-gnats-submit@freebsd.org Subject: ports/32164: New port: p5-XML-SAX-Simple-0.01 Message-ID: <E166UPT-000K7W-00@3wgraphics.com>
next in thread | raw e-mail | index | archive | help
>Number: 32164
>Category: ports
>Synopsis: New port: p5-XML-SAX-Simple-0.01
>Confidential: no
>Severity: serious
>Priority: medium
>Responsible: freebsd-ports
>State: open
>Quarter:
>Keywords:
>Date-Required:
>Class: change-request
>Submitter-Id: current-users
>Arrival-Date: Wed Nov 21 02:30:01 PST 2001
>Closed-Date:
>Last-Modified:
>Originator: Sergey Skvortsov
>Release: FreeBSD 4.4-STABLE i386
>Organization:
<Organization of PR author (multiple lines)>
>Environment:
<Relevant environment information (multiple lines)>
>Description:
New port: p5-XML-SAX-Simple-0.01
SAX version of XML::Simple
>How-To-Repeat:
<Code/input/activities to reproduce the problem (multiple lines)>
>Fix:
# This is a shell archive. Save it in a file, remove anything before
# this line, and then unpack it by entering "sh file". Note, it may
# create directories; files and directories will be owned by you and
# have default permissions.
#
# This archive contains:
#
# p5-XML-SAX-Simple
# p5-XML-SAX-Simple/pkg-comment
# p5-XML-SAX-Simple/Makefile
# p5-XML-SAX-Simple/distinfo
# p5-XML-SAX-Simple/pkg-descr
# p5-XML-SAX-Simple/pkg-plist
# p5-XML-SAX-Simple/work
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile
# p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib
# p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01
# p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01
# p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01
# p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01
# p5-XML-SAX-Simple/work/.PLIST.mktmp
# p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01
# p5-XML-SAX-Simple/work/.PLIST.setuid
# p5-XML-SAX-Simple/work/.PLIST.startup
# p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01
#
echo c - p5-XML-SAX-Simple
mkdir -p p5-XML-SAX-Simple > /dev/null 2>&1
echo x - p5-XML-SAX-Simple/pkg-comment
sed 's/^X//' >p5-XML-SAX-Simple/pkg-comment << 'END-of-p5-XML-SAX-Simple/pkg-comment'
XSAX version of XML::Simple
END-of-p5-XML-SAX-Simple/pkg-comment
echo x - p5-XML-SAX-Simple/Makefile
sed 's/^X//' >p5-XML-SAX-Simple/Makefile << 'END-of-p5-XML-SAX-Simple/Makefile'
X# New ports collection makefile for: XML::SAX::Simple
X# Date created: 21 Nov 2001
X# Whom: Sergey Skvortsov <skv@protey.ru>
X#
X# $FreeBSD$
X#
X
XPORTNAME= XML-SAX-Simple
XPORTVERSION= 0.01
XCATEGORIES= textproc perl5
XMASTER_SITES= ${MASTER_SITE_PERL_CPAN}
XMASTER_SITE_SUBDIR= XML
XPKGNAMEPREFIX= p5-
X
XMAINTAINER= skv@protey.ru
X
XRUN_DEPENDS= ${LOCALBASE}/lib/perl5/site_perl/${PERL_VER}/XML/SAX.pm:${PORTSDIR}/textproc/p5-XML-SAX \
X ${LOCALBASE}/lib/perl5/site_perl/${PERL_VER}/XML/Simple.pm:${PORTSDIR}/textproc/p5-XML-Simple
XBUILD_DEPENDS= ${RUN_DEPENDS}
X
XPERL_CONFIGURE= yes
X
XMAN3= XML::SAX::Simple.3
X
XMANPREFIX= ${PREFIX}/lib/perl5/${PERL_VERSION}
X
X.include <bsd.port.mk>
END-of-p5-XML-SAX-Simple/Makefile
echo x - p5-XML-SAX-Simple/distinfo
sed 's/^X//' >p5-XML-SAX-Simple/distinfo << 'END-of-p5-XML-SAX-Simple/distinfo'
XMD5 (XML-SAX-Simple-0.01.tar.gz) = 8aebd4f3b3d5b5692d9d4ea21953d4cc
END-of-p5-XML-SAX-Simple/distinfo
echo x - p5-XML-SAX-Simple/pkg-descr
sed 's/^X//' >p5-XML-SAX-Simple/pkg-descr << 'END-of-p5-XML-SAX-Simple/pkg-descr'
XXML::SAX::Simple is a very simple version of XML::Simple but for
XSAX. It can be used as a complete drop-in replacement for XML::Simple.
X
XWWW: http://search.cpan.org/search?dist=XML-SAX-Simple
X
X-- Sergey Skvortsov
Xskv@protey.ru
END-of-p5-XML-SAX-Simple/pkg-descr
echo x - p5-XML-SAX-Simple/pkg-plist
sed 's/^X//' >p5-XML-SAX-Simple/pkg-plist << 'END-of-p5-XML-SAX-Simple/pkg-plist'
Xlib/perl5/site_perl/%%PERL_VER%%/%%PERL_ARCH%%/auto/XML/SAX/Simple/.packlist
Xlib/perl5/site_perl/%%PERL_VER%%/XML/SAX/Simple.pm
X@dirrm lib/perl5/site_perl/%%PERL_VER%%/%%PERL_ARCH%%/auto/XML/SAX/Simple
X@unexec rmdir %D/lib/perl5/site_perl/%%PERL_VER%%/XML/SAX 2>/dev/null || true
X@unexec rmdir %D/lib/perl5/site_perl/%%PERL_VER%%/XML 2>/dev/null || true
X@unexec rmdir %D/lib/perl5/site_perl/%%PERL_VER%%/%%PERL_ARCH%%/auto/XML/SAX 2>/dev/null || true
X@unexec rmdir %D/lib/perl5/site_perl/%%PERL_VER%%/%%PERL_ARCH%%/auto/XML 2>/dev/null || true
END-of-p5-XML-SAX-Simple/pkg-plist
echo c - p5-XML-SAX-Simple/work
mkdir -p p5-XML-SAX-Simple/work > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01 > /dev/null 2>&1
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes'
XRevision history for Perl extension XML::SAX::Simple.
X
X0.01 Wed Oct 31 15:52:17 2001
X - original version; created by h2xs 1.21 with options
X -A -X -n XML::SAX::Simple
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Changes
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL'
Xuse ExtUtils::MakeMaker;
X# See lib/ExtUtils/MakeMaker.pm for details of how to influence
X# the contents of the Makefile that is written.
XWriteMakefile(
X 'NAME' => 'XML::SAX::Simple',
X 'VERSION_FROM' => 'Simple.pm', # finds $VERSION
X 'PREREQ_PM' => { 'XML::Simple' => 1.06,
X 'XML::SAX' => 0.02,
X 'XML::Handler::Trees' => 0.02,
X },
X ($] >= 5.005 ? ## Add these new keywords supported since 5.005
X (ABSTRACT_FROM => 'Simple.pm', # retrieve abstract from module
X AUTHOR => 'Matt Sergeant, <matt@sergeant.org>') : ()),
X);
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile.PL
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST'
XChanges
XMANIFEST
XMakefile.PL
XREADME
XSimple.pm
Xt/1_XMLin.t
Xt/1_XMLin.xml
Xt/2_XMLout.t
Xt/3_Storable.t
Xt/4_MemShare.t
Xt/5_MemCopy.t
Xt/6_ObjIntf.t
Xt/desertnet.src
Xt/subdir/test2.xml
Xt/srt.xml
Xt/test1.xml
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/MANIFEST
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README'
XXML/SAX/Simple
X==============
X
XThis is a SAX version of XML::Simple. It works exactly the same
Xas XML::Simple, so see the documentation of that module for details.
XThe benefit of using this over XML::Simple is that XML::SAX::Simple
Xwill use any Perl SAX2 parser installed on your system (via XML::SAX),
Xrather than being hard coded to use XML::Parser.
X
XINSTALLATION
X
XTo install this module type the following:
X
X perl Makefile.PL
X make
X make test
X make install
X
XDEPENDENCIES
X
XThis module requires these other modules and libraries:
X
X XML::Simple, XML::SAX, XML::Handler::Trees
X
XCOPYRIGHT AND LICENCE
X
XThis is free software. You may use it and distribute it under the
Xsame terms as Perl itself.
X
XCopyright (C) 2001 Matt Sergeant, matt@sergeant.org
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/README
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm'
X# $Id: Simple.pm,v 1.1.1.1 2001/11/13 14:07:40 matt Exp $
X
Xpackage XML::SAX::Simple;
X
Xuse strict;
Xuse vars qw($VERSION @ISA @EXPORT);
Xuse XML::Simple ();
Xuse XML::SAX;
Xuse XML::Handler::Trees;
X@ISA = ('XML::Simple');
X
X$VERSION = '0.01';
X
X@EXPORT = qw(XMLin XMLout);
X
Xsub XMLin {
X my $self;
X if($_[0] and UNIVERSAL::isa($_[0], 'XML::Simple')) {
X $self = shift;
X }
X else {
X $self = new XML::SAX::Simple();
X }
X $self->SUPER::XMLin(@_);
X}
X
Xsub XMLout {
X my $self;
X if($_[0] and UNIVERSAL::isa($_[0], 'XML::Simple')) {
X $self = shift;
X }
X else {
X $self = new XML::SAX::Simple();
X }
X $self->SUPER::XMLout(@_);
X}
X
Xsub build_tree {
X my $self = shift;
X my ($filename, $string) = @_;
X
X if($filename and $filename eq '-') {
X local($/);
X $string = <STDIN>;
X $filename = undef;
X }
X
X my $handler = XML::Handler::Tree->new();
X my $parser = XML::SAX::ParserFactory->parser(Handler => $handler);
X my $tree;
X if($filename) {
X $tree = $parser->parse_uri($filename);
X }
X else {
X if (ref($string)) {
X $tree = $parser->parse_file($string);
X }
X else {
X $tree = $parser->parse_string($string);
X }
X }
X
X # use Data::Dumper;
X # warn("returning ", Dumper($tree), "\n");
X return($tree);
X}
X
X1;
X__END__
X
X=head1 NAME
X
XXML::SAX::Simple - SAX version of XML::Simple
X
X=head1 SYNOPSIS
X
X use XML::SAX::Simple qw(XMLin XMLout);
X my $hash = XMLin("foo.xml");
X
X=head1 DESCRIPTION
X
XXML::SAX::Simple is a very simple version of XML::Simple but for
XSAX. It can be used as a complete drop-in replacement for XML::Simple.
X
XSee the documentation for XML::Simple (which is required for this module
Xto work) for details.
X
X=head1 AUTHOR
X
XMatt Sergeant, matt@sergeant.org
X
X=head1 SEE ALSO
X
XL<XML::Simple>, L<XML::SAX>.
X
X=cut
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Simple.pm
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t > /dev/null 2>&1
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t'
Xuse strict;
Xuse IO::File;
Xuse File::Spec;
X
X$|++;
X
X# Initialise filenames and check they're there
X
Xmy $XMLFile = File::Spec->catfile('t', 'test1.xml'); # t/test1.xml
X
Xunless(-e $XMLFile) {
X print STDERR "test data missing...";
X print "1..0\n";
X exit 0;
X}
X
X
Xprint "1..65\n";
X
Xmy $t = 1;
X
X##############################################################################
X# S U P P O R T R O U T I N E S
X##############################################################################
X
X##############################################################################
X# Print out 'n ok' or 'n not ok' as expected by test harness.
X# First arg is test number (n). If only one following arg, it is interpreted
X# as true/false value. If two args, equality = true.
X#
X
Xsub ok {
X my($n, $x, $y) = @_;
X die "Sequence error got $n expected $t" if($n != $t);
X $x = 0 if(@_ > 2 and $x ne $y);
X print(($x ? '' : 'not '), 'ok ', $t++, "\n");
X}
X
X
X##############################################################################
X# Take two scalar values (may be references) and compare them (recursively
X# if necessary) returning 1 if same, 0 if different.
X#
X
Xsub DataCompare {
X my($x, $y) = @_;
X
X my($i);
X
X if(!defined($x)) {
X return(1) if(!defined($y));
X print STDERR "$t:DataCompare: undef != $y\n";
X return(0);
X }
X
X
X if(!ref($x)) {
X return(1) if($x eq $y);
X print STDERR "$t:DataCompare: $x != $y\n";
X return(0);
X }
X
X if(ref($x) eq 'ARRAY') {
X unless(ref($y) eq 'ARRAY') {
X print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
X return(0);
X }
X if(scalar(@$x) != scalar(@$y)) {
X print STDERR "$t:DataCompare: expected ", scalar(@$x),
X " element(s), got: ", scalar(@$y), "\n";
X return(0);
X }
X for($i = 0; $i < scalar(@$x); $i++) {
X DataCompare($x->[$i], $y->[$i]) || return(0);
X }
X return(1);
X }
X
X if(ref($x) eq 'HASH') {
X unless(ref($y) eq 'HASH') {
X print STDERR "$t:DataCompare: expected hashref, got: $y\n";
X return(0);
X }
X if(scalar(keys(%$x)) != scalar(keys(%$y))) {
X print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
X " key(s), (", join(', ', keys(%$x)),
X ") got: ", scalar(keys(%$y)), " (", join(', ', keys(%$y)),
X ")\n";
X return(0);
X }
X foreach $i (keys(%$x)) {
X unless(exists($y->{$i})) {
X print STDERR "$t:DataCompare: missing hash key - {$i}\n";
X return(0);
X }
X DataCompare($x->{$i}, $y->{$i}) || return(0);
X }
X return(1);
X }
X
X print STDERR "Don't know how to compare: " . ref($x) . "\n";
X return(0);
X}
X
X
X##############################################################################
X# T E S T R O U T I N E S
X##############################################################################
X
Xeval "use XML::SAX::Simple;";
Xok(1, !$@); # Module compiled OK
X
X# Start by parsing an extremely simple piece of XML
X
Xmy $opt = XMLin(q(<opt name1="value1" name2="value2"></opt>));
X
Xmy $expected = {
X name1 => 'value1',
X name2 => 'value2',
X };
X
Xok(2, 1); # XMLin() didn't crash
Xok(3, defined($opt)); # and it returned a value
Xok(4, ref($opt) eq 'HASH'); # and a hasref at that
Xok(5, DataCompare($opt, $expected));
X
X
X# Now try a slightly more complex one that returns the same value
X
X$opt = XMLin(q(
X <opt>
X <name1>value1</name1>
X <name2>value2</name2>
X </opt>
X));
Xok(6, DataCompare($opt, $expected));
X
X
X# And something else that returns the same (line break included to pick up
X# missing /s bug)
X
X$opt = XMLin(q(<opt name1="value1"
X name2="value2" />));
Xok(7, DataCompare($opt, $expected));
X
X
X# Try something with two lists of nested values
X
X$opt = XMLin(q(
X <opt>
X <name1>value1.1</name1>
X <name1>value1.2</name1>
X <name1>value1.3</name1>
X <name2>value2.1</name2>
X <name2>value2.2</name2>
X <name2>value2.3</name2>
X </opt>)
X);
X
Xok(8, DataCompare($opt, {
X name1 => [ 'value1.1', 'value1.2', 'value1.3' ],
X name2 => [ 'value2.1', 'value2.2', 'value2.3' ],
X}));
X
X
X# Now a simple nested hash
X
X$opt = XMLin(q(
X <opt>
X <item name1="value1" name2="value2" />
X </opt>)
X);
X
Xok(9, DataCompare($opt, {
X item => { name1 => 'value1', name2 => 'value2' }
X}));
X
X
X# Now a list of nested hashes
X
X$opt = XMLin(q(
X <opt>
X <item name1="value1" name2="value2" />
X <item name1="value3" name2="value4" />
X </opt>)
X);
Xok(10, DataCompare($opt, {
X item => [
X { name1 => 'value1', name2 => 'value2' },
X { name1 => 'value3', name2 => 'value4' }
X ]
X}));
X
X
X# Now a list of nested hashes transformed into a hash using default key names
X
Xmy $string = q(
X <opt>
X <item name="item1" attr1="value1" attr2="value2" />
X <item name="item2" attr1="value3" attr2="value4" />
X </opt>
X);
Xmy $target = {
X item => {
X item1 => { attr1 => 'value1', attr2 => 'value2' },
X item2 => { attr1 => 'value3', attr2 => 'value4' }
X }
X};
X$opt = XMLin($string);
Xok(11, DataCompare($opt, $target));
X
X
X# Same thing left as an array by suppressing default key names
X
X$target = {
X item => [
X {name => 'item1', attr1 => 'value1', attr2 => 'value2' },
X {name => 'item2', attr1 => 'value3', attr2 => 'value4' }
X ]
X};
X$opt = XMLin($string, keyattr => [] );
Xok(12, DataCompare($opt, $target));
X
X
X# Same again with alternative key suppression
X
X$opt = XMLin($string, keyattr => {} );
Xok(13, DataCompare($opt, $target));
X
X
X# Try the other two default key attribute names
X
X$opt = XMLin(q(
X <opt>
X <item key="item1" attr1="value1" attr2="value2" />
X <item key="item2" attr1="value3" attr2="value4" />
X </opt>
X));
Xok(14, DataCompare($opt, {
X item => {
X item1 => { attr1 => 'value1', attr2 => 'value2' },
X item2 => { attr1 => 'value3', attr2 => 'value4' }
X }
X}));
X
X
X$opt = XMLin(q(
X <opt>
X <item id="item1" attr1="value1" attr2="value2" />
X <item id="item2" attr1="value3" attr2="value4" />
X </opt>
X));
Xok(15, DataCompare($opt, {
X item => {
X item1 => { attr1 => 'value1', attr2 => 'value2' },
X item2 => { attr1 => 'value3', attr2 => 'value4' }
X }
X}));
X
X
X# Similar thing using non-standard key names
X
Xmy $xml = q(
X <opt>
X <item xname="item1" attr1="value1" attr2="value2" />
X <item xname="item2" attr1="value3" attr2="value4" />
X </opt>);
X
X$target = {
X item => {
X item1 => { attr1 => 'value1', attr2 => 'value2' },
X item2 => { attr1 => 'value3', attr2 => 'value4' }
X }
X};
X
X$opt = XMLin($xml, keyattr => [qw(xname)]);
Xok(16, DataCompare($opt, $target));
X
X
X# And with precise element/key specification
X
X$opt = XMLin($xml, keyattr => { 'item' => 'xname' });
Xok(17, DataCompare($opt, $target));
X
X
X# Same again but with key field further down the list
X
X$opt = XMLin($xml, keyattr => [qw(wibble xname)]);
Xok(18, DataCompare($opt, $target));
X
X
X# Same again but with key field supplied as scalar
X
X$opt = XMLin($xml, keyattr => qw(xname));
Xok(19, DataCompare($opt, $target));
X
X
X# Weird variation, not exactly what we wanted but it is what we expected
X# given the current implementation and we don't want to break it accidently
X
X$xml = q(
X<opt>
X <item id="one" value="1" name="a" />
X <item id="two" value="2" />
X <item id="three" value="3" />
X</opt>
X);
X
X$target = { item => {
X 'three' => { 'value' => 3 },
X 'a' => { 'value' => 1, 'id' => 'one' },
X 'two' => { 'value' => 2 }
X }
X};
X
X$opt = XMLin($xml);
Xok(20, DataCompare($opt, $target));
X
X
X# Or somewhat more as one might expect
X
X$target = { item => {
X 'one' => { 'value' => '1', 'name' => 'a' },
X 'two' => { 'value' => '2' },
X 'three' => { 'value' => '3' },
X }
X};
X$opt = XMLin($xml, keyattr => { 'item' => 'id' });
Xok(21, DataCompare($opt, $target));
X
X
X# Now a somewhat more complex test of targetting folding
X
X$xml = q(
X<opt>
X <car license="SH6673" make="Ford" id="1">
X <option key="1" pn="6389733317-12" desc="Electric Windows"/>
X <option key="2" pn="3735498158-01" desc="Leather Seats"/>
X <option key="3" pn="5776155953-25" desc="Sun Roof"/>
X </car>
X <car license="LW1804" make="GM" id="2">
X <option key="1" pn="9926543-1167" desc="Steering Wheel"/>
X </car>
X</opt>
X);
X
X$target = {
X 'car' => {
X 'LW1804' => {
X 'id' => 2,
X 'make' => 'GM',
X 'option' => {
X '9926543-1167' => { 'key' => 1, 'desc' => 'Steering Wheel' }
X }
X },
X 'SH6673' => {
X 'id' => 1,
X 'make' => 'Ford',
X 'option' => {
X '6389733317-12' => { 'key' => 1, 'desc' => 'Electric Windows' },
X '3735498158-01' => { 'key' => 2, 'desc' => 'Leather Seats' },
X '5776155953-25' => { 'key' => 3, 'desc' => 'Sun Roof' }
X }
X }
X }
X};
X
X$opt = XMLin($xml, forcearray => 1, keyattr => { 'car' => 'license', 'option' => 'pn' });
Xok(22, DataCompare($opt, $target));
X
X
X# Now try leaving the keys in place
X
X$target = {
X 'car' => {
X 'LW1804' => {
X 'id' => 2,
X 'make' => 'GM',
X 'option' => {
X '9926543-1167' => { 'key' => 1, 'desc' => 'Steering Wheel',
X '-pn' => '9926543-1167' }
X },
X license => 'LW1804'
X },
X 'SH6673' => {
X 'id' => 1,
X 'make' => 'Ford',
X 'option' => {
X '6389733317-12' => { 'key' => 1, 'desc' => 'Electric Windows',
X '-pn' => '6389733317-12' },
X '3735498158-01' => { 'key' => 2, 'desc' => 'Leather Seats',
X '-pn' => '3735498158-01' },
X '5776155953-25' => { 'key' => 3, 'desc' => 'Sun Roof',
X '-pn' => '5776155953-25' }
X },
X license => 'SH6673'
X }
X }
X};
X$opt = XMLin($xml, forcearray => 1, keyattr => { 'car' => '+license', 'option' => '-pn' });
Xok(23, DataCompare($opt, $target));
X
X
X# Make sure that the root element name is preserved if we ask for it
X
X$target = XMLin("<opt>$xml</opt>", forcearray => 1,
X keyattr => { 'car' => '+license', 'option' => '-pn' });
X
X$opt = XMLin( $xml, forcearray => 1, keeproot => 1,
X keyattr => { 'car' => '+license', 'option' => '-pn' });
X
Xok(24, DataCompare($opt, $target));
X
X
X# confirm that CDATA sections parse correctly
X
X$xml = q{<opt><cdata><![CDATA[<greeting>Hello, world!</greeting>]]></cdata></opt>};
X$opt = XMLin($xml);
Xok(25, DataCompare($opt, {
X 'cdata' => '<greeting>Hello, world!</greeting>'
X}));
X
X$xml = q{<opt><x><![CDATA[<y>one</y>]]><![CDATA[<y>two</y>]]></x></opt>};
X$opt = XMLin($xml);
Xok(26, DataCompare($opt, {
X 'x' => '<y>one</y><y>two</y>'
X}));
X
X
X# Try parsing a named external file
X
X$opt = eval{ XMLin($XMLFile); };
Xok(27, !$@); # XMLin didn't die
Xprint STDERR $@ if($@);
Xok(28, DataCompare($opt, {
X location => 't/test1.xml'
X}));
X
X
X# Try parsing default external file (scriptname.xml in script directory)
X
X$opt = eval { XMLin(); };
Xprint STDERR $@ if($@);
Xok(29, !$@); # XMLin didn't die
Xok(30, DataCompare($opt, {
X location => 't/1_XMLin.xml'
X}));
X
X
X# Try parsing named file in a directory in the searchpath
X
X$opt = eval {
X XMLin('test2.xml', searchpath => [
X 'dir1', 'dir2', File::Spec->catdir('t', 'subdir')
X ] );
X
X};
Xprint STDERR $@ if($@);
Xok(31, !$@); # XMLin didn't die
Xok(32, DataCompare($opt, { location => 't/subdir/test2.xml' }));
X
X
X# Ensure we get expected result if file does not exist
X
X$opt = eval {
X XMLin('bogusfile.xml', searchpath => [qw(. ./t)] ); # should 'die'
X};
Xok(33, !defined($opt)); # XMLin failed
Xok(34, $@ =~ /Could not find bogusfile.xml in/); # with the expected message
X
X
X# Try parsing from an IO::Handle
X
Xmy $fh = new IO::File;
X$XMLFile = File::Spec->catfile('t', '1_XMLin.xml'); # t/1_XMLin.xml
X$fh->open($XMLFile) || die "$!";
X$opt = XMLin($fh);
Xok(35, 1); # XMLin didn't die
Xok(36, $opt->{location}, 't/1_XMLin.xml'); # and it parsed the right file
X
X
X# Try parsing from STDIN
X
Xclose(STDIN);
Xopen(STDIN, $XMLFile) || die "$!";
X$opt = XMLin('-');
Xok(37, $opt->{location}, 't/1_XMLin.xml'); # parsed the right file
X
X
X# Confirm anonymous array folding works in general
X
X$opt = XMLin(q(
X <opt>
X <row>
X <anon>0.0</anon><anon>0.1</anon><anon>0.2</anon>
X </row>
X <row>
X <anon>1.0</anon><anon>1.1</anon><anon>1.2</anon>
X </row>
X <row>
X <anon>2.0</anon><anon>2.1</anon><anon>2.2</anon>
X </row>
X </opt>
X));
Xok(38, DataCompare($opt, {
X row => [
X [ '0.0', '0.1', '0.2' ],
X [ '1.0', '1.1', '1.2' ],
X [ '2.0', '2.1', '2.2' ]
X ]
X}));
X
X
X# Confirm anonymous array folding works in special top level case
X
X$opt = XMLin(q{
X <opt>
X <anon>one</anon>
X <anon>two</anon>
X <anon>three</anon>
X </opt>
X});
Xok(39, DataCompare($opt, [
X qw(one two three)
X]));
X
X
X$opt = XMLin(q(
X <opt>
X <anon>1</anon>
X <anon>
X <anon>2.1</anon>
X <anon>
X <anon>2.2.1</anon>
X <anon>2.2.2</anon>
X </anon>
X </anon>
X </opt>
X));
Xok(40, DataCompare($opt, [
X 1,
X [
X '2.1', [ '2.2.1', '2.2.2']
X ]
X]));
X
X
X# Check for the dreaded 'content' attribute
X
X$xml = q(
X <opt>
X <item attr="value">text</item>
X </opt>
X);
X
X$opt = XMLin($xml);
Xok(41, DataCompare($opt, {
X item => {
X content => 'text',
X attr => 'value'
X }
X}));
X
X
X# And check that we can change its name if required
X
X$opt = XMLin($xml, contentkey => 'text_content');
Xok(42, DataCompare($opt, {
X item => {
X text_content => 'text',
X attr => 'value'
X }
X}));
X
X
X# Check that it doesn't get screwed up by forcearray option
X
X$xml = q(<opt attr="value">text content</opt>);
X
X$opt = XMLin($xml, forcearray => 1);
Xok(43, DataCompare($opt, {
X 'attr' => 'value',
X 'content' => 'text content'
X}));
X
X
X# Test that we can force all text content to parse to hash values
X
X$xml = q(<opt><x>text1</x><y a="2">text2</y></opt>);
X$opt = XMLin($xml, forcecontent => 1);
Xok(44, DataCompare($opt, {
X 'x' => { 'content' => 'text1' },
X 'y' => { 'a' => 2, 'content' => 'text2' }
X}));
X
X
X# And that this is compatible with changing the key name
X
X$opt = XMLin($xml, forcecontent => 1, contentkey => '0');
Xok(45, DataCompare($opt, {
X 'x' => { 0 => 'text1' },
X 'y' => { 'a' => 2, 0 => 'text2' }
X}));
X
X
X# Check that mixed content parses in the weird way we expect
X
X$xml = q(<p class="mixed">Text with a <b>bold</b> word</p>);
X
Xok(46, DataCompare(XMLin($xml), {
X 'class' => 'mixed',
X 'content' => [ 'Text with a ', ' word' ],
X 'b' => 'bold'
X}));
X
X
X# Confirm single nested element rolls up into a scalar attribute value
X
X$string = q(
X <opt>
X <name>value</name>
X </opt>
X);
X$opt = XMLin($string);
Xok(47, DataCompare($opt, {
X name => 'value'
X}));
X
X
X# Unless 'forcearray' option is specified
X
X$opt = XMLin($string, forcearray => 1);
Xok(48, DataCompare($opt, {
X name => [ 'value' ]
X}));
X
X
X# Confirm array folding of single nested hash
X
X$string = q(<opt>
X <inner name="one" value="1" />
X</opt>);
X
X$opt = XMLin($string, forcearray => 1);
Xok(49, DataCompare($opt, {
X 'inner' => { 'one' => { 'value' => 1 } }
X}));
X
X
X# But not without forcearray option specified
X
X$opt = XMLin($string, forcearray => 0);
Xok(50, DataCompare($opt, {
X 'inner' => { 'name' => 'one', 'value' => 1 }
X}));
X
X
X# Test advanced features of forcearray
X
X$xml = q(<opt zero="0">
X <one>i</one>
X <two>ii</two>
X <three>iii</three>
X <three>3</three>
X <three>c</three>
X</opt>
X);
X
X$opt = XMLin($xml, forcearray => [ 'two' ]);
Xok(51, DataCompare($opt, {
X 'zero' => '0',
X 'one' => 'i',
X 'two' => [ 'ii' ],
X 'three' => [ 'iii', 3, 'c' ]
X}));
X
X
X# Test 'noattr' option
X
X$xml = q(<opt name="user" password="foobar">
X <nest attr="value">text</nest>
X</opt>
X);
X
X$opt = XMLin($xml, noattr => 1);
Xok(52, DataCompare($opt, { nest => 'text' }));
X
X
X# And make sure it doesn't screw up array folding
X
X$xml = q{<opt>
X <item><key>a</key><value>alpha</value></item>
X <item><key>b</key><value>beta</value></item>
X <item><key>g</key><value>gamma</value></item>
X</opt>
X};
X
X
X$opt = XMLin($xml, noattr => 1);
Xok(53, DataCompare($opt, {
X 'item' => {
X 'a' => { 'value' => 'alpha' },
X 'b' => { 'value' => 'beta' },
X 'g' => { 'value' => 'gamma' }
X }
X}));
X
X
X# Confirm empty elements parse to empty hashrefs
X
X$xml = q(<body>
X <name>bob</name>
X <outer attr="value">
X <inner1 />
X <inner2></inner2>
X </outer>
X</body>);
X
X$opt = XMLin($xml, noattr => 1);
Xok(54, DataCompare($opt, {
X 'name' => 'bob',
X 'outer' => {
X 'inner1' => {},
X 'inner2' => {}
X }
X}));
X
X
X# Unless 'suppressempty' is enabled
X
X$opt = XMLin($xml, noattr => 1, suppressempty => 1);
Xok(55, DataCompare($opt, { 'name' => 'bob', }));
X
X
X# Check behaviour when 'suppressempty' is set to to undef;
X
X$opt = XMLin($xml, noattr => 1, suppressempty => undef);
Xok(56, DataCompare($opt, {
X 'name' => 'bob',
X 'outer' => {
X 'inner1' => undef,
X 'inner2' => undef
X }
X}));
X
X# Check behaviour when 'suppressempty' is set to to empty string;
X
X$opt = XMLin($xml, noattr => 1, suppressempty => '');
Xok(57, DataCompare($opt, {
X 'name' => 'bob',
X 'outer' => {
X 'inner1' => '',
X 'inner2' => ''
X }
X}));
X
X# Confirm completely empty XML parses to undef with 'suppressempty'
X
X$xml = q(<body>
X <outer attr="value">
X <inner1 />
X <inner2></inner2>
X </outer>
X</body>);
X
X$opt = XMLin($xml, noattr => 1, suppressempty => 1);
Xok(58, DataCompare($opt, undef));
X
X
X# Test that nothing unusual happens with namespaces by default
X
X$xml = q(<opt xmlns="urn:accounts" xmlns:eng="urn:engineering">
X <invoice_num>12345678</invoice_num>
X <eng:partnum>8001-22374-001</eng:partnum>
X</opt>);
X
X$opt = XMLin($xml);
Xok(59, DataCompare($opt, {
X 'xmlns' => 'urn:accounts',
X '{urn:accounts}invoice_num' => '12345678',
X '{urn:engineering}partnum' => '8001-22374-001',
X '{http://www.w3.org/2000/xmlns/}eng' => 'urn:engineering',
X}));
X
X
X# Test that we can pass an option in to turn on XML::Parser's namespace mode
X
X# Skip for now since I haven't added this feature to XML::SAX::PurePerl yet!
Xok(60, 1);
X# $opt = XMLin($xml, parseropts => [ Namespaces => 1 ]);
X# ok(60, DataCompare($opt, {
X# 'invoice_num' => 12345678,
X# 'partnum' => '8001-22374-001'
X# }));
X
X
X# Test option error handling
X
X$_ = eval { XMLin('<x y="z" />', rootname => 'fred') }; # not valid for XMLin()
Xok(61, !defined($_));
Xok(62, $@ =~ /Unrecognised option:/);
X
X$_ = eval { XMLin('<x y="z" />', 'searchpath') };
Xok(63, !defined($_));
Xok(64, $@ =~ /Options must be name=>value pairs .odd number supplied./);
X
X
X# Now for a 'real world' test, try slurping in an SRT config file
X
X$opt = XMLin(File::Spec->catfile('t', 'srt.xml'), forcearray => 1);
X$target = {
X 'global' => [
X {
X 'proxypswd' => 'bar',
X 'proxyuser' => 'foo',
X 'exclude' => [
X '/_vt',
X '/save\\b',
X '\\.bak$',
X '\\.\\$\\$\\$$'
X ],
X 'httpproxy' => 'http://10.1.1.5:8080/',
X 'tempdir' => 'C:/Temp'
X }
X ],
X 'pubpath' => {
X 'test1' => {
X 'source' => [
X {
X 'label' => 'web_source',
X 'root' => 'C:/webshare/web_source'
X }
X ],
X 'title' => 'web_source -> web_target1',
X 'package' => {
X 'images' => { 'dir' => 'wwwroot/images' }
X },
X 'target' => [
X {
X 'label' => 'web_target1',
X 'root' => 'C:/webshare/web_target1',
X 'temp' => 'C:/webshare/web_target1/temp'
X }
X ],
X 'dir' => [ 'wwwroot' ]
X },
X 'test2' => {
X 'source' => [
X {
X 'label' => 'web_source',
X 'root' => 'C:/webshare/web_source'
X }
X ],
X 'title' => 'web_source -> web_target1 & web_target2',
X 'package' => {
X 'bios' => { 'dir' => 'wwwroot/staff/bios' },
X 'images' => { 'dir' => 'wwwroot/images' },
X 'templates' => { 'dir' => 'wwwroot/templates' }
X },
X 'target' => [
X {
X 'label' => 'web_target1',
X 'root' => 'C:/webshare/web_target1',
X 'temp' => 'C:/webshare/web_target1/temp'
X },
X {
X 'label' => 'web_target2',
X 'root' => 'C:/webshare/web_target2',
X 'temp' => 'C:/webshare/web_target2/temp'
X }
X ],
X 'dir' => [ 'wwwroot' ]
X },
X 'test3' => {
X 'source' => [
X {
X 'label' => 'web_source',
X 'root' => 'C:/webshare/web_source'
X }
X ],
X 'title' => 'web_source -> web_target1 via HTTP',
X 'addexclude' => [ '\\.pdf$' ],
X 'target' => [
X {
X 'label' => 'web_target1',
X 'root' => 'http://127.0.0.1/cgi-bin/srt_slave.plx',
X 'noproxy' => 1
X }
X ],
X 'dir' => [ 'wwwroot' ]
X }
X }
X};
Xok(65, DataCompare($target, $opt));
X
X
Xexit(0);
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.t
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml'
X<opt location="t/1_XMLin.xml" />
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/1_XMLin.xml
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t'
Xuse strict;
Xuse IO::File;
X
X$|++;
X
XBEGIN { print "1..189\n"; }
X
Xmy $t = 1;
X
X##############################################################################
X# S U P P O R T R O U T I N E S
X##############################################################################
X
X##############################################################################
X# Print out 'n ok' or 'n not ok' as expected by test harness.
X# First arg is test number (n). If only one following arg, it is interpreted
X# as true/false value. If two args, equality = true.
X#
X
Xsub ok {
X my($n, $x, $y) = @_;
X die "Sequence error got $n expected $t" if($n != $t);
X $x = 0 if(@_ > 2 and $x ne $y);
X print(($x ? '' : 'not '), 'ok ', $t++, "\n");
X}
X
X##############################################################################
X# Take two scalar values (may be references) and compare them (recursively
X# if necessary) returning 1 if same, 0 if different.
X#
X
Xsub DataCompare {
X my($x, $y) = @_;
X
X my($i);
X
X if(!ref($x)) {
X return(1) if($x eq $y);
X print STDERR "$t:DataCompare: $x != $y\n";
X return(0);
X }
X
X if(ref($x) eq 'ARRAY') {
X unless(ref($y) eq 'ARRAY') {
X print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
X return(0);
X }
X if(scalar(@$x) != scalar(@$y)) {
X print STDERR "$t:DataCompare: expected ", scalar(@$x),
X " element(s), got: ", scalar(@$y), "\n";
X return(0);
X }
X for($i = 0; $i < scalar(@$x); $i++) {
X DataCompare($x->[$i], $y->[$i]) || return(0);
X }
X return(1);
X }
X
X if(ref($x) eq 'HASH') {
X unless(ref($y) eq 'HASH') {
X print STDERR "$t:DataCompare: expected hashref, got: $y\n";
X return(0);
X }
X if(scalar(keys(%$x)) != scalar(keys(%$y))) {
X print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
X " key(s) (", join(', ', keys(%$x)),
X "), got: ", scalar(keys(%$y)), " (", join(', ', keys(%$y)),
X ")\n";
X return(0);
X }
X foreach $i (keys(%$x)) {
X unless(exists($y->{$i})) {
X print STDERR "$t:DataCompare: missing hash key - {$i}\n";
X return(0);
X }
X DataCompare($x->{$i}, $y->{$i}) || return(0);
X }
X return(1);
X }
X
X print STDERR "Don't know how to compare: " . ref($x) . "\n";
X return(0);
X}
X
X
X##############################################################################
X# Read file and return contents as a scalar.
X#
X
Xsub ReadFile {
X local($/) = undef;
X
X open(_READ_FILE_, $_[0]) || die "open($_[0]): $!";
X my $data = <_READ_FILE_>;
X close(_READ_FILE_);
X return($data);
X}
X
Xuse XML::SAX::Simple;
X
X# Try encoding a scalar value
X
Xmy $xml = XMLout("scalar");
Xok(1, 1); # XMLout did not crash
Xok(2, defined($xml)); # and it returned an XML string
Xok(3, XMLin($xml), 'scalar'); # which parses back OK
X
X
X# Next try encoding a hash
X
Xmy $hashref1 = { one => 1, two => 'II', three => '...' };
Xmy $hashref2 = { one => 1, two => 'II', three => '...' };
X
X# Expect:
X# <opt one="1" two="II" three="..." />
X
X$_ = XMLout($hashref1); # Encode to $_ for convenience
X # Confirm it parses back OK
Xok(4, DataCompare($hashref1, XMLin($_)));
Xok(5, s/one="1"//); # first key encoded OK
Xok(6, s/two="II"//); # second key encoded OK
Xok(7, s/three="..."//); # third key encoded OK
Xok(8, /^<\w+\s+\/>/); # no other attributes encoded
X
X
X# Now try encoding a hash with a nested array
X
Xmy $ref = {array => [qw(one two three)]};
X# Expect:
X# <opt>
X# <array>one</array>
X# <array>two</array>
X# <array>three</array>
X# </opt>
X
X$_ = XMLout($ref); # Encode to $_ for convenience
Xok(9, DataCompare($ref, XMLin($_)));
Xok(10, s{<array>one</array>\s*
X <array>two</array>\s*
X <array>three</array>}{}sx); # array elements encoded in correct order
Xok(11, /^<(\w+)\s*>\s*<\/\1>\s*$/s); # no other spurious encodings
X
X
X# Now try encoding a nested hash
X
X$ref = { value => '555 1234',
X hash1 => { one => 1 },
X hash2 => { two => 2 } };
X# Expect:
X# <opt value="555 1234">
X# <hash1 one="1" />
X# <hash2 two="2" />
X# </opt>
X
X$_ = XMLout($ref);
Xok(12, DataCompare($ref, XMLin($_))); # Parses back OK
X
Xok(13, s{<hash1 one="1" />\s*}{}s);
Xok(14, s{<hash2 two="2" />\s*}{}s);
Xok(15, m{^<(\w+)\s+value="555 1234"\s*>\s*</\1>\s*$}s);
X
X
X# Now try encoding an anonymous array
X
X$ref = [ qw(1 two III) ];
X# Expect:
X# <opt>
X# <anon>1</anon>
X# <anon>two</anon>
X# <anon>III</anon>
X# </opt>
X
X$_ = XMLout($ref);
Xok(16, DataCompare($ref, XMLin($_))); # Parses back OK
X
Xok(17, s{<anon>1</anon>\s*}{}s);
Xok(18, s{<anon>two</anon>\s*}{}s);
Xok(19, s{<anon>III</anon>\s*}{}s);
Xok(20, m{^<(\w+)\s*>\s*</\1>\s*$}s);
X
X
X# Now try encoding a nested anonymous array
X
X$ref = [ [ qw(1.1 1.2) ], [ qw(2.1 2.2) ] ];
X# Expect:
X# <opt>
X# <anon>
X# <anon>1.1</anon>
X# <anon>1.2</anon>
X# </anon>
X# <anon>
X# <anon>2.1</anon>
X# <anon>2.2</anon>
X# </anon>
X# </opt>
X
X$_ = XMLout($ref);
Xok(21, DataCompare($ref, XMLin($_))); # Parses back OK
X
Xok(22, s{<anon>1\.1</anon>\s*}{row}s);
Xok(23, s{<anon>1\.2</anon>\s*}{ one}s);
Xok(24, s{<anon>2\.1</anon>\s*}{row}s);
Xok(25, s{<anon>2\.2</anon>\s*}{ two}s);
Xok(26, s{<anon>\s*row one\s*</anon>\s*}{}s);
Xok(27, s{<anon>\s*row two\s*</anon>\s*}{}s);
Xok(28, m{^<(\w+)\s*>\s*</\1>\s*$}s);
X
X
X# Now try encoding a hash of hashes with key folding disabled
X
X$ref = { country => {
X England => { capital => 'London' },
X France => { capital => 'Paris' },
X Turkey => { capital => 'Istanbul' },
X }
X };
X# Expect:
X# <opt>
X# <country>
X# <England capital="London" />
X# <France capital="Paris" />
X# <Turkey capital="Istanbul" />
X# </country>
X# </opt>
X
X$_ = XMLout($ref, keyattr => []);
Xok(29, DataCompare($ref, XMLin($_))); # Parses back OK
Xok(30, s{<England\s+capital="London"\s*/>\s*}{}s);
Xok(31, s{<France\s+capital="Paris"\s*/>\s*}{}s);
Xok(32, s{<Turkey\s+capital="Istanbul"\s*/>\s*}{}s);
Xok(33, s{<country\s*>\s*</country>}{}s);
Xok(34, s{^<(\w+)\s*>\s*</\1>$}{}s);
X
X
X# Try encoding same again with key folding set to non-standard value
X
X# Expect:
X# <opt>
X# <country fullname="England" capital="London" />
X# <country fullname="France" capital="Paris" />
X# <country fullname="Turkey" capital="Istanbul" />
X# </opt>
X
X$_ = XMLout($ref, keyattr => ['fullname']);
X$xml = $_;
Xok(35, DataCompare($ref,
X XMLin($_, keyattr => ['fullname']))); # Parses back OK
Xok(36, s{\s*fullname="England"}{uk}s);
Xok(37, s{\s*capital="London"}{uk}s);
Xok(38, s{\s*fullname="France"}{fr}s);
Xok(39, s{\s*capital="Paris"}{fr}s);
Xok(40, s{\s*fullname="Turkey"}{tk}s);
Xok(41, s{\s*capital="Istanbul"}{tk}s);
Xok(42, s{<countryukuk\s*/>\s*}{}s);
Xok(43, s{<countryfrfr\s*/>\s*}{}s);
Xok(44, s{<countrytktk\s*/>\s*}{}s);
Xok(45, s{^<(\w+)\s*>\s*</\1>$}{}s);
X
X# Same again but specify name as scalar rather than array
X
X$_ = XMLout($ref, keyattr => 'fullname');
Xok(46, $_ eq $xml); # Same result as last time
X
X
X# Same again but specify keyattr as hash rather than array
X
X$_ = XMLout($ref, keyattr => { country => 'fullname' });
Xok(47, $_ eq $xml); # Same result as last time
X
X
X# Same again but add leading '+'
X
X$_ = XMLout($ref, keyattr => { country => '+fullname' });
Xok(48, $_ eq $xml); # Same result as last time
X
X
X# and leading '-'
X
X$_ = XMLout($ref, keyattr => { country => '-fullname' });
Xok(49, $_ eq $xml); # Same result as last time
X
X
X# One more time but with default key folding values
X
X# Expect:
X# <opt>
X# <country name="England" capital="London" />
X# <country name="France" capital="Paris" />
X# <country name="Turkey" capital="Istanbul" />
X# </opt>
X
X$_ = XMLout($ref);
Xok(50, DataCompare($ref, XMLin($_))); # Parses back OK
Xok(51, s{\s*name="England"}{uk}s);
Xok(52, s{\s*capital="London"}{uk}s);
Xok(53, s{\s*name="France"}{fr}s);
Xok(54, s{\s*capital="Paris"}{fr}s);
Xok(55, s{\s*name="Turkey"}{tk}s);
Xok(56, s{\s*capital="Istanbul"}{tk}s);
Xok(57, s{<countryukuk\s*/>\s*}{}s);
Xok(58, s{<countryfrfr\s*/>\s*}{}s);
Xok(59, s{<countrytktk\s*/>\s*}{}s);
Xok(60, s{^<(\w+)\s*>\s*</\1>$}{}s);
X
X
X# Finally, confirm folding still works with only one nested hash
X
X# Expect:
X# <opt>
X# <country name="England" capital="London" />
X# </opt>
X
X$ref = { country => { England => { capital => 'London' } } };
X$_ = XMLout($ref);
Xok(61, DataCompare($ref, XMLin($_, forcearray => 1))); # Parses back OK
Xok(62, s{\s*name="England"}{uk}s);
Xok(63, s{\s*capital="London"}{uk}s);
Xok(64, s{<countryukuk\s*/>\s*}{}s);
X#print STDERR "\n$_\n";
Xok(65, s{^<(\w+)\s*>\s*</\1>$}{}s);
X
X
X# Check that default XML declaration works
X#
X# Expect:
X# <?xml version='1' standalone='yes'?>
X# <opt one="1" />
X
X$ref = { one => 1 };
X
X$_ = XMLout($ref, xmldecl => 1);
Xok(66, DataCompare($ref, XMLin($_))); # Parses back OK
Xok(67, s{^\Q<?xml version='1.0' standalone='yes'?>\E}{}s);
Xok(68, s{<opt one="1" />}{}s);
Xok(69, m{^\s*$}s);
X
X
X# Check that custom XML declaration works
X#
X# Expect:
X# <?xml version='1' encoding='ISO-8859-1'?>
X# <opt one="1" />
X
X$_ = XMLout($ref, xmldecl => "<?xml version='1.0' encoding='ASCII'?>");
Xok(70, DataCompare($ref, XMLin($_))); # Parses back OK
Xok(71, s{^\Q<?xml version='1.0' encoding='ASCII'?>\E}{}s);
Xok(72, s{<opt one="1" />}{}s);
Xok(73, m{^\s*$}s);
X
X
X# Check that special characters do get escaped
X
X$ref = { a => '<A>', b => '"B"', c => '&C&' };
X$_ = XMLout($ref);
Xok(74, DataCompare($ref, XMLin($_))); # Parses back OK
Xok(75, s{a="<A>"}{}s);
Xok(76, s{b=""B""}{}s);
Xok(77, s{c="&C&"}{}s);
Xok(78, s{^<(\w+)\s*/>$}{}s);
X
X
X# unless we turn escaping off
X
X$_ = XMLout($ref, noescape => 1);
Xok(79, s{a="<A>"}{}s);
Xok(80, s{b=""B""}{}s);
Xok(81, s{c="&C&"}{}s);
Xok(82, s{^<(\w+)\s*/>$}{}s);
X
X
X# Try encoding a recursive data structure and confirm that it fails
X
X$_ = eval {
X my $ref = { a => '1' };
X $ref->{b} = $ref;
X XMLout($ref);
X};
Xok(83, !defined($_));
Xok(84, $@ =~ /recursive data structures not supported/);
X
X
X# Try encoding a blessed reference and confirm that it fails
X
X$_ = eval { my $ref = new IO::File; XMLout($ref) };
Xok(85, !defined($_));
Xok(86, $@ =~ /Can't encode a value of type: /);
X
X
X# Repeat some of the above tests with named root element
X
X# Try encoding a scalar value
X
X$xml = XMLout("scalar", rootname => 'TOM');
Xok(87, defined($xml)); # and it returned an XML string
Xok(88, XMLin($xml), 'scalar'); # which parses back OK
X # and contains the expected data
Xok(89, $xml =~ /^\s*<TOM>scalar<\/TOM>\s*$/si);
X
X
X# Next try encoding a hash
X
X# Expect:
X# <DICK one="1" two="II" three="..." />
X
X$_ = XMLout($hashref1, rootname => 'DICK');
X # Confirm it parses back OK
Xok(90, DataCompare($hashref1, XMLin($_)));
Xok(91, s/one="1"//); # first key encoded OK
Xok(92, s/two="II"//); # second key encoded OK
Xok(93, s/three="..."//); # third key encoded OK
Xok(94, /^<DICK\s+\/>/); # only expected root element left
X
X
X# Now try encoding a hash with a nested array
X
X$ref = {array => [qw(one two three)]};
X# Expect:
X# <LARRY>
X# <array>one</array>
X# <array>two</array>
X# <array>three</array>
X# </LARRY>
X
X$_ = XMLout($ref, rootname => 'LARRY'); # Encode to $_ for convenience
Xok(95, DataCompare($ref, XMLin($_)));
Xok(96, s{<array>one</array>\s*
X <array>two</array>\s*
X <array>three</array>}{}sx); # array encoded in correct order
Xok(97, /^<(LARRY)\s*>\s*<\/\1>\s*$/s); # only expected root element left
X
X
X# Now try encoding a nested hash
X
X$ref = { value => '555 1234',
X hash1 => { one => 1 },
X hash2 => { two => 2 } };
X# Expect:
X# <CURLY value="555 1234">
X# <hash1 one="1" />
X# <hash2 two="2" />
X# </CURLY>
X
X$_ = XMLout($ref, rootname => 'CURLY');
Xok(98, DataCompare($ref, XMLin($_))); # Parses back OK
X
Xok(99, s{<hash1 one="1" />\s*}{}s);
Xok(100, s{<hash2 two="2" />\s*}{}s);
Xok(101, m{^<(CURLY)\s+value="555 1234"\s*>\s*</\1>\s*$}s);
X
X
X# Now try encoding an anonymous array
X
X$ref = [ qw(1 two III) ];
X# Expect:
X# <MOE>
X# <anon>1</anon>
X# <anon>two</anon>
X# <anon>III</anon>
X# </MOE>
X
X$_ = XMLout($ref, rootname => 'MOE');
Xok(102, DataCompare($ref, XMLin($_))); # Parses back OK
X
Xok(103, s{<anon>1</anon>\s*}{}s);
Xok(104, s{<anon>two</anon>\s*}{}s);
Xok(105, s{<anon>III</anon>\s*}{}s);
Xok(106, m{^<(MOE)\s*>\s*</\1>\s*$}s);
X
X
X# Test again, this time with no root element
X
X# Try encoding a scalar value
X
Xok(107, XMLout("scalar", rootname => '') =~ /scalar\s+/s);
Xok(108, XMLout("scalar", rootname => undef) =~ /scalar\s+/s);
X
X
X# Next try encoding a hash
X
X# Expect:
X# <one>1</one>
X# <two>II</two>
X# <three>...</three>
X
X$_ = XMLout($hashref1, rootname => '');
X # Confirm it parses back OK
Xok(109, DataCompare($hashref1, XMLin("<opt>$_</opt>")));
Xok(110, s/<one>1<\/one>//); # first key encoded OK
Xok(111, s/<two>II<\/two>//); # second key encoded OK
Xok(112, s/<three>...<\/three>//); # third key encoded OK
Xok(113, /^\s*$/); # nothing else left
X
X
X# Now try encoding a nested hash
X
X$ref = { value => '555 1234',
X hash1 => { one => 1 },
X hash2 => { two => 2 } };
X# Expect:
X# <value>555 1234</value>
X# <hash1 one="1" />
X# <hash2 two="2" />
X
X$_ = XMLout($ref, rootname => '');
Xok(114, DataCompare($ref, XMLin("<opt>$_</opt>"))); # Parses back OK
Xok(115, s{<value>555 1234<\/value>\s*}{}s);
Xok(116, s{<hash1 one="1" />\s*}{}s);
Xok(117, s{<hash2 two="2" />\s*}{}s);
Xok(118, m{^\s*$}s);
X
X
X# Now try encoding an anonymous array
X
X$ref = [ qw(1 two III) ];
X# Expect:
X# <anon>1</anon>
X# <anon>two</anon>
X# <anon>III</anon>
X
X$_ = XMLout($ref, rootname => '');
Xok(119, DataCompare($ref, XMLin("<opt>$_</opt>"))); # Parses back OK
X
Xok(120, s{<anon>1</anon>\s*}{}s);
Xok(121, s{<anon>two</anon>\s*}{}s);
Xok(122, s{<anon>III</anon>\s*}{}s);
Xok(123, m{^\s*$}s);
X
X
X# Test option error handling
X
X$_ = eval { XMLout($hashref1, searchpath => []) }; # only valid for XMLin()
Xok(124, !defined($_));
Xok(125, $@ =~ /Unrecognised option:/);
X
X$_ = eval { XMLout($hashref1, 'bogus') };
Xok(126, !defined($_));
Xok(127, $@ =~ /Options must be name=>value pairs .odd number supplied./);
X
X
X# Test output to file
X
Xmy $TestFile = 'testoutput.xml';
Xunlink($TestFile);
Xok(128, !-e $TestFile);
X
X$xml = XMLout($hashref1);
XXMLout($hashref1, outputfile => $TestFile);
Xok(129, -e $TestFile);
Xok(130, ReadFile($TestFile) eq $xml);
Xunlink($TestFile);
X
X
X# Test output to an IO handle
X
Xok(131, !-e $TestFile);
Xmy $fh = new IO::File;
X$fh->open(">$TestFile") || die "$!";
XXMLout($hashref1, outputfile => $TestFile);
X$fh->close();
Xok(132, -e $TestFile);
Xok(133, ReadFile($TestFile) eq $xml);
Xunlink($TestFile);
X
X# After all that, confirm that the original hashref we supplied has not
X# been corrupted.
X
Xok(134, DataCompare($hashref1, $hashref2));
X
X
X# Confirm that hash keys with leading '-' are skipped
X
X$ref = {
X 'a' => 'one',
X '-b' => 'two',
X '-c' => {
X 'one' => 1,
X 'two' => 2
X }
X};
X
X$_ = XMLout($ref, rootname => 'opt');
Xok(135, m{^\s*<opt\s+a="one"\s*/>\s*$}s);
X
X
X# Try a more complex unfolding with key attributes named in a hash
X
X$ref = {
X 'car' => {
X 'LW1804' => {
X 'option' => {
X '9926543-1167' => { 'key' => 1, 'desc' => 'Steering Wheel' }
X },
X 'id' => 2,
X 'make' => 'GM'
X },
X 'SH6673' => {
X 'option' => {
X '6389733317-12' => { 'key' => 2, 'desc' => 'Electric Windows' },
X '3735498158-01' => { 'key' => 3, 'desc' => 'Leather Seats' },
X '5776155953-25' => { 'key' => 4, 'desc' => 'Sun Roof' },
X },
X 'id' => 1,
X 'make' => 'Ford'
X }
X }
X};
X
X# Expect:
X# <opt>
X# <car license="LW1804" id="2" make="GM">
X# <option key="1" pn="9926543-1167" desc="Steering Wheel" />
X# </car>
X# <car license="SH6673" id="1" make="Ford">
X# <option key="2" pn="6389733317-12" desc="Electric Windows" />
X# <option key="3" pn="3735498158-01" desc="Leather Seats" />
X# <option key="4" pn="5776155953-25" desc="Sun Roof" />
X# </car>
X# </opt>
X
X$_ = XMLout($ref, keyattr => { 'car' => 'license', 'option' => 'pn' });
Xok(136, DataCompare($ref, # Parses back OK
X XMLin($_, forcearray => 1,
X keyattr => { 'car' => 'license', 'option' => 'pn' })));
Xok(137, s{\s*make="GM"}{gm}s);
Xok(138, s{\s*id="2"}{gm}s);
Xok(139, s{\s*license="LW1804"}{gm}s);
Xok(140, s{\s*desc="Steering Wheel"}{opt}s);
Xok(141, s{\s*pn="9926543-1167"}{opt}s);
Xok(142, s{\s*key="1"}{opt}s);
Xok(143, s{\s*<cargmgmgm>\s*<optionoptoptopt\s*/>\s*</car>}{CAR}s);
Xok(144, s{\s*make="Ford"}{ford}s);
Xok(145, s{\s*id="1"}{ford}s);
Xok(146, s{\s*license="SH6673"}{ford}s);
Xok(147, s{\s*desc="Electric Windows"}{1}s);
Xok(148, s{\s*pn="6389733317-12"}{1}s);
Xok(149, s{\s*key="2"}{1}s);
Xok(150, s{\s*<option111}{<option}s);
Xok(151, s{\s*desc="Leather Seats"}{2}s);
Xok(152, s{\s*pn="3735498158-01"}{2}s);
Xok(153, s{\s*key="3"}{2}s);
Xok(154, s{\s*<option222}{<option}s);
Xok(155, s{\s*desc="Sun Roof"}{3}s);
Xok(156, s{\s*pn="5776155953-25"}{3}s);
Xok(157, s{\s*key="4"}{3}s);
Xok(158, s{\s*<option333}{<option}s);
Xok(159, s{\s*<carfordfordford>\s*(<option\s*/>\s*){3}</car>}{CAR}s);
Xok(160, s{^<(\w+)\s*>\s*CAR\s*CAR\s*</\1>$}{}s);
X
X
X# Check that empty hashes translate to empty tags
X
X$ref = {
X 'one' => {
X 'attr1' => 'avalue1',
X 'nest1' => [ 'nvalue1' ],
X 'nest2' => {}
X },
X two => {}
X};
X
X$_ = XMLout($ref);
X
Xok(161, s{<nest2\s*></nest2\s*>\s*}{<NNN>});
Xok(162, s{<nest1\s*>nvalue1</nest1\s*>\s*}{<NNN>});
Xok(163, s{<one\s*attr1\s*=\s*"avalue1">\s*}{<one>});
Xok(164, s{<one\s*>\s*<NNN>\s*<NNN>\s*</one>}{<nnn>});
Xok(165, s{<two\s*></two\s*>\s*}{<nnn>});
Xok(166, m{^\s*<(\w+)\s*>\s*<nnn>\s*<nnn>\s*</\1\s*>\s*$});
X
X
X# Check undefined values generate warnings
X
X{
Xmy $warn = '';
Xlocal $SIG{__WARN__} = sub { $warn = $_[0] };
X$_ = eval {
X $ref = { 'tag' => undef };
X XMLout($ref);
X};
Xok(167, $warn =~ /Use of uninitialized value/);
X}
X
X
X# Unless undef is mapped to empty tags
X
X$ref = { 'tag' => undef };
X$_ = XMLout($ref, suppressempty => undef);
Xok(168, m{^\s*<(\w*)\s*>\s*<tag\s*></tag\s*>\s*</\1\s*>\s*$}s);
X
X
X# Test the keeproot option
X
X$ref = {
X 'seq' => {
X 'name' => 'alpha',
X 'alpha' => [ 1, 2, 3 ]
X }
X};
X
Xmy $xml1 = XMLout($ref, rootname => 'sequence');
Xmy $xml2 = XMLout({ 'sequence' => $ref }, keeproot => 1);
X
Xok(169, DataCompare($xml1, $xml2));
X
X
X# Test that items with text content are output correctly
X# Expect: <opt one="1">text</opt>
X
X$ref = { 'one' => 1, 'content' => 'text' };
X
X$_ = XMLout($ref);
X
Xok(170, m{^\s*<opt\s+one="1">text</opt>\s*$}s);
X
X
X# Even if we change the default value for the 'contentkey' option
X
X$ref = { 'one' => 1, 'text_content' => 'text' };
X
X$_ = XMLout($ref, contentkey => 'text_content');
X
Xok(171, m{^\s*<opt\s+one="1">text</opt>\s*$}s);
X
X
X# Check 'noattr' option
X
X$ref = {
X attr1 => 'value1',
X attr2 => 'value2',
X nest => [ qw(one two three) ]
X};
X
X# Expect:
X#
X# <opt>
X# <attr1>value1</attr1>
X# <attr2>value2</attr2>
X# <nest>one</nest>
X# <nest>two</nest>
X# <nest>three</nest>
X# </opt>
X#
X
X$_ = XMLout($ref, noattr => 1);
X
Xok(172, !m{=}s); # No '=' signs anywhere
Xok(173, DataCompare($ref, XMLin($_))); # Parses back ok
Xok(174, s{\s*<(attr1)>value1</\1>\s*}{NEST}s); # Output meets expectations
Xok(175, s{\s*<(attr2)>value2</\1>\s*}{NEST}s);
Xok(176, s{\s*<(nest)>one</\1>\s*<\1>two</\1>\s*<\1>three</\1>}{NEST}s);
Xok(177, s{^<(\w+)\s*>(NEST\s*){3}</\1>$}{}s);
X
X
X# Check noattr doesn't screw up keyattr
X
X$ref = { number => {
X 'twenty one' => { dec => 21, hex => '0x15' },
X 'thirty two' => { dec => 32, hex => '0x20' }
X }
X};
X
X# Expect:
X#
X# <opt>
X# <number>
X# <dec>21</dec>
X# <word>twenty one</word>
X# <hex>0x15</hex>
X# </number>
X# <number>
X# <dec>32</dec>
X# <word>thirty two</word>
X# <hex>0x20</hex>
X# </number>
X# </opt>
X#
X
X$_ = XMLout($ref, noattr => 1, keyattr => [ 'word' ]);
X
Xok(178, !m{=}s); # No '=' signs anywhere
X # Parses back ok
Xok(179, DataCompare($ref, XMLin($_, keyattr => [ 'word' ])));
Xok(180, s{\s*<(dec)>21</\1>\s*}{21}s);
Xok(181, s{\s*<(hex)>0x15</\1>\s*}{21}s);
Xok(182, s{\s*<(word)>twenty one</\1>\s*}{21}s);
Xok(183, s{\s*<(number)>212121</\1>\s*}{NUM}s);
Xok(184, s{\s*<(dec)>32</\1>\s*}{32}s);
Xok(185, s{\s*<(hex)>0x20</\1>\s*}{32}s);
Xok(186, s{\s*<(word)>thirty two</\1>\s*}{32}s);
Xok(187, s{\s*<(number)>323232</\1>\s*}{NUM}s);
Xok(188, s{^<(\w+)\s*>NUMNUM</\1>$}{}s);
X
X
X# 'Stress test' with a data structure that maps to several thousand elements.
X# Unfold elements with XMLout() and fold them up again with XMLin()
X
Xmy $opt1 = {};
Xforeach my $i (1..40) {
X foreach my $j (1..$i) {
X $opt1->{TypeA}->{$i}->{Record}->{$j} = { Hex => sprintf("0x%04X", $j) };
X $opt1->{TypeB}->{$i}->{Record}->{$j} = { Oct => sprintf("%04o", $j) };
X }
X}
X
X$xml = XMLout($opt1, keyattr => { TypeA => 'alpha', TypeB => 'beta', Record => 'id' });
X
Xmy $opt2 = XMLin($xml, keyattr => { TypeA => 'alpha', TypeB => 'beta', Record => 'id' }, forcearray => 1);
X
Xok(189, DataCompare($opt1, $opt2));
X
Xexit(0);
X
X
X
X
X
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/2_XMLout.t
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t'
Xuse strict;
X
Xuse File::Spec;
X
Xeval { require Storable; };
Xunless($INC{'Storable.pm'}) {
X print STDERR "no Storable.pm...";
X print "1..0\n";
X exit 0;
X}
X
X# Initialise filenames and check they're there
X
Xmy $SrcFile = File::Spec->catfile('t', 'desertnet.src');
Xmy $XMLFile = File::Spec->catfile('t', 'desertnet.xml');
Xmy $CacheFile = File::Spec->catfile('t', 'desertnet.stor');
X
Xunless(-e $SrcFile) {
X print STDERR "test data missing...";
X print "1..0\n";
X exit 0;
X}
X
Xprint "1..19\n";
X
Xmy $t = 1;
X
X##############################################################################
X# S U P P O R T R O U T I N E S
X##############################################################################
X
X##############################################################################
X# Print out 'n ok' or 'n not ok' as expected by test harness.
X# First arg is test number (n). If only one following arg, it is interpreted
X# as true/false value. If two args, equality = true.
X#
X
Xsub ok {
X my($n, $x, $y) = @_;
X die "Sequence error got $n expected $t" if($n != $t);
X $x = 0 if(@_ > 2 and $x ne $y);
X print(($x ? '' : 'not '), 'ok ', $t++, "\n");
X}
X
X
X##############################################################################
X# Take two scalar values (may be references) and compare them (recursively
X# if necessary) returning 1 if same, 0 if different.
X#
X
Xsub DataCompare {
X my($x, $y) = @_;
X
X my($i);
X
X if(!ref($x)) {
X return(1) if($x eq $y);
X print STDERR "$t:DataCompare: $x != $y\n";
X return(0);
X }
X
X if(ref($x) eq 'ARRAY') {
X unless(ref($y) eq 'ARRAY') {
X print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
X return(0);
X }
X if(scalar(@$x) != scalar(@$y)) {
X print STDERR "$t:DataCompare: expected ", scalar(@$x),
X " element(s), got: ", scalar(@$y), "\n";
X return(0);
X }
X for($i = 0; $i < scalar(@$x); $i++) {
X DataCompare($x->[$i], $y->[$i]) || return(0);
X }
X return(1);
X }
X
X if(ref($x) eq 'HASH') {
X unless(ref($y) eq 'HASH') {
X print STDERR "$t:DataCompare: expected hashref, got: $y\n";
X return(0);
X }
X if(scalar(keys(%$x)) != scalar(keys(%$y))) {
X print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
X " key(s) (", join(', ', keys(%$x)),
X "), got: ", scalar(keys(%$y)), " (", join(', ', keys(%$y)),
X ")\n";
X return(0);
X }
X foreach $i (keys(%$x)) {
X unless(exists($y->{$i})) {
X print STDERR "$t:DataCompare: missing hash key - {$i}\n";
X return(0);
X }
X DataCompare($x->{$i}, $y->{$i}) || return(0);
X }
X return(1);
X }
X
X print STDERR "Don't know how to compare: " . ref($x) . "\n";
X return(0);
X}
X
X
X##############################################################################
X# Copy a file
X#
X
Xsub CopyFile {
X my($Src, $Dst) = @_;
X
X open(IN, $Src) || return(undef);
X local($/) = undef;
X my $Data = <IN>;
X close(IN);
X
X open(OUT, ">$Dst") || return(undef);
X print OUT $Data;
X close(OUT);
X
X return(1);
X}
X
X
X##############################################################################
X# Wait until the current time is greater than the supplied value
X#
X
Xsub PassTime {
X my($Target) = @_;
X
X while(time <= $Target) {
X sleep 1;
X }
X}
X
X
X##############################################################################
X# T E S T R O U T I N E S
X##############################################################################
X
Xuse XML::SAX::Simple;
X
X# Initialise test data
X
Xmy $Expected = {
X 'server' => {
X 'sahara' => {
X 'osversion' => '2.6',
X 'osname' => 'solaris',
X 'address' => [
X '10.0.0.101',
X '10.0.1.101'
X ]
X },
X 'gobi' => {
X 'osversion' => '6.5',
X 'osname' => 'irix',
X 'address' => '10.0.0.102'
X },
X 'kalahari' => {
X 'osversion' => '2.0.34',
X 'osname' => 'linux',
X 'address' => [
X '10.0.0.103',
X '10.0.1.103'
X ]
X }
X }
X };
X
Xok(1, CopyFile($SrcFile, $XMLFile)); # Start with known source file
Xunlink($CacheFile); # Ensure there are ...
Xok(2, ! -e $CacheFile); # ... no cache files lying around
X
Xmy $opt = XMLin($XMLFile);
Xok(3, DataCompare($opt, $Expected)); # Got what we expected
Xok(4, ! -e $CacheFile); # And no cache file was created
XPassTime(time()); # Ensure cache file will be newer
X
X$opt = XMLin($XMLFile, cache => 'storable');
Xok(5, DataCompare($opt, $Expected)); # Got what we expected again
Xok(6, -e $CacheFile); # But this time a cache file was created
Xmy $t0 = (stat($CacheFile))[9]; # Remember cache timestamp
XPassTime($t0);
X
X$opt = XMLin($XMLFile, cache => 'storable');
Xok(7, DataCompare($opt, $Expected)); # Got what we expected from the cache
Xmy $t1 = (stat($CacheFile))[9]; # Check cache timestamp
Xok(8, $t0, $t1); # has not changed
X
XPassTime(time());
X$t0 = time();
Xopen(FILE, ">>$XMLFile"); # Touch the XML file
Xprint FILE "\n";
Xclose(FILE);
X$opt = XMLin($XMLFile, cache => 'storable');
Xok(9, DataCompare($opt, $Expected)); # Got what we expected
Xmy $t2 = (stat($CacheFile))[9]; # Check cache timestamp
Xok(10, $t1 != $t2); # has changed
X
Xunlink($XMLFile);
Xok(11, ! -e $XMLFile); # Original XML file is gone
Xopen(FILE, ">$XMLFile"); # Re-create it (empty)
Xclose(FILE);
Xutime($t1, $t1, $XMLFile); # but wind back the clock
X$t0 = (stat($XMLFile))[9]; # Skip these tests if that didn't work
Xif($t0 == $t1) {
X $opt = XMLin($XMLFile, cache => 'storable');
X ok(12, DataCompare($opt, $Expected)); # Got what we expected from the cache
X ok(13, ! -s $XMLFile); # even though the XML file is empty
X}
Xelse {
X print STDERR "no utime - skipping test 12...";
X ok(12, 1);
X ok(13, 1);
X}
X
XPassTime($t2);
Xopen(FILE, ">$XMLFile"); # Write some new data to the XML file
Xprint FILE qq(<opt one="1" two="2"></opt>\n);
Xclose(FILE);
X
X$opt = XMLin($XMLFile); # Parse with no caching
Xok(14, DataCompare($opt, { one => 1, two => 2})); # Got what we expected
X$t0 = (stat($CacheFile))[9]; # And timestamp on cache file
Xmy $s0 = (-s $CacheFile);
Xok(15, $t0 == $t2); # has not changed
X
X # Parse again with caching enabled
X$opt = XMLin($XMLFile, cache => 'storable');
X # Came through the cache
Xok(16, DataCompare($opt, { one => 1, two => 2}));
X$t1 = (stat($CacheFile))[9]; # which has been updated
Xmy $s1 = (-s $CacheFile);
Xok(17, ($t0 != $t1) || ($s0 != $s1)); # Content changes but date may not on Win32
X
Xok(18, CopyFile($SrcFile, $XMLFile)); # Put back the original file
XPassTime($t1);
X$opt = XMLin($XMLFile, cache => 'storable');
Xok(19, DataCompare($opt, $Expected)); # Got what we expected
X
X# Clean up and go
X
Xunlink($CacheFile);
Xunlink($XMLFile);
Xexit(0);
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/3_Storable.t
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t'
Xuse strict;
X
Xuse File::Spec;
X
X# Initialise filenames and check they're there
X
Xmy $SrcFile = File::Spec->catfile('t', 'desertnet.src');
Xmy $XMLFile = File::Spec->catfile('t', 'desertnet.xml');
X
Xunless(-e $SrcFile) {
X print STDERR "test data missing...";
X print "1..0\n";
X exit 0;
X}
X
Xprint "1..7\n";
X
Xmy $t = 1;
X
X##############################################################################
X# S U P P O R T R O U T I N E S
X##############################################################################
X
X##############################################################################
X# Print out 'n ok' or 'n not ok' as expected by test harness.
X# First arg is test number (n). If only one following arg, it is interpreted
X# as true/false value. If two args, equality = true.
X#
X
Xsub ok {
X my($n, $x, $y) = @_;
X die "Sequence error got $n expected $t" if($n != $t);
X $x = 0 if(@_ > 2 and $x ne $y);
X print(($x ? '' : 'not '), 'ok ', $t++, "\n");
X}
X
X
X##############################################################################
X# Take two scalar values (may be references) and compare them (recursively
X# if necessary) returning 1 if same, 0 if different.
X#
X
Xsub DataCompare {
X my($x, $y) = @_;
X
X my($i);
X
X if(!ref($x)) {
X return(1) if($x eq $y);
X print STDERR "$t:DataCompare: $x != $y\n";
X return(0);
X }
X
X if(ref($x) eq 'ARRAY') {
X unless(ref($y) eq 'ARRAY') {
X print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
X return(0);
X }
X if(scalar(@$x) != scalar(@$y)) {
X print STDERR "$t:DataCompare: expected ", scalar(@$x),
X " element(s), got: ", scalar(@$y), "\n";
X return(0);
X }
X for($i = 0; $i < scalar(@$x); $i++) {
X DataCompare($x->[$i], $y->[$i]) || return(0);
X }
X return(1);
X }
X
X if(ref($x) eq 'HASH') {
X unless(ref($y) eq 'HASH') {
X print STDERR "$t:DataCompare: expected hashref, got: $y\n";
X return(0);
X }
X if(scalar(keys(%$x)) != scalar(keys(%$y))) {
X print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
X " key(s) (", join(', ', keys(%$x)),
X "), got: ", scalar(keys(%$y)), " (", join(', ', keys(%$y)),
X ")\n";
X return(0);
X }
X foreach $i (keys(%$x)) {
X unless(exists($y->{$i})) {
X print STDERR "$t:DataCompare: missing hash key - {$i}\n";
X return(0);
X }
X DataCompare($x->{$i}, $y->{$i}) || return(0);
X }
X return(1);
X }
X
X print STDERR "Don't know how to compare: " . ref($x) . "\n";
X return(0);
X}
X
X
X##############################################################################
X# Copy a file
X#
X
Xsub CopyFile {
X my($Src, $Dst) = @_;
X
X open(IN, $Src) || return(undef);
X local($/) = undef;
X my $Data = <IN>;
X close(IN);
X
X open(OUT, ">$Dst") || return(undef);
X print OUT $Data;
X close(OUT);
X
X return(1);
X}
X
X
X##############################################################################
X# Wait until the current time is greater than the supplied value
X#
X
Xsub PassTime {
X my($Target) = @_;
X
X while(time <= $Target) {
X sleep 1;
X }
X}
X
X
X##############################################################################
X# T E S T R O U T I N E S
X##############################################################################
X
Xuse XML::SAX::Simple;
X
X# Initialise test data
X
Xmy $Expected = {
X 'server' => {
X 'sahara' => {
X 'osversion' => '2.6',
X 'osname' => 'solaris',
X 'address' => [
X '10.0.0.101',
X '10.0.1.101'
X ]
X },
X 'gobi' => {
X 'osversion' => '6.5',
X 'osname' => 'irix',
X 'address' => '10.0.0.102'
X },
X 'kalahari' => {
X 'osversion' => '2.0.34',
X 'osname' => 'linux',
X 'address' => [
X '10.0.0.103',
X '10.0.1.103'
X ]
X }
X }
X };
X
Xok(1, CopyFile($SrcFile, $XMLFile)); # Start with known source file
Xmy $t0 = (stat($XMLFile))[9]; # Remember its timestamp
X
X # Parse it with caching enabled
Xmy $opt = XMLin($XMLFile, cache => 'memshare');
Xok(2, DataCompare($opt, $Expected)); # Got what we expected
X
Xunlink($XMLFile);
Xok(3, ! -e $XMLFile); # Original XML file is gone
Xopen(FILE, ">$XMLFile"); # Re-create it (empty)
Xclose(FILE);
Xmy $t1 = $t0 - 1;
Xeval { utime($t1, $t1, $XMLFile); }; # but wind back the clock
Xmy $t2 = (stat($XMLFile))[9]; # Skip these tests if that didn't work
Xif($t2 >= $t0) {
X print STDERR "no utime - skipping test 4...";
X ok(4, 1);
X ok(5, 1);
X}
Xelse {
X $opt = XMLin($XMLFile, cache => 'memshare');
X ok(4, DataCompare($opt, $Expected)); # Got what we expected from the cache
X ok(5, ! -s $XMLFile); # even though the XML file is empty
X}
XPassTime(time()); # Ensure timestamp changes
X
X
Xopen(FILE, ">$XMLFile"); # Write some new data to the XML file
Xprint FILE qq(<opt one="1" two="2"></opt>\n);
Xclose(FILE);
XPassTime(time()); # Ensure current time later than file time
X
X # Parse again with caching enabled
X$opt = XMLin($XMLFile, cache => 'memshare');
X # Came through the cache
Xok(6, DataCompare($opt, { one => 1, two => 2}));
X
X$opt->{three} = 3; # Alter the returned structure
X # Retrieve again from the cache
Xmy $opt2 = XMLin($XMLFile, cache => 'memshare');
X
Xok(7, $opt2->{three}, 3); # Confirm cached version is altered too
X
X
Xexit(0);
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/4_MemShare.t
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t'
Xuse strict;
X
Xuse File::Spec;
X
Xeval { require Storable; };
Xunless($INC{'Storable.pm'}) {
X print STDERR "no Storable.pm...";
X print "1..0\n";
X exit;
X}
X
X# Initialise filenames and check they're there
X
Xmy $SrcFile = File::Spec->catfile('t', 'desertnet.src');
Xmy $XMLFile = File::Spec->catfile('t', 'desertnet.xml');
X
Xunless(-e $SrcFile) {
X print STDERR "test data missing...";
X print "1..0\n";
X exit 0;
X}
X
X
Xprint "1..7\n";
X
Xmy $t = 1;
X
X##############################################################################
X# S U P P O R T R O U T I N E S
X##############################################################################
X
X##############################################################################
X# Print out 'n ok' or 'n not ok' as expected by test harness.
X# First arg is test number (n). If only one following arg, it is interpreted
X# as true/false value. If two args, equality = true.
X#
X
Xsub ok {
X my($n, $x, $y) = @_;
X die "Sequence error got $n expected $t" if($n != $t);
X $x = 0 if(@_ > 2 and $x ne $y);
X print(($x ? '' : 'not '), 'ok ', $t++, "\n");
X}
X
X
X##############################################################################
X# Take two scalar values (may be references) and compare them (recursively
X# if necessary) returning 1 if same, 0 if different.
X#
X
Xsub DataCompare {
X my($x, $y) = @_;
X
X my($i);
X
X if(!ref($x)) {
X return(1) if($x eq $y);
X print STDERR "$t:DataCompare: $x != $y\n";
X return(0);
X }
X
X if(ref($x) eq 'ARRAY') {
X unless(ref($y) eq 'ARRAY') {
X print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
X return(0);
X }
X if(scalar(@$x) != scalar(@$y)) {
X print STDERR "$t:DataCompare: expected ", scalar(@$x),
X " element(s), got: ", scalar(@$y), "\n";
X return(0);
X }
X for($i = 0; $i < scalar(@$x); $i++) {
X DataCompare($x->[$i], $y->[$i]) || return(0);
X }
X return(1);
X }
X
X if(ref($x) eq 'HASH') {
X unless(ref($y) eq 'HASH') {
X print STDERR "$t:DataCompare: expected hashref, got: $y\n";
X return(0);
X }
X if(scalar(keys(%$x)) != scalar(keys(%$y))) {
X print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
X " key(s) (", join(', ', keys(%$x)),
X "), got: ", scalar(keys(%$y)), " (", join(', ', keys(%$y)),
X ")\n";
X return(0);
X }
X foreach $i (keys(%$x)) {
X unless(exists($y->{$i})) {
X print STDERR "$t:DataCompare: missing hash key - {$i}\n";
X return(0);
X }
X DataCompare($x->{$i}, $y->{$i}) || return(0);
X }
X return(1);
X }
X
X print STDERR "Don't know how to compare: " . ref($x) . "\n";
X return(0);
X}
X
X
X##############################################################################
X# Copy a file
X#
X
Xsub CopyFile {
X my($Src, $Dst) = @_;
X
X open(IN, $Src) || return(undef);
X local($/) = undef;
X my $Data = <IN>;
X close(IN);
X
X open(OUT, ">$Dst") || return(undef);
X print OUT $Data;
X close(OUT);
X
X return(1);
X}
X
X
X##############################################################################
X# Wait until the current time is greater than the supplied value
X#
X
Xsub PassTime {
X my($Target) = @_;
X
X while(time <= $Target) {
X sleep 1;
X }
X}
X
X
X##############################################################################
X# T E S T R O U T I N E S
X##############################################################################
X
Xuse XML::SAX::Simple;
X
X# Initialise test data
X
Xmy $Expected = {
X 'server' => {
X 'sahara' => {
X 'osversion' => '2.6',
X 'osname' => 'solaris',
X 'address' => [
X '10.0.0.101',
X '10.0.1.101'
X ]
X },
X 'gobi' => {
X 'osversion' => '6.5',
X 'osname' => 'irix',
X 'address' => '10.0.0.102'
X },
X 'kalahari' => {
X 'osversion' => '2.0.34',
X 'osname' => 'linux',
X 'address' => [
X '10.0.0.103',
X '10.0.1.103'
X ]
X }
X }
X };
X
Xok(1, CopyFile($SrcFile, $XMLFile)); # Start with known source file
Xmy $t0 = (stat($XMLFile))[9]; # Remember its timestamp
X
X # Parse it with caching enabled
Xmy $opt = XMLin($XMLFile, cache => 'memcopy');
Xok(2, DataCompare($opt, $Expected)); # Got what we expected
X
Xunlink($XMLFile);
Xok(3, ! -e $XMLFile); # Original XML file is gone
Xopen(FILE, ">$XMLFile"); # Re-create it (empty)
Xclose(FILE);
Xmy $t1 = $t0 - 1;
Xeval { utime($t1, $t1, $XMLFile); }; # but wind back the clock
Xmy $t2 = (stat($XMLFile))[9]; # Skip these tests if that didn't work
Xif($t2 >= $t0) {
X print STDERR "no utime - skipping test 4...";
X ok(4, 1);
X ok(5, 1);
X}
Xelse {
X $opt = XMLin($XMLFile, cache => 'memcopy');
X ok(4, DataCompare($opt, $Expected)); # Got what we expected from the cache
X ok(5, ! -s $XMLFile); # even though the XML file is empty
X}
X
X
XPassTime(time()); # Ensure source file will be newer
Xopen(FILE, ">$XMLFile"); # Write some new data to the XML file
Xprint FILE qq(<opt one="1" two="2"></opt>\n);
Xclose(FILE);
X
X # Parse again with caching enabled
X$opt = XMLin($XMLFile, cache => 'memcopy');
X # Came through the cache
Xok(6, DataCompare($opt, { one => 1, two => 2}));
X
X$opt->{three} = 3; # Alter the returned structure
X # Retrieve again from the cache
Xmy $opt2 = XMLin($XMLFile, cache => 'memcopy');
X
Xok(7, !defined($opt2->{three})); # Confirm cached copy is not altered
X
X
X# Clean up and go
X
Xunlink($XMLFile);
Xexit(0);
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/5_MemCopy.t
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t'
Xuse strict;
X
X##############################################################################
X# Derived version of XML::SAX::Simple that returns everything in lower case
X##############################################################################
X
Xpackage XML::Simple::UC;
X
Xuse vars qw(@ISA);
X@ISA = qw(XML::SAX::Simple);
X
Xsub build_tree {
X my $self = shift;
X
X my $tree = $self->SUPER::build_tree(@_);
X
X ($tree) = uctree($tree);
X
X return($tree);
X}
X
Xsub uctree {
X foreach my $i (0..$#_) {
X my $x = $_[$i];
X if(ref($x) eq 'ARRAY') {
X $_[$i] = [ uctree(@$x) ];
X }
X elsif(ref($x) eq 'HASH') {
X $_[$i] = { uctree(%$x) };
X }
X else {
X $_[$i] = uc($x);
X }
X }
X return(@_);
X}
X
X
X##############################################################################
X# Derived version of XML::SAX::Simple that uses CDATA sections for escaping
X##############################################################################
X
Xpackage XML::Simple::CDE;
X
Xuse vars qw(@ISA);
X@ISA = qw(XML::SAX::Simple);
X
Xsub escape_value {
X my $self = shift;
X
X my($data) = @_;
X
X if($data =~ /[&<>"]/) {
X $data = '<![CDATA[' . $data . ']]>';
X }
X
X return($data);
X}
X
X
X##############################################################################
X# Start of the test script itself
X##############################################################################
X
Xpackage main;
X
XBEGIN { print "1..27\n"; }
X
Xmy $t = 1;
X
X##############################################################################
X# S U P P O R T R O U T I N E S
X##############################################################################
X
X##############################################################################
X# Print out 'n ok' or 'n not ok' as expected by test harness.
X# First arg is test number (n). If only one following arg, it is interpreted
X# as true/false value. If two args, equality = true.
X#
X
Xsub ok {
X my($n, $x, $y) = @_;
X die "Sequence error got $n expected $t" if($n != $t);
X $x = 0 if(@_ > 2 and $x ne $y);
X print(($x ? '' : 'not '), 'ok ', $t++, "\n");
X}
X
X##############################################################################
X# Take two scalar values (may be references) and compare them (recursively
X# if necessary) returning 1 if same, 0 if different.
X#
X
Xsub DataCompare {
X my($x, $y) = @_;
X
X my($i);
X
X if(!ref($x)) {
X return(1) if($x eq $y);
X print STDERR "$t:DataCompare: $x != $y\n";
X return(0);
X }
X
X if(ref($x) eq 'ARRAY') {
X unless(ref($y) eq 'ARRAY') {
X print STDERR "$t:DataCompare: expected arrayref, got: $y\n";
X return(0);
X }
X if(scalar(@$x) != scalar(@$y)) {
X print STDERR "$t:DataCompare: expected ", scalar(@$x),
X " element(s), got: ", scalar(@$y), "\n";
X return(0);
X }
X for($i = 0; $i < scalar(@$x); $i++) {
X DataCompare($x->[$i], $y->[$i]) || return(0);
X }
X return(1);
X }
X
X if(ref($x) eq 'HASH') {
X unless(ref($y) eq 'HASH') {
X print STDERR "$t:DataCompare: expected hashref, got: $y\n";
X return(0);
X }
X if(scalar(keys(%$x)) != scalar(keys(%$y))) {
X print STDERR "$t:DataCompare: expected ", scalar(keys(%$x)),
X " key(s) (", join(', ', keys(%$x)),
X "), got: ", scalar(keys(%$y)), " (", join(', ', keys(%$y)),
X ")\n";
X return(0);
X }
X foreach $i (keys(%$x)) {
X unless(exists($y->{$i})) {
X print STDERR "$t:DataCompare: missing hash key - {$i}\n";
X return(0);
X }
X DataCompare($x->{$i}, $y->{$i}) || return(0);
X }
X return(1);
X }
X
X print STDERR "Don't know how to compare: " . ref($x) . "\n";
X return(0);
X}
X
X
X##############################################################################
X# Start the tests
X#
X
Xuse XML::SAX::Simple;
X
Xmy $xml = q(<cddatabase>
X <disc id="9362-45055-2" cddbid="960b750c">
X <artist>R.E.M.</artist>
X <album>Automatic For The People</album>
X <track number="1">Drive</track>
X <track number="2">Try Not To Breathe</track>
X <track number="3">The Sidewinder Sleeps Tonite</track>
X <track number="4">Everybody Hurts</track>
X <track number="5">New Orleans Instrumental No. 1</track>
X <track number="6">Sweetness Follows</track>
X <track number="7">Monty Got A Raw Deal</track>
X <track number="8">Ignoreland</track>
X <track number="9">Star Me Kitten</track>
X <track number="10">Man On The Moon</track>
X <track number="11">Nightswimming</track>
X <track number="12">Find The River</track>
X </disc>
X</cddatabase>
X);
X
Xmy %opts1 = (
X keyattr => { disc => 'cddbid', track => 'number' },
X keeproot => 1,
X contentkey => 'title',
X forcearray => [ qw(disc album) ]
X);
X
Xmy %opts2 = (
X keyattr => { }
X);
X
Xmy $xs1 = new XML::SAX::Simple( %opts1 );
Xmy $xs2 = new XML::SAX::Simple( %opts2 );
Xok(1, $xs1); # Object created successfully
Xok(2, $xs2); # and another
Xok(3, DataCompare(\%opts1, { # Options values not corrupted
X keyattr => { disc => 'cddbid', track => 'number' },
X keeproot => 1,
X contentkey => 'title',
X forcearray => [ qw(disc album) ]
X}));
X
Xmy $exp1 = {
X 'cddatabase' => {
X 'disc' => {
X '960b750c' => {
X 'id' => '9362-45055-2',
X 'album' => [ 'Automatic For The People' ],
X 'artist' => 'R.E.M.',
X 'track' => {
X 1 => { 'title' => 'Drive' },
X 2 => { 'title' => 'Try Not To Breathe' },
X 3 => { 'title' => 'The Sidewinder Sleeps Tonite' },
X 4 => { 'title' => 'Everybody Hurts' },
X 5 => { 'title' => 'New Orleans Instrumental No. 1' },
X 6 => { 'title' => 'Sweetness Follows' },
X 7 => { 'title' => 'Monty Got A Raw Deal' },
X 8 => { 'title' => 'Ignoreland' },
X 9 => { 'title' => 'Star Me Kitten' },
X 10 => { 'title' => 'Man On The Moon' },
X 11 => { 'title' => 'Nightswimming' },
X 12 => { 'title' => 'Find The River' }
X }
X }
X }
X }
X};
X
Xmy $ref1 = $xs1->XMLin($xml);
Xok(4, DataCompare($ref1, $exp1)); # Parsed to what we expected
X
X
X# Try using the other object
X
Xmy $exp2 = {
X 'disc' => {
X 'album' => 'Automatic For The People',
X 'artist' => 'R.E.M.',
X 'cddbid' => '960b750c',
X 'id' => '9362-45055-2',
X 'track' => [
X { 'number' => 1, 'content' => 'Drive' },
X { 'number' => 2, 'content' => 'Try Not To Breathe' },
X { 'number' => 3, 'content' => 'The Sidewinder Sleeps Tonite' },
X { 'number' => 4, 'content' => 'Everybody Hurts' },
X { 'number' => 5, 'content' => 'New Orleans Instrumental No. 1' },
X { 'number' => 6, 'content' => 'Sweetness Follows' },
X { 'number' => 7, 'content' => 'Monty Got A Raw Deal' },
X { 'number' => 8, 'content' => 'Ignoreland' },
X { 'number' => 9, 'content' => 'Star Me Kitten' },
X { 'number' => 10, 'content' => 'Man On The Moon' },
X { 'number' => 11, 'content' => 'Nightswimming' },
X { 'number' => 12, 'content' => 'Find The River' }
X ]
X }
X};
X
Xmy $ref2 = $xs2->XMLin($xml);
Xok(5, DataCompare($ref2, $exp2)); # Parsed to what we expected
X
X
X
X# Confirm default options in object merge correctly with options as args
X
X$ref1 = $xs1->XMLin($xml, keyattr => [], forcearray => 0);
X
Xok(6, DataCompare($ref1, { # Parsed to what we expected
X 'cddatabase' => {
X 'disc' => {
X 'album' => 'Automatic For The People',
X 'id' => '9362-45055-2',
X 'artist' => 'R.E.M.',
X 'cddbid' => '960b750c',
X 'track' => [
X { 'number' => 1, 'title' => 'Drive' },
X { 'number' => 2, 'title' => 'Try Not To Breathe' },
X { 'number' => 3, 'title' => 'The Sidewinder Sleeps Tonite' },
X { 'number' => 4, 'title' => 'Everybody Hurts' },
X { 'number' => 5, 'title' => 'New Orleans Instrumental No. 1' },
X { 'number' => 6, 'title' => 'Sweetness Follows' },
X { 'number' => 7, 'title' => 'Monty Got A Raw Deal' },
X { 'number' => 8, 'title' => 'Ignoreland' },
X { 'number' => 9, 'title' => 'Star Me Kitten' },
X { 'number' => 10, 'title' => 'Man On The Moon' },
X { 'number' => 11, 'title' => 'Nightswimming' },
X { 'number' => 12, 'title' => 'Find The River' }
X ]
X }
X }
X}));
X
X
X# Confirm that default options in object still work as expected
X
X$ref1 = $xs1->XMLin($xml);
Xok(7, DataCompare($ref1, $exp1)); # Still parsed to what we expected
X
X
X# Confirm they work for output too
X
X$_ = $xs1->XMLout($ref1);
X
Xok(8, s{<track number="1">Drive</track>} {<NEST/>});
Xok(9, s{<track number="2">Try Not To Breathe</track>} {<NEST/>});
Xok(10, s{<track number="3">The Sidewinder Sleeps Tonite</track>} {<NEST/>});
Xok(11, s{<track number="4">Everybody Hurts</track>} {<NEST/>});
Xok(12, s{<track number="5">New Orleans Instrumental No. 1</track>}{<NEST/>});
Xok(13, s{<track number="6">Sweetness Follows</track>} {<NEST/>});
Xok(14, s{<track number="7">Monty Got A Raw Deal</track>} {<NEST/>});
Xok(15, s{<track number="8">Ignoreland</track>} {<NEST/>});
Xok(16, s{<track number="9">Star Me Kitten</track>} {<NEST/>});
Xok(17, s{<track number="10">Man On The Moon</track>} {<NEST/>});
Xok(18, s{<track number="11">Nightswimming</track>} {<NEST/>});
Xok(19, s{<track number="12">Find The River</track>} {<NEST/>});
Xok(20, s{<album>Automatic For The People</album>} {<NEST/>});
Xok(21, s{cddbid="960b750c"}{ATTR});
Xok(22, s{id="9362-45055-2"}{ATTR});
Xok(23, s{artist="R.E.M."} {ATTR});
Xok(24, s{<disc(\s+ATTR){3}\s*>(\s*<NEST/>){13}\s*</disc>}{<DISC/>}s);
Xok(25, m{^\s*<(cddatabase)>\s*<DISC/>\s*</\1>\s*$});
X
X
X# Check that overriding build_tree() method works
X
X$xml = q(<opt>
X <server>
X <name>Apollo</name>
X <address>10 Downing Street</address>
X </server>
X</opt>
X);
X
Xmy $xsp = new XML::Simple::UC();
X$ref1 = $xsp->XMLin($xml);
Xok(26, DataCompare($ref1, {
X 'SERVER' => {
X 'NAME' => 'APOLLO',
X 'ADDRESS' => '10 DOWNING STREET'
X }
X}));
X
X
X# Check that overriding escape_value() method works
X
Xmy $ref = {
X 'server' => {
X 'address' => '12->14 "Puf&Stuf" Drive'
X }
X};
X
X$xsp = new XML::Simple::CDE();
X
X$_ = $xsp->XMLout($ref);
X
Xok(27, m{<opt>\s*
X <server\s+address="<!\[CDATA\[12->14\s+"Puf&Stuf"\s+Drive\]\]>"\s*/>\s*
X</opt>}xs);
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/6_ObjIntf.t
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src'
X<config>
X <server name="sahara" osname="solaris" osversion="2.6">
X <address>10.0.0.101</address>
X <address>10.0.1.101</address>
X </server>
X <server name="gobi" osname="irix" osversion="6.5">
X <address>10.0.0.102</address>
X </server>
X <server name="kalahari" osname="linux" osversion="2.0.34">
X <address>10.0.0.103</address>
X <address>10.0.1.103</address>
X </server>
X</config>
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/desertnet.src
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml'
X<?xml version='1.0' standalone='yes'?>
X
X<!--
X
X This is an example of what a simple config file used by the System Release
X Tool (SRT) might look like. The file itself doesn't do anything other
X than serve as a moderately complex test case for t/1_XMLin.t.
X
X If you would like to find out more about the SRT, email the author at:
X
X grantm@web.co.nz
X
X-->
X
X<opt>
X <global tempdir="C:/Temp"
X httpproxy="http://10.1.1.5:8080/"
X proxyuser="foo"
X proxypswd="bar" >
X
X <exclude>/_vt</exclude>
X <exclude>/save\b</exclude>
X <exclude>\.bak$</exclude>
X <exclude>\.\$\$\$$</exclude>
X
X </global>
X
X <pubpath name="test1" title="web_source -> web_target1">
X <source label="web_source"
X root="C:/webshare/web_source" />
X <target label="web_target1"
X root="C:/webshare/web_target1"
X temp="C:/webshare/web_target1/temp" />
X
X <dir>wwwroot</dir>
X
X <package name="images" dir="wwwroot/images" />
X
X </pubpath>
X
X <pubpath name="test2" title="web_source -> web_target1 & web_target2">
X <source label="web_source"
X root="C:/webshare/web_source" />
X <target label="web_target1"
X root="C:/webshare/web_target1"
X temp="C:/webshare/web_target1/temp" />
X <target label="web_target2"
X root="C:/webshare/web_target2"
X temp="C:/webshare/web_target2/temp" />
X
X <dir>wwwroot</dir>
X
X <package name="images" dir="wwwroot/images" />
X <package name="templates" dir="wwwroot/templates" />
X <package name="bios" dir="wwwroot/staff/bios" />
X
X </pubpath>
X
X <pubpath name="test3" title="web_source -> web_target1 via HTTP">
X <source label="web_source"
X root="C:/webshare/web_source" />
X <target label="web_target1"
X root="http://127.0.0.1/cgi-bin/srt_slave.plx"
X noproxy="1" />
X
X <dir>wwwroot</dir>
X
X <addexclude>\.pdf$</addexclude>
X
X </pubpath>
X
X</opt>
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/srt.xml
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir > /dev/null 2>&1
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml'
X<opt location="t/subdir/test2.xml" />
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/subdir/test2.xml
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml'
X<opt location="t/test1.xml" />
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/t/test1.xml
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX > /dev/null 2>&1
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists'
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/.exists
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm'
X# $Id: Simple.pm,v 1.1.1.1 2001/11/13 14:07:40 matt Exp $
X
Xpackage XML::SAX::Simple;
X
Xuse strict;
Xuse vars qw($VERSION @ISA @EXPORT);
Xuse XML::Simple ();
Xuse XML::SAX;
Xuse XML::Handler::Trees;
X@ISA = ('XML::Simple');
X
X$VERSION = '0.01';
X
X@EXPORT = qw(XMLin XMLout);
X
Xsub XMLin {
X my $self;
X if($_[0] and UNIVERSAL::isa($_[0], 'XML::Simple')) {
X $self = shift;
X }
X else {
X $self = new XML::SAX::Simple();
X }
X $self->SUPER::XMLin(@_);
X}
X
Xsub XMLout {
X my $self;
X if($_[0] and UNIVERSAL::isa($_[0], 'XML::Simple')) {
X $self = shift;
X }
X else {
X $self = new XML::SAX::Simple();
X }
X $self->SUPER::XMLout(@_);
X}
X
Xsub build_tree {
X my $self = shift;
X my ($filename, $string) = @_;
X
X if($filename and $filename eq '-') {
X local($/);
X $string = <STDIN>;
X $filename = undef;
X }
X
X my $handler = XML::Handler::Tree->new();
X my $parser = XML::SAX::ParserFactory->parser(Handler => $handler);
X my $tree;
X if($filename) {
X $tree = $parser->parse_uri($filename);
X }
X else {
X if (ref($string)) {
X $tree = $parser->parse_file($string);
X }
X else {
X $tree = $parser->parse_string($string);
X }
X }
X
X # use Data::Dumper;
X # warn("returning ", Dumper($tree), "\n");
X return($tree);
X}
X
X1;
X__END__
X
X=head1 NAME
X
XXML::SAX::Simple - SAX version of XML::Simple
X
X=head1 SYNOPSIS
X
X use XML::SAX::Simple qw(XMLin XMLout);
X my $hash = XMLin("foo.xml");
X
X=head1 DESCRIPTION
X
XXML::SAX::Simple is a very simple version of XML::Simple but for
XSAX. It can be used as a complete drop-in replacement for XML::Simple.
X
XSee the documentation for XML::Simple (which is required for this module
Xto work) for details.
X
X=head1 AUTHOR
X
XMatt Sergeant, matt@sergeant.org
X
X=head1 SEE ALSO
X
XL<XML::Simple>, L<XML::SAX>.
X
X=cut
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/XML/SAX/Simple.pm
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple > /dev/null 2>&1
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists'
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/lib/auto/XML/SAX/Simple/.exists
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX > /dev/null 2>&1
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple > /dev/null 2>&1
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists'
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/arch/auto/XML/SAX/Simple/.exists
echo c - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3
mkdir -p p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3 > /dev/null 2>&1
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists'
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/.exists
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3 << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3'
X.rn '' }`
X''' $RCSfile$$Revision$$Date$
X'''
X''' $Log$
X'''
X.de Sh
X.br
X.if t .Sp
X.ne 5
X.PP
X\fB\\$1\fR
X.PP
X..
X.de Sp
X.if t .sp .5v
X.if n .sp
X..
X.de Ip
X.br
X.ie \\n(.$>=3 .ne \\$3
X.el .ne 3
X.IP "\\$1" \\$2
X..
X.de Vb
X.ft CW
X.nf
X.ne \\$1
X..
X.de Ve
X.ft R
X
X.fi
X..
X'''
X'''
X''' Set up \*(-- to give an unbreakable dash;
X''' string Tr holds user defined translation string.
X''' Bell System Logo is used as a dummy character.
X'''
X.tr \(*W-|\(bv\*(Tr
X.ie n \{\
X.ds -- \(*W-
X.ds PI pi
X.if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
X.if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch
X.ds L" ""
X.ds R" ""
X''' \*(M", \*(S", \*(N" and \*(T" are the equivalent of
X''' \*(L" and \*(R", except that they are used on ".xx" lines,
X''' such as .IP and .SH, which do another additional levels of
X''' double-quote interpretation
X.ds M" """
X.ds S" """
X.ds N" """""
X.ds T" """""
X.ds L' '
X.ds R' '
X.ds M' '
X.ds S' '
X.ds N' '
X.ds T' '
X'br\}
X.el\{\
X.ds -- \(em\|
X.tr \*(Tr
X.ds L" ``
X.ds R" ''
X.ds M" ``
X.ds S" ''
X.ds N" ``
X.ds T" ''
X.ds L' `
X.ds R' '
X.ds M' `
X.ds S' '
X.ds N' `
X.ds T' '
X.ds PI \(*p
X'br\}
X.\" If the F register is turned on, we'll generate
X.\" index entries out stderr for the following things:
X.\" TH Title
X.\" SH Header
X.\" Sh Subsection
X.\" Ip Item
X.\" X<> Xref (embedded
X.\" Of course, you have to process the output yourself
X.\" in some meaninful fashion.
X.if \nF \{
X.de IX
X.tm Index:\\$1\t\\n%\t"\\$2"
X..
X.nr % 0
X.rr F
X.\}
X.TH Simple 3 "perl 5.005, patch 03" "13/Nov/2001" "User Contributed Perl Documentation"
X.UC
X.if n .hy 0
X.if n .na
X.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
X.de CQ \" put $1 in typewriter font
X.ft CW
X'if n "\c
X'if t \\&\\$1\c
X'if n \\&\\$1\c
X'if n \&"
X\\&\\$2 \\$3 \\$4 \\$5 \\$6 \\$7
X'.ft R
X..
X.\" @(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2
X. \" AM - accent mark definitions
X.bd B 3
X. \" fudge factors for nroff and troff
X.if n \{\
X. ds #H 0
X. ds #V .8m
X. ds #F .3m
X. ds #[ \f1
X. ds #] \fP
X.\}
X.if t \{\
X. ds #H ((1u-(\\\\n(.fu%2u))*.13m)
X. ds #V .6m
X. ds #F 0
X. ds #[ \&
X. ds #] \&
X.\}
X. \" simple accents for nroff and troff
X.if n \{\
X. ds ' \&
X. ds ` \&
X. ds ^ \&
X. ds , \&
X. ds ~ ~
X. ds ? ?
X. ds ! !
X. ds /
X. ds q
X.\}
X.if t \{\
X. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
X. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
X. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
X. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
X. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
X. ds ? \s-2c\h'-\w'c'u*7/10'\u\h'\*(#H'\zi\d\s+2\h'\w'c'u*8/10'
X. ds ! \s-2\(or\s+2\h'-\w'\(or'u'\v'-.8m'.\v'.8m'
X. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
X. ds q o\h'-\w'o'u*8/10'\s-4\v'.4m'\z\(*i\v'-.4m'\s+4\h'\w'o'u*8/10'
X.\}
X. \" troff and (daisy-wheel) nroff accents
X.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
X.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
X.ds v \\k:\h'-(\\n(.wu*9/10-\*(#H)'\v'-\*(#V'\*(#[\s-4v\s0\v'\*(#V'\h'|\\n:u'\*(#]
X.ds _ \\k:\h'-(\\n(.wu*9/10-\*(#H+(\*(#F*2/3))'\v'-.4m'\z\(hy\v'.4m'\h'|\\n:u'
X.ds . \\k:\h'-(\\n(.wu*8/10)'\v'\*(#V*4/10'\z.\v'-\*(#V*4/10'\h'|\\n:u'
X.ds 3 \*(#[\v'.2m'\s-2\&3\s0\v'-.2m'\*(#]
X.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
X.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
X.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
X.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
X.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
X.ds ae a\h'-(\w'a'u*4/10)'e
X.ds Ae A\h'-(\w'A'u*4/10)'E
X.ds oe o\h'-(\w'o'u*4/10)'e
X.ds Oe O\h'-(\w'O'u*4/10)'E
X. \" corrections for vroff
X.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
X.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
X. \" for low resolution devices (crt and lpr)
X.if \n(.H>23 .if \n(.V>19 \
X\{\
X. ds : e
X. ds 8 ss
X. ds v \h'-1'\o'\(aa\(ga'
X. ds _ \h'-1'^
X. ds . \h'-1'.
X. ds 3 3
X. ds o a
X. ds d- d\h'-1'\(ga
X. ds D- D\h'-1'\(hy
X. ds th \o'bp'
X. ds Th \o'LP'
X. ds ae ae
X. ds Ae AE
X. ds oe oe
X. ds Oe OE
X.\}
X.rm #[ #] #H #V #F C
X.SH "NAME"
XXML::SAX::Simple \- SAX version of XML::Simple
X.SH "SYNOPSIS"
X.PP
X.Vb 2
X\& use XML::SAX::Simple qw(XMLin XMLout);
X\& my $hash = XMLin("foo.xml");
X.Ve
X.SH "DESCRIPTION"
XXML::SAX::Simple is a very simple version of XML::Simple but for
XSAX. It can be used as a complete drop-in replacement for XML::Simple.
X.PP
XSee the documentation for XML::Simple (which is required for this module
Xto work) for details.
X.SH "AUTHOR"
XMatt Sergeant, matt@sergeant.org
X.SH "SEE ALSO"
Xthe \fIXML::Simple\fR manpage, the \fIXML::SAX\fR manpage.
X
X.rn }` ''
X.IX Title "Simple 3"
X.IX Name "XML::SAX::Simple - SAX version of XML::Simple"
X
X.IX Header "NAME"
X
X.IX Header "SYNOPSIS"
X
X.IX Header "DESCRIPTION"
X
X.IX Header "AUTHOR"
X
X.IX Header "SEE ALSO"
X
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/blib/man3/XML::SAX::Simple.3
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile'
X# This Makefile is for the XML::SAX::Simple extension to perl.
X#
X# It was generated automatically by MakeMaker version
X# 5.4302 (Revision: 1.222) from the contents of
X# Makefile.PL. Don't edit this file, edit Makefile.PL instead.
X#
X# ANY CHANGES MADE HERE WILL BE LOST!
X#
X# MakeMaker ARGV: (q[CC=cc], q[CCFLAGS=-O -pipe ], q[PREFIX=/usr/local])
X#
X# MakeMaker Parameters:
X
X# ABSTRACT_FROM => q[Simple.pm]
X# AUTHOR => q[Matt Sergeant, <matt@sergeant.org>]
X# NAME => q[XML::SAX::Simple]
X# PREREQ_PM => { XML::SAX=>q[0.02], XML::Handler::Trees=>q[0.02], XML::Simple=>q[1.06] }
X# VERSION_FROM => q[Simple.pm]
X
X# --- MakeMaker post_initialize section:
X
X
X# --- MakeMaker const_config section:
X
X# These definitions are from config.sh (via /usr/libdata/perl/5.00503/mach/Config.pm)
X
X# They may have been overridden via Makefile.PL or on the command line
XAR = ar
XCC = cc
XCCCDLFLAGS = -DPIC -fpic
XCCDLFLAGS = -Wl,-R/usr/lib
XDLEXT = so
XDLSRC = dl_dlopen.xs
XLD = cc
XLDDLFLAGS = -Wl,-E -shared -lperl -lm
XLDFLAGS = -Wl,-E -lperl -lm
XLIBC =
XLIB_EXT = .a
XOBJ_EXT = .o
XOSNAME = freebsd
XOSVERS = 4.0-current
XRANLIB = :
XSO = so
XEXE_EXT =
X
X
X# --- MakeMaker constants section:
XAR_STATIC_ARGS = cr
XNAME = XML::SAX::Simple
XDISTNAME = XML-SAX-Simple
XNAME_SYM = XML_SAX_Simple
XVERSION = 0.01
XVERSION_SYM = 0_01
XXS_VERSION = 0.01
XINST_BIN = blib/bin
XINST_EXE = blib/script
XINST_LIB = blib/lib
XINST_ARCHLIB = blib/arch
XINST_SCRIPT = blib/script
XPREFIX = /usr/local
XINSTALLDIRS = site
XINSTALLPRIVLIB = /usr/libdata/perl/5.00503
XINSTALLARCHLIB = /usr/libdata/perl/5.00503/mach
XINSTALLSITELIB = /usr/local/lib/perl5/site_perl/5.005
XINSTALLSITEARCH = /usr/local/lib/perl5/site_perl/5.005/i386-freebsd
XINSTALLBIN = $(PREFIX)/bin
XINSTALLSCRIPT = $(PREFIX)/bin
XPERL_LIB = /usr/libdata/perl/5.00503
XPERL_ARCHLIB = /usr/libdata/perl/5.00503/mach
XSITELIBEXP = /usr/local/lib/perl5/site_perl/5.005
XSITEARCHEXP = /usr/local/lib/perl5/site_perl/5.005/i386-freebsd
XLIBPERL_A = libperl.a
XFIRST_MAKEFILE = Makefile
XMAKE_APERL_FILE = Makefile.aperl
XPERLMAINCC = $(CC)
XPERL_INC = /usr/libdata/perl/5.00503/mach/CORE
XPERL = /usr/bin/perl5.00503
XFULLPERL = /usr/bin/perl5.00503
X
XVERSION_MACRO = VERSION
XDEFINE_VERSION = -D$(VERSION_MACRO)=\"$(VERSION)\"
XXS_VERSION_MACRO = XS_VERSION
XXS_DEFINE_VERSION = -D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"
X
XMAKEMAKER = /usr/libdata/perl/5.00503/ExtUtils/MakeMaker.pm
XMM_VERSION = 5.4302
X
X# FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
X# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
X# ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD) !!! Deprecated from MM 5.32 !!!
X# PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
X# DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
XFULLEXT = XML/SAX/Simple
XBASEEXT = Simple
XPARENT_NAME = XML::SAX
XDLBASE = $(BASEEXT)
XVERSION_FROM = Simple.pm
XOBJECT =
XLDFROM = $(OBJECT)
XLINKTYPE = dynamic
X
X# Handy lists of source code files:
XXS_FILES=
XC_FILES =
XO_FILES =
XH_FILES =
XMAN1PODS =
XMAN3PODS = Simple.pm
XINST_MAN1DIR = blib/man1
XINSTALLMAN1DIR = /usr/local/man/man1
XMAN1EXT = 1
XINST_MAN3DIR = blib/man3
XINSTALLMAN3DIR = /usr/local/lib/perl5/5.00503/man/man3
XMAN3EXT = 3
XPERM_RW = 644
XPERM_RWX = 755
X
X# work around a famous dec-osf make(1) feature(?):
Xmakemakerdflt: all
X
X.SUFFIXES: .xs .c .C .cpp .cxx .cc $(OBJ_EXT)
X
X# Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
X# some make implementations will delete the Makefile when we rebuild it. Because
X# we call false(1) when we rebuild it. So make(1) is not completely wrong when it
X# does so. Our milage may vary.
X# .PRECIOUS: Makefile # seems to be not necessary anymore
X
X.PHONY: all config static dynamic test linkext manifest
X
X# Where is the Config information that we are using/depend on
XCONFIGDEP = $(PERL_ARCHLIB)/Config.pm $(PERL_INC)/config.h
X
X# Where to put things:
XINST_LIBDIR = $(INST_LIB)/XML/SAX
XINST_ARCHLIBDIR = $(INST_ARCHLIB)/XML/SAX
X
XINST_AUTODIR = $(INST_LIB)/auto/$(FULLEXT)
XINST_ARCHAUTODIR = $(INST_ARCHLIB)/auto/$(FULLEXT)
X
XINST_STATIC =
XINST_DYNAMIC =
XINST_BOOT =
X
XEXPORT_LIST =
X
XPERL_ARCHIVE =
X
XTO_INST_PM = Simple.pm
X
XPM_TO_BLIB = Simple.pm \
X $(INST_LIBDIR)/Simple.pm
X
X
X# --- MakeMaker tool_autosplit section:
X
X# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
XAUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
X
X
X# --- MakeMaker tool_xsubpp section:
X
X
X# --- MakeMaker tools_other section:
X
XSHELL = /bin/sh
XCHMOD = chmod
XCP = cp
XLD = cc
XMV = mv
XNOOP = $(SHELL) -c true
XRM_F = rm -f
XRM_RF = rm -rf
XTEST_F = test -f
XTOUCH = touch
XUMASK_NULL = umask 0
XDEV_NULL = > /dev/null 2>&1
X
X# The following is a portable way to say mkdir -p
X# To see which directories are created, change the if 0 to if 1
XMKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
X
X# This helps us to minimize the effect of the .exists files A yet
X# better solution would be to have a stable file in the perl
X# distribution with a timestamp of zero. But this solution doesn't
X# need any changes to the core distribution and works with older perls
XEQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
X
X# Here we warn users that an old packlist file was found somewhere,
X# and that they should call some uninstall routine
XWARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \
X-e 'print "WARNING: I have found an old package in\n";' \
X-e 'print "\t$$ARGV[0].\n";' \
X-e 'print "Please make sure the two installations are not conflicting\n";'
X
XUNINST=0
XVERBINST=1
X
XMOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
X-e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
X
XDOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
X-e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", shift, ">";' \
X-e 'print "=over 4";' \
X-e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
X-e 'print "=back";'
X
XUNINSTALL = $(PERL) -MExtUtils::Install \
X-e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
X-e 'print " packlist above carefully.\n There may be errors. Remove the";' \
X-e 'print " appropriate files manually.\n Sorry for the inconveniences.\n"'
X
X
X# --- MakeMaker dist section:
X
XDISTVNAME = $(DISTNAME)-$(VERSION)
XTAR = tar
XTARFLAGS = cvf
XZIP = zip
XZIPFLAGS = -r
XCOMPRESS = gzip --best
XSUFFIX = .gz
XSHAR = shar
XPREOP = @$(NOOP)
XPOSTOP = @$(NOOP)
XTO_UNIX = @$(NOOP)
XCI = ci -u
XRCS_LABEL = rcs -Nv$(VERSION_SYM): -q
XDIST_CP = best
XDIST_DEFAULT = tardist
X
X
X# --- MakeMaker macro section:
X
X
X# --- MakeMaker depend section:
X
X
X# --- MakeMaker cflags section:
X
X
X# --- MakeMaker const_loadlibs section:
X
X
X# --- MakeMaker const_cccmd section:
X
X
X# --- MakeMaker post_constants section:
X
X
X# --- MakeMaker pasthru section:
X
XPASTHRU = LIB="$(LIB)"\
X LIBPERL_A="$(LIBPERL_A)"\
X LINKTYPE="$(LINKTYPE)"\
X PREFIX="$(PREFIX)"\
X OPTIMIZE="$(OPTIMIZE)"
X
X
X# --- MakeMaker c_o section:
X
X
X# --- MakeMaker xs_c section:
X
X
X# --- MakeMaker xs_o section:
X
X
X# --- MakeMaker top_targets section:
X
X#all :: config $(INST_PM) subdirs linkext manifypods
X
Xall :: pure_all manifypods
X @$(NOOP)
X
Xpure_all :: config pm_to_blib subdirs linkext
X @$(NOOP)
X
Xsubdirs :: $(MYEXTLIB)
X @$(NOOP)
X
Xconfig :: Makefile $(INST_LIBDIR)/.exists
X @$(NOOP)
X
Xconfig :: $(INST_ARCHAUTODIR)/.exists
X @$(NOOP)
X
Xconfig :: $(INST_AUTODIR)/.exists
X @$(NOOP)
X
Xconfig :: Version_check
X @$(NOOP)
X
X
X$(INST_AUTODIR)/.exists :: /usr/libdata/perl/5.00503/mach/CORE/perl.h
X @$(MKPATH) $(INST_AUTODIR)
X @$(EQUALIZE_TIMESTAMP) /usr/libdata/perl/5.00503/mach/CORE/perl.h $(INST_AUTODIR)/.exists
X
X -@$(CHMOD) $(PERM_RWX) $(INST_AUTODIR)
X
X$(INST_LIBDIR)/.exists :: /usr/libdata/perl/5.00503/mach/CORE/perl.h
X @$(MKPATH) $(INST_LIBDIR)
X @$(EQUALIZE_TIMESTAMP) /usr/libdata/perl/5.00503/mach/CORE/perl.h $(INST_LIBDIR)/.exists
X
X -@$(CHMOD) $(PERM_RWX) $(INST_LIBDIR)
X
X$(INST_ARCHAUTODIR)/.exists :: /usr/libdata/perl/5.00503/mach/CORE/perl.h
X @$(MKPATH) $(INST_ARCHAUTODIR)
X @$(EQUALIZE_TIMESTAMP) /usr/libdata/perl/5.00503/mach/CORE/perl.h $(INST_ARCHAUTODIR)/.exists
X
X -@$(CHMOD) $(PERM_RWX) $(INST_ARCHAUTODIR)
X
Xconfig :: $(INST_MAN3DIR)/.exists
X @$(NOOP)
X
X
X$(INST_MAN3DIR)/.exists :: /usr/libdata/perl/5.00503/mach/CORE/perl.h
X @$(MKPATH) $(INST_MAN3DIR)
X @$(EQUALIZE_TIMESTAMP) /usr/libdata/perl/5.00503/mach/CORE/perl.h $(INST_MAN3DIR)/.exists
X
X -@$(CHMOD) $(PERM_RWX) $(INST_MAN3DIR)
X
Xhelp:
X perldoc ExtUtils::MakeMaker
X
XVersion_check:
X @$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
X -MExtUtils::MakeMaker=Version_check \
X -e "Version_check('$(MM_VERSION)')"
X
X
X# --- MakeMaker linkext section:
X
Xlinkext :: $(LINKTYPE)
X @$(NOOP)
X
X
X# --- MakeMaker dlsyms section:
X
X
X# --- MakeMaker dynamic section:
X
X## $(INST_PM) has been moved to the all: target.
X## It remains here for awhile to allow for old usage: "make dynamic"
X#dynamic :: Makefile $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
Xdynamic :: Makefile $(INST_DYNAMIC) $(INST_BOOT)
X @$(NOOP)
X
X
X# --- MakeMaker dynamic_bs section:
X
XBOOTSTRAP =
X
X
X# --- MakeMaker dynamic_lib section:
X
X
X# --- MakeMaker static section:
X
X## $(INST_PM) has been moved to the all: target.
X## It remains here for awhile to allow for old usage: "make static"
X#static :: Makefile $(INST_STATIC) $(INST_PM)
Xstatic :: Makefile $(INST_STATIC)
X @$(NOOP)
X
X
X# --- MakeMaker static_lib section:
X
X
X# --- MakeMaker manifypods section:
XPOD2MAN_EXE = /usr/bin/pod2man
XPOD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \
X-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "Makefile";' \
X-e 'print "Manifying $$m{$$_}\n";' \
X-e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\047t install $$m{$$_}\n";' \
X-e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
X
Xmanifypods : pure_all Simple.pm
X @$(POD2MAN) \
X Simple.pm \
X $(INST_MAN3DIR)/XML::SAX::Simple.$(MAN3EXT)
X
X# --- MakeMaker processPL section:
X
X
X# --- MakeMaker installbin section:
X
X
X# --- MakeMaker subdirs section:
X
X# none
X
X# --- MakeMaker clean section:
X
X# Delete temporary files but do not touch installed files. We don't delete
X# the Makefile here so a later make realclean still has a makefile to use.
X
Xclean ::
X -rm -rf ./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all perlmain.c mon.out core so_locations pm_to_blib *~ */*~ */*/*~ *$(OBJ_EXT) *$(LIB_EXT) perl.exe $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def $(BASEEXT).exp
X -mv Makefile Makefile.old $(DEV_NULL)
X
X
X# --- MakeMaker realclean section:
X
X# Delete temporary files (via clean) and also delete installed files
Xrealclean purge :: clean
X rm -rf $(INST_AUTODIR) $(INST_ARCHAUTODIR)
X rm -f $(INST_LIBDIR)/Simple.pm
X rm -rf Makefile Makefile.old
X
X
X# --- MakeMaker dist_basics section:
X
Xdistclean :: realclean distcheck
X
Xdistcheck :
X $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=fullcheck \
X -e fullcheck
X
Xskipcheck :
X $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=skipcheck \
X -e skipcheck
X
Xmanifest :
X $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=mkmanifest \
X -e mkmanifest
X
X
X# --- MakeMaker dist_core section:
X
Xdist : $(DIST_DEFAULT)
X @$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
X -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "Makefile";'
X
Xtardist : $(DISTVNAME).tar$(SUFFIX)
X
Xzipdist : $(DISTVNAME).zip
X
X$(DISTVNAME).tar$(SUFFIX) : distdir
X $(PREOP)
X $(TO_UNIX)
X $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
X $(RM_RF) $(DISTVNAME)
X $(COMPRESS) $(DISTVNAME).tar
X $(POSTOP)
X
X$(DISTVNAME).zip : distdir
X $(PREOP)
X $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
X $(RM_RF) $(DISTVNAME)
X $(POSTOP)
X
Xuutardist : $(DISTVNAME).tar$(SUFFIX)
X uuencode $(DISTVNAME).tar$(SUFFIX) \
X $(DISTVNAME).tar$(SUFFIX) > \
X $(DISTVNAME).tar$(SUFFIX)_uu
X
Xshdist : distdir
X $(PREOP)
X $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
X $(RM_RF) $(DISTVNAME)
X $(POSTOP)
X
X
X# --- MakeMaker dist_dir section:
X
Xdistdir :
X $(RM_RF) $(DISTVNAME)
X $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=manicopy,maniread \
X -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');"
X
X
X# --- MakeMaker dist_test section:
X
Xdisttest : distdir
X cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
X cd $(DISTVNAME) && $(MAKE)
X cd $(DISTVNAME) && $(MAKE) test
X
X
X# --- MakeMaker dist_ci section:
X
Xci :
X $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=maniread \
X -e "@all = keys %{ maniread() };" \
X -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \
X -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
X
X
X# --- MakeMaker install section:
X
Xinstall :: all pure_install doc_install
X
Xinstall_perl :: all pure_perl_install doc_perl_install
X
Xinstall_site :: all pure_site_install doc_site_install
X
Xinstall_ :: install_site
X @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
X
Xpure_install :: pure_$(INSTALLDIRS)_install
X
Xdoc_install :: doc_$(INSTALLDIRS)_install
X @echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
X
Xpure__install : pure_site_install
X @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
X
Xdoc__install : doc_site_install
X @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
X
Xpure_perl_install ::
X @$(MOD_INSTALL) \
X read $(PERL_ARCHLIB)/auto/$(FULLEXT)/.packlist \
X write $(INSTALLARCHLIB)/auto/$(FULLEXT)/.packlist \
X $(INST_LIB) $(INSTALLPRIVLIB) \
X $(INST_ARCHLIB) $(INSTALLARCHLIB) \
X $(INST_BIN) $(INSTALLBIN) \
X $(INST_SCRIPT) $(INSTALLSCRIPT) \
X $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
X $(INST_MAN3DIR) $(INSTALLMAN3DIR)
X @$(WARN_IF_OLD_PACKLIST) \
X $(SITEARCHEXP)/auto/$(FULLEXT)
X
X
Xpure_site_install ::
X @$(MOD_INSTALL) \
X read $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist \
X write $(INSTALLSITEARCH)/auto/$(FULLEXT)/.packlist \
X $(INST_LIB) $(INSTALLSITELIB) \
X $(INST_ARCHLIB) $(INSTALLSITEARCH) \
X $(INST_BIN) $(INSTALLBIN) \
X $(INST_SCRIPT) $(INSTALLSCRIPT) \
X $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
X $(INST_MAN3DIR) $(INSTALLMAN3DIR)
X @$(WARN_IF_OLD_PACKLIST) \
X $(PERL_ARCHLIB)/auto/$(FULLEXT)
X
Xdoc_perl_install ::
X -@$(DOC_INSTALL) \
X "Module" "$(NAME)" \
X "installed into" "$(INSTALLPRIVLIB)" \
X LINKTYPE "$(LINKTYPE)" \
X VERSION "$(VERSION)" \
X EXE_FILES "$(EXE_FILES)" \
X >> $(INSTALLARCHLIB)/perllocal.pod
X
Xdoc_site_install ::
X -@$(DOC_INSTALL) \
X "Module" "$(NAME)" \
X "installed into" "$(INSTALLSITELIB)" \
X LINKTYPE "$(LINKTYPE)" \
X VERSION "$(VERSION)" \
X EXE_FILES "$(EXE_FILES)" \
X >> $(INSTALLARCHLIB)/perllocal.pod
X
X
Xuninstall :: uninstall_from_$(INSTALLDIRS)dirs
X
Xuninstall_from_perldirs ::
X @$(UNINSTALL) $(PERL_ARCHLIB)/auto/$(FULLEXT)/.packlist
X
Xuninstall_from_sitedirs ::
X @$(UNINSTALL) $(SITEARCHEXP)/auto/$(FULLEXT)/.packlist
X
X
X# --- MakeMaker force section:
X# Phony target to force checking subdirectories.
XFORCE:
X @$(NOOP)
X
X
X# --- MakeMaker perldepend section:
X
X
X# --- MakeMaker makefile section:
X
X# We take a very conservative approach here, but it\'s worth it.
X# We move Makefile to Makefile.old here to avoid gnu make looping.
XMakefile : Makefile.PL $(CONFIGDEP)
X @echo "Makefile out-of-date with respect to $?"
X @echo "Cleaning current config before rebuilding Makefile..."
X -@$(RM_F) Makefile.old
X -@$(MV) Makefile Makefile.old
X -$(MAKE) -f Makefile.old clean $(DEV_NULL) || $(NOOP)
X $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL "CC=cc" "CCFLAGS=-O -pipe " "PREFIX=/usr/local"
X @echo "==> Your Makefile has been rebuilt. <=="
X @echo "==> Please rerun the make command. <=="
X false
X
X# To change behavior to :: would be nice, but would break Tk b9.02
X# so you find such a warning below the dist target.
X#Makefile :: $(VERSION_FROM)
X# @echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
X
X
X# --- MakeMaker staticmake section:
X
X# --- MakeMaker makeaperl section ---
XMAP_TARGET = perl
XFULLPERL = /usr/bin/perl5.00503
X
X$(MAP_TARGET) :: static $(MAKE_APERL_FILE)
X $(MAKE) -f $(MAKE_APERL_FILE) $@
X
X$(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
X @echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
X @$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
X Makefile.PL DIR= \
X MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
X MAKEAPERL=1 NORECURS=1 CCCDLFLAGS= \
X CC=cc \
X CCFLAGS='-O -pipe ' \
X PREFIX=/usr/local
X
X
X# --- MakeMaker test section:
X
XTEST_VERBOSE=0
XTEST_TYPE=test_$(LINKTYPE)
XTEST_FILE = test.pl
XTEST_FILES = t/*.t
XTESTDB_SW = -d
X
Xtestdb :: testdb_$(LINKTYPE)
X
Xtest :: $(TEST_TYPE)
X
Xtest_dynamic :: pure_all
X PERL_DL_NONLAZY=1 $(FULLPERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use Test::Harness qw(&runtests $$verbose); $$verbose=$(TEST_VERBOSE); runtests @ARGV;' $(TEST_FILES)
X
Xtestdb_dynamic :: pure_all
X PERL_DL_NONLAZY=1 $(FULLPERL) $(TESTDB_SW) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(TEST_FILE)
X
Xtest_ : test_dynamic
X
Xtest_static :: test_dynamic
Xtestdb_static :: testdb_dynamic
X
X
X# --- MakeMaker ppd section:
X# Creates a PPD (Perl Package Description) for a binary distribution.
Xppd:
X @$(PERL) -e "print qq{<SOFTPKG NAME=\"XML-SAX-Simple\" VERSION=\"0,01,0,0\">\n}. qq{\t<TITLE>XML-SAX-Simple</TITLE>\n}. qq{\t<ABSTRACT></ABSTRACT>\n}. qq{\t<AUTHOR>Matt Sergeant, <matt\@sergeant.org></AUTHOR>\n}. qq{\t<IMPLEMENTATION>\n}. qq{\t\t<DEPENDENCY NAME=\"XML-Handler-Trees\" VERSION=\"0,02,0,0\" />\n}. qq{\t\t<DEPENDENCY NAME=\"XML-SAX\" VERSION=\"0,02,0,0\" />\n}. qq{\t\t<DEPENDENCY NAME=\"XML-Simple\" VERSION=\"1,06,0,0\" />\n}. qq{\t\t<OS NAME=\"$(OSNAME)\" />\n}. qq{\t\t<ARCHITECTURE NAME=\"i386-freebsd\" />\n}. qq{\t\t<CODEBASE HREF=\"\" />\n}. qq{\t</IMPLEMENTATION>\n}. qq{</SOFTPKG>\n}" > XML-SAX-Simple.ppd
X
X# --- MakeMaker pm_to_blib section:
X
Xpm_to_blib: $(TO_INST_PM)
X @$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
X "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
X -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'$(INST_LIB)/auto')"
X @$(TOUCH) $@
X
X
X# --- MakeMaker selfdocument section:
X
X
X# --- MakeMaker postamble section:
X
X
X# End.
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/Makefile
echo x - p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib
sed 's/^X//' >p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib << 'END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib'
END-of-p5-XML-SAX-Simple/work/XML-SAX-Simple-0.01/pm_to_blib
echo x - p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01
sed 's/^X//' >p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01'
END-of-p5-XML-SAX-Simple/work/.extract_done.p5-XML-SAX-Simple-0.01
echo x - p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01
sed 's/^X//' >p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01'
END-of-p5-XML-SAX-Simple/work/.patch_done.p5-XML-SAX-Simple-0.01
echo x - p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01
sed 's/^X//' >p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01'
END-of-p5-XML-SAX-Simple/work/.configure_done.p5-XML-SAX-Simple-0.01
echo x - p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01
sed 's/^X//' >p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01'
END-of-p5-XML-SAX-Simple/work/.build_done.p5-XML-SAX-Simple-0.01
echo x - p5-XML-SAX-Simple/work/.PLIST.mktmp
sed 's/^X//' >p5-XML-SAX-Simple/work/.PLIST.mktmp << 'END-of-p5-XML-SAX-Simple/work/.PLIST.mktmp'
Xlib/perl5/5.00503/man/man3/XML::SAX::Simple.3.gz
Xlib/perl5/site_perl/5.005/i386-freebsd/auto/XML/SAX/Simple/.packlist
Xlib/perl5/site_perl/5.005/XML/SAX/Simple.pm
X@dirrm lib/perl5/site_perl/5.005/i386-freebsd/auto/XML/SAX/Simple
X@unexec rmdir %D/lib/perl5/site_perl/5.005/XML/SAX 2>/dev/null || true
X@unexec rmdir %D/lib/perl5/site_perl/5.005/XML 2>/dev/null || true
X@unexec rmdir %D/lib/perl5/site_perl/5.005/i386-freebsd/auto/XML/SAX 2>/dev/null || true
X@unexec rmdir %D/lib/perl5/site_perl/5.005/i386-freebsd/auto/XML 2>/dev/null || true
X@unexec if [ -f %D/info/dir ]; then if sed -e '1,/Menu:/d' %D/info/dir | grep -q '^[*] '; then true; else rm %D/info/dir; fi; fi
END-of-p5-XML-SAX-Simple/work/.PLIST.mktmp
echo x - p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01
sed 's/^X//' >p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01'
END-of-p5-XML-SAX-Simple/work/.install_done.p5-XML-SAX-Simple-0.01
echo x - p5-XML-SAX-Simple/work/.PLIST.setuid
sed 's/^X//' >p5-XML-SAX-Simple/work/.PLIST.setuid << 'END-of-p5-XML-SAX-Simple/work/.PLIST.setuid'
END-of-p5-XML-SAX-Simple/work/.PLIST.setuid
echo x - p5-XML-SAX-Simple/work/.PLIST.startup
sed 's/^X//' >p5-XML-SAX-Simple/work/.PLIST.startup << 'END-of-p5-XML-SAX-Simple/work/.PLIST.startup'
END-of-p5-XML-SAX-Simple/work/.PLIST.startup
echo x - p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01
sed 's/^X//' >p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01 << 'END-of-p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01'
END-of-p5-XML-SAX-Simple/work/.package_done.p5-XML-SAX-Simple-0.01
exit
>Release-Note:
>Audit-Trail:
>Unformatted:
To Unsubscribe: send mail to majordomo@FreeBSD.org
with "unsubscribe freebsd-ports" in the body of the message
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?E166UPT-000K7W-00>