Changeset 59141 for trunk/src/wp-includes/SimplePie/src/Registry.php

Timestamp:

09/30/2024 10:48:16 PM (7 months ago)

Author:

SergeyBiryukov

Message:

External Libraries: Update the SimplePie library to version 1.8.0.

The most notable change in this update is that all code is now namespaced and uses PSR-4 classes, though there is a compatibility layer available for extenders using the older class names, so plugin or theme authors directly using SimplePie can decide for themselves when they want to change to using the namespaced names for SimplePie classes.

Note: This commit includes additional fixes for PHP 8.4 compatibility (​PR 875, ​PR 888) from the one-dot-eight branch of SimplePie, which is expected to be ​released as SimplePie 1.8.1 soon.

References:

• ​SimplePie 1.8.0 release notes
• ​SimplePie 1.7.0 release notes
• ​SimplePie 1.6.0 release notes
• ​Full list of changes in SimplePie 1.8.0

Follow-up to [47733], [49176], [52393], [52413].

Props jrf, peterwilsoncc, chaion07, cu121, markparnell, audrasjb, costdev, Presskopp, desrosj, faisal03, mukesh27, SergeyBiryukov.
See #55604.

Location:

trunk/src/wp-includes/SimplePie/src

Files:

• . (added)
• Registry.php (moved) (moved from trunk/src/wp-includes/SimplePie/Registry.php) (3 diffs)

trunk/src/wp-includes/SimplePie/src/Registry.php

@@ -1 +1 @@
 <?php
+
 /**
  * SimplePie
@@ -6 +7 @@
  * Takes the hard work out of managing a complete RSS/Atom solution.
  *
- * Copyright (c) 2004-2016, Ryan Parman, Sam Sneddon, Ryan McCue, and contributors
+ * Copyright (c) 2004-2022, Ryan Parman, Sam Sneddon, Ryan McCue, and contributors
  * All rights reserved.
  *
@@ -42 +43 @@
  */
 
+namespace SimplePie;
+
+use SimplePie\Content\Type\Sniffer;
+use SimplePie\Parse\Date;
+use SimplePie\XML\Declaration\Parser as DeclarationParser;
+
 /**
  * Handles creating objects and calling methods
  *
- * Access this via {@see SimplePie::get_registry()}
+ * Access this via {@see \SimplePie\SimplePie::get_registry()}
  *
  * @package SimplePie
  */
-class SimplePie_Registry
+class Registry
 {
-    /**
-     * Default class mapping
-     *
-     * Overriding classes *must* subclass these.
-     *
-     * @var array
-     */
-    protected $default = array(
-        'Cache' => 'SimplePie_Cache',
-        'Locator' => 'SimplePie_Locator',
-        'Parser' => 'SimplePie_Parser',
-        'File' => 'SimplePie_File',
-        'Sanitize' => 'SimplePie_Sanitize',
-        'Item' => 'SimplePie_Item',
-        'Author' => 'SimplePie_Author',
-        'Category' => 'SimplePie_Category',
-        'Enclosure' => 'SimplePie_Enclosure',
-        'Caption' => 'SimplePie_Caption',
-        'Copyright' => 'SimplePie_Copyright',
-        'Credit' => 'SimplePie_Credit',
-        'Rating' => 'SimplePie_Rating',
-        'Restriction' => 'SimplePie_Restriction',
-        'Content_Type_Sniffer' => 'SimplePie_Content_Type_Sniffer',
-        'Source' => 'SimplePie_Source',
-        'Misc' => 'SimplePie_Misc',
-        'XML_Declaration_Parser' => 'SimplePie_XML_Declaration_Parser',
-        'Parse_Date' => 'SimplePie_Parse_Date',
-    );
-
-    /**
-     * Class mapping
-     *
-     * @see register()
-     * @var array
-     */
-    protected $classes = array();
-
-    /**
-     * Legacy classes
-     *
-     * @see register()
-     * @var array
-     */
-    protected $legacy = array();
-
-    /**
-     * Constructor
-     *
-     * No-op
-     */
-    public function __construct() { }
-
-    /**
-     * Register a class
-     *
-     * @param string $type See {@see $default} for names
-     * @param string $class Class name, must subclass the corresponding default
-     * @param bool $legacy Whether to enable legacy support for this class
-     * @return bool Successfulness
-     */
-    public function register($type, $class, $legacy = false)
-    {
-        if (!@is_subclass_of($class, $this->default[$type]))
-        {
-            return false;
-        }
-
-        $this->classes[$type] = $class;
-
-        if ($legacy)
-        {
-            $this->legacy[] = $class;
-        }
-
-        return true;
-    }
-
-    /**
-     * Get the class registered for a type
-     *
-     * Where possible, use {@see create()} or {@see call()} instead
-     *
-     * @param string $type
-     * @return string|null
-     */
-    public function get_class($type)
-    {
-        if (!empty($this->classes[$type]))
-        {
-            return $this->classes[$type];
-        }
-        if (!empty($this->default[$type]))
-        {
-            return $this->default[$type];
-        }
-
-        return null;
-    }
-
-    /**
-     * Create a new instance of a given type
-     *
-     * @param string $type
-     * @param array $parameters Parameters to pass to the constructor
-     * @return object Instance of class
-     */
-    public function &create($type, $parameters = array())
-    {
-        $class = $this->get_class($type);
-
-        if (in_array($class, $this->legacy))
-        {
-            switch ($type)
-            {
-                case 'locator':
-                    // Legacy: file, timeout, useragent, file_class, max_checked_feeds, content_type_sniffer_class
-                    // Specified: file, timeout, useragent, max_checked_feeds
-                    $replacement = array($this->get_class('file'), $parameters[3], $this->get_class('content_type_sniffer'));
-                    array_splice($parameters, 3, 1, $replacement);
-                    break;
-            }
-        }
-
-        if (!method_exists($class, '__construct'))
-        {
-            $instance = new $class;
-        }
-        else
-        {
-            $reflector = new ReflectionClass($class);
-            $instance = $reflector->newInstanceArgs($parameters);
-        }
-
-        if (method_exists($instance, 'set_registry'))
-        {
-            $instance->set_registry($this);
-        }
-        return $instance;
-    }
-
-    /**
-     * Call a static method for a type
-     *
-     * @param string $type
-     * @param string $method
-     * @param array $parameters
-     * @return mixed
-     */
-    public function &call($type, $method, $parameters = array())
-    {
-        $class = $this->get_class($type);
-
-        if (in_array($class, $this->legacy))
-        {
-            switch ($type)
-            {
-                case 'Cache':
-                    // For backwards compatibility with old non-static
-                    // Cache::create() methods in PHP < 8.0.
-                    // No longer supported as of PHP 8.0.
-                    if ($method === 'get_handler')
-                    {
-                        $result = @call_user_func_array(array($class, 'create'), $parameters);
-                        return $result;
-                    }
-                    break;
-            }
-        }
-
-        $result = call_user_func_array(array($class, $method), $parameters);
-        return $result;
-    }
+    /**
+     * Default class mapping
+     *
+     * Overriding classes *must* subclass these.
+     *
+     * @var array<class-string, class-string>
+     */
+    protected $default = [
+        Cache::class => Cache::class,
+        Locator::class => Locator::class,
+        Parser::class => Parser::class,
+        File::class => File::class,
+        Sanitize::class => Sanitize::class,
+        Item::class => Item::class,
+        Author::class => Author::class,
+        Category::class => Category::class,
+        Enclosure::class => Enclosure::class,
+        Caption::class => Caption::class,
+        Copyright::class => Copyright::class,
+        Credit::class => Credit::class,
+        Rating::class => Rating::class,
+        Restriction::class => Restriction::class,
+        Sniffer::class => Sniffer::class,
+        Source::class => Source::class,
+        Misc::class => Misc::class,
+        DeclarationParser::class => DeclarationParser::class,
+        Date::class => Date::class,
+    ];
+
+    /**
+     * Class mapping
+     *
+     * @see register()
+     * @var array
+     */
+    protected $classes = [];
+
+    /**
+     * Legacy classes
+     *
+     * @see register()
+     * @var array<class-string>
+     */
+    protected $legacy = [];
+
+    /**
+     * Legacy types
+     *
+     * @see register()
+     * @var array<string, class-string>
+     */
+    private $legacyTypes = [
+        'Cache' => Cache::class,
+        'Locator' => Locator::class,
+        'Parser' => Parser::class,
+        'File' => File::class,
+        'Sanitize' => Sanitize::class,
+        'Item' => Item::class,
+        'Author' => Author::class,
+        'Category' => Category::class,
+        'Enclosure' => Enclosure::class,
+        'Caption' => Caption::class,
+        'Copyright' => Copyright::class,
+        'Credit' => Credit::class,
+        'Rating' => Rating::class,
+        'Restriction' => Restriction::class,
+        'Content_Type_Sniffer' => Sniffer::class,
+        'Source' => Source::class,
+        'Misc' => Misc::class,
+        'XML_Declaration_Parser' => DeclarationParser::class,
+        'Parse_Date' => Date::class,
+    ];
+
+    /**
+     * Constructor
+     *
+     * No-op
+     */
+    public function __construct()
+    {
+    }
+
+    /**
+     * Register a class
+     *
+     * @param string $type See {@see $default} for names
+     * @param class-string $class Class name, must subclass the corresponding default
+     * @param bool $legacy Whether to enable legacy support for this class
+     * @return bool Successfulness
+     */
+    public function register($type, $class, $legacy = false)
+    {
+        if (array_key_exists($type, $this->legacyTypes)) {
+            // trigger_error(sprintf('"%s"(): Using argument #1 ($type) with value "%s" is deprecated since SimplePie 1.8.0, use class-string "%s" instead.', __METHOD__, $type, $this->legacyTypes[$type]), \E_USER_DEPRECATED);
+
+            $type = $this->legacyTypes[$type];
+        }
+
+        if (!array_key_exists($type, $this->default)) {
+            return false;
+        }
+
+        if (!class_exists($class)) {
+            return false;
+        }
+
+        /** @var string */
+        $base_class = $this->default[$type];
+
+        if (!is_subclass_of($class, $base_class)) {
+            return false;
+        }
+
+        $this->classes[$type] = $class;
+
+        if ($legacy) {
+            $this->legacy[] = $class;
+        }
+
+        return true;
+    }
+
+    /**
+     * Get the class registered for a type
+     *
+     * Where possible, use {@see create()} or {@see call()} instead
+     *
+     * @template T
+     * @param class-string<T> $type
+     * @return class-string<T>|null
+     */
+    public function get_class($type)
+    {
+        if (array_key_exists($type, $this->legacyTypes)) {
+            // trigger_error(sprintf('"%s"(): Using argument #1 ($type) with value "%s" is deprecated since SimplePie 1.8.0, use class-string "%s" instead.', __METHOD__, $type, $this->legacyTypes[$type]), \E_USER_DEPRECATED);
+
+            $type = $this->legacyTypes[$type];
+        }
+
+        if (!array_key_exists($type, $this->default)) {
+            return null;
+        }
+
+        $class = $this->default[$type];
+
+        if (array_key_exists($type, $this->classes)) {
+            $class = $this->classes[$type];
+        }
+
+        return $class;
+    }
+
+    /**
+     * Create a new instance of a given type
+     *
+     * @template T class-string $type
+     * @param class-string<T> $type
+     * @param array $parameters Parameters to pass to the constructor
+     * @return T Instance of class
+     */
+    public function &create($type, $parameters = [])
+    {
+        $class = $this->get_class($type);
+
+        if (!method_exists($class, '__construct')) {
+            $instance = new $class();
+        } else {
+            $reflector = new \ReflectionClass($class);
+            $instance = $reflector->newInstanceArgs($parameters);
+        }
+
+        if ($instance instanceof RegistryAware) {
+            $instance->set_registry($this);
+        } elseif (method_exists($instance, 'set_registry')) {
+            trigger_error(sprintf('Using the method "set_registry()" without implementing "%s" is deprecated since SimplePie 1.8.0, implement "%s" in "%s".', RegistryAware::class, RegistryAware::class, $class), \E_USER_DEPRECATED);
+            $instance->set_registry($this);
+        }
+        return $instance;
+    }
+
+    /**
+     * Call a static method for a type
+     *
+     * @param class-string $type
+     * @param string $method
+     * @param array $parameters
+     * @return mixed
+     */
+    public function &call($type, $method, $parameters = [])
+    {
+        $class = $this->get_class($type);
+
+        if (in_array($class, $this->legacy)) {
+            switch ($type) {
+                case Cache::class:
+                    // For backwards compatibility with old non-static
+                    // Cache::create() methods in PHP < 8.0.
+                    // No longer supported as of PHP 8.0.
+                    if ($method === 'get_handler') {
+                        $result = @call_user_func_array([$class, 'create'], $parameters);
+                        return $result;
+                    }
+                    break;
+            }
+        }
+
+        $result = call_user_func_array([$class, $method], $parameters);
+        return $result;
+    }
 }
+
+class_alias('SimplePie\Registry', 'SimplePie_Registry');