alioth/nixpkgs
3
0
Fork 0
forked from mirrors/nixpkgs
Code Releases Activity
nixpkgs/pkgs/development/interpreters/php/generic.nix

283 lines
11 KiB
Nix
Raw Normal View History

nixos/php: Move the pcre tests to the php test attribute
2020-03-31 18:06:04 +01:00
# We have tests for PCRE and PHP-FPM in nixos/tests/php/ or
# both in the same attribute named nixosTests.php
php: Refactor to have the different versions as separate files This should enable easier auto updates of the packages.
2020-11-04 17:59:02 +00:00
{ callPackage, lib, stdenv, nixosTests, ... }:
php: Use callPackages
2015-08-11 12:13:28 +01:00
php: get rid of composableDerivation Some bugs may have creeped in during the conversion. One flag I had trouble with and so removed was: "--enable-embedded-mysqli"
2018-07-21 16:41:48 +01:00
let
php: Use callPackages
2015-08-11 12:13:28 +01:00
generic =
php: Rename extra init file in store and symlink it instead of copying
2021-02-27 17:36:45 +00:00
{ callPackage, lib, stdenv, nixosTests, fetchurl, makeWrapper
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
, symlinkJoin, writeText, autoconf, automake, bison, flex, libtool
treewide: pkgs.pkgconfig -> pkgs.pkg-config, move pkgconfig to alias.nix continuation of #109595 pkgconfig was aliased in 2018, however, it remained in all-packages.nix due to its wide usage. This cleans up the remaining references to pkgs.pkgsconfig and moves the entry to aliases.nix. python3Packages.pkgconfig remained unchanged because it's the canonical name of the upstream package on pypi.
2021-01-19 06:50:56 +00:00
, pkg-config, re2c, apacheHttpd, libargon2, libxml2, pcre, pcre2
php: use system-sendmail By default PHP is looking for sendmail in /usr/bin/sendmail which isn't a correct path for NixOS.
2020-08-21 11:37:33 +01:00
, systemd, system-sendmail, valgrind, xcbuild
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
, version
, sha256
, extraPatches ? []
php.packages: Make packages overridable This will allow patching extensions without having to manually having to patch all occurrences in the dependency tree.
2020-12-15 23:06:42 +00:00
, packageOverrides ? (final: prev: {})
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
# Sapi flags
php: Get rid of all config.php parameters Since all options controlled by the config.php parameters can now be overridden directly, there's no reason to keep them around.
2020-04-24 12:29:46 +01:00
, cgiSupport ? true
, cliSupport ? true
, fpmSupport ? true
, pearSupport ? true
, pharSupport ? true
, phpdbgSupport ? true
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
# Misc flags
php: Get rid of all config.php parameters Since all options controlled by the config.php parameters can now be overridden directly, there's no reason to keep them around.
2020-04-24 12:29:46 +01:00
, apxs2Support ? !stdenv.isDarwin
, argon2Support ? true
, cgotoSupport ? false
, embedSupport ? false
, ipv6Support ? true
, systemdSupport ? stdenv.isLinux
php: fix on darwin
2020-10-27 10:24:20 +00:00
, valgrindSupport ? !stdenv.isDarwin
php: Get rid of all config.php parameters Since all options controlled by the config.php parameters can now be overridden directly, there's no reason to keep them around.
2020-04-24 12:29:46 +01:00
, ztsSupport ? apxs2Support
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
}@args:
let
php.buildEnv: Provide a list of currently enabled extensions Rework withExtensions / buildEnv to handle currently enabled extensions better and make them compatible with override. They now accept a function with the named arguments enabled and all, where enabled is a list of currently enabled extensions and all is the set of all extensions. This gives us several nice properties: - You always get the right version of the list of currently enabled extensions - Invocations chain - It works well with overridden PHP packages - you always get the correct versions of extensions As a contrived example of what's possible, you can add ImageMagick, then override the version and disable fpm, then disable cgi, and lastly remove the zip extension like this: { pkgs ? (import <nixpkgs>) {} }: with pkgs; let phpWithImagick = php74.withExtensions ({ all, enabled }: enabled ++ [ all.imagick ]); phpWithImagickWithoutFpm743 = phpWithImagick.override { version = "7.4.3"; sha256 = "wVF7pJV4+y3MZMc6Ptx21PxQfEp6xjmYFYTMfTtMbRQ="; fpmSupport = false; }; phpWithImagickWithoutFpmZip743 = phpWithImagickWithoutFpm743.withExtensions ( { enabled, all }: lib.filter (e: e != all.zip) enabled); phpWithImagickWithoutFpmZipCgi743 = phpWithImagickWithoutFpmZip743.override { cgiSupport = false; }; in phpWithImagickWithoutFpmZipCgi743
2020-04-12 22:31:56 +01:00
# buildEnv wraps php to provide additional extensions and
# configuration. Its usage is documented in
# doc/languages-frameworks/php.section.md.
#
# Create a buildEnv with earlier overridden values and
# extensions functions in its closure. This is necessary for
# consecutive calls to buildEnv and overrides to work as
# expected.
mkBuildEnv = prevArgs: prevExtensionFunctions: lib.makeOverridable (
php.buildEnv: Let enabled extensions to pass through by default If only extraConfig is specified in buildEnv, keep the currently enabled extensions active. Brought up in #89011.
2020-05-28 23:32:12 +01:00
{ extensions ? ({ enabled, ... }: enabled), extraConfig ? "", ... }@innerArgs:
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
let
php.buildEnv: Respect override Make buildEnv take earlier overridden values into account by forwarding all arguments (a merge of generic's arguments, all previous arguments and the current arguments) to the next invocation of buildEnv.
2020-04-12 21:52:51 +01:00
allArgs = args // prevArgs // innerArgs;
filteredArgs = builtins.removeAttrs allArgs [ "extensions" "extraConfig" ];
php = generic filteredArgs;
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
php-packages = (callPackage ../../../top-level/php-packages.nix {
phpPackages: convert to scope This will make it easier to make overridable. Had to rename `packages` attribute to `tools` in `php-packages.nix` because `packages` is shadowed by `makeScope`.
2020-12-15 16:42:21 +00:00
phpPackage = phpWithExtensions;
php.packages: Make packages overridable This will allow patching extensions without having to manually having to patch all occurrences in the dependency tree.
2020-12-15 23:06:42 +00:00
}).overrideScope' packageOverrides;
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
php.buildEnv: Provide a list of currently enabled extensions Rework withExtensions / buildEnv to handle currently enabled extensions better and make them compatible with override. They now accept a function with the named arguments enabled and all, where enabled is a list of currently enabled extensions and all is the set of all extensions. This gives us several nice properties: - You always get the right version of the list of currently enabled extensions - Invocations chain - It works well with overridden PHP packages - you always get the correct versions of extensions As a contrived example of what's possible, you can add ImageMagick, then override the version and disable fpm, then disable cgi, and lastly remove the zip extension like this: { pkgs ? (import <nixpkgs>) {} }: with pkgs; let phpWithImagick = php74.withExtensions ({ all, enabled }: enabled ++ [ all.imagick ]); phpWithImagickWithoutFpm743 = phpWithImagick.override { version = "7.4.3"; sha256 = "wVF7pJV4+y3MZMc6Ptx21PxQfEp6xjmYFYTMfTtMbRQ="; fpmSupport = false; }; phpWithImagickWithoutFpmZip743 = phpWithImagickWithoutFpm743.withExtensions ( { enabled, all }: lib.filter (e: e != all.zip) enabled); phpWithImagickWithoutFpmZipCgi743 = phpWithImagickWithoutFpmZip743.override { cgiSupport = false; }; in phpWithImagickWithoutFpmZipCgi743
2020-04-12 22:31:56 +01:00
allExtensionFunctions = prevExtensionFunctions ++ [ extensions ];
enabledExtensions =
builtins.foldl'
php.buildEnv: Let enabled extensions to pass through by default If only extraConfig is specified in buildEnv, keep the currently enabled extensions active. Brought up in #89011.
2020-05-28 23:32:12 +01:00
(enabled: f:
f { inherit enabled; all = php-packages.extensions; })
php.buildEnv: Provide a list of currently enabled extensions Rework withExtensions / buildEnv to handle currently enabled extensions better and make them compatible with override. They now accept a function with the named arguments enabled and all, where enabled is a list of currently enabled extensions and all is the set of all extensions. This gives us several nice properties: - You always get the right version of the list of currently enabled extensions - Invocations chain - It works well with overridden PHP packages - you always get the correct versions of extensions As a contrived example of what's possible, you can add ImageMagick, then override the version and disable fpm, then disable cgi, and lastly remove the zip extension like this: { pkgs ? (import <nixpkgs>) {} }: with pkgs; let phpWithImagick = php74.withExtensions ({ all, enabled }: enabled ++ [ all.imagick ]); phpWithImagickWithoutFpm743 = phpWithImagick.override { version = "7.4.3"; sha256 = "wVF7pJV4+y3MZMc6Ptx21PxQfEp6xjmYFYTMfTtMbRQ="; fpmSupport = false; }; phpWithImagickWithoutFpmZip743 = phpWithImagickWithoutFpm743.withExtensions ( { enabled, all }: lib.filter (e: e != all.zip) enabled); phpWithImagickWithoutFpmZipCgi743 = phpWithImagickWithoutFpmZip743.override { cgiSupport = false; }; in phpWithImagickWithoutFpmZipCgi743
2020-04-12 22:31:56 +01:00
[]
allExtensionFunctions;
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
getExtName = ext: lib.removePrefix "php-" (builtins.parseDrvName ext.name).name;
php.buildEnv: Automatically include extension dependencies Some extensions depend on other extensions. Previously, these had to be added manually to the list of included extensions, or we got a cryptic error message pointing to strings-with-deps.nix, which wasn't very helpful. This makes sure all required extensions are included in the set from which textClosureList chooses its snippets.
2020-04-24 17:11:40 +01:00
# Recursively get a list of all internal dependencies
# for a list of extensions.
getDepsRecursively = extensions:
let
deps = lib.concatMap
php.buildPecl: Allow PECLs to depend on other PECLs Some PECLs depend on other PECLs and, like internal PHP extension dependencies, need to be loaded in the correct order. This makes this possible by adding the argument "peclDeps" to buildPecl, which adds the extension to buildInputs and is treated the same way as internalDeps when the extension config is generated.
2020-05-02 22:13:53 +01:00
(ext: (ext.internalDeps or []) ++ (ext.peclDeps or []))
php.buildEnv: Automatically include extension dependencies Some extensions depend on other extensions. Previously, these had to be added manually to the list of included extensions, or we got a cryptic error message pointing to strings-with-deps.nix, which wasn't very helpful. This makes sure all required extensions are included in the set from which textClosureList chooses its snippets.
2020-04-24 17:11:40 +01:00
extensions;
in
if ! (deps == []) then
deps ++ (getDepsRecursively deps)
else
deps;
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
# Generate extension load configuration snippets from the
# extension parameter. This is an attrset suitable for use
# with textClosureList, which is used to put the strings in
# the right order - if a plugin which is dependent on
# another plugin is placed before its dependency, it will
# fail to load.
extensionTexts =
lib.listToAttrs
(map (ext:
let
extName = getExtName ext;
php.buildPecl: Allow PECLs to depend on other PECLs Some PECLs depend on other PECLs and, like internal PHP extension dependencies, need to be loaded in the correct order. This makes this possible by adding the argument "peclDeps" to buildPecl, which adds the extension to buildInputs and is treated the same way as internalDeps when the extension config is generated.
2020-05-02 22:13:53 +01:00
phpDeps = (ext.internalDeps or []) ++ (ext.peclDeps or []);
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
type = "${lib.optionalString (ext.zendExtension or false) "zend_"}extension";
in
lib.nameValuePair extName {
text = "${type}=${ext}/lib/php/extensions/${extName}.so";
php.buildPecl: Allow PECLs to depend on other PECLs Some PECLs depend on other PECLs and, like internal PHP extension dependencies, need to be loaded in the correct order. This makes this possible by adding the argument "peclDeps" to buildPecl, which adds the extension to buildInputs and is treated the same way as internalDeps when the extension config is generated.
2020-05-02 22:13:53 +01:00
deps = map getExtName phpDeps;
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
})
php.buildEnv: Automatically include extension dependencies Some extensions depend on other extensions. Previously, these had to be added manually to the list of included extensions, or we got a cryptic error message pointing to strings-with-deps.nix, which wasn't very helpful. This makes sure all required extensions are included in the set from which textClosureList chooses its snippets.
2020-04-24 17:11:40 +01:00
(enabledExtensions ++ (getDepsRecursively enabledExtensions)));
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
extNames = map getExtName enabledExtensions;
php: Rename extra init file in store and symlink it instead of copying
2021-02-27 17:36:45 +00:00
extraInit = writeText "php-extra-init-${version}.ini" ''
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
${lib.concatStringsSep "\n"
(lib.textClosureList extensionTexts extNames)}
${extraConfig}
'';
phpWithExtensions = symlinkJoin rec {
name = "php-with-extensions-${version}";
inherit (php) version;
nativeBuildInputs = [ makeWrapper ];
php: declare ZTS support Binary extensions like Blackfire need to know whether PHP was compiled with ZTS support to work properly.
2020-10-04 12:00:23 +01:00
passthru = php.passthru // {
php.buildEnv: Provide a list of currently enabled extensions Rework withExtensions / buildEnv to handle currently enabled extensions better and make them compatible with override. They now accept a function with the named arguments enabled and all, where enabled is a list of currently enabled extensions and all is the set of all extensions. This gives us several nice properties: - You always get the right version of the list of currently enabled extensions - Invocations chain - It works well with overridden PHP packages - you always get the correct versions of extensions As a contrived example of what's possible, you can add ImageMagick, then override the version and disable fpm, then disable cgi, and lastly remove the zip extension like this: { pkgs ? (import <nixpkgs>) {} }: with pkgs; let phpWithImagick = php74.withExtensions ({ all, enabled }: enabled ++ [ all.imagick ]); phpWithImagickWithoutFpm743 = phpWithImagick.override { version = "7.4.3"; sha256 = "wVF7pJV4+y3MZMc6Ptx21PxQfEp6xjmYFYTMfTtMbRQ="; fpmSupport = false; }; phpWithImagickWithoutFpmZip743 = phpWithImagickWithoutFpm743.withExtensions ( { enabled, all }: lib.filter (e: e != all.zip) enabled); phpWithImagickWithoutFpmZipCgi743 = phpWithImagickWithoutFpmZip743.override { cgiSupport = false; }; in phpWithImagickWithoutFpmZipCgi743
2020-04-12 22:31:56 +01:00
buildEnv = mkBuildEnv allArgs allExtensionFunctions;
withExtensions = mkWithExtensions allArgs allExtensionFunctions;
php.buildEnv: Add phpIni attribute for easy access to the php.ini
2020-04-24 18:34:34 +01:00
phpIni = "${phpWithExtensions}/lib/php.ini";
php.buildEnv: Provide the unwrapped php package in php.unwrapped This is useful if you need to access the dev output of the unwrapped derivation.
2020-04-24 20:28:33 +01:00
unwrapped = php;
nixos/tests/php: Select the right versions of the tests depending on version
2021-02-28 20:16:08 +00:00
# Select the right php tests for the php version
tests = nixosTests."php${lib.strings.replaceStrings [ "." ] [ "" ] (lib.versions.majorMinor php.version)}";
phpPackages: convert to scope This will make it easier to make overridable. Had to rename `packages` attribute to `tools` in `php-packages.nix` because `packages` is shadowed by `makeScope`.
2020-12-15 16:42:21 +00:00
inherit (php-packages) extensions buildPecl;
packages = php-packages.tools;
php: override outputsToInstall when using withExtensions At the moment, using .withExtensions on a PHP derivation will produce something which can't be used inside an environment.systemPackages array, because outputsToInstall refers to an output which doesn't exist on the final derivation. Instead, override it back to just containing the single output "out".
2020-05-06 21:34:19 +01:00
meta = php.meta // {
outputsToInstall = [ "out" ];
};
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
};
paths = [ php ];
postBuild = ''
php: Rename extra init file in store and symlink it instead of copying
2021-02-27 17:36:45 +00:00
ln -s ${extraInit} $out/lib/php.ini
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
wrapProgram $out/bin/php --set PHP_INI_SCAN_DIR $out/lib
if test -e $out/bin/php-fpm; then
wrapProgram $out/bin/php-fpm --set PHP_INI_SCAN_DIR $out/lib
fi
wrapProgram for phpdbg in pkgs.php*
2020-11-16 16:27:38 +00:00
if test -e $out/bin/phpdbg; then
wrapProgram $out/bin/phpdbg --set PHP_INI_SCAN_DIR $out/lib
fi
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
'';
php.buildEnv: Make the exported php package overridable This implements the override pattern for builds done with buildEnv, so that we can, for example, write php.override { fpmSupport = false; } and get a PHP package with the default extensions enabled, but PHP compiled without fpm support.
2020-04-11 20:48:37 +01:00
};
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
in
phpWithExtensions);
php.buildEnv: Provide a list of currently enabled extensions Rework withExtensions / buildEnv to handle currently enabled extensions better and make them compatible with override. They now accept a function with the named arguments enabled and all, where enabled is a list of currently enabled extensions and all is the set of all extensions. This gives us several nice properties: - You always get the right version of the list of currently enabled extensions - Invocations chain - It works well with overridden PHP packages - you always get the correct versions of extensions As a contrived example of what's possible, you can add ImageMagick, then override the version and disable fpm, then disable cgi, and lastly remove the zip extension like this: { pkgs ? (import <nixpkgs>) {} }: with pkgs; let phpWithImagick = php74.withExtensions ({ all, enabled }: enabled ++ [ all.imagick ]); phpWithImagickWithoutFpm743 = phpWithImagick.override { version = "7.4.3"; sha256 = "wVF7pJV4+y3MZMc6Ptx21PxQfEp6xjmYFYTMfTtMbRQ="; fpmSupport = false; }; phpWithImagickWithoutFpmZip743 = phpWithImagickWithoutFpm743.withExtensions ( { enabled, all }: lib.filter (e: e != all.zip) enabled); phpWithImagickWithoutFpmZipCgi743 = phpWithImagickWithoutFpmZip743.override { cgiSupport = false; }; in phpWithImagickWithoutFpmZipCgi743
2020-04-12 22:31:56 +01:00
mkWithExtensions = prevArgs: prevExtensionFunctions: extensions:
mkBuildEnv prevArgs prevExtensionFunctions { inherit extensions; };
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
pcre' = if (lib.versionAtLeast version "7.3") then pcre2 else pcre;
in
stdenv.mkDerivation {
pname = "php";
inherit version;
enableParallelBuilding = true;
treewide: pkgs.pkgconfig -> pkgs.pkg-config, move pkgconfig to alias.nix continuation of #109595 pkgconfig was aliased in 2018, however, it remained in all-packages.nix due to its wide usage. This cleans up the remaining references to pkgs.pkgsconfig and moves the entry to aliases.nix. python3Packages.pkgconfig remained unchanged because it's the canonical name of the upstream package on pypi.
2021-01-19 06:50:56 +00:00
nativeBuildInputs = [ autoconf automake bison flex libtool pkg-config re2c ]
php7{2,3}: fix darwin build * Backported patches from `php-7.4` which fixes the env for all `gettext` and `zlib` tests. * Setting `--with-libxml-dir` is still needed for versions 7.2 and 7.3.
2020-06-25 20:21:28 +01:00
++ lib.optional stdenv.isDarwin xcbuild;
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
buildInputs =
# PCRE extension
[ pcre' ]
# Enable sapis
++ lib.optional pearSupport [ libxml2.dev ]
# Misc deps
++ lib.optional apxs2Support apacheHttpd
++ lib.optional argon2Support libargon2
++ lib.optional systemdSupport systemd
++ lib.optional valgrindSupport valgrind
;
CXXFLAGS = lib.optionalString stdenv.cc.isClang "-std=c++11";
configureFlags =
# Disable all extensions
[ "--disable-all" ]
# PCRE
++ lib.optionals (lib.versionAtLeast version "7.4") [ "--with-external-pcre=${pcre'.dev}" ]
++ lib.optionals (lib.versions.majorMinor version == "7.3") [ "--with-pcre-regex=${pcre'.dev}" ]
++ lib.optionals (lib.versionOlder version "7.3") [ "--with-pcre-regex=${pcre'.dev}" ]
++ [ "PCRE_LIBDIR=${pcre'}" ]
# Enable sapis
++ lib.optional (!cgiSupport) "--disable-cgi"
++ lib.optional (!cliSupport) "--disable-cli"
++ lib.optional fpmSupport "--enable-fpm"
php: Fix pear path
2020-10-14 06:41:30 +01:00
++ lib.optional pearSupport [ "--with-pear" "--enable-xml" "--with-libxml" ]
php7{2,3}: fix darwin build * Backported patches from `php-7.4` which fixes the env for all `gettext` and `zlib` tests. * Setting `--with-libxml-dir` is still needed for versions 7.2 and 7.3.
2020-06-25 20:21:28 +01:00
++ lib.optionals (pearSupport && (lib.versionOlder version "7.4")) [
"--enable-libxml"
"--with-libxml-dir=${libxml2.dev}"
]
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
++ lib.optional pharSupport "--enable-phar"
++ lib.optional phpdbgSupport "--enable-phpdbg"
# Misc flags
++ lib.optional apxs2Support "--with-apxs2=${apacheHttpd.dev}/bin/apxs"
++ lib.optional argon2Support "--with-password-argon2=${libargon2}"
++ lib.optional cgotoSupport "--enable-re2c-cgoto"
++ lib.optional embedSupport "--enable-embed"
++ lib.optional (!ipv6Support) "--disable-ipv6"
++ lib.optional systemdSupport "--with-fpm-systemd"
++ lib.optional valgrindSupport "--with-valgrind=${valgrind.dev}"
php80: init at 8.0.0
2020-11-26 12:21:43 +00:00
++ lib.optional (ztsSupport && (lib.versionOlder version "8.0")) "--enable-maintainer-zts"
++ lib.optional (ztsSupport && (lib.versionAtLeast version "8.0")) "--enable-zts"
php: use system-sendmail By default PHP is looking for sendmail in /usr/bin/sendmail which isn't a correct path for NixOS.
2020-08-21 11:37:33 +01:00
# Sendmail
++ [ "PROG_SENDMAIL=${system-sendmail}/bin/sendmail" ]
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
;
hardeningDisable = [ "bindnow" ];
php < 7.4: Fix validation of PKG_CONFIG var They were assuming it is an absolute path, but it (conventionally) can be something to look up on the PATH too. Fixes #90202
2020-06-13 20:05:15 +01:00
preConfigure =
# Don't record the configure flags since this causes unnecessary
# runtime dependencies
''
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
for i in main/build-defs.h.in scripts/php-config.in; do
substituteInPlace $i \
--replace '@CONFIGURE_COMMAND@' '(omitted)' \
--replace '@CONFIGURE_OPTIONS@' "" \
--replace '@PHP_LDFLAGS@' ""
done
export EXTENSION_DIR=$out/lib/php/extensions
php < 7.4: Fix validation of PKG_CONFIG var They were assuming it is an absolute path, but it (conventionally) can be something to look up on the PATH too. Fixes #90202
2020-06-13 20:05:15 +01:00
''
# PKG_CONFIG need not be a relative path
+ lib.optionalString (! lib.versionAtLeast version "7.4") ''
for i in $(find . -type f -name "*.m4"); do
substituteInPlace $i \
--replace 'test -x "$PKG_CONFIG"' 'type -P "$PKG_CONFIG" >/dev/null'
done
'' + ''
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
./buildconf --copy --force
if test -f $src/genfiles; then
./genfiles
fi
'' + lib.optionalString stdenv.isDarwin ''
substituteInPlace configure --replace "-lstdc++" "-lc++"
'';
postInstall = ''
test -d $out/etc || mkdir $out/etc
cp php.ini-production $out/etc/php.ini
'';
postFixup = ''
mkdir -p $dev/bin $dev/share/man/man1
mv $out/bin/phpize $out/bin/php-config $dev/bin/
mv $out/share/man/man1/phpize.1.gz \
$out/share/man/man1/php-config.1.gz \
$dev/share/man/man1/
'';
src = fetchurl {
url = "https://www.php.net/distributions/php-${version}.tar.bz2";
inherit sha256;
};
patches = [ ./fix-paths-php7.patch ] ++ extraPatches;
separateDebugInfo = true;
outputs = [ "out" "dev" ];
passthru = {
php.buildEnv: Provide a list of currently enabled extensions Rework withExtensions / buildEnv to handle currently enabled extensions better and make them compatible with override. They now accept a function with the named arguments enabled and all, where enabled is a list of currently enabled extensions and all is the set of all extensions. This gives us several nice properties: - You always get the right version of the list of currently enabled extensions - Invocations chain - It works well with overridden PHP packages - you always get the correct versions of extensions As a contrived example of what's possible, you can add ImageMagick, then override the version and disable fpm, then disable cgi, and lastly remove the zip extension like this: { pkgs ? (import <nixpkgs>) {} }: with pkgs; let phpWithImagick = php74.withExtensions ({ all, enabled }: enabled ++ [ all.imagick ]); phpWithImagickWithoutFpm743 = phpWithImagick.override { version = "7.4.3"; sha256 = "wVF7pJV4+y3MZMc6Ptx21PxQfEp6xjmYFYTMfTtMbRQ="; fpmSupport = false; }; phpWithImagickWithoutFpmZip743 = phpWithImagickWithoutFpm743.withExtensions ( { enabled, all }: lib.filter (e: e != all.zip) enabled); phpWithImagickWithoutFpmZipCgi743 = phpWithImagickWithoutFpmZip743.override { cgiSupport = false; }; in phpWithImagickWithoutFpmZipCgi743
2020-04-12 22:31:56 +01:00
buildEnv = mkBuildEnv {} [];
withExtensions = mkWithExtensions {} [];
php: declare ZTS support Binary extensions like Blackfire need to know whether PHP was compiled with ZTS support to work properly.
2020-10-04 12:00:23 +01:00
inherit ztsSupport;
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
};
pkgs/development/interpreters: stdenv.lib -> lib
2021-01-23 13:15:07 +00:00
meta = with lib; {
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
description = "An HTML-embedded scripting language";
homepage = "https://www.php.net/";
license = licenses.php301;
php: Set maintainer team as maintainers Also passthrough the meta of the package to have description, homepage, license, maintainers and other metadata passed through to the commonly used attribute.
2020-04-19 19:48:06 +01:00
maintainers = teams.php.members;
php: Make all arguments to a PHP build overridable Make all arguments to a PHP build overridable; i.e, both configuration flags, such as valgrindSupport, and packages, such as valgrind: php.override { valgrindSupport = false; valgrind = valgrind-light; } This applies to packages built by generic and buildEnv/withExtensions; i.e, it works with both phpXX and phpXXBase packages. The following changes were also made to facilitate this: - generic and generic' are merged into one function - generic now takes all required arguments for a complete build and is meant to be called by callPackage - The main function called from all-packages.nix no longer takes all required arguments for a complete build - all arguments passed to it are however forwarded to the individual builds, thus default arguments can still be overridden from all-packages.nix
2020-04-12 12:55:57 +01:00
platforms = platforms.all;
outputsToInstall = [ "out" "dev" ];
};
phpPackages: Move phpPackages to php.packages This means php packages can now refer to other php packages by looking them up in the php.packages attribute and gets rid of the internal recursive set previously defined in php-packages.nix. This also means that in applications where previously both the php package and the corresponding version of the phpPackages package set had to be specified, the php package will now suffice. This also adds the phpWithExtensions parameter to the php-packages.nix, which can be used by extensions that need a fully featured PHP executable.
2020-03-28 21:37:22 +00:00
};
php: Refactor to have the different versions as separate files This should enable easier auto updates of the packages.
2020-11-04 17:59:02 +00:00
in generic
Copy permalink