]> git.donarmstrong.com Git - debhelper.git/blobdiff - dh
simplify
[debhelper.git] / dh
diff --git a/dh b/dh
index c34a5a0273e952f359e8b92cf14c19ab7f73c24b..c90cf0e286752c72288edc86863bf58fa0c8da2d 100755 (executable)
--- a/dh
+++ b/dh
@@ -11,7 +11,7 @@ use Debian::Debhelper::Dh_Lib;
 
 =head1 SYNOPSIS
 
-B<dh> sequence [B<--with> I<addon>[,I<addon>,...]] [B<--until> I<cmd>] [B<--before> I<cmd>] [B<--after> I<cmd>] [B<--remaining>] [S<I<debhelper options>>]
+B<dh> sequence [B<--with> I<addon>[,I<addon>,...]] [B<--list>] [B<--until> I<cmd>] [B<--before> I<cmd>] [B<--after> I<cmd>] [B<--remaining>] [S<I<debhelper options>>]
 
 =head1 DESCRIPTION
 
@@ -35,11 +35,10 @@ in the sequence. The B<--until>, B<--before>, B<--after>, and B<--remaining>
 options can override this behavior.
 
 If debian/rules contains a target with a name like "override_I<dh_command>",
-then when it gets to that command in the sequence, dh will run that
-target from the rules file, rather than running the actual command. The
-override target can then run the command with additional options, or run
-entirely different commands instead. (Note that to use this feature,
-you should Build-Depend on debhelper 7.0.50 or above.)
+then when it would notmally run I<dh_command>, dh will instead call that
+target. The override target can then run the command with additional options,
+or run entirely different commands instead. See examples below. (Note that to
+use this feature, you should Build-Depend on debhelper 7.0.50 or above.)
 
 =head1 OPTIONS
 
@@ -58,6 +57,10 @@ the sequence addon interface.
 
 The inverse of --with, disables using the given addon.
 
+=item B<--list>, B<-l>
+
+List all available addons.
+
 =item B<--until> I<cmd>
 
 Run commands in the sequence until and including I<cmd>, then stop.
@@ -74,18 +77,20 @@ Run commands in the sequence that come after I<cmd>.
 
 Run all commands in the sequence that have yet to be run.
 
+=item B<--no-act>
+
+Prints commands that would run for a given sequence, but does not run them.
+
 =back
 
 All other options passed to dh are passed on to each command it runs. This
 can be used to set an option like "-v" or "-X" or "-N", as well as for more
 specialised options.
 
-=head1 COMMAND SPECIFICATION
-
-I<cmd> can be a full name of a debhelper command, or a substring. It'll first
-search for a command in the sequence exactly matching the name, to avoid any
-ambiguity. If there are multiple substring matches, the last one in the
-sequence will be used.
+In the above options, I<cmd> can be a full name of a debhelper command, or
+a substring. It'll first search for a command in the sequence exactly
+matching the name, to avoid any ambiguity. If there are multiple substring
+matches, the last one in the sequence will be used.
 
 =cut
 
@@ -172,6 +177,14 @@ default. This is how to use dh_pycentral instead.
        %:
                dh --with python-central $@
 
+Here is how to force use of perl's Module::Build build system,
+which can be necessary if debhelper wrongly detects that the package
+uses MakeMaker.
+
+       #!/usr/bin/make -f
+       %:
+               dh --buildsystem=perl_build $@
+
 To patch your package using quilt, you can tell dh to use quilt's dh
 sequence addons like this:
        
@@ -181,13 +194,22 @@ sequence addons like this:
 
 Here is an example of overriding where the dh_auto_* commands find
 the package's source, for a package where the source is located in a
-subdirectory. It also forces use of perl's Module::Build build system,
-which can be necessary if debhelper wrongly detects that the package
-uses MakeMaker.
+subdirectory.
 
        #!/usr/bin/make -f
        %:
-               dh --sourcedirectory=src --buildsystem=perl_build $@
+               dh --sourcedirectory=src $@
+
+Finally, here is a way to prevent dh from running several commands
+that you don't want it to run, by defining empty override targets for each
+command.
+
+       #!/usr/bin/make -f
+       %:
+               dh $@
+       
+       # Commands not to run:
+       override_dh_auto_test override_dh_compress override_dh_fixperms:
 
 =cut
 
@@ -216,9 +238,18 @@ init(options => {
                my ($option,$value)=@_;
                @{$dh{WITH}} = grep { $_ ne $value } @{$dh{WITH}};
        },
+       "l" => \$dh{LIST},
+       "list" => \$dh{LIST},
 });
 inhibit_log();
 
+# If make is using a jobserver, but it is not available
+# to this process, clean out MAKEFLAGS. This avoids
+# ugly warnings when calling make.
+if (is_make_jobserver_unavailable()) {
+       clean_jobserver_makeflags();
+}
+
 # Definitions of sequences.
 my %sequences;
 $sequences{build} = [qw{
@@ -247,7 +278,6 @@ $sequences{install} = [@{$sequences{build}}, qw{
        dh_installcatalogs
        dh_installcron
        dh_installdebconf
-       dh_installcatalogs
        dh_installemacsen
        dh_installifupdown
        dh_installinfo
@@ -287,6 +317,9 @@ $sequences{binary} = [@{$sequences{install}}, qw{
 }, @b];
 $sequences{'binary-arch'} = [@{$sequences{binary}}];
 
+# Additional command options
+my %command_opts;
+
 # sequence addon interface
 sub _insert {
        my $offset=shift;
@@ -322,12 +355,61 @@ sub remove_command {
        }
        
 }
+sub add_command {
+       my $command=shift;
+       my $sequence=shift;
+       unshift @{$sequences{$sequence}}, $command;
+}
+sub add_command_options {
+       my $command=shift;
+       push @{$command_opts{$command}}, @_;
+}
+sub remove_command_options {
+       my $command=shift;
+       if (@_) {
+               # Remove only specified options
+               if (my $opts = $command_opts{$command}) {
+                       foreach my $opt (@_) {
+                               $opts = [ grep { $_ ne $opt } @$opts ];
+                       }
+                       $command_opts{$command} = $opts;
+               }
+       }
+       else {
+               # Clear all additional options
+               delete $command_opts{$command};
+       }
+}
+
+if ($dh{LIST}) {
+       my %addons;
+
+       for my $inc (@INC) {
+               eval q{use File::Spec};
+               my $path = File::Spec->catdir($inc, "Debian/Debhelper/Sequence");
+               if (-d $path) {
+                       for my $module_path (glob "$path/*.pm") {
+                               my $name = basename($module_path);
+                               $name =~ s/\.pm$//;
+                               $name =~ s/_/-/g;
+                               $addons{$name} = 1;
+                       }
+               }
+       }
+
+       for my $name (sort keys %addons) {
+               print "$name\n";
+       }
+
+       exit 0;
+}
+
 foreach my $addon (@{$dh{WITH}}) {
        my $mod="Debian::Debhelper::Sequence::$addon";
        $mod=~s/-/_/g;
        eval "use $mod";
        if ($@) {
-               error("--with $addon not supported or failed to load module $mod");
+               error("unable to load addon $addon: $@");
        }
 }
 
@@ -458,26 +540,44 @@ sub run {
        # Check for override targets in debian/rules and
        # run them instead of running the command directly.
        my $override_command;
-       if (rules_explicit_target("override_".$command)) {
+       my $has_explicit_target = rules_explicit_target("override_".$command);
+       if (defined $has_explicit_target) {
                $override_command=$command;
-               # This passes the options through to commands called
-               # inside the target.
-               $ENV{DH_INTERNAL_OPTIONS}=join("\x1e", @options);
-               $command="debian/rules";
-               @options="override_".$override_command;
+               # Check if target isn't noop
+               if ($has_explicit_target) {
+                       # This passes the options through to commands called
+                       # inside the target.
+                       $ENV{DH_INTERNAL_OPTIONS}=join("\x1e", @options);
+                       $command="debian/rules";
+                       @options="override_".$override_command;
+               }
+               else {
+                       $command = undef;
+               }
+       }
+       else {
+               # Pass additional command options if any
+               unshift @options, @{$command_opts{$command}} if exists $command_opts{$command};
        }
 
-       # 3 space indent lines the command being run up under the 
-       # sequence name after "dh ".
-       print "   ".escape_shell($command, @options)."\n";
+       if (defined $command) {
+               # 3 space indent lines the command being run up under the
+               # sequence name after "dh ".
+               print "   ".escape_shell($command, @options)."\n";
+       }
+       else {
+               print "   ", "# Skipping ", $override_command, " - empty override", "\n";
+       }
 
        if (! $dh{NO_ACT}) {
-               my $ret=system($command, @options);
-               if ($ret >> 8 != 0) {
-                       exit $ret >> 8;
-               }
-               elsif ($ret) {
-                       exit 1;
+               if (defined $command) {
+                       my $ret=system($command, @options);
+                       if ($ret >> 8 != 0) {
+                               exit $ret >> 8;
+                       }
+                       elsif ($ret) {
+                               exit 1;
+                       }
                }
 
                if (defined $override_command) {
@@ -502,12 +602,15 @@ my $rules_parsed;
 
 sub rules_explicit_target {
        # Checks if a specified target exists as an explicit target
-       # in debian/rules. 
+       # in debian/rules.
+       # undef is returned if target does not exist, 0 if target is noop
+       # and 1 if target has dependencies or executes commands.
        my $target=shift;
-       
-       if (! $rules_parsed) {  
+
+       if (! $rules_parsed) {
                my $processing_targets = 0;
                my $not_a_target = 0;
+               my $current_target;
                open(MAKE, "LC_ALL=C make -Rrnpsf debian/rules debhelper-fail-me 2>/dev/null |");
                while (<MAKE>) {
                        if ($processing_targets) {
@@ -515,19 +618,34 @@ sub rules_explicit_target {
                                        $not_a_target = 1;
                                }
                                else {
-                                       if (!$not_a_target && /^([^#:]+)::?/) {
-                                               # Target is defined.
-                                               # NOTE: if it is a depenency
-                                               # of .PHONY it will be
-                                               # defined too but that's ok.
-                                               $targets{$1} = 1;
+                                       if (!$not_a_target && /^([^#:]+)::?\s*(.*)$/) {
+                                               # Target is defined. NOTE: if it is a depenency of
+                                               # .PHONY it will be defined too but that's ok.
+                                               # $2 contains target dependencies if any.
+                                               $current_target = $1;
+                                               $targets{$current_target} = ($2) ? 1 : 0;
+                                       }
+                                       else {
+                                               if (defined $current_target) {
+                                                       if (/^#/) {
+                                                               # Check if target has commands to execute
+                                                               if (/^#\s*commands to execute/) {
+                                                                       $targets{$current_target} = 1;
+                                                               }
+                                                       }
+                                                       else {
+                                                               # Target parsed.
+                                                               $current_target = undef;
+                                                       }
+                                               }
                                        }
                                        # "Not a target:" is always followed by
                                        # a target name, so resetting this one
                                        # here is safe.
                                        $not_a_target = 0;
                                }
-                       } elsif (/^# Files$/) {
+                       }
+                       elsif (/^# Files$/) {
                                $processing_targets = 1;
                        }
                }
@@ -535,7 +653,7 @@ sub rules_explicit_target {
                $rules_parsed = 1;
        }
 
-       return exists $targets{$target};
+       return $targets{$target};
 }
 
 }