As you haven't shown any code, I assume that your problem is with the general approach. I suggest doing it the following way:

1. Read the file, separate the lines into hashes of property => $value
2. For each hash, add a property children => []
3. For each hash, add it to the children list of the hash which has the Child propery the same value as this hashes Parent propery. You might want to create another hash to ease the lookup.

What do you mean by "indicate if a node was overwritten by its parent"? Please show us an example of where such overwriting happens and what the implications of this are.

bryank will also need some kind of iterator/traverser if the parents properties are going to be applied to the whole branch (i.e. children who are also parents).

You could check out Tree::Simple. The docs there also review most of the other tree data structures/parsers/dumpers.

Just a something something...

I'm playing around with Tree::Simple, but I fear I don't get it:

use warnings;
use strict;
use Tree::Simple;

# make a tree root
my $tree = Tree::Simple->new("0", Tree::Simple->ROOT);

while(<DATA>) {
chomp;
my ($child, $parent) = split /:/;
my $sub_tree = Tree::Simple->new("$parent", $tree);

# explicity add a child to it
$sub_tree->addChild(Tree::Simple->new("$child"));

}

$tree->traverse(sub {
    my ($_tree) = @_;
    print (("\t" x $_tree->getDepth()), $_tree->getNodeValue(), "\n");
});


__DATA__
apple:fruit
granny smith:apple
fuji:apple
orange:fruit
blood orange:orange
mandarine:orange
dwarf fuji:fuji
[download]

Currently, the output looks like this:

$ perl test.pl
fruit
        apple
apple
        granny smith
apple
        fuji
fruit
        orange
orange
        blood orange
orange
        mandarine
fuji
        dwarf fuji
[download]

I want a format more like the one in the module example:

1
        1.1
2
        2.1
        2.1a
        2.2
3
[download]

I know I am missing some stuff, but I can't grok it. :(

use strict;
use warnings;

use DBI;


sub treeify {
    my ($sth) = @_;

    my %root = ( _children => [] );
    my %children;

    while (my $row = $sth->fetchrow_hashref()) {
        my ($id, $parent_id) = @$row{qw( Child Parent )};

        my $parent = ( defined($parent_id)
            ? $children{$parent_id} ||= { _children => [] }
            : \%root
        );

        my $node = $children{$id} ||= {};
        %$node = ( _children => [], %$row );

        push @{ $parent->{_children} }, $node;
    }

    return \%root;
}


{
    my $sponge = DBI->connect(
        'dbi:Sponge:', '', '',
        { RaiseError => 1 }
    );

    my $sth = $sponge->prepare(
        'SELECT * FROM Fruit',
        {
            NAME =>   [qw( Parent  Child  Desc             Property1  
+Property2        )],
            rows => [ [     undef,    50, 'Fruit',         'hidden',  
+'non-searchable'  ],
                      [        50,   100, 'Apple',         'hidden',  
+'non-searchable'  ],
                      [       100,   110, 'Granny Smith',  'Visible', 
+'searchable'      ],
            ],
        }
    );

    my $tree = treeify($sth);

    use Data::Dumper;
    print Dumper $tree;
}
[download]

Based on Generating a Hash of Hashes Recursively to Display Database Hierarchy. Should use a classes.

use strict;
use warnings;

use DBI          qw( );
use Tree::Simple qw( );


{
    package Fruit;

    use Data::Dumper qw( Dumper );

    sub new { my $class = shift; bless({@_}, $class) }

    sub dump {
        my ($self, $prefix) = @_;

        local $Data::Dumper::Useqq    = 1;
        local $Data::Dumper::Terse    = 1;
        local $Data::Dumper::Indent   = 1;
        local $Data::Dumper::Pad      = $prefix;
        local $Data::Dumper::Sortkeys =
            sub{[qw( Parent Child Desc Property1 Property2 )]};

        return Dumper($self);
    }
}


sub treeify {
    my ($sth) = @_;

    my $tree = Tree::Simple->new(undef);

    my %children;
    while (my $row = $sth->fetchrow_hashref()) {
        my ($id, $parent_id) = @$row{qw( Child Parent )};

        my $parent = ( defined($parent_id)
            ? $children{$parent_id} ||= Tree::Simple->new(undef)
            : $tree
        );

        my $node = $children{$id} ||= Tree::Simple->new();
        $node->setNodeValue( Fruit->new(%$row) );
        $parent->addChild( $node );
    }

    return $tree;
}


sub dump_tree {
    my ($tree) = @_;

    $tree->traverse(sub {
        my ($node) = @_;
        my $prefix = "\t" x $node->getDepth();
        print( $node->getNodeValue()->dump( $prefix ) );
    });
}


{
    my $sponge = DBI->connect(
        'dbi:Sponge:', '', '',
        { RaiseError => 1 }
    );

    my $sth = $sponge->prepare(
        'SELECT * FROM Fruit',
        {
            NAME =>   [qw( Parent  Child  Desc             Property1  
+Property2        )],
            rows => [ [     undef,    50, 'Fruit',         'hidden',  
+'non-searchable'  ],
                      [        50,   100, 'Apple',         'hidden',  
+'non-searchable'  ],
                      [       100,   110, 'Granny Smith',  'Visible', 
+'searchable'      ],
            ],
        }
    );

    my $tree = treeify($sth);
    dump_tree($tree);
}
[download]