BoomMicrophone/nixpkgs-suyu
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
nixpkgs-suyu/pkgs/development/interpreters/php/default.nix

292 lines
11 KiB
Nix
Raw Normal View History

nixos/php: Move the pcre tests to the php test attribute
2020-03-31 19:06:04 +02:00
# We have tests for PCRE and PHP-FPM in nixos/tests/php/ or
# both in the same attribute named nixosTests.php
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 13:55:57 +02:00
{ callPackage, lib, stdenv }@_args:
php: Use callPackages
2015-08-11 13:13:28 +02: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 17:41:48 +02:00
let
php: Use callPackages
2015-08-11 13:13:28 +02:00
generic =
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 13:55:57 +02:00
{ callPackage, lib, stdenv, config, fetchurl, makeWrapper
, symlinkJoin, writeText, autoconf, automake, bison, flex, libtool
, pkgconfig, re2c, apacheHttpd, libargon2, libxml2, pcre, pcre2
, systemd, valgrind
, version
, sha256
, extraPatches ? []
, defaultPhpExtensions
# Sapi flags
, cgiSupport ? config.php.cgi or true
, cliSupport ? config.php.cli or true
, fpmSupport ? config.php.fpm or true
, pearSupport ? config.php.pear or true
, pharSupport ? config.php.phar or true
, phpdbgSupport ? config.php.phpdbg or true
# Misc flags
, apxs2Support ? config.php.apxs2 or (!stdenv.isDarwin)
, argon2Support ? config.php.argon2 or true
, cgotoSupport ? config.php.cgoto or false
, embedSupport ? config.php.embed or false
, ipv6Support ? config.php.ipv6 or true
, systemdSupport ? config.php.systemd or stdenv.isLinux
, valgrindSupport ? config.php.valgrind or true
, ztsSupport ? (config.php.zts or false) || (apxs2Support)
}@args:
let
self = generic args;
php-packages = (callPackage ../../../top-level/php-packages.nix {
php = self;
phpWithExtensions = self.withExtensions defaultPhpExtensions;
});
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 23:31:56 +02: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 (
{ extensions ? ({...}: []), 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 13:55:57 +02: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 22:52:51 +02: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 13:55:57 +02:00
php-packages = (callPackage ../../../top-level/php-packages.nix {
inherit php 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 23:31:56 +02:00
allExtensionFunctions = prevExtensionFunctions ++ [ extensions ];
enabledExtensions =
builtins.foldl'
(state: f:
f { enabled = state; all = php-packages.extensions; })
[]
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 13:55:57 +02:00
getExtName = ext: lib.removePrefix "php-" (builtins.parseDrvName ext.name).name;
# 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;
type = "${lib.optionalString (ext.zendExtension or false) "zend_"}extension";
in
lib.nameValuePair extName {
text = "${type}=${ext}/lib/php/extensions/${extName}.so";
deps = lib.optionals (ext ? internalDeps)
(map getExtName ext.internalDeps);
})
enabledExtensions);
extNames = map getExtName enabledExtensions;
extraInit = writeText "custom-php.ini" ''
${lib.concatStringsSep "\n"
(lib.textClosureList extensionTexts extNames)}
${extraConfig}
'';
phpWithExtensions = symlinkJoin rec {
name = "php-with-extensions-${version}";
inherit (php) version;
nativeBuildInputs = [ makeWrapper ];
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 23:31:56 +02:00
buildEnv = mkBuildEnv allArgs allExtensionFunctions;
withExtensions = mkWithExtensions allArgs 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 13:55:57 +02:00
inherit (php-packages) packages extensions;
};
paths = [ php ];
postBuild = ''
cp ${extraInit} $out/lib/custom-php.ini
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
'';
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 21:48:37 +02: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 13:55:57 +02: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 23:31:56 +02: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 13:55:57 +02:00
pcre' = if (lib.versionAtLeast version "7.3") then pcre2 else pcre;
in
stdenv.mkDerivation {
pname = "php";
inherit version;
enableParallelBuilding = true;
nativeBuildInputs = [ autoconf automake bison flex libtool pkgconfig re2c ];
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"
++ lib.optional pearSupport [ "--with-pear=$(out)/lib/php/pear" "--enable-xml" "--with-libxml" ]
++ lib.optional (pearSupport && (lib.versionOlder version "7.4")) "--enable-libxml"
++ 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}"
++ lib.optional ztsSupport "--enable-maintainer-zts"
;
hardeningDisable = [ "bindnow" ];
preConfigure = ''
# Don't record the configure flags since this causes unnecessary
# runtime dependencies
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
./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 23:31:56 +02:00
buildEnv = mkBuildEnv {} [];
withExtensions = mkWithExtensions {} [];
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 13:55:57 +02:00
inherit (php-packages) packages extensions;
};
meta = with stdenv.lib; {
description = "An HTML-embedded scripting language";
homepage = "https://www.php.net/";
license = licenses.php301;
maintainers = with maintainers; [ globin etu ma27 ];
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 22:37:22 +01:00
};
php: add `buildEnv` function for additional config on the CLI SAPI Initially discussed in #55460. This patch adds a `buildEnv` function to `php` that has the following features: * `php.buildEnv { extraConfig = /* ... */; }` to specify custom `php.ini` args for the CLI. * `php.buildEnv { exts = phpPackages: [phpPackages.apcu] }` to create a PHP interpreter for the CLI with the `apcu` extension.
2020-02-06 20:05:34 +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 13:55:57 +02:00
php72base = callPackage generic (_args // {
php72: 7.2.28 -> 7.2.29 Changelog: https://www.php.net/ChangeLog-7.php#7.2.29
2020-04-05 22:06:30 +02:00
version = "7.2.29";
sha256 = "08xry2fgqgg8s0ym1hh11wkbr36av3zq1bn4krbciw1b7x8gb8ga";
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 13:55:57 +02:00
defaultPhpExtensions = defaultPhpExtensionsWithHash;
php: Refactor so we can upgrade PHP per platform (#47162) This way we don't need to disable flags etc by platform and can still backport new versions to stable for linux even if there's a bug or something in the darwin build.
2018-09-22 20:22:57 +02:00
php: align Darwin and Linux versions again Instead of pinning Darwin to older versions, add small patches to configure.in (7.1) / configure.ac (7.2) to fix the build of the intl extension on recent PHP versions on Darwin. fix-paths-php7.patch also required changes -- since we now run autoconf at build time (through ./buildconf), it needs to patch the input .m4 files instead of ./configure directly.
2018-11-27 01:39:20 +01:00
# https://bugs.php.net/bug.php?id=76826
php: get rid of `with lib;` used on entire file
2020-03-15 17:51:28 +01:00
extraPatches = lib.optional stdenv.isDarwin ./php72-darwin-isfinite.patch;
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 13:55:57 +02:00
});
php: init at 7.3.0
2018-12-08 18:10:11 +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 13:55:57 +02:00
php73base = callPackage generic (_args // {
php73: 7.3.15 -> 7.3.16 Changelog: https://www.php.net/ChangeLog-7.php#7.3.16
2020-04-05 22:05:57 +02:00
version = "7.3.16";
sha256 = "0bh499v9dfgh9k51w4rird1slb9rh9whp5h37fb84c98d992s1xq";
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 13:55:57 +02:00
defaultPhpExtensions = defaultPhpExtensionsWithHash;
php: fix bug 71041
2018-12-10 10:23:56 +01:00
php: fix build php 7.3 in Darwin
2018-12-10 10:34:35 +01:00
# https://bugs.php.net/bug.php?id=76826
php: get rid of `with lib;` used on entire file
2020-03-15 17:51:28 +01:00
extraPatches = lib.optional stdenv.isDarwin ./php73-darwin-isfinite.patch;
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 13:55:57 +02:00
});
php74: init at 7.4.0RC6
2019-11-21 22:19:01 +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 13:55:57 +02:00
php74base = callPackage generic (_args // {
php74: 7.4.3 -> 7.4.4 Changelog: https://www.php.net/ChangeLog-7.php#7.4.4
2020-04-05 22:05:16 +02:00
version = "7.4.4";
sha256 = "17w2m4phhpj76x5fx67vgjrlkcczqvky3f5in1kjg2pch90qz3ih";
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 13:55:57 +02:00
inherit defaultPhpExtensions;
});
php: init phpXYbase packages and make the default php extended by default Also, add opcache to default extensions since it significantly increases PHP's performance and is by default enabled on Debian based distributions. Not having it enabled by default results in a puzzling performance loss for anyone attempting to migrate from Debian/Ubuntu to NixOS who is unaware of this. Therefore, enable it by default. /talyz
2020-03-22 18:58:23 +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 23:31:56 +02:00
defaultPhpExtensions = { all, ... }: with all; ([
php: Add withExtensions as a simpler alternative to buildEnv
2020-04-03 18:18:36 +02:00
bcmath calendar curl ctype dom exif fileinfo filter ftp gd
gettext gmp iconv intl json ldap mbstring mysqli mysqlnd opcache
openssl pcntl pdo pdo_mysql pdo_odbc pdo_pgsql pdo_sqlite pgsql
posix readline session simplexml sockets soap sodium sqlite3
tokenizer xmlreader xmlwriter zip zlib
] ++ lib.optionals (!stdenv.isDarwin) [ imap ]);
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 23:31:56 +02:00
defaultPhpExtensionsWithHash = { all, ... }:
(defaultPhpExtensions { inherit all; }) ++ [ all.hash ];
php: Add missing hash extension to php < 7.4
2020-04-03 18:55:03 +02:00
php: Add withExtensions as a simpler alternative to buildEnv
2020-04-03 18:18:36 +02:00
php74 = php74base.withExtensions defaultPhpExtensions;
php: Add missing hash extension to php < 7.4
2020-04-03 18:55:03 +02:00
php73 = php73base.withExtensions defaultPhpExtensionsWithHash;
php72 = php72base.withExtensions defaultPhpExtensionsWithHash;
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 22:37:22 +01:00
in {
inherit php72base php73base php74base php72 php73 php74;
php: Use callPackages
2015-08-11 13:13:28 +02:00
}
Reference in a new issue Copy permalink