Subversion Repositories DevTools

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

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

#

# Module name   : jats.sh

# Module type   : Makefile system

# Compiler(s)   : n/a

# Environment(s): jats

#

# Description   : This package extends the JATS toolset at build time

#                 It provides additional directives to the JATS makefiles

#                 to simplify the directives.

#

#                 The directive matches up with a run-time tool to

#                 do the bulk of the work.

#

# Operation     : This package adds the JATS directive MakeDebianPackage

#                 When used the directive will use GenerateFiles to invoke

#                 a script (DebianPackager.pl) to actually do the hard work.

#

# Syntax        : MakeDebianPackage (<platforms>, Options+);

#                 Where Options may be one of:

#                   --Script=DebianPackagerScript       - Mandatory. Name of a the debian script

#

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

require 5.006_001;

#use strict;

use warnings;

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

# Function        : MakeDebianPackage

#

# Description     : Create a Debian Package

#

# Inputs          : PkgName                 - Symbolic Package Name

#                   --Script=Name           - Script to use in the packaging process

#                   --Name=Name             - Debian Package name(optional)

#                   --Variant=Text          - Package Variant(optional)

#

# Returns         : 

#

sub MakeDebianPackage

{

    my( $platforms, @elements ) = @_;

    Debug2( "MakeDebianPackage($platforms, @elements)" );

    return if ( ! ActivePlatform($platforms) );

    my $build_name =  $::ScmBuildPackage;

    my $build_version = $::ScmBuildVersionFull;

    my $build_variant = '';

    my $script_set=0;

    my $name_set=0;

    my $variant_set=0;

    #

    #   Take the project name and convert it into a full path

    #

    my $script;

    #

    #   Collect user arguments

    #   They are all processed within the toolset

    #

    foreach ( @elements )

    {

        if ( m/^--Script=(.+)/ ) {

            $script = $1;

            $script_set++;

        } elsif ( m/^--Name=(.+)/ ) {

            $build_name = $1;

            $name_set++;

        } elsif ( m/^--Variant=(.+)/ ) {

            $build_variant = $1;

            $variant_set++;

        } elsif ( m/^--/ ) {

            Error("MakeDebianPackage. Unknown option: $_");

        } else {

            Error("MakeDebianPackage. Unknown argument: $_");

        }

    }

    #

    #   Sanity test

    #

    Error ("MakeDebianPackage: Script name not defined") unless ( $script );

    Error ("MakeDebianPackage: --Script option can only be used once") if ( $script_set > 1 );

    Error ("MakeDebianPackage: --Name option can only be used once") if ( $name_set > 1 );

    Error ("MakeDebianPackage: --Variant option can only be used once") if ( $variant_set > 1 );

    #

    #   Build up the build name

    #       Add variant to base name.

    #

    if ( $build_variant )

    {

        $build_name .= '-' . $build_variant;

    }

    #

    #   Sanity check the package name and version

    #   Debian has strict requirements than JATS

    #       Name:    Lower case letters (a-z), digits (0-9), plus (+) and minus (-) signs, and periods (.).

    #                Release Manager does not allow '.'

    #       Version: alphanumerics and the characters . + - : (full stop, plus, hyphen, colon) and should start with a digit

    #

    #   Allow ( and cleanup )

    #       ERGxxxxx    -> erg-xxx

    #       VIXxxxxx    -> vix-xxx

    #       Whitespace   -> -

    #       _           -> -

    #       Remove multiple '-' characters

    #       Lowercase all text

    #

    my $cvt = 0;

    $cvt = 1 if ( $build_name =~ s/^ERG/erg-/ );

    $cvt = 2 if ( $build_name =~ s/^VIX/vix-/ );

    $cvt = 3 if ( $build_name =~ s~\s~-~g );

    $cvt = 4 if ( $build_name =~ s~_~-~g );

    $cvt = 5 if ( $build_name =~ s~--+~-~g );

    if ( $build_name =~ m/[A-Z]/ )

    {

        $cvt = 6;

        $build_name = lc $build_name;

    }

    Warning ("Package Name converted to debian friendly form: $build_name")

        if ( $cvt );

    unless ( $build_name =~ m/^[a-z][-+a-z0-9]+$/ )

    {

        Error ("Package Name does not conform to Debian Requirements",

               "Must be at least two characters long",

               "Must start with an alphabetic character",

               "Must only contain: (a-z) (0-9) and -",

               "Provided Name: $::ScmBuildPackage");

    }

    unless ( $::ScmBuildVersionFull =~ m/^[0-9][-+:.A-Za-z0-9]+$/ )

    {

        Error ("Package Version does not conform to Debian Requirements",

               "Must only contain: (a-zA-Z) (0-9), - and .",

               "Must sart with a number",

               );

    }

    #

    #   Create the name of the target package

    #   The form of the name is of a fixed form.

    #

    #   Note: "_" used since this is the format of dpkg-name

    #   Note: dpkg-name generates: Name _ Version _ Architecture

    #

    #

    my $DebianPkgName = "${build_name}_${::ScmBuildVersionFull}_${::ScmPlatform}.deb";

    #

    #   Simply use Generate Files

    #   With lots of options

    #

    Src ( '*', $script );

    GenerateFiles ('*', "--Tool=DebianPackager.pl",               # Associated tool

                        "-DebianPackage=--Prerequisite($script)", # Packager script

                        "--AutoGenerate",                         # Build when needed

                        "--UnknownPreq",                          # Always build

                        "--Clean",                                # Script supports jats clean

                        "--Text=Debian Package",                  # Display when building

                        '--Var(BuildName)',                       # Target Package

                        '--Var(BuildVersion)',                    # Target Version

                        '--Var(Platform)',                        # Target platform

                        '--Var(Product)',                         # Target product

                        '--Var(Target)',                          # Underlying Target

                        '--Var(Type)',                            # Build Type

                        '--Var(Verbose)',                         # Verbose operation

                        '--Var(InterfaceDir)',                    # Interface Directory

                        '--Var(InterfaceIncDir)',

                        '--Var(InterfaceLibDir)',

                        '--Var(InterfaceBinDir)',

                        '--Var(LibDir)',                          # My Artifacts

                        '--Var(BinDir)',

                        '--Var(PackageDir)',                      # My Package

                        '--Var(PackageLibDir)',                   # My Package Library

                        '--Var(PackageBinDir)',                   # My Package Bin

                        '--Var(PackagePkgDir)',                   # My Package/pkg.target

                        '--Var(LocalIncDir)',                     # Installed Artifacts

                        '--Var(LocalLibDir)',

                        '--Var(LocalBinDir)',

                        '--Var(PkgArch)',

                        "-Name=$build_name",                      # Base Package Name

                        "-Variant=$build_variant",                # Variant Name

                        "-Output=--GeneratedProg($DebianPkgName)",# Specify output file

                        );

    #

    #   The Packager has created a binary in the 'PROG' directory

    #   Lets package it as a program.

    #

    PackageProg ('*', $DebianPkgName );

}

1;