Perl XML2JSON : How to preserve XML element order?

Here's a program that I hacked together that uses XML::Parser to parse some XML data and generate the equivalent JSON in the same order. It ignores any attributes, processing instructions etc. and requires that every XML element must contain either a list of child elements or a text node. Mixing text and elements won't work, and this isn't checked except that the program will die trying to dereference a string

It's intended to be a framework for you to enhance as you require, but works fine as it stands with the XML data you show in your question

use strict;
use warnings 'all';

use XML::Parser;


my $parser = XML::Parser->new(Handlers => {
    Start => \&start_tag,
    End   => \&end_tag,
    Char  => \&text,
});

my $struct;
my @stack;

$parser->parsefile('config.xml');

print_json($struct->[1]);


sub start_tag {
    my $expat = shift;
    my ($tag, %attr) = @_;

    my $elem = [ $tag => [] ];
    if ( $struct ) {
        my $content = $stack[-1][1];
        push @{ $content }, $elem;
    }
    else {
        $struct = $elem;
    }
    push @stack, $elem;
}


sub end_tag {
    my $expat = shift;
    my ($elem) = @_;
    die "$elem <=> $stack[-1][0]" unless $stack[-1][0] eq $elem;
    for my $content ( $stack[-1][1] ) {
        $content = "@$content" unless grep ref, @$content;
    }
    pop @stack;
}


sub text {
    my $expat = shift;
    my ($string) = @_;
    return unless $string =~ /\S/;
    $string =~ s/\A\s+//;
    $string =~ s/\s+\z//;
    push @{ $stack[-1][1] }, $string;
}


sub print_json {
    my ($data, $indent, $comma) = (@_, 0, '');

    print "{\n";

    for my $i ( 0 .. $#$data ) {

        # Note that $data, $indent and $comma are overridden here
        # to reflect the inner context
        #
        my $elem = $data->[$i];
        my $comma = $i < $#$data ? ',' : '';
        my ($tag, $data) = @$elem;
        my $indent = $indent + 1;

        printf qq{%s"%s" : }, '  ' x $indent, $tag;

        if ( ref $data ) {
            print_json($data, $indent, $comma);
        }
        else {
            printf qq{"%s"%s\n}, $data, $comma;
        }
    }

    # $indent and $comma (and $data) are restored here
    #
    printf "%s}%s\n", '  ' x $indent, $comma;
}

output

{
  "ip" : {
    "address" : "1.1.1.1",
    "netmask" : "255.255.255.0"
  },
  "route" : {
    "network" : "20.20.20.0",
    "netmask" : "55.255.255.0",
    "gateway" : "1.1.1.1"
  }
}

The problem isn't so much to do with XML parsing, but because perl hashes are not ordered. So when you 'write' some JSON... it can be any order.

The way to avoid this is to apply a sort function to your JSON.

You can do this by using sort_by to explicitly sort:

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

use XML::Twig; 
use JSON::PP; 

use Data::Dumper;

sub order_nodes {
   my %rank_of = ( ip => 0, route => 1, address => 2, network => 3, netmask => 4, gateway => 5 ); 
   print "$JSON::PP::a <=> $JSON::PP::b\n";
   return $rank_of{$JSON::PP::a} <=> $rank_of{$JSON::PP::b};
}

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

my $json = JSON::PP -> new;
$json ->sort_by ( \&order_nodes );
print $json -> encode( $twig -> simplify );

__DATA__
<Config>
<ip>
    <address>1.1.1.1</address>
    <netmask>255.255.255.0</netmask>
</ip>
<route>
    <network>20.20.20.0</network>
    <netmask>55.255.255.0</netmask>
    <gateway>1.1.1.1</gateway>
</route>
</Config>

In some scenarios, setting canonical can help, as that sets ordering to lexical order. (And means your JSON output would be consistently ordered). This doesn't apply to your case.

You could build the node ordering via XML::Twig, either by an xpath expression, or by using twig_handlers. I gave it a quick go, but got slightly unstuck in figuring out how you'd 'tell' how to figure out ordering based on getting address/netmask and then network/netmask/gateway.

As a simple example you could:

my $count = 0; 
foreach my $node ( $twig -> get_xpath ( './*' ) ) {
    $rank_of{$node->tag} = $count++ unless $rank_of{$node->tag};    
}

print Dumper \%rank_of; 

This will ensure ip and route are always the right way around. However it doesn't order the subkeys.

That actually gets a bit more complicated, as you'd need to recurse... and then decide how to handle 'collisions' (like netmask - address comes before, but how does it sort compared to network).

Or alternatively:

my $count = 0;
foreach my $node ( $twig->get_xpath('.//*') ) {
   $rank_of{ $node->tag } = $count++ unless $rank_of{ $node->tag };
}

This walks all the nodes, and puts them in order. It doesn't quite work, because netmask appears in both stanzas though.

You get:

{"ip":{"address":"1.1.1.1","netmask":"255.255.255.0"},"route":{"netmask":"55.255.255.0","network":"20.20.20.0","gateway":"1.1.1.1"}}

I couldn't figure out a neat way of collapsing both lists.