#!/usr/bin/perl

use strict;
use warnings;

use XML::LibXML;

local $/;
my $xml = <DATA>;
print $xml, "\n";

my $parser = XML::LibXML->new();
my $doc    = $parser->parse_string( $xml );
my $nodes  = $doc->findnodes( '/msg/text()' );
my $node   = $nodes->pop();
my $string = $node->data;
   $string =~ s/^As a last resort //;
   $string =~ s/is also/is extremely/;
$node->setData( $string );
$node->appendData( " ... and XML::LibXSLT too!" );

print $doc->toString();

__DATA__
<?xml version="1.0" encoding="iso-8859-1"?>
<msg>As a last resort XML::LibXML is also useful.</msg>
[download]

-derby

use strict;
use XML::Twig;
local $/;
XML::Twig->new(
  TwigHandlers => {
    '/root/msg' => sub { $_[1]->set_text('Twig is easy') }
  }
)->parse(<DATA>)->print;
__DATA__
<?xml version="1.0" encoding="iso-8859-1"?>
<root><msg>As a last resort XML::LibXML is also useful.</msg></root>
[download]

Boris

Yes, XML is 'human readable' (ie, plain old text), but I don't think it's a very robust solution to make changes to an XML document simply with a s/// operation skimming its way through the file. You have to weigh the risks of messing it up by under-engineering the solution against the difficulty and value of developing a properly engineered solution.

The good news is that there are some excellent XML parsing tools that virtually eliminate the "difficulty" of implementing a well-engineered solution. XML::Simple is one, but I prefer XML::Twig, because it handles some peculiar XML cases that make 'Simple choke, and because it still provides a very simple interface, similar to that of XML::Simple. With XML::Twig you can, in very few easy lines of code, grab the entire XML document (or portions thereof) and have it automagically parsed into a Perl datastructure. Then after modifying the specific elements within that datastructure that need to be changed, one or two more lines of code will dump that datastructure back into a properly formed XML document.

Because the XML::Twig approach is so easy to use, and because it represents a "properly engineered" solution, there is simply virtually no reason not to favor it over a less robust "regexp" solution.

The only problem I see is with regard to keeping indents and line breaks from the original file in the same exact places. XML::Twig will output clean XML, but it might not follow the existing formatting 100%. ...nor should it matter; XML, while human readable, is ultimately there for the machines to use. You can guarantee that an XML document output by XML::Twig will retain just as much human readability as the original, but you cannot guarantee that it will look 100% identical.

Just for the record, it is simple for simple XML things, however the parameters and options available in this package have complex implications on how the XML information is read in and written out.

It looks like XML::Simple loses the distinction between attributes and child elements, when building the returned data structure. How do you preserve the actual content when writing it back out?

This is definitely one of the difficulties I've had with XML::Simple. XMLin and XMLout aren't the inverse of each other. In other words, it's difficult write out the same thing that you read in and vice versa.

I if you need that, you should probably look at XML::Twig.

Hazah! I'm Employed!

I'm not sure about keeping the actual formating (indents, line breaks, comments), but what you're basically looking for is XSLT.

There exists in CPAN a few different XSLT modules (XML::XSLT, XML::LibXSLT, XML::ApplyXSLT), but I've never used any of them.

(I do enough XML work that I know of XSLT, yet never used it directly)

Given your desire to preserve indentation, comments etc, XML::Simple is definitely not what you want. I'd recommend XML-LibXML. This node compares the code required to complete various tasks using XML::Simple and XML::LibXML.