source: main/trunk/model-sites-dev/mozarts-laptop/collect/digital-music-stand/perllib/plugins/SimpleRDFMetadataPlugin.pm@ 30446

###########################################################################
#
# SimpleRDFMetadataPlugin.pm --
# A component of the Greenstone digital library software
# from the New Zealand Digital Library Project at the 
# University of Waikato, New Zealand.
#
# Copyright (C) 2006 New Zealand Digital Library Project
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
###########################################################################

# SimpleRDFMetadataPlugin process metadata contained in RDF description tags


package SimpleRDFMetadataPlugin;

use strict;
no strict 'refs';
use BasePlugin;
use util;
use metadatautil;

use MetadataRead;

sub BEGIN {
    @SimpleRDFMetadataPlugin::ISA = ('MetadataRead', 'BasePlugin');
    unshift (@INC, "$ENV{'GSDLHOME'}/perllib/cpan");
}

use XMLParser;
use XML::Rules;

my $arguments = [
      { 'name' => "process_exp",
    'desc' => "{BasePlugin.process_exp}",
    'type' => "regexp",
    'reqd' => "no",
    'deft' => &get_default_process_exp() }

];

my $options = { 'name'     => "SimpleRDFMetadataPlugin",
        'desc'     => "{SimpleRDFMetadataPlugin.desc}",
        'abstract' => "no",
        'inherits' => "yes",
        'args'     => $arguments };

my ($self);

my @rules = 
    ( 'rdf:Description' => \&rdf_description,
      '_default'        => \&rdf_default );



sub new {
    my ($class) = shift (@_);
    my ($pluginlist,$inputargs,$hashArgOptLists) = @_;
    push(@$pluginlist, $class);

    push(@{$hashArgOptLists->{"ArgList"}},@{$arguments});
    push(@{$hashArgOptLists->{"OptList"}},$options);

    $self = new BasePlugin($pluginlist, $inputargs, $hashArgOptLists);

    if ($self->{'info_only'}) {
    # don't worry about any options or initialisations etc
    return bless $self, $class;
    }
    
    # create XML::Rules Parser object for parsing metadata.xml files
    my $parser = XML::Rules->new(rules => \@rules);


    $self->{'parser'} = $parser;
    $self->{'in_filename'} = 0;
    
    
    return bless $self, $class;
}


sub get_default_process_exp
{
    return q^.*\.rdf$^;
}


sub metadata_read
{
    my $self = shift (@_);
    my ($pluginfo, $base_dir, $file, $block_hash, $extrametakeys, $extrametadata,
$processor, $maxdocs, $gli) = @_;

    my $filename = &util::filename_cat($base_dir, $file);
    my $process_exp = $self->{'process_exp'};

    if ($filename !~ /$process_exp/ || !-f $filename) {
        return undef;
    }

    my $outhandle = $self->{'outhandle'};
    
    print STDERR "\n<Processing n='$file' p='SimpleRDFMetadataPlugin'>\n" if ($gli);
    print $outhandle "SimpleRDFMetadataPlugin: processing $file\n" if ($self->{'verbosity'})> 1;

    # add the file to the block list so that it won't be processed in
    # read, as we will do all we can with it here
    &util::block_filename($block_hash,$filename);
    $self->{'metadataref'} = $extrametadata;
    $self->{'metakeysref'} = $extrametakeys;
    
    eval {
    $self->{'saved_metadata'} = {};
    $self->{'saved_metadata_count'} = 0;

    $self->{'parser'}->parsefile($filename);
    };

    if ($@) {
    my $plugin_name = ref ($self);
    print $outhandle "$plugin_name failed to process $file ($@)\n";
    
    return -1; #error
    }

    return 1;

}


sub file_block_read {
    my $self = shift (@_);
    my ($pluginfo, $base_dir, $file, $block_hash, $metadata, $gli) = @_;
    
    my $filename_full_path = &util::filename_cat($base_dir, $file);
    return undef unless $self->can_process_this_file($filename_full_path);    

    if ($ENV{'GSDLOS'} =~ m/^windows$/) {
        
        my $lower_drive = $filename_full_path;
        $lower_drive =~ s/^([A-Z]):/\l$1:/i;
        
        my $upper_drive = $filename_full_path;
        $upper_drive =~ s/^([A-Z]):/\u$1:/i;
        
        $block_hash->{'metadata_files'}->{$lower_drive} = 1;
        $block_hash->{'metadata_files'}->{$upper_drive} = 1;        
    }
    else {
        $block_hash->{'metadata_files'}->{$filename_full_path} = 1;
    }

    return 1;
}


sub rdf_description
{

    my ($tagname, $attrHash, $contextArray, $parentDataArray, $parser) = @_;

    my $target = $attrHash->{'rdf:about'};
    if ($target eq ".") {
    $target = ".*";
    }

    my $file_metadata = $self->{'metadataref'}->{$target};
    my $saved_metadata = $self->{'saved_metadata'};
    if (!defined $file_metadata) {
    $self->{'metadataref'}->{$target} = $saved_metadata;
        
    # not had target before
    push (@{$self->{'metakeysref'}}, $target);
    }
    else {
    &metadatautil::combine_metadata_structures($file_metadata,$saved_metadata);
    }

    my $outhandle = $self->{'outhandle'};
    print $outhandle "SimpleRDFMetadataPlugin associated ";
    print $outhandle $self->{'saved_metadata_count'};
    print $outhandle " piece(s) of metadata with $target\n";
    
    $self->{'saved_metadata'} = {};
    $self->{'saved_metadata_count'} = 0;

}

sub rdf_default
{

    my ($tagname, $attrHash, $contextArray, $parentDataArray, $parser) = @_;

    my $num_enclosing_nodes = scalar(@$contextArray);
    if ($num_enclosing_nodes>0) {

    my $immediate_parent = $contextArray->[$num_enclosing_nodes-1];
    return if ($immediate_parent ne "rdf:Description");
    
    my ($md_set,$md_name) = ($tagname =~ m/^(\w+):(\w+)/);
    my $md_content = $attrHash->{'_content'};

    if (defined $md_content) {

        my $full_md_name = "$md_set.$md_name";
        &metadatautil::store_saved_metadata($self,$full_md_name,
                        $md_content, 0);

        if ($full_md_name eq "mp.title") {
        my $sort_by_title = $md_content;
        $sort_by_title =~ s/^\s*(The|Die|Das|Der|Le|La|Les)\s+//i;
        my ($initial_letter) = ($sort_by_title =~ m/([A-Z])/i);

        &metadatautil::store_saved_metadata($self,"mp.titleInitialLetter",
                            $initial_letter, 0);
        }

        $self->{'saved_metadata_count'}++;
    }
    }

}



1;