Subversion Repositories DevTools

#! perl

########################################################################

# Copyright ( C ) 2005 ERG Limited, All rights reserved

#

# Module name   : jats.sh

# Module type   : Perl Package

# Compiler(s)   : n/a

# Environment(s): jats

#

# Description   : This package contains functions to manipulate desckpkg files

#

# Usage:

#

# Version   Who      Date        Description

#

#......................................................................#

require 5.6.1;

use strict;

use warnings;

package DescPkg;

our (@ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS, $VERSION);

use Exporter;

use Sys::Hostname;                          # For hostname

use JatsVersionUtils;

$VERSION = 1.00;

@ISA = qw(Exporter);

# Symbols to autoexport (:DEFAULT tag)

@EXPORT = qw( ReadDescpkg

              CopyDescpkg

            );

#-------------------------------------------------------------------------------

# Function        : ReadDescpkg

#

# Description     : Read in a descpkg file

#                   Support both old and new formats of the file

#

# Inputs          : path    - path of the file to process

#                   mode    - 1 == process dependancies

#

# Returns         : undef if the file was not found

#                   Pointer to a hash of useful information

#

sub ReadDescpkg

{

    my ($path, $mode) = @_;

    my $line;

    my $rec;

    my $ver_string;

    open (DESCPKG, "$path") || return undef;

    #

    #  Slurp the first line and determine the type of the file

    #  If the descpkg file is empty then this is an error

    #

    $line = <DESCPKG>;

    if ( ! $line )

    {

        close DESCPKG;

        return undef;

    }

    elsif ( $line =~ m/^Manifest-Version:/ )

    {

        #

        #   Manifest form

        #

        my $section;

        while ( defined( $line = <DESCPKG> ) )

        {

            $line =~ s~\s+$~~;                              # Kill DOS and UNIX line endings

            #

            #   Detect section break;

            #

            if ( $line =~ m/^Name:\s*(.*)/ )

            {

                $section = $1;

                next;

            }

            next unless ( $section );

            #

            #   Extract Build Properties

            #

            if ( $section eq "Build Properties" )

            {

                if ( $line =~ m/^Package Name:\s*(.*)/ )

                {

                    $rec->{'NAME'} = $1;

                }

                elsif ( $line =~ m/^Package Version:\s*(.*)$/ )

                {

                    $ver_string = $1;

                }

            }

            elsif ( $mode && $section eq "Build Dependencies" )

            {

                my %data;

                if ( $line =~ m/(.*):\s*(.*)/ )

                {

                    $data{name} = $1;

                    $data{version} = $2;

                    push @{$rec->{'PACKAGES'}}, \%data;

                }

            }

        }

    }

    elsif ( $line =~ m/^Package Name:\s/ )

    {

        #

        #   New form

        #

        while ( 1 )

        {

            $line =~ s~\s+$~~;                              # Kill DOS and UNIX line endings

            if ( $line =~ m/^Package Name:\s*(.*)/ )

            {

                $rec->{'NAME'} = $1;

            }

            elsif ( $line =~ m/^Version:\s*(.*)$/ )

            {

                    $ver_string = $1;

            }

            elsif ( $line =~ m/^Build Dependencies:/ )

            {

                last;

            }

            last unless ( defined ($line = <DESCPKG>) )

        }

        #

        #   Extract dependancies

        #   Keep the order of the dependancies as this may be important

        #   These are stored in an array of hashes.

        #

        #   Locate lines of the form:

        #       <sandbox .... />

        #   and extract all attributes. These are of the form

        #       attribute_name="attribute_value"

        #   The values are stored in a hash for later use

        #

        if ( $mode )

        {

            while ( defined( $line = <DESCPKG> ) )

            {

                $line =~ s~\s+$~~;                              # Kill DOS and UNIX line endings

                if ( $line =~ m~<sandbox\s+(.*)/>~ )

                {

                    my $raw = $1;

                    my $data;

                    while ( $raw =~ m/(\w*?)="(.*?)"/g )

                    {

                        $data->{$1} = $2;

                    }

                    push @{$rec->{'PACKAGES'}}, $data;

                }

            }

        }

    }

    else

    {

        #

        #   Old form

        #   Cleanup various bad habits

        #       1) Remove trailing comments ie: space-space

        #       2) Replace , with a space

        #

        $line =~ s~\s+-\s+.*~~;

        $line =~ s~,~ ~g;

        my $proj;

        ($rec->{'NAME'}, $ver_string, $proj) = split( ' ', $line );

        #

        #   Attempt to correct for a common error in old packages

        #   where the project is attached to to the version

        #   ie: name 1.2.3.cr instead of name 1.2.3 cr

        #

        $ver_string .= '.' . $proj if ( $proj );

    }

    close DESCPKG;

    #

    #   Ensure the package Name has been found

    #

    return undef

        unless ( exists ($rec->{'NAME'}) && $rec->{'NAME'} && $ver_string );

    #

    #   Split the version string into bits and save the results

    #

    (

     $rec->{'NAME'},

     $rec->{'VERSION'},

     $rec->{'PROJ'},

     $rec->{'VERSION_FULL'} ) = SplitPackage( $rec->{'NAME'} ,$ver_string);

    return $rec;

}

