Subversion Repositories DevTools

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

# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.

#

# Module name   : jats.sh

# Module type   : Makefile system

# Compiler(s)   : n/a

# Environment(s): jats

#

# Description   : Class to provide utilities associated with a locating

#                 build files and build file dependencies.

#

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

require 5.006_001;

use strict;

use warnings;

package JatsBuildFiles;

use JatsError;

use File::Find;

use BuildName;

use JatsVersionUtils;

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

use Exporter;

$VERSION = 1.00;

@ISA = qw(Exporter);

# Symbols to autoexport (:DEFAULT tag)

@EXPORT = qw( BuildFileScanner

            );

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

# Function        : BuildEntry

#

# Description     : Create a BuildEntry Object

#                   This object describes a build file. It is passed to the

#                   user of this class.

#

#                   There are no object accessors.

#                   Just use the object as a reference to hash.

#

# Inputs          : $dir                - Dir of the build file

#                   $file               - Name of the build file

#                   $type               - Type 1:Jats, 2:ANT

#

# Returns         : Reference to an object

#

sub BuildEntry

{

    my $self  = {};

    $self->{dir} = shift;

    $self->{file}  = shift;

    $self->{type} = shift;

    #

    #   Other fields that are known:

    #       name

    #       version

    #       full

    #       mname

    #       project

    #

    bless ($self, 'BuildEntry');

    return $self;

}

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

# Function        : BuildFileScanner

#

# Description     : Create a new instance of a build file class

#                   This is the one exported function of this class

#                   It is a constructor to allow scanning for build files

#

# Inputs          : root            - Base pathname

#                   file            - Build filename

#                   options         - Options to be processed

#

#                   Options are:

#                   --ScanDependencies  - Collect information on dependent packages

#                   --LocateAll         - Scan for ANT and JATS build files

#                   --LimitDepth=n      - Limit the depth of the scan

#                   --stop              - Ignore if a 'stop' file exists in the directory

#

#

# Returns         : A reference to class.

#

sub BuildFileScanner {

    my $self  = {};

    $self->{root} = shift;

    $self->{file}  = shift;

    $self->{info} = [];

    $self->{scandeps} = 0;

    $self->{locateAll} = 0;             # Scan Jats and Ant files

    $self->{LimitDepth} = 0;            # Skim the tree

    $self->{Stop} = 0;                  # Support a 'stop' file

    bless ($self);

    Error ("Locating Build files. Root directory not found",

           "Path: $self->{root}" ) unless ( -d $self->{root} );

    #

    #   Process user arguments.

    #   These are treated as options. Leading '--' is optional

    #

    foreach ( @_ )

    {

        my $opt = '--' . $_;

        $opt =~ s~^----~--~;

        $self->option ($opt) || Error( "BuildFileScanner. Unknown initialiser: $_");

    }

    return $self;

}

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

# Function        : option

#

# Description     : Function to simplify the processing of arguments

#                   Given an argument this function will act on it or

#                   return false

#

# Inputs          : option          - One possible standard search option

#

# Returns         : True            - Option is an  option and its been

#                                     processed

#

sub option

{

    my ($self, $opt) = @_;

    my $result = 1;

    if ( $opt =~ m/^--ScanDependencies/ ) {

        $self->{scandeps} = 1;

    } elsif ( $opt =~ m/^--ScanExactDependencies/ ) {

        $self->{scandeps} = 2;

    } elsif ( $opt =~ m/^--LocateAll/ ) {

        $self->{locateAll} = 1;

    } elsif ( $opt =~ m/^--Stop/ ) {

        $self->{Stop} = 1;

    } elsif ( $opt =~ m/^--LimitDepth=(\d+)/ ) {

        $self->{LimitDepth} = $1;

    } else {

        $result = 0;

    }

    return $result;

}

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

# Function        : getLocation 

#

# Description     : Serialize location data such that it can be used by the

#                   setLocation function.

#                   Format:

#                       RootDirectory

#                       Number of BuildEntry(s) that follow

#                       BuildEntry

#                   Where each BuildEntry is:

#                       Path

#                       BuildFile

#                       Type 1:Jats, 2:ANT    

#

# Inputs          :  $self

#

# Returns         :  Text string of serailised data

#

sub getLocation

{

    my ($self) = shift;

    my @locationData;

    push @locationData,  $self->{root};

    push @locationData,  scalar  @{$self->{info}};

    foreach my $be ( @{$self->{info}} )

    {

        push @locationData,  $be->{dir}, $be->{file}, $be->{type};

    }

    return (join($;, @locationData));

}

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

