[p5sagit/p5-mst-13.2.git] / lib / Module / Build / Compat.pm

package Module::Build::Compat;

use strict;
use vars qw($VERSION);
$VERSION = '0.31_04';

use File::Spec;
use IO::File;
use Config;
use Module::Build;
use Module::Build::ModuleInfo;
use Data::Dumper;

my %convert_installdirs = (
    PERL        => 'core',
    SITE        => 'site',
    VENDOR      => 'vendor',
);

my %makefile_to_build = 
  (
   TEST_VERBOSE => 'verbose',
   VERBINST     => 'verbose',
   INC          => sub { map {(extra_compiler_flags => $_)} Module::Build->split_like_shell(shift) },
   POLLUTE      => sub { (extra_compiler_flags => '-DPERL_POLLUTE') },
   INSTALLDIRS  => sub { (installdirs => $convert_installdirs{uc shift()}) },
   LIB          => sub {
       my $lib = shift;
       my %config = (
           installprivlib  => $lib,
           installsitelib  => $lib,
           installarchlib  => "$lib/$Config{archname}",
           installsitearch => "$lib/$Config{archname}"
       );
       return map { (config => "$_=$config{$_}") } keys %config;
   },

   # Convert INSTALLVENDORLIB and friends.
   (
       map {
           my $name = "INSTALL".$_."LIB";
           $name => sub {
                 my @ret = (config => { lc $name => shift });
                 print STDERR "# Converted to @ret\n";

                 return @ret;
           }
       } keys %convert_installdirs
   ),

   # Some names they have in common
   map {$_, lc($_)} qw(DESTDIR PREFIX INSTALL_BASE UNINST),
  );

my %macro_to_build = %makefile_to_build;
# "LIB=foo make" is not the same as "perl Makefile.PL LIB=foo"
delete $macro_to_build{LIB};


sub create_makefile_pl {
  my ($package, $type, $build, %args) = @_;
  
  die "Don't know how to build Makefile.PL of type '$type'"
    unless $type =~ /^(small|passthrough|traditional)$/;

  my $fh;
  if ($args{fh}) {
    $fh = $args{fh};
  } else {
    $args{file} ||= 'Makefile.PL';
    local $build->{properties}{quiet} = 1;
    $build->delete_filetree($args{file});
    $fh = IO::File->new("> $args{file}") or die "Can't write $args{file}: $!";
  }

  print {$fh} "# Note: this file was auto-generated by ", __PACKAGE__, " version $VERSION\n";

  # Minimum perl version should be specified as "require 5.XXXXXX" in 
  # Makefile.PL
  my $requires = $build->requires;
  if ( my $minimum_perl = $requires->{perl} ) {
    print {$fh} "require $minimum_perl;\n";
  }

  # If a *bundled* custom subclass is being used, make sure we add its
  # directory to @INC.  Also, lib.pm always needs paths in Unix format.
  my $subclass_load = '';
  if (ref($build) ne "Module::Build") {
    my $subclass_dir = $package->subclass_dir($build);

    if (File::Spec->file_name_is_absolute($subclass_dir)) {
      my $base_dir = $build->base_dir;

      if ($build->dir_contains($base_dir, $subclass_dir)) {
	$subclass_dir = File::Spec->abs2rel($subclass_dir, $base_dir);
	$subclass_dir = $package->unixify_dir($subclass_dir);
        $subclass_load = "use lib '$subclass_dir';";
      }
      # Otherwise, leave it the empty string

    } else {
      $subclass_dir = $package->unixify_dir($subclass_dir);
      $subclass_load = "use lib '$subclass_dir';";
    }
  }

  if ($type eq 'small') {
    printf {$fh} <<'EOF', $subclass_load, ref($build), ref($build);
    use Module::Build::Compat 0.02;
    %s
    Module::Build::Compat->run_build_pl(args => \@ARGV);
    require %s;
    Module::Build::Compat->write_makefile(build_class => '%s');
EOF

  } elsif ($type eq 'passthrough') {
    printf {$fh} <<'EOF', $subclass_load, ref($build), ref($build);
    
    unless (eval "use Module::Build::Compat 0.02; 1" ) {
      print "This module requires Module::Build to install itself.\n";
      
      require ExtUtils::MakeMaker;
      my $yn = ExtUtils::MakeMaker::prompt
	('  Install Module::Build now from CPAN?', 'y');
      
      unless ($yn =~ /^y/i) {
	die " *** Cannot install without Module::Build.  Exiting ...\n";
      }
      
      require Cwd;
      require File::Spec;
      require CPAN;
      
      # Save this 'cause CPAN will chdir all over the place.
      my $cwd = Cwd::cwd();
      
      CPAN::Shell->install('Module::Build::Compat');
      CPAN::Shell->expand("Module", "Module::Build::Compat")->uptodate
	or die "Couldn't install Module::Build, giving up.\n";
      
      chdir $cwd or die "Cannot chdir() back to $cwd: $!";
    }
    eval "use Module::Build::Compat 0.02; 1" or die $@;
    %s
    Module::Build::Compat->run_build_pl(args => \@ARGV);
    exit(0) unless(-e 'Build'); # cpantesters convention
    require %s;
    Module::Build::Compat->write_makefile(build_class => '%s');
EOF
    
  } elsif ($type eq 'traditional') {

    my (%MM_Args, %prereq);
    if (eval "use Tie::IxHash; 1") {
      tie %MM_Args, 'Tie::IxHash'; # Don't care if it fails here
      tie %prereq,  'Tie::IxHash'; # Don't care if it fails here
    }
    
    my %name = ($build->module_name
		? (NAME => $build->module_name)
		: (DISTNAME => $build->dist_name));
    
    my %version = ($build->dist_version_from
		   ? (VERSION_FROM => $build->dist_version_from)
		   : (VERSION      => $build->dist_version)
		  );
    %MM_Args = (%name, %version);
    
    %prereq = ( %{$build->requires}, %{$build->build_requires} );
    %prereq = map {$_, $prereq{$_}} sort keys %prereq;
    
    delete $prereq{perl};
    $MM_Args{PREREQ_PM} = \%prereq;
    
    $MM_Args{INSTALLDIRS} = $build->installdirs eq 'core' ? 'perl' : $build->installdirs;
    
    $MM_Args{EXE_FILES} = [ sort keys %{$build->script_files} ] if $build->script_files;
    
    $MM_Args{PL_FILES} = $build->PL_files if $build->PL_files;
    
    local $Data::Dumper::Terse = 1;
    my $args = Data::Dumper::Dumper(\%MM_Args);
    $args =~ s/\{(.*)\}/($1)/s;
    
    print $fh <<"EOF";
use ExtUtils::MakeMaker;
WriteMakefile
$args;
EOF
  }
}


