File Coverage

script/mkpkgconfig

Criterion	Covered	Total	%
statement	57	65	87.6
branch	24	30	80.0
condition	3	4	75.0
subroutine	10	10	100.0
pod			n/a
total	94	109	86.2

#! /usr/bin/env perl

# ABSTRACT: create pkg-config metadata files
# PODNAME: mkpkgconfig

use strict;
use warnings;

use Getopt::Long::Descriptive;
use File::Basename;
use File::Spec::Functions;
use Carp;

our $VERSION = 'v2.0.0';

use constant {
    ALL_VARS       => 1,
    REQUESTED_VARS => 2,
    NEEDED_VARS    => 3,
};

our %VarsAuto = (
    exec_prefix => '${prefix}',

    bindir  => '${exec_prefix}/bin',
    sbindir => '${exec_prefix}/sbin',

    libdir     => '${exec_prefix}/lib',
    pkg_libdir => '${libdir}/${package}',

    libexecdir     => '${exec_prefix}/libexec',
    pkg_libexecdir => '${libexecdir}/${package}',

    datarootdir => '${prefix}/share',

    datadir     => '${datarootdir}',
    pkg_datadir => '${datadir}/${package}',

    sysconfdir     => '${prefix}/etc',
    pkg_sysconfdir => '${sysconfdir}/${package}',

    localstatedir     => '${prefix}/var',
    pkg_localstatedir => '${localstatedir}/${package}',

    includedir     => '${prefix}/include',
    pkg_includedir => '${includedir}/${package}',

    docdir  => '${datarootdir}/doc/${package}',
    infodir => '${datarootdir}/info',
    mandir  => '${datarootdir}/man',
);

my %KeywordOptions = (
    Name               => { required => 1 },
    Description        => { required => 1 },
    Requires           => { required => 0 },
    Libs               => { required => 0 },
    Conflicts          => { required => 0 },
    Cflags             => { required => 0 },
    URL                => { required => 0 },
);




main( @ARGV ) unless caller;

sub main {

    local @ARGV = @_;

    # save original options for output;
    my @sARGV = @ARGV;
    my $opt   = parse_opts();

    require App::mkpkgconfig::PkgConfig;

    my $conf = App::mkpkgconfig::PkgConfig->new;

    # add standard variables
    $conf->add_variable( prefix  => $opt->prefix )  if defined $opt->prefix;
    $conf->add_variable( package => $opt->package ) if defined $opt->package;
    $conf->add_variable( version => $opt->modversion );

    # add auto generated variables
    $conf->add_variables( \%VarsAuto )
      if defined $opt->auto;

    # override from user
    $conf->add_variables( $opt->var );

    # add standard keywords
    $conf->add_keyword( Name        => $opt->name );
    $conf->add_keyword( Description => $opt->description );
    $conf->add_keyword( Version     => '${version}' );
    for my $kwd ( qw(  Requires Libs Conflicts Cflags ) ) {
        my $mth = lc $kwd;
        $conf->add_keyword( $kwd => $opt->$mth )
          if defined $opt->$mth;
    }

    # override from user
    $conf->add_keywords( $opt->kwd );

    #<<< no tidy
    my @vars_needed =
      # output all variables, used or not
        $opt->usevars == ALL_VARS       ? $conf->variables
      # output only requested  + keyword dependencies
      : $opt->usevars == REQUESTED_VARS ? ( keys %{ $opt->var } , @{ $opt->auto // [] } )
      # only variables actually used by keywords
      : $opt->usevars == NEEDED_VARS    ? ()
      :                                   die( "unknown filter for variables: ", $opt->usevars, "\n" );
    #>>>

    $conf->write(
        $opt->output,
        write    => ( $opt->usevars == ALL_VARS ? 'all' : 'req' ),
        vars     => \@vars_needed,
        comments => [
            "This file was created by $0 ($VERSION) via",
            join( ' ', $0, @sARGV ) ] );
}


sub parse_opts {

    my %Map_usevars = (
        'all'       => ALL_VARS,
        'requested' => REQUESTED_VARS,
        'req'       => REQUESTED_VARS,
        'needed'    => NEEDED_VARS
    );

    my ( $opt, $usage ) = Getopt::Long::Descriptive::describe_options(
        "%o ",
        [ 'output|o=s', "output [stdout]" ],
        [
            'usevars|u:s',
            "which variables to output",
            {
                default   => { reverse %Map_usevars }->{ +NEEDED_VARS },
                callbacks => {
                    'valid output variables' => sub {
                        return 1 if defined $Map_usevars{ $_[0] };
                        die(
                            "$_[0] isn't one of 'all', 'req', 'requested', or 'used'\n"
                        );
                    }
                } }
        ],
        [ 'auto:s@', "generate a default set of variables" ],
        [
            'list-auto',
            "output a list of variables generated by the --auto option",
            { shortcircuit => 1 }
        ],

        [],
        ['Variables:'],
        [ 'var|variable=s%', 'define variables', { default => {} } ],
        [ 'prefix=s',        "'prefix' variable", ],
        [ 'package=s',       "'package' variable", ],
        [
            'modversion|modversion=s',
            '"version" variable and Version keyword)',
            { required => 1 }
        ],

        [],
        ['Keywords:'],

        [ 'kwd|keyword=s%', 'define keywords', { default => {} } ],

        (
            map { [
                    qq(\u$_|\l$_=s),
                    qq("\u$_" keyword),
                    { (
                            $KeywordOptions{$_}{required}
                              // 0 ? ( required => 1 ) : ()
                        ),
                    },
                ]
              }
              keys %KeywordOptions
        ),

        [],
        ['Miscellaneous::'],

        [ 'version|v', 'output version and exit', { shortcircuit => 1 } ],

        [
            'help|h',
            'output short help message and exit',
            { shortcircuit => 1 }
        ],

        [
            'manual|m',
            'output full manual page and exit',
            { shortcircuit => 1 }
        ],
    );

    print( $usage->text ), exit if $opt->help;
    print( $VERSION, "\n" ), exit if $opt->version;
    if ( $opt->manual ) {
        require Pod::Usage;
        Pod::Usage::pod2usage(
            { -exitval => 0, -verbose => 2, -output => \*STDOUT } );
    }

    if ( $opt->list_auto ) {
        require List::Util;
        my $length = List::Util::max( map { length( $_ ) } keys %VarsAuto );
        printf( "%-*s = %s\n", $length, $_, $VarsAuto{$_} )
          for sort keys %VarsAuto;
        exit;
    }

    if ( defined $opt->auto ) {
        my @auto = map { split /,/ } @{ $opt->auto };
        $opt->{auto} = \@auto;
    }

    $opt->{usevars} = $Map_usevars{ $opt->usevars };

    return $opt;
}



1;

#
# This file is part of App-mkpkgconfig
#
# This software is Copyright (c) 2020 by Smithsonian Astrophysical Observatory.
#
# This is free software, licensed under:
#
#   The GNU General Public License, Version 3, June 2007
#

__END__