# Function        : setLocation 

#

# Description     : Insert location data

#                   Bypass the need to perform a 'locate' operation

#                   Used to cache location data in large systems 

#                   

#                   Will detect missing build files and allow the user to

#                   handle the error.

#

# Inputs          : $self

#                   ...     Location data as returned by getLocation

#

# Returns         : 1   - All Build files exist

#                   0   - At least one of the build files does not exist

#

sub setLocation

{

    my ($self, $data) = @_;

    my @locationData =  split($;, $data);

    my $rv = 1;

    my $root = shift @locationData;

    my $count = shift @locationData;

    while ($count-- > 0)

    {

        my $buildfile = join('/',$locationData[0], $locationData[1]);

        $rv = 0 unless -f $buildfile;    

        push @{$self->{info}}, BuildEntry( @locationData);

        splice @locationData, 0, 3;

    }

    $self->{locate_done} = 1;

    return $rv;

}

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

# Function        : locate

#

# Description     : Locate all build files within a given directory tree

#                   Collects the data and builds up a data structure

#

#                   If the file is an xml file, then we are looking for

#                   an ant pair of files.

#

# Inputs          : $self

#

# Returns         : Number of buildfiles found 0,1 ....

#

sub locate

{

    my ($self) = @_;

    #

    #   Locate all the build files that match the users request

    #

    my $ff_datap = \@{$self->{info}};

    my $ff_file = $self->{file};

    my $ff_all = $self->{locateAll};

    my $ff_self = $self;

    my $ff_ant = ( $ff_file =~ m~(.+)\.xml$~i ) ? $1 : '';

    #

    #   Anonymous sub for the file::find wanted function

    #       Use closure to allow access to local variables

    #       Use no_chdir to allow very deep (windows) structures

    #

    my $wanted = sub 

    {

        # Using no_chdir - extract just the filename

        my $file = $_;

        $file =~ s~.*/~~;

        Verbose3( "locateBuildFile: $file");

        if ( -d $_)

        {

            #

            #   Skip known dirs

            #   

            if ($file eq '.git' || $file eq '.svn' || $file eq 'lost+found')

            {

                $File::Find::prune = 1;

                Verbose3( "locateBuildFile: PRUNE: $file");

                return;

            }

            #

            #   Limit the depth of the scan

            #       Suggestion 3 or 4 below the package base

            #

            if ($self->{LimitDepth})

            {

                my $depth = $File::Find::name =~ tr~/~/~;

                if ($depth >= $self->{LimitDepth})

                {

                    $File::Find::prune = 1;

                    Verbose3( "locateBuildFile: LimitDepth: $_");

                    return;

                }

            }

            #

            #   Stop file processing

            #   If the directory conatins a 'stop' file then we won't find any build files in it

            #   Nor should we find any below it.

            #

            if ($self->{Stop})

            {

               if ( -f $File::Find::name . '/stop' )

               {

                   $File::Find::prune = 1;

                   Verbose0( "locateBuildFile: Stop file: $_");

                   return;

               }

            }

        }

        if ( $file eq $ff_file  )

        {

            if ( $ff_ant )

            {

                if ( -f ( $File::Find::dir . '/' . ${ff_ant} . 'depends.xml') )

                {

                    Verbose ("locateBuildFile: FOUND $File::Find::dir, $file");

                    push @{$ff_datap}, BuildEntry( $File::Find::dir, $file, 2);

                }

            }

            else

            {

                $file = 'auto.pl' if ( $ff_self->{scandeps} && -f 'auto.pl' );

                Verbose ("locateBuildFile: FOUND $File::Find::dir, $file");

                push @{$ff_datap}, BuildEntry( $File::Find::dir, $file, 1);

            }

            return;    

        }

        #

        #   Detect ANT {packagename}depends.xml file

        #       These are file pairs (mostly)

        #       Must not be empty

        #

        if ( $ff_all && $file =~ m/(.+)depends.xml$/ && -s $file )

        {

            my $baseFile = $File::Find::dir . '/' . $1 . '.xml';

            if ( -f $baseFile && -s $baseFile )

            {

                Verbose ("locateBuildFile: FOUND $File::Find::dir, $file");

                push @{$ff_datap}, BuildEntry( $File::Find::dir, $file, 2);

            }

        }

    };

    #

    #   Find all matching files

    #   Call helper rouine to populate the data strcutures

    #

    File::Find::find ( { wanted => $wanted, no_chdir => 1 }, $self->{root} );

    #

    #   Flag that the directories have been scanned

    #

    $self->{locate_done} = 1;

    return scalar  @{$self->{info}};

}

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