sub subclass_dir {
  my ($self, $build) = @_;
  
  return (Module::Build::ModuleInfo->find_module_dir_by_name(ref $build)
	  || File::Spec->catdir($build->config_dir, 'lib'));
}

sub unixify_dir {
  my ($self, $path) = @_;
  return join '/', File::Spec->splitdir($path);
}

sub makefile_to_build_args {
  my $class = shift;
  my @out;
  foreach my $arg (@_) {
    next if $arg eq '';
    
    my ($key, $val) = ($arg =~ /^(\w+)=(.+)/ ? ($1, $2) :
		       die "Malformed argument '$arg'");

    # Do tilde-expansion if it looks like a tilde prefixed path
    ( $val ) = Module::Build->_detildefy( $val ) if $val =~ /^~/;

    if (exists $makefile_to_build{$key}) {
      my $trans = $makefile_to_build{$key};
      push @out, $class->_argvify( ref($trans) ? $trans->($val) : ($trans => $val) );
    } elsif (exists $Config{lc($key)}) {
      push @out, $class->_argvify( config => lc($key) . "=$val" );
    } else {
      # Assume M::B can handle it in lowercase form
      push @out, $class->_argvify("\L$key" => $val);
    }
  }
  return @out;
}

sub _argvify {
  my ($self, @pairs) = @_;
  my @out;
  while (@pairs) {
    my ($k, $v) = splice @pairs, 0, 2;
    push @out, ("--$k", $v);
  }
  return @out;
}

sub makefile_to_build_macros {
  my @out;
  while (my ($macro, $trans) = each %macro_to_build) {
    # On some platforms (e.g. Cygwin with 'make'), the mere presence
    # of "EXPORT: FOO" in the Makefile will make $ENV{FOO} defined.
    # Therefore we check length() too.
    next unless exists $ENV{$macro} && length $ENV{$macro};
    my $val = $ENV{$macro};
    push @out, ref($trans) ? $trans->($val) : ($trans => $val);
  }
  return @out;
}

sub run_build_pl {
  my ($pack, %in) = @_;
  $in{script} ||= 'Build.PL';
  my @args = $in{args} ? $pack->makefile_to_build_args(@{$in{args}}) : ();
  print "# running $in{script} @args\n";
  Module::Build->run_perl_script($in{script}, [], \@args) or die "Couldn't run $in{script}: $!";
}

