File Coverage

blib/lib/Persistence/Meta/XML.pm

Criterion	Covered	Total	%
statement	16	18	88.8
branch			n/a
condition			n/a
subroutine	6	6	100.0
pod			n/a
total	22	24	91.6

package Persistence::Meta::XML;

use strict;
use warnings;
use vars qw($VERSION);

use Abstract::Meta::Class ':all';
use Carp 'confess';
use Persistence::Entity::Manager;
use Persistence::Entity ':all';
use Persistence::ORM;
use Persistence::Meta::Injection;
use Persistence::Relationship;
use Persistence::Relationship::ToOne;
use Persistence::Relationship::OneToMany;
use Persistence::Relationship::ManyToMany;
use SQL::Entity::Condition;
use Simple::SAX::Serializer;
use Simple::SAX::Serializer::Handler ':all';


$VERSION = 0.04;

=head1 NAME

Persistence::Meta::XML - Persistence meta object xml injection

=cut

=head1 SYNOPSIS

   use Persistence::Meta::XML;
   my $meta = Persistence::Meta::XML->new(persistence_dir => 'meta/');
   my $entity_manager = $meta->inject('my_persistence.xml');
   #or
   # $meta->inject('my_persistence.xml');
   # my $entity_manager = Persistence::Entity::Manager->manager('manager_name');


=head1 DESCRIPTION

Loads xml files that containt meta persistence definition.

    persistence.xml












    emp.xml


        empno












    dept.xml


        deptno







                deptno




    Employee.xml









    Department.xml









    package Employee;
    use Abstract::Meta::Class ':all';

    has '$.id';
    has '$.name';
    has '$.job';
    has '$.dept_name';
    has '$.dept' => (associated_class => 'Department');

    package Department;
    use Abstract::Meta::Class ':all';

    has '$.id';
    has '$.name';
    has '$.location';
    has '@.employees' => (associated_class => 'Employee');

    my $meta = Persistence::Meta::XML->new(persistence_dir => $dir);
    my $entity_manager = $meta->inject('persistence.xml');

    my ($dept) = $entity_manager->find(dept => 'Department', name => 'dept3');

    my $enp = Employee->new(id => 88, name => 'emp88');
    $enp->set_dept(Department->new(id => 99, name => 'd99'));
    $entity_manager->insert($enp);

=head1 EXPORT

None

=head2 ATTRIBUTES

=over

=item cache_dir

Containts cache directory.

=cut

has '$.cache_dir';


=item use_cache

Flag that indicates if cache is used.

=cut

has '$.use_cache' => (default => 0);


=item persistence_dir

Directory for xml meta persistence definition.

=cut

has '$.persistence_dir';


=item persistence_dir

Contains directory of xml files that contain persistence object definition.

=cut


=item injection

=cut

has '$.injection';


=back

=head2 METHODS

=over

=item initialise

=cut

sub initialise {
    my ($self) = @_;
    $self->set_cache_dir($self->persistence_dir)
        if ($self->use_cache && ! $self->cache_dir);
}


=item inject

Injects persistence xml definition.
Takes xml file definition


    my $meta = Persistence::Meta::XML->new(persistence_dir => $dir);
    my $entity_manager = $meta->inject('persistence.xml');


=cut

sub inject {
    my ($self, $file) = @_;
    my $injection;
    my $prefix_dir = $self->persistence_dir;
    my $file_name = $prefix_dir . $file;
    if($self->use_cache) {
        my $cached_injection = Persistence::Meta::Injection->load_from_cache($self, $file_name);
        $injection = $cached_injection
            if $cached_injection && $cached_injection->can_use_cache;
    }

    $injection ||= Persistence::Meta::Injection->new;
    $self->set_injection($injection);
    unless ($injection->cached_version) {
        $injection->add_file_stat($file_name);
        my $xml = $self->persistence_xml_handler;
        $xml->parse_file($prefix_dir . $file);
    }
    $self->injection->load_persistence_context($self, $file);
}


=item persistence_xml_handler

Retunds xml handlers that will transform the persistence xml into objects.
Persistence node is mapped to the Persistence::Entity::Manager;
































=cut

sub persistence_xml_handler {
    my ($self) = @_;
    my $xml = Simple::SAX::Serializer->new;
    $self->add_xml_persistence_handlers($xml);
    $xml;
}


=item add_xml_persistence_handlers

Adds persistence xml handlers/
Takes Simple::SAX::Serializer object as parameter.

=cut

sub add_xml_persistence_handlers {
    my ($self, $xml) = @_;
    my $temp_data = {};
    $xml->handler('persistence', root_object_handler('Persistence::Entity::Manager' , sub {
        my ($result) = @_;
        my $injection = $self->injection;
        $injection->set_entity_manager($result);
        $injection->set_orm_files(\@{$temp_data->{orm}});
        $injection->set_entities_files(\@{$temp_data->{entities}});
        $injection->set_sequence_generators(\@{$temp_data->{sequence_generators}});
        $injection->set_table_generators(\@{$temp_data->{table_generators}});
        delete $temp_data->{$_} for qw(entities orm sequence_generators table_generators);
        $result;
    })),

    $xml->handler('entities', ignore_node_handler());
    $xml->handler('value_generators', ignore_node_handler());
    $xml->handler('to_many_relationships', ignore_node_handler());
    $xml->handler('entity_file', custom_array_handler($temp_data, undef, undef, 'entities'));
    $xml->handler('filter_condition_values', hash_handler());
    $xml->handler('dml_filter_values', hash_handler());
    $xml->handler('mapping_rules', ignore_node_handler());
    $xml->handler('orm_file', custom_array_handler($temp_data, undef, undef, 'orm'));
    $xml->handler('sequence_generator', custom_array_handler($temp_data, undef, undef, 'sequence_generators'));
    $xml->handler('table_generator', custom_array_handler($temp_data, undef, undef, 'table_generators'));
}


