Force perl XMLin to treat an empty tag as empty string?

Question

Having the following:

perl -MXML::LibXML::Simple -MData::Dumper -E '$h=XMLin("<some><bubu>string</bubu></some>");say Dumper $h'

is parsed as:

$VAR1 = {
          'bubu' => 'string'
        };

but the

perl -MXML::LibXML::Simple -MData::Dumper -E '$h=XMLin("<some><bubu/></some>"); say Dumper $h'

or

perl -MXML::LibXML::Simple -MData::Dumper -E '$h=XMLin("<some><bubu></bubu></some>");say Dumper $h'

prints:

$VAR1 = {
          'bubu' => {}
        };

Is possible to get

$VAR1 = {
          'bubu' => ""
        };

To be consistent with other string values?

The real code behind the question is like:

package Something {
    use Moose;
    has 'bar' => (is => 'ro', isa => 'Str');
    has 'baz' => (is => 'ro', isa => 'Str');
}

use 5.014;
use warnings;
use XML::LibXML::Simple;

my $xml = do {local $/, <DATA>};
my $hr = XMLin($xml);
for my $node( @{$hr->{node}} ) {
    my $obj = Something->new($node);
}
__DATA__
<root>
<node>
    <bar>bar1</bar>
    <baz>baz1</baz>
</node>
<node>
    <bar>bar2</bar>
    <baz/>
</node>
</root>

which dies with

Attribute (baz) does not pass the type constraint because: Validation failed for 'Str' with value HASH(0x7f91a4a92450) at /opt/anyenv/envs/plenv/versions/5.24.0/lib/perl5/site_perl/5.24.0/darwin-2level/Moose/Object.pm line 24
    Moose::Object::new('Something', 'HASH(0x7f91a3f3d430)') called at l line 28

therefore i need either

• treat the empty baz not as {} but as ''
• or adding some coercion to the package Something to coerce any empty hashrefs {} to empty strings ''.

Any idea for the easy way?

EDIT

So, the result. The accepted answer remains because it gives the answer to the above question.

But must say, after 3 days of studying the new (very complex) module XML::Twig + learning XPath's basics i got a solution which is more clear and nicer as the XMLIn solution.

In the XMLIn i needed reorganize the got hashref, because wanted only few elements and with exactly defined structure. (acceptable for an constructor). Such reorganizing (deleting unwanted members, moving deeper hashref's values to arrayrefs and such) is easy in perl, but the code isn't nice and needed cope with questions like above.

Using the XML::Twig (and 2 followup questions here) the result was much cleaner and much more readable and much shorter as the XMLIn. Really is better sacrifice some time and learn (at least the basics) of the XPath and such...

Answer 1

XML::LibXML::Simple does not appear to have an option to enable this behavior.

XML::Simple does, though; set SuppressEmpty to an empty string to parse empty nodes as strings instead of containers:

# perl -MXML::Simple -MData::Dumper \
  -E '$h=XMLin("<some><bubu></bubu></some>", SuppressEmpty => ""); say Dumper $h'

$VAR1 = {
      'bubu' => ''
    };

Answer 2

You can use Data::Find module to traverse the hash and and find paths to empty hash refs. You can then use eval to replace empty hash refs with empty string. Here is an example:

use strict;
use warnings;

use XML::LibXML::Simple;
use Data::Dumper;
use Data::Find qw/ diter /;

my $xml = <<XML;
<root>
<node>
    <bar>bar1</bar>
    <baz>baz1</baz>
</node>
<node>
    <bar>bar2</bar>
    <baz/>
</node>
</root>
XML

my $h = XMLin($xml);

my $iter = diter $h, sub {
    my $v = shift;

    defined $v and ref($v) eq "HASH" and !(keys %{ $v });
};

while (my $path = $iter->() )
{
    eval "\$h->$path = ''";
}

print Dumper($h);

Answer 3

First off: Why is XML::Simple "Discouraged"?

XML::Simple doesn't make it easier, it makes it harder. I would advocate XML::Twig or XML::LibXML instead. In XML::Twig getting the 'value' of a node is exactly as you expect:

#!/usr/bin/env perl
use strict;
use warnings;

use XML::Twig;
my $twig = XML::Twig -> parse ( \*DATA ); 

foreach my $node ( $twig -> findnodes('//node/*') ) {
    print $node -> tag, " => \"", $node -> text,"\"\n";
}

__DATA__
<root>
<node>
    <bar>bar1</bar>
    <baz>baz1</baz>
</node>
<node>
    <bar>bar2</bar>
    <baz/>
</node>
</root>

Gives:

bar => "bar1"
baz => "baz1"
bar => "bar2"
baz => ""

Which you could pass to your constructor.