#-------------------------------------------------------------------------------

# Function        : CopyDescpkg

#

# Description     : Copy a descpkg file and update various fields

#                   Several fields will be re-written or modified

#                   Used when creating a package to maintain package contents

#                   Supports all the formats of descpkg

#

# Inputs          : $src       - Source Path

#                   $dest      - Destination path

#

#

# Returns         : 0    - All is well

#                   Else - Error string

#

#

sub CopyDescpkg

{

    my ($src,$dest) = @_;

    #

    #   Ensure that we have user and machine name

    #

    my ($USER) = $ENV{"USER"} || return "Need JATS 'USER' environment variable";

    my $MACHINENAME = hostname;

    return "Machine Name not determined" unless ( $MACHINENAME );

    chomp( $MACHINENAME );

    #

    #   Open files

    #

    open (DESCPKG, "<$src") || return "File not found [$src]";

    open (DESCPKGOUT, ">$dest")    || return "Failed to create file [$dest]";

    #

    #   Need to sniff the header of the file to determine which type of file

    #   it is. There are several types of file

    #

    my $line = <DESCPKG>;

    $line =~ s~\s+$~~;                              # Kill DOS and UNIX line endings

    return ("Empty descpkg file: $src") unless ( $line );

    print DESCPKGOUT $line, "\n";

    if ( $line =~ m/^Manifest-Version:/ )

    {

        ########################################################################

        #   Manifest format

        #

        my $active = 'h';

        my %attributes =

                (

                    'Built By:'         => $USER,

                    'Built On:'         => scalar( localtime()),

                    'Build Machine:'    => $MACHINENAME,

                );

        while ( $line = <DESCPKG> )

        {

            $line =~ s~\s+$~~;                              # Kill DOS and UNIX line endings

            if ( $active eq 'h' )

            {

                #

                #   Hunt for the Build Properties section

                #

                if ( $line =~ m/^Name: Build Properties/ )

                {

                    $active = 'p';

                }

            }

            elsif ($line)

            {

                #

                #   Process Build Properties

                #

                #

                #   Extract attribute name

                #   Pass on those we don't know

                #   Susbstitute those we do

                #

                $line =~ m/^(.*?:)\s+(.*)/;

                if ( exists $attributes{$1} )

                {

                    $line = "$1 $attributes{$1}";

                    delete $attributes{$1};

                }

            }

            else

            {

                $active = 'h';

                #

                #   End of the section

                #   Write out attributes not already processed

                #

                foreach  ( sort keys %attributes )

                {

                    print DESCPKGOUT "$_ $attributes{$_}\n";

                }

            }

        }

        continue

        {

            print DESCPKGOUT $line, "\n";

        }

    }

    elsif ( $line =~ m/^Package Name: / )

    {

        ########################################################################

        #   Original JATS format

        #

        while ( $line = <DESCPKG> )

        {

            $line =~ s~\s+$~~;                              # Kill DOS and UNIX line endings

            if ( $line =~ m/^(Released By:\s+)/ ) {

                $line = $1 . $USER;

            }

            elsif ( $line =~ m/^(Released On:\s+)/ ) {

                $line = $1 . localtime();

            }

        }

        continue

        {

            print DESCPKGOUT $line, "\n";

        }

    }

    else

    {

        ########################################################################

        #   Naughty format

        #   Possible a very old format

        #

        while ( $line = <DESCPKG> )

        {

            print DESCPKGOUT $line;

        }

    }

    close DESCPKG;

    close DESCPKGOUT;

    return undef;

}

1;