=item orm_xml_handler


















    many_to_many 'project' => (
        attribute        => has('%.projects' => (associated_class => 'Project'), index_by => 'name'),
        join_entity_name => 'emp_project',
        fetch_method     => LAZY,
        cascade          => ALL,
    );


=item orm_xml_handler

Retunds xml handlers that will transform the orm xml into Persistence::ORM object

=cut

sub orm_xml_handler {
    my ($self) = @_;
    my $xml = Simple::SAX::Serializer->new;
    $self->add_orm_xml_handlers($xml);
    $xml;
}


=item add_orm_xml_handlers

Adds orm xml handler to Simple::SAX::Serializer object.

=cut

sub add_orm_xml_handlers {
    my ($self, $xml) = @_;
    my $temp_data = {};
    $xml->handler('orm', sub {
        my ($this, $element, $parent) = @_;
        my $injection = $self->injection;
        my $orm_mapping = $injection->_orm_mapping;
        my $attributes = $element->attributes;
        my $children_result = $element->children_result || {};
        push @$orm_mapping, {%$attributes}, {%$children_result};
    });
    $xml->handler('column', hash_of_array_handler(undef, undef, 'columns'));
    $xml->handler('lob', hash_of_array_handler(undef, undef, 'lobs'));
    $xml->handler('to_one_relationship', hash_of_array_handler(undef, undef, 'to_one_relationships'));
    $xml->handler('one_to_many_relationship', hash_of_array_handler(undef, undef, 'one_to_many_relationships'));
    $xml->handler('many_to_many_relationship', hash_of_array_handler(undef, undef, 'many_to_many_relationships'));
}


=item entity_xml_handler

Retunds xml handlers that will transform the enity xml into Persistence::Entity


    filter_condition_value+ .dml_filter_value+, to_one_relationships? to_many_relationships?, value_generators*)>




























    For instnace.


        empno


                ename


                empno














                deptno




=cut

sub entity_xml_handler {
    my ($self) = @_;
    my $xml = Simple::SAX::Serializer->new;
    $self->add_entity_xml_handlers($xml);
    $xml;
}


=item add_entity_xml_handlers

Adds entity xml handler to the Simple::SAX::Serializer object.

=cut

sub add_entity_xml_handlers {
    my ($self, $xml) = @_;
    my $temp_data = {};
    $xml->handler('entity', root_object_handler('Persistence::Entity' , sub {
        my ($result) = @_;
        my $id = $result->id;
        my $injection = $self->injection;
        my $entities_subquery_columns = $injection->_entities_subquery_columns;
        my $entities_to_many_relationships = $injection->_entities_to_many_relationships;
        my $entities_to_one_relationships = $injection->_entities_to_one_relationships;
        $entities_subquery_columns->{$id} = \@{$temp_data->{subquery_columns}};
        $entities_to_many_relationships->{$id} = \@{$temp_data->{to_many_relationships}};
        $entities_to_one_relationships->{$id} = \@{$temp_data->{to_one_relationships}};
        delete $temp_data->{$_} for qw(subquery_columns to_many_relationships to_one_relationships);
        $result;
    })),
    $xml->handler('columns', hash_item_of_child_value_handler());
    $xml->handler('columns/column', array_of_objects_handler(\&sql_column));
    $xml->handler('lobs', hash_item_of_child_value_handler());
    $xml->handler('lobs/lob', array_of_objects_handler(\&sql_lob));
    $xml->handler('indexes', hash_item_of_child_value_handler());
    $xml->handler('index', array_of_objects_handler(\&sql_index));
    $xml->handler('index_column', array_handler('columns'));
    $xml->handler('primary_key', array_handler());
    $xml->handler('value_generator', hash_handler('value_generators', 'column'));
    $xml->handler('filter_condition_values', hash_handler());
    $xml->handler('dml_filter_values', hash_handler());
    $xml->handler('subquery_columns', ignore_node_handler());
    $xml->handler('subquery_column', custom_array_handler($temp_data, undef, undef, 'subquery_columns'));
    $xml->handler('to_one_relationships', ignore_node_handler());
    $xml->handler('to_many_relationships', ignore_node_handler());
    $xml->handler('to_many_relationships/relationship', custom_array_handler($temp_data, undef, undef, 'to_many_relationships'));
    $xml->handler('to_one_relationships/relationship', custom_array_handler($temp_data, undef, undef, 'to_one_relationships'));
    $xml->handler('join_column', array_handler('join_columns'));
    $xml->handler('condition', object_handler('SQL::Entity::Condition'));
    $xml->handler('condition/condition', hash_of_object_array_handler('SQL::Entity::Condition', undef, undef, 'conditions'));
}


=item cache_file_name

Returns fulle path to cache file, takes persistence file name.

=cut

sub cache_file_name {
    my ($self, $file) = @_;
    my ($file_name) = $file =~ /([\w]+)\.xml$/i;
    $self->cache_dir . $file_name .'.cache';
}


1;

__END__