Makefile - Tutorial and Tips & Tricks

This makefile snippet checks whether a file called phpunit.xml exists in the .config directory and prints a message accordingly. The first line reports if the file is missing, and the third line confirms if it's present. The @ symbol suppresses the command itself from being printed during execution.

This is a bash test that checks whether a phpunit.xml configuration file exists and has content. If the file doesn't exist or is empty, it prints an error message and stops the script with an exit code of 1 to signal failure.

This Makefile snippet checks whether a .env file exists in the current directory, and if it does, it includes (loads) that file so its variables are available to the rest of the Makefile. This is a common pattern for loading configuration from environment files.

This is a Makefile snippet that includes a .env file if it exists. The minus sign tells Make to ignore errors if the file isn't found, so the build won't fail just because there's no .env file.

This Makefile snippet checks whether a specific folder (vendor/a/b/c) exists using two different approaches. The first block echoes a message if the folder does NOT exist, while the second block echoes a message if the folder DOES exist. Both use shell commands to test for the folder's presence and compare the result.

This is a Makefile that defines three build targets: 'vendor' prints a message about getting vendors, 'update-them' prints a message about updating vendors, and 'php-cs-fixer' runs those two targets in sequence and then executes the php-cs-fixer tool to automatically format PHP code according to style rules.

This is a Makefile that defines build targets for managing PHP dependencies and code formatting. The `php-cs-fixer` target runs a code style fixer tool, while `vendor` and `update-them` are helper targets that print messages (likely meant to be called in sequence). The exit statement on line 10 deliberately causes the update process to fail.

This is a Makefile rule that finds all markdown files in the current directory and runs a shell script called concat.sh to process them. The 'concat' target depends on all .md files being present, so if any markdown files change, the rule will re-execute.

This is a simple shell script target (likely in a Makefile) that, when invoked, will print the text 'Hello world' to the console. It's a basic example of defining a named command that can be run by calling 'make helloWorld'.

This is a Makefile target named 'helloWorld' that, when invoked with the make command, will print the text 'Hello world' to the console. The @ symbol suppresses echoing the command itself, so you only see the output message, not the echo command that produced it.

This is a Makefile snippet that checks the PHP version being used and prints an appropriate message to the console. If PHP 8 or higher is set, it tells the user to upgrade dependencies; otherwise, it says to downgrade to PHP 7. The message is printed in bold yellow text.

This is a Makefile snippet that checks whether the DB_TYPE variable has a value or not, printing different messages depending on the result. It uses two conditional blocks—one that triggers if DB_TYPE is not empty, and another that triggers if it is empty.

This is a Makefile target named 'phplint' that runs PHP's built-in linter on index.php to check for syntax errors, then prints a confirmation message if no errors stop execution.

This Makefile target creates a Docker bridge network named 'my_network', suppressing any output and error messages. The '|| true' at the end ensures the command never fails, even if the network already exists, so the build continues without interruption.

This line sets a Makefile variable called SHELL to the value 'bash', which tells Make to use the bash shell (instead of the default sh shell) when executing commands in recipe lines throughout the rest of the Makefile.

This is a Makefile that defines a simple target called 'hello' which prints 'Hello World' to the console. The 'default' target points to 'hello', so running 'make' without arguments will execute the hello target by default.

This Makefile snippet sets up a build target that converts a file from Markdown to PDF format. It defines a color constant for terminal output, creates a variable for the output filename by replacing the .md extension with .pdf, and then prints a colored message to the user showing what file will be converted and where it will go.

This is a Makefile target named 'helloWorld' that, when invoked, executes a simple echo command to print 'Hello World' to the console. It's a basic example of how to define and run tasks in a Makefile.

This is a Makefile snippet that defines a custom recipe prefix and creates a simple target called 'changeExt'. When you run this target, it prints 'It works' to the output. The first line changes Makefile's recipe prefix from tab characters to the '>' character, which is unusual but valid.

This is a Makefile target named 'hello' that prints a greeting message. When you run 'make hello', it echoes a message that includes a variable called 'firstname', which gets substituted with its actual value.

This Makefile snippet defines a task called 'runsql' that checks whether a SQL variable has been set, then either prints a yellow message saying what SQL will run, or prints a red error message and exits if SQL wasn't provided. It's a safety check to prevent accidentally running undefined SQL commands.

This Makefile target checks whether a SonarQube Docker container is already running before proceeding with a scan. If the container isn't found or isn't in a running state, it prints an error message and exits with failure status, preventing the scan from running against a non-existent service.