# Function        : scan

#

# Description     : Scan all buildfiles and determine the packages that are

#                   created by file(s)

#

#                   This routine can extract build dependency information, but

#                   this is not done by default

#

# Inputs          : $self

#

# Returns         : 

#

sub scan

{

    my ($self) = @_;

    #

    #   Locate the buildfiles, unless this has been done

    #

    locate ( $self ) unless ( $self->{locate_done} );

    #

    #   Scan all build files and determine the target package name

    #

    #

    foreach my $be ( @{$self->{info}} )

    {

        if ( $be->{type} == 2 ) {

            scan_ant ( $be, $self->{scandeps} );

        } else {

            scan_jats( $be, $self->{scandeps} );

        }

        #

        #   Skip invalid build files

        #

        next unless ( $be->{name} &&  $be->{version}  );

        #

        #   Calculate internal information from the basic information

        #   To be used as a Display Name (Display to user)

        #   full    - Full package version and extension

        #   mname   - name and extension

        #

        #   To be used for data processing (Hash key into data)

        #   fullTag - Full package version and extension $; joiner

        #   package - name and extension with a $; joiner

        #

        #

        $be->{fullTag} = join $;, $be->{name}, $be->{version}, $be->{prj};

        $be->{package} = join $;, $be->{name}, $be->{prj};

        $be->{version} .= '.' . $be->{prj} if ( $be->{prj} );

        $be->{full} = $be->{name} . ' ' . $be->{version};

        $be->{mname} = $be->{name};

        $be->{mname} .= '.' . $be->{prj} if ( $be->{prj} );

        Verbose2( "Buildfile: $be->{dir}, $be->{file},$be->{name}");

    }

    $self->{scan_done} = 1;

}

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

# Function        : scan_jats

#

# Description     : Scan a jats build file

#

# Inputs          : $be         - Reference to a BuildEntry

#                   $scanDeps   - Include dependency information

#

# Returns         : Nothing

#

sub scan_jats

{

    my ($be, $scanDeps ) = @_;

    my $infile = "$be->{dir}/$be->{file}";

    open ( INFILE, "<$infile" ) || Error( "Cannot open $infile" );

    while ( <INFILE> )

    {

        next if ( m~^\s*#~ );            # Skip comments

        #

        #   Process BuildName

        #

        if ( m~\s*BuildName[\s\(]~ )

        {

            #   Build names come in many flavours, luckily we have a function

            #

            m~\(\s*(.*?)\s*\)~;

            my @args = split /\s*,\s*/, $1;

            my $build_info = BuildName::parseBuildName( @args );

            $be->{name} = $build_info->{BUILDNAME_PACKAGE};

            $be->{version} = $build_info->{BUILDNAME_VERSION};

            $be->{prj} = $build_info->{BUILDNAME_PROJECT};

        }

        #

        #   (Optional) Process BuildPkgArchive and LinkPkgArchive

        #   Retain the Name and the ProjectSuffix and the version

        #

        if ( $scanDeps && ( m/^LinkPkgArchive/ or m/^BuildPkgArchive/ ))

        {

            m/['"](.*?)['"][^'"]*['"](.*?)['"]/;

            my ( $package, $rel, $suf, $full ) = SplitPackage( $1, $2 );

            if ( $scanDeps > 1 ) {

                $be->{depends}{$package,$rel,$suf} = join ($;, $1, $2);

            } else {

                $be->{depends}{$package,$suf} = join ($;, $1, $2);

            }

        }

    }

    close INFILE;

}

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

# Function        : scan_ant

#

# Description     : Scan an ant build file

#

# Inputs          : $be         - Reference to a BuildEntry

#                   $scanDeps   - Include dependency information

#

# Returns         : Nothing

#

sub scan_ant

{

    my ($be, $scanDeps ) = @_;

    my $infile = "$be->{dir}/$be->{file}";

    my $release_name;

    my $release_version;

    open ( INFILE, "<$infile" ) || Error( "Cannot open $infile" );

    while ( <INFILE> )

    {

        #

        #   Process "property" statements

        #

        if ( m~<property~ )

        {

            my $name;

            my $value;

            #

            #   Extract the name and version

            #

            $name = $1 if m~name=\"([^"]*)"~;

            $value = $1 if m~value=\"([^"]*)"~;

            if ( $name && $value )

            {

                if ( $name eq 'packagename' ) {

                    $release_name = $value;

                } elsif ( $name eq 'packageversion' ) {

                    $release_version = $value;

                    my ( $package, $rel, $suf, $full ) = SplitPackage( $release_name, $release_version );

                    $be->{name} = $package;

                    $be->{version} = $rel;

                    $be->{prj} = $suf;

                } elsif ( $name eq 'releasemanager.releasename' ) {

                    next;

                } elsif ( $name eq 'releasemanager.projectname' ) {

                    next;

                } elsif ( $scanDeps ) {

                    my ( $package, $rel, $suf, $full ) = SplitPackage( $name, $value );

                    if ( $scanDeps > 1 ) {

                        $be->{depends}{$package,$rel,$suf} = join ($;, $name, $value);

                    } else {

                        $be->{depends}{$package,$suf} = join ($;, $name, $value);

                    }

                }

            }

        }

    }

    close INFILE;

}

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