sub fake_makefile {
  my ($self, %args) = @_;
  unless (exists $args{build_class}) {
    warn "Unknown 'build_class', defaulting to 'Module::Build'\n";
    $args{build_class} = 'Module::Build';
  }
  my $class = $args{build_class};

  my $perl = $class->find_perl_interpreter;

  # VMS MMS/MMK need to use MCR to run the Perl image.
  $perl = 'MCR ' . $perl if $self->_is_vms_mms;

  my $noop = ($class->is_windowsish ? 'rem>nul'  :
	      $self->_is_vms_mms    ? 'Continue' :
	      'true');

  my $filetype = $class->is_vmsish ? '.COM' : '';

  my $Build = 'Build' . $filetype . ' --makefile_env_macros 1';
  my $unlink = $class->oneliner('1 while unlink $ARGV[0]', [], [$args{makefile}]);
  $unlink =~ s/\$/\$\$/g unless $class->is_vmsish;

  my $maketext = <<"EOF";
all : force_do_it
	$perl $Build
realclean : force_do_it
	$perl $Build realclean
	$unlink

force_do_it :
	@ $noop
EOF

  foreach my $action ($class->known_actions) {
    next if $action =~ /^(all|realclean|force_do_it)$/;  # Don't double-define
    $maketext .= <<"EOF";
$action : force_do_it
	$perl $Build $action
EOF
  }
  
  if ($self->_is_vms_mms) {
    # Roll our own .EXPORT as MMS/MMK don't honor that directive.
    $maketext .= "\n.FIRST\n\t\@ $noop\n"; 
    for my $macro (keys %macro_to_build) {
      $maketext .= ".IFDEF $macro\n\tDEFINE $macro \"\$($macro)\"\n.ENDIF\n";
    }
    $maketext .= "\n"; 
  }
  else {
    $maketext .= "\n.EXPORT : " . join(' ', keys %macro_to_build) . "\n\n";
  }
  
  return $maketext;
}

sub fake_prereqs {
  my $file = File::Spec->catfile('_build', 'prereqs');
  my $fh = IO::File->new("< $file") or die "Can't read $file: $!";
  my $prereqs = eval do {local $/; <$fh>};
  close $fh;
  
  my @prereq;
  foreach my $section (qw/build_requires requires/) {
    foreach (keys %{$prereqs->{$section}}) {
      next if $_ eq 'perl';
      push @prereq, "$_=>q[$prereqs->{$section}{$_}]";
    }
  }

  return unless @prereq;
  return "#     PREREQ_PM => { " . join(", ", @prereq) . " }\n\n";
}


sub write_makefile {
  my ($pack, %in) = @_;

  unless (exists $in{build_class}) {
    warn "Unknown 'build_class', defaulting to 'Module::Build'\n";
    $in{build_class} = 'Module::Build';
  }
  my $class = $in{build_class};
  $in{makefile} ||= $pack->_is_vms_mms ? 'Descrip.MMS' : 'Makefile';

  open  MAKE, "> $in{makefile}" or die "Cannot write $in{makefile}: $!";
  print MAKE $pack->fake_prereqs;
  print MAKE $pack->fake_makefile(%in);
  close MAKE;
}

sub _is_vms_mms {
  return Module::Build->is_vmsish && ($Config{make} =~ m/MM[SK]/i);
}

1;
__END__


=head1 NAME

Module::Build::Compat - Compatibility with ExtUtils::MakeMaker


=head1 SYNOPSIS

  # In a Build.PL :
  use Module::Build;
  my $build = Module::Build->new
    ( module_name => 'Foo::Bar',
      license     => 'perl',
      create_makefile_pl => 'passthrough' );
  ...


=head1 DESCRIPTION

Because ExtUtils::MakeMaker has been the standard way to distribute
modules for a long time, many tools (CPAN.pm, or your system
administrator) may expect to find a working Makefile.PL in every
distribution they download from CPAN.  If you want to throw them a
bone, you can use Module::Build::Compat to automatically generate a
Makefile.PL for you, in one of several different styles.

Module::Build::Compat also provides some code that helps out the
Makefile.PL at runtime.


=head1 METHODS

=over 4

=item create_makefile_pl($style, $build)

Creates a Makefile.PL in the current directory in one of several
styles, based on the supplied Module::Build object C<$build>.  This is
typically controlled by passing the desired style as the
C<create_makefile_pl> parameter to Module::Build's C<new()> method;
the Makefile.PL will then be automatically created during the
C<distdir> action.

The currently supported styles are:

=over 4

=item small

A small Makefile.PL will be created that passes all functionality
through to the Build.PL script in the same directory.  The user must
already have Module::Build installed in order to use this, or else
they'll get a module-not-found error.

=item passthrough

This is just like the C<small> option above, but if Module::Build is
not already installed on the user's system, the script will offer to
use C<CPAN.pm> to download it and install it before continuing with
the build.

=item traditional

A Makefile.PL will be created in the "traditional" style, i.e. it will
use C<ExtUtils::MakeMaker> and won't rely on C<Module::Build> at all.
In order to create the Makefile.PL, we'll include the C<requires> and
C<build_requires> dependencies as the C<PREREQ_PM> parameter.