This Makefile snippet checks whether a Docker container named 'sonarqube' already exists. If it doesn't, it creates a new one from the latest sonarqube image. If it does exist, it ensures the container is started, silencing any output or errors.

This is a Makefile with two targets both named 'hello'. When you run 'make hello', only the second one executes because Makefile targets with duplicate names get overwritten — the second definition replaces the first. Each target uses @echo to print a message without showing the command itself.

This Makefile defines a target called 'hello' three separate times, each with its own echo command. When you run 'make hello', all three rules will execute in sequence, printing three different greeting messages.

This Makefile snippet defines a phony target called 'current_dir' that, when invoked, prints out the current working directory. The PWD variable is set at the beginning using a shell command to capture the actual directory path.

This Makefile snippet finds all Docker Compose YAML files in the `.docker` directory, then converts the space-separated list into a colon-separated list. This format is useful for passing multiple files as arguments to tools that expect paths delimited by colons.

This Makefile target runs Docker Compose's config command to validate and display the final merged Docker Compose configuration. It uses a variable to specify which YAML files to include, allowing you to see what Docker will actually execute when you run your services.

This is a Makefile that includes environment variables from a .env file and defines a task called 'helloDocker' that prints out the name of a Docker image stored in the DOCKER_IMAGE variable.

This Makefile snippet conditionally sets a CMD variable based on the APP_ENV environment variable. If we're in production, CMD stays empty (commands run directly), but in other environments like development, CMD becomes a docker compose prefix so commands run inside a container.

This is a Makefile target that runs the Composer dependency manager with an update command. When you invoke 'make composer-update', it will update all PHP project dependencies to their latest allowed versions without prompting for user input.

This is a Makefile variable assignment that sets PHP_VERSION to 8.1 if it hasn't already been defined. The `or` function checks if PHP_VERSION was passed in from elsewhere (like command-line arguments), and only uses the default value 8.1 if nothing was provided.

This line outputs a directory path, using a variable called DOCKER_APP_HOME if it's set, otherwise falling back to the default path /var/www/html. It's a common pattern for allowing configuration while providing a sensible default.

This line defines a Makefile variable called DOCKER_PHPQA that constructs a Docker image name by combining a base image path with a PHP version number. When this variable is used later in the Makefile, it will expand to the full image identifier needed to run PHP code quality analysis tools.

This Makefile snippet checks the PHP version by using a regex pattern to detect if it's version 7, then stores the result in a variable. When the doThing target runs, it prints different messages depending on whether PHP 7 was detected or not.

This Makefile snippet checks whether a `--quiet` flag was passed in the command arguments, then defines a `testme` target that conditionally prints an informational message about quiet mode, followed by an important message that always prints.

This Makefile snippet captures three pieces of information about the current Git repository: the branch name, the root directory path, and the repository URL. Each line runs a shell command and stores the result in a variable so it can be used later in build scripts or automation.

This Makefile defines three convenience targets that open different pages of a Git repository in your default web browser. Each target uses the sensible-browser command to launch a URL, with the base repository URL stored in the GIT_URL_REPO variable and different paths appended for the repo, pipelines, and wiki pages.

This is a Makefile target that creates a quick checkpoint of work-in-progress code. When you run 'make git_wip', it stages all changes, commits them with a 'wip' message while skipping pre-commit hooks, and pushes to the remote repository — useful for saving your work without worrying about code quality checks.

This is a Makefile snippet that defines two build targets: one to update PHP dependencies (composer.lock), and another to install them (vendor directory). The first target runs when composer.json changes, ensuring the lock file stays in sync; the second runs when the lock file changes, installing those specific versions into the vendor folder.

This Makefile snippet sets up a quality assurance workflow using Docker containers to run PHP linting and code formatting tools. It defines color codes, configures a phpqa Docker image with the current PHP version, and then creates four Make targets (phan, php-cs-fixer-dry-run, php-cs-fixer-fix, phplint, yamllint) that run various code analysis and formatting commands inside isolated Docker containers while preserving file ownership.

This is a Makefile snippet that defines a 'clean' target to remove build artifacts and temporary files from a project. When you run 'make clean', it deletes node_modules and vendor directories, then empties cache and log directories, with yellow colored status messages printed along the way.

This is a build target that safely removes the vendor directory if it exists. It's a cleanup step that would typically be run before a fresh installation or rebuild to ensure no stale dependencies remain.

This is a Makefile target that opens a French Google homepage in your default browser and prints a confirmation message. It's a convenient shortcut for developers who want to quickly launch a website during their build process.

This Makefile snippet defines a variable that extracts the GitHub repository URL from your local Git configuration and converts it to HTTPS format if needed, then provides a make target that opens that repository in your default web browser.