[ family => { name => 'Kawasaki' },
  [
    [father => 'Yasushisa' ],
    [mother => 'Chizuko' ],
    [children =>
      [
        [girl => 'Shiori'],
        [boy  => 'Yasuke'],
        [boy  => 'Kairi']
      ]
    ]
  ]
]
[download]

I also think your example had a couple minor errors (extra array ref and no punctuation between 'children' and its children.)

If you've defined two explicit cases for $inner (scalar or array ref), you can always differentiate it from a hash ref, so why not just make the \%attr optional and just omit the empty hashes {}?

Yes, I certainly thought of that. And you will often simply provide content without attributes, so I think that is a nice shorthand.

You may use something like the lol structure of the method new_from_lol in HTML::Element, I think it is very compact and easy to handle.

The way you have laid it out - With ctilmes' comments included - would seem to be an ideal case for a lightweight OO approach?

The way you have laid it out - With ctilmes' comments included - would seem to be an ideal case for a lightweight OO approach?

Right now, it is using the OO heavyweight - Moose. (grin).

The first few test cases pass in my git repo for the source More late-breaking hacker news as it surfaces!

 $ximple_tree = { 
                    tag_name => "unicycle"
                    attrib   => { color  => "chrom",
                                  height => 3,
                                  brand  => "foo"}
                    content  => ["The content of a ximple tree\n",
                                 "is heterogenious just like xml",
                                 "itself. For example this is how\n",
                                 "i would make the word",
                                 {
                                  tag_name=>"bold",
                                   attrib=>{},
                                   content=>["cheese"]
                                  },
                                 "appear in a bold tag"]
                  };
[download]

{
    package Template::Declare::TagSet::Family;
    use base 'Template::Declare::TagSet';

    sub get_tag_list {
        return [qw(family father mother children girl boy)]
    }
}

{
    package Family::Templates;
    use base 'Template::Declare';
    use Template::Declare::Tags 'Family';

    template Kawasaki => sub {
        family {
            attr { name => 'Kawasaki' }
            father { 'Yasushisa' }
            mother { 'Chizuko' }
            children {
                girl { 'Shiori' }
                boy { 'Yasuka' }
                boy { 'Kairi' }
            }
        }
    };
}

use Template::Declare;
Template::Declare->init(roots => ['Family::Templates']);
print Template::Declare->show('Kawasaki');
[download]

If you require each array to have the following format you can complete eliminate the array around the child tags. The position alone is enough to determine whether or not an array element is a nested tag. Eliminating the extra square brackets around each tag set would help keep the indentation from going halfway across the page or more.

  [0] tag name
  [1] attribute hash reference
  [2] data
  [3] ...: one array ref for each nested tag
[download]

Your sample data would then look like this:

[ family => { name => 'Kawasaki' } => undef,
  [father => {} => 'Yasushisa' ],
  [mother => {} => 'Chizuko' ],
  [children => {} => undef,
    [girl => {} => 'Shiori'],
    [boy  => {} => 'Yasuke'],
    [boy  => {} => 'Kairi']
  ]
]
[download]

Best, beth

The attribute hash ref can also be optional: if ref($tag->[1]) ne 'HASH', the tag has no attributes and $tag->[1] is the first child node. So position is only relative and undefs are not needed.

[ family => { name => 'Kawasaki' },
  [father => 'Yasushisa' ],
  [mother => 'Chizuko' ],
  [children =>
    [girl => 'Shiori' ],
    [boy  => 'Yasuke' ],
    [boy  => 'Kairi' ]
  ]
]
[download]

This is HTML::Element 's "lol", as said by jrey above.

[ family => { name => 'Kawasaki' },
  [
    father => 'Yasushisa' ,
    mother => { hair => 'short'} => 'Chizuko' ,
    children =>
    [
      girl => 'Shiori',
      boy  => { hair => 'black' } => 'Yasuke',
      boy  => 'Kairi'
    ]
  ]
]
[download]

<family name="Kawasaki">
    <father>Yasuhisa</father>
    <mother hair="short">Chizuko</mother>
    <children>
        <girl>Shiori</girl>
        <boy hair="black">Yusuke</boy>
        <boy>Kairi</boy>
    </children>
</family>
[download]

It uses Pair objects for both attributes and child tags, distinguished by the type of the value: if the value is an List, it's used as a child tag, if it's a scalar it's used as an attribute.

The documentation uses this example:

my $svg = :svg[             # root tag
    :width(200),            # attribute
    :height(200),           #
    circle => [             # child tag
        :cx(100), :cy(100), :r(50)      # child tag attributes
    ],
    text => [               # child tag
        :x(10), :y(20), "hello"         # child tag attributes
    ]
];
[download]

I used this data structure to generate bar charts in SVG, and found it very handy.

not easy/possible to specify when something is an attribute versus an element using XML::Simple

Actually XML::Simple has a very simple rule for determining whether to output something as an attribute vs a nested element. If the value is a plain scalar, it will be output as an element, otherwise it will be a nested element. E.g.:

gives:

<opt>
  <person id="123">
    <name>John Doe</name>
  </person>
</opt>
[download]

Having said that, I'd encourage the use of a different module for anything non-trivial.

Actually XML::Simple has a very simple rule for determining whether to output something as an attribute vs a nested element. If the value is a plain scalar, it will be output as an element, otherwise it will be a nested element.

Indeed... Just FYI, a co-worker and myself were evaluating XML::Simple for producing XML and he had the impression that there was no way to do this. If you glance at the SYNOPSIS, and see this:

'gobi'          => {
              'osversion'     => '6.5',
              'osname'        => 'irix',
              'address'       => '10.0.0.102'
          },
[download]

you get the idea that there is no way to force address to be an element somehow.

I knew about ForceArray but for some reason, things didn't click for me until your post here.

regexps as "non-plain scalars"

I wanted to ease my typing. The standard "non-plain scalar" is this:

mother => ['Mary']
[download]

but I was hoping to get away with this:

mother => qr/Mary/
[download]

because it is easier to type and more readable (IMHO).

Any chance of converting a node whose value is a regexp into an element as opposed to an attribute?

Order of sibling XML elements

Now, one other question, we are producing XML based on an XSD. I am wondering if the XML has order requirements on siblings. In other words, I did the sample XML for the original topic in this thread in XML::Simple -

use strict;
use warnings;

use XML::Simple;
use Tie::IxHash;


tie (my %struct, 'Tie::IxHash',

 family => { 
        name => 'Kawasaki', 
        father => ['Yasuhisa'],
        mother => ['Chizuko'],
        children => {
             girl => ['Shiori'],
             boy  => ['Kairi'],
            }
       }
);          
         
warn XMLout(\%struct);
[download]

but while each level of the XML tree was accurate, the sibling elements father, mother, children were in a different order than I wanted them to be.

The short answer is that XML::Simple is absolutely not the right module for generating XML. I don't generate XML very often and when I do I tend to use a templating tool like TT or Mason.

Mkay,

use XML::Rules; # at least 1.08
my $parser = XML::Rules->new(rules => []);

print $parser->ToXML( [ family => { name => 'Kawasaki' },
  [
    [father => 'Yasushisa' ],
    [mother => 'Chizuko' ],
    [children =>
      [
        [girl => 'Shiori'],
        [boy  => 'Yasuke'],
        [boy  => 'Kairi']
      ]
    ]
  ]
], 0, ' ', '');
[download]

This doesn't work for me. When I run it I get

<ARRAY(0x84b3a0)>0
[download]

What version of XML::Rules do you have? Are you sure you have 1.08?

Jenda
Enoch was right!
Enjoy the last years of Rome.