From b2deabed282fb525913e4b54c004fbdea60d0415 Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 15:51:45 +0100 Subject: [PATCH 01/16] Update CHANGELOG for 5.4.17 --- CHANGELOG-5.4.md | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/CHANGELOG-5.4.md b/CHANGELOG-5.4.md index 378f31473a4c5..ace18524fa969 100644 --- a/CHANGELOG-5.4.md +++ b/CHANGELOG-5.4.md @@ -7,6 +7,41 @@ in 5.4 minor versions. To get the diff for a specific change, go to https://github.com/symfony/symfony/commit/XXX where XXX is the change hash To get the diff between two versions, go to https://github.com/symfony/symfony/compare/v5.4.0...v5.4.1 +* 5.4.17 (2022-12-28) + + * bug #48787 [PhpUnitBridge] Use verbose deprecation output for quiet types only when it reaches the threshold (ogizanagi) + * bug #48784 [Console] Correctly overwrite progressbars with different line count per step (ncharalampidis) + * bug #48801 [Form] Make `ButtonType` handle `form_attr` option (MatTheCat) + * bug #48791 [DependencyInjection] Fix deduplicating service instances in circular graphs (nicolas-grekas) + * bug #48771 [CssSelector] Fix escape patterns (fancyweb) + * bug #48711 [Cache] RedisTrait::createConnection does not pass auth value from redis sentinel cluster DSN (evgkord) + * bug #48724 [VarExporter] Fix exporting classes with __unserialize() but not __serialize() (fancyweb) + * bug #48746 [Validator] Fix IBAN format for Tunisia and Mauritania (smelesh) + * bug #48738 [Workflow] Allow spaces in place names so the PUML dump doesn't break (Kamil Musial) + * bug #48718 Compatibility with doctrine/annotations 2 (derrabus) + * bug #48651 [HttpKernel] AbstractSessionListener should not override the cache lifetime for private responses (rodmen) + * bug #48591 [DependencyInjection] Shared private services becomes public after a public service is accessed (alexpott) + * bug #48126 [Mailer] Include all transports' debug messages in RoundRobin transport exception (mixdf) + * bug #48635 [HttpFoundation] Use relative timestamps with MemcachedSessionHandler (tvlooy) + * bug #47979 [Cache] Fix dealing with ext-redis' multi/exec returning a bool (João Nogueira) + * bug #48612 [Messenger] [Amqp] Added missing rpc_timeout option (lyrixx) + * bug #48233 [Serializer] Prevent `GetSetMethodNormalizer` from creating invalid magic method call (klaussilveira) + * bug #48628 [HttpFoundation] Fix dumping array cookies (nicolas-grekas) + * bug #48048 [WebProfilerBundle] Fix dump header not being displayed (HypeMC) + * bug #47836 [HttpClient] TraceableHttpClient: increase decorator's priority (adpeyre) + * bug #48259 [FrameworkBundle] Allow configuring `framework.exceptions` with a config builder (MatTheCat) + * bug #48314 [Mime] Fix MessagePart serialization (Amunak) + * bug #48331 [Yaml] fix dumping top-level tagged values (xabbuh) + * bug #48615 Fix getting the name of closures on PHP 8.1.11+ (nicolas-grekas) + * bug #48618 [ErrorHandler] [DebugClassLoader] Fix some new return types support (fancyweb) + * bug #48421 [HttpFoundation] IPv4-mapped IPv6 addresses incorrectly rejected (bonroyage) + * bug #48501 [RateLimiter] Add `int` to `Reservation::wait()` (DaRealFreak) + * bug #48359 [VarDumper] Ignore \Error in __debugInfo() (fancyweb) + * bug #48482 [DependencyInjection] Revert "bug #48027 Don't autoconfigure tag when it's already set with attributes" (nicolas-grekas) + * bug #48335 [TwigBridge] Amend `MoneyType` twig to include a space (mogilvie) + * bug #48046 [WebProfilerBundle] Remove redundant code from logger template (HypeMC) + * bug #48292 [Security] [LoginLink] Throw InvalidLoginLinkException on missing parameter (MatTheCat) + * 5.4.16 (2022-11-28) * bug #48333 [Yaml] parse unquoted digits in tag values as integers (xabbuh) From 264ffd4157bfd1d13b7f293773903643233345d5 Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 15:51:51 +0100 Subject: [PATCH 02/16] Update CONTRIBUTORS for 5.4.17 --- CONTRIBUTORS.md | 94 +++++++++++++++++++++++++++++++------------------ 1 file changed, 60 insertions(+), 34 deletions(-) diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md index b136e74da6266..94862ab99db42 100644 --- a/CONTRIBUTORS.md +++ b/CONTRIBUTORS.md @@ -23,8 +23,8 @@ The Symfony Connect username in parenthesis allows to get more information - Victor Berchet (victor) - Yonel Ceruto (yonelceruto) - Tobias Nyholm (tobias) - - Javier Eguiluz (javier.eguiluz) - Oskar Stark (oskarstark) + - Javier Eguiluz (javier.eguiluz) - Ryan Weaver (weaverryan) - Johannes S (johannes) - Jakub Zalas (jakubzalas) @@ -38,12 +38,12 @@ The Symfony Connect username in parenthesis allows to get more information - Joseph Bielawski (stloyd) - Drak (drak) - Abdellatif Ait boudad (aitboudad) - - Lukas Kahwe Smith (lsmith) - Jan Schädlich (jschaedl) - - Martin Hasoň (hason) + - Lukas Kahwe Smith (lsmith) - Jérôme Tamarelle (gromnan) - - Jeremy Mikola (jmikola) + - Martin Hasoň (hason) - Kevin Bond (kbond) + - Jeremy Mikola (jmikola) - Jean-François Simon (jfsimon) - Benjamin Eberlei (beberlei) - Igor Wiedler @@ -57,8 +57,9 @@ The Symfony Connect username in parenthesis allows to get more information - Grégoire Paris (greg0ire) - Gabriel Ostrolucký (gadelat) - Jonathan Wage (jwage) - - David Maicher (dmaicher) - Titouan Galopin (tgalopin) + - David Maicher (dmaicher) + - Alexandre Daubois (alexandre-daubois) - Alexandre Salomé (alexandresalome) - William DURAND - Alexander Schranz (alexander-schranz) @@ -71,16 +72,17 @@ The Symfony Connect username in parenthesis allows to get more information - Alexander Mols (asm89) - Gábor Egyed (1ed) - Francis Besset (francisbesset) - - Alexandre Daubois (alexandre-daubois) - Vasilij Dusko | CREATION - Bulat Shakirzyanov (avalanche123) - Iltar van der Berg - Miha Vrhovnik (mvrhov) - Mathieu Piot (mpiot) - Saša Stamenković (umpirsky) + - Antoine Lamirault - Alex Pott - - Guilhem N (guilhemn) - Vincent Langlet (deviling) + - Mathieu Lechat (mat_the_cat) + - Guilhem N (guilhemn) - Vladimir Reznichenko (kalessil) - Sarah Khalil (saro0h) - Konstantin Kudryashov (everzet) @@ -89,7 +91,6 @@ The Symfony Connect username in parenthesis allows to get more information - Eriksen Costa - Florin Patan (florinpatan) - Peter Rehm (rpet) - - Mathieu Lechat (mat_the_cat) - Henrik Bjørnskov (henrikbjorn) - David Buchmann (dbu) - Konstantin Myakshin (koc) @@ -106,7 +107,6 @@ The Symfony Connect username in parenthesis allows to get more information - Issei Murasawa (issei_m) - Fran Moreno (franmomu) - Malte Schlüter (maltemaltesich) - - Antoine Lamirault - Vasilij Dusko - Denis (yethee) - Arnout Boks (aboks) @@ -136,10 +136,11 @@ The Symfony Connect username in parenthesis allows to get more information - Konstantin.Myakshin - Rokas Mikalkėnas (rokasm) - Arman Hosseini (arman) + - Saif Eddin Gmati (azjezz) - Arnaud Le Blanc (arnaud-lb) - Maxime STEINHAUSSER - Peter Kokot (maastermedia) - - Saif Eddin Gmati (azjezz) + - jeremyFreeAgent (jeremyfreeagent) - Ahmed TAILOULOUTE (ahmedtai) - Simon Berger - Tim Nagel (merk) @@ -158,7 +159,6 @@ The Symfony Connect username in parenthesis allows to get more information - lenar - Jesse Rushlow (geeshoe) - Théo FIDRY - - jeremyFreeAgent (jeremyfreeagent) - Jeroen Spee (jeroens) - Michael Babker (mbabker) - Włodzimierz Gajda (gajdaw) @@ -170,6 +170,7 @@ The Symfony Connect username in parenthesis allows to get more information - Olivier Dolbeau (odolbeau) - Florian Voutzinos (florianv) - zairig imad (zairigimad) + - Hugo Alliaume (kocal) - Colin Frei - Christopher Hertel (chertel) - Javier Spagnoletti (phansys) @@ -193,7 +194,6 @@ The Symfony Connect username in parenthesis allows to get more information - Baptiste Leduc (korbeil) - Marco Pivetta (ocramius) - Robert Schönthal (digitalkaoz) - - Hugo Alliaume (kocal) - Võ Xuân Tiến (tienvx) - fd6130 (fdtvui) - Tigran Azatyan (tigranazatyan) @@ -232,6 +232,7 @@ The Symfony Connect username in parenthesis allows to get more information - Michael Voříšek - Farhad Safarov (safarov) - SpacePossum + - Nicolas Philippe (nikophil) - Pablo Godel (pgodel) - Denis Brumann (dbrumann) - Romaric Drigon (romaricdrigon) @@ -246,8 +247,9 @@ The Symfony Connect username in parenthesis allows to get more information - David Prévot - Vincent Touzet (vincenttouzet) - Fabien Bourigault (fbourigault) + - soyuka + - Sergey (upyx) - Jérémy Derussé - - Nicolas Philippe (nikophil) - Hubert Lenoir (hubert_lenoir) - Florent Mata (fmata) - mcfedr (mcfedr) @@ -257,13 +259,13 @@ The Symfony Connect username in parenthesis allows to get more information - Sokolov Evgeniy (ewgraf) - Stadly - Justin Hileman (bobthecow) + - Tom Van Looy (tvlooy) - Niels Keurentjes (curry684) - Vyacheslav Pavlov - Richard Shank (iampersistent) + - Thomas Landauer (thomas-landauer) - Andre Rømcke (andrerom) - Dmitrii Poddubnyi (karser) - - soyuka - - Sergey (upyx) - Rouven Weßling (realityking) - BoShurik - Zmey @@ -275,7 +277,6 @@ The Symfony Connect username in parenthesis allows to get more information - Ben Hakim - Sylvain Fabre (sylfabre) - Filippo Tessarotto (slamdunk) - - Tom Van Looy (tvlooy) - 77web - Bohan Yang (brentybh) - Bastien Jaillot (bastnic) @@ -288,7 +289,6 @@ The Symfony Connect username in parenthesis allows to get more information - Jonathan Ingram - Artur Kotyrba - Tyson Andre - - Thomas Landauer (thomas-landauer) - GDIBass - Samuel NELA (snela) - dFayet @@ -324,6 +324,7 @@ The Symfony Connect username in parenthesis allows to get more information - Jonathan Scheiber (jmsche) - DQNEO - Andrii Bodnar + - gnito-org - Artem (artemgenvald) - ivan - Sergey Belyshkin (sbelyshkin) @@ -351,6 +352,7 @@ The Symfony Connect username in parenthesis allows to get more information - Clara van Miert - Martin Auswöger - Alexander Menshchikov + - Marcin Sikoń (marphi) - Stepan Anchugov (kix) - bronze1man - sun (sun) @@ -368,6 +370,7 @@ The Symfony Connect username in parenthesis allows to get more information - Pierre Minnieur (pminnieur) - Kyle - Dominique Bongiraud + - Romain Monteil (ker0x) - Hidde Wieringa (hiddewie) - Christopher Davis (chrisguitarguy) - Lukáš Holeczy (holicz) @@ -387,7 +390,7 @@ The Symfony Connect username in parenthesis allows to get more information - Daniel STANCU - Markus Fasselt (digilist) - Maxime Veber (nek-) - - Marcin Sikoń (marphi) + - Oleksiy (alexndlm) - Sullivan SENECHAL (soullivaneuh) - Rui Marinho (ruimarinho) - Marc Weistroff (futurecat) @@ -409,7 +412,6 @@ The Symfony Connect username in parenthesis allows to get more information - Craig Duncan (duncan3dc) - Mantis Development - Pablo Lozano (arkadis) - - Romain Monteil (ker0x) - quentin neyrat (qneyrat) - Antonio Jose Cerezo (ajcerezo) - Marcin Szepczynski (czepol) @@ -480,6 +482,7 @@ The Symfony Connect username in parenthesis allows to get more information - Quynh Xuan Nguyen (seriquynh) - Ray - Philipp Cordes (corphi) + - Yannick Ihmels (ihmels) - Andrii Dembitskyi - Chekote - bhavin (bhavin4u) @@ -508,6 +511,7 @@ The Symfony Connect username in parenthesis allows to get more information - Josip Kruslin (jkruslin) - Giorgio Premi - renanbr + - Maxim Dovydenok (shiftby) - Sébastien Lavoie (lavoiesl) - Alex Rock (pierstoval) - Wodor Wodorski @@ -563,7 +567,6 @@ The Symfony Connect username in parenthesis allows to get more information - Grégoire Passault (gregwar) - Jerzy Zawadzki (jzawadzki) - Ismael Ambrosi (iambrosi) - - Yannick Ihmels (ihmels) - Saif Eddin G - Emmanuel BORGES (eborges78) - siganushka (siganushka) @@ -604,6 +607,7 @@ The Symfony Connect username in parenthesis allows to get more information - Tri Pham (phamuyentri) - marie - Erkhembayar Gantulga (erheme318) + - Philippe SEGATORI (tigitz) - Fractal Zombie - Gunnstein Lye (glye) - Thomas Talbot (ioni) @@ -622,7 +626,6 @@ The Symfony Connect username in parenthesis allows to get more information - Ricard Clau (ricardclau) - Dmitrii Tarasov (dtarasov) - Philipp Kolesnikov - - Maxim Dovydenok (shiftby) - Carlos Pereira De Amorim (epitre) - Rodrigo Aguilera - Roumen Damianoff @@ -679,7 +682,6 @@ The Symfony Connect username in parenthesis allows to get more information - Tomasz Kusy - Jakub Kucharovic (jkucharovic) - Kristen Gilden - - Oleksiy (alexndlm) - Robbert Klarenbeek (robbertkl) - Eric Masoero (eric-masoero) - Michael Lutz @@ -827,6 +829,7 @@ The Symfony Connect username in parenthesis allows to get more information - Steffen Roßkamp - Alexandru Furculita (afurculita) - Michel Salib (michelsalib) + - Quentin Dequippe (qdequippe) - Valentin Jonovs - geoffrey - Bastien DURAND (deamon) @@ -839,12 +842,12 @@ The Symfony Connect username in parenthesis allows to get more information - Tobias Bönner - Berny Cantos (xphere81) - Mátyás Somfai (smatyas) + - Simon Leblanc (leblanc_simon) - Jan Schumann - Matheo Daninos (mathdns) - Niklas Fiekas - Mark Challoner (markchalloner) - Markus Bachmann (baachi) - - Philippe SEGATORI (tigitz) - Roger Guasch (rogerguasch) - Luis Tacón (lutacon) - Alex Hofbauer (alexhofbauer) @@ -858,6 +861,7 @@ The Symfony Connect username in parenthesis allows to get more information - Arturs Vonda - Xavier Briand (xavierbriand) - Daniel Badura + - Angelov Dejan (angelov) - vagrant - Asier Illarramendi (doup) - AKeeman (akeeman) @@ -873,6 +877,7 @@ The Symfony Connect username in parenthesis allows to get more information - Vitaliy Tverdokhlib (vitaliytv) - Ariel Ferrandini (aferrandini) - Niklas Keller + - BASAK Semih (itsemih) - Dirk Pahl (dirkaholic) - Cédric Lombardot (cedriclombardot) - Jonas Flodén (flojon) @@ -900,7 +905,9 @@ The Symfony Connect username in parenthesis allows to get more information - ReenExe - Fabian Lange (codingfabian) - Yoshio HANAWA + - Sergey Melesh (sergex) - Toon Verwerft (veewee) + - Jiri Barous - Gert de Pagter - Sebastian Bergmann - Miroslav Šustek (sustmi) @@ -1003,6 +1010,7 @@ The Symfony Connect username in parenthesis allows to get more information - Zach Badgett (zachbadgett) - Loïc Faugeron - Aurélien Fredouelle + - Jordane VASPARD (elementaire) - Pavel Campr (pcampr) - Forfarle (forfarle) - Johnny Robeson (johnny) @@ -1019,6 +1027,7 @@ The Symfony Connect username in parenthesis allows to get more information - Jannik Zschiesche - Jan Ole Behrens (deegital) - Mantas Var (mvar) + - Florent Morselli (spomky_) - Yann LUCAS (drixs6o9) - Sebastian Krebs - Htun Htun Htet (ryanhhh91) @@ -1040,7 +1049,6 @@ The Symfony Connect username in parenthesis allows to get more information - Aurélien MARTIN - Malte Schlüter - Jules Matsounga (hyoa) - - Quentin Dequippe (qdequippe) - Yewhen Khoptynskyi (khoptynskyi) - Jérôme Nadaud (jnadaud) - wuchen90 @@ -1160,6 +1168,7 @@ The Symfony Connect username in parenthesis allows to get more information - RevZer0 (rav) - remieuronews - Marek Binkowski + - Benjamin Schoch (bschoch) - Rostyslav Kinash - Andrey Lebedev (alebedev) - Cristoforo Cervino (cristoforocervino) @@ -1180,7 +1189,6 @@ The Symfony Connect username in parenthesis allows to get more information - Quentin Moreau (sheitak) - Stefan Warman (warmans) - Bert Ramakers - - Angelov Dejan (angelov) - Tristan Maindron (tmaindron) - Behnoush Norouzali (behnoush) - Marc Duboc (icemad) @@ -1222,7 +1230,6 @@ The Symfony Connect username in parenthesis allows to get more information - Evgeny Efimov (edefimov) - John VanDeWeghe - Oleg Mifle - - gnito-org - Michael Devery (mickadoo) - Loïc Ovigne (oviglo) - Antoine Corcy @@ -1250,6 +1257,7 @@ The Symfony Connect username in parenthesis allows to get more information - Benjamin Zikarsky (bzikarsky) - Jason Schilling (chapterjason) - Nathan PAGE (nathix) + - Rodrigo Méndez (rodmen) - sl_toto (sl_toto) - Marek Pietrzak (mheki) - Dmitrii Lozhkin @@ -1291,6 +1299,7 @@ The Symfony Connect username in parenthesis allows to get more information - Konstantin Bogomolov - Mark Spink - Cesar Scur (cesarscur) + - Maximilian Beckers (maxbeckers) - Kevin (oxfouzer) - Paweł Wacławczyk (pwc) - Sagrario Meneses @@ -1314,7 +1323,6 @@ The Symfony Connect username in parenthesis allows to get more information - rtek - Maxime AILLOUD (mailloud) - Richard van den Brand (ricbra) - - Sergey Melesh (sergex) - mohammadreza honarkhah - develop - flip111 @@ -1359,6 +1367,7 @@ The Symfony Connect username in parenthesis allows to get more information - Harald Tollefsen - Arend-Jan Tetteroo - Mbechezi Nawo + - Klaus Silveira (klaussilveira) - Andre Eckardt (korve) - Michael Piecko (michael.piecko) - Osayawe Ogbemudia Terry (terdia) @@ -1391,7 +1400,6 @@ The Symfony Connect username in parenthesis allows to get more information - Serhiy Lunak (slunak) - Wojciech Błoszyk (wbloszyk) - Jeroen van den Enden (endroid) - - Jiri Barous - abunch - tamcy - Mikko Pesari @@ -1571,6 +1579,7 @@ The Symfony Connect username in parenthesis allows to get more information - Stefano Degenkamp (steef) - James Michael DuPont - kor3k kor3k (kor3k) + - Rustam Bakeev (nommyde) - Eric Schildkamp - agaktr - Vincent CHALAMON @@ -1774,7 +1783,6 @@ The Symfony Connect username in parenthesis allows to get more information - Shin Ohno (ganchiku) - Jaap van Otterdijk (jaapio) - Kubicki Kamil (kubik) - - Simon Leblanc (leblanc_simon) - Vladislav Nikolayev (luxemate) - Martin Mandl (m2mtech) - Maxime Pinot (maximepinot) @@ -1919,7 +1927,6 @@ The Symfony Connect username in parenthesis allows to get more information - Ronny (big-r) - Anton (bonio) - Alexandre Fiocre (demos77) - - Jordane VASPARD (elementaire) - Erwan Nader (ernadoo) - Faizan Akram Dar (faizanakram) - Greg Szczotka (greg606) @@ -1971,7 +1978,6 @@ The Symfony Connect username in parenthesis allows to get more information - Daniel Alejandro Castro Arellano (lexcast) - Aleksandar Dimitrov (netbull) - Gary Houbre (thegarious) - - Florent Morselli - Thomas Jarrand - Baptiste Leduc (bleduc) - Antoine Bluchet (soyuka) @@ -1993,6 +1999,7 @@ The Symfony Connect username in parenthesis allows to get more information - The Whole Life to Learn - Mikkel Paulson - ergiegonzaga + - kurozumi (kurozumi) - Liverbool (liverbool) - Dalibor Karlović - Sam Malone @@ -2000,6 +2007,7 @@ The Symfony Connect username in parenthesis allows to get more information - Chris Jones (leek) - neghmurken - stefan.r + - Allison Guilhem (a_guilhem) - xaav - Jean-Christophe Cuvelier [Artack] - Mahmoud Mostafa (mahmoud) @@ -2045,6 +2053,7 @@ The Symfony Connect username in parenthesis allows to get more information - Zachary Tong (polyfractal) - Ashura - Hryhorii Hrebiniuk + - Alex Plekhanov - johnstevenson - hamza - dantleech @@ -2091,6 +2100,7 @@ The Symfony Connect username in parenthesis allows to get more information - Mert Simsek (mrtsmsk0) - Lin Clark - Jeremy David (jeremy.david) + - Michał Marcin Brzuchalski (brzuchal) - Jordi Rejas - Troy McCabe - Ville Mattila @@ -2137,6 +2147,7 @@ The Symfony Connect username in parenthesis allows to get more information - Hugo Fonseca (fonsecas72) - Martynas Narbutas - Bailey Parker + - curlycarla2004 - Antanas Arvasevicius - Kris Kelly - Eddie Abou-Jaoude (eddiejaoude) @@ -2156,6 +2167,7 @@ The Symfony Connect username in parenthesis allows to get more information - HellFirePvP - Maximilian Ruta (deltachaos) - Jakub Sacha + - Kamil Musial - Olaf Klischat - orlovv - Claude Dioudonnat @@ -2173,6 +2185,7 @@ The Symfony Connect username in parenthesis allows to get more information - Rodrigo Díez Villamuera (rodrigodiez) - Stephen Clouse - e-ivanov + - Abderrahman DAIF (death_maker) - Yann Rabiller (einenlum) - Jochen Bayer (jocl) - Patrick Carlo-Hickman @@ -2182,6 +2195,7 @@ The Symfony Connect username in parenthesis allows to get more information - Gordienko Vladislav - Ener-Getick - Viacheslav Sychov + - Nicolas Sauveur (baishu) - Helmut Hummel (helhum) - Matt Brunt - Carlos Ortega Huetos @@ -2199,6 +2213,7 @@ The Symfony Connect username in parenthesis allows to get more information - Artem Kolesnikov (tyomo4ka) - Gustavo Adrian - Yannick + - Kuzia - Vladimir Luchaninov (luchaninov) - spdionis - rchoquet @@ -2206,6 +2221,7 @@ The Symfony Connect username in parenthesis allows to get more information - gitlost - Taras Girnyk - Sergio + - Mehrdad - Eduardo García Sanz (coma) - fduch (fduch) - David de Boer (ddeboer) @@ -2271,6 +2287,7 @@ The Symfony Connect username in parenthesis allows to get more information - AlbinoDrought - Jay Klehr - Sergey Yuferev + - Monet Emilien - Tobias Stöckler - Mario Young - martkop26 @@ -2327,7 +2344,6 @@ The Symfony Connect username in parenthesis allows to get more information - Balázs Benyó (duplabe) - Erika Heidi Reinaldo (erikaheidi) - Marc J. Schmidt (marcjs) - - Maximilian Beckers (maxbeckers) - Sebastian Schwarz - karolsojko - Marco Jantke @@ -2472,7 +2488,6 @@ The Symfony Connect username in parenthesis allows to get more information - Nouhail AL FIDI (alfidi) - Fabian Steiner (fabstei) - Felipy Amorim (felipyamorim) - - Klaus Silveira (klaussilveira) - Michael Lively (mlivelyjr) - Abderrahim (phydev) - Attila Bukor (r1pp3rj4ck) @@ -2487,7 +2502,6 @@ The Symfony Connect username in parenthesis allows to get more information - AnrDaemon - Charly Terrier (charlypoppins) - Emre Akinci (emre) - - Rustam Bakeev (nommyde) - psampaz (psampaz) - Maxwell Vandervelde - kaywalker @@ -2560,6 +2574,7 @@ The Symfony Connect username in parenthesis allows to get more information - Tiago Garcia (tiagojsag) - Artiom - Jakub Simon + - Brandon Antonio Lorenzo - Bouke Haarsma - mlievertz - Enrico Schultz @@ -2577,6 +2592,7 @@ The Symfony Connect username in parenthesis allows to get more information - Anton Sukhachev (mrsuh) - Marcel Siegert - ryunosuke + - Roy de Vos Burchart - Francisco Facioni (fran6co) - Iwan van Staveren (istaveren) - Povilas S. (povilas) @@ -2659,6 +2675,7 @@ The Symfony Connect username in parenthesis allows to get more information - Mike Francis - Nil Borodulia - Almog Baku (almogbaku) + - Arrakis (arrakis) - Benjamin Schultz (bschultz) - Gerd Christian Kunze (derdu) - Ionel Scutelnicu (ionelscutelnicu) @@ -2735,6 +2752,7 @@ The Symfony Connect username in parenthesis allows to get more information - Steeve Titeca (stiteca) - Artem Lopata (bumz) - alex + - evgkord - Roman Orlov - Andreas Allacher - VolCh @@ -2754,6 +2772,7 @@ The Symfony Connect username in parenthesis allows to get more information - Julien Moulin (lizjulien) - Raito Akehanareru (raito) - Mauro Foti (skler) + - skmedix (skmedix) - Yannick Warnier (ywarnier) - Jörn Lang - Kevin Decherf @@ -2769,6 +2788,7 @@ The Symfony Connect username in parenthesis allows to get more information - Sam Ward - Hans N. Hjort - Walther Lalk + - victor-prdh - Adam - Ivo - Sören Bernstein @@ -2855,6 +2875,7 @@ The Symfony Connect username in parenthesis allows to get more information - Omar Yepez (oyepez003) - Jonny Schmid (schmidjon) - Götz Gottwald + - Adrien Peyre - Christoph Krapp - Nick Chiu - Robert Campbell @@ -2983,6 +3004,7 @@ The Symfony Connect username in parenthesis allows to get more information - Gabriel Moreira - Alexey Popkov - ChS + - Jannik Zschiesche - Alexis MARQUIS - Joseph Deray - Damian Sromek @@ -3032,6 +3054,7 @@ The Symfony Connect username in parenthesis allows to get more information - znerol - Christian Eikermann - Sergei Shitikov + - Steffen Keuper - Antonio Angelino - Pavel Golovin - Matt Fields @@ -3237,6 +3260,7 @@ The Symfony Connect username in parenthesis allows to get more information - Moritz Borgmann (mborgmann) - Matt Drollette (mdrollette) - Adam Monsen (meonkeys) + - Steffen Persch (n3o77) - Ala Eddine Khefifi (nayzo) - emilienbouard (neime) - Nicholas Byfleet (nickbyfleet) @@ -3264,6 +3288,7 @@ The Symfony Connect username in parenthesis allows to get more information - Schuyler Jager (sjager) - Volker (skydiablo) - Julien Sanchez (sumbobyboys) + - Sylvain BEISSIER (sylvain-beissier) - Ron Gähler (t-ronx) - Guillermo Gisinger (t3chn0r) - Tom Newby (tomnewbyau) @@ -3302,6 +3327,7 @@ The Symfony Connect username in parenthesis allows to get more information - Mark Topper - Romain - Xavier REN + - Kevin Meijer - max - Ahmad Mayahi (ahmadmayahi) - Mohamed Karnichi (amiral) From 88907a19201747d50b12374caf044c76bd708c24 Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 15:51:55 +0100 Subject: [PATCH 03/16] Update VERSION for 5.4.17 --- src/Symfony/Component/HttpKernel/Kernel.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Symfony/Component/HttpKernel/Kernel.php b/src/Symfony/Component/HttpKernel/Kernel.php index a783462b8c977..b7d516e41363f 100644 --- a/src/Symfony/Component/HttpKernel/Kernel.php +++ b/src/Symfony/Component/HttpKernel/Kernel.php @@ -78,12 +78,12 @@ abstract class Kernel implements KernelInterface, RebootableInterface, Terminabl */ private static $freshCache = []; - public const VERSION = '5.4.17-DEV'; + public const VERSION = '5.4.17'; public const VERSION_ID = 50417; public const MAJOR_VERSION = 5; public const MINOR_VERSION = 4; public const RELEASE_VERSION = 17; - public const EXTRA_VERSION = 'DEV'; + public const EXTRA_VERSION = ''; public const END_OF_MAINTENANCE = '11/2024'; public const END_OF_LIFE = '11/2025'; From 3502d7e90541139468077e27fb6273a24f9d77f4 Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 15:55:17 +0100 Subject: [PATCH 04/16] Bump Symfony version to 5.4.18 --- src/Symfony/Component/HttpKernel/Kernel.php | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Symfony/Component/HttpKernel/Kernel.php b/src/Symfony/Component/HttpKernel/Kernel.php index b7d516e41363f..75244b851e1fa 100644 --- a/src/Symfony/Component/HttpKernel/Kernel.php +++ b/src/Symfony/Component/HttpKernel/Kernel.php @@ -78,12 +78,12 @@ abstract class Kernel implements KernelInterface, RebootableInterface, Terminabl */ private static $freshCache = []; - public const VERSION = '5.4.17'; - public const VERSION_ID = 50417; + public const VERSION = '5.4.18-DEV'; + public const VERSION_ID = 50418; public const MAJOR_VERSION = 5; public const MINOR_VERSION = 4; - public const RELEASE_VERSION = 17; - public const EXTRA_VERSION = ''; + public const RELEASE_VERSION = 18; + public const EXTRA_VERSION = 'DEV'; public const END_OF_MAINTENANCE = '11/2024'; public const END_OF_LIFE = '11/2025'; From efd1eb632e6cdd27c23d6ddda90e4a5eeac3a33b Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 15:55:46 +0100 Subject: [PATCH 05/16] Update CHANGELOG for 6.0.17 --- CHANGELOG-6.0.md | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/CHANGELOG-6.0.md b/CHANGELOG-6.0.md index d0024faa6a47d..c2328862f0a62 100644 --- a/CHANGELOG-6.0.md +++ b/CHANGELOG-6.0.md @@ -7,6 +7,41 @@ in 6.0 minor versions. To get the diff for a specific change, go to https://github.com/symfony/symfony/commit/XXX where XXX is the change hash To get the diff between two versions, go to https://github.com/symfony/symfony/compare/v6.0.0...v6.0.1 +* 6.0.17 (2022-12-28) + + * bug #48787 [PhpUnitBridge] Use verbose deprecation output for quiet types only when it reaches the threshold (ogizanagi) + * bug #48784 [Console] Correctly overwrite progressbars with different line count per step (ncharalampidis) + * bug #48801 [Form] Make `ButtonType` handle `form_attr` option (MatTheCat) + * bug #48791 [DependencyInjection] Fix deduplicating service instances in circular graphs (nicolas-grekas) + * bug #48771 [CssSelector] Fix escape patterns (fancyweb) + * bug #48711 [Cache] RedisTrait::createConnection does not pass auth value from redis sentinel cluster DSN (evgkord) + * bug #48724 [VarExporter] Fix exporting classes with __unserialize() but not __serialize() (fancyweb) + * bug #48746 [Validator] Fix IBAN format for Tunisia and Mauritania (smelesh) + * bug #48738 [Workflow] Allow spaces in place names so the PUML dump doesn't break (Kamil Musial) + * bug #48718 Compatibility with doctrine/annotations 2 (derrabus) + * bug #48651 [HttpKernel] AbstractSessionListener should not override the cache lifetime for private responses (rodmen) + * bug #48591 [DependencyInjection] Shared private services becomes public after a public service is accessed (alexpott) + * bug #48126 [Mailer] Include all transports' debug messages in RoundRobin transport exception (mixdf) + * bug #48635 [HttpFoundation] Use relative timestamps with MemcachedSessionHandler (tvlooy) + * bug #47979 [Cache] Fix dealing with ext-redis' multi/exec returning a bool (João Nogueira) + * bug #48612 [Messenger] [Amqp] Added missing rpc_timeout option (lyrixx) + * bug #48233 [Serializer] Prevent `GetSetMethodNormalizer` from creating invalid magic method call (klaussilveira) + * bug #48628 [HttpFoundation] Fix dumping array cookies (nicolas-grekas) + * bug #48048 [WebProfilerBundle] Fix dump header not being displayed (HypeMC) + * bug #47836 [HttpClient] TraceableHttpClient: increase decorator's priority (adpeyre) + * bug #48259 [FrameworkBundle] Allow configuring `framework.exceptions` with a config builder (MatTheCat) + * bug #48314 [Mime] Fix MessagePart serialization (Amunak) + * bug #48331 [Yaml] fix dumping top-level tagged values (xabbuh) + * bug #48615 Fix getting the name of closures on PHP 8.1.11+ (nicolas-grekas) + * bug #48618 [ErrorHandler] [DebugClassLoader] Fix some new return types support (fancyweb) + * bug #48421 [HttpFoundation] IPv4-mapped IPv6 addresses incorrectly rejected (bonroyage) + * bug #48501 [RateLimiter] Add `int` to `Reservation::wait()` (DaRealFreak) + * bug #48359 [VarDumper] Ignore \Error in __debugInfo() (fancyweb) + * bug #48482 [DependencyInjection] Revert "bug #48027 Don't autoconfigure tag when it's already set with attributes" (nicolas-grekas) + * bug #48335 [TwigBridge] Amend `MoneyType` twig to include a space (mogilvie) + * bug #48046 [WebProfilerBundle] Remove redundant code from logger template (HypeMC) + * bug #48292 [Security] [LoginLink] Throw InvalidLoginLinkException on missing parameter (MatTheCat) + * 6.0.16 (2022-11-28) * bug #48333 [Yaml] parse unquoted digits in tag values as integers (xabbuh) From 826fe83d5c368aab7174697636675be6c36b3c16 Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 15:55:51 +0100 Subject: [PATCH 06/16] Update VERSION for 6.0.17 --- src/Symfony/Component/HttpKernel/Kernel.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Symfony/Component/HttpKernel/Kernel.php b/src/Symfony/Component/HttpKernel/Kernel.php index 25b69d132dd7d..34ebae503a27c 100644 --- a/src/Symfony/Component/HttpKernel/Kernel.php +++ b/src/Symfony/Component/HttpKernel/Kernel.php @@ -78,12 +78,12 @@ abstract class Kernel implements KernelInterface, RebootableInterface, Terminabl */ private static array $freshCache = []; - public const VERSION = '6.0.17-DEV'; + public const VERSION = '6.0.17'; public const VERSION_ID = 60017; public const MAJOR_VERSION = 6; public const MINOR_VERSION = 0; public const RELEASE_VERSION = 17; - public const EXTRA_VERSION = 'DEV'; + public const EXTRA_VERSION = ''; public const END_OF_MAINTENANCE = '01/2023'; public const END_OF_LIFE = '01/2023'; From d01f6d0f2607cb28289f915f4148b9160c6b9d8c Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 16:00:15 +0100 Subject: [PATCH 07/16] Bump Symfony version to 6.0.18 --- src/Symfony/Component/HttpKernel/Kernel.php | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Symfony/Component/HttpKernel/Kernel.php b/src/Symfony/Component/HttpKernel/Kernel.php index 34ebae503a27c..246b5eb57d741 100644 --- a/src/Symfony/Component/HttpKernel/Kernel.php +++ b/src/Symfony/Component/HttpKernel/Kernel.php @@ -78,12 +78,12 @@ abstract class Kernel implements KernelInterface, RebootableInterface, Terminabl */ private static array $freshCache = []; - public const VERSION = '6.0.17'; - public const VERSION_ID = 60017; + public const VERSION = '6.0.18-DEV'; + public const VERSION_ID = 60018; public const MAJOR_VERSION = 6; public const MINOR_VERSION = 0; - public const RELEASE_VERSION = 17; - public const EXTRA_VERSION = ''; + public const RELEASE_VERSION = 18; + public const EXTRA_VERSION = 'DEV'; public const END_OF_MAINTENANCE = '01/2023'; public const END_OF_LIFE = '01/2023'; From c5d65e5f485fbe28eb65f0c7c74a8e9e041af824 Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 16:00:36 +0100 Subject: [PATCH 08/16] Update CHANGELOG for 6.1.9 --- CHANGELOG-6.1.md | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/CHANGELOG-6.1.md b/CHANGELOG-6.1.md index 10ba1bca4466b..ec054deff3146 100644 --- a/CHANGELOG-6.1.md +++ b/CHANGELOG-6.1.md @@ -7,6 +7,47 @@ in 6.1 minor versions. To get the diff for a specific change, go to https://github.com/symfony/symfony/commit/XXX where XXX is the change hash To get the diff between two versions, go to https://github.com/symfony/symfony/compare/v6.1.0...v6.1.1 +* 6.1.9 (2022-12-28) + + * bug #48787 [PhpUnitBridge] Use verbose deprecation output for quiet types only when it reaches the threshold (ogizanagi) + * bug #48784 [Console] Correctly overwrite progressbars with different line count per step (ncharalampidis) + * bug #48801 [Form] Make `ButtonType` handle `form_attr` option (MatTheCat) + * bug #48791 [DependencyInjection] Fix deduplicating service instances in circular graphs (nicolas-grekas) + * bug #48771 [CssSelector] Fix escape patterns (fancyweb) + * bug #48711 [Cache] RedisTrait::createConnection does not pass auth value from redis sentinel cluster DSN (evgkord) + * bug #48724 [VarExporter] Fix exporting classes with __unserialize() but not __serialize() (fancyweb) + * bug #48746 [Validator] Fix IBAN format for Tunisia and Mauritania (smelesh) + * bug #48738 [Workflow] Allow spaces in place names so the PUML dump doesn't break (Kamil Musial) + * bug #48718 Compatibility with doctrine/annotations 2 (derrabus) + * bug #48681 [Console] Revert "bug #48089 Fix clear line with question in section (maxbeckers) (chalasr) + * bug #48651 [HttpKernel] AbstractSessionListener should not override the cache lifetime for private responses (rodmen) + * bug #48591 [DependencyInjection] Shared private services becomes public after a public service is accessed (alexpott) + * bug #48126 [Mailer] Include all transports' debug messages in RoundRobin transport exception (mixdf) + * bug #48089 [Console] Fix clear line with question in section (maxbeckers) + * bug #48602 [HtmlSanitizer] Fix HtmlSanitizer default configuration behavior for allowed schemes (Titouan Galopin) + * bug #48635 [HttpFoundation] Use relative timestamps with MemcachedSessionHandler (tvlooy) + * bug #47979 [Cache] Fix dealing with ext-redis' multi/exec returning a bool (João Nogueira) + * bug #48612 [Messenger] [Amqp] Added missing rpc_timeout option (lyrixx) + * bug #48233 [Serializer] Prevent `GetSetMethodNormalizer` from creating invalid magic method call (klaussilveira) + * bug #48628 [HttpFoundation] Fix dumping array cookies (nicolas-grekas) + * bug #48048 [WebProfilerBundle] Fix dump header not being displayed (HypeMC) + * bug #47836 [HttpClient] TraceableHttpClient: increase decorator's priority (adpeyre) + * bug #48259 [FrameworkBundle] Allow configuring `framework.exceptions` with a config builder (MatTheCat) + * bug #48314 [Mime] Fix MessagePart serialization (Amunak) + * bug #48331 [Yaml] fix dumping top-level tagged values (xabbuh) + * bug #48615 Fix getting the name of closures on PHP 8.1.11+ (nicolas-grekas) + * bug #48624 [ErrorHandler][HttpKernel] Fix reading the SYMFONY_IDE env var (nicolas-grekas) + * bug #48618 [ErrorHandler] [DebugClassLoader] Fix some new return types support (fancyweb) + * bug #48421 [HttpFoundation] IPv4-mapped IPv6 addresses incorrectly rejected (bonroyage) + * bug #48501 [RateLimiter] Add `int` to `Reservation::wait()` (DaRealFreak) + * bug #48359 [VarDumper] Ignore \Error in __debugInfo() (fancyweb) + * bug #48534 [FrameworkBundle] add `kernel.locale_aware` tag to `LocaleSwitcher` (kbond) + * bug #48482 [DependencyInjection] Revert "bug #48027 Don't autoconfigure tag when it's already set with attributes" (nicolas-grekas) + * bug #48346 [HttpKernel] In DateTimeValueResolver, convert previously defined date attribute to the expected class (GromNaN) + * bug #48335 [TwigBridge] Amend `MoneyType` twig to include a space (mogilvie) + * bug #48046 [WebProfilerBundle] Remove redundant code from logger template (HypeMC) + * bug #48292 [Security] [LoginLink] Throw InvalidLoginLinkException on missing parameter (MatTheCat) + * 6.1.8 (2022-11-28) * bug #48333 [Yaml] parse unquoted digits in tag values as integers (xabbuh) From 92bc1f65c672ea9d844c081bfaa6e0f7f79ea075 Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 16:00:40 +0100 Subject: [PATCH 09/16] Update VERSION for 6.1.9 --- src/Symfony/Component/HttpKernel/Kernel.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Symfony/Component/HttpKernel/Kernel.php b/src/Symfony/Component/HttpKernel/Kernel.php index 946ca05ad8533..22efec052530d 100644 --- a/src/Symfony/Component/HttpKernel/Kernel.php +++ b/src/Symfony/Component/HttpKernel/Kernel.php @@ -78,12 +78,12 @@ abstract class Kernel implements KernelInterface, RebootableInterface, Terminabl */ private static array $freshCache = []; - public const VERSION = '6.1.9-DEV'; + public const VERSION = '6.1.9'; public const VERSION_ID = 60109; public const MAJOR_VERSION = 6; public const MINOR_VERSION = 1; public const RELEASE_VERSION = 9; - public const EXTRA_VERSION = 'DEV'; + public const EXTRA_VERSION = ''; public const END_OF_MAINTENANCE = '01/2023'; public const END_OF_LIFE = '01/2023'; From 7ee7d8b51500a81aa022fa08d6e10d4ad0941423 Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 16:05:17 +0100 Subject: [PATCH 10/16] Bump Symfony version to 6.1.10 --- src/Symfony/Component/HttpKernel/Kernel.php | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Symfony/Component/HttpKernel/Kernel.php b/src/Symfony/Component/HttpKernel/Kernel.php index 22efec052530d..ae8df3c5a075e 100644 --- a/src/Symfony/Component/HttpKernel/Kernel.php +++ b/src/Symfony/Component/HttpKernel/Kernel.php @@ -78,12 +78,12 @@ abstract class Kernel implements KernelInterface, RebootableInterface, Terminabl */ private static array $freshCache = []; - public const VERSION = '6.1.9'; - public const VERSION_ID = 60109; + public const VERSION = '6.1.10-DEV'; + public const VERSION_ID = 60110; public const MAJOR_VERSION = 6; public const MINOR_VERSION = 1; - public const RELEASE_VERSION = 9; - public const EXTRA_VERSION = ''; + public const RELEASE_VERSION = 10; + public const EXTRA_VERSION = 'DEV'; public const END_OF_MAINTENANCE = '01/2023'; public const END_OF_LIFE = '01/2023'; From ebb259363c27677b4b8d69a698acfac71027b1bf Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Wed, 28 Dec 2022 16:41:11 +0100 Subject: [PATCH 11/16] Bump Symfony version to 6.2.4 --- src/Symfony/Component/HttpKernel/Kernel.php | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Symfony/Component/HttpKernel/Kernel.php b/src/Symfony/Component/HttpKernel/Kernel.php index 0e62c045bd532..39a46a055d576 100644 --- a/src/Symfony/Component/HttpKernel/Kernel.php +++ b/src/Symfony/Component/HttpKernel/Kernel.php @@ -75,12 +75,12 @@ abstract class Kernel implements KernelInterface, RebootableInterface, Terminabl */ private static array $freshCache = []; - public const VERSION = '6.2.3'; - public const VERSION_ID = 60203; + public const VERSION = '6.2.4-DEV'; + public const VERSION_ID = 60204; public const MAJOR_VERSION = 6; public const MINOR_VERSION = 2; - public const RELEASE_VERSION = 3; - public const EXTRA_VERSION = ''; + public const RELEASE_VERSION = 4; + public const EXTRA_VERSION = 'DEV'; public const END_OF_MAINTENANCE = '07/2023'; public const END_OF_LIFE = '07/2023'; From 0cf91ab6b4f409c712958efc7c41bb5fbe64869c Mon Sep 17 00:00:00 2001 From: Rik van der Heijden Date: Thu, 29 Dec 2022 07:29:58 +0100 Subject: [PATCH 12/16] fix for caching without auth parameter, broken by #48711, fix for #48813 --- .../Component/Cache/Traits/RedisTrait.php | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/src/Symfony/Component/Cache/Traits/RedisTrait.php b/src/Symfony/Component/Cache/Traits/RedisTrait.php index 8e26cfc1f23e5..85dc306c05fb0 100644 --- a/src/Symfony/Component/Cache/Traits/RedisTrait.php +++ b/src/Symfony/Component/Cache/Traits/RedisTrait.php @@ -206,8 +206,11 @@ public static function createConnection(string $dsn, array $options = []) if (!isset($params['redis_sentinel'])) { break; } - - $sentinel = new \RedisSentinel($host, $port, $params['timeout'], (string) $params['persistent_id'], $params['retry_interval'], $params['read_timeout'], ...\defined('Redis::OPT_NULL_MULTIBULK_AS_NULL') ? [$params['auth'] ?? ''] : []); + $extra = []; + if (\defined('Redis::OPT_NULL_MULTIBULK_AS_NULL') && isset($params['auth'])) { + $extra = [$params['auth']]; + } + $sentinel = new \RedisSentinel($host, $port, $params['timeout'], (string) $params['persistent_id'], $params['retry_interval'], $params['read_timeout'], ...$extra); if ($address = $sentinel->getMasterAddrByName($params['redis_sentinel'])) { [$host, $port] = $address; @@ -219,10 +222,13 @@ public static function createConnection(string $dsn, array $options = []) } try { - @$redis->{$connect}($host, $port, $params['timeout'], (string) $params['persistent_id'], $params['retry_interval'], $params['read_timeout'], ...\defined('Redis::SCAN_PREFIX') ? [[ - 'auth' => $params['auth'] ?? '', + $extra = [ 'stream' => $params['ssl'] ?? null, - ]] : []); + ]; + if (isset($params['auth'])) { + $extra['auth'] = $params['auth']; + } + @$redis->{$connect}($host, $port, $params['timeout'], (string) $params['persistent_id'], $params['retry_interval'], $params['read_timeout'], ...\defined('Redis::SCAN_PREFIX') ? [$extra] : []); set_error_handler(function ($type, $msg) use (&$error) { $error = $msg; }); try { From 89e6c2f0b58e789544a87d63729b93cbf7fa7df5 Mon Sep 17 00:00:00 2001 From: Robin Chalas Date: Thu, 29 Dec 2022 17:06:09 +0100 Subject: [PATCH 13/16] [Cache] Fix possibly null value passed to preg_match() in RedisTrait --- src/Symfony/Component/Cache/Traits/RedisTrait.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Symfony/Component/Cache/Traits/RedisTrait.php b/src/Symfony/Component/Cache/Traits/RedisTrait.php index 85dc306c05fb0..d452ee4cfc4d8 100644 --- a/src/Symfony/Component/Cache/Traits/RedisTrait.php +++ b/src/Symfony/Component/Cache/Traits/RedisTrait.php @@ -237,7 +237,7 @@ public static function createConnection(string $dsn, array $options = []) restore_error_handler(); } if (!$isConnected) { - $error = preg_match('/^Redis::p?connect\(\): (.*)/', $error, $error) ? sprintf(' (%s)', $error[1]) : ''; + $error = preg_match('/^Redis::p?connect\(\): (.*)/', $error ?? '', $error) ? sprintf(' (%s)', $error[1]) : ''; throw new InvalidArgumentException(sprintf('Redis connection "%s" failed: ', $dsn).$error.'.'); } From 61f443c40c87966a24540f01a321c5a333d188b8 Mon Sep 17 00:00:00 2001 From: Javier Eguiluz Date: Thu, 29 Dec 2022 17:00:41 +0100 Subject: [PATCH 14/16] [WebProfilerBundle] Fix the usage of web fonts --- .../Resources/views/Profiler/fonts.css.twig | 11 +++-- .../views/Profiler/profiler.css.twig | 44 +++++++++++-------- 2 files changed, 33 insertions(+), 22 deletions(-) diff --git a/src/Symfony/Bundle/WebProfilerBundle/Resources/views/Profiler/fonts.css.twig b/src/Symfony/Bundle/WebProfilerBundle/Resources/views/Profiler/fonts.css.twig index cbf832ea3dc9d..17d48b06086f3 100644 --- a/src/Symfony/Bundle/WebProfilerBundle/Resources/views/Profiler/fonts.css.twig +++ b/src/Symfony/Bundle/WebProfilerBundle/Resources/views/Profiler/fonts.css.twig @@ -1,7 +1,12 @@ +{# +Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono) +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +https://www.jetbrains.com/lp/mono/ +#} @font-face { - font-family: 'Ubuntu Mono'; + font-family: 'JetBrains Mono'; font-style: normal; - font-weight: 400; + font-weight: 100 800; font-display: swap; - src: url(data:font/opentype;base64,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) format('woff2'); + src: url(data:application/octet-stream;base64,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) format('woff2'); } diff --git a/src/Symfony/Bundle/WebProfilerBundle/Resources/views/Profiler/profiler.css.twig b/src/Symfony/Bundle/WebProfilerBundle/Resources/views/Profiler/profiler.css.twig index 42f30d6ff4805..7fc32f99352cb 100644 --- a/src/Symfony/Bundle/WebProfilerBundle/Resources/views/Profiler/profiler.css.twig +++ b/src/Symfony/Bundle/WebProfilerBundle/Resources/views/Profiler/profiler.css.twig @@ -7,8 +7,10 @@ button,hr,input{overflow:visible}progress,sub,sup{vertical-align:baseline}[type= :root { --font-family-system: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", "Liberation Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; - --font-family-monospace: "Ubuntu Mono", "JetBrains Mono", ui-monospace, "Roboto Mono", SFMono-Regular, Menlo, Monaco, Consolas,"Liberation Mono", "Courier New", monospace; - + --font-family-monospace: "JetBrains Mono", ui-monospace, "Roboto Mono", SFMono-Regular, Menlo, Monaco, Consolas,"Liberation Mono", "Courier New", monospace; + --font-size-body: 14px; + --font-size-monospace: 13px; + --font-variant-ligatures-monospace: none; --summary-status-border-width: 6px; --white: #fff; @@ -353,7 +355,7 @@ body { background-size: 15px 15px; color: var(--page-color); font-family: var(--font-family-system); - font-size: 14px; + font-size: var(--font-size-body); line-height: 1.4; } @@ -438,7 +440,8 @@ abbr { code, pre { font-family: var(--font-family-monospace); - font-size: 14px; + font-size: var(--font-size-monospace); + font-variant-ligatures: var(--font-variant-ligatures-monospace); } h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { color: inherit; @@ -486,7 +489,7 @@ input[type="radio"], input[type="checkbox"] { color: var(--button-color); cursor: pointer; display: inline-block; - font-size: 14px; + font-size: var(--font-size-body); font-weight: 500; line-height: 20px; padding: 5px 15px; @@ -570,10 +573,12 @@ table tbody td { border: 1px solid var(--table-border-color); border-width: 1px 0; font-family: var(--font-family-monospace); + font-size: var(--font-size-monospace); + font-variant-ligatures: var(--font-variant-ligatures-monospace); } table tbody th.font-normal, table tbody td.font-normal { - font-size: 13px; + font-size: var(--font-size-body); } table tbody tr:last-of-type th, table tbody tr:last-of-type td { @@ -641,11 +646,11 @@ table tbody td.num-col { } .font-normal { font-family: var(--font-family-system); - font-size: 14px; + font-size: var(--font-size-body); } .help { color: var(--color-muted); - font-size: 14px; + font-size: var(--font-size-body); margin: .5em 0; } .empty { @@ -662,7 +667,7 @@ table tbody td.num-col { background-image: url("data:image/svg+xml,%3csvg width='100%25' height='100%25' xmlns='http://www.w3.org/2000/svg'%3e%3crect width='100%25' height='100%25' fill='none' stroke='%23737373' stroke-width='4' stroke-dasharray='6%2c 14' stroke-dashoffset='0' stroke-linecap='square'/%3e%3c/svg%3e"); } .empty p { - font-size: 14px; + font-size: var(--font-size-body); max-width: 60ch; margin-left: auto; margin-right: auto; @@ -1391,7 +1396,7 @@ tr.status-warning td { } #menu-profiler li a .label strong { flex: 1; - font-size: 14px; + font-size: var(--font-size-body); font-weight: 500; } #menu-profiler li a .label.disabled { @@ -1671,7 +1676,7 @@ tr.status-warning td { {# Twig panel ========================================================================= #} #twig-dump pre { - font-size: 14px; + font-size: var(--font-size-monospace); line-height: 1.7; background-color: var(--base-0); border: var(--border); @@ -1995,7 +2000,7 @@ tr.log-status-silenced > td:first-child:before { .mailer-transport-information { border-bottom: 1px solid var(--form-input-border-color); padding-bottom: 5px; - font-size: 14px; + font-size: var(--font-size-body); margin: 5px 0 10px 5px; } .mailer-transport-information .badge { @@ -2011,7 +2016,7 @@ tr.log-status-silenced > td:first-child:before { margin-bottom: 10px; } .mailer-message-headers p { - font-size: 14px; + font-size: var(--font-size-body); margin: 2px 5px; } .mailer-message-header-secondary { @@ -2020,7 +2025,7 @@ tr.log-status-silenced > td:first-child:before { .mailer-message-attachments-title { align-items: center; display: flex; - font-size: 14px; + font-size: var(--font-size-body); font-weight: 600; margin-bottom: 10px; } @@ -2201,7 +2206,8 @@ pre.sf-dump, pre.sf-dump .sf-dump-default { #collector-content .sf-dump code, #collector-content .sf-dump samp { font-family: var(--font-family-monospace); - font-size: 13px; + font-size: var(--font-size-monospace); + font-variant-ligatures: var(--font-variant-ligatures-monospace); } #collector-content .sf-dump a { cursor: pointer; @@ -2229,7 +2235,7 @@ pre.sf-dump, pre.sf-dump .sf-dump-default { #collector-content .dump-inline .sf-dump { display: inline; white-space: normal; - font-size: 14px; + font-size: var(--font-size-monospace); line-height: inherit; } #collector-content .dump-inline .sf-dump:after { @@ -2247,7 +2253,7 @@ pre.sf-dump, pre.sf-dump .sf-dump-default { {# Forms panel ========================================================================= #} .form-type-class { - font-size: 14px; + font-size: var(--font-size-body); display: flex; margin: 0 0 15px; } @@ -2256,7 +2262,7 @@ pre.sf-dump, pre.sf-dump .sf-dump-default { } .form-type-class pre.sf-dump { font-family: var(--font-family-system) !important; - font-size: 14px !important; + font-size: var(--font-size-body) !important; margin-left: 5px; } .form-type-class .sf-dump .sf-dump-str { @@ -2407,7 +2413,7 @@ body.width-full .container { {# VarDumper dumps ========================================================================= #} #collector-content pre.sf-dump, #collector-content .sf-dump code, #collector-content .sf-dump samp { - font-size: 14px; + font-size: var(--font-size-monospace); font-weight: normal; } From bc7d1752b28290028ae175e57178dfe552a0778d Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Thu, 29 Dec 2022 20:05:04 +0100 Subject: [PATCH 15/16] Update CHANGELOG for 6.2.4 --- CHANGELOG-6.2.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/CHANGELOG-6.2.md b/CHANGELOG-6.2.md index 3c3a4e350590c..df3991022ddf0 100644 --- a/CHANGELOG-6.2.md +++ b/CHANGELOG-6.2.md @@ -7,6 +7,12 @@ in 6.2 minor versions. To get the diff for a specific change, go to https://github.com/symfony/symfony/commit/XXX where XXX is the change hash To get the diff between two versions, go to https://github.com/symfony/symfony/compare/v6.2.0...v6.2.1 +* 6.2.4 (2022-12-29) + + * bug #48822 [WebProfilerBundle] Fix the usage of web fonts (javiereguiluz) + * bug #48823 [Cache] Fix possibly null value passed to preg_match() in RedisTrait (chalasr) + * bug #48816 [Cache] Fix for RedisAdapter without auth parameter (rikvdh) + * 6.2.3 (2022-12-28) * bug #48805 [DependencyInjection] Fix resolving parameters when dumping lazy proxies (nicolas-grekas) From 529b933a87013b953411fbf1217c11b72dd4332a Mon Sep 17 00:00:00 2001 From: Fabien Potencier Date: Thu, 29 Dec 2022 20:05:08 +0100 Subject: [PATCH 16/16] Update VERSION for 6.2.4 --- src/Symfony/Component/HttpKernel/Kernel.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Symfony/Component/HttpKernel/Kernel.php b/src/Symfony/Component/HttpKernel/Kernel.php index 39a46a055d576..846e12d284216 100644 --- a/src/Symfony/Component/HttpKernel/Kernel.php +++ b/src/Symfony/Component/HttpKernel/Kernel.php @@ -75,12 +75,12 @@ abstract class Kernel implements KernelInterface, RebootableInterface, Terminabl */ private static array $freshCache = []; - public const VERSION = '6.2.4-DEV'; + public const VERSION = '6.2.4'; public const VERSION_ID = 60204; public const MAJOR_VERSION = 6; public const MINOR_VERSION = 2; public const RELEASE_VERSION = 4; - public const EXTRA_VERSION = 'DEV'; + public const EXTRA_VERSION = ''; public const END_OF_MAINTENANCE = '07/2023'; public const END_OF_LIFE = '07/2023';