How to make one target call another when order matters? - makefile

Question

I've got two targets that are almost the same:
# install node modules from package.json and bring npm-shrinkwrap.json up to date
npm-install:
ifndef SHRINKWRAP_BIN
$(error `npm-shrinkwrap` not found. Please run `sudo npm install -g npm-shrinkwrap`)
endif
$(NPM_BIN) install --no-shrinkwrap --loglevel=error --no-optional
$(NPM_BIN) prune --no-shrinkwrap --loglevel=error
$(NPM_BIN) dedupe --no-shrinkwrap --loglevel=error
npm-shrinkwrap --dev
touch $(NPM_TIMESTAMP)
# update npm dependencies to their latest version given the semver constraints and re-write npm-shrinkwrap file
npm-update:
ifndef SHRINKWRAP_BIN
$(error `npm-shrinkwrap` not found. Please run `sudo npm install -g npm-shrinkwrap`)
endif
$(NPM_BIN) update --save-dev --loglevel=error --no-optional
$(NPM_BIN) prune --no-shrinkwrap --loglevel=error
$(NPM_BIN) dedupe --no-shrinkwrap --loglevel=error
npm-shrinkwrap --dev
touch $(NPM_TIMESTAMP)
Is there any way I can remove some duplication by having them both call another target? I can't just add a prerequisite with the common part to both of them because prerequisites are ran before the commands and the install/update bit has to be ran first (before prune/dedupe/shrinkwrap).

Answer 1

Assuming I read this correctly and the difference between the two is just the word install in npm-install and update in npm-update then the solution here is to just use the target (or part of it) in the commands you are running.
Something like this:
# install node modules from package.json and bring npm-shrinkwrap.json up to date
npm-install npm-update:
ifndef SHRINKWRAP_BIN
$(error `npm-shrinkwrap` not found. Please run `sudo npm install -g npm-shrinkwrap`)
endif
$(NPM_BIN) $(subst npm-,,$#) --no-shrinkwrap --loglevel=error --no-optional
$(NPM_BIN) prune --no-shrinkwrap --loglevel=error
$(NPM_BIN) dedupe --no-shrinkwrap --loglevel=error
npm-shrinkwrap --dev
touch $(NPM_TIMESTAMP)
You could also use $(word 2,$(subst -, ,$#)) or $(patsubst npm-%,%,$#) or as the above doesn't switch --no-shrinkwrap for --save-dev you could use something like this (or combine the $# usage above with an arg variable like this):
npm-install: command := install
npm-install: arg := --no-shrinkwrap
npm-update: command := update
npm-update: arg :=--save-dev
npm-install npm-update:
....
$(NPM_BIN) $(command) $(arg) --loglevel=error --no-optional
....

Answer 2

I have several ideas about this. The first is to just use text processing within the Makefile to reduce the duplication explicitly. Define a multi-line macro and then call it.
define NPM_COMMON_STEPS
$(NPM_BIN) prune ...
$(NPM_BIN) dedupe ...
...
endef
Since this has no parameters, we don't have to use the $(call ...) operator. Just simply, in the recipe we call it as:
$(NPM_COMMON_STEPS)
Then there are other ways. You could make the dummy prerequisite target handle all the logic, and just switch some part of it around based on who is "calling". How can we know that? Why, via target-specific variables!
This can be illustrated via a complete Makefile:
.PHONY: all common-target a-target b-target
all: a-target b-target
common-target:
$(if $(CALLED_FOR_A), echo called for a-target)
$(if $(CALLED_FOR_B), echo called for b-target)
echo common recipe
a-target: CALLED_FOR_A := y
a-target: common-target
b-target: CALLED_FOR_B := y
b-target: common-target
Tests:
$ make
echo called for a-target
called for a-target
echo common recipe
common recipe
$ make a-target
echo called for a-target
called for a-target
echo common recipe
common recipe
$ make b-target
echo called for b-target
called for b-target
echo common recipe
common recipe
As you can see, there is a drawback here in that if we update the target all, then GNU Make only executes the shared common rule once. When that rule has been run on behalf of a-target, it's considered updated and isn't run for b-target.
This doesn't matter if we don't update both targets in the same run, but all the same, it's a potential snag:
$ make a-target b-target
echo called for a-target
called for a-target
echo common recipe
common recipe
make: Nothing to be done for `b-target'.
Thus I'd think twice before using this type of trick. If you would never do an npm-update and npm-install in the same invocation, then this could be used.
Here is a complete sample of the textual substitution solution:
.PHONY: all a-target b-target
all: a-target b-target
define COMMON
echo common recipe
endef
define COMMON_WITH_ARG
echo common recipe with arg 1 == $(1)
endef
a-target:
echo a-target
$(COMMON)
$(call COMMON_WITH_ARG,a)
echo a-done
b-target:
echo b-target
$(COMMON)
$(call COMMON_WITH_ARG,b)
echo b-done
Run:
$ make
echo a-target
a-target
echo common recipe
common recipe
echo common recipe with arg 1 == a
common recipe with arg 1 == a
echo a-done
a-done
echo b-target
b-target
echo common recipe
common recipe
echo common recipe with arg 1 == b
common recipe with arg 1 == b
echo b-done
b-done