You don't want to use this style if during the C<perl Build.PL> stage
you ask the user questions, or do some auto-sensing about the user's
environment, or if you subclass Module::Build to do some
customization, because the vanilla Makefile.PL won't do any of that.

=back

=item run_build_pl(args => \@ARGV)

This method runs the Build.PL script, passing it any arguments the
user may have supplied to the C<perl Makefile.PL> command.  Because
ExtUtils::MakeMaker and Module::Build accept different arguments, this
method also performs some translation between the two.

C<run_build_pl()> accepts the following named parameters:

=over 4

=item args

The C<args> parameter specifies the parameters that would usually
appear on the command line of the C<perl Makefile.PL> command -
typically you'll just pass a reference to C<@ARGV>.

=item script

This is the filename of the script to run - it defaults to C<Build.PL>.

=back

=item write_makefile()

This method writes a 'dummy' Makefile that will pass all commands
through to the corresponding Module::Build actions.

C<write_makefile()> accepts the following named parameters:

=over 4

=item makefile

The name of the file to write - defaults to the string C<Makefile>.

=back

=back


=head1 SCENARIOS

So, some common scenarios are:

=over 4

=item 1.

Just include a Build.PL script (without a Makefile.PL
script), and give installation directions in a README or INSTALL
document explaining how to install the module.  In particular, explain
that the user must install Module::Build before installing your
module.

Note that if you do this, you may make things easier for yourself, but
harder for people with older versions of CPAN or CPANPLUS on their
system, because those tools generally only understand the
F<Makefile.PL>/C<ExtUtils::MakeMaker> way of doing things.

=item 2.

Include a Build.PL script and a "traditional" Makefile.PL,
created either manually or with C<create_makefile_pl()>.  Users won't
ever have to install Module::Build if they use the Makefile.PL, but
they won't get to take advantage of Module::Build's extra features
either.

If you go this route, make sure you explicitly set C<PL_FILES> in the
call to C<WriteMakefile()> (probably to an empty hash reference), or
else MakeMaker will mistakenly run the Build.PL and you'll get an
error message about "Too early to run Build script" or something.  For
good measure, of course, test both the F<Makefile.PL> and the
F<Build.PL> before shipping.

=item 3.

Include a Build.PL script and a "pass-through" Makefile.PL
built using Module::Build::Compat.  This will mean that people can
continue to use the "old" installation commands, and they may never
notice that it's actually doing something else behind the scenes.  It
will also mean that your installation process is compatible with older
versions of tools like CPAN and CPANPLUS.

=back


=head1 AUTHOR

Ken Williams <kwilliams@cpan.org>


=head1 COPYRIGHT

Copyright (c) 2001-2006 Ken Williams.  All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.


=head1 SEE ALSO

L<Module::Build>(3), L<ExtUtils::MakeMaker>(3)


=cut
Commit	Line	Data
bb4e9162	1	package Module::Build::Compat;
	2
	3	use strict;
	4	use vars qw($VERSION);
66e531b6	5	$VERSION = '0.31_04';
bb4e9162	6
	7	use File::Spec;
	8	use IO::File;
	9	use Config;
	10	use Module::Build;
	11	use Module::Build::ModuleInfo;
	12	use Data::Dumper;
	13
738349a8	14	my %convert_installdirs = (
	15	PERL => 'core',
	16	SITE => 'site',
	17	VENDOR => 'vendor',
	18	);
	19
bb4e9162	20	my %makefile_to_build =
	21	(
	22	TEST_VERBOSE => 'verbose',
	23	VERBINST => 'verbose',
738349a8	24	INC => sub { map {(extra_compiler_flags => $_)} Module::Build->split_like_shell(shift) },
	25	POLLUTE => sub { (extra_compiler_flags => '-DPERL_POLLUTE') },
	26	INSTALLDIRS => sub { (installdirs => $convert_installdirs{uc shift()}) },
	27	LIB => sub {
	28	my $lib = shift;
	29	my %config = (
	30	installprivlib => $lib,
	31	installsitelib => $lib,
	32	installarchlib => "$lib/$Config{archname}",
	33	installsitearch => "$lib/$Config{archname}"
	34	);
	35	return map { (config => "$_=$config{$_}") } keys %config;
	36	},
	37
	38	# Convert INSTALLVENDORLIB and friends.
	39	(
	40	map {
	41	my $name = "INSTALL".$_."LIB";
	42	$name => sub {
	43	my @ret = (config => { lc $name => shift });
	44	print STDERR "# Converted to @ret\n";
	45
	46	return @ret;
	47	}
	48	} keys %convert_installdirs
	49	),
bb4e9162	50
	51	# Some names they have in common
	52	map {$_, lc($_)} qw(DESTDIR PREFIX INSTALL_BASE UNINST),
	53	);
	54
738349a8	55	my %macro_to_build = %makefile_to_build;
	56	# "LIB=foo make" is not the same as "perl Makefile.PL LIB=foo"
	57	delete $macro_to_build{LIB};
bb4e9162	58
	59
	60	sub create_makefile_pl {
	61	my ($package, $type, $build, %args) = @_;
	62
	63	die "Don't know how to build Makefile.PL of type '$type'"
	64	unless $type =~ /^(small\|passthrough\|traditional)$/;
	65
	66	my $fh;
	67	if ($args{fh}) {
	68	$fh = $args{fh};
	69	} else {
	70	$args{file} \|\|= 'Makefile.PL';
738349a8	71	local $build->{properties}{quiet} = 1;
738349a8	72	$build->delete_filetree($args{file});
bb4e9162	73	$fh = IO::File->new("> $args{file}") or die "Can't write $args{file}: $!";
	74	}
	75
	76	print {$fh} "# Note: this file was auto-generated by ", __PACKAGE__, " version $VERSION\n";
	77
7a827510	78	# Minimum perl version should be specified as "require 5.XXXXXX" in
	79	# Makefile.PL
	80	my $requires = $build->requires;
	81	if ( my $minimum_perl = $requires->{perl} ) {
	82	print {$fh} "require $minimum_perl;\n";
	83	}
	84
dc8021d3	85	# If a bundled custom subclass is being used, make sure we add its
738349a8	86	# directory to @INC. Also, lib.pm always needs paths in Unix format.
bb4e9162	87	my $subclass_load = '';
	88	if (ref($build) ne "Module::Build") {
	89	my $subclass_dir = $package->subclass_dir($build);
dc8021d3	90
bb4e9162	91	if (File::Spec->file_name_is_absolute($subclass_dir)) {
	92	my $base_dir = $build->base_dir;
	93
	94	if ($build->dir_contains($base_dir, $subclass_dir)) {
	95	$subclass_dir = File::Spec->abs2rel($subclass_dir, $base_dir);
738349a8	96	$subclass_dir = $package->unixify_dir($subclass_dir);
dc8021d3	97	$subclass_load = "use lib '$subclass_dir';";
bb4e9162	98	}
738349a8	99	# Otherwise, leave it the empty string
dc8021d3	100
dc8021d3	101	} else {
738349a8	102	$subclass_dir = $package->unixify_dir($subclass_dir);
dc8021d3	103	$subclass_load = "use lib '$subclass_dir';";
bb4e9162	104	}
bb4e9162	105	}
dc8021d3	106
bb4e9162	107	if ($type eq 'small') {
	108	printf {$fh} <<'EOF', $subclass_load, ref($build), ref($build);
	109	use Module::Build::Compat 0.02;
	110	%s
	111	Module::Build::Compat->run_build_pl(args => \@ARGV);
	112	require %s;
	113	Module::Build::Compat->write_makefile(build_class => '%s');
	114	EOF
	115
	116	} elsif ($type eq 'passthrough') {
	117	printf {$fh} <<'EOF', $subclass_load, ref($build), ref($build);
	118
	119	unless (eval "use Module::Build::Compat 0.02; 1" ) {
	120	print "This module requires Module::Build to install itself.\n";
	121
	122	require ExtUtils::MakeMaker;
	123	my $yn = ExtUtils::MakeMaker::prompt
	124	(' Install Module::Build now from CPAN?', 'y');
	125
	126	unless ($yn =~ /^y/i) {
	127	die " *** Cannot install without Module::Build. Exiting ...\n";
	128	}
	129
	130	require Cwd;
	131	require File::Spec;
	132	require CPAN;
	133
	134	# Save this 'cause CPAN will chdir all over the place.
	135	my $cwd = Cwd::cwd();
	136
bb4e9162	137	CPAN::Shell->install('Module::Build::Compat');
47f13fd5	138	CPAN::Shell->expand("Module", "Module::Build::Compat")->uptodate
47f13fd5	139	or die "Couldn't install Module::Build, giving up.\n";
bb4e9162	140
	141	chdir $cwd or die "Cannot chdir() back to $cwd: $!";
	142	}
	143	eval "use Module::Build::Compat 0.02; 1" or die $@;
	144	%s
	145	Module::Build::Compat->run_build_pl(args => \@ARGV);
66e531b6	146	exit(0) unless(-e 'Build'); # cpantesters convention
bb4e9162	147	require %s;
	148	Module::Build::Compat->write_makefile(build_class => '%s');
	149	EOF
	150
	151	} elsif ($type eq 'traditional') {
	152
	153	my (%MM_Args, %prereq);
	154	if (eval "use Tie::IxHash; 1") {
	155	tie %MM_Args, 'Tie::IxHash'; # Don't care if it fails here
	156	tie %prereq, 'Tie::IxHash'; # Don't care if it fails here
	157	}
	158
	159	my %name = ($build->module_name
	160	? (NAME => $build->module_name)
	161	: (DISTNAME => $build->dist_name));
	162
	163	my %version = ($build->dist_version_from
	164	? (VERSION_FROM => $build->dist_version_from)
	165	: (VERSION => $build->dist_version)
	166	);
	167	%MM_Args = (%name, %version);
	168
	169	%prereq = ( %{$build->requires}, %{$build->build_requires} );
	170	%prereq = map {$_, $prereq{$_}} sort keys %prereq;
	171
	172	delete $prereq{perl};
	173	$MM_Args{PREREQ_PM} = \%prereq;
	174
	175	$MM_Args{INSTALLDIRS} = $build->installdirs eq 'core' ? 'perl' : $build->installdirs;
	176
	177	$MM_Args{EXE_FILES} = [ sort keys %{$build->script_files} ] if $build->script_files;
	178
15cb7b9d	179	$MM_Args{PL_FILES} = $build->PL_files if $build->PL_files;
bb4e9162	180
	181	local $Data::Dumper::Terse = 1;
	182	my $args = Data::Dumper::Dumper(\%MM_Args);
	183	$args =~ s/\{(.*)\}/($1)/s;
	184
	185	print $fh <<"EOF";
	186	use ExtUtils::MakeMaker;
	187	WriteMakefile
	188	$args;
	189	EOF
	190	}
	191	}
	192
	193
	194	sub subclass_dir {
	195	my ($self, $build) = @_;
	196
	197	return (Module::Build::ModuleInfo->find_module_dir_by_name(ref $build)
	198	\|\| File::Spec->catdir($build->config_dir, 'lib'));
	199	}
	200
738349a8	201	sub unixify_dir {
	202	my ($self, $path) = @_;
	203	return join '/', File::Spec->splitdir($path);
	204	}
	205
bb4e9162	206	sub makefile_to_build_args {
738349a8	207	my $class = shift;
bb4e9162	208	my @out;
	209	foreach my $arg (@_) {
	210	next if $arg eq '';
	211
	212	my ($key, $val) = ($arg =~ /^(\w+)=(.+)/ ? ($1, $2) :
	213	die "Malformed argument '$arg'");
	214
	215	# Do tilde-expansion if it looks like a tilde prefixed path
738349a8	216	( $val ) = Module::Build->_detildefy( $val ) if $val =~ /^~/;
bb4e9162	217
	218	if (exists $makefile_to_build{$key}) {
	219	my $trans = $makefile_to_build{$key};
738349a8	220	push @out, $class->_argvify( ref($trans) ? $trans->($val) : ($trans => $val) );
bb4e9162	221	} elsif (exists $Config{lc($key)}) {
738349a8	222	push @out, $class->_argvify( config => lc($key) . "=$val" );
bb4e9162	223	} else {
bb4e9162	224	# Assume M::B can handle it in lowercase form
738349a8	225	push @out, $class->_argvify("\L$key" => $val);
bb4e9162	226	}
	227	}
	228	return @out;
	229	}
	230
738349a8	231	sub _argvify {
	232	my ($self, @pairs) = @_;
	233	my @out;
	234	while (@pairs) {
	235	my ($k, $v) = splice @pairs, 0, 2;
	236	push @out, ("--$k", $v);
	237	}
	238	return @out;
	239	}
	240
bb4e9162	241	sub makefile_to_build_macros {
bb4e9162	242	my @out;
738349a8	243	while (my ($macro, $trans) = each %macro_to_build) {
bb4e9162	244	# On some platforms (e.g. Cygwin with 'make'), the mere presence
	245	# of "EXPORT: FOO" in the Makefile will make $ENV{FOO} defined.
	246	# Therefore we check length() too.
	247	next unless exists $ENV{$macro} && length $ENV{$macro};
	248	my $val = $ENV{$macro};
	249	push @out, ref($trans) ? $trans->($val) : ($trans => $val);
	250	}
	251	return @out;
	252	}
	253
	254	sub run_build_pl {
	255	my ($pack, %in) = @_;
	256	$in{script} \|\|= 'Build.PL';
	257	my @args = $in{args} ? $pack->makefile_to_build_args(@{$in{args}}) : ();
	258	print "# running $in{script} @args\n";
	259	Module::Build->run_perl_script($in{script}, [], \@args) or die "Couldn't run $in{script}: $!";
	260	}
	261
	262	sub fake_makefile {
	263	my ($self, %args) = @_;
	264	unless (exists $args{build_class}) {
	265	warn "Unknown 'build_class', defaulting to 'Module::Build'\n";
	266	$args{build_class} = 'Module::Build';
	267	}
c1d8f74e	268	my $class = $args{build_class};
bb4e9162	269
c1d8f74e	270	my $perl = $class->find_perl_interpreter;
738349a8	271
	272	# VMS MMS/MMK need to use MCR to run the Perl image.
	273	$perl = 'MCR ' . $perl if $self->_is_vms_mms;
	274
c1d8f74e	275	my $noop = ($class->is_windowsish ? 'rem>nul' :
738349a8	276	$self->_is_vms_mms ? 'Continue' :
bb4e9162	277	'true');
bb4e9162	278
738349a8	279	my $filetype = $class->is_vmsish ? '.COM' : '';
	280
	281	my $Build = 'Build' . $filetype . ' --makefile_env_macros 1';
	282	my $unlink = $class->oneliner('1 while unlink $ARGV[0]', [], [$args{makefile}]);
86bddcbf	283	$unlink =~ s/\$/\$\$/g unless $class->is_vmsish;
738349a8	284
bb4e9162	285	my $maketext = <<"EOF";
	286	all : force_do_it
	287	$perl $Build
	288	realclean : force_do_it
	289	$perl $Build realclean
738349a8	290	$unlink
bb4e9162	291
	292	force_do_it :
	293	@ $noop
	294	EOF
	295
c1d8f74e	296	foreach my $action ($class->known_actions) {
bb4e9162	297	next if $action =~ /^(all\|realclean\|force_do_it)$/; # Don't double-define
	298	$maketext .= <<"EOF";
	299	$action : force_do_it
	300	$perl $Build $action
	301	EOF
	302	}
	303
738349a8	304	if ($self->_is_vms_mms) {
	305	# Roll our own .EXPORT as MMS/MMK don't honor that directive.
	306	$maketext .= "\n.FIRST\n\t\@ $noop\n";
	307	for my $macro (keys %macro_to_build) {
	308	$maketext .= ".IFDEF $macro\n\tDEFINE $macro \"\$($macro)\"\n.ENDIF\n";
	309	}
	310	$maketext .= "\n";
	311	}
	312	else {
	313	$maketext .= "\n.EXPORT : " . join(' ', keys %macro_to_build) . "\n\n";
	314	}
bb4e9162	315
	316	return $maketext;
	317	}
	318
	319	sub fake_prereqs {
	320	my $file = File::Spec->catfile('_build', 'prereqs');
	321	my $fh = IO::File->new("< $file") or die "Can't read $file: $!";
	322	my $prereqs = eval do {local $/; <$fh>};
	323	close $fh;
	324
	325	my @prereq;
	326	foreach my $section (qw/build_requires requires/) {
	327	foreach (keys %{$prereqs->{$section}}) {
	328	next if $_ eq 'perl';
	329	push @prereq, "$_=>q[$prereqs->{$section}{$_}]";
	330	}
	331	}
	332
	333	return unless @prereq;
	334	return "# PREREQ_PM => { " . join(", ", @prereq) . " }\n\n";
	335	}
	336
	337
	338	sub write_makefile {
	339	my ($pack, %in) = @_;
738349a8	340
	341	unless (exists $in{build_class}) {
	342	warn "Unknown 'build_class', defaulting to 'Module::Build'\n";
	343	$in{build_class} = 'Module::Build';
	344	}
	345	my $class = $in{build_class};
	346	$in{makefile} \|\|= $pack->_is_vms_mms ? 'Descrip.MMS' : 'Makefile';
	347
bb4e9162	348	open MAKE, "> $in{makefile}" or die "Cannot write $in{makefile}: $!";
	349	print MAKE $pack->fake_prereqs;
	350	print MAKE $pack->fake_makefile(%in);
	351	close MAKE;
	352	}
	353
738349a8	354	sub _is_vms_mms {
	355	return Module::Build->is_vmsish && ($Config{make} =~ m/MM[SK]/i);
	356	}
	357
bb4e9162	358	1;
	359	__END__
	360
	361
	362	=head1 NAME
	363
	364	Module::Build::Compat - Compatibility with ExtUtils::MakeMaker
	365
	366
	367	=head1 SYNOPSIS
	368
	369	# In a Build.PL :
	370	use Module::Build;
	371	my $build = Module::Build->new
	372	( module_name => 'Foo::Bar',
	373	license => 'perl',
	374	create_makefile_pl => 'passthrough' );
	375	...
	376
	377
	378	=head1 DESCRIPTION
	379
	380	Because ExtUtils::MakeMaker has been the standard way to distribute
	381	modules for a long time, many tools (CPAN.pm, or your system
	382	administrator) may expect to find a working Makefile.PL in every
	383	distribution they download from CPAN. If you want to throw them a
	384	bone, you can use Module::Build::Compat to automatically generate a
	385	Makefile.PL for you, in one of several different styles.
	386
	387	Module::Build::Compat also provides some code that helps out the
	388	Makefile.PL at runtime.
	389
	390
	391	=head1 METHODS
	392
	393	=over 4
	394
	395	=item create_makefile_pl($style, $build)
	396
	397	Creates a Makefile.PL in the current directory in one of several
	398	styles, based on the supplied Module::Build object C<$build>. This is
	399	typically controlled by passing the desired style as the
	400	C<create_makefile_pl> parameter to Module::Build's C<new()> method;
	401	the Makefile.PL will then be automatically created during the
	402	C<distdir> action.
	403
	404	The currently supported styles are:
	405
	406	=over 4
	407
	408	=item small
	409
	410	A small Makefile.PL will be created that passes all functionality
	411	through to the Build.PL script in the same directory. The user must
	412	already have Module::Build installed in order to use this, or else
	413	they'll get a module-not-found error.
	414
	415	=item passthrough
	416
	417	This is just like the C<small> option above, but if Module::Build is
	418	not already installed on the user's system, the script will offer to
	419	use C<CPAN.pm> to download it and install it before continuing with
	420	the build.
	421
422	=item traditional
423
424	A Makefile.PL will be created in the "traditional" style, i.e. it will
425	use C<ExtUtils::MakeMaker> and won't rely on C<Module::Build> at all.
426	In order to create the Makefile.PL, we'll include the C<requires> and
427	C<build_requires> dependencies as the C<PREREQ_PM> parameter.
428
429	You don't want to use this style if during the C<perl Build.PL> stage
430	you ask the user questions, or do some auto-sensing about the user's
431	environment, or if you subclass Module::Build to do some
432	customization, because the vanilla Makefile.PL won't do any of that.
433
434	=back
435
436	=item run_build_pl(args => \@ARGV)
437
438	This method runs the Build.PL script, passing it any arguments the
439	user may have supplied to the C<perl Makefile.PL> command. Because
440	ExtUtils::MakeMaker and Module::Build accept different arguments, this
441	method also performs some translation between the two.
442
443	C<run_build_pl()> accepts the following named parameters:
444
445	=over 4
446
447	=item args
448
449	The C<args> parameter specifies the parameters that would usually
450	appear on the command line of the C<perl Makefile.PL> command -
451	typically you'll just pass a reference to C<@ARGV>.
452
453	=item script
454
455	This is the filename of the script to run - it defaults to C<Build.PL>.
456
457	=back
458
459	=item write_makefile()
460
461	This method writes a 'dummy' Makefile that will pass all commands
462	through to the corresponding Module::Build actions.
463
464	C<write_makefile()> accepts the following named parameters:
465
466	=over 4
467
468	=item makefile
469
470	The name of the file to write - defaults to the string C<Makefile>.
471
472	=back
473
474	=back
475
476
477	=head1 SCENARIOS
478
479	So, some common scenarios are:
480
481	=over 4
482
483	=item 1.
484
485	Just include a Build.PL script (without a Makefile.PL
486	script), and give installation directions in a README or INSTALL
487	document explaining how to install the module. In particular, explain
488	that the user must install Module::Build before installing your
489	module.
490
491	Note that if you do this, you may make things easier for yourself, but
492	harder for people with older versions of CPAN or CPANPLUS on their
493	system, because those tools generally only understand the
494	F<Makefile.PL>/C<ExtUtils::MakeMaker> way of doing things.
495
496	=item 2.
497
498	Include a Build.PL script and a "traditional" Makefile.PL,
499	created either manually or with C<create_makefile_pl()>. Users won't
500	ever have to install Module::Build if they use the Makefile.PL, but
501	they won't get to take advantage of Module::Build's extra features
502	either.
503
504	If you go this route, make sure you explicitly set C<PL_FILES> in the
505	call to C<WriteMakefile()> (probably to an empty hash reference), or
506	else MakeMaker will mistakenly run the Build.PL and you'll get an
507	error message about "Too early to run Build script" or something. For
508	good measure, of course, test both the F<Makefile.PL> and the
509	F<Build.PL> before shipping.
510
511	=item 3.
512
513	Include a Build.PL script and a "pass-through" Makefile.PL
514	built using Module::Build::Compat. This will mean that people can
515	continue to use the "old" installation commands, and they may never
516	notice that it's actually doing something else behind the scenes. It
517	will also mean that your installation process is compatible with older
518	versions of tools like CPAN and CPANPLUS.
519
520	=back
521
522
523	=head1 AUTHOR
524
77e96e88	525	Ken Williams <kwilliams@cpan.org>
bb4e9162	526
	527
	528	=head1 COPYRIGHT
	529
77e96e88	530	Copyright (c) 2001-2006 Ken Williams. All rights reserved.
bb4e9162	531
	532	This library is free software; you can redistribute it and/or
	533	modify it under the same terms as Perl itself.
	534
	535
	536	=head1 SEE ALSO
	537
dc8021d3	538	L<Module::Build>(3), L<ExtUtils::MakeMaker>(3)
bb4e9162	539
	540
	541	=cut