Remove deprecated code in Cache package.

src/Cache/Cache.php

@@ -73,7 +73,6 @@ class Cache
      * @var array
      */
     protected static $_dsnClassMap = [
-        'apc' => 'Cake\Cache\Engine\ApcuEngine', // @deprecated Since 3.6. Use apcu instead.
         'apcu' => 'Cake\Cache\Engine\ApcuEngine',
         'file' => 'Cake\Cache\Engine\FileEngine',
         'memcached' => 'Cake\Cache\Engine\MemcachedEngine',
@@ -132,24 +131,6 @@ class Cache
     }
 
     /**
-     * Returns the Cache Registry instance used for creating and using cache adapters.
-     * Also allows for injecting of a new registry instance.
-     *
-     * @param \Cake\Core\ObjectRegistry|null $registry Injectable registry object.
-     * @return \Cake\Core\ObjectRegistry
-     * @deprecated Deprecated since 3.5. Use getRegistry() and setRegistry() instead.
-     */
-    public static function registry(ObjectRegistry $registry = null)
-    {
-        deprecationWarning('Use Cache::getRegistry() and Cache::setRegistry() instead.');
-        if ($registry) {
-            static::setRegistry($registry);
-        }
-
-        return static::getRegistry();
-    }
-
-    /**
      * Finds and builds the instance of the required engine class.
      *
      * @param string $name Name of the config array that needs an engine instance built

src/Cache/Engine/ApcEngine.php

@@ -1,20 +0,0 @@
-<?php
-/**
- * CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
- * Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
- *
- * Licensed under The MIT License
- * For full copyright and license information, please see the LICENSE.txt
- * Redistributions of files must retain the above copyright notice.
- *
- * @copyright     Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
- * @link          https://cakephp.org CakePHP(tm) Project
- * @since         1.2.0
- * @license       https://opensource.org/licenses/mit-license.php MIT License
- */
-namespace Cake\Cache\Engine;
-
-// @deprecated Add backwards compat alias.
-class_alias('Cake\Cache\Engine\ApcuEngine', 'Cake\Cache\Engine\ApcEngine');
-
-deprecationWarning('Use Cake\Cache\Engine\ApcuEngine instead of Cake\Cache\Engine\ApcEngine.');

src/Cache/Engine/MemcachedEngine.php

@@ -267,18 +267,6 @@ class MemcachedEngine extends CacheEngine
     }
 
     /**
-     * Backwards compatible alias of parseServerString
-     *
-     * @param string $server The server address string.
-     * @return array Array containing host, port
-     * @deprecated 3.4.13 Will be removed in 4.0.0
-     */
-    protected function _parseServerString($server)
-    {
-        return $this->parseServerString($server);
-    }
-
-    /**
      * Read an option value from the memcached connection.
      *
      * @param string $name The option name to read.

src/Cache/Engine/XcacheEngine.php

@@ -1,256 +0,0 @@
-<?php
-/**
- * CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
- * Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
- *
- * Licensed under The MIT License
- * For full copyright and license information, please see the LICENSE.txt
- * Redistributions of files must retain the above copyright notice.
- *
- * @copyright     Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
- * @link          https://cakephp.org CakePHP(tm) Project
- * @since         1.2.0
- * @license       https://opensource.org/licenses/mit-license.php MIT License
- */
-namespace Cake\Cache\Engine;
-
-use Cake\Cache\CacheEngine;
-
-/**
- * Xcache storage engine for cache
- *
- * @link          http://trac.lighttpd.net/xcache/ Xcache
- * @deprecated 3.6.0 Xcache engine has been deprecated and will be removed in 4.0.0.
- */
-class XcacheEngine extends CacheEngine
-{
-
-    /**
-     * The default config used unless overridden by runtime configuration
-     *
-     * - `duration` Specify how long items in this cache configuration last.
-     * - `groups` List of groups or 'tags' associated to every key stored in this config.
-     *    handy for deleting a complete group from cache.
-     * - `prefix` Prefix appended to all entries. Good for when you need to share a keyspace
-     *    with either another cache config or another application.
-     * - `probability` Probability of hitting a cache gc cleanup. Setting to 0 will disable
-     *    cache::gc from ever being called automatically.
-     * - `PHP_AUTH_USER` xcache.admin.user
-     * - `PHP_AUTH_PW` xcache.admin.password
-     *
-     * @var array
-     */
-    protected $_defaultConfig = [
-        'duration' => 3600,
-        'groups' => [],
-        'prefix' => null,
-        'probability' => 100,
-        'PHP_AUTH_USER' => 'user',
-        'PHP_AUTH_PW' => 'password'
-    ];
-
-    /**
-     * Initialize the Cache Engine
-     *
-     * Called automatically by the cache frontend
-     *
-     * @param array $config array of setting for the engine
-     * @return bool True if the engine has been successfully initialized, false if not
-     */
-    public function init(array $config = [])
-    {
-        if (!extension_loaded('xcache')) {
-            return false;
-        }
-
-        parent::init($config);
-
-        return true;
-    }
-
-    /**
-     * Write data for key into cache
-     *
-     * @param string $key Identifier for the data
-     * @param mixed $value Data to be cached
-     * @return bool True if the data was successfully cached, false on failure
-     */
-    public function write($key, $value)
-    {
-        $key = $this->_key($key);
-
-        if (!is_numeric($value)) {
-            $value = serialize($value);
-        }
-
-        $duration = $this->_config['duration'];
-        $expires = time() + $duration;
-        xcache_set($key . '_expires', $expires, $duration);
-
-        return xcache_set($key, $value, $duration);
-    }
-
-    /**
-     * Read a key from the cache
-     *
-     * @param string $key Identifier for the data
-     * @return mixed The cached data, or false if the data doesn't exist,
-     *   has expired, or if there was an error fetching it
-     */
-    public function read($key)
-    {
-        $key = $this->_key($key);
-
-        if (xcache_isset($key)) {
-            $time = time();
-            $cachetime = (int)xcache_get($key . '_expires');
-            if ($cachetime < $time || ($time + $this->_config['duration']) < $cachetime) {
-                return false;
-            }
-
-            $value = xcache_get($key);
-            if (is_string($value) && !is_numeric($value)) {
-                $value = unserialize($value);
-            }
-
-            return $value;
-        }
-
-        return false;
-    }
-
-    /**
-     * Increments the value of an integer cached key
-     * If the cache key is not an integer it will be treated as 0
-     *
-     * @param string $key Identifier for the data
-     * @param int $offset How much to increment
-     * @return bool|int New incremented value, false otherwise
-     */
-    public function increment($key, $offset = 1)
-    {
-        $key = $this->_key($key);
-
-        return xcache_inc($key, $offset);
-    }
-
-    /**
-     * Decrements the value of an integer cached key.
-     * If the cache key is not an integer it will be treated as 0
-     *
-     * @param string $key Identifier for the data
-     * @param int $offset How much to subtract
-     * @return bool|int New decremented value, false otherwise
-     */
-    public function decrement($key, $offset = 1)
-    {
-        $key = $this->_key($key);
-
-        return xcache_dec($key, $offset);
-    }
-
-    /**
-     * Delete a key from the cache
-     *
-     * @param string $key Identifier for the data
-     * @return bool True if the value was successfully deleted, false if it didn't exist or couldn't be removed
-     */
-    public function delete($key)
-    {
-        $key = $this->_key($key);
-
-        return xcache_unset($key);
-    }
-
-    /**
-     * Delete all keys from the cache
-     *
-     * @param bool $check If true no deletes will occur and instead CakePHP will rely
-     *   on key TTL values.
-     *   Unused for Xcache engine.
-     * @return bool True if the cache was successfully cleared, false otherwise
-     */
-    public function clear($check)
-    {
-        $this->_auth();
-        $max = xcache_count(XC_TYPE_VAR);
-        for ($i = 0; $i < $max; $i++) {
-            xcache_clear_cache(XC_TYPE_VAR, $i);
-        }
-        $this->_auth(true);
-
-        return true;
-    }
-
-    /**
-     * Returns the `group value` for each of the configured groups
-     * If the group initial value was not found, then it initializes
-     * the group accordingly.
-     *
-     * @return array
-     */
-    public function groups()
-    {
-        $result = [];
-        foreach ($this->_config['groups'] as $group) {
-            $value = xcache_get($this->_config['prefix'] . $group);
-            if (!$value) {
-                $value = 1;
-                xcache_set($this->_config['prefix'] . $group, $value, 0);
-            }
-            $result[] = $group . $value;
-        }
-
-        return $result;
-    }
-
-    /**
-     * Increments the group value to simulate deletion of all keys under a group
-     * old values will remain in storage until they expire.
-     *
-     * @param string $group The group to clear.
-     * @return bool success
-     */
-    public function clearGroup($group)
-    {
-        return (bool)xcache_inc($this->_config['prefix'] . $group, 1);
-    }
-
-    /**
-     * Populates and reverses $_SERVER authentication values
-     * Makes necessary changes (and reverting them back) in $_SERVER
-     *
-     * This has to be done because xcache_clear_cache() needs to pass Basic Http Auth
-     * (see xcache.admin configuration config)
-     *
-     * @param bool $reverse Revert changes
-     * @return void
-     */
-    protected function _auth($reverse = false)
-    {
-        static $backup = [];
-        $keys = ['PHP_AUTH_USER' => 'user', 'PHP_AUTH_PW' => 'password'];
-        foreach ($keys as $key => $value) {
-            if ($reverse) {
-                if (isset($backup[$key])) {
-                    $_SERVER[$key] = $backup[$key];
-                    unset($backup[$key]);
-                } else {
-                    unset($_SERVER[$key]);
-                }
-            } else {
-                $value = env($key);
-                if (!empty($value)) {
-                    $backup[$key] = $value;
-                }
-                if (!empty($this->_config[$value])) {
-                    $_SERVER[$key] = $this->_config[$value];
-                } elseif (!empty($this->_config[$key])) {
-                    $_SERVER[$key] = $this->_config[$key];
-                } else {
-                    $_SERVER[$key] = $value;
-                }
-            }
-        }
-    }
-}

tests/TestCase/Cache/CacheTest.php

@@ -432,28 +432,6 @@ class CacheTest extends TestCase
     /**
      * Test reading configuration.
      *
-     * @group deprecated
-     * @return void
-     */
-    public function testConfigReadCompat()
-    {
-        $this->deprecated(function () {
-            $config = [
-                'engine' => 'File',
-                'path' => TMP,
-                'prefix' => 'cake_'
-            ];
-            Cache::config('tests', $config);
-            $expected = $config;
-            $expected['className'] = $config['engine'];
-            unset($expected['engine']);
-            $this->assertEquals($expected, Cache::config('tests'));
-        });
-    }
-
-    /**
-     * Test reading configuration.
-     *
      * @return void
      */
     public function testConfigRead()
@@ -858,34 +836,6 @@ class CacheTest extends TestCase
     }
 
     /**
-     * test registry method
-     *
-     * @group deprecated
-     * @return void
-     */
-    public function testRegistry()
-    {
-        $this->deprecated(function () {
-            $this->assertInstanceOf(CacheRegistry::class, Cache::registry());
-        });
-    }
-
-    /**
-     * test registry method setting
-     *
-     * @group deprecated
-     * @return void
-     */
-    public function testRegistrySet()
-    {
-        $registry = new CacheRegistry();
-        $this->deprecated(function () use ($registry) {
-            Cache::registry($registry);
-            $this->assertSame($registry, Cache::registry());
-        });
-    }
-
-    /**
      * Test getting the registry
      *
      * @return void

tests/TestCase/Cache/Engine/XcacheEngineTest.php

@@ -1,315 +0,0 @@
-<?php
-/**
- * XcacheEngineTest file
- *
- * CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
- * Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
- *
- * Licensed under The MIT License
- * For full copyright and license information, please see the LICENSE.txt
- * Redistributions of files must retain the above copyright notice
- *
- * @copyright     Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
- * @link          https://cakephp.org CakePHP(tm) Project
- * @since         1.2.0
- * @license       https://opensource.org/licenses/mit-license.php MIT License
- */
-namespace Cake\Test\TestCase\Cache\Engine;
-
-use Cake\Cache\Cache;
-use Cake\TestSuite\TestCase;
-
-/**
- * XcacheEngineTest class
- */
-class XcacheEngineTest extends TestCase
-{
-
-    /**
-     * setUp method
-     *
-     * @return void
-     */
-    public function setUp()
-    {
-        parent::setUp();
-        if (!extension_loaded('xcache')) {
-            $this->markTestSkipped('Xcache is not installed or configured properly');
-        }
-        Cache::enable();
-        Cache::setConfig('xcache', ['engine' => 'Xcache', 'prefix' => 'cake_']);
-    }
-
-    /**
-     * Helper method for testing.
-     *
-     * @param array $config
-     * @return void
-     */
-    protected function _configCache($config = [])
-    {
-        $defaults = [
-            'className' => 'Xcache',
-            'prefix' => 'cake_',
-        ];
-        Cache::drop('xcache');
-        Cache::setConfig('xcache', array_merge($defaults, $config));
-    }
-
-    /**
-     * tearDown method
-     *
-     * @return void
-     */
-    public function tearDown()
-    {
-        parent::tearDown();
-        Cache::drop('xcache');
-        Cache::drop('xcache_groups');
-    }
-
-    /**
-     * testConfig method
-     *
-     * @return void
-     */
-    public function testConfig()
-    {
-        $config = Cache::engine('xcache')->getConfig();
-        $expecting = [
-            'prefix' => 'cake_',
-            'duration' => 3600,
-            'probability' => 100,
-            'groups' => [],
-        ];
-        $this->assertArrayHasKey('PHP_AUTH_USER', $config);
-        $this->assertArrayHasKey('PHP_AUTH_PW', $config);
-
-        unset($config['PHP_AUTH_USER'], $config['PHP_AUTH_PW']);
-        $this->assertEquals($config, $expecting);
-    }
-
-    /**
-     * testReadAndWriteCache method
-     *
-     * @return void
-     */
-    public function testReadAndWriteCache()
-    {
-        $result = Cache::read('test', 'xcache');
-        $expecting = '';
-        $this->assertEquals($expecting, $result);
-
-        // String
-        $data = 'this is a test of the emergency broadcasting system';
-        $result = Cache::write('test', $data, 'xcache');
-        $this->assertTrue($result);
-
-        $result = Cache::read('test', 'xcache');
-        $expecting = $data;
-        $this->assertEquals($expecting, $result);
-
-        // Integer
-        $data = 100;
-        $result = Cache::write('test', 100, 'xcache');
-        $this->assertTrue($result);
-
-        $result = Cache::read('test', 'xcache');
-        $this->assertSame(100, $result);
-
-        // Object
-        $data = (object)['value' => 'an object'];
-        $result = Cache::write('test', $data, 'xcache');
-        $this->assertTrue($result);
-
-        $result = Cache::read('test', 'xcache');
-        $this->assertInstanceOf('stdClass', $result);
-        $this->assertEquals('an object', $result->value);
-
-        Cache::delete('test', 'xcache');
-    }
-
-    /**
-     * testExpiry method
-     *
-     * @return void
-     */
-    public function testExpiry()
-    {
-        $this->_configCache(['duration' => 1]);
-        $result = Cache::read('test', 'xcache');
-        $this->assertFalse($result);
-
-        $data = 'this is a test of the emergency broadcasting system';
-        $result = Cache::write('other_test', $data, 'xcache');
-        $this->assertTrue($result);
-
-        sleep(2);
-        $result = Cache::read('other_test', 'xcache');
-        $this->assertFalse($result);
-
-        $this->_configCache(['duration' => '+1 second']);
-
-        $data = 'this is a test of the emergency broadcasting system';
-        $result = Cache::write('other_test', $data, 'xcache');
-        $this->assertTrue($result);
-
-        sleep(2);
-        $result = Cache::read('other_test', 'xcache');
-        $this->assertFalse($result);
-    }
-
-    /**
-     * testDeleteCache method
-     *
-     * @return void
-     */
-    public function testDeleteCache()
-    {
-        $data = 'this is a test of the emergency broadcasting system';
-        $result = Cache::write('delete_test', $data, 'xcache');
-        $this->assertTrue($result);
-
-        $result = Cache::delete('delete_test', 'xcache');
-        $this->assertTrue($result);
-    }
-
-    /**
-     * testClearCache method
-     *
-     * @return void
-     */
-    public function testClearCache()
-    {
-        if ((PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg')) {
-            $this->markTestSkipped('Xcache administration functions are not available for the CLI.');
-        }
-        $data = 'this is a test of the emergency broadcasting system';
-        $result = Cache::write('clear_test_1', $data, 'xcache');
-        $this->assertTrue($result);
-
-        $result = Cache::write('clear_test_2', $data, 'xcache');
-        $this->assertTrue($result);
-
-        $result = Cache::clear(false, 'xcache');
-        $this->assertTrue($result);
-    }
-
-    /**
-     * testDecrement method
-     *
-     * @return void
-     */
-    public function testDecrement()
-    {
-        $result = Cache::write('test_decrement', 5, 'xcache');
-        $this->assertTrue($result);
-
-        $result = Cache::decrement('test_decrement', 1, 'xcache');
-        $this->assertEquals(4, $result);
-
-        $result = Cache::read('test_decrement', 'xcache');
-        $this->assertEquals(4, $result);
-
-        $result = Cache::decrement('test_decrement', 2, 'xcache');
-        $this->assertEquals(2, $result);
-
-        $result = Cache::read('test_decrement', 'xcache');
-        $this->assertEquals(2, $result);
-    }
-
-    /**
-     * testIncrement method
-     *
-     * @return void
-     */
-    public function testIncrement()
-    {
-        $result = Cache::write('test_increment', 5, 'xcache');
-        $this->assertTrue($result);
-
-        $result = Cache::increment('test_increment', 1, 'xcache');
-        $this->assertEquals(6, $result);
-
-        $result = Cache::read('test_increment', 'xcache');
-        $this->assertEquals(6, $result);
-
-        $result = Cache::increment('test_increment', 2, 'xcache');
-        $this->assertEquals(8, $result);
-
-        $result = Cache::read('test_increment', 'xcache');
-        $this->assertEquals(8, $result);
-    }
-
-    /**
-     * Tests that configuring groups for stored keys return the correct values when read/written
-     * Shows that altering the group value is equivalent to deleting all keys under the same
-     * group
-     *
-     * @return void
-     */
-    public function testGroupsReadWrite()
-    {
-        Cache::setConfig('xcache_groups', [
-            'engine' => 'Xcache',
-            'duration' => 0,
-            'groups' => ['group_a', 'group_b'],
-            'prefix' => 'test_'
-        ]);
-        $this->assertTrue(Cache::write('test_groups', 'value', 'xcache_groups'));
-        $this->assertEquals('value', Cache::read('test_groups', 'xcache_groups'));
-
-        xcache_inc('test_group_a', 1);
-        $this->assertFalse(Cache::read('test_groups', 'xcache_groups'));
-        $this->assertTrue(Cache::write('test_groups', 'value2', 'xcache_groups'));
-        $this->assertEquals('value2', Cache::read('test_groups', 'xcache_groups'));
-
-        xcache_inc('test_group_b', 1);
-        $this->assertFalse(Cache::read('test_groups', 'xcache_groups'));
-        $this->assertTrue(Cache::write('test_groups', 'value3', 'xcache_groups'));
-        $this->assertEquals('value3', Cache::read('test_groups', 'xcache_groups'));
-    }
-
-    /**
-     * Tests that deleting from a groups-enabled config is possible
-     *
-     * @return void
-     */
-    public function testGroupDelete()
-    {
-        Cache::setConfig('xcache_groups', [
-            'engine' => 'Xcache',
-            'duration' => 0,
-            'groups' => ['group_a', 'group_b'],
-            'prefix' => 'test_'
-        ]);
-        $this->assertTrue(Cache::write('test_groups', 'value', 'xcache_groups'));
-        $this->assertEquals('value', Cache::read('test_groups', 'xcache_groups'));
-        $this->assertTrue(Cache::delete('test_groups', 'xcache_groups'));
-
-        $this->assertFalse(Cache::read('test_groups', 'xcache_groups'));
-    }
-
-    /**
-     * Test clearing a cache group
-     *
-     * @return void
-     */
-    public function testGroupClear()
-    {
-        Cache::setConfig('xcache_groups', [
-            'engine' => 'Xcache',
-            'duration' => 0,
-            'groups' => ['group_a', 'group_b'],
-            'prefix' => 'test_'
-        ]);
-
-        $this->assertTrue(Cache::write('test_groups', 'value', 'xcache_groups'));
-        $this->assertTrue(Cache::clearGroup('group_a', 'xcache_groups'));
-        $this->assertFalse(Cache::read('test_groups', 'xcache_groups'));
-
-        $this->assertTrue(Cache::write('test_groups', 'value2', 'xcache_groups'));
-        $this->assertTrue(Cache::clearGroup('group_b', 'xcache_groups'));
-        $this->assertFalse(Cache::read('test_groups', 'xcache_groups'));
-    }
-}