static/dependencies.config.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2010-2023, the Friendica project
   4  *
   5  * @license GNU AGPL version 3 or any later version
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19  *
  20  * The configuration defines "complex" dependencies inside Friendica
  21  * So this classes shouldn't be simple or their dependencies are already defined here.
  22  *
  23  * This kind of dependencies are NOT required to be defined here:
  24  *   - $a = new ClassA(new ClassB());
  25  *   - $a = new ClassA();
  26  *   - $a = new ClassA(Configuration $configuration);
  27  *
  28  * This kind of dependencies SHOULD be defined here:
  29  *   - $a = new ClassA();
  30  *     $b = $a->create();
  31  *
  32  *   - $a = new ClassA($creationPassedVariable);
  33  *
  34  */
  35
  36 use Dice\Dice;
  37 use Friendica\App;
  38 use Friendica\Core\Cache;
  39 use Friendica\Core\Config;
  40 use Friendica\Core\Hooks\Capabilities\ICanManageInstances;
  41 use Friendica\Core\Hooks\Model\InstanceManager;
  42 use Friendica\Core\PConfig;
  43 use Friendica\Core\L10n;
  44 use Friendica\Core\Lock;
  45 use Friendica\Core\Session\Capability\IHandleSessions;
  46 use Friendica\Core\Session\Capability\IHandleUserSessions;
  47 use Friendica\Core\Storage\Repository\StorageManager;
  48 use Friendica\Database\Database;
  49 use Friendica\Database\Definition\DbaDefinition;
  50 use Friendica\Database\Definition\ViewDefinition;
  51 use Friendica\Factory;
  52 use Friendica\Core\Storage\Capability\ICanWriteToStorage;
  53 use Friendica\Model\User\Cookie;
  54 use Friendica\Model\Log\ParsedLogIterator;
  55 use Friendica\Network;
  56 use Friendica\Util;
  57 use Psr\Log\LoggerInterface;
  58
  59 return [
  60         '*'                             => [
  61                 // marks all class result as shared for other creations, so there's just
  62                 // one instance for the whole execution
  63                 'shared' => true,
  64         ],
  65         '$basepath'                     => [
  66                 'instanceOf'      => Util\BasePath::class,
  67                 'call'            => [
  68                         ['getPath', [], Dice::CHAIN_CALL],
  69                 ],
  70                 'constructParams' => [
  71                         dirname(__FILE__, 2),
  72                         $_SERVER
  73                 ]
  74         ],
  75         Util\BasePath::class         => [
  76                 'constructParams' => [
  77                         dirname(__FILE__, 2),
  78                         $_SERVER
  79                 ]
  80         ],
  81         ICanManageInstances::class => [
  82                 'instanceOf' => InstanceManager::class,
  83                 'constructParams' => [
  84                         [Dice::INSTANCE => Dice::SELF],
  85                 ],
  86         ],
  87         Config\Util\ConfigFileManager::class => [
  88                 'instanceOf' => Config\Factory\Config::class,
  89                 'call'       => [
  90                         ['createConfigFileManager', [
  91                                 [Dice::INSTANCE => '$basepath'],
  92                                 $_SERVER,
  93                         ], Dice::CHAIN_CALL],
  94                 ],
  95         ],
  96         Config\ValueObject\Cache::class => [
  97                 'instanceOf' => Config\Factory\Config::class,
  98                 'call'       => [
  99                         ['createCache', [], Dice::CHAIN_CALL],
 100                 ],
 101         ],
 102         App\Mode::class              => [
 103                 'call' => [
 104                         ['determineRunMode', [true, $_SERVER], Dice::CHAIN_CALL],
 105                         ['determine', [
 106                                 [Dice::INSTANCE => '$basepath']
 107                         ], Dice::CHAIN_CALL],
 108                 ],
 109         ],
 110         Config\Capability\IManageConfigValues::class => [
 111                 'instanceOf' => Config\Model\DatabaseConfig::class,
 112                 'constructParams' => [
 113                         $_SERVER,
 114                 ],
 115         ],
 116         PConfig\Capability\IManagePersonalConfigValues::class => [
 117                 'instanceOf' => PConfig\Factory\PConfig::class,
 118                 'call'       => [
 119                         ['create', [], Dice::CHAIN_CALL],
 120                 ]
 121         ],
 122         DbaDefinition::class => [
 123                 'constructParams' => [
 124                         [Dice::INSTANCE => '$basepath'],
 125                 ],
 126                 'call' => [
 127                         ['load', [false], Dice::CHAIN_CALL],
 128                 ],
 129         ],
 130         ViewDefinition::class => [
 131                 'constructParams' => [
 132                         [Dice::INSTANCE => '$basepath'],
 133                 ],
 134                 'call' => [
 135                         ['load', [false], Dice::CHAIN_CALL],
 136                 ],
 137         ],
 138         Database::class                         => [
 139                 'constructParams' => [
 140                         [Dice::INSTANCE => Config\Model\ReadOnlyFileConfig::class],
 141                 ],
 142         ],
 143         /**
 144          * Creates the App\BaseURL
 145          *
 146          * Same as:
 147          *   $baseURL = new App\BaseURL($configuration, $_SERVER);
 148          */
 149         App\BaseURL::class             => [
 150                 'constructParams' => [
 151                         $_SERVER,
 152                 ],
 153         ],
 154         App\Page::class => [
 155                 'constructParams' => [
 156                         [Dice::INSTANCE => '$basepath'],
 157                 ],
 158         ],
 159         /**
 160          * Create a Logger, which implements the LoggerInterface
 161          *
 162          * Same as:
 163          *   $loggerFactory = new Factory\LoggerFactory();
 164          *   $logger = $loggerFactory->create($channel, $configuration, $profiler);
 165          *
 166          * Attention1: We can use DICE for detecting dependencies inside "chained" calls too
 167          * Attention2: The variable "$channel" is passed inside the creation of the dependencies per:
 168          *    $app = $dice->create(App::class, [], ['$channel' => 'index']);
 169          *    and is automatically passed as an argument with the same name
 170          */
 171         LoggerInterface::class          => [
 172                 'instanceOf' => \Friendica\Core\Logger\Factory\Logger::class,
 173                 'constructParams' => [
 174                         'index',
 175                 ],
 176                 'call'       => [
 177                         ['create', [], Dice::CHAIN_CALL],
 178                 ],
 179         ],
 180         '$devLogger'                    => [
 181                 'instanceOf' => \Friendica\Core\Logger\Factory\Logger::class,
 182                 'constructParams' => [
 183                         'dev',
 184                 ],
 185                 'call'       => [
 186                         ['createDev', [], Dice::CHAIN_CALL],
 187                 ]
 188         ],
 189         \Friendica\Core\Logger\Capabilities\IHaveCallIntrospections::class => [
 190                 'instanceOf' => \Friendica\Core\Logger\Util\Introspection::class,
 191                 'constructParams' => [
 192                         \Friendica\Core\Logger\Util\Introspection::IGNORE_CLASS_LIST,
 193                 ],
 194         ],
 195         Cache\Capability\ICanCache::class => [
 196                 'instanceOf' => Cache\Factory\Cache::class,
 197                 'call'       => [
 198                         ['createLocal', [], Dice::CHAIN_CALL],
 199                 ],
 200         ],
 201         Cache\Capability\ICanCacheInMemory::class => [
 202                 'instanceOf' => Cache\Factory\Cache::class,
 203                 'call'       => [
 204                         ['createLocal', [], Dice::CHAIN_CALL],
 205                 ],
 206         ],
 207         Lock\Capability\ICanLock::class => [
 208                 'instanceOf' => Lock\Factory\Lock::class,
 209                 'call'       => [
 210                         ['create', [], Dice::CHAIN_CALL],
 211                 ],
 212         ],
 213         App\Arguments::class => [
 214                 'instanceOf' => App\Arguments::class,
 215                 'call' => [
 216                         ['determine', [$_SERVER, $_GET], Dice::CHAIN_CALL],
 217                 ],
 218         ],
 219         \Friendica\Core\System::class => [
 220                 'constructParams' => [
 221                         [Dice::INSTANCE => '$basepath'],
 222                 ],
 223         ],
 224         App\Router::class => [
 225                 'constructParams' => [
 226                         $_SERVER,
 227                         __DIR__ . '/routes.config.php',
 228                         [Dice::INSTANCE => Dice::SELF],
 229                         null
 230                 ],
 231         ],
 232         L10n::class => [
 233                 'constructParams' => [
 234                         $_SERVER, $_GET
 235                 ],
 236         ],
 237         IHandleSessions::class => [
 238                 'instanceOf' => \Friendica\Core\Session\Factory\Session::class,
 239                 'call' => [
 240                         ['create', [$_SERVER], Dice::CHAIN_CALL],
 241                         ['start', [], Dice::CHAIN_CALL],
 242                 ],
 243         ],
 244         IHandleUserSessions::class => [
 245                 'instanceOf' => \Friendica\Core\Session\Model\UserSession::class,
 246         ],
 247         Cookie::class => [
 248                 'constructParams' => [
 249                         $_COOKIE
 250                 ],
 251         ],
 252         ICanWriteToStorage::class => [
 253                 'instanceOf' => StorageManager::class,
 254                 'call' => [
 255                         ['getBackend', [], Dice::CHAIN_CALL],
 256                 ],
 257         ],
 258         \Friendica\Core\KeyValueStorage\Capabilities\IManageKeyValuePairs::class => [
 259                 'instanceOf' => \Friendica\Core\KeyValueStorage\Type\DBKeyValueStorage::class,
 260         ],
 261         Network\HTTPClient\Capability\ICanSendHttpRequests::class => [
 262                 'instanceOf' => Network\HTTPClient\Factory\HttpClient::class,
 263                 'call'       => [
 264                         ['createClient', [], Dice::CHAIN_CALL],
 265                 ],
 266         ],
 267         Factory\Api\Mastodon\Error::class => [
 268                 'constructParams' => [
 269                         $_SERVER
 270                 ],
 271         ],
 272         ParsedLogIterator::class => [
 273                 'constructParams' => [
 274                         [Dice::INSTANCE => Util\ReversedFileReader::class],
 275                 ]
 276         ],
 277         \Friendica\Core\Worker\Repository\Process::class => [
 278                 'constructParams' => [
 279                         $_SERVER
 280                 ],
 281         ],
 282         App\Request::class => [
 283                 'constructParams' => [
 284                         $_SERVER
 285                 ],
 286         ],
 287         \Psr\Clock\ClockInterface::class => [
 288                 'instanceOf' => Util\Clock\SystemClock::class
 289         ],
 290         \Friendica\Module\Special\HTTPException::class => [
 291                 'constructParams' => [
 292                         $_SERVER
 293                 ],
 294         ],
 295 ];