# Function        : getInfo

#

# Description     : Returns an array of stuff that can be used to iterate

#                   over the collected data.

#

#                   Will perform a 'locate' if not already done

#

#                   The elements are BuildEntries

#                   These are pretty simple

#

# Inputs          : $self

#

# Returns         : 

#

sub getInfo

{

    my ($self) = @_;

    #

    #   Locate the buildfiles, unless this has been done

    #

    locate ( $self ) unless ( $self->{locate_done} );

    return @{$self->{info}};

}

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

# Function        : match

#

# Description     : Determine build files that match a given package

#                   A full package name has three fields

#                       1) Name

#                       2) Version

#                       3) Extension (optional)

#                   The package can be specified as:

#                       Name.Version.Extension

#                       Name.Extension

#

# Inputs          : $self

#                   $package                - See above

#

# Returns         : Number of buildfiles that match

#

sub match

{

    my ($self, $package) = @_;

    return 0 unless ( $package );

    scan ( $self ) unless ( $self->{scan_done} );

    $self->{match} = [];

    foreach my $be ( @{$self->{info}} )

    {

        next unless ( $be->{name} &&  $be->{version}  );

        if ( $package eq $be->{mname} || $package eq ($be->{name} . '.' . $be->{version}) )

        {

            push @{$self->{match}}, $be;

        }

    }

    $self->{match_done} = 1;

    return scalar @{$self->{match}}

}

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

# Function        : getMatchList

#

# Description     : Get the results of a match

#                   If no match has been done, then return the complete

#                   list - Like getInfo

#

# Inputs          : $self

#

# Returns         : Array of directories that matched the last match

#

sub getMatchList

{

    my ($self) = @_;

    my $set = 'info';

    $set = 'match' if ( $self->{match_done} );

    return @{$self->{$set}};

}

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

# Function        : getMatchDir

#

# Description     : Get the results of a match

#                   Can be an array or a scalar. If a scalar is requested

#                   then this rouitne will ensure that only one entry

#                   has been matched.

#

# Inputs          : $self

#

# Returns         : Array of directories that matched the last match

#

sub getMatchDir

{

    my ($self) = @_;

    my @list;

    foreach my $be ( $self->getMatchList() )

    {

        push @list, $be->{dir};

    }

    if ( wantarray )

    {

        return @list;

    }

    Error ("Locate Build file. Internal error",

           "Multiple build files have been located. This condition should have",

           "been handled by the application") if ( $#list > 0 );

    return $list[0];

}

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

# Function        : formatData

#

# Description     : Create an array of build files and package names

#                   Used to pretty print error messages

#

# Inputs          : $self

#

# Returns         : Array of text strings formatted as:

#                   path : packagename

#

#

sub formatData

{

    my ($self) = @_;

    my @text;

    my $max_len = 0;

    my %data;

    #

    #   Travserse the internal data

    #

    foreach my $be ( @{$self->{info}} )

    {

        my $package = $be->{mname} || '-Undefined-';

        my $path = "$be->{dir}/$be->{file}";

        my $len = length $path;

        $max_len = $len if ( $len > $max_len );

        $data{$path} = $package;

    }

    foreach my $path ( sort keys %data )

    {

        push (@text, sprintf ("%${max_len}s : %s", $path, $data{$path} ));

    }

    return @text;

}

1;