Perl::Dist::WiX::Asset::Library - "C Library" asset for a Win32 Perl

  my $library = Perl::Dist::Asset::Library->new(
      name       => 'zlib',
      url        => 'http://strawberryperl.com/packages/zlib-1.2.3.win32.zip',
      unpack_to  => 'zlib',
      build_a    => {
          'dll'    => 'zlib-1.2.3.win32/bin/zlib1.dll',
          'def'    => 'zlib-1.2.3.win32/bin/zlib1.def',
          'a'      => 'zlib-1.2.3.win32/lib/zlib1.a',
      },
      install_to => {
          'zlib-1.2.3.win32/bin'     => 'c/bin',
          'zlib-1.2.3.win32/lib'     => 'c/lib',
          'zlib-1.2.3.win32/include' => 'c/include',
      },
  );

package Perl::Dist::WiX::Asset::Library;

use 5.010;
use Moose;
use MooseX::Types::Moose qw( Str Maybe HashRef );

our $VERSION = '1.500002';

with 'Perl::Dist::WiX::Role::Asset';

has name => (
	is       => 'ro',
	isa      => Str,
	reader   => '_get_name',
	required => 1,
);

has unpack_to => (
	is      => 'ro',
	isa     => Str,
	reader  => '_get_unpack_to',
	lazy    => 1,
	default => sub { $_[0]->_get_name() },
);

has license => (
	is      => 'ro',
	isa     => Maybe [HashRef],
	reader  => '_get_license',
	default => undef,
);

has install_to => (
	is       => 'ro',
	isa      => HashRef,
	reader   => '_get_install_to',
	required => 1,
);

has build_a => (
	is      => 'ro',
	isa     => HashRef,
	reader  => '_get_build_a',
	default => sub { return {} },
);

sub install {
	my $self = shift;

	# Announce the fact that we're starting to install a library.
	my $name = $self->_get_name();
	$self->_trace_line( 1, "Preparing $name\n" );

	# Download the file
	my $tgz =
	  $self->_mirror( $self->_get_url(), $self->_get_download_dir(), );

	# Unpack to the build directory
	my @files;
	my $unpack_to =
	  catdir( $self->_get_build_dir(), $self->_get_unpack_to() );
	if ( -d $unpack_to ) {
		$self->_trace_line( 2, "Removing previous $unpack_to\n" );
		$self->remove_path($unpack_to);
	}
	@files = $self->_extract( $tgz, $unpack_to );

	# Build the .a file if needed
	my $build_a = $self->_get_build_a();
	if ( defined $build_a ) {

		# If we have a source, use it.
		my @source = ();
		if ( $build_a->{source} ) {
			@source = ( dll => catfile( $unpack_to, $build_a->{source} ) );
		}

		# Hand off for the .a generation
		push @files,
		  $self->_dll_to_a(
			dll => catfile( $unpack_to, $build_a->{dll} ),
			def => catfile( $unpack_to, $build_a->{def} ),
			a   => catfile( $unpack_to, $build_a->{a} ),
			@source,
		  );
	} ## end if ( defined $build_a )

	# Copy in the files
	my $install_to = $self->_get_install_to();
	if ($install_to) {
		foreach my $k ( sort keys %{$install_to} ) {
			my $from = catdir( $unpack_to, $k );
			my $to = catdir( $self->_get_image_dir(), $install_to->{$k} );
			$self->_copy( $from, $to );
			@files = $self->_copy_filesref( \@files, $from, $to );
		}
	}

	# Copy in licenses
	my $licenses = $self->_get_license();
	if ( defined $licenses ) {
		my $license_dir = $self->_dir('licenses');
		push @files,
		  $self->_extract_filemap( $tgz, $licenses, $license_dir, 1 );
	}

	# Create the list of files.
	my @sorted_files = sort { $a cmp $b } @files;
	my $filelist =
	  File::List::Object->new->load_array(@sorted_files)
	  ->filter( $self->_filters() )->filter( [$unpack_to] );

	return $filelist;
} ## end sub install



# This routine copies a list of files, while changing the directory
# the files are in.
# It does not copy the files themselves.
sub _copy_filesref {
	my ( $self, $files_ref, $from, $to ) = @_;

	# Move each file referred to in @$file_ref from $from to $to.
	my @files;
	foreach my $file ( @{$files_ref} ) {
		if ( $file =~ m{\A\Q$from\E}msx ) {
			$file =~ s{\A\Q$from\E}{$to}msx;
		}
		push @files, $file;
	}

	return @files;
} ## end sub _copy_filesref



# Generate a .a file from a .dll.
sub _dll_to_a {
	my $self   = shift;
	my %params = @_;

	# Check for binaries required.
	if ( not $self->_bin_dlltool() ) {
		PDWiX->throw('dlltool has not been installed');
	}
	if ( not $self->_bin_pexports() ) {
		PDWiX->throw('pexports has not been installed');
	}

	my @files;

	# Source file
	my $source = $params{source};
	if ( $source and not( $source =~ /[.]dll\z/msx ) ) {
		PDWiX::Parameter->throw(
			parameter => 'source',
			where     => '::Asset::Library->_dll_to_a'
		);
	}

	# Target .dll file
	my $dll = $params{dll};
	if ( not $dll or $dll !~ /[.]dll/msx ) {
		PDWiX::Parameter->throw(
			parameter => 'dll',
			where     => '::Asset::Library->_dll_to_a'
		);
	}

	# Target .def file
	my $def = $params{def};
	if ( not $def or $def !~ /[.]def\z/msx ) {
		PDWiX::Parameter->throw(
			parameter => 'def',
			where     => '::Asset::Library->_dll_to_a'
		);
	}

	# Target .a file
	my $_a = $params{a};
	if ( not $_a or $_a !~ /[.]a\z/msx ) {
		PDWiX::Parameter->throw(
			parameter => 'a',
			where     => '::Asset::Library->_dll_to_a'
		);
	}

	# Step 1 - Copy the source .dll to the target if needed
	if ( not( ( $source and -f $source ) or -f $dll ) ) {
		PDWiX::Parameter->throw(
			parameter => 'source or dll: Need one of '
			  . 'these two parameters, and the file needs to exist',
			where => '::Asset::Library->_dll_to_a'
		);
	}

	if ($source) {
		$self->_move( $source => $dll );
		push @files, $dll;
	}

	# Step 2 - Generate the .def from the .dll
  SCOPE: {
		my $bin = $self->_bin_pexports();
		my $ok  = !system "$bin $dll > $def";
		if ( not $ok or not -f $def ) {
			PDWiX->throw('pexports failed to generate .def file');
		}

		push @files, $def;
	}

	# Step 3 - Generate the .a from the .def
  SCOPE: {
		my $bin = $self->_bin_dlltool();
		my $ok  = !system "$bin -dllname $dll --def $def --output-lib $_a";
		if ( not $ok or not -f $_a ) {
			PDWiX->throw('dlltool failed to generate .a file');
		}

		push @files, $_a;
	}

	return @files;
} ## end sub _dll_to_a

no Moose;
__PACKAGE__->meta->make_immutable;

1;

__END__