source: trunk/gsdl/bin/script/mkcol.pl@ 7101

#!/usr/bin/perl -w

###########################################################################
#
# mkcol.pl --
# A component of the Greenstone digital library software
# from the New Zealand Digital Library Project at the 
# University of Waikato, New Zealand.
#
# Copyright (C) 1999 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.
#
###########################################################################


# This program will setup a new collection from a model one. It does this by
# copying the model, moving files to have the correct names, and replacing
# text within the files to match the parameters.

package mkcol;

BEGIN {
    die "GSDLHOME not set\n" unless defined $ENV{'GSDLHOME'};
    die "GSDLOS not set\n" unless defined $ENV{'GSDLOS'};
    unshift (@INC, "$ENV{'GSDLHOME'}/perllib");
}

use parsargv;
use util;
use cfgread;
use gsprintf;
use printusage;

my $arguments =
    [ { 'name' => "creator",
    'desc' => "{mkcol.creator}",
    'type' => "string",
    'reqd' => "no" },
      { 'name' => "optionfile",
    'desc' => "{mkcol.optionfile}",
    'type' => "string",
    'reqd' => "no" },
      { 'name' => "maintainer",
    'desc' => "{mkcol.maintainer}",
    'type' => "string",
    'reqd' => "no" },
      { 'name' => "collectdir",
    'desc' => "{mkcol.collectdir}",
    'type' => "string",
    'deft' => &util::filename_cat ($ENV{'GSDLHOME'}, "collect"),
    'reqd' => "no" },
      { 'name' => "public",
    'desc' => "{mkcol.public}",
    'type' => "string",
    'deft' => "true",
    'reqd' => "no" },
      { 'name' => "title",
    'desc' => "{mkcol.title}",
    'type' => "string",
    'reqd' => "no" },
      { 'name' => "about",
    'desc' => "{mkcol.about}",
    'type' => "string",
    'reqd' => "no" },
      { 'name' => "plugin",
    'desc' => "{mkcol.plugin}",
    'type' => "string",
    'reqd' => "no" },
      { 'name' => "quiet",
    'desc' => "{mkcol.quiet}",
    'type' => "flag",
    'reqd' => "no" },
      { 'name' => "language",
    'desc' => "{scripts.language}",
    'type' => "string",
    'reqd' => "no" } ];

my $options = { 'name' => "mkcol.pl",
        'desc' => "{mkcol.desc}",
        'args' => $arguments };

sub gsprintf
{
    return &gsprintf::gsprintf(@_);
}


sub traverse_dir
{
    my ($modeldir, $coldir) = @_;
    my ($newfile, @filetext);

    if (!(-e $coldir)) {

    my $store_umask = umask(0002);
    my $mkdir_ok = mkdir ($coldir, 0777);
    umask($store_umask);

    if (!$mkdir_ok) 
    {
        die "$!";
    }
    }

    opendir(DIR, $modeldir) ||
    (&gsprintf(STDERR, "{common.cannot_read}\n", $modeldir) && die);
    my @files = grep(!/^(\.\.?|CVS)$/, readdir(DIR));
    closedir(DIR);

    foreach $file (@files)
    {
    my $thisfile = &util::filename_cat ($modeldir, $file);
    if (-d $thisfile) {
        my $colfiledir = &util::filename_cat ($coldir, $file);
        traverse_dir ($thisfile, $colfiledir);

    } else {
        my $destfile = $file;
        $destfile =~ s/^modelcol/$collection/;
        $destfile =~ s/^MODELCOL/$capcollection/;
        &gsprintf(STDOUT, "{mkcol.doing_replacements}\n", $destfile)
        unless $quiet;
        $destfile = &util::filename_cat ($coldir, $destfile);

        open (INFILE, $thisfile) || 
        (&gsprintf(STDERR, "{common.cannot_read_file}\n", $thisfile) && die);
        open (OUTFILE, ">$destfile") ||
        (&gsprintf(STDERR, "{common.cannot_create_file}\n", $destfile) && die);

        while (defined ($line = <INFILE>)) {
        $line =~ s/\*\*collection\*\*/$collection/g;
        $line =~ s/\*\*COLLECTION\*\*/$capcollection/g;
        $line =~ s/\*\*creator\*\*/$creator/g;
        $line =~ s/\*\*maintainer\*\*/$maintainer/g;
        $line =~ s/\*\*public\*\*/$public/g;
        $line =~ s/\*\*title\*\*/$title/g;
        $line =~ s/\*\*about\*\*/$about/g;
        $line =~ s/\*\*plugins\*\*/$pluginstring/g;

        print OUTFILE $line;
        }
        
        close (OUTFILE);
        close (INFILE);
    }
    }
}

# get and check options
sub parse_args {
    my ($argref) = @_;
    if (!&parsargv::parse($argref,
              'language/.*/', \$language,
              'optionfile/.*/', \$optionfile,
              'collectdir/.*/', \$collectdir,
              'creator/\w+\@[\w\.]+/', \$creator,
              'maintainer/\w+\@[\w\.]+/', \$maintainer,
              'public/true|false/true', \$public,
              'title/.+/', \$title,
              'about/.+/', \$about,
              'plugin/.+', \@plugin,
              'quiet', \$quiet,
              'gli', \$gli,
              q^xml^, \$xml
              )) {
    &PrintUsage::print_txt_usage($options, "{mkcol.params}");
    die "\n";
    }
}

sub main {

    &parse_args (\@ARGV);

    # If $language has been specified, load the appropriate resource bundle
    # (Otherwise, the default resource bundle will be loaded automatically)
    if ($language) {
    &gsprintf::load_language_specific_resource_bundle($language);
    }

    if ($xml) {
    &PrintUsage::print_xml_usage($options);
    die "\n";
    }

    if ($gli) { # the gli wants strings to be in UTF-8
    &gsprintf::output_strings_in_UTF8; 
    }
    
    if ($optionfile =~ /\w/) {
    open (OPTIONS, $optionfile) ||
        (&gsprintf(STDERR, "{common.cannot_open}\n", $optionfile) && die);
    my $line = [];
    my $options = [];
    while (defined ($line = &cfgread::read_cfg_line ('mkcol::OPTIONS'))) {
        push (@$options, @$line);
    }
    close OPTIONS;
    &parse_args ($options);
    }

    # load default plugins if none were on command line
    if (!scalar(@plugin)) {
    @plugin = (ZIPPlug,GAPlug,TEXTPlug,HTMLPlug,EMAILPlug,
           PDFPlug,RTFPlug,WordPlug,PSPlug,ArcPlug,RecPlug);
    }

    # get and check the collection name
    ($collection) = @ARGV;
    if (!defined($collection)) {
    &gsprintf(STDOUT, "{mkcol.no_colname}\n");
    &PrintUsage::print_txt_usage($options, "{mkcol.params}");
    die "\n";
    }

    if (length($collection) > 8) {
    &gsprintf(STDOUT, "{mkcol.long_colname}\n");
    die "\n";
    }

    if ($collection eq "modelcol") {
    &gsprintf(STDOUT, "{mkcol.bad_name_modelcol}\n");
    die "\n";
    }

    if ($collection eq "CVS") {
    &gsprintf(STDOUT, "{mkcol.bad_name_cvs}\n");
    die "\n";
    }

    # We don't want creator to be required anymore - John Thompson 28-11-2003
    #if (!defined($creator) || $creator eq "") {
    #   &gsprintf(STDOUT, "{mkcol.creator_undefined}\n");
    #   die "\n";
    #}

    #Of course thats means we don't want to default maintainer unless a creator is provided
    if (defined($creator) && (!defined($maintainer) || $maintainer eq "")) {
    $maintainer = $creator;
    }

    $public = "true" unless defined $public;

    if (!defined($title) || $title eq "") {
    $title = $collection;
    }

    # get capitalised version of the collection
    $capcollection = $collection;
    $capcollection =~ tr/a-z/A-Z/;

    # get the strings to include.
    $pluginstring = "";
    foreach $plugin (@plugin) {
    $pluginstring .= "plugin         $plugin\n";
    }

    $mdir = &util::filename_cat ($ENV{'GSDLHOME'}, "collect", "modelcol");
    if (defined $collectdir && $collectdir =~ /\w/) {
    if (!-d $collectdir) {
        &gsprintf(STDOUT, "{mkcol.no_collectdir}\n", $collectdir);
        die "\n";
    }
    $cdir = &util::filename_cat ($collectdir, $collection);
    } else {
    $cdir = &util::filename_cat ($ENV{'GSDLHOME'}, "collect", $collection);
    }

    # make sure the model collection exists
    (&gsprintf(STDERR, "{mkcol.cannot_find_modelcol}\n", $mdir) && die) unless (-d $mdir);

    # make sure this collection does not already exist
    if (-e $cdir) {
    &gsprintf(STDOUT, "{mkcol.col_already_exists}\n");
    die "\n";
    }

    # start creating the collection
    &gsprintf(STDOUT, "\n{mkcol.creating_col}...\n", $collection)
    unless $quiet;
    &traverse_dir ($mdir, $cdir);
    &gsprintf(STDOUT, "\n{mkcol.success}\n", $cdir)
    unless $quiet;
}

&main ();