var/cache/dev/classes.php line 3744

Open in your IDE?
  1. <?php 
  2. namespace Symfony\Component\EventDispatcher
  3. {
  4. interface EventSubscriberInterface
  5. {
  6. public static function getSubscribedEvents();
  7. }
  8. }
  9. namespace Symfony\Component\HttpKernel\EventListener
  10. {
  11. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  12. use Symfony\Component\HttpFoundation\Session\Session;
  13. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  14. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  15. use Symfony\Component\HttpKernel\Event\FinishRequestEvent;
  16. use Symfony\Component\HttpKernel\Event\GetResponseEvent;
  17. use Symfony\Component\HttpKernel\KernelEvents;
  18. abstract class AbstractSessionListener implements EventSubscriberInterface
  19. {
  20. private $sessionUsageStack = array();
  21. public function onKernelRequest(GetResponseEvent $event)
  22. {
  23. if (!$event->isMasterRequest()) {
  24. return;
  25. }
  26. $request = $event->getRequest();
  27. $session = $this->getSession();
  28. $this->sessionUsageStack[] = $session instanceof Session ? $session->getUsageIndex() : null;
  29. if (null === $session || $request->hasSession()) {
  30. return;
  31. }
  32. $request->setSession($session);
  33. }
  34. public function onKernelResponse(FilterResponseEvent $event)
  35. {
  36. if (!$event->isMasterRequest()) {
  37. return;
  38. }
  39. if (!$session = $event->getRequest()->getSession()) {
  40. return;
  41. }
  42. if ($session instanceof Session ? $session->getUsageIndex() !== end($this->sessionUsageStack) : $session->isStarted()) {
  43. $event->getResponse()
  44. ->setPrivate()
  45. ->setMaxAge(0)
  46. ->headers->addCacheControlDirective('must-revalidate');
  47. }
  48. }
  49. public function onFinishRequest(FinishRequestEvent $event)
  50. {
  51. if ($event->isMasterRequest()) {
  52. array_pop($this->sessionUsageStack);
  53. }
  54. }
  55. public static function getSubscribedEvents()
  56. {
  57. return array(
  58. KernelEvents::REQUEST => array('onKernelRequest', 128),
  59. KernelEvents::RESPONSE => array('onKernelResponse', -1000),
  60. KernelEvents::FINISH_REQUEST => array('onFinishRequest'),
  61. );
  62. }
  63. abstract protected function getSession();
  64. }
  65. }
  66. namespace Symfony\Component\HttpKernel\EventListener
  67. {
  68. use Psr\Container\ContainerInterface;
  69. class SessionListener extends AbstractSessionListener
  70. {
  71. private $container;
  72. public function __construct(ContainerInterface $container)
  73. {
  74. $this->container = $container;
  75. }
  76. protected function getSession()
  77. {
  78. if (!$this->container->has('session')) {
  79. return;
  80. }
  81. return $this->container->get('session');
  82. }
  83. }
  84. }
  85. namespace Symfony\Component\HttpFoundation\Session\Storage
  86. {
  87. use Symfony\Component\HttpFoundation\Session\SessionBagInterface;
  88. interface SessionStorageInterface
  89. {
  90. public function start();
  91. public function isStarted();
  92. public function getId();
  93. public function setId($id);
  94. public function getName();
  95. public function setName($name);
  96. public function regenerate($destroy = false, $lifetime = null);
  97. public function save();
  98. public function clear();
  99. public function getBag($name);
  100. public function registerBag(SessionBagInterface $bag);
  101. public function getMetadataBag();
  102. }
  103. }
  104. namespace Symfony\Component\HttpFoundation\Session\Storage
  105. {
  106. use Symfony\Component\HttpFoundation\Session\SessionBagInterface;
  107. use Symfony\Component\HttpFoundation\Session\Storage\Handler\StrictSessionHandler;
  108. use Symfony\Component\HttpFoundation\Session\Storage\Proxy\AbstractProxy;
  109. use Symfony\Component\HttpFoundation\Session\Storage\Proxy\SessionHandlerProxy;
  110. class NativeSessionStorage implements SessionStorageInterface
  111. {
  112. protected $bags = array();
  113. protected $started = false;
  114. protected $closed = false;
  115. protected $saveHandler;
  116. protected $metadataBag;
  117. public function __construct(array $options = array(), $handler = null, MetadataBag $metaBag = null)
  118. {
  119. $options += array('cache_limiter'=>'','cache_expire'=> 0,'use_cookies'=> 1,'lazy_write'=> 1,
  120. );
  121. session_register_shutdown();
  122. $this->setMetadataBag($metaBag);
  123. $this->setOptions($options);
  124. $this->setSaveHandler($handler);
  125. }
  126. public function getSaveHandler()
  127. {
  128. return $this->saveHandler;
  129. }
  130. public function start()
  131. {
  132. if ($this->started) {
  133. return true;
  134. }
  135. if (\PHP_SESSION_ACTIVE === session_status()) {
  136. throw new \RuntimeException('Failed to start the session: already started by PHP.');
  137. }
  138. if (ini_get('session.use_cookies') && headers_sent($file, $line)) {
  139. throw new \RuntimeException(sprintf('Failed to start the session because headers have already been sent by "%s" at line %d.', $file, $line));
  140. }
  141. if (!session_start()) {
  142. throw new \RuntimeException('Failed to start the session');
  143. }
  144. $this->loadSession();
  145. return true;
  146. }
  147. public function getId()
  148. {
  149. return $this->saveHandler->getId();
  150. }
  151. public function setId($id)
  152. {
  153. $this->saveHandler->setId($id);
  154. }
  155. public function getName()
  156. {
  157. return $this->saveHandler->getName();
  158. }
  159. public function setName($name)
  160. {
  161. $this->saveHandler->setName($name);
  162. }
  163. public function regenerate($destroy = false, $lifetime = null)
  164. {
  165. if (\PHP_SESSION_ACTIVE !== session_status()) {
  166. return false;
  167. }
  168. if (headers_sent()) {
  169. return false;
  170. }
  171. if (null !== $lifetime) {
  172. ini_set('session.cookie_lifetime', $lifetime);
  173. }
  174. if ($destroy) {
  175. $this->metadataBag->stampNew();
  176. }
  177. $isRegenerated = session_regenerate_id($destroy);
  178. $this->loadSession();
  179. return $isRegenerated;
  180. }
  181. public function save()
  182. {
  183. $session = $_SESSION;
  184. foreach ($this->bags as $bag) {
  185. if (empty($_SESSION[$key = $bag->getStorageKey()])) {
  186. unset($_SESSION[$key]);
  187. }
  188. }
  189. if (array($key = $this->metadataBag->getStorageKey()) === array_keys($_SESSION)) {
  190. unset($_SESSION[$key]);
  191. }
  192. $previousHandler = set_error_handler(function ($type, $msg, $file, $line) use (&$previousHandler) {
  193. if (E_WARNING === $type && 0 === strpos($msg,'session_write_close():')) {
  194. $handler = $this->saveHandler instanceof SessionHandlerProxy ? $this->saveHandler->getHandler() : $this->saveHandler;
  195. $msg = sprintf('session_write_close(): Failed to write session data with "%s" handler', \get_class($handler));
  196. }
  197. return $previousHandler ? $previousHandler($type, $msg, $file, $line) : false;
  198. });
  199. try {
  200. session_write_close();
  201. } finally {
  202. restore_error_handler();
  203. $_SESSION = $session;
  204. }
  205. $this->closed = true;
  206. $this->started = false;
  207. }
  208. public function clear()
  209. {
  210. foreach ($this->bags as $bag) {
  211. $bag->clear();
  212. }
  213. $_SESSION = array();
  214. $this->loadSession();
  215. }
  216. public function registerBag(SessionBagInterface $bag)
  217. {
  218. if ($this->started) {
  219. throw new \LogicException('Cannot register a bag when the session is already started.');
  220. }
  221. $this->bags[$bag->getName()] = $bag;
  222. }
  223. public function getBag($name)
  224. {
  225. if (!isset($this->bags[$name])) {
  226. throw new \InvalidArgumentException(sprintf('The SessionBagInterface %s is not registered.', $name));
  227. }
  228. if (!$this->started && $this->saveHandler->isActive()) {
  229. $this->loadSession();
  230. } elseif (!$this->started) {
  231. $this->start();
  232. }
  233. return $this->bags[$name];
  234. }
  235. public function setMetadataBag(MetadataBag $metaBag = null)
  236. {
  237. if (null === $metaBag) {
  238. $metaBag = new MetadataBag();
  239. }
  240. $this->metadataBag = $metaBag;
  241. }
  242. public function getMetadataBag()
  243. {
  244. return $this->metadataBag;
  245. }
  246. public function isStarted()
  247. {
  248. return $this->started;
  249. }
  250. public function setOptions(array $options)
  251. {
  252. if (headers_sent() || \PHP_SESSION_ACTIVE === session_status()) {
  253. return;
  254. }
  255. $validOptions = array_flip(array('cache_expire','cache_limiter','cookie_domain','cookie_httponly','cookie_lifetime','cookie_path','cookie_secure','entropy_file','entropy_length','gc_divisor','gc_maxlifetime','gc_probability','hash_bits_per_character','hash_function','lazy_write','name','referer_check','serialize_handler','use_strict_mode','use_cookies','use_only_cookies','use_trans_sid','upload_progress.enabled','upload_progress.cleanup','upload_progress.prefix','upload_progress.name','upload_progress.freq','upload_progress.min_freq','url_rewriter.tags','sid_length','sid_bits_per_character','trans_sid_hosts','trans_sid_tags',
  256. ));
  257. foreach ($options as $key => $value) {
  258. if (isset($validOptions[$key])) {
  259. ini_set('url_rewriter.tags'!== $key ?'session.'.$key : $key, $value);
  260. }
  261. }
  262. }
  263. public function setSaveHandler($saveHandler = null)
  264. {
  265. if (!$saveHandler instanceof AbstractProxy &&
  266. !$saveHandler instanceof \SessionHandlerInterface &&
  267. null !== $saveHandler) {
  268. throw new \InvalidArgumentException('Must be instance of AbstractProxy; implement \SessionHandlerInterface; or be null.');
  269. }
  270. if (!$saveHandler instanceof AbstractProxy && $saveHandler instanceof \SessionHandlerInterface) {
  271. $saveHandler = new SessionHandlerProxy($saveHandler);
  272. } elseif (!$saveHandler instanceof AbstractProxy) {
  273. $saveHandler = new SessionHandlerProxy(new StrictSessionHandler(new \SessionHandler()));
  274. }
  275. $this->saveHandler = $saveHandler;
  276. if (headers_sent() || \PHP_SESSION_ACTIVE === session_status()) {
  277. return;
  278. }
  279. if ($this->saveHandler instanceof SessionHandlerProxy) {
  280. session_set_save_handler($this->saveHandler, false);
  281. }
  282. }
  283. protected function loadSession(array &$session = null)
  284. {
  285. if (null === $session) {
  286. $session = &$_SESSION;
  287. }
  288. $bags = array_merge($this->bags, array($this->metadataBag));
  289. foreach ($bags as $bag) {
  290. $key = $bag->getStorageKey();
  291. $session[$key] = isset($session[$key]) ? $session[$key] : array();
  292. $bag->initialize($session[$key]);
  293. }
  294. $this->started = true;
  295. $this->closed = false;
  296. }
  297. }
  298. }
  299. namespace Symfony\Component\HttpFoundation\Session\Storage
  300. {
  301. class PhpBridgeSessionStorage extends NativeSessionStorage
  302. {
  303. public function __construct($handler = null, MetadataBag $metaBag = null)
  304. {
  305. $this->setMetadataBag($metaBag);
  306. $this->setSaveHandler($handler);
  307. }
  308. public function start()
  309. {
  310. if ($this->started) {
  311. return true;
  312. }
  313. $this->loadSession();
  314. return true;
  315. }
  316. public function clear()
  317. {
  318. foreach ($this->bags as $bag) {
  319. $bag->clear();
  320. }
  321. $this->loadSession();
  322. }
  323. }
  324. }
  325. namespace Symfony\Component\HttpFoundation\Session\Storage\Handler
  326. {
  327. class NativeSessionHandler extends \SessionHandler
  328. {
  329. public function __construct()
  330. {
  331. @trigger_error('The '.__NAMESPACE__.'\NativeSessionHandler class is deprecated since Symfony 3.4 and will be removed in 4.0. Use the \SessionHandler class instead.', E_USER_DEPRECATED);
  332. }
  333. }
  334. }
  335. namespace Symfony\Component\HttpFoundation\Session\Storage\Handler
  336. {
  337. class NativeFileSessionHandler extends NativeSessionHandler
  338. {
  339. public function __construct($savePath = null)
  340. {
  341. if (null === $savePath) {
  342. $savePath = ini_get('session.save_path');
  343. }
  344. $baseDir = $savePath;
  345. if ($count = substr_count($savePath,';')) {
  346. if ($count > 2) {
  347. throw new \InvalidArgumentException(sprintf('Invalid argument $savePath \'%s\'', $savePath));
  348. }
  349. $baseDir = ltrim(strrchr($savePath,';'),';');
  350. }
  351. if ($baseDir && !is_dir($baseDir) && !@mkdir($baseDir, 0777, true) && !is_dir($baseDir)) {
  352. throw new \RuntimeException(sprintf('Session Storage was not able to create directory "%s"', $baseDir));
  353. }
  354. ini_set('session.save_path', $savePath);
  355. ini_set('session.save_handler','files');
  356. }
  357. }
  358. }
  359. namespace Symfony\Component\HttpFoundation\Session\Storage\Proxy
  360. {
  361. abstract class AbstractProxy
  362. {
  363. protected $wrapper = false;
  364. protected $saveHandlerName;
  365. public function getSaveHandlerName()
  366. {
  367. return $this->saveHandlerName;
  368. }
  369. public function isSessionHandlerInterface()
  370. {
  371. return $this instanceof \SessionHandlerInterface;
  372. }
  373. public function isWrapper()
  374. {
  375. return $this->wrapper;
  376. }
  377. public function isActive()
  378. {
  379. return \PHP_SESSION_ACTIVE === session_status();
  380. }
  381. public function getId()
  382. {
  383. return session_id();
  384. }
  385. public function setId($id)
  386. {
  387. if ($this->isActive()) {
  388. throw new \LogicException('Cannot change the ID of an active session');
  389. }
  390. session_id($id);
  391. }
  392. public function getName()
  393. {
  394. return session_name();
  395. }
  396. public function setName($name)
  397. {
  398. if ($this->isActive()) {
  399. throw new \LogicException('Cannot change the name of an active session');
  400. }
  401. session_name($name);
  402. }
  403. }
  404. }
  405. namespace
  406. {
  407. interface SessionUpdateTimestampHandlerInterface
  408. {
  409. public function validateId($key);
  410. public function updateTimestamp($key, $val);
  411. }
  412. }
  413. namespace Symfony\Component\HttpFoundation\Session\Storage\Proxy
  414. {
  415. class SessionHandlerProxy extends AbstractProxy implements \SessionHandlerInterface, \SessionUpdateTimestampHandlerInterface
  416. {
  417. protected $handler;
  418. public function __construct(\SessionHandlerInterface $handler)
  419. {
  420. $this->handler = $handler;
  421. $this->wrapper = ($handler instanceof \SessionHandler);
  422. $this->saveHandlerName = $this->wrapper ? ini_get('session.save_handler') :'user';
  423. }
  424. public function getHandler()
  425. {
  426. return $this->handler;
  427. }
  428. public function open($savePath, $sessionName)
  429. {
  430. return (bool) $this->handler->open($savePath, $sessionName);
  431. }
  432. public function close()
  433. {
  434. return (bool) $this->handler->close();
  435. }
  436. public function read($sessionId)
  437. {
  438. return (string) $this->handler->read($sessionId);
  439. }
  440. public function write($sessionId, $data)
  441. {
  442. return (bool) $this->handler->write($sessionId, $data);
  443. }
  444. public function destroy($sessionId)
  445. {
  446. return (bool) $this->handler->destroy($sessionId);
  447. }
  448. public function gc($maxlifetime)
  449. {
  450. return (bool) $this->handler->gc($maxlifetime);
  451. }
  452. public function validateId($sessionId)
  453. {
  454. return !$this->handler instanceof \SessionUpdateTimestampHandlerInterface || $this->handler->validateId($sessionId);
  455. }
  456. public function updateTimestamp($sessionId, $data)
  457. {
  458. return $this->handler instanceof \SessionUpdateTimestampHandlerInterface ? $this->handler->updateTimestamp($sessionId, $data) : $this->write($sessionId, $data);
  459. }
  460. }
  461. }
  462. namespace Symfony\Component\HttpFoundation\Session
  463. {
  464. use Symfony\Component\HttpFoundation\Session\Storage\MetadataBag;
  465. interface SessionInterface
  466. {
  467. public function start();
  468. public function getId();
  469. public function setId($id);
  470. public function getName();
  471. public function setName($name);
  472. public function invalidate($lifetime = null);
  473. public function migrate($destroy = false, $lifetime = null);
  474. public function save();
  475. public function has($name);
  476. public function get($name, $default = null);
  477. public function set($name, $value);
  478. public function all();
  479. public function replace(array $attributes);
  480. public function remove($name);
  481. public function clear();
  482. public function isStarted();
  483. public function registerBag(SessionBagInterface $bag);
  484. public function getBag($name);
  485. public function getMetadataBag();
  486. }
  487. }
  488. namespace Symfony\Component\HttpFoundation\Session
  489. {
  490. use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBag;
  491. use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBagInterface;
  492. use Symfony\Component\HttpFoundation\Session\Flash\FlashBag;
  493. use Symfony\Component\HttpFoundation\Session\Flash\FlashBagInterface;
  494. use Symfony\Component\HttpFoundation\Session\Storage\NativeSessionStorage;
  495. use Symfony\Component\HttpFoundation\Session\Storage\SessionStorageInterface;
  496. class Session implements SessionInterface, \IteratorAggregate, \Countable
  497. {
  498. protected $storage;
  499. private $flashName;
  500. private $attributeName;
  501. private $data = array();
  502. private $usageIndex = 0;
  503. public function __construct(SessionStorageInterface $storage = null, AttributeBagInterface $attributes = null, FlashBagInterface $flashes = null)
  504. {
  505. $this->storage = $storage ?: new NativeSessionStorage();
  506. $attributes = $attributes ?: new AttributeBag();
  507. $this->attributeName = $attributes->getName();
  508. $this->registerBag($attributes);
  509. $flashes = $flashes ?: new FlashBag();
  510. $this->flashName = $flashes->getName();
  511. $this->registerBag($flashes);
  512. }
  513. public function start()
  514. {
  515. return $this->storage->start();
  516. }
  517. public function has($name)
  518. {
  519. return $this->getAttributeBag()->has($name);
  520. }
  521. public function get($name, $default = null)
  522. {
  523. return $this->getAttributeBag()->get($name, $default);
  524. }
  525. public function set($name, $value)
  526. {
  527. $this->getAttributeBag()->set($name, $value);
  528. }
  529. public function all()
  530. {
  531. return $this->getAttributeBag()->all();
  532. }
  533. public function replace(array $attributes)
  534. {
  535. $this->getAttributeBag()->replace($attributes);
  536. }
  537. public function remove($name)
  538. {
  539. return $this->getAttributeBag()->remove($name);
  540. }
  541. public function clear()
  542. {
  543. $this->getAttributeBag()->clear();
  544. }
  545. public function isStarted()
  546. {
  547. return $this->storage->isStarted();
  548. }
  549. public function getIterator()
  550. {
  551. return new \ArrayIterator($this->getAttributeBag()->all());
  552. }
  553. public function count()
  554. {
  555. return \count($this->getAttributeBag()->all());
  556. }
  557. public function getUsageIndex()
  558. {
  559. return $this->usageIndex;
  560. }
  561. public function isEmpty()
  562. {
  563. if ($this->isStarted()) {
  564. ++$this->usageIndex;
  565. }
  566. foreach ($this->data as &$data) {
  567. if (!empty($data)) {
  568. return false;
  569. }
  570. }
  571. return true;
  572. }
  573. public function invalidate($lifetime = null)
  574. {
  575. $this->storage->clear();
  576. return $this->migrate(true, $lifetime);
  577. }
  578. public function migrate($destroy = false, $lifetime = null)
  579. {
  580. return $this->storage->regenerate($destroy, $lifetime);
  581. }
  582. public function save()
  583. {
  584. $this->storage->save();
  585. }
  586. public function getId()
  587. {
  588. return $this->storage->getId();
  589. }
  590. public function setId($id)
  591. {
  592. if ($this->storage->getId() !== $id) {
  593. $this->storage->setId($id);
  594. }
  595. }
  596. public function getName()
  597. {
  598. return $this->storage->getName();
  599. }
  600. public function setName($name)
  601. {
  602. $this->storage->setName($name);
  603. }
  604. public function getMetadataBag()
  605. {
  606. ++$this->usageIndex;
  607. return $this->storage->getMetadataBag();
  608. }
  609. public function registerBag(SessionBagInterface $bag)
  610. {
  611. $this->storage->registerBag(new SessionBagProxy($bag, $this->data, $this->usageIndex));
  612. }
  613. public function getBag($name)
  614. {
  615. return $this->storage->getBag($name)->getBag();
  616. }
  617. public function getFlashBag()
  618. {
  619. return $this->getBag($this->flashName);
  620. }
  621. private function getAttributeBag()
  622. {
  623. return $this->getBag($this->attributeName);
  624. }
  625. }
  626. }
  627. namespace Symfony\Bundle\FrameworkBundle\Templating
  628. {
  629. use Symfony\Component\DependencyInjection\ContainerInterface;
  630. use Symfony\Component\HttpFoundation\Request;
  631. use Symfony\Component\HttpFoundation\Session\Session;
  632. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  633. class GlobalVariables
  634. {
  635. protected $container;
  636. public function __construct(ContainerInterface $container)
  637. {
  638. $this->container = $container;
  639. }
  640. public function getToken()
  641. {
  642. if (!$this->container->has('security.token_storage')) {
  643. return;
  644. }
  645. return $this->container->get('security.token_storage')->getToken();
  646. }
  647. public function getUser()
  648. {
  649. if (!$token = $this->getToken()) {
  650. return;
  651. }
  652. $user = $token->getUser();
  653. if (!\is_object($user)) {
  654. return;
  655. }
  656. return $user;
  657. }
  658. public function getRequest()
  659. {
  660. if ($this->container->has('request_stack')) {
  661. return $this->container->get('request_stack')->getCurrentRequest();
  662. }
  663. }
  664. public function getSession()
  665. {
  666. if ($request = $this->getRequest()) {
  667. return $request->getSession();
  668. }
  669. }
  670. public function getEnvironment()
  671. {
  672. return $this->container->getParameter('kernel.environment');
  673. }
  674. public function getDebug()
  675. {
  676. return (bool) $this->container->getParameter('kernel.debug');
  677. }
  678. }
  679. }
  680. namespace Symfony\Component\Templating
  681. {
  682. interface TemplateReferenceInterface
  683. {
  684. public function all();
  685. public function set($name, $value);
  686. public function get($name);
  687. public function getPath();
  688. public function getLogicalName();
  689. public function __toString();
  690. }
  691. }
  692. namespace Symfony\Component\Templating
  693. {
  694. class TemplateReference implements TemplateReferenceInterface
  695. {
  696. protected $parameters;
  697. public function __construct($name = null, $engine = null)
  698. {
  699. $this->parameters = array('name'=> $name,'engine'=> $engine,
  700. );
  701. }
  702. public function __toString()
  703. {
  704. return $this->getLogicalName();
  705. }
  706. public function set($name, $value)
  707. {
  708. if (array_key_exists($name, $this->parameters)) {
  709. $this->parameters[$name] = $value;
  710. } else {
  711. throw new \InvalidArgumentException(sprintf('The template does not support the "%s" parameter.', $name));
  712. }
  713. return $this;
  714. }
  715. public function get($name)
  716. {
  717. if (array_key_exists($name, $this->parameters)) {
  718. return $this->parameters[$name];
  719. }
  720. throw new \InvalidArgumentException(sprintf('The template does not support the "%s" parameter.', $name));
  721. }
  722. public function all()
  723. {
  724. return $this->parameters;
  725. }
  726. public function getPath()
  727. {
  728. return $this->parameters['name'];
  729. }
  730. public function getLogicalName()
  731. {
  732. return $this->parameters['name'];
  733. }
  734. }
  735. }
  736. namespace Symfony\Bundle\FrameworkBundle\Templating
  737. {
  738. use Symfony\Component\Templating\TemplateReference as BaseTemplateReference;
  739. class TemplateReference extends BaseTemplateReference
  740. {
  741. public function __construct($bundle = null, $controller = null, $name = null, $format = null, $engine = null)
  742. {
  743. $this->parameters = array('bundle'=> $bundle,'controller'=> $controller,'name'=> $name,'format'=> $format,'engine'=> $engine,
  744. );
  745. }
  746. public function getPath()
  747. {
  748. $controller = str_replace('\\','/', $this->get('controller'));
  749. $path = (empty($controller) ?'': $controller.'/').$this->get('name').'.'.$this->get('format').'.'.$this->get('engine');
  750. return empty($this->parameters['bundle']) ?'views/'.$path :'@'.$this->get('bundle').'/Resources/views/'.$path;
  751. }
  752. public function getLogicalName()
  753. {
  754. return sprintf('%s:%s:%s.%s.%s', $this->parameters['bundle'], $this->parameters['controller'], $this->parameters['name'], $this->parameters['format'], $this->parameters['engine']);
  755. }
  756. }
  757. }
  758. namespace Symfony\Component\Templating
  759. {
  760. interface TemplateNameParserInterface
  761. {
  762. public function parse($name);
  763. }
  764. }
  765. namespace Symfony\Component\Templating
  766. {
  767. class TemplateNameParser implements TemplateNameParserInterface
  768. {
  769. public function parse($name)
  770. {
  771. if ($name instanceof TemplateReferenceInterface) {
  772. return $name;
  773. }
  774. $engine = null;
  775. if (false !== $pos = strrpos($name,'.')) {
  776. $engine = substr($name, $pos + 1);
  777. }
  778. return new TemplateReference($name, $engine);
  779. }
  780. }
  781. }
  782. namespace Symfony\Bundle\FrameworkBundle\Templating
  783. {
  784. use Symfony\Component\HttpKernel\KernelInterface;
  785. use Symfony\Component\Templating\TemplateNameParser as BaseTemplateNameParser;
  786. use Symfony\Component\Templating\TemplateReferenceInterface;
  787. class TemplateNameParser extends BaseTemplateNameParser
  788. {
  789. protected $kernel;
  790. protected $cache = array();
  791. public function __construct(KernelInterface $kernel)
  792. {
  793. $this->kernel = $kernel;
  794. }
  795. public function parse($name)
  796. {
  797. if ($name instanceof TemplateReferenceInterface) {
  798. return $name;
  799. } elseif (isset($this->cache[$name])) {
  800. return $this->cache[$name];
  801. }
  802. $name = str_replace(':/',':', preg_replace('#/{2,}#','/', str_replace('\\','/', $name)));
  803. if (false !== strpos($name,'..')) {
  804. throw new \RuntimeException(sprintf('Template name "%s" contains invalid characters.', $name));
  805. }
  806. if ($this->isAbsolutePath($name) || !preg_match('/^(?:([^:]*):([^:]*):)?(.+)\.([^\.]+)\.([^\.]+)$/', $name, $matches) || 0 === strpos($name,'@')) {
  807. return parent::parse($name);
  808. }
  809. $template = new TemplateReference($matches[1], $matches[2], $matches[3], $matches[4], $matches[5]);
  810. if ($template->get('bundle')) {
  811. try {
  812. $this->kernel->getBundle($template->get('bundle'));
  813. } catch (\Exception $e) {
  814. throw new \InvalidArgumentException(sprintf('Template name "%s" is not valid.', $name), 0, $e);
  815. }
  816. }
  817. return $this->cache[$name] = $template;
  818. }
  819. private function isAbsolutePath($file)
  820. {
  821. $isAbsolute = (bool) preg_match('#^(?:/|[a-zA-Z]:)#', $file);
  822. if ($isAbsolute) {
  823. @trigger_error('Absolute template path support is deprecated since Symfony 3.1 and will be removed in 4.0.', E_USER_DEPRECATED);
  824. }
  825. return $isAbsolute;
  826. }
  827. }
  828. }
  829. namespace Symfony\Component\Config
  830. {
  831. use Symfony\Component\Config\Exception\FileLocatorFileNotFoundException;
  832. interface FileLocatorInterface
  833. {
  834. public function locate($name, $currentPath = null, $first = true);
  835. }
  836. }
  837. namespace Symfony\Bundle\FrameworkBundle\Templating\Loader
  838. {
  839. use Symfony\Component\Config\FileLocatorInterface;
  840. use Symfony\Component\Templating\TemplateReferenceInterface;
  841. class TemplateLocator implements FileLocatorInterface
  842. {
  843. protected $locator;
  844. protected $cache;
  845. private $cacheHits = array();
  846. public function __construct(FileLocatorInterface $locator, $cacheDir = null)
  847. {
  848. if (null !== $cacheDir && file_exists($cache = $cacheDir.'/templates.php')) {
  849. $this->cache = require $cache;
  850. }
  851. $this->locator = $locator;
  852. }
  853. protected function getCacheKey($template)
  854. {
  855. return $template->getLogicalName();
  856. }
  857. public function locate($template, $currentPath = null, $first = true)
  858. {
  859. if (!$template instanceof TemplateReferenceInterface) {
  860. throw new \InvalidArgumentException('The template must be an instance of TemplateReferenceInterface.');
  861. }
  862. $key = $this->getCacheKey($template);
  863. if (isset($this->cacheHits[$key])) {
  864. return $this->cacheHits[$key];
  865. }
  866. if (isset($this->cache[$key])) {
  867. return $this->cacheHits[$key] = realpath($this->cache[$key]) ?: $this->cache[$key];
  868. }
  869. try {
  870. return $this->cacheHits[$key] = $this->locator->locate($template->getPath(), $currentPath);
  871. } catch (\InvalidArgumentException $e) {
  872. throw new \InvalidArgumentException(sprintf('Unable to find template "%s" : "%s".', $template, $e->getMessage()), 0, $e);
  873. }
  874. }
  875. }
  876. }
  877. namespace Symfony\Component\Cache
  878. {
  879. interface ResettableInterface
  880. {
  881. public function reset();
  882. }
  883. }
  884. namespace Psr\Log
  885. {
  886. interface LoggerAwareInterface
  887. {
  888. public function setLogger(LoggerInterface $logger);
  889. }
  890. }
  891. namespace Psr\Cache
  892. {
  893. interface CacheItemPoolInterface
  894. {
  895. public function getItem($key);
  896. public function getItems(array $keys = array());
  897. public function hasItem($key);
  898. public function clear();
  899. public function deleteItem($key);
  900. public function deleteItems(array $keys);
  901. public function save(CacheItemInterface $item);
  902. public function saveDeferred(CacheItemInterface $item);
  903. public function commit();
  904. }
  905. }
  906. namespace Symfony\Component\Cache\Adapter
  907. {
  908. use Psr\Cache\CacheItemPoolInterface;
  909. use Symfony\Component\Cache\CacheItem;
  910. interface AdapterInterface extends CacheItemPoolInterface
  911. {
  912. public function getItem($key);
  913. public function getItems(array $keys = array());
  914. }
  915. }
  916. namespace Psr\Log
  917. {
  918. trait LoggerAwareTrait
  919. {
  920. protected $logger;
  921. public function setLogger(LoggerInterface $logger)
  922. {
  923. $this->logger = $logger;
  924. }
  925. }
  926. }
  927. namespace Symfony\Component\Cache\Traits
  928. {
  929. use Psr\Log\LoggerAwareTrait;
  930. use Symfony\Component\Cache\CacheItem;
  931. trait AbstractTrait
  932. {
  933. use LoggerAwareTrait;
  934. private $namespace;
  935. private $namespaceVersion ='';
  936. private $versioningIsEnabled = false;
  937. private $deferred = array();
  938. protected $maxIdLength;
  939. abstract protected function doFetch(array $ids);
  940. abstract protected function doHave($id);
  941. abstract protected function doClear($namespace);
  942. abstract protected function doDelete(array $ids);
  943. abstract protected function doSave(array $values, $lifetime);
  944. public function hasItem($key)
  945. {
  946. $id = $this->getId($key);
  947. if (isset($this->deferred[$key])) {
  948. $this->commit();
  949. }
  950. try {
  951. return $this->doHave($id);
  952. } catch (\Exception $e) {
  953. CacheItem::log($this->logger,'Failed to check if key "{key}" is cached', array('key'=> $key,'exception'=> $e));
  954. return false;
  955. }
  956. }
  957. public function clear()
  958. {
  959. $this->deferred = array();
  960. if ($cleared = $this->versioningIsEnabled) {
  961. $namespaceVersion = substr_replace(base64_encode(pack('V', mt_rand())),':', 5);
  962. try {
  963. $cleared = $this->doSave(array('@'.$this->namespace => $namespaceVersion), 0);
  964. } catch (\Exception $e) {
  965. $cleared = false;
  966. }
  967. if ($cleared = true === $cleared || array() === $cleared) {
  968. $this->namespaceVersion = $namespaceVersion;
  969. }
  970. }
  971. try {
  972. return $this->doClear($this->namespace) || $cleared;
  973. } catch (\Exception $e) {
  974. CacheItem::log($this->logger,'Failed to clear the cache', array('exception'=> $e));
  975. return false;
  976. }
  977. }
  978. public function deleteItem($key)
  979. {
  980. return $this->deleteItems(array($key));
  981. }
  982. public function deleteItems(array $keys)
  983. {
  984. $ids = array();
  985. foreach ($keys as $key) {
  986. $ids[$key] = $this->getId($key);
  987. unset($this->deferred[$key]);
  988. }
  989. try {
  990. if ($this->doDelete($ids)) {
  991. return true;
  992. }
  993. } catch (\Exception $e) {
  994. }
  995. $ok = true;
  996. foreach ($ids as $key => $id) {
  997. try {
  998. $e = null;
  999. if ($this->doDelete(array($id))) {
  1000. continue;
  1001. }
  1002. } catch (\Exception $e) {
  1003. }
  1004. CacheItem::log($this->logger,'Failed to delete key "{key}"', array('key'=> $key,'exception'=> $e));
  1005. $ok = false;
  1006. }
  1007. return $ok;
  1008. }
  1009. public function enableVersioning($enable = true)
  1010. {
  1011. $wasEnabled = $this->versioningIsEnabled;
  1012. $this->versioningIsEnabled = (bool) $enable;
  1013. $this->namespaceVersion ='';
  1014. return $wasEnabled;
  1015. }
  1016. public function reset()
  1017. {
  1018. if ($this->deferred) {
  1019. $this->commit();
  1020. }
  1021. $this->namespaceVersion ='';
  1022. }
  1023. protected static function unserialize($value)
  1024. {
  1025. if ('b:0;'=== $value) {
  1026. return false;
  1027. }
  1028. $unserializeCallbackHandler = ini_set('unserialize_callback_func', __CLASS__.'::handleUnserializeCallback');
  1029. try {
  1030. if (false !== $value = unserialize($value)) {
  1031. return $value;
  1032. }
  1033. throw new \DomainException('Failed to unserialize cached value');
  1034. } catch (\Error $e) {
  1035. throw new \ErrorException($e->getMessage(), $e->getCode(), E_ERROR, $e->getFile(), $e->getLine());
  1036. } finally {
  1037. ini_set('unserialize_callback_func', $unserializeCallbackHandler);
  1038. }
  1039. }
  1040. private function getId($key)
  1041. {
  1042. CacheItem::validateKey($key);
  1043. if ($this->versioningIsEnabled &&''=== $this->namespaceVersion) {
  1044. $this->namespaceVersion ='1:';
  1045. try {
  1046. foreach ($this->doFetch(array('@'.$this->namespace)) as $v) {
  1047. $this->namespaceVersion = $v;
  1048. }
  1049. if ('1:'=== $this->namespaceVersion) {
  1050. $this->namespaceVersion = substr_replace(base64_encode(pack('V', time())),':', 5);
  1051. $this->doSave(array('@'.$this->namespace => $this->namespaceVersion), 0);
  1052. }
  1053. } catch (\Exception $e) {
  1054. }
  1055. }
  1056. if (null === $this->maxIdLength) {
  1057. return $this->namespace.$this->namespaceVersion.$key;
  1058. }
  1059. if (\strlen($id = $this->namespace.$this->namespaceVersion.$key) > $this->maxIdLength) {
  1060. $id = $this->namespace.$this->namespaceVersion.substr_replace(base64_encode(hash('sha256', $key, true)),':', -(\strlen($this->namespaceVersion) + 22));
  1061. }
  1062. return $id;
  1063. }
  1064. public static function handleUnserializeCallback($class)
  1065. {
  1066. throw new \DomainException('Class not found: '.$class);
  1067. }
  1068. }
  1069. }
  1070. namespace Symfony\Component\Cache\Traits
  1071. {
  1072. use Symfony\Component\Cache\CacheItem;
  1073. use Symfony\Component\Cache\Exception\CacheException;
  1074. trait ApcuTrait
  1075. {
  1076. public static function isSupported()
  1077. {
  1078. return \function_exists('apcu_fetch') && ini_get('apc.enabled');
  1079. }
  1080. private function init($namespace, $defaultLifetime, $version)
  1081. {
  1082. if (!static::isSupported()) {
  1083. throw new CacheException('APCu is not enabled');
  1084. }
  1085. if ('cli'=== \PHP_SAPI) {
  1086. ini_set('apc.use_request_time', 0);
  1087. }
  1088. parent::__construct($namespace, $defaultLifetime);
  1089. if (null !== $version) {
  1090. CacheItem::validateKey($version);
  1091. if (!apcu_exists($version.'@'.$namespace)) {
  1092. $this->doClear($namespace);
  1093. apcu_add($version.'@'.$namespace, null);
  1094. }
  1095. }
  1096. }
  1097. protected function doFetch(array $ids)
  1098. {
  1099. try {
  1100. foreach (apcu_fetch($ids, $ok) ?: array() as $k => $v) {
  1101. if (null !== $v || $ok) {
  1102. yield $k => $v;
  1103. }
  1104. }
  1105. } catch (\Error $e) {
  1106. throw new \ErrorException($e->getMessage(), $e->getCode(), E_ERROR, $e->getFile(), $e->getLine());
  1107. }
  1108. }
  1109. protected function doHave($id)
  1110. {
  1111. return apcu_exists($id);
  1112. }
  1113. protected function doClear($namespace)
  1114. {
  1115. return isset($namespace[0]) && class_exists('APCuIterator', false) && ('cli'!== \PHP_SAPI || ini_get('apc.enable_cli'))
  1116. ? apcu_delete(new \APCuIterator(sprintf('/^%s/', preg_quote($namespace,'/')), APC_ITER_KEY))
  1117. : apcu_clear_cache();
  1118. }
  1119. protected function doDelete(array $ids)
  1120. {
  1121. foreach ($ids as $id) {
  1122. apcu_delete($id);
  1123. }
  1124. return true;
  1125. }
  1126. protected function doSave(array $values, $lifetime)
  1127. {
  1128. try {
  1129. if (false === $failures = apcu_store($values, null, $lifetime)) {
  1130. $failures = $values;
  1131. }
  1132. return array_keys($failures);
  1133. } catch (\Error $e) {
  1134. } catch (\Exception $e) {
  1135. }
  1136. if (1 === \count($values)) {
  1137. apcu_delete(key($values));
  1138. }
  1139. throw $e;
  1140. }
  1141. }
  1142. }
  1143. namespace Symfony\Component\Cache\Adapter
  1144. {
  1145. use Psr\Cache\CacheItemInterface;
  1146. use Psr\Log\LoggerAwareInterface;
  1147. use Psr\Log\LoggerInterface;
  1148. use Psr\Log\NullLogger;
  1149. use Symfony\Component\Cache\CacheItem;
  1150. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  1151. use Symfony\Component\Cache\ResettableInterface;
  1152. use Symfony\Component\Cache\Traits\AbstractTrait;
  1153. abstract class AbstractAdapter implements AdapterInterface, LoggerAwareInterface, ResettableInterface
  1154. {
  1155. use AbstractTrait;
  1156. private static $apcuSupported;
  1157. private static $phpFilesSupported;
  1158. private $createCacheItem;
  1159. private $mergeByLifetime;
  1160. protected function __construct($namespace ='', $defaultLifetime = 0)
  1161. {
  1162. $this->namespace =''=== $namespace ?'': CacheItem::validateKey($namespace).':';
  1163. if (null !== $this->maxIdLength && \strlen($namespace) > $this->maxIdLength - 24) {
  1164. throw new InvalidArgumentException(sprintf('Namespace must be %d chars max, %d given ("%s")', $this->maxIdLength - 24, \strlen($namespace), $namespace));
  1165. }
  1166. $this->createCacheItem = \Closure::bind(
  1167. function ($key, $value, $isHit) use ($defaultLifetime) {
  1168. $item = new CacheItem();
  1169. $item->key = $key;
  1170. $item->value = $value;
  1171. $item->isHit = $isHit;
  1172. $item->defaultLifetime = $defaultLifetime;
  1173. return $item;
  1174. },
  1175. null,
  1176. CacheItem::class
  1177. );
  1178. $getId = function ($key) { return $this->getId((string) $key); };
  1179. $this->mergeByLifetime = \Closure::bind(
  1180. function ($deferred, $namespace, &$expiredIds) use ($getId) {
  1181. $byLifetime = array();
  1182. $now = time();
  1183. $expiredIds = array();
  1184. foreach ($deferred as $key => $item) {
  1185. if (null === $item->expiry) {
  1186. $byLifetime[0 < $item->defaultLifetime ? $item->defaultLifetime : 0][$getId($key)] = $item->value;
  1187. } elseif ($item->expiry > $now) {
  1188. $byLifetime[$item->expiry - $now][$getId($key)] = $item->value;
  1189. } else {
  1190. $expiredIds[] = $getId($key);
  1191. }
  1192. }
  1193. return $byLifetime;
  1194. },
  1195. null,
  1196. CacheItem::class
  1197. );
  1198. }
  1199. public static function createSystemCache($namespace, $defaultLifetime, $version, $directory, LoggerInterface $logger = null)
  1200. {
  1201. if (null === self::$apcuSupported) {
  1202. self::$apcuSupported = ApcuAdapter::isSupported();
  1203. }
  1204. if (!self::$apcuSupported && null === self::$phpFilesSupported) {
  1205. self::$phpFilesSupported = PhpFilesAdapter::isSupported();
  1206. }
  1207. if (self::$phpFilesSupported) {
  1208. $opcache = new PhpFilesAdapter($namespace, $defaultLifetime, $directory);
  1209. if (null !== $logger) {
  1210. $opcache->setLogger($logger);
  1211. }
  1212. return $opcache;
  1213. }
  1214. $fs = new FilesystemAdapter($namespace, $defaultLifetime, $directory);
  1215. if (null !== $logger) {
  1216. $fs->setLogger($logger);
  1217. }
  1218. if (!self::$apcuSupported) {
  1219. return $fs;
  1220. }
  1221. $apcu = new ApcuAdapter($namespace, (int) $defaultLifetime / 5, $version);
  1222. if ('cli'=== \PHP_SAPI && !ini_get('apc.enable_cli')) {
  1223. $apcu->setLogger(new NullLogger());
  1224. } elseif (null !== $logger) {
  1225. $apcu->setLogger($logger);
  1226. }
  1227. return new ChainAdapter(array($apcu, $fs));
  1228. }
  1229. public static function createConnection($dsn, array $options = array())
  1230. {
  1231. if (!\is_string($dsn)) {
  1232. throw new InvalidArgumentException(sprintf('The %s() method expect argument #1 to be string, %s given.', __METHOD__, \gettype($dsn)));
  1233. }
  1234. if (0 === strpos($dsn,'redis://')) {
  1235. return RedisAdapter::createConnection($dsn, $options);
  1236. }
  1237. if (0 === strpos($dsn,'memcached://')) {
  1238. return MemcachedAdapter::createConnection($dsn, $options);
  1239. }
  1240. throw new InvalidArgumentException(sprintf('Unsupported DSN: %s.', $dsn));
  1241. }
  1242. public function getItem($key)
  1243. {
  1244. if ($this->deferred) {
  1245. $this->commit();
  1246. }
  1247. $id = $this->getId($key);
  1248. $f = $this->createCacheItem;
  1249. $isHit = false;
  1250. $value = null;
  1251. try {
  1252. foreach ($this->doFetch(array($id)) as $value) {
  1253. $isHit = true;
  1254. }
  1255. } catch (\Exception $e) {
  1256. CacheItem::log($this->logger,'Failed to fetch key "{key}"', array('key'=> $key,'exception'=> $e));
  1257. }
  1258. return $f($key, $value, $isHit);
  1259. }
  1260. public function getItems(array $keys = array())
  1261. {
  1262. if ($this->deferred) {
  1263. $this->commit();
  1264. }
  1265. $ids = array();
  1266. foreach ($keys as $key) {
  1267. $ids[] = $this->getId($key);
  1268. }
  1269. try {
  1270. $items = $this->doFetch($ids);
  1271. } catch (\Exception $e) {
  1272. CacheItem::log($this->logger,'Failed to fetch requested items', array('keys'=> $keys,'exception'=> $e));
  1273. $items = array();
  1274. }
  1275. $ids = array_combine($ids, $keys);
  1276. return $this->generateItems($items, $ids);
  1277. }
  1278. public function save(CacheItemInterface $item)
  1279. {
  1280. if (!$item instanceof CacheItem) {
  1281. return false;
  1282. }
  1283. $this->deferred[$item->getKey()] = $item;
  1284. return $this->commit();
  1285. }
  1286. public function saveDeferred(CacheItemInterface $item)
  1287. {
  1288. if (!$item instanceof CacheItem) {
  1289. return false;
  1290. }
  1291. $this->deferred[$item->getKey()] = $item;
  1292. return true;
  1293. }
  1294. public function commit()
  1295. {
  1296. $ok = true;
  1297. $byLifetime = $this->mergeByLifetime;
  1298. $byLifetime = $byLifetime($this->deferred, $this->namespace, $expiredIds);
  1299. $retry = $this->deferred = array();
  1300. if ($expiredIds) {
  1301. $this->doDelete($expiredIds);
  1302. }
  1303. foreach ($byLifetime as $lifetime => $values) {
  1304. try {
  1305. $e = $this->doSave($values, $lifetime);
  1306. } catch (\Exception $e) {
  1307. }
  1308. if (true === $e || array() === $e) {
  1309. continue;
  1310. }
  1311. if (\is_array($e) || 1 === \count($values)) {
  1312. foreach (\is_array($e) ? $e : array_keys($values) as $id) {
  1313. $ok = false;
  1314. $v = $values[$id];
  1315. $type = \is_object($v) ? \get_class($v) : \gettype($v);
  1316. CacheItem::log($this->logger,'Failed to save key "{key}" ({type})', array('key'=> substr($id, \strlen($this->namespace)),'type'=> $type,'exception'=> $e instanceof \Exception ? $e : null));
  1317. }
  1318. } else {
  1319. foreach ($values as $id => $v) {
  1320. $retry[$lifetime][] = $id;
  1321. }
  1322. }
  1323. }
  1324. foreach ($retry as $lifetime => $ids) {
  1325. foreach ($ids as $id) {
  1326. try {
  1327. $v = $byLifetime[$lifetime][$id];
  1328. $e = $this->doSave(array($id => $v), $lifetime);
  1329. } catch (\Exception $e) {
  1330. }
  1331. if (true === $e || array() === $e) {
  1332. continue;
  1333. }
  1334. $ok = false;
  1335. $type = \is_object($v) ? \get_class($v) : \gettype($v);
  1336. CacheItem::log($this->logger,'Failed to save key "{key}" ({type})', array('key'=> substr($id, \strlen($this->namespace)),'type'=> $type,'exception'=> $e instanceof \Exception ? $e : null));
  1337. }
  1338. }
  1339. return $ok;
  1340. }
  1341. public function __destruct()
  1342. {
  1343. if ($this->deferred) {
  1344. $this->commit();
  1345. }
  1346. }
  1347. private function generateItems($items, &$keys)
  1348. {
  1349. $f = $this->createCacheItem;
  1350. try {
  1351. foreach ($items as $id => $value) {
  1352. if (!isset($keys[$id])) {
  1353. $id = key($keys);
  1354. }
  1355. $key = $keys[$id];
  1356. unset($keys[$id]);
  1357. yield $key => $f($key, $value, true);
  1358. }
  1359. } catch (\Exception $e) {
  1360. CacheItem::log($this->logger,'Failed to fetch requested items', array('keys'=> array_values($keys),'exception'=> $e));
  1361. }
  1362. foreach ($keys as $key) {
  1363. yield $key => $f($key, null, false);
  1364. }
  1365. }
  1366. }
  1367. }
  1368. namespace Symfony\Component\Cache\Adapter
  1369. {
  1370. use Symfony\Component\Cache\Traits\ApcuTrait;
  1371. class ApcuAdapter extends AbstractAdapter
  1372. {
  1373. use ApcuTrait;
  1374. public function __construct($namespace ='', $defaultLifetime = 0, $version = null)
  1375. {
  1376. $this->init($namespace, $defaultLifetime, $version);
  1377. }
  1378. }
  1379. }
  1380. namespace Symfony\Component\Cache
  1381. {
  1382. interface PruneableInterface
  1383. {
  1384. public function prune();
  1385. }
  1386. }
  1387. namespace Symfony\Component\Cache\Traits
  1388. {
  1389. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  1390. trait FilesystemCommonTrait
  1391. {
  1392. private $directory;
  1393. private $tmp;
  1394. private function init($namespace, $directory)
  1395. {
  1396. if (!isset($directory[0])) {
  1397. $directory = sys_get_temp_dir().'/symfony-cache';
  1398. } else {
  1399. $directory = realpath($directory) ?: $directory;
  1400. }
  1401. if (isset($namespace[0])) {
  1402. if (preg_match('#[^-+_.A-Za-z0-9]#', $namespace, $match)) {
  1403. throw new InvalidArgumentException(sprintf('Namespace contains "%s" but only characters in [-+_.A-Za-z0-9] are allowed.', $match[0]));
  1404. }
  1405. $directory .= \DIRECTORY_SEPARATOR.$namespace;
  1406. }
  1407. if (!file_exists($directory)) {
  1408. @mkdir($directory, 0777, true);
  1409. }
  1410. $directory .= \DIRECTORY_SEPARATOR;
  1411. if ('\\'=== \DIRECTORY_SEPARATOR && \strlen($directory) > 234) {
  1412. throw new InvalidArgumentException(sprintf('Cache directory too long (%s)', $directory));
  1413. }
  1414. $this->directory = $directory;
  1415. }
  1416. protected function doClear($namespace)
  1417. {
  1418. $ok = true;
  1419. foreach (new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($this->directory, \FilesystemIterator::SKIP_DOTS)) as $file) {
  1420. $ok = ($file->isDir() || @unlink($file) || !file_exists($file)) && $ok;
  1421. }
  1422. return $ok;
  1423. }
  1424. protected function doDelete(array $ids)
  1425. {
  1426. $ok = true;
  1427. foreach ($ids as $id) {
  1428. $file = $this->getFile($id);
  1429. $ok = (!file_exists($file) || @unlink($file) || !file_exists($file)) && $ok;
  1430. }
  1431. return $ok;
  1432. }
  1433. private function write($file, $data, $expiresAt = null)
  1434. {
  1435. set_error_handler(__CLASS__.'::throwError');
  1436. try {
  1437. if (null === $this->tmp) {
  1438. $this->tmp = $this->directory.uniqid('', true);
  1439. }
  1440. file_put_contents($this->tmp, $data);
  1441. if (null !== $expiresAt) {
  1442. touch($this->tmp, $expiresAt);
  1443. }
  1444. return rename($this->tmp, $file);
  1445. } finally {
  1446. restore_error_handler();
  1447. }
  1448. }
  1449. private function getFile($id, $mkdir = false)
  1450. {
  1451. $hash = str_replace('/','-', base64_encode(hash('sha256', static::class.$id, true)));
  1452. $dir = $this->directory.strtoupper($hash[0].\DIRECTORY_SEPARATOR.$hash[1].\DIRECTORY_SEPARATOR);
  1453. if ($mkdir && !file_exists($dir)) {
  1454. @mkdir($dir, 0777, true);
  1455. }
  1456. return $dir.substr($hash, 2, 20);
  1457. }
  1458. public static function throwError($type, $message, $file, $line)
  1459. {
  1460. throw new \ErrorException($message, 0, $type, $file, $line);
  1461. }
  1462. public function __destruct()
  1463. {
  1464. if (method_exists(parent::class,'__destruct')) {
  1465. parent::__destruct();
  1466. }
  1467. if (null !== $this->tmp && file_exists($this->tmp)) {
  1468. unlink($this->tmp);
  1469. }
  1470. }
  1471. }
  1472. }
  1473. namespace Symfony\Component\Cache\Traits
  1474. {
  1475. use Symfony\Component\Cache\Exception\CacheException;
  1476. trait FilesystemTrait
  1477. {
  1478. use FilesystemCommonTrait;
  1479. public function prune()
  1480. {
  1481. $time = time();
  1482. $pruned = true;
  1483. foreach (new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($this->directory, \FilesystemIterator::SKIP_DOTS), \RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
  1484. if (!$h = @fopen($file,'rb')) {
  1485. continue;
  1486. }
  1487. if (($expiresAt = (int) fgets($h)) && $time >= $expiresAt) {
  1488. fclose($h);
  1489. $pruned = @unlink($file) && !file_exists($file) && $pruned;
  1490. } else {
  1491. fclose($h);
  1492. }
  1493. }
  1494. return $pruned;
  1495. }
  1496. protected function doFetch(array $ids)
  1497. {
  1498. $values = array();
  1499. $now = time();
  1500. foreach ($ids as $id) {
  1501. $file = $this->getFile($id);
  1502. if (!file_exists($file) || !$h = @fopen($file,'rb')) {
  1503. continue;
  1504. }
  1505. if (($expiresAt = (int) fgets($h)) && $now >= $expiresAt) {
  1506. fclose($h);
  1507. @unlink($file);
  1508. } else {
  1509. $i = rawurldecode(rtrim(fgets($h)));
  1510. $value = stream_get_contents($h);
  1511. fclose($h);
  1512. if ($i === $id) {
  1513. $values[$id] = parent::unserialize($value);
  1514. }
  1515. }
  1516. }
  1517. return $values;
  1518. }
  1519. protected function doHave($id)
  1520. {
  1521. $file = $this->getFile($id);
  1522. return file_exists($file) && (@filemtime($file) > time() || $this->doFetch(array($id)));
  1523. }
  1524. protected function doSave(array $values, $lifetime)
  1525. {
  1526. $ok = true;
  1527. $expiresAt = $lifetime ? (time() + $lifetime) : 0;
  1528. foreach ($values as $id => $value) {
  1529. $ok = $this->write($this->getFile($id, true), $expiresAt."\n".rawurlencode($id)."\n".serialize($value), $expiresAt) && $ok;
  1530. }
  1531. if (!$ok && !is_writable($this->directory)) {
  1532. throw new CacheException(sprintf('Cache directory is not writable (%s)', $this->directory));
  1533. }
  1534. return $ok;
  1535. }
  1536. }
  1537. }
  1538. namespace Symfony\Component\Cache\Adapter
  1539. {
  1540. use Symfony\Component\Cache\PruneableInterface;
  1541. use Symfony\Component\Cache\Traits\FilesystemTrait;
  1542. class FilesystemAdapter extends AbstractAdapter implements PruneableInterface
  1543. {
  1544. use FilesystemTrait;
  1545. public function __construct($namespace ='', $defaultLifetime = 0, $directory = null)
  1546. {
  1547. parent::__construct('', $defaultLifetime);
  1548. $this->init($namespace, $directory);
  1549. }
  1550. }
  1551. }
  1552. namespace Psr\Cache
  1553. {
  1554. interface CacheItemInterface
  1555. {
  1556. public function getKey();
  1557. public function get();
  1558. public function isHit();
  1559. public function set($value);
  1560. public function expiresAt($expiration);
  1561. public function expiresAfter($time);
  1562. }
  1563. }
  1564. namespace Symfony\Component\Cache
  1565. {
  1566. use Psr\Cache\CacheItemInterface;
  1567. use Psr\Log\LoggerInterface;
  1568. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  1569. final class CacheItem implements CacheItemInterface
  1570. {
  1571. protected $key;
  1572. protected $value;
  1573. protected $isHit = false;
  1574. protected $expiry;
  1575. protected $defaultLifetime;
  1576. protected $tags = array();
  1577. protected $prevTags = array();
  1578. protected $innerItem;
  1579. protected $poolHash;
  1580. public function getKey()
  1581. {
  1582. return $this->key;
  1583. }
  1584. public function get()
  1585. {
  1586. return $this->value;
  1587. }
  1588. public function isHit()
  1589. {
  1590. return $this->isHit;
  1591. }
  1592. public function set($value)
  1593. {
  1594. $this->value = $value;
  1595. return $this;
  1596. }
  1597. public function expiresAt($expiration)
  1598. {
  1599. if (null === $expiration) {
  1600. $this->expiry = $this->defaultLifetime > 0 ? time() + $this->defaultLifetime : null;
  1601. } elseif ($expiration instanceof \DateTimeInterface) {
  1602. $this->expiry = (int) $expiration->format('U');
  1603. } else {
  1604. throw new InvalidArgumentException(sprintf('Expiration date must implement DateTimeInterface or be null, "%s" given', \is_object($expiration) ? \get_class($expiration) : \gettype($expiration)));
  1605. }
  1606. return $this;
  1607. }
  1608. public function expiresAfter($time)
  1609. {
  1610. if (null === $time) {
  1611. $this->expiry = $this->defaultLifetime > 0 ? time() + $this->defaultLifetime : null;
  1612. } elseif ($time instanceof \DateInterval) {
  1613. $this->expiry = (int) \DateTime::createFromFormat('U', time())->add($time)->format('U');
  1614. } elseif (\is_int($time)) {
  1615. $this->expiry = $time + time();
  1616. } else {
  1617. throw new InvalidArgumentException(sprintf('Expiration date must be an integer, a DateInterval or null, "%s" given', \is_object($time) ? \get_class($time) : \gettype($time)));
  1618. }
  1619. return $this;
  1620. }
  1621. public function tag($tags)
  1622. {
  1623. if (!\is_array($tags)) {
  1624. $tags = array($tags);
  1625. }
  1626. foreach ($tags as $tag) {
  1627. if (!\is_string($tag)) {
  1628. throw new InvalidArgumentException(sprintf('Cache tag must be string, "%s" given', \is_object($tag) ? \get_class($tag) : \gettype($tag)));
  1629. }
  1630. if (isset($this->tags[$tag])) {
  1631. continue;
  1632. }
  1633. if (''=== $tag) {
  1634. throw new InvalidArgumentException('Cache tag length must be greater than zero');
  1635. }
  1636. if (false !== strpbrk($tag,'{}()/\@:')) {
  1637. throw new InvalidArgumentException(sprintf('Cache tag "%s" contains reserved characters {}()/\@:', $tag));
  1638. }
  1639. $this->tags[$tag] = $tag;
  1640. }
  1641. return $this;
  1642. }
  1643. public function getPreviousTags()
  1644. {
  1645. return $this->prevTags;
  1646. }
  1647. public static function validateKey($key)
  1648. {
  1649. if (!\is_string($key)) {
  1650. throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given', \is_object($key) ? \get_class($key) : \gettype($key)));
  1651. }
  1652. if (''=== $key) {
  1653. throw new InvalidArgumentException('Cache key length must be greater than zero');
  1654. }
  1655. if (false !== strpbrk($key,'{}()/\@:')) {
  1656. throw new InvalidArgumentException(sprintf('Cache key "%s" contains reserved characters {}()/\@:', $key));
  1657. }
  1658. return $key;
  1659. }
  1660. public static function log(LoggerInterface $logger = null, $message, $context = array())
  1661. {
  1662. if ($logger) {
  1663. $logger->warning($message, $context);
  1664. } else {
  1665. $replace = array();
  1666. foreach ($context as $k => $v) {
  1667. if (is_scalar($v)) {
  1668. $replace['{'.$k.'}'] = $v;
  1669. }
  1670. }
  1671. @trigger_error(strtr($message, $replace), E_USER_WARNING);
  1672. }
  1673. }
  1674. }
  1675. }
  1676. namespace Symfony\Component\Routing
  1677. {
  1678. interface RequestContextAwareInterface
  1679. {
  1680. public function setContext(RequestContext $context);
  1681. public function getContext();
  1682. }
  1683. }
  1684. namespace Symfony\Component\Routing\Generator
  1685. {
  1686. use Symfony\Component\Routing\Exception\InvalidParameterException;
  1687. use Symfony\Component\Routing\Exception\MissingMandatoryParametersException;
  1688. use Symfony\Component\Routing\Exception\RouteNotFoundException;
  1689. use Symfony\Component\Routing\RequestContextAwareInterface;
  1690. interface UrlGeneratorInterface extends RequestContextAwareInterface
  1691. {
  1692. const ABSOLUTE_URL = 0;
  1693. const ABSOLUTE_PATH = 1;
  1694. const RELATIVE_PATH = 2;
  1695. const NETWORK_PATH = 3;
  1696. public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH);
  1697. }
  1698. }
  1699. namespace Symfony\Component\Routing\Generator
  1700. {
  1701. interface ConfigurableRequirementsInterface
  1702. {
  1703. public function setStrictRequirements($enabled);
  1704. public function isStrictRequirements();
  1705. }
  1706. }
  1707. namespace Symfony\Component\Routing\Generator
  1708. {
  1709. use Psr\Log\LoggerInterface;
  1710. use Symfony\Component\Routing\Exception\InvalidParameterException;
  1711. use Symfony\Component\Routing\Exception\MissingMandatoryParametersException;
  1712. use Symfony\Component\Routing\Exception\RouteNotFoundException;
  1713. use Symfony\Component\Routing\RequestContext;
  1714. use Symfony\Component\Routing\RouteCollection;
  1715. class UrlGenerator implements UrlGeneratorInterface, ConfigurableRequirementsInterface
  1716. {
  1717. protected $routes;
  1718. protected $context;
  1719. protected $strictRequirements = true;
  1720. protected $logger;
  1721. protected $decodedChars = array('%2F'=>'/','%40'=>'@','%3A'=>':','%3B'=>';','%2C'=>',','%3D'=>'=','%2B'=>'+','%21'=>'!','%2A'=>'*','%7C'=>'|',
  1722. );
  1723. public function __construct(RouteCollection $routes, RequestContext $context, LoggerInterface $logger = null)
  1724. {
  1725. $this->routes = $routes;
  1726. $this->context = $context;
  1727. $this->logger = $logger;
  1728. }
  1729. public function setContext(RequestContext $context)
  1730. {
  1731. $this->context = $context;
  1732. }
  1733. public function getContext()
  1734. {
  1735. return $this->context;
  1736. }
  1737. public function setStrictRequirements($enabled)
  1738. {
  1739. $this->strictRequirements = null === $enabled ? null : (bool) $enabled;
  1740. }
  1741. public function isStrictRequirements()
  1742. {
  1743. return $this->strictRequirements;
  1744. }
  1745. public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH)
  1746. {
  1747. if (null === $route = $this->routes->get($name)) {
  1748. throw new RouteNotFoundException(sprintf('Unable to generate a URL for the named route "%s" as such route does not exist.', $name));
  1749. }
  1750. $compiledRoute = $route->compile();
  1751. return $this->doGenerate($compiledRoute->getVariables(), $route->getDefaults(), $route->getRequirements(), $compiledRoute->getTokens(), $parameters, $name, $referenceType, $compiledRoute->getHostTokens(), $route->getSchemes());
  1752. }
  1753. protected function doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $referenceType, $hostTokens, array $requiredSchemes = array())
  1754. {
  1755. $variables = array_flip($variables);
  1756. $mergedParams = array_replace($defaults, $this->context->getParameters(), $parameters);
  1757. if ($diff = array_diff_key($variables, $mergedParams)) {
  1758. throw new MissingMandatoryParametersException(sprintf('Some mandatory parameters are missing ("%s") to generate a URL for route "%s".', implode('", "', array_keys($diff)), $name));
  1759. }
  1760. $url ='';
  1761. $optional = true;
  1762. $message ='Parameter "{parameter}" for route "{route}" must match "{expected}" ("{given}" given) to generate a corresponding URL.';
  1763. foreach ($tokens as $token) {
  1764. if ('variable'=== $token[0]) {
  1765. if (!$optional || !array_key_exists($token[3], $defaults) || null !== $mergedParams[$token[3]] && (string) $mergedParams[$token[3]] !== (string) $defaults[$token[3]]) {
  1766. if (null !== $this->strictRequirements && !preg_match('#^'.$token[2].'$#'.(empty($token[4]) ?'':'u'), $mergedParams[$token[3]])) {
  1767. if ($this->strictRequirements) {
  1768. throw new InvalidParameterException(strtr($message, array('{parameter}'=> $token[3],'{route}'=> $name,'{expected}'=> $token[2],'{given}'=> $mergedParams[$token[3]])));
  1769. }
  1770. if ($this->logger) {
  1771. $this->logger->error($message, array('parameter'=> $token[3],'route'=> $name,'expected'=> $token[2],'given'=> $mergedParams[$token[3]]));
  1772. }
  1773. return;
  1774. }
  1775. $url = $token[1].$mergedParams[$token[3]].$url;
  1776. $optional = false;
  1777. }
  1778. } else {
  1779. $url = $token[1].$url;
  1780. $optional = false;
  1781. }
  1782. }
  1783. if (''=== $url) {
  1784. $url ='/';
  1785. }
  1786. $url = strtr(rawurlencode($url), $this->decodedChars);
  1787. $url = strtr($url, array('/../'=>'/%2E%2E/','/./'=>'/%2E/'));
  1788. if ('/..'=== substr($url, -3)) {
  1789. $url = substr($url, 0, -2).'%2E%2E';
  1790. } elseif ('/.'=== substr($url, -2)) {
  1791. $url = substr($url, 0, -1).'%2E';
  1792. }
  1793. $schemeAuthority ='';
  1794. $host = $this->context->getHost();
  1795. $scheme = $this->context->getScheme();
  1796. if ($requiredSchemes) {
  1797. if (!\in_array($scheme, $requiredSchemes, true)) {
  1798. $referenceType = self::ABSOLUTE_URL;
  1799. $scheme = current($requiredSchemes);
  1800. }
  1801. }
  1802. if ($hostTokens) {
  1803. $routeHost ='';
  1804. foreach ($hostTokens as $token) {
  1805. if ('variable'=== $token[0]) {
  1806. if (null !== $this->strictRequirements && !preg_match('#^'.$token[2].'$#i'.(empty($token[4]) ?'':'u'), $mergedParams[$token[3]])) {
  1807. if ($this->strictRequirements) {
  1808. throw new InvalidParameterException(strtr($message, array('{parameter}'=> $token[3],'{route}'=> $name,'{expected}'=> $token[2],'{given}'=> $mergedParams[$token[3]])));
  1809. }
  1810. if ($this->logger) {
  1811. $this->logger->error($message, array('parameter'=> $token[3],'route'=> $name,'expected'=> $token[2],'given'=> $mergedParams[$token[3]]));
  1812. }
  1813. return;
  1814. }
  1815. $routeHost = $token[1].$mergedParams[$token[3]].$routeHost;
  1816. } else {
  1817. $routeHost = $token[1].$routeHost;
  1818. }
  1819. }
  1820. if ($routeHost !== $host) {
  1821. $host = $routeHost;
  1822. if (self::ABSOLUTE_URL !== $referenceType) {
  1823. $referenceType = self::NETWORK_PATH;
  1824. }
  1825. }
  1826. }
  1827. if ((self::ABSOLUTE_URL === $referenceType || self::NETWORK_PATH === $referenceType) && !empty($host)) {
  1828. $port ='';
  1829. if ('http'=== $scheme && 80 != $this->context->getHttpPort()) {
  1830. $port =':'.$this->context->getHttpPort();
  1831. } elseif ('https'=== $scheme && 443 != $this->context->getHttpsPort()) {
  1832. $port =':'.$this->context->getHttpsPort();
  1833. }
  1834. $schemeAuthority = self::NETWORK_PATH === $referenceType ?'//': "$scheme://";
  1835. $schemeAuthority .= $host.$port;
  1836. }
  1837. if (self::RELATIVE_PATH === $referenceType) {
  1838. $url = self::getRelativePath($this->context->getPathInfo(), $url);
  1839. } else {
  1840. $url = $schemeAuthority.$this->context->getBaseUrl().$url;
  1841. }
  1842. $extra = array_udiff_assoc(array_diff_key($parameters, $variables), $defaults, function ($a, $b) {
  1843. return $a == $b ? 0 : 1;
  1844. });
  1845. $fragment ='';
  1846. if (isset($defaults['_fragment'])) {
  1847. $fragment = $defaults['_fragment'];
  1848. }
  1849. if (isset($extra['_fragment'])) {
  1850. $fragment = $extra['_fragment'];
  1851. unset($extra['_fragment']);
  1852. }
  1853. if ($extra && $query = http_build_query($extra,'','&', PHP_QUERY_RFC3986)) {
  1854. $url .='?'.strtr($query, array('%2F'=>'/'));
  1855. }
  1856. if (''!== $fragment) {
  1857. $url .='#'.strtr(rawurlencode($fragment), array('%2F'=>'/','%3F'=>'?'));
  1858. }
  1859. return $url;
  1860. }
  1861. public static function getRelativePath($basePath, $targetPath)
  1862. {
  1863. if ($basePath === $targetPath) {
  1864. return'';
  1865. }
  1866. $sourceDirs = explode('/', isset($basePath[0]) &&'/'=== $basePath[0] ? substr($basePath, 1) : $basePath);
  1867. $targetDirs = explode('/', isset($targetPath[0]) &&'/'=== $targetPath[0] ? substr($targetPath, 1) : $targetPath);
  1868. array_pop($sourceDirs);
  1869. $targetFile = array_pop($targetDirs);
  1870. foreach ($sourceDirs as $i => $dir) {
  1871. if (isset($targetDirs[$i]) && $dir === $targetDirs[$i]) {
  1872. unset($sourceDirs[$i], $targetDirs[$i]);
  1873. } else {
  1874. break;
  1875. }
  1876. }
  1877. $targetDirs[] = $targetFile;
  1878. $path = str_repeat('../', \count($sourceDirs)).implode('/', $targetDirs);
  1879. return''=== $path ||'/'=== $path[0]
  1880. || false !== ($colonPos = strpos($path,':')) && ($colonPos < ($slashPos = strpos($path,'/')) || false === $slashPos)
  1881. ? "./$path" : $path;
  1882. }
  1883. }
  1884. }
  1885. namespace Symfony\Component\Routing
  1886. {
  1887. use Symfony\Component\HttpFoundation\Request;
  1888. class RequestContext
  1889. {
  1890. private $baseUrl;
  1891. private $pathInfo;
  1892. private $method;
  1893. private $host;
  1894. private $scheme;
  1895. private $httpPort;
  1896. private $httpsPort;
  1897. private $queryString;
  1898. private $parameters = array();
  1899. public function __construct($baseUrl ='', $method ='GET', $host ='localhost', $scheme ='http', $httpPort = 80, $httpsPort = 443, $path ='/', $queryString ='')
  1900. {
  1901. $this->setBaseUrl($baseUrl);
  1902. $this->setMethod($method);
  1903. $this->setHost($host);
  1904. $this->setScheme($scheme);
  1905. $this->setHttpPort($httpPort);
  1906. $this->setHttpsPort($httpsPort);
  1907. $this->setPathInfo($path);
  1908. $this->setQueryString($queryString);
  1909. }
  1910. public function fromRequest(Request $request)
  1911. {
  1912. $this->setBaseUrl($request->getBaseUrl());
  1913. $this->setPathInfo($request->getPathInfo());
  1914. $this->setMethod($request->getMethod());
  1915. $this->setHost($request->getHost());
  1916. $this->setScheme($request->getScheme());
  1917. $this->setHttpPort($request->isSecure() ? $this->httpPort : $request->getPort());
  1918. $this->setHttpsPort($request->isSecure() ? $request->getPort() : $this->httpsPort);
  1919. $this->setQueryString($request->server->get('QUERY_STRING',''));
  1920. return $this;
  1921. }
  1922. public function getBaseUrl()
  1923. {
  1924. return $this->baseUrl;
  1925. }
  1926. public function setBaseUrl($baseUrl)
  1927. {
  1928. $this->baseUrl = $baseUrl;
  1929. return $this;
  1930. }
  1931. public function getPathInfo()
  1932. {
  1933. return $this->pathInfo;
  1934. }
  1935. public function setPathInfo($pathInfo)
  1936. {
  1937. $this->pathInfo = $pathInfo;
  1938. return $this;
  1939. }
  1940. public function getMethod()
  1941. {
  1942. return $this->method;
  1943. }
  1944. public function setMethod($method)
  1945. {
  1946. $this->method = strtoupper($method);
  1947. return $this;
  1948. }
  1949. public function getHost()
  1950. {
  1951. return $this->host;
  1952. }
  1953. public function setHost($host)
  1954. {
  1955. $this->host = strtolower($host);
  1956. return $this;
  1957. }
  1958. public function getScheme()
  1959. {
  1960. return $this->scheme;
  1961. }
  1962. public function setScheme($scheme)
  1963. {
  1964. $this->scheme = strtolower($scheme);
  1965. return $this;
  1966. }
  1967. public function getHttpPort()
  1968. {
  1969. return $this->httpPort;
  1970. }
  1971. public function setHttpPort($httpPort)
  1972. {
  1973. $this->httpPort = (int) $httpPort;
  1974. return $this;
  1975. }
  1976. public function getHttpsPort()
  1977. {
  1978. return $this->httpsPort;
  1979. }
  1980. public function setHttpsPort($httpsPort)
  1981. {
  1982. $this->httpsPort = (int) $httpsPort;
  1983. return $this;
  1984. }
  1985. public function getQueryString()
  1986. {
  1987. return $this->queryString;
  1988. }
  1989. public function setQueryString($queryString)
  1990. {
  1991. $this->queryString = (string) $queryString;
  1992. return $this;
  1993. }
  1994. public function getParameters()
  1995. {
  1996. return $this->parameters;
  1997. }
  1998. public function setParameters(array $parameters)
  1999. {
  2000. $this->parameters = $parameters;
  2001. return $this;
  2002. }
  2003. public function getParameter($name)
  2004. {
  2005. return isset($this->parameters[$name]) ? $this->parameters[$name] : null;
  2006. }
  2007. public function hasParameter($name)
  2008. {
  2009. return array_key_exists($name, $this->parameters);
  2010. }
  2011. public function setParameter($name, $parameter)
  2012. {
  2013. $this->parameters[$name] = $parameter;
  2014. return $this;
  2015. }
  2016. }
  2017. }
  2018. namespace Symfony\Component\Routing\Matcher
  2019. {
  2020. use Symfony\Component\Routing\Exception\MethodNotAllowedException;
  2021. use Symfony\Component\Routing\Exception\NoConfigurationException;
  2022. use Symfony\Component\Routing\Exception\ResourceNotFoundException;
  2023. use Symfony\Component\Routing\RequestContextAwareInterface;
  2024. interface UrlMatcherInterface extends RequestContextAwareInterface
  2025. {
  2026. public function match($pathinfo);
  2027. }
  2028. }
  2029. namespace Symfony\Component\Routing
  2030. {
  2031. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  2032. use Symfony\Component\Routing\Matcher\UrlMatcherInterface;
  2033. interface RouterInterface extends UrlMatcherInterface, UrlGeneratorInterface
  2034. {
  2035. public function getRouteCollection();
  2036. }
  2037. }
  2038. namespace Symfony\Component\Routing\Matcher
  2039. {
  2040. use Symfony\Component\HttpFoundation\Request;
  2041. use Symfony\Component\Routing\Exception\MethodNotAllowedException;
  2042. use Symfony\Component\Routing\Exception\NoConfigurationException;
  2043. use Symfony\Component\Routing\Exception\ResourceNotFoundException;
  2044. interface RequestMatcherInterface
  2045. {
  2046. public function matchRequest(Request $request);
  2047. }
  2048. }
  2049. namespace Symfony\Component\Routing
  2050. {
  2051. use Psr\Log\LoggerInterface;
  2052. use Symfony\Component\Config\ConfigCacheFactory;
  2053. use Symfony\Component\Config\ConfigCacheFactoryInterface;
  2054. use Symfony\Component\Config\ConfigCacheInterface;
  2055. use Symfony\Component\Config\Loader\LoaderInterface;
  2056. use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
  2057. use Symfony\Component\HttpFoundation\Request;
  2058. use Symfony\Component\Routing\Generator\ConfigurableRequirementsInterface;
  2059. use Symfony\Component\Routing\Generator\Dumper\GeneratorDumperInterface;
  2060. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  2061. use Symfony\Component\Routing\Matcher\Dumper\MatcherDumperInterface;
  2062. use Symfony\Component\Routing\Matcher\RequestMatcherInterface;
  2063. use Symfony\Component\Routing\Matcher\UrlMatcherInterface;
  2064. class Router implements RouterInterface, RequestMatcherInterface
  2065. {
  2066. protected $matcher;
  2067. protected $generator;
  2068. protected $context;
  2069. protected $loader;
  2070. protected $collection;
  2071. protected $resource;
  2072. protected $options = array();
  2073. protected $logger;
  2074. private $configCacheFactory;
  2075. private $expressionLanguageProviders = array();
  2076. public function __construct(LoaderInterface $loader, $resource, array $options = array(), RequestContext $context = null, LoggerInterface $logger = null)
  2077. {
  2078. $this->loader = $loader;
  2079. $this->resource = $resource;
  2080. $this->logger = $logger;
  2081. $this->context = $context ?: new RequestContext();
  2082. $this->setOptions($options);
  2083. }
  2084. public function setOptions(array $options)
  2085. {
  2086. $this->options = array('cache_dir'=> null,'debug'=> false,'generator_class'=>'Symfony\\Component\\Routing\\Generator\\UrlGenerator','generator_base_class'=>'Symfony\\Component\\Routing\\Generator\\UrlGenerator','generator_dumper_class'=>'Symfony\\Component\\Routing\\Generator\\Dumper\\PhpGeneratorDumper','generator_cache_class'=>'ProjectUrlGenerator','matcher_class'=>'Symfony\\Component\\Routing\\Matcher\\UrlMatcher','matcher_base_class'=>'Symfony\\Component\\Routing\\Matcher\\UrlMatcher','matcher_dumper_class'=>'Symfony\\Component\\Routing\\Matcher\\Dumper\\PhpMatcherDumper','matcher_cache_class'=>'ProjectUrlMatcher','resource_type'=> null,'strict_requirements'=> true,
  2087. );
  2088. $invalid = array();
  2089. foreach ($options as $key => $value) {
  2090. if (array_key_exists($key, $this->options)) {
  2091. $this->options[$key] = $value;
  2092. } else {
  2093. $invalid[] = $key;
  2094. }
  2095. }
  2096. if ($invalid) {
  2097. throw new \InvalidArgumentException(sprintf('The Router does not support the following options: "%s".', implode('", "', $invalid)));
  2098. }
  2099. }
  2100. public function setOption($key, $value)
  2101. {
  2102. if (!array_key_exists($key, $this->options)) {
  2103. throw new \InvalidArgumentException(sprintf('The Router does not support the "%s" option.', $key));
  2104. }
  2105. $this->options[$key] = $value;
  2106. }
  2107. public function getOption($key)
  2108. {
  2109. if (!array_key_exists($key, $this->options)) {
  2110. throw new \InvalidArgumentException(sprintf('The Router does not support the "%s" option.', $key));
  2111. }
  2112. return $this->options[$key];
  2113. }
  2114. public function getRouteCollection()
  2115. {
  2116. if (null === $this->collection) {
  2117. $this->collection = $this->loader->load($this->resource, $this->options['resource_type']);
  2118. }
  2119. return $this->collection;
  2120. }
  2121. public function setContext(RequestContext $context)
  2122. {
  2123. $this->context = $context;
  2124. if (null !== $this->matcher) {
  2125. $this->getMatcher()->setContext($context);
  2126. }
  2127. if (null !== $this->generator) {
  2128. $this->getGenerator()->setContext($context);
  2129. }
  2130. }
  2131. public function getContext()
  2132. {
  2133. return $this->context;
  2134. }
  2135. public function setConfigCacheFactory(ConfigCacheFactoryInterface $configCacheFactory)
  2136. {
  2137. $this->configCacheFactory = $configCacheFactory;
  2138. }
  2139. public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH)
  2140. {
  2141. return $this->getGenerator()->generate($name, $parameters, $referenceType);
  2142. }
  2143. public function match($pathinfo)
  2144. {
  2145. return $this->getMatcher()->match($pathinfo);
  2146. }
  2147. public function matchRequest(Request $request)
  2148. {
  2149. $matcher = $this->getMatcher();
  2150. if (!$matcher instanceof RequestMatcherInterface) {
  2151. return $matcher->match($request->getPathInfo());
  2152. }
  2153. return $matcher->matchRequest($request);
  2154. }
  2155. public function getMatcher()
  2156. {
  2157. if (null !== $this->matcher) {
  2158. return $this->matcher;
  2159. }
  2160. if (null === $this->options['cache_dir'] || null === $this->options['matcher_cache_class']) {
  2161. $this->matcher = new $this->options['matcher_class']($this->getRouteCollection(), $this->context);
  2162. if (method_exists($this->matcher,'addExpressionLanguageProvider')) {
  2163. foreach ($this->expressionLanguageProviders as $provider) {
  2164. $this->matcher->addExpressionLanguageProvider($provider);
  2165. }
  2166. }
  2167. return $this->matcher;
  2168. }
  2169. $cache = $this->getConfigCacheFactory()->cache($this->options['cache_dir'].'/'.$this->options['matcher_cache_class'].'.php',
  2170. function (ConfigCacheInterface $cache) {
  2171. $dumper = $this->getMatcherDumperInstance();
  2172. if (method_exists($dumper,'addExpressionLanguageProvider')) {
  2173. foreach ($this->expressionLanguageProviders as $provider) {
  2174. $dumper->addExpressionLanguageProvider($provider);
  2175. }
  2176. }
  2177. $options = array('class'=> $this->options['matcher_cache_class'],'base_class'=> $this->options['matcher_base_class'],
  2178. );
  2179. $cache->write($dumper->dump($options), $this->getRouteCollection()->getResources());
  2180. }
  2181. );
  2182. if (!class_exists($this->options['matcher_cache_class'], false)) {
  2183. require_once $cache->getPath();
  2184. }
  2185. return $this->matcher = new $this->options['matcher_cache_class']($this->context);
  2186. }
  2187. public function getGenerator()
  2188. {
  2189. if (null !== $this->generator) {
  2190. return $this->generator;
  2191. }
  2192. if (null === $this->options['cache_dir'] || null === $this->options['generator_cache_class']) {
  2193. $this->generator = new $this->options['generator_class']($this->getRouteCollection(), $this->context, $this->logger);
  2194. } else {
  2195. $cache = $this->getConfigCacheFactory()->cache($this->options['cache_dir'].'/'.$this->options['generator_cache_class'].'.php',
  2196. function (ConfigCacheInterface $cache) {
  2197. $dumper = $this->getGeneratorDumperInstance();
  2198. $options = array('class'=> $this->options['generator_cache_class'],'base_class'=> $this->options['generator_base_class'],
  2199. );
  2200. $cache->write($dumper->dump($options), $this->getRouteCollection()->getResources());
  2201. }
  2202. );
  2203. if (!class_exists($this->options['generator_cache_class'], false)) {
  2204. require_once $cache->getPath();
  2205. }
  2206. $this->generator = new $this->options['generator_cache_class']($this->context, $this->logger);
  2207. }
  2208. if ($this->generator instanceof ConfigurableRequirementsInterface) {
  2209. $this->generator->setStrictRequirements($this->options['strict_requirements']);
  2210. }
  2211. return $this->generator;
  2212. }
  2213. public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
  2214. {
  2215. $this->expressionLanguageProviders[] = $provider;
  2216. }
  2217. protected function getGeneratorDumperInstance()
  2218. {
  2219. return new $this->options['generator_dumper_class']($this->getRouteCollection());
  2220. }
  2221. protected function getMatcherDumperInstance()
  2222. {
  2223. return new $this->options['matcher_dumper_class']($this->getRouteCollection());
  2224. }
  2225. private function getConfigCacheFactory()
  2226. {
  2227. if (null === $this->configCacheFactory) {
  2228. $this->configCacheFactory = new ConfigCacheFactory($this->options['debug']);
  2229. }
  2230. return $this->configCacheFactory;
  2231. }
  2232. }
  2233. }
  2234. namespace Symfony\Component\Routing\Matcher
  2235. {
  2236. interface RedirectableUrlMatcherInterface
  2237. {
  2238. public function redirect($path, $route, $scheme = null);
  2239. }
  2240. }
  2241. namespace Symfony\Component\Routing\Matcher
  2242. {
  2243. use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
  2244. use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
  2245. use Symfony\Component\HttpFoundation\Request;
  2246. use Symfony\Component\Routing\Exception\MethodNotAllowedException;
  2247. use Symfony\Component\Routing\Exception\NoConfigurationException;
  2248. use Symfony\Component\Routing\Exception\ResourceNotFoundException;
  2249. use Symfony\Component\Routing\RequestContext;
  2250. use Symfony\Component\Routing\Route;
  2251. use Symfony\Component\Routing\RouteCollection;
  2252. class UrlMatcher implements UrlMatcherInterface, RequestMatcherInterface
  2253. {
  2254. const REQUIREMENT_MATCH = 0;
  2255. const REQUIREMENT_MISMATCH = 1;
  2256. const ROUTE_MATCH = 2;
  2257. protected $context;
  2258. protected $allow = array();
  2259. protected $routes;
  2260. protected $request;
  2261. protected $expressionLanguage;
  2262. protected $expressionLanguageProviders = array();
  2263. public function __construct(RouteCollection $routes, RequestContext $context)
  2264. {
  2265. $this->routes = $routes;
  2266. $this->context = $context;
  2267. }
  2268. public function setContext(RequestContext $context)
  2269. {
  2270. $this->context = $context;
  2271. }
  2272. public function getContext()
  2273. {
  2274. return $this->context;
  2275. }
  2276. public function match($pathinfo)
  2277. {
  2278. $this->allow = array();
  2279. if ($ret = $this->matchCollection(rawurldecode($pathinfo), $this->routes)) {
  2280. return $ret;
  2281. }
  2282. if ('/'=== $pathinfo && !$this->allow) {
  2283. throw new NoConfigurationException();
  2284. }
  2285. throw 0 < \count($this->allow)
  2286. ? new MethodNotAllowedException(array_unique($this->allow))
  2287. : new ResourceNotFoundException(sprintf('No routes found for "%s".', $pathinfo));
  2288. }
  2289. public function matchRequest(Request $request)
  2290. {
  2291. $this->request = $request;
  2292. $ret = $this->match($request->getPathInfo());
  2293. $this->request = null;
  2294. return $ret;
  2295. }
  2296. public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
  2297. {
  2298. $this->expressionLanguageProviders[] = $provider;
  2299. }
  2300. protected function matchCollection($pathinfo, RouteCollection $routes)
  2301. {
  2302. foreach ($routes as $name => $route) {
  2303. $compiledRoute = $route->compile();
  2304. if (''!== $compiledRoute->getStaticPrefix() && 0 !== strpos($pathinfo, $compiledRoute->getStaticPrefix())) {
  2305. continue;
  2306. }
  2307. if (!preg_match($compiledRoute->getRegex(), $pathinfo, $matches)) {
  2308. continue;
  2309. }
  2310. $hostMatches = array();
  2311. if ($compiledRoute->getHostRegex() && !preg_match($compiledRoute->getHostRegex(), $this->context->getHost(), $hostMatches)) {
  2312. continue;
  2313. }
  2314. $status = $this->handleRouteRequirements($pathinfo, $name, $route);
  2315. if (self::REQUIREMENT_MISMATCH === $status[0]) {
  2316. continue;
  2317. }
  2318. if ($requiredMethods = $route->getMethods()) {
  2319. if ('HEAD'=== $method = $this->context->getMethod()) {
  2320. $method ='GET';
  2321. }
  2322. if (!\in_array($method, $requiredMethods)) {
  2323. if (self::REQUIREMENT_MATCH === $status[0]) {
  2324. $this->allow = array_merge($this->allow, $requiredMethods);
  2325. }
  2326. continue;
  2327. }
  2328. }
  2329. return $this->getAttributes($route, $name, array_replace($matches, $hostMatches, isset($status[1]) ? $status[1] : array()));
  2330. }
  2331. }
  2332. protected function getAttributes(Route $route, $name, array $attributes)
  2333. {
  2334. $attributes['_route'] = $name;
  2335. return $this->mergeDefaults($attributes, $route->getDefaults());
  2336. }
  2337. protected function handleRouteRequirements($pathinfo, $name, Route $route)
  2338. {
  2339. if ($route->getCondition() && !$this->getExpressionLanguage()->evaluate($route->getCondition(), array('context'=> $this->context,'request'=> $this->request ?: $this->createRequest($pathinfo)))) {
  2340. return array(self::REQUIREMENT_MISMATCH, null);
  2341. }
  2342. $scheme = $this->context->getScheme();
  2343. $status = $route->getSchemes() && !$route->hasScheme($scheme) ? self::REQUIREMENT_MISMATCH : self::REQUIREMENT_MATCH;
  2344. return array($status, null);
  2345. }
  2346. protected function mergeDefaults($params, $defaults)
  2347. {
  2348. foreach ($params as $key => $value) {
  2349. if (!\is_int($key)) {
  2350. $defaults[$key] = $value;
  2351. }
  2352. }
  2353. return $defaults;
  2354. }
  2355. protected function getExpressionLanguage()
  2356. {
  2357. if (null === $this->expressionLanguage) {
  2358. if (!class_exists('Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
  2359. throw new \RuntimeException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
  2360. }
  2361. $this->expressionLanguage = new ExpressionLanguage(null, $this->expressionLanguageProviders);
  2362. }
  2363. return $this->expressionLanguage;
  2364. }
  2365. protected function createRequest($pathinfo)
  2366. {
  2367. if (!class_exists('Symfony\Component\HttpFoundation\Request')) {
  2368. return null;
  2369. }
  2370. return Request::create($this->context->getScheme().'://'.$this->context->getHost().$this->context->getBaseUrl().$pathinfo, $this->context->getMethod(), $this->context->getParameters(), array(), array(), array('SCRIPT_FILENAME'=> $this->context->getBaseUrl(),'SCRIPT_NAME'=> $this->context->getBaseUrl(),
  2371. ));
  2372. }
  2373. }
  2374. }
  2375. namespace Symfony\Component\Routing\Matcher
  2376. {
  2377. use Symfony\Component\Routing\Exception\ResourceNotFoundException;
  2378. use Symfony\Component\Routing\Route;
  2379. abstract class RedirectableUrlMatcher extends UrlMatcher implements RedirectableUrlMatcherInterface
  2380. {
  2381. public function match($pathinfo)
  2382. {
  2383. try {
  2384. $parameters = parent::match($pathinfo);
  2385. } catch (ResourceNotFoundException $e) {
  2386. if ('/'=== substr($pathinfo, -1) || !\in_array($this->context->getMethod(), array('HEAD','GET'))) {
  2387. throw $e;
  2388. }
  2389. try {
  2390. $parameters = parent::match($pathinfo.'/');
  2391. return array_replace($parameters, $this->redirect($pathinfo.'/', isset($parameters['_route']) ? $parameters['_route'] : null));
  2392. } catch (ResourceNotFoundException $e2) {
  2393. throw $e;
  2394. }
  2395. }
  2396. return $parameters;
  2397. }
  2398. protected function handleRouteRequirements($pathinfo, $name, Route $route)
  2399. {
  2400. if ($route->getCondition() && !$this->getExpressionLanguage()->evaluate($route->getCondition(), array('context'=> $this->context,'request'=> $this->request ?: $this->createRequest($pathinfo)))) {
  2401. return array(self::REQUIREMENT_MISMATCH, null);
  2402. }
  2403. $scheme = $this->context->getScheme();
  2404. $schemes = $route->getSchemes();
  2405. if ($schemes && !$route->hasScheme($scheme)) {
  2406. return array(self::ROUTE_MATCH, $this->redirect($pathinfo, $name, current($schemes)));
  2407. }
  2408. return array(self::REQUIREMENT_MATCH, null);
  2409. }
  2410. }
  2411. }
  2412. namespace Symfony\Bundle\FrameworkBundle\Routing
  2413. {
  2414. use Symfony\Component\Routing\Matcher\RedirectableUrlMatcher as BaseMatcher;
  2415. class RedirectableUrlMatcher extends BaseMatcher
  2416. {
  2417. public function redirect($path, $route, $scheme = null)
  2418. {
  2419. return array('_controller'=>'Symfony\\Bundle\\FrameworkBundle\\Controller\\RedirectController::urlRedirectAction','path'=> $path,'permanent'=> true,'scheme'=> $scheme,'httpPort'=> $this->context->getHttpPort(),'httpsPort'=> $this->context->getHttpsPort(),'_route'=> $route,
  2420. );
  2421. }
  2422. }
  2423. }
  2424. namespace Symfony\Component\HttpKernel\CacheWarmer
  2425. {
  2426. interface WarmableInterface
  2427. {
  2428. public function warmUp($cacheDir);
  2429. }
  2430. }
  2431. namespace Symfony\Component\DependencyInjection
  2432. {
  2433. interface ServiceSubscriberInterface
  2434. {
  2435. public static function getSubscribedServices();
  2436. }
  2437. }
  2438. namespace Symfony\Bundle\FrameworkBundle\Routing
  2439. {
  2440. use Symfony\Component\Config\Loader\LoaderInterface;
  2441. use Symfony\Component\DependencyInjection\Config\ContainerParametersResource;
  2442. use Symfony\Component\DependencyInjection\ContainerInterface;
  2443. use Symfony\Component\DependencyInjection\Exception\ParameterNotFoundException;
  2444. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  2445. use Symfony\Component\DependencyInjection\ServiceSubscriberInterface;
  2446. use Symfony\Component\HttpKernel\CacheWarmer\WarmableInterface;
  2447. use Symfony\Component\Routing\RequestContext;
  2448. use Symfony\Component\Routing\RouteCollection;
  2449. use Symfony\Component\Routing\Router as BaseRouter;
  2450. class Router extends BaseRouter implements WarmableInterface, ServiceSubscriberInterface
  2451. {
  2452. private $container;
  2453. private $collectedParameters = array();
  2454. public function __construct(ContainerInterface $container, $resource, array $options = array(), RequestContext $context = null)
  2455. {
  2456. $this->container = $container;
  2457. $this->resource = $resource;
  2458. $this->context = $context ?: new RequestContext();
  2459. $this->setOptions($options);
  2460. }
  2461. public function getRouteCollection()
  2462. {
  2463. if (null === $this->collection) {
  2464. $this->collection = $this->container->get('routing.loader')->load($this->resource, $this->options['resource_type']);
  2465. $this->resolveParameters($this->collection);
  2466. $this->collection->addResource(new ContainerParametersResource($this->collectedParameters));
  2467. }
  2468. return $this->collection;
  2469. }
  2470. public function warmUp($cacheDir)
  2471. {
  2472. $currentDir = $this->getOption('cache_dir');
  2473. $this->setOption('cache_dir', $cacheDir);
  2474. $this->getMatcher();
  2475. $this->getGenerator();
  2476. $this->setOption('cache_dir', $currentDir);
  2477. }
  2478. private function resolveParameters(RouteCollection $collection)
  2479. {
  2480. foreach ($collection as $route) {
  2481. foreach ($route->getDefaults() as $name => $value) {
  2482. $route->setDefault($name, $this->resolve($value));
  2483. }
  2484. foreach ($route->getRequirements() as $name => $value) {
  2485. $route->setRequirement($name, $this->resolve($value));
  2486. }
  2487. $route->setPath($this->resolve($route->getPath()));
  2488. $route->setHost($this->resolve($route->getHost()));
  2489. $schemes = array();
  2490. foreach ($route->getSchemes() as $scheme) {
  2491. $schemes = array_merge($schemes, explode('|', $this->resolve($scheme)));
  2492. }
  2493. $route->setSchemes($schemes);
  2494. $methods = array();
  2495. foreach ($route->getMethods() as $method) {
  2496. $methods = array_merge($methods, explode('|', $this->resolve($method)));
  2497. }
  2498. $route->setMethods($methods);
  2499. $route->setCondition($this->resolve($route->getCondition()));
  2500. }
  2501. }
  2502. private function resolve($value)
  2503. {
  2504. if (\is_array($value)) {
  2505. foreach ($value as $key => $val) {
  2506. $value[$key] = $this->resolve($val);
  2507. }
  2508. return $value;
  2509. }
  2510. if (!\is_string($value)) {
  2511. return $value;
  2512. }
  2513. $container = $this->container;
  2514. $escapedValue = preg_replace_callback('/%%|%([^%\s]++)%/', function ($match) use ($container, $value) {
  2515. if (!isset($match[1])) {
  2516. return'%%';
  2517. }
  2518. if (preg_match('/^env\(\w+\)$/', $match[1])) {
  2519. throw new RuntimeException(sprintf('Using "%%%s%%" is not allowed in routing configuration.', $match[1]));
  2520. }
  2521. $resolved = $container->getParameter($match[1]);
  2522. if (\is_string($resolved) || is_numeric($resolved)) {
  2523. $this->collectedParameters[$match[1]] = $resolved;
  2524. return (string) $resolved;
  2525. }
  2526. throw new RuntimeException(sprintf('The container parameter "%s", used in the route configuration value "%s", must be a string or numeric, but it is of type %s.', $match[1], $value, \gettype($resolved)));
  2527. }, $value);
  2528. return str_replace('%%','%', $escapedValue);
  2529. }
  2530. public static function getSubscribedServices()
  2531. {
  2532. return array('routing.loader'=> LoaderInterface::class,
  2533. );
  2534. }
  2535. }
  2536. }
  2537. namespace Symfony\Component\Cache\Traits
  2538. {
  2539. use Symfony\Component\Cache\PruneableInterface;
  2540. use Symfony\Component\Cache\ResettableInterface;
  2541. trait ProxyTrait
  2542. {
  2543. private $pool;
  2544. public function prune()
  2545. {
  2546. return $this->pool instanceof PruneableInterface && $this->pool->prune();
  2547. }
  2548. public function reset()
  2549. {
  2550. if ($this->pool instanceof ResettableInterface) {
  2551. $this->pool->reset();
  2552. }
  2553. }
  2554. }
  2555. }
  2556. namespace Symfony\Component\Cache\Traits
  2557. {
  2558. use Symfony\Component\Cache\CacheItem;
  2559. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  2560. trait PhpArrayTrait
  2561. {
  2562. use ProxyTrait;
  2563. private $file;
  2564. private $values;
  2565. private $zendDetectUnicode;
  2566. public function warmUp(array $values)
  2567. {
  2568. if (file_exists($this->file)) {
  2569. if (!is_file($this->file)) {
  2570. throw new InvalidArgumentException(sprintf('Cache path exists and is not a file: %s.', $this->file));
  2571. }
  2572. if (!is_writable($this->file)) {
  2573. throw new InvalidArgumentException(sprintf('Cache file is not writable: %s.', $this->file));
  2574. }
  2575. } else {
  2576. $directory = \dirname($this->file);
  2577. if (!is_dir($directory) && !@mkdir($directory, 0777, true)) {
  2578. throw new InvalidArgumentException(sprintf('Cache directory does not exist and cannot be created: %s.', $directory));
  2579. }
  2580. if (!is_writable($directory)) {
  2581. throw new InvalidArgumentException(sprintf('Cache directory is not writable: %s.', $directory));
  2582. }
  2583. }
  2584. $dump =<<<'EOF'
  2585. <?php
  2587. // This file has been auto-generated by the Symfony Cache Component.
  2589. return array(
  2592. EOF
  2593. ;
  2594. foreach ($values as $key => $value) {
  2595. CacheItem::validateKey(\is_int($key) ? (string) $key : $key);
  2596. if (null === $value || \is_object($value)) {
  2597. try {
  2598. $value = serialize($value);
  2599. } catch (\Exception $e) {
  2600. throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable %s value.', $key, \get_class($value)), 0, $e);
  2601. }
  2602. } elseif (\is_array($value)) {
  2603. try {
  2604. $serialized = serialize($value);
  2605. $unserialized = unserialize($serialized);
  2606. } catch (\Exception $e) {
  2607. throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable array value.', $key), 0, $e);
  2608. }
  2609. if ($unserialized !== $value || (false !== strpos($serialized,';R:') && preg_match('/;R:[1-9]/', $serialized))) {
  2610. $value = $serialized;
  2611. }
  2612. } elseif (\is_string($value)) {
  2613. if ('N;'=== $value || (isset($value[2]) &&':'=== $value[1])) {
  2614. $value = serialize($value);
  2615. }
  2616. } elseif (!\is_scalar($value)) {
  2617. throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable %s value.', $key, \gettype($value)));
  2618. }
  2619. $dump .= var_export($key, true).' => '.var_export($value, true).",\n";
  2620. }
  2621. $dump .="\n);\n";
  2622. $dump = str_replace("' . \"\\0\" . '","\0", $dump);
  2623. $tmpFile = uniqid($this->file, true);
  2624. file_put_contents($tmpFile, $dump);
  2625. @chmod($tmpFile, 0666 & ~umask());
  2626. unset($serialized, $unserialized, $value, $dump);
  2627. @rename($tmpFile, $this->file);
  2628. $this->initialize();
  2629. }
  2630. public function clear()
  2631. {
  2632. $this->values = array();
  2633. $cleared = @unlink($this->file) || !file_exists($this->file);
  2634. return $this->pool->clear() && $cleared;
  2635. }
  2636. private function initialize()
  2637. {
  2638. if ($this->zendDetectUnicode) {
  2639. $zmb = ini_set('zend.detect_unicode', 0);
  2640. }
  2641. try {
  2642. $this->values = file_exists($this->file) ? (include $this->file ?: array()) : array();
  2643. } finally {
  2644. if ($this->zendDetectUnicode) {
  2645. ini_set('zend.detect_unicode', $zmb);
  2646. }
  2647. }
  2648. }
  2649. }
  2650. }
  2651. namespace Symfony\Component\Cache\Adapter
  2652. {
  2653. use Psr\Cache\CacheItemInterface;
  2654. use Psr\Cache\CacheItemPoolInterface;
  2655. use Symfony\Component\Cache\CacheItem;
  2656. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  2657. use Symfony\Component\Cache\PruneableInterface;
  2658. use Symfony\Component\Cache\ResettableInterface;
  2659. use Symfony\Component\Cache\Traits\PhpArrayTrait;
  2660. class PhpArrayAdapter implements AdapterInterface, PruneableInterface, ResettableInterface
  2661. {
  2662. use PhpArrayTrait;
  2663. private $createCacheItem;
  2664. public function __construct($file, AdapterInterface $fallbackPool)
  2665. {
  2666. $this->file = $file;
  2667. $this->pool = $fallbackPool;
  2668. $this->zendDetectUnicode = ini_get('zend.detect_unicode');
  2669. $this->createCacheItem = \Closure::bind(
  2670. function ($key, $value, $isHit) {
  2671. $item = new CacheItem();
  2672. $item->key = $key;
  2673. $item->value = $value;
  2674. $item->isHit = $isHit;
  2675. return $item;
  2676. },
  2677. null,
  2678. CacheItem::class
  2679. );
  2680. }
  2681. public static function create($file, CacheItemPoolInterface $fallbackPool)
  2682. {
  2683. if ((\PHP_VERSION_ID >= 70000 && ini_get('opcache.enable')) || \defined('HHVM_VERSION')) {
  2684. if (!$fallbackPool instanceof AdapterInterface) {
  2685. $fallbackPool = new ProxyAdapter($fallbackPool);
  2686. }
  2687. return new static($file, $fallbackPool);
  2688. }
  2689. return $fallbackPool;
  2690. }
  2691. public function getItem($key)
  2692. {
  2693. if (!\is_string($key)) {
  2694. throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
  2695. }
  2696. if (null === $this->values) {
  2697. $this->initialize();
  2698. }
  2699. if (!isset($this->values[$key])) {
  2700. return $this->pool->getItem($key);
  2701. }
  2702. $value = $this->values[$key];
  2703. $isHit = true;
  2704. if ('N;'=== $value) {
  2705. $value = null;
  2706. } elseif (\is_string($value) && isset($value[2]) &&':'=== $value[1]) {
  2707. try {
  2708. $e = null;
  2709. $value = unserialize($value);
  2710. } catch (\Error $e) {
  2711. } catch (\Exception $e) {
  2712. }
  2713. if (null !== $e) {
  2714. $value = null;
  2715. $isHit = false;
  2716. }
  2717. }
  2718. $f = $this->createCacheItem;
  2719. return $f($key, $value, $isHit);
  2720. }
  2721. public function getItems(array $keys = array())
  2722. {
  2723. foreach ($keys as $key) {
  2724. if (!\is_string($key)) {
  2725. throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
  2726. }
  2727. }
  2728. if (null === $this->values) {
  2729. $this->initialize();
  2730. }
  2731. return $this->generateItems($keys);
  2732. }
  2733. public function hasItem($key)
  2734. {
  2735. if (!\is_string($key)) {
  2736. throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
  2737. }
  2738. if (null === $this->values) {
  2739. $this->initialize();
  2740. }
  2741. return isset($this->values[$key]) || $this->pool->hasItem($key);
  2742. }
  2743. public function deleteItem($key)
  2744. {
  2745. if (!\is_string($key)) {
  2746. throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
  2747. }
  2748. if (null === $this->values) {
  2749. $this->initialize();
  2750. }
  2751. return !isset($this->values[$key]) && $this->pool->deleteItem($key);
  2752. }
  2753. public function deleteItems(array $keys)
  2754. {
  2755. $deleted = true;
  2756. $fallbackKeys = array();
  2757. foreach ($keys as $key) {
  2758. if (!\is_string($key)) {
  2759. throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', \is_object($key) ? \get_class($key) : \gettype($key)));
  2760. }
  2761. if (isset($this->values[$key])) {
  2762. $deleted = false;
  2763. } else {
  2764. $fallbackKeys[] = $key;
  2765. }
  2766. }
  2767. if (null === $this->values) {
  2768. $this->initialize();
  2769. }
  2770. if ($fallbackKeys) {
  2771. $deleted = $this->pool->deleteItems($fallbackKeys) && $deleted;
  2772. }
  2773. return $deleted;
  2774. }
  2775. public function save(CacheItemInterface $item)
  2776. {
  2777. if (null === $this->values) {
  2778. $this->initialize();
  2779. }
  2780. return !isset($this->values[$item->getKey()]) && $this->pool->save($item);
  2781. }
  2782. public function saveDeferred(CacheItemInterface $item)
  2783. {
  2784. if (null === $this->values) {
  2785. $this->initialize();
  2786. }
  2787. return !isset($this->values[$item->getKey()]) && $this->pool->saveDeferred($item);
  2788. }
  2789. public function commit()
  2790. {
  2791. return $this->pool->commit();
  2792. }
  2793. private function generateItems(array $keys)
  2794. {
  2795. $f = $this->createCacheItem;
  2796. $fallbackKeys = array();
  2797. foreach ($keys as $key) {
  2798. if (isset($this->values[$key])) {
  2799. $value = $this->values[$key];
  2800. if ('N;'=== $value) {
  2801. yield $key => $f($key, null, true);
  2802. } elseif (\is_string($value) && isset($value[2]) &&':'=== $value[1]) {
  2803. try {
  2804. yield $key => $f($key, unserialize($value), true);
  2805. } catch (\Error $e) {
  2806. yield $key => $f($key, null, false);
  2807. } catch (\Exception $e) {
  2808. yield $key => $f($key, null, false);
  2809. }
  2810. } else {
  2811. yield $key => $f($key, $value, true);
  2812. }
  2813. } else {
  2814. $fallbackKeys[] = $key;
  2815. }
  2816. }
  2817. if ($fallbackKeys) {
  2818. foreach ($this->pool->getItems($fallbackKeys) as $key => $item) {
  2819. yield $key => $item;
  2820. }
  2821. }
  2822. }
  2823. public static function throwOnRequiredClass($class)
  2824. {
  2825. $e = new \ReflectionException("Class $class does not exist");
  2826. $trace = $e->getTrace();
  2827. $autoloadFrame = array('function'=>'spl_autoload_call','args'=> array($class),
  2828. );
  2829. $i = 1 + array_search($autoloadFrame, $trace, true);
  2830. if (isset($trace[$i]['function']) && !isset($trace[$i]['class'])) {
  2831. switch ($trace[$i]['function']) {
  2832. case'get_class_methods':
  2833. case'get_class_vars':
  2834. case'get_parent_class':
  2835. case'is_a':
  2836. case'is_subclass_of':
  2837. case'class_exists':
  2838. case'class_implements':
  2839. case'class_parents':
  2840. case'trait_exists':
  2841. case'defined':
  2842. case'interface_exists':
  2843. case'method_exists':
  2844. case'property_exists':
  2845. case'is_callable':
  2846. return;
  2847. }
  2848. }
  2849. throw $e;
  2850. }
  2851. }
  2852. }
  2853. namespace Doctrine\Common\Cache
  2854. {
  2855. interface MultiPutCache
  2856. {
  2857. function saveMultiple(array $keysAndValues, $lifetime = 0);
  2858. }
  2859. }
  2860. namespace Doctrine\Common\Cache
  2861. {
  2862. interface MultiGetCache
  2863. {
  2864. function fetchMultiple(array $keys);
  2865. }
  2866. }
  2867. namespace Doctrine\Common\Cache
  2868. {
  2869. interface ClearableCache
  2870. {
  2871. public function deleteAll();
  2872. }
  2873. }
  2874. namespace Doctrine\Common\Cache
  2875. {
  2876. interface FlushableCache
  2877. {
  2878. public function flushAll();
  2879. }
  2880. }
  2881. namespace Doctrine\Common\Cache
  2882. {
  2883. interface Cache
  2884. {
  2885. const STATS_HITS ='hits';
  2886. const STATS_MISSES ='misses';
  2887. const STATS_UPTIME ='uptime';
  2888. const STATS_MEMORY_USAGE ='memory_usage';
  2889. const STATS_MEMORY_AVAILABLE ='memory_available';
  2890. const STATS_MEMORY_AVAILIABLE ='memory_available';
  2891. public function fetch($id);
  2892. public function contains($id);
  2893. public function save($id, $data, $lifeTime = 0);
  2894. public function delete($id);
  2895. public function getStats();
  2896. }
  2897. }
  2898. namespace Doctrine\Common\Cache
  2899. {
  2900. abstract class CacheProvider implements Cache, FlushableCache, ClearableCache, MultiGetCache, MultiPutCache
  2901. {
  2902. const DOCTRINE_NAMESPACE_CACHEKEY ='DoctrineNamespaceCacheKey[%s]';
  2903. private $namespace ='';
  2904. private $namespaceVersion;
  2905. public function setNamespace($namespace)
  2906. {
  2907. $this->namespace = (string) $namespace;
  2908. $this->namespaceVersion = null;
  2909. }
  2910. public function getNamespace()
  2911. {
  2912. return $this->namespace;
  2913. }
  2914. public function fetch($id)
  2915. {
  2916. return $this->doFetch($this->getNamespacedId($id));
  2917. }
  2918. public function fetchMultiple(array $keys)
  2919. {
  2920. if (empty($keys)) {
  2921. return array();
  2922. }
  2923. $namespacedKeys = array_combine($keys, array_map(array($this,'getNamespacedId'), $keys));
  2924. $items = $this->doFetchMultiple($namespacedKeys);
  2925. $foundItems = array();
  2926. foreach ($namespacedKeys as $requestedKey => $namespacedKey) {
  2927. if (isset($items[$namespacedKey]) || array_key_exists($namespacedKey, $items)) {
  2928. $foundItems[$requestedKey] = $items[$namespacedKey];
  2929. }
  2930. }
  2931. return $foundItems;
  2932. }
  2933. public function saveMultiple(array $keysAndValues, $lifetime = 0)
  2934. {
  2935. $namespacedKeysAndValues = array();
  2936. foreach ($keysAndValues as $key => $value) {
  2937. $namespacedKeysAndValues[$this->getNamespacedId($key)] = $value;
  2938. }
  2939. return $this->doSaveMultiple($namespacedKeysAndValues, $lifetime);
  2940. }
  2941. public function contains($id)
  2942. {
  2943. return $this->doContains($this->getNamespacedId($id));
  2944. }
  2945. public function save($id, $data, $lifeTime = 0)
  2946. {
  2947. return $this->doSave($this->getNamespacedId($id), $data, $lifeTime);
  2948. }
  2949. public function delete($id)
  2950. {
  2951. return $this->doDelete($this->getNamespacedId($id));
  2952. }
  2953. public function getStats()
  2954. {
  2955. return $this->doGetStats();
  2956. }
  2957. public function flushAll()
  2958. {
  2959. return $this->doFlush();
  2960. }
  2961. public function deleteAll()
  2962. {
  2963. $namespaceCacheKey = $this->getNamespaceCacheKey();
  2964. $namespaceVersion = $this->getNamespaceVersion() + 1;
  2965. if ($this->doSave($namespaceCacheKey, $namespaceVersion)) {
  2966. $this->namespaceVersion = $namespaceVersion;
  2967. return true;
  2968. }
  2969. return false;
  2970. }
  2971. private function getNamespacedId($id)
  2972. {
  2973. $namespaceVersion = $this->getNamespaceVersion();
  2974. return sprintf('%s[%s][%s]', $this->namespace, $id, $namespaceVersion);
  2975. }
  2976. private function getNamespaceCacheKey()
  2977. {
  2978. return sprintf(self::DOCTRINE_NAMESPACE_CACHEKEY, $this->namespace);
  2979. }
  2980. private function getNamespaceVersion()
  2981. {
  2982. if (null !== $this->namespaceVersion) {
  2983. return $this->namespaceVersion;
  2984. }
  2985. $namespaceCacheKey = $this->getNamespaceCacheKey();
  2986. $this->namespaceVersion = $this->doFetch($namespaceCacheKey) ?: 1;
  2987. return $this->namespaceVersion;
  2988. }
  2989. protected function doFetchMultiple(array $keys)
  2990. {
  2991. $returnValues = array();
  2992. foreach ($keys as $key) {
  2993. if (false !== ($item = $this->doFetch($key)) || $this->doContains($key)) {
  2994. $returnValues[$key] = $item;
  2995. }
  2996. }
  2997. return $returnValues;
  2998. }
  2999. abstract protected function doFetch($id);
  3000. abstract protected function doContains($id);
  3001. protected function doSaveMultiple(array $keysAndValues, $lifetime = 0)
  3002. {
  3003. $success = true;
  3004. foreach ($keysAndValues as $key => $value) {
  3005. if (!$this->doSave($key, $value, $lifetime)) {
  3006. $success = false;
  3007. }
  3008. }
  3009. return $success;
  3010. }
  3011. abstract protected function doSave($id, $data, $lifeTime = 0);
  3012. abstract protected function doDelete($id);
  3013. abstract protected function doFlush();
  3014. abstract protected function doGetStats();
  3015. }
  3016. }
  3017. namespace Symfony\Component\Cache
  3018. {
  3019. use Doctrine\Common\Cache\CacheProvider;
  3020. use Psr\Cache\CacheItemPoolInterface;
  3021. class DoctrineProvider extends CacheProvider implements PruneableInterface, ResettableInterface
  3022. {
  3023. private $pool;
  3024. public function __construct(CacheItemPoolInterface $pool)
  3025. {
  3026. $this->pool = $pool;
  3027. }
  3028. public function prune()
  3029. {
  3030. return $this->pool instanceof PruneableInterface && $this->pool->prune();
  3031. }
  3032. public function reset()
  3033. {
  3034. if ($this->pool instanceof ResettableInterface) {
  3035. $this->pool->reset();
  3036. }
  3037. $this->setNamespace($this->getNamespace());
  3038. }
  3039. protected function doFetch($id)
  3040. {
  3041. $item = $this->pool->getItem(rawurlencode($id));
  3042. return $item->isHit() ? $item->get() : false;
  3043. }
  3044. protected function doContains($id)
  3045. {
  3046. return $this->pool->hasItem(rawurlencode($id));
  3047. }
  3048. protected function doSave($id, $data, $lifeTime = 0)
  3049. {
  3050. $item = $this->pool->getItem(rawurlencode($id));
  3051. if (0 < $lifeTime) {
  3052. $item->expiresAfter($lifeTime);
  3053. }
  3054. return $this->pool->save($item->set($data));
  3055. }
  3056. protected function doDelete($id)
  3057. {
  3058. return $this->pool->deleteItem(rawurlencode($id));
  3059. }
  3060. protected function doFlush()
  3061. {
  3062. $this->pool->clear();
  3063. }
  3064. protected function doGetStats()
  3065. {
  3066. }
  3067. }
  3068. }
  3069. namespace Symfony\Component\Config
  3070. {
  3071. use Symfony\Component\Config\Resource\ResourceInterface;
  3072. interface ConfigCacheInterface
  3073. {
  3074. public function getPath();
  3075. public function isFresh();
  3076. public function write($content, array $metadata = null);
  3077. }
  3078. }
  3079. namespace Symfony\Component\Config
  3080. {
  3081. use Symfony\Component\Config\Resource\ResourceInterface;
  3082. use Symfony\Component\Filesystem\Exception\IOException;
  3083. use Symfony\Component\Filesystem\Filesystem;
  3084. class ResourceCheckerConfigCache implements ConfigCacheInterface
  3085. {
  3086. private $file;
  3087. private $resourceCheckers;
  3088. public function __construct($file, $resourceCheckers = array())
  3089. {
  3090. $this->file = $file;
  3091. $this->resourceCheckers = $resourceCheckers;
  3092. }
  3093. public function getPath()
  3094. {
  3095. return $this->file;
  3096. }
  3097. public function isFresh()
  3098. {
  3099. if (!is_file($this->file)) {
  3100. return false;
  3101. }
  3102. if ($this->resourceCheckers instanceof \Traversable && !$this->resourceCheckers instanceof \Countable) {
  3103. $this->resourceCheckers = iterator_to_array($this->resourceCheckers);
  3104. }
  3105. if (!\count($this->resourceCheckers)) {
  3106. return true; }
  3107. $metadata = $this->getMetaFile();
  3108. if (!is_file($metadata)) {
  3109. return false;
  3110. }
  3111. $meta = $this->safelyUnserialize($metadata);
  3112. if (false === $meta) {
  3113. return false;
  3114. }
  3115. $time = filemtime($this->file);
  3116. foreach ($meta as $resource) {
  3117. foreach ($this->resourceCheckers as $checker) {
  3118. if (!$checker->supports($resource)) {
  3119. continue; }
  3120. if ($checker->isFresh($resource, $time)) {
  3121. break; }
  3122. return false; }
  3123. }
  3124. return true;
  3125. }
  3126. public function write($content, array $metadata = null)
  3127. {
  3128. $mode = 0666;
  3129. $umask = umask();
  3130. $filesystem = new Filesystem();
  3131. $filesystem->dumpFile($this->file, $content);
  3132. try {
  3133. $filesystem->chmod($this->file, $mode, $umask);
  3134. } catch (IOException $e) {
  3135. }
  3136. if (null !== $metadata) {
  3137. $filesystem->dumpFile($this->getMetaFile(), serialize($metadata));
  3138. try {
  3139. $filesystem->chmod($this->getMetaFile(), $mode, $umask);
  3140. } catch (IOException $e) {
  3141. }
  3142. }
  3143. if (\function_exists('opcache_invalidate') && filter_var(ini_get('opcache.enable'), FILTER_VALIDATE_BOOLEAN)) {
  3144. @opcache_invalidate($this->file, true);
  3145. }
  3146. }
  3147. private function getMetaFile()
  3148. {
  3149. return $this->file.'.meta';
  3150. }
  3151. private function safelyUnserialize($file)
  3152. {
  3153. $e = null;
  3154. $meta = false;
  3155. $signalingException = new \UnexpectedValueException();
  3156. $prevUnserializeHandler = ini_set('unserialize_callback_func','');
  3157. $prevErrorHandler = set_error_handler(function ($type, $msg, $file, $line, $context = array()) use (&$prevErrorHandler, $signalingException) {
  3158. if (E_WARNING === $type &&'Class __PHP_Incomplete_Class has no unserializer'=== $msg) {
  3159. throw $signalingException;
  3160. }
  3161. return $prevErrorHandler ? $prevErrorHandler($type, $msg, $file, $line, $context) : false;
  3162. });
  3163. try {
  3164. $meta = unserialize(file_get_contents($file));
  3165. } catch (\Error $e) {
  3166. } catch (\Exception $e) {
  3167. }
  3168. restore_error_handler();
  3169. ini_set('unserialize_callback_func', $prevUnserializeHandler);
  3170. if (null !== $e && $e !== $signalingException) {
  3171. throw $e;
  3172. }
  3173. return $meta;
  3174. }
  3175. }
  3176. }
  3177. namespace Symfony\Component\Config
  3178. {
  3179. use Symfony\Component\Config\Resource\SelfCheckingResourceChecker;
  3180. class ConfigCache extends ResourceCheckerConfigCache
  3181. {
  3182. private $debug;
  3183. public function __construct($file, $debug)
  3184. {
  3185. $this->debug = (bool) $debug;
  3186. $checkers = array();
  3187. if (true === $this->debug) {
  3188. $checkers = array(new SelfCheckingResourceChecker());
  3189. }
  3190. parent::__construct($file, $checkers);
  3191. }
  3192. public function isFresh()
  3193. {
  3194. if (!$this->debug && is_file($this->getPath())) {
  3195. return true;
  3196. }
  3197. return parent::isFresh();
  3198. }
  3199. }
  3200. }
  3201. namespace Symfony\Component\Config
  3202. {
  3203. use Symfony\Component\Config\Exception\FileLocatorFileNotFoundException;
  3204. class FileLocator implements FileLocatorInterface
  3205. {
  3206. protected $paths;
  3207. public function __construct($paths = array())
  3208. {
  3209. $this->paths = (array) $paths;
  3210. }
  3211. public function locate($name, $currentPath = null, $first = true)
  3212. {
  3213. if (''== $name) {
  3214. throw new \InvalidArgumentException('An empty file name is not valid to be located.');
  3215. }
  3216. if ($this->isAbsolutePath($name)) {
  3217. if (!file_exists($name)) {
  3218. throw new FileLocatorFileNotFoundException(sprintf('The file "%s" does not exist.', $name), 0, null, array($name));
  3219. }
  3220. return $name;
  3221. }
  3222. $paths = $this->paths;
  3223. if (null !== $currentPath) {
  3224. array_unshift($paths, $currentPath);
  3225. }
  3226. $paths = array_unique($paths);
  3227. $filepaths = $notfound = array();
  3228. foreach ($paths as $path) {
  3229. if (@file_exists($file = $path.\DIRECTORY_SEPARATOR.$name)) {
  3230. if (true === $first) {
  3231. return $file;
  3232. }
  3233. $filepaths[] = $file;
  3234. } else {
  3235. $notfound[] = $file;
  3236. }
  3237. }
  3238. if (!$filepaths) {
  3239. throw new FileLocatorFileNotFoundException(sprintf('The file "%s" does not exist (in: %s).', $name, implode(', ', $paths)), 0, null, $notfound);
  3240. }
  3241. return $filepaths;
  3242. }
  3243. private function isAbsolutePath($file)
  3244. {
  3245. if ('/'=== $file[0] ||'\\'=== $file[0]
  3246. || (\strlen($file) > 3 && ctype_alpha($file[0])
  3247. &&':'=== $file[1]
  3248. && ('\\'=== $file[2] ||'/'=== $file[2])
  3249. )
  3250. || null !== parse_url($file, PHP_URL_SCHEME)
  3251. ) {
  3252. return true;
  3253. }
  3254. return false;
  3255. }
  3256. }
  3257. }
  3258. namespace Symfony\Component\DependencyInjection
  3259. {
  3260. interface ContainerAwareInterface
  3261. {
  3262. public function setContainer(ContainerInterface $container = null);
  3263. }
  3264. }
  3265. namespace Psr\Container
  3266. {
  3267. interface ContainerInterface
  3268. {
  3269. public function get($id);
  3270. public function has($id);
  3271. }
  3272. }
  3273. namespace Symfony\Component\DependencyInjection
  3274. {
  3275. use Psr\Container\ContainerInterface as PsrContainerInterface;
  3276. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  3277. use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  3278. use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
  3279. interface ContainerInterface extends PsrContainerInterface
  3280. {
  3281. const EXCEPTION_ON_INVALID_REFERENCE = 1;
  3282. const NULL_ON_INVALID_REFERENCE = 2;
  3283. const IGNORE_ON_INVALID_REFERENCE = 3;
  3284. const IGNORE_ON_UNINITIALIZED_REFERENCE = 4;
  3285. public function set($id, $service);
  3286. public function get($id, $invalidBehavior = self::EXCEPTION_ON_INVALID_REFERENCE);
  3287. public function has($id);
  3288. public function initialized($id);
  3289. public function getParameter($name);
  3290. public function hasParameter($name);
  3291. public function setParameter($name, $value);
  3292. }
  3293. }
  3294. namespace Symfony\Component\DependencyInjection
  3295. {
  3296. interface ResettableContainerInterface extends ContainerInterface
  3297. {
  3298. public function reset();
  3299. }
  3300. }
  3301. namespace Symfony\Component\DependencyInjection
  3302. {
  3303. use Symfony\Component\DependencyInjection\Exception\EnvNotFoundException;
  3304. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  3305. use Symfony\Component\DependencyInjection\Exception\ParameterCircularReferenceException;
  3306. use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  3307. use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
  3308. use Symfony\Component\DependencyInjection\ParameterBag\EnvPlaceholderParameterBag;
  3309. use Symfony\Component\DependencyInjection\ParameterBag\FrozenParameterBag;
  3310. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  3311. class Container implements ResettableContainerInterface
  3312. {
  3313. protected $parameterBag;
  3314. protected $services = array();
  3315. protected $fileMap = array();
  3316. protected $methodMap = array();
  3317. protected $aliases = array();
  3318. protected $loading = array();
  3319. protected $resolving = array();
  3320. protected $syntheticIds = array();
  3321. protected $privates = array();
  3322. protected $normalizedIds = array();
  3323. private $underscoreMap = array('_'=>'','.'=>'_','\\'=>'_');
  3324. private $envCache = array();
  3325. private $compiled = false;
  3326. private $getEnv;
  3327. public function __construct(ParameterBagInterface $parameterBag = null)
  3328. {
  3329. $this->parameterBag = $parameterBag ?: new EnvPlaceholderParameterBag();
  3330. }
  3331. public function compile()
  3332. {
  3333. $this->parameterBag->resolve();
  3334. $this->parameterBag = new FrozenParameterBag($this->parameterBag->all());
  3335. $this->compiled = true;
  3336. }
  3337. public function isCompiled()
  3338. {
  3339. return $this->compiled;
  3340. }
  3341. public function isFrozen()
  3342. {
  3343. @trigger_error(sprintf('The %s() method is deprecated since Symfony 3.3 and will be removed in 4.0. Use the isCompiled() method instead.', __METHOD__), E_USER_DEPRECATED);
  3344. return $this->parameterBag instanceof FrozenParameterBag;
  3345. }
  3346. public function getParameterBag()
  3347. {
  3348. return $this->parameterBag;
  3349. }
  3350. public function getParameter($name)
  3351. {
  3352. return $this->parameterBag->get($name);
  3353. }
  3354. public function hasParameter($name)
  3355. {
  3356. return $this->parameterBag->has($name);
  3357. }
  3358. public function setParameter($name, $value)
  3359. {
  3360. $this->parameterBag->set($name, $value);
  3361. }
  3362. public function set($id, $service)
  3363. {
  3364. if (isset($this->privates['service_container']) && $this->privates['service_container'] instanceof \Closure) {
  3365. $initialize = $this->privates['service_container'];
  3366. unset($this->privates['service_container']);
  3367. $initialize();
  3368. }
  3369. $id = $this->normalizeId($id);
  3370. if ('service_container'=== $id) {
  3371. throw new InvalidArgumentException('You cannot set service "service_container".');
  3372. }
  3373. if (isset($this->privates[$id]) || !(isset($this->fileMap[$id]) || isset($this->methodMap[$id]))) {
  3374. if (!isset($this->privates[$id]) && !isset($this->getRemovedIds()[$id])) {
  3375. } elseif (null === $service) {
  3376. @trigger_error(sprintf('The "%s" service is private, unsetting it is deprecated since Symfony 3.2 and will fail in 4.0.', $id), E_USER_DEPRECATED);
  3377. unset($this->privates[$id]);
  3378. } else {
  3379. @trigger_error(sprintf('The "%s" service is private, replacing it is deprecated since Symfony 3.2 and will fail in 4.0.', $id), E_USER_DEPRECATED);
  3380. }
  3381. } elseif (isset($this->services[$id])) {
  3382. if (null === $service) {
  3383. @trigger_error(sprintf('The "%s" service is already initialized, unsetting it is deprecated since Symfony 3.3 and will fail in 4.0.', $id), E_USER_DEPRECATED);
  3384. } else {
  3385. @trigger_error(sprintf('The "%s" service is already initialized, replacing it is deprecated since Symfony 3.3 and will fail in 4.0.', $id), E_USER_DEPRECATED);
  3386. }
  3387. }
  3388. if (isset($this->aliases[$id])) {
  3389. unset($this->aliases[$id]);
  3390. }
  3391. if (null === $service) {
  3392. unset($this->services[$id]);
  3393. return;
  3394. }
  3395. $this->services[$id] = $service;
  3396. }
  3397. public function has($id)
  3398. {
  3399. for ($i = 2;;) {
  3400. if (isset($this->privates[$id])) {
  3401. @trigger_error(sprintf('The "%s" service is private, checking for its existence is deprecated since Symfony 3.2 and will fail in 4.0.', $id), E_USER_DEPRECATED);
  3402. }
  3403. if (isset($this->aliases[$id])) {
  3404. $id = $this->aliases[$id];
  3405. }
  3406. if (isset($this->services[$id])) {
  3407. return true;
  3408. }
  3409. if ('service_container'=== $id) {
  3410. return true;
  3411. }
  3412. if (isset($this->fileMap[$id]) || isset($this->methodMap[$id])) {
  3413. return true;
  3414. }
  3415. if (--$i && $id !== $normalizedId = $this->normalizeId($id)) {
  3416. $id = $normalizedId;
  3417. continue;
  3418. }
  3419. if (!$this->methodMap && !$this instanceof ContainerBuilder && __CLASS__ !== static::class && method_exists($this,'get'.strtr($id, $this->underscoreMap).'Service')) {
  3420. @trigger_error('Generating a dumped container without populating the method map is deprecated since Symfony 3.2 and will be unsupported in 4.0. Update your dumper to generate the method map.', E_USER_DEPRECATED);
  3421. return true;
  3422. }
  3423. return false;
  3424. }
  3425. }
  3426. public function get($id, $invalidBehavior = 1)
  3427. {
  3428. for ($i = 2;;) {
  3429. if (isset($this->privates[$id])) {
  3430. @trigger_error(sprintf('The "%s" service is private, getting it from the container is deprecated since Symfony 3.2 and will fail in 4.0. You should either make the service public, or stop using the container directly and use dependency injection instead.', $id), E_USER_DEPRECATED);
  3431. }
  3432. if (isset($this->aliases[$id])) {
  3433. $id = $this->aliases[$id];
  3434. }
  3435. if (isset($this->services[$id])) {
  3436. return $this->services[$id];
  3437. }
  3438. if ('service_container'=== $id) {
  3439. return $this;
  3440. }
  3441. if (isset($this->loading[$id])) {
  3442. throw new ServiceCircularReferenceException($id, array_merge(array_keys($this->loading), array($id)));
  3443. }
  3444. $this->loading[$id] = true;
  3445. try {
  3446. if (isset($this->fileMap[$id])) {
  3447. return 4 === $invalidBehavior ? null : $this->load($this->fileMap[$id]);
  3448. } elseif (isset($this->methodMap[$id])) {
  3449. return 4 === $invalidBehavior ? null : $this->{$this->methodMap[$id]}();
  3450. } elseif (--$i && $id !== $normalizedId = $this->normalizeId($id)) {
  3451. unset($this->loading[$id]);
  3452. $id = $normalizedId;
  3453. continue;
  3454. } elseif (!$this->methodMap && !$this instanceof ContainerBuilder && __CLASS__ !== static::class && method_exists($this, $method ='get'.strtr($id, $this->underscoreMap).'Service')) {
  3455. @trigger_error('Generating a dumped container without populating the method map is deprecated since Symfony 3.2 and will be unsupported in 4.0. Update your dumper to generate the method map.', E_USER_DEPRECATED);
  3456. return 4 === $invalidBehavior ? null : $this->{$method}();
  3457. }
  3458. break;
  3459. } catch (\Exception $e) {
  3460. unset($this->services[$id]);
  3461. throw $e;
  3462. } finally {
  3463. unset($this->loading[$id]);
  3464. }
  3465. }
  3466. if ( 1 === $invalidBehavior) {
  3467. if (!$id) {
  3468. throw new ServiceNotFoundException($id);
  3469. }
  3470. if (isset($this->syntheticIds[$id])) {
  3471. throw new ServiceNotFoundException($id, null, null, array(), sprintf('The "%s" service is synthetic, it needs to be set at boot time before it can be used.', $id));
  3472. }
  3473. if (isset($this->getRemovedIds()[$id])) {
  3474. throw new ServiceNotFoundException($id, null, null, array(), sprintf('The "%s" service or alias has been removed or inlined when the container was compiled. You should either make it public, or stop using the container directly and use dependency injection instead.', $id));
  3475. }
  3476. $alternatives = array();
  3477. foreach ($this->getServiceIds() as $knownId) {
  3478. $lev = levenshtein($id, $knownId);
  3479. if ($lev <= \strlen($id) / 3 || false !== strpos($knownId, $id)) {
  3480. $alternatives[] = $knownId;
  3481. }
  3482. }
  3483. throw new ServiceNotFoundException($id, null, null, $alternatives);
  3484. }
  3485. }
  3486. public function initialized($id)
  3487. {
  3488. $id = $this->normalizeId($id);
  3489. if (isset($this->privates[$id])) {
  3490. @trigger_error(sprintf('Checking for the initialization of the "%s" private service is deprecated since Symfony 3.4 and won\'t be supported anymore in Symfony 4.0.', $id), E_USER_DEPRECATED);
  3491. }
  3492. if (isset($this->aliases[$id])) {
  3493. $id = $this->aliases[$id];
  3494. }
  3495. if ('service_container'=== $id) {
  3496. return false;
  3497. }
  3498. return isset($this->services[$id]);
  3499. }
  3500. public function reset()
  3501. {
  3502. $this->services = array();
  3503. }
  3504. public function getServiceIds()
  3505. {
  3506. $ids = array();
  3507. if (!$this->methodMap && !$this instanceof ContainerBuilder && __CLASS__ !== static::class) {
  3508. @trigger_error('Generating a dumped container without populating the method map is deprecated since Symfony 3.2 and will be unsupported in 4.0. Update your dumper to generate the method map.', E_USER_DEPRECATED);
  3509. foreach (get_class_methods($this) as $method) {
  3510. if (preg_match('/^get(.+)Service$/', $method, $match)) {
  3511. $ids[] = self::underscore($match[1]);
  3512. }
  3513. }
  3514. }
  3515. $ids[] ='service_container';
  3516. return array_unique(array_merge($ids, array_keys($this->methodMap), array_keys($this->fileMap), array_keys($this->services)));
  3517. }
  3518. public function getRemovedIds()
  3519. {
  3520. return array();
  3521. }
  3522. public static function camelize($id)
  3523. {
  3524. return strtr(ucwords(strtr($id, array('_'=>' ','.'=>'_ ','\\'=>'_ '))), array(' '=>''));
  3525. }
  3526. public static function underscore($id)
  3527. {
  3528. return strtolower(preg_replace(array('/([A-Z]+)([A-Z][a-z])/','/([a-z\d])([A-Z])/'), array('\\1_\\2','\\1_\\2'), str_replace('_','.', $id)));
  3529. }
  3530. protected function load($file)
  3531. {
  3532. return require $file;
  3533. }
  3534. protected function getEnv($name)
  3535. {
  3536. if (isset($this->resolving[$envName = "env($name)"])) {
  3537. throw new ParameterCircularReferenceException(array_keys($this->resolving));
  3538. }
  3539. if (isset($this->envCache[$name]) || array_key_exists($name, $this->envCache)) {
  3540. return $this->envCache[$name];
  3541. }
  3542. if (!$this->has($id ='container.env_var_processors_locator')) {
  3543. $this->set($id, new ServiceLocator(array()));
  3544. }
  3545. if (!$this->getEnv) {
  3546. $this->getEnv = new \ReflectionMethod($this, __FUNCTION__);
  3547. $this->getEnv->setAccessible(true);
  3548. $this->getEnv = $this->getEnv->getClosure($this);
  3549. }
  3550. $processors = $this->get($id);
  3551. if (false !== $i = strpos($name,':')) {
  3552. $prefix = substr($name, 0, $i);
  3553. $localName = substr($name, 1 + $i);
  3554. } else {
  3555. $prefix ='string';
  3556. $localName = $name;
  3557. }
  3558. $processor = $processors->has($prefix) ? $processors->get($prefix) : new EnvVarProcessor($this);
  3559. $this->resolving[$envName] = true;
  3560. try {
  3561. return $this->envCache[$name] = $processor->getEnv($prefix, $localName, $this->getEnv);
  3562. } finally {
  3563. unset($this->resolving[$envName]);
  3564. }
  3565. }
  3566. public function normalizeId($id)
  3567. {
  3568. if (!\is_string($id)) {
  3569. $id = (string) $id;
  3570. }
  3571. if (isset($this->normalizedIds[$normalizedId = strtolower($id)])) {
  3572. $normalizedId = $this->normalizedIds[$normalizedId];
  3573. if ($id !== $normalizedId) {
  3574. @trigger_error(sprintf('Service identifiers will be made case sensitive in Symfony 4.0. Using "%s" instead of "%s" is deprecated since Symfony 3.3.', $id, $normalizedId), E_USER_DEPRECATED);
  3575. }
  3576. } else {
  3577. $normalizedId = $this->normalizedIds[$normalizedId] = $id;
  3578. }
  3579. return $normalizedId;
  3580. }
  3581. private function __clone()
  3582. {
  3583. }
  3584. }
  3585. }
  3586. namespace Symfony\Component\EventDispatcher
  3587. {
  3588. class Event
  3589. {
  3590. private $propagationStopped = false;
  3591. public function isPropagationStopped()
  3592. {
  3593. return $this->propagationStopped;
  3594. }
  3595. public function stopPropagation()
  3596. {
  3597. $this->propagationStopped = true;
  3598. }
  3599. }
  3600. }
  3601. namespace Symfony\Component\EventDispatcher
  3602. {
  3603. interface EventDispatcherInterface
  3604. {
  3605. public function dispatch($eventName, Event $event = null);
  3606. public function addListener($eventName, $listener, $priority = 0);
  3607. public function addSubscriber(EventSubscriberInterface $subscriber);
  3608. public function removeListener($eventName, $listener);
  3609. public function removeSubscriber(EventSubscriberInterface $subscriber);
  3610. public function getListeners($eventName = null);
  3611. public function getListenerPriority($eventName, $listener);
  3612. public function hasListeners($eventName = null);
  3613. }
  3614. }
  3615. namespace Symfony\Component\EventDispatcher
  3616. {
  3617. class EventDispatcher implements EventDispatcherInterface
  3618. {
  3619. private $listeners = array();
  3620. private $sorted = array();
  3621. public function dispatch($eventName, Event $event = null)
  3622. {
  3623. if (null === $event) {
  3624. $event = new Event();
  3625. }
  3626. if ($listeners = $this->getListeners($eventName)) {
  3627. $this->doDispatch($listeners, $eventName, $event);
  3628. }
  3629. return $event;
  3630. }
  3631. public function getListeners($eventName = null)
  3632. {
  3633. if (null !== $eventName) {
  3634. if (empty($this->listeners[$eventName])) {
  3635. return array();
  3636. }
  3637. if (!isset($this->sorted[$eventName])) {
  3638. $this->sortListeners($eventName);
  3639. }
  3640. return $this->sorted[$eventName];
  3641. }
  3642. foreach ($this->listeners as $eventName => $eventListeners) {
  3643. if (!isset($this->sorted[$eventName])) {
  3644. $this->sortListeners($eventName);
  3645. }
  3646. }
  3647. return array_filter($this->sorted);
  3648. }
  3649. public function getListenerPriority($eventName, $listener)
  3650. {
  3651. if (empty($this->listeners[$eventName])) {
  3652. return;
  3653. }
  3654. if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure) {
  3655. $listener[0] = $listener[0]();
  3656. }
  3657. foreach ($this->listeners[$eventName] as $priority => $listeners) {
  3658. foreach ($listeners as $k => $v) {
  3659. if ($v !== $listener && \is_array($v) && isset($v[0]) && $v[0] instanceof \Closure) {
  3660. $v[0] = $v[0]();
  3661. $this->listeners[$eventName][$priority][$k] = $v;
  3662. }
  3663. if ($v === $listener) {
  3664. return $priority;
  3665. }
  3666. }
  3667. }
  3668. }
  3669. public function hasListeners($eventName = null)
  3670. {
  3671. if (null !== $eventName) {
  3672. return !empty($this->listeners[$eventName]);
  3673. }
  3674. foreach ($this->listeners as $eventListeners) {
  3675. if ($eventListeners) {
  3676. return true;
  3677. }
  3678. }
  3679. return false;
  3680. }
  3681. public function addListener($eventName, $listener, $priority = 0)
  3682. {
  3683. $this->listeners[$eventName][$priority][] = $listener;
  3684. unset($this->sorted[$eventName]);
  3685. }
  3686. public function removeListener($eventName, $listener)
  3687. {
  3688. if (empty($this->listeners[$eventName])) {
  3689. return;
  3690. }
  3691. if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure) {
  3692. $listener[0] = $listener[0]();
  3693. }
  3694. foreach ($this->listeners[$eventName] as $priority => $listeners) {
  3695. foreach ($listeners as $k => $v) {
  3696. if ($v !== $listener && \is_array($v) && isset($v[0]) && $v[0] instanceof \Closure) {
  3697. $v[0] = $v[0]();
  3698. }
  3699. if ($v === $listener) {
  3700. unset($listeners[$k], $this->sorted[$eventName]);
  3701. } else {
  3702. $listeners[$k] = $v;
  3703. }
  3704. }
  3705. if ($listeners) {
  3706. $this->listeners[$eventName][$priority] = $listeners;
  3707. } else {
  3708. unset($this->listeners[$eventName][$priority]);
  3709. }
  3710. }
  3711. }
  3712. public function addSubscriber(EventSubscriberInterface $subscriber)
  3713. {
  3714. foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
  3715. if (\is_string($params)) {
  3716. $this->addListener($eventName, array($subscriber, $params));
  3717. } elseif (\is_string($params[0])) {
  3718. $this->addListener($eventName, array($subscriber, $params[0]), isset($params[1]) ? $params[1] : 0);
  3719. } else {
  3720. foreach ($params as $listener) {
  3721. $this->addListener($eventName, array($subscriber, $listener[0]), isset($listener[1]) ? $listener[1] : 0);
  3722. }
  3723. }
  3724. }
  3725. }
  3726. public function removeSubscriber(EventSubscriberInterface $subscriber)
  3727. {
  3728. foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
  3729. if (\is_array($params) && \is_array($params[0])) {
  3730. foreach ($params as $listener) {
  3731. $this->removeListener($eventName, array($subscriber, $listener[0]));
  3732. }
  3733. } else {
  3734. $this->removeListener($eventName, array($subscriber, \is_string($params) ? $params : $params[0]));
  3735. }
  3736. }
  3737. }
  3738. protected function doDispatch($listeners, $eventName, Event $event)
  3739. {
  3740. foreach ($listeners as $listener) {
  3741. if ($event->isPropagationStopped()) {
  3742. break;
  3743. }
  3744. \call_user_func($listener, $event, $eventName, $this);
  3745. }
  3746. }
  3747. private function sortListeners($eventName)
  3748. {
  3749. krsort($this->listeners[$eventName]);
  3750. $this->sorted[$eventName] = array();
  3751. foreach ($this->listeners[$eventName] as $priority => $listeners) {
  3752. foreach ($listeners as $k => $listener) {
  3753. if (\is_array($listener) && isset($listener[0]) && $listener[0] instanceof \Closure) {
  3754. $listener[0] = $listener[0]();
  3755. $this->listeners[$eventName][$priority][$k] = $listener;
  3756. }
  3757. $this->sorted[$eventName][] = $listener;
  3758. }
  3759. }
  3760. }
  3761. }
  3762. }
  3763. namespace Symfony\Component\EventDispatcher
  3764. {
  3765. use Symfony\Component\DependencyInjection\ContainerInterface;
  3766. class ContainerAwareEventDispatcher extends EventDispatcher
  3767. {
  3768. private $container;
  3769. private $listenerIds = array();
  3770. private $listeners = array();
  3771. public function __construct(ContainerInterface $container)
  3772. {
  3773. $this->container = $container;
  3774. $class = \get_class($this);
  3775. if ($this instanceof \PHPUnit_Framework_MockObject_MockObject || $this instanceof \Prophecy\Doubler\DoubleInterface) {
  3776. $class = get_parent_class($class);
  3777. }
  3778. if (__CLASS__ !== $class) {
  3779. @trigger_error(sprintf('The %s class is deprecated since Symfony 3.3 and will be removed in 4.0. Use EventDispatcher with closure factories instead.', __CLASS__), E_USER_DEPRECATED);
  3780. }
  3781. }
  3782. public function addListenerService($eventName, $callback, $priority = 0)
  3783. {
  3784. @trigger_error(sprintf('The %s class is deprecated since Symfony 3.3 and will be removed in 4.0. Use EventDispatcher with closure factories instead.', __CLASS__), E_USER_DEPRECATED);
  3785. if (!\is_array($callback) || 2 !== \count($callback)) {
  3786. throw new \InvalidArgumentException('Expected an array("service", "method") argument');
  3787. }
  3788. $this->listenerIds[$eventName][] = array($callback[0], $callback[1], $priority);
  3789. }
  3790. public function removeListener($eventName, $listener)
  3791. {
  3792. $this->lazyLoad($eventName);
  3793. if (isset($this->listenerIds[$eventName])) {
  3794. foreach ($this->listenerIds[$eventName] as $i => list($serviceId, $method)) {
  3795. $key = $serviceId.'.'.$method;
  3796. if (isset($this->listeners[$eventName][$key]) && $listener === array($this->listeners[$eventName][$key], $method)) {
  3797. unset($this->listeners[$eventName][$key]);
  3798. if (empty($this->listeners[$eventName])) {
  3799. unset($this->listeners[$eventName]);
  3800. }
  3801. unset($this->listenerIds[$eventName][$i]);
  3802. if (empty($this->listenerIds[$eventName])) {
  3803. unset($this->listenerIds[$eventName]);
  3804. }
  3805. }
  3806. }
  3807. }
  3808. parent::removeListener($eventName, $listener);
  3809. }
  3810. public function hasListeners($eventName = null)
  3811. {
  3812. if (null === $eventName) {
  3813. return $this->listenerIds || $this->listeners || parent::hasListeners();
  3814. }
  3815. if (isset($this->listenerIds[$eventName])) {
  3816. return true;
  3817. }
  3818. return parent::hasListeners($eventName);
  3819. }
  3820. public function getListeners($eventName = null)
  3821. {
  3822. if (null === $eventName) {
  3823. foreach ($this->listenerIds as $serviceEventName => $args) {
  3824. $this->lazyLoad($serviceEventName);
  3825. }
  3826. } else {
  3827. $this->lazyLoad($eventName);
  3828. }
  3829. return parent::getListeners($eventName);
  3830. }
  3831. public function getListenerPriority($eventName, $listener)
  3832. {
  3833. $this->lazyLoad($eventName);
  3834. return parent::getListenerPriority($eventName, $listener);
  3835. }
  3836. public function addSubscriberService($serviceId, $class)
  3837. {
  3838. @trigger_error(sprintf('The %s class is deprecated since Symfony 3.3 and will be removed in 4.0. Use EventDispatcher with closure factories instead.', __CLASS__), E_USER_DEPRECATED);
  3839. foreach ($class::getSubscribedEvents() as $eventName => $params) {
  3840. if (\is_string($params)) {
  3841. $this->listenerIds[$eventName][] = array($serviceId, $params, 0);
  3842. } elseif (\is_string($params[0])) {
  3843. $this->listenerIds[$eventName][] = array($serviceId, $params[0], isset($params[1]) ? $params[1] : 0);
  3844. } else {
  3845. foreach ($params as $listener) {
  3846. $this->listenerIds[$eventName][] = array($serviceId, $listener[0], isset($listener[1]) ? $listener[1] : 0);
  3847. }
  3848. }
  3849. }
  3850. }
  3851. public function getContainer()
  3852. {
  3853. @trigger_error('The '.__METHOD__.'() method is deprecated since Symfony 3.3 as its class will be removed in 4.0. Inject the container or the services you need in your listeners/subscribers instead.', E_USER_DEPRECATED);
  3854. return $this->container;
  3855. }
  3856. protected function lazyLoad($eventName)
  3857. {
  3858. if (isset($this->listenerIds[$eventName])) {
  3859. foreach ($this->listenerIds[$eventName] as list($serviceId, $method, $priority)) {
  3860. $listener = $this->container->get($serviceId);
  3861. $key = $serviceId.'.'.$method;
  3862. if (!isset($this->listeners[$eventName][$key])) {
  3863. $this->addListener($eventName, array($listener, $method), $priority);
  3864. } elseif ($this->listeners[$eventName][$key] !== $listener) {
  3865. parent::removeListener($eventName, array($this->listeners[$eventName][$key], $method));
  3866. $this->addListener($eventName, array($listener, $method), $priority);
  3867. }
  3868. $this->listeners[$eventName][$key] = $listener;
  3869. }
  3870. }
  3871. }
  3872. }
  3873. }
  3874. namespace Symfony\Component\HttpKernel\EventListener
  3875. {
  3876. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  3877. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  3878. use Symfony\Component\HttpKernel\KernelEvents;
  3879. class ResponseListener implements EventSubscriberInterface
  3880. {
  3881. private $charset;
  3882. public function __construct($charset)
  3883. {
  3884. $this->charset = $charset;
  3885. }
  3886. public function onKernelResponse(FilterResponseEvent $event)
  3887. {
  3888. if (!$event->isMasterRequest()) {
  3889. return;
  3890. }
  3891. $response = $event->getResponse();
  3892. if (null === $response->getCharset()) {
  3893. $response->setCharset($this->charset);
  3894. }
  3895. $response->prepare($event->getRequest());
  3896. }
  3897. public static function getSubscribedEvents()
  3898. {
  3899. return array(
  3900. KernelEvents::RESPONSE =>'onKernelResponse',
  3901. );
  3902. }
  3903. }
  3904. }
  3905. namespace {require __DIR__.'/../../../vendor/symfony/symfony/src/Symfony/Component/HttpKernel/EventListener/RouterListener.php';}
  3906. namespace Symfony\Component\HttpKernel\Bundle
  3907. {
  3908. use Symfony\Component\DependencyInjection\ContainerAwareInterface;
  3909. use Symfony\Component\DependencyInjection\ContainerBuilder;
  3910. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  3911. interface BundleInterface extends ContainerAwareInterface
  3912. {
  3913. public function boot();
  3914. public function shutdown();
  3915. public function build(ContainerBuilder $container);
  3916. public function getContainerExtension();
  3917. public function getParent();
  3918. public function getName();
  3919. public function getNamespace();
  3920. public function getPath();
  3921. }
  3922. }
  3923. namespace Symfony\Component\DependencyInjection
  3924. {
  3925. trait ContainerAwareTrait
  3926. {
  3927. protected $container;
  3928. public function setContainer(ContainerInterface $container = null)
  3929. {
  3930. $this->container = $container;
  3931. }
  3932. }
  3933. }
  3934. namespace Symfony\Component\HttpKernel\Bundle
  3935. {
  3936. use Symfony\Component\Console\Application;
  3937. use Symfony\Component\DependencyInjection\Container;
  3938. use Symfony\Component\DependencyInjection\ContainerAwareTrait;
  3939. use Symfony\Component\DependencyInjection\ContainerBuilder;
  3940. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  3941. use Symfony\Component\Finder\Finder;
  3942. abstract class Bundle implements BundleInterface
  3943. {
  3944. use ContainerAwareTrait;
  3945. protected $name;
  3946. protected $extension;
  3947. protected $path;
  3948. private $namespace;
  3949. public function boot()
  3950. {
  3951. }
  3952. public function shutdown()
  3953. {
  3954. }
  3955. public function build(ContainerBuilder $container)
  3956. {
  3957. }
  3958. public function getContainerExtension()
  3959. {
  3960. if (null === $this->extension) {
  3961. $extension = $this->createContainerExtension();
  3962. if (null !== $extension) {
  3963. if (!$extension instanceof ExtensionInterface) {
  3964. throw new \LogicException(sprintf('Extension %s must implement Symfony\Component\DependencyInjection\Extension\ExtensionInterface.', \get_class($extension)));
  3965. }
  3966. $basename = preg_replace('/Bundle$/','', $this->getName());
  3967. $expectedAlias = Container::underscore($basename);
  3968. if ($expectedAlias != $extension->getAlias()) {
  3969. throw new \LogicException(sprintf('Users will expect the alias of the default extension of a bundle to be the underscored version of the bundle name ("%s"). You can override "Bundle::getContainerExtension()" if you want to use "%s" or another alias.', $expectedAlias, $extension->getAlias()));
  3970. }
  3971. $this->extension = $extension;
  3972. } else {
  3973. $this->extension = false;
  3974. }
  3975. }
  3976. if ($this->extension) {
  3977. return $this->extension;
  3978. }
  3979. }
  3980. public function getNamespace()
  3981. {
  3982. if (null === $this->namespace) {
  3983. $this->parseClassName();
  3984. }
  3985. return $this->namespace;
  3986. }
  3987. public function getPath()
  3988. {
  3989. if (null === $this->path) {
  3990. $reflected = new \ReflectionObject($this);
  3991. $this->path = \dirname($reflected->getFileName());
  3992. }
  3993. return $this->path;
  3994. }
  3995. public function getParent()
  3996. {
  3997. }
  3998. final public function getName()
  3999. {
  4000. if (null === $this->name) {
  4001. $this->parseClassName();
  4002. }
  4003. return $this->name;
  4004. }
  4005. public function registerCommands(Application $application)
  4006. {
  4007. if (!is_dir($dir = $this->getPath().'/Command')) {
  4008. return;
  4009. }
  4010. if (!class_exists('Symfony\Component\Finder\Finder')) {
  4011. throw new \RuntimeException('You need the symfony/finder component to register bundle commands.');
  4012. }
  4013. $finder = new Finder();
  4014. $finder->files()->name('*Command.php')->in($dir);
  4015. $prefix = $this->getNamespace().'\\Command';
  4016. foreach ($finder as $file) {
  4017. $ns = $prefix;
  4018. if ($relativePath = $file->getRelativePath()) {
  4019. $ns .='\\'.str_replace('/','\\', $relativePath);
  4020. }
  4021. $class = $ns.'\\'.$file->getBasename('.php');
  4022. if ($this->container) {
  4023. $commandIds = $this->container->hasParameter('console.command.ids') ? $this->container->getParameter('console.command.ids') : array();
  4024. $alias ='console.command.'.strtolower(str_replace('\\','_', $class));
  4025. if (isset($commandIds[$alias]) || $this->container->has($alias)) {
  4026. continue;
  4027. }
  4028. }
  4029. $r = new \ReflectionClass($class);
  4030. if ($r->isSubclassOf('Symfony\\Component\\Console\\Command\\Command') && !$r->isAbstract() && !$r->getConstructor()->getNumberOfRequiredParameters()) {
  4031. @trigger_error(sprintf('Auto-registration of the command "%s" is deprecated since Symfony 3.4 and won\'t be supported in 4.0. Use PSR-4 based service discovery instead.', $class), E_USER_DEPRECATED);
  4032. $application->add($r->newInstance());
  4033. }
  4034. }
  4035. }
  4036. protected function getContainerExtensionClass()
  4037. {
  4038. $basename = preg_replace('/Bundle$/','', $this->getName());
  4039. return $this->getNamespace().'\\DependencyInjection\\'.$basename.'Extension';
  4040. }
  4041. protected function createContainerExtension()
  4042. {
  4043. if (class_exists($class = $this->getContainerExtensionClass())) {
  4044. return new $class();
  4045. }
  4046. }
  4047. private function parseClassName()
  4048. {
  4049. $pos = strrpos(static::class,'\\');
  4050. $this->namespace = false === $pos ?'': substr(static::class, 0, $pos);
  4051. if (null === $this->name) {
  4052. $this->name = false === $pos ? static::class : substr(static::class, $pos + 1);
  4053. }
  4054. }
  4055. }
  4056. }
  4057. namespace Symfony\Component\HttpKernel\Controller
  4058. {
  4059. use Symfony\Component\HttpFoundation\Request;
  4060. interface ArgumentResolverInterface
  4061. {
  4062. public function getArguments(Request $request, $controller);
  4063. }
  4064. }
  4065. namespace Symfony\Component\HttpKernel\Controller
  4066. {
  4067. use Symfony\Component\HttpFoundation\Request;
  4068. interface ControllerResolverInterface
  4069. {
  4070. public function getController(Request $request);
  4071. public function getArguments(Request $request, $controller);
  4072. }
  4073. }
  4074. namespace Symfony\Component\HttpKernel\Controller
  4075. {
  4076. use Psr\Log\LoggerInterface;
  4077. use Symfony\Component\HttpFoundation\Request;
  4078. class ControllerResolver implements ArgumentResolverInterface, ControllerResolverInterface
  4079. {
  4080. private $logger;
  4081. private $supportsVariadic;
  4082. private $supportsScalarTypes;
  4083. public function __construct(LoggerInterface $logger = null)
  4084. {
  4085. $this->logger = $logger;
  4086. $this->supportsVariadic = method_exists('ReflectionParameter','isVariadic');
  4087. $this->supportsScalarTypes = method_exists('ReflectionParameter','getType');
  4088. }
  4089. public function getController(Request $request)
  4090. {
  4091. if (!$controller = $request->attributes->get('_controller')) {
  4092. if (null !== $this->logger) {
  4093. $this->logger->warning('Unable to look for the controller as the "_controller" parameter is missing.');
  4094. }
  4095. return false;
  4096. }
  4097. if (\is_array($controller)) {
  4098. return $controller;
  4099. }
  4100. if (\is_object($controller)) {
  4101. if (method_exists($controller,'__invoke')) {
  4102. return $controller;
  4103. }
  4104. throw new \InvalidArgumentException(sprintf('Controller "%s" for URI "%s" is not callable.', \get_class($controller), $request->getPathInfo()));
  4105. }
  4106. if (false === strpos($controller,':')) {
  4107. if (method_exists($controller,'__invoke')) {
  4108. return $this->instantiateController($controller);
  4109. } elseif (\function_exists($controller)) {
  4110. return $controller;
  4111. }
  4112. }
  4113. $callable = $this->createController($controller);
  4114. if (!\is_callable($callable)) {
  4115. throw new \InvalidArgumentException(sprintf('The controller for URI "%s" is not callable. %s', $request->getPathInfo(), $this->getControllerError($callable)));
  4116. }
  4117. return $callable;
  4118. }
  4119. public function getArguments(Request $request, $controller)
  4120. {
  4121. @trigger_error(sprintf('The "%s()" method is deprecated as of 3.1 and will be removed in 4.0. Implement the %s and inject it in the HttpKernel instead.', __METHOD__, ArgumentResolverInterface::class), E_USER_DEPRECATED);
  4122. if (\is_array($controller)) {
  4123. $r = new \ReflectionMethod($controller[0], $controller[1]);
  4124. } elseif (\is_object($controller) && !$controller instanceof \Closure) {
  4125. $r = new \ReflectionObject($controller);
  4126. $r = $r->getMethod('__invoke');
  4127. } else {
  4128. $r = new \ReflectionFunction($controller);
  4129. }
  4130. return $this->doGetArguments($request, $controller, $r->getParameters());
  4131. }
  4132. protected function doGetArguments(Request $request, $controller, array $parameters)
  4133. {
  4134. @trigger_error(sprintf('The "%s()" method is deprecated as of 3.1 and will be removed in 4.0. Implement the %s and inject it in the HttpKernel instead.', __METHOD__, ArgumentResolverInterface::class), E_USER_DEPRECATED);
  4135. $attributes = $request->attributes->all();
  4136. $arguments = array();
  4137. foreach ($parameters as $param) {
  4138. if (array_key_exists($param->name, $attributes)) {
  4139. if ($this->supportsVariadic && $param->isVariadic() && \is_array($attributes[$param->name])) {
  4140. $arguments = array_merge($arguments, array_values($attributes[$param->name]));
  4141. } else {
  4142. $arguments[] = $attributes[$param->name];
  4143. }
  4144. } elseif ($param->getClass() && $param->getClass()->isInstance($request)) {
  4145. $arguments[] = $request;
  4146. } elseif ($param->isDefaultValueAvailable()) {
  4147. $arguments[] = $param->getDefaultValue();
  4148. } elseif ($this->supportsScalarTypes && $param->hasType() && $param->allowsNull()) {
  4149. $arguments[] = null;
  4150. } else {
  4151. if (\is_array($controller)) {
  4152. $repr = sprintf('%s::%s()', \get_class($controller[0]), $controller[1]);
  4153. } elseif (\is_object($controller)) {
  4154. $repr = \get_class($controller);
  4155. } else {
  4156. $repr = $controller;
  4157. }
  4158. throw new \RuntimeException(sprintf('Controller "%s" requires that you provide a value for the "$%s" argument (because there is no default value or because there is a non optional argument after this one).', $repr, $param->name));
  4159. }
  4160. }
  4161. return $arguments;
  4162. }
  4163. protected function createController($controller)
  4164. {
  4165. if (false === strpos($controller,'::')) {
  4166. throw new \InvalidArgumentException(sprintf('Unable to find controller "%s".', $controller));
  4167. }
  4168. list($class, $method) = explode('::', $controller, 2);
  4169. if (!class_exists($class)) {
  4170. throw new \InvalidArgumentException(sprintf('Class "%s" does not exist.', $class));
  4171. }
  4172. return array($this->instantiateController($class), $method);
  4173. }
  4174. protected function instantiateController($class)
  4175. {
  4176. return new $class();
  4177. }
  4178. private function getControllerError($callable)
  4179. {
  4180. if (\is_string($callable)) {
  4181. if (false !== strpos($callable,'::')) {
  4182. $callable = explode('::', $callable);
  4183. }
  4184. if (class_exists($callable) && !method_exists($callable,'__invoke')) {
  4185. return sprintf('Class "%s" does not have a method "__invoke".', $callable);
  4186. }
  4187. if (!\function_exists($callable)) {
  4188. return sprintf('Function "%s" does not exist.', $callable);
  4189. }
  4190. }
  4191. if (!\is_array($callable)) {
  4192. return sprintf('Invalid type for controller given, expected string or array, got "%s".', \gettype($callable));
  4193. }
  4194. if (2 !== \count($callable)) {
  4195. return'Invalid format for controller, expected array(controller, method) or controller::method.';
  4196. }
  4197. list($controller, $method) = $callable;
  4198. if (\is_string($controller) && !class_exists($controller)) {
  4199. return sprintf('Class "%s" does not exist.', $controller);
  4200. }
  4201. $className = \is_object($controller) ? \get_class($controller) : $controller;
  4202. if (method_exists($controller, $method)) {
  4203. return sprintf('Method "%s" on class "%s" should be public and non-abstract.', $method, $className);
  4204. }
  4205. $collection = get_class_methods($controller);
  4206. $alternatives = array();
  4207. foreach ($collection as $item) {
  4208. $lev = levenshtein($method, $item);
  4209. if ($lev <= \strlen($method) / 3 || false !== strpos($item, $method)) {
  4210. $alternatives[] = $item;
  4211. }
  4212. }
  4213. asort($alternatives);
  4214. $message = sprintf('Expected method "%s" on class "%s"', $method, $className);
  4215. if (\count($alternatives) > 0) {
  4216. $message .= sprintf(', did you mean "%s"?', implode('", "', $alternatives));
  4217. } else {
  4218. $message .= sprintf('. Available methods: "%s".', implode('", "', $collection));
  4219. }
  4220. return $message;
  4221. }
  4222. }
  4223. }
  4224. namespace Symfony\Component\HttpKernel\Controller
  4225. {
  4226. use Symfony\Component\HttpFoundation\Request;
  4227. use Symfony\Component\HttpKernel\Controller\ArgumentResolver\DefaultValueResolver;
  4228. use Symfony\Component\HttpKernel\Controller\ArgumentResolver\RequestAttributeValueResolver;
  4229. use Symfony\Component\HttpKernel\Controller\ArgumentResolver\RequestValueResolver;
  4230. use Symfony\Component\HttpKernel\Controller\ArgumentResolver\SessionValueResolver;
  4231. use Symfony\Component\HttpKernel\Controller\ArgumentResolver\VariadicValueResolver;
  4232. use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadataFactory;
  4233. use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadataFactoryInterface;
  4234. final class ArgumentResolver implements ArgumentResolverInterface
  4235. {
  4236. private $argumentMetadataFactory;
  4237. private $argumentValueResolvers;
  4238. public function __construct(ArgumentMetadataFactoryInterface $argumentMetadataFactory = null, $argumentValueResolvers = array())
  4239. {
  4240. $this->argumentMetadataFactory = $argumentMetadataFactory ?: new ArgumentMetadataFactory();
  4241. $this->argumentValueResolvers = $argumentValueResolvers ?: self::getDefaultArgumentValueResolvers();
  4242. }
  4243. public function getArguments(Request $request, $controller)
  4244. {
  4245. $arguments = array();
  4246. foreach ($this->argumentMetadataFactory->createArgumentMetadata($controller) as $metadata) {
  4247. foreach ($this->argumentValueResolvers as $resolver) {
  4248. if (!$resolver->supports($request, $metadata)) {
  4249. continue;
  4250. }
  4251. $resolved = $resolver->resolve($request, $metadata);
  4252. if (!$resolved instanceof \Generator) {
  4253. throw new \InvalidArgumentException(sprintf('%s::resolve() must yield at least one value.', \get_class($resolver)));
  4254. }
  4255. foreach ($resolved as $append) {
  4256. $arguments[] = $append;
  4257. }
  4258. continue 2;
  4259. }
  4260. $representative = $controller;
  4261. if (\is_array($representative)) {
  4262. $representative = sprintf('%s::%s()', \get_class($representative[0]), $representative[1]);
  4263. } elseif (\is_object($representative)) {
  4264. $representative = \get_class($representative);
  4265. }
  4266. throw new \RuntimeException(sprintf('Controller "%s" requires that you provide a value for the "$%s" argument. Either the argument is nullable and no null value has been provided, no default value has been provided or because there is a non optional argument after this one.', $representative, $metadata->getName()));
  4267. }
  4268. return $arguments;
  4269. }
  4270. public static function getDefaultArgumentValueResolvers()
  4271. {
  4272. return array(
  4273. new RequestAttributeValueResolver(),
  4274. new RequestValueResolver(),
  4275. new SessionValueResolver(),
  4276. new DefaultValueResolver(),
  4277. new VariadicValueResolver(),
  4278. );
  4279. }
  4280. }
  4281. }
  4282. namespace Symfony\Component\HttpKernel\ControllerMetadata
  4283. {
  4284. class ArgumentMetadata
  4285. {
  4286. private $name;
  4287. private $type;
  4288. private $isVariadic;
  4289. private $hasDefaultValue;
  4290. private $defaultValue;
  4291. private $isNullable;
  4292. public function __construct($name, $type, $isVariadic, $hasDefaultValue, $defaultValue, $isNullable = false)
  4293. {
  4294. $this->name = $name;
  4295. $this->type = $type;
  4296. $this->isVariadic = $isVariadic;
  4297. $this->hasDefaultValue = $hasDefaultValue;
  4298. $this->defaultValue = $defaultValue;
  4299. $this->isNullable = $isNullable || null === $type || ($hasDefaultValue && null === $defaultValue);
  4300. }
  4301. public function getName()
  4302. {
  4303. return $this->name;
  4304. }
  4305. public function getType()
  4306. {
  4307. return $this->type;
  4308. }
  4309. public function isVariadic()
  4310. {
  4311. return $this->isVariadic;
  4312. }
  4313. public function hasDefaultValue()
  4314. {
  4315. return $this->hasDefaultValue;
  4316. }
  4317. public function isNullable()
  4318. {
  4319. return $this->isNullable;
  4320. }
  4321. public function getDefaultValue()
  4322. {
  4323. if (!$this->hasDefaultValue) {
  4324. throw new \LogicException(sprintf('Argument $%s does not have a default value. Use %s::hasDefaultValue() to avoid this exception.', $this->name, __CLASS__));
  4325. }
  4326. return $this->defaultValue;
  4327. }
  4328. }
  4329. }
  4330. namespace Symfony\Component\HttpKernel\ControllerMetadata
  4331. {
  4332. interface ArgumentMetadataFactoryInterface
  4333. {
  4334. public function createArgumentMetadata($controller);
  4335. }
  4336. }
  4337. namespace Symfony\Component\HttpKernel\ControllerMetadata
  4338. {
  4339. final class ArgumentMetadataFactory implements ArgumentMetadataFactoryInterface
  4340. {
  4341. private $supportsVariadic;
  4342. private $supportsParameterType;
  4343. public function __construct()
  4344. {
  4345. $this->supportsVariadic = method_exists('ReflectionParameter','isVariadic');
  4346. $this->supportsParameterType = method_exists('ReflectionParameter','getType');
  4347. }
  4348. public function createArgumentMetadata($controller)
  4349. {
  4350. $arguments = array();
  4351. if (\is_array($controller)) {
  4352. $reflection = new \ReflectionMethod($controller[0], $controller[1]);
  4353. } elseif (\is_object($controller) && !$controller instanceof \Closure) {
  4354. $reflection = (new \ReflectionObject($controller))->getMethod('__invoke');
  4355. } else {
  4356. $reflection = new \ReflectionFunction($controller);
  4357. }
  4358. foreach ($reflection->getParameters() as $param) {
  4359. $arguments[] = new ArgumentMetadata($param->getName(), $this->getType($param, $reflection), $this->isVariadic($param), $this->hasDefaultValue($param), $this->getDefaultValue($param), $param->allowsNull());
  4360. }
  4361. return $arguments;
  4362. }
  4363. private function isVariadic(\ReflectionParameter $parameter)
  4364. {
  4365. return $this->supportsVariadic && $parameter->isVariadic();
  4366. }
  4367. private function hasDefaultValue(\ReflectionParameter $parameter)
  4368. {
  4369. return $parameter->isDefaultValueAvailable();
  4370. }
  4371. private function getDefaultValue(\ReflectionParameter $parameter)
  4372. {
  4373. return $this->hasDefaultValue($parameter) ? $parameter->getDefaultValue() : null;
  4374. }
  4375. private function getType(\ReflectionParameter $parameter, \ReflectionFunctionAbstract $function)
  4376. {
  4377. if ($this->supportsParameterType) {
  4378. if (!$type = $parameter->getType()) {
  4379. return;
  4380. }
  4381. $name = $type instanceof \ReflectionNamedType ? $type->getName() : $type->__toString();
  4382. if ('array'=== $name && !$type->isBuiltin()) {
  4383. return;
  4384. }
  4385. } elseif (preg_match('/^(?:[^ ]++ ){4}([a-zA-Z_\x7F-\xFF][^ ]++)/', $parameter, $name)) {
  4386. $name = $name[1];
  4387. } else {
  4388. return;
  4389. }
  4390. $lcName = strtolower($name);
  4391. if ('self'!== $lcName &&'parent'!== $lcName) {
  4392. return $name;
  4393. }
  4394. if (!$function instanceof \ReflectionMethod) {
  4395. return;
  4396. }
  4397. if ('self'=== $lcName) {
  4398. return $function->getDeclaringClass()->name;
  4399. }
  4400. if ($parent = $function->getDeclaringClass()->getParentClass()) {
  4401. return $parent->name;
  4402. }
  4403. }
  4404. }
  4405. }
  4406. namespace Symfony\Component\HttpKernel\Event
  4407. {
  4408. use Symfony\Component\EventDispatcher\Event;
  4409. use Symfony\Component\HttpFoundation\Request;
  4410. use Symfony\Component\HttpKernel\HttpKernelInterface;
  4411. class KernelEvent extends Event
  4412. {
  4413. private $kernel;
  4414. private $request;
  4415. private $requestType;
  4416. public function __construct(HttpKernelInterface $kernel, Request $request, $requestType)
  4417. {
  4418. $this->kernel = $kernel;
  4419. $this->request = $request;
  4420. $this->requestType = $requestType;
  4421. }
  4422. public function getKernel()
  4423. {
  4424. return $this->kernel;
  4425. }
  4426. public function getRequest()
  4427. {
  4428. return $this->request;
  4429. }
  4430. public function getRequestType()
  4431. {
  4432. return $this->requestType;
  4433. }
  4434. public function isMasterRequest()
  4435. {
  4436. return HttpKernelInterface::MASTER_REQUEST === $this->requestType;
  4437. }
  4438. }
  4439. }
  4440. namespace Symfony\Component\HttpKernel\Event
  4441. {
  4442. use Symfony\Component\HttpFoundation\Request;
  4443. use Symfony\Component\HttpKernel\HttpKernelInterface;
  4444. class FilterControllerEvent extends KernelEvent
  4445. {
  4446. private $controller;
  4447. public function __construct(HttpKernelInterface $kernel, callable $controller, Request $request, $requestType)
  4448. {
  4449. parent::__construct($kernel, $request, $requestType);
  4450. $this->setController($controller);
  4451. }
  4452. public function getController()
  4453. {
  4454. return $this->controller;
  4455. }
  4456. public function setController(callable $controller)
  4457. {
  4458. $this->controller = $controller;
  4459. }
  4460. }
  4461. }
  4462. namespace Symfony\Component\HttpKernel\Event
  4463. {
  4464. use Symfony\Component\HttpFoundation\Request;
  4465. use Symfony\Component\HttpFoundation\Response;
  4466. use Symfony\Component\HttpKernel\HttpKernelInterface;
  4467. class FilterResponseEvent extends KernelEvent
  4468. {
  4469. private $response;
  4470. public function __construct(HttpKernelInterface $kernel, Request $request, $requestType, Response $response)
  4471. {
  4472. parent::__construct($kernel, $request, $requestType);
  4473. $this->setResponse($response);
  4474. }
  4475. public function getResponse()
  4476. {
  4477. return $this->response;
  4478. }
  4479. public function setResponse(Response $response)
  4480. {
  4481. $this->response = $response;
  4482. }
  4483. }
  4484. }
  4485. namespace Symfony\Component\HttpKernel\Event
  4486. {
  4487. use Symfony\Component\HttpFoundation\Response;
  4488. class GetResponseEvent extends KernelEvent
  4489. {
  4490. private $response;
  4491. public function getResponse()
  4492. {
  4493. return $this->response;
  4494. }
  4495. public function setResponse(Response $response)
  4496. {
  4497. $this->response = $response;
  4498. $this->stopPropagation();
  4499. }
  4500. public function hasResponse()
  4501. {
  4502. return null !== $this->response;
  4503. }
  4504. }
  4505. }
  4506. namespace Symfony\Component\HttpKernel\Event
  4507. {
  4508. use Symfony\Component\HttpFoundation\Request;
  4509. use Symfony\Component\HttpKernel\HttpKernelInterface;
  4510. class GetResponseForControllerResultEvent extends GetResponseEvent
  4511. {
  4512. private $controllerResult;
  4513. public function __construct(HttpKernelInterface $kernel, Request $request, $requestType, $controllerResult)
  4514. {
  4515. parent::__construct($kernel, $request, $requestType);
  4516. $this->controllerResult = $controllerResult;
  4517. }
  4518. public function getControllerResult()
  4519. {
  4520. return $this->controllerResult;
  4521. }
  4522. public function setControllerResult($controllerResult)
  4523. {
  4524. $this->controllerResult = $controllerResult;
  4525. }
  4526. }
  4527. }
  4528. namespace Symfony\Component\HttpKernel\Event
  4529. {
  4530. use Symfony\Component\HttpFoundation\Request;
  4531. use Symfony\Component\HttpKernel\HttpKernelInterface;
  4532. class GetResponseForExceptionEvent extends GetResponseEvent
  4533. {
  4534. private $exception;
  4535. private $allowCustomResponseCode = false;
  4536. public function __construct(HttpKernelInterface $kernel, Request $request, $requestType, \Exception $e)
  4537. {
  4538. parent::__construct($kernel, $request, $requestType);
  4539. $this->setException($e);
  4540. }
  4541. public function getException()
  4542. {
  4543. return $this->exception;
  4544. }
  4545. public function setException(\Exception $exception)
  4546. {
  4547. $this->exception = $exception;
  4548. }
  4549. public function allowCustomResponseCode()
  4550. {
  4551. $this->allowCustomResponseCode = true;
  4552. }
  4553. public function isAllowingCustomResponseCode()
  4554. {
  4555. return $this->allowCustomResponseCode;
  4556. }
  4557. }
  4558. }
  4559. namespace Symfony\Component\HttpKernel
  4560. {
  4561. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  4562. use Symfony\Component\HttpFoundation\Exception\RequestExceptionInterface;
  4563. use Symfony\Component\HttpFoundation\Request;
  4564. use Symfony\Component\HttpFoundation\RequestStack;
  4565. use Symfony\Component\HttpFoundation\Response;
  4566. use Symfony\Component\HttpKernel\Controller\ArgumentResolver;
  4567. use Symfony\Component\HttpKernel\Controller\ArgumentResolverInterface;
  4568. use Symfony\Component\HttpKernel\Controller\ControllerResolverInterface;
  4569. use Symfony\Component\HttpKernel\Event\FilterControllerArgumentsEvent;
  4570. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  4571. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  4572. use Symfony\Component\HttpKernel\Event\FinishRequestEvent;
  4573. use Symfony\Component\HttpKernel\Event\GetResponseEvent;
  4574. use Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent;
  4575. use Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent;
  4576. use Symfony\Component\HttpKernel\Event\PostResponseEvent;
  4577. use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  4578. use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
  4579. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  4580. class HttpKernel implements HttpKernelInterface, TerminableInterface
  4581. {
  4582. protected $dispatcher;
  4583. protected $resolver;
  4584. protected $requestStack;
  4585. private $argumentResolver;
  4586. public function __construct(EventDispatcherInterface $dispatcher, ControllerResolverInterface $resolver, RequestStack $requestStack = null, ArgumentResolverInterface $argumentResolver = null)
  4587. {
  4588. $this->dispatcher = $dispatcher;
  4589. $this->resolver = $resolver;
  4590. $this->requestStack = $requestStack ?: new RequestStack();
  4591. $this->argumentResolver = $argumentResolver;
  4592. if (null === $this->argumentResolver) {
  4593. @trigger_error(sprintf('As of 3.1 an %s is used to resolve arguments. In 4.0 the $argumentResolver becomes the %s if no other is provided instead of using the $resolver argument.', ArgumentResolverInterface::class, ArgumentResolver::class), E_USER_DEPRECATED);
  4594. $this->argumentResolver = $resolver;
  4595. }
  4596. }
  4597. public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
  4598. {
  4599. $request->headers->set('X-Php-Ob-Level', ob_get_level());
  4600. try {
  4601. return $this->handleRaw($request, $type);
  4602. } catch (\Exception $e) {
  4603. if ($e instanceof RequestExceptionInterface) {
  4604. $e = new BadRequestHttpException($e->getMessage(), $e);
  4605. }
  4606. if (false === $catch) {
  4607. $this->finishRequest($request, $type);
  4608. throw $e;
  4609. }
  4610. return $this->handleException($e, $request, $type);
  4611. }
  4612. }
  4613. public function terminate(Request $request, Response $response)
  4614. {
  4615. $this->dispatcher->dispatch(KernelEvents::TERMINATE, new PostResponseEvent($this, $request, $response));
  4616. }
  4617. public function terminateWithException(\Exception $exception, Request $request = null)
  4618. {
  4619. if (!$request = $request ?: $this->requestStack->getMasterRequest()) {
  4620. throw $exception;
  4621. }
  4622. $response = $this->handleException($exception, $request, self::MASTER_REQUEST);
  4623. $response->sendHeaders();
  4624. $response->sendContent();
  4625. $this->terminate($request, $response);
  4626. }
  4627. private function handleRaw(Request $request, $type = self::MASTER_REQUEST)
  4628. {
  4629. $this->requestStack->push($request);
  4630. $event = new GetResponseEvent($this, $request, $type);
  4631. $this->dispatcher->dispatch(KernelEvents::REQUEST, $event);
  4632. if ($event->hasResponse()) {
  4633. return $this->filterResponse($event->getResponse(), $request, $type);
  4634. }
  4635. if (false === $controller = $this->resolver->getController($request)) {
  4636. throw new NotFoundHttpException(sprintf('Unable to find the controller for path "%s". The route is wrongly configured.', $request->getPathInfo()));
  4637. }
  4638. $event = new FilterControllerEvent($this, $controller, $request, $type);
  4639. $this->dispatcher->dispatch(KernelEvents::CONTROLLER, $event);
  4640. $controller = $event->getController();
  4641. $arguments = $this->argumentResolver->getArguments($request, $controller);
  4642. $event = new FilterControllerArgumentsEvent($this, $controller, $arguments, $request, $type);
  4643. $this->dispatcher->dispatch(KernelEvents::CONTROLLER_ARGUMENTS, $event);
  4644. $controller = $event->getController();
  4645. $arguments = $event->getArguments();
  4646. $response = \call_user_func_array($controller, $arguments);
  4647. if (!$response instanceof Response) {
  4648. $event = new GetResponseForControllerResultEvent($this, $request, $type, $response);
  4649. $this->dispatcher->dispatch(KernelEvents::VIEW, $event);
  4650. if ($event->hasResponse()) {
  4651. $response = $event->getResponse();
  4652. }
  4653. if (!$response instanceof Response) {
  4654. $msg = sprintf('The controller must return a response (%s given).', $this->varToString($response));
  4655. if (null === $response) {
  4656. $msg .=' Did you forget to add a return statement somewhere in your controller?';
  4657. }
  4658. throw new \LogicException($msg);
  4659. }
  4660. }
  4661. return $this->filterResponse($response, $request, $type);
  4662. }
  4663. private function filterResponse(Response $response, Request $request, $type)
  4664. {
  4665. $event = new FilterResponseEvent($this, $request, $type, $response);
  4666. $this->dispatcher->dispatch(KernelEvents::RESPONSE, $event);
  4667. $this->finishRequest($request, $type);
  4668. return $event->getResponse();
  4669. }
  4670. private function finishRequest(Request $request, $type)
  4671. {
  4672. $this->dispatcher->dispatch(KernelEvents::FINISH_REQUEST, new FinishRequestEvent($this, $request, $type));
  4673. $this->requestStack->pop();
  4674. }
  4675. private function handleException(\Exception $e, $request, $type)
  4676. {
  4677. $event = new GetResponseForExceptionEvent($this, $request, $type, $e);
  4678. $this->dispatcher->dispatch(KernelEvents::EXCEPTION, $event);
  4679. $e = $event->getException();
  4680. if (!$event->hasResponse()) {
  4681. $this->finishRequest($request, $type);
  4682. throw $e;
  4683. }
  4684. $response = $event->getResponse();
  4685. if ($response->headers->has('X-Status-Code')) {
  4686. @trigger_error(sprintf('Using the X-Status-Code header is deprecated since Symfony 3.3 and will be removed in 4.0. Use %s::allowCustomResponseCode() instead.', GetResponseForExceptionEvent::class), E_USER_DEPRECATED);
  4687. $response->setStatusCode($response->headers->get('X-Status-Code'));
  4688. $response->headers->remove('X-Status-Code');
  4689. } elseif (!$event->isAllowingCustomResponseCode() && !$response->isClientError() && !$response->isServerError() && !$response->isRedirect()) {
  4690. if ($e instanceof HttpExceptionInterface) {
  4691. $response->setStatusCode($e->getStatusCode());
  4692. $response->headers->add($e->getHeaders());
  4693. } else {
  4694. $response->setStatusCode(500);
  4695. }
  4696. }
  4697. try {
  4698. return $this->filterResponse($response, $request, $type);
  4699. } catch (\Exception $e) {
  4700. return $response;
  4701. }
  4702. }
  4703. private function varToString($var)
  4704. {
  4705. if (\is_object($var)) {
  4706. return sprintf('Object(%s)', \get_class($var));
  4707. }
  4708. if (\is_array($var)) {
  4709. $a = array();
  4710. foreach ($var as $k => $v) {
  4711. $a[] = sprintf('%s => %s', $k, $this->varToString($v));
  4712. }
  4713. return sprintf('Array(%s)', implode(', ', $a));
  4714. }
  4715. if (\is_resource($var)) {
  4716. return sprintf('Resource(%s)', get_resource_type($var));
  4717. }
  4718. if (null === $var) {
  4719. return'null';
  4720. }
  4721. if (false === $var) {
  4722. return'false';
  4723. }
  4724. if (true === $var) {
  4725. return'true';
  4726. }
  4727. return (string) $var;
  4728. }
  4729. }
  4730. }
  4731. namespace Symfony\Component\HttpKernel
  4732. {
  4733. final class KernelEvents
  4734. {
  4735. const REQUEST ='kernel.request';
  4736. const EXCEPTION ='kernel.exception';
  4737. const VIEW ='kernel.view';
  4738. const CONTROLLER ='kernel.controller';
  4739. const CONTROLLER_ARGUMENTS ='kernel.controller_arguments';
  4740. const RESPONSE ='kernel.response';
  4741. const TERMINATE ='kernel.terminate';
  4742. const FINISH_REQUEST ='kernel.finish_request';
  4743. }
  4744. }
  4745. namespace Symfony\Component\HttpKernel\Config
  4746. {
  4747. use Symfony\Component\Config\FileLocator as BaseFileLocator;
  4748. use Symfony\Component\HttpKernel\KernelInterface;
  4749. class FileLocator extends BaseFileLocator
  4750. {
  4751. private $kernel;
  4752. private $path;
  4753. public function __construct(KernelInterface $kernel, $path = null, array $paths = array())
  4754. {
  4755. $this->kernel = $kernel;
  4756. if (null !== $path) {
  4757. $this->path = $path;
  4758. $paths[] = $path;
  4759. }
  4760. parent::__construct($paths);
  4761. }
  4762. public function locate($file, $currentPath = null, $first = true)
  4763. {
  4764. if (isset($file[0]) &&'@'=== $file[0]) {
  4765. return $this->kernel->locateResource($file, $this->path, $first);
  4766. }
  4767. return parent::locate($file, $currentPath, $first);
  4768. }
  4769. }
  4770. }
  4771. namespace Symfony\Bundle\FrameworkBundle\Controller
  4772. {
  4773. use Symfony\Component\HttpKernel\KernelInterface;
  4774. class ControllerNameParser
  4775. {
  4776. protected $kernel;
  4777. public function __construct(KernelInterface $kernel)
  4778. {
  4779. $this->kernel = $kernel;
  4780. }
  4781. public function parse($controller)
  4782. {
  4783. $parts = explode(':', $controller);
  4784. if (3 !== \count($parts) || \in_array('', $parts, true)) {
  4785. throw new \InvalidArgumentException(sprintf('The "%s" controller is not a valid "a:b:c" controller string.', $controller));
  4786. }
  4787. $originalController = $controller;
  4788. list($bundle, $controller, $action) = $parts;
  4789. $controller = str_replace('/','\\', $controller);
  4790. $bundles = array();
  4791. try {
  4792. $allBundles = $this->kernel->getBundle($bundle, false, true);
  4793. } catch (\InvalidArgumentException $e) {
  4794. $message = sprintf('The "%s" (from the _controller value "%s") does not exist or is not enabled in your kernel!',
  4795. $bundle,
  4796. $originalController
  4797. );
  4798. if ($alternative = $this->findAlternative($bundle)) {
  4799. $message .= sprintf(' Did you mean "%s:%s:%s"?', $alternative, $controller, $action);
  4800. }
  4801. throw new \InvalidArgumentException($message, 0, $e);
  4802. }
  4803. if (!\is_array($allBundles)) {
  4804. $allBundles = array($allBundles);
  4805. }
  4806. foreach ($allBundles as $b) {
  4807. $try = $b->getNamespace().'\\Controller\\'.$controller.'Controller';
  4808. if (class_exists($try)) {
  4809. return $try.'::'.$action.'Action';
  4810. }
  4811. $bundles[] = $b->getName();
  4812. $msg = sprintf('The _controller value "%s:%s:%s" maps to a "%s" class, but this class was not found. Create this class or check the spelling of the class and its namespace.', $bundle, $controller, $action, $try);
  4813. }
  4814. if (\count($bundles) > 1) {
  4815. $msg = sprintf('Unable to find controller "%s:%s" in bundles %s.', $bundle, $controller, implode(', ', $bundles));
  4816. }
  4817. throw new \InvalidArgumentException($msg);
  4818. }
  4819. public function build($controller)
  4820. {
  4821. if (0 === preg_match('#^(.*?\\\\Controller\\\\(.+)Controller)::(.+)Action$#', $controller, $match)) {
  4822. throw new \InvalidArgumentException(sprintf('The "%s" controller is not a valid "class::method" string.', $controller));
  4823. }
  4824. $className = $match[1];
  4825. $controllerName = $match[2];
  4826. $actionName = $match[3];
  4827. foreach ($this->kernel->getBundles() as $name => $bundle) {
  4828. if (0 !== strpos($className, $bundle->getNamespace())) {
  4829. continue;
  4830. }
  4831. return sprintf('%s:%s:%s', $name, $controllerName, $actionName);
  4832. }
  4833. throw new \InvalidArgumentException(sprintf('Unable to find a bundle that defines controller "%s".', $controller));
  4834. }
  4835. private function findAlternative($nonExistentBundleName)
  4836. {
  4837. $bundleNames = array_map(function ($b) {
  4838. return $b->getName();
  4839. }, $this->kernel->getBundles());
  4840. $alternative = null;
  4841. $shortest = null;
  4842. foreach ($bundleNames as $bundleName) {
  4843. if (false !== strpos($bundleName, $nonExistentBundleName)) {
  4844. return $bundleName;
  4845. }
  4846. $lev = levenshtein($nonExistentBundleName, $bundleName);
  4847. if ($lev <= \strlen($nonExistentBundleName) / 3 && (null === $alternative || $lev < $shortest)) {
  4848. $alternative = $bundleName;
  4849. $shortest = $lev;
  4850. }
  4851. }
  4852. return $alternative;
  4853. }
  4854. }
  4855. }
  4856. namespace Symfony\Component\HttpKernel\Controller
  4857. {
  4858. use Psr\Container\ContainerInterface;
  4859. use Psr\Log\LoggerInterface;
  4860. use Symfony\Component\DependencyInjection\Container;
  4861. use Symfony\Component\HttpFoundation\Request;
  4862. class ContainerControllerResolver extends ControllerResolver
  4863. {
  4864. protected $container;
  4865. public function __construct(ContainerInterface $container, LoggerInterface $logger = null)
  4866. {
  4867. $this->container = $container;
  4868. parent::__construct($logger);
  4869. }
  4870. public function getController(Request $request)
  4871. {
  4872. $controller = parent::getController($request);
  4873. if (\is_array($controller) && isset($controller[0]) && \is_string($controller[0]) && $this->container->has($controller[0])) {
  4874. $controller[0] = $this->instantiateController($controller[0]);
  4875. }
  4876. return $controller;
  4877. }
  4878. protected function createController($controller)
  4879. {
  4880. if (false !== strpos($controller,'::')) {
  4881. return parent::createController($controller);
  4882. }
  4883. $method = null;
  4884. if (1 == substr_count($controller,':')) {
  4885. list($controller, $method) = explode(':', $controller, 2);
  4886. }
  4887. if (!$this->container->has($controller)) {
  4888. $this->throwExceptionIfControllerWasRemoved($controller);
  4889. throw new \LogicException(sprintf('Controller not found: service "%s" does not exist.', $controller));
  4890. }
  4891. $service = $this->container->get($controller);
  4892. if (null !== $method) {
  4893. return array($service, $method);
  4894. }
  4895. if (!method_exists($service,'__invoke')) {
  4896. throw new \LogicException(sprintf('Controller "%s" cannot be called without a method name. Did you forget an "__invoke" method?', $controller));
  4897. }
  4898. return $service;
  4899. }
  4900. protected function instantiateController($class)
  4901. {
  4902. if ($this->container->has($class)) {
  4903. return $this->container->get($class);
  4904. }
  4905. try {
  4906. return parent::instantiateController($class);
  4907. } catch (\ArgumentCountError $e) {
  4908. } catch (\ErrorException $e) {
  4909. } catch (\TypeError $e) {
  4910. }
  4911. $this->throwExceptionIfControllerWasRemoved($class, $e);
  4912. throw $e;
  4913. }
  4914. private function throwExceptionIfControllerWasRemoved($controller, $previous = null)
  4915. {
  4916. if ($this->container instanceof Container && isset($this->container->getRemovedIds()[$controller])) {
  4917. throw new \LogicException(sprintf('Controller "%s" cannot be fetched from the container because it is private. Did you forget to tag the service with "controller.service_arguments"?', $controller), 0, $previous);
  4918. }
  4919. }
  4920. }
  4921. }
  4922. namespace Symfony\Bundle\FrameworkBundle\Controller
  4923. {
  4924. use Psr\Log\LoggerInterface;
  4925. use Symfony\Component\DependencyInjection\ContainerAwareInterface;
  4926. use Symfony\Component\DependencyInjection\ContainerInterface;
  4927. use Symfony\Component\HttpKernel\Controller\ContainerControllerResolver;
  4928. class ControllerResolver extends ContainerControllerResolver
  4929. {
  4930. protected $parser;
  4931. public function __construct(ContainerInterface $container, ControllerNameParser $parser, LoggerInterface $logger = null)
  4932. {
  4933. $this->parser = $parser;
  4934. parent::__construct($container, $logger);
  4935. }
  4936. protected function createController($controller)
  4937. {
  4938. if (false === strpos($controller,'::') && 2 === substr_count($controller,':')) {
  4939. $controller = $this->parser->parse($controller);
  4940. }
  4941. $resolvedController = parent::createController($controller);
  4942. if (1 === substr_count($controller,':') && \is_array($resolvedController)) {
  4943. $resolvedController[0] = $this->configureController($resolvedController[0]);
  4944. }
  4945. return $resolvedController;
  4946. }
  4947. protected function instantiateController($class)
  4948. {
  4949. return $this->configureController(parent::instantiateController($class));
  4950. }
  4951. private function configureController($controller)
  4952. {
  4953. if ($controller instanceof ContainerAwareInterface) {
  4954. switch (\get_class($controller)) {
  4955. case RedirectController::class:
  4956. case TemplateController::class:
  4957. return $controller;
  4958. }
  4959. $controller->setContainer($this->container);
  4960. }
  4961. if ($controller instanceof AbstractController && null !== $previousContainer = $controller->setContainer($this->container)) {
  4962. $controller->setContainer($previousContainer);
  4963. }
  4964. return $controller;
  4965. }
  4966. }
  4967. }
  4968. namespace Symfony\Component\Security\Http
  4969. {
  4970. use Symfony\Component\HttpFoundation\Request;
  4971. interface AccessMapInterface
  4972. {
  4973. public function getPatterns(Request $request);
  4974. }
  4975. }
  4976. namespace Symfony\Component\Security\Http
  4977. {
  4978. use Symfony\Component\HttpFoundation\Request;
  4979. use Symfony\Component\HttpFoundation\RequestMatcherInterface;
  4980. class AccessMap implements AccessMapInterface
  4981. {
  4982. private $map = array();
  4983. public function add(RequestMatcherInterface $requestMatcher, array $attributes = array(), $channel = null)
  4984. {
  4985. $this->map[] = array($requestMatcher, $attributes, $channel);
  4986. }
  4987. public function getPatterns(Request $request)
  4988. {
  4989. foreach ($this->map as $elements) {
  4990. if (null === $elements[0] || $elements[0]->matches($request)) {
  4991. return array($elements[1], $elements[2]);
  4992. }
  4993. }
  4994. return array(null, null);
  4995. }
  4996. }
  4997. }
  4998. namespace Symfony\Component\Security\Http
  4999. {
  5000. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  5001. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  5002. use Symfony\Component\HttpKernel\Event\FinishRequestEvent;
  5003. use Symfony\Component\HttpKernel\Event\GetResponseEvent;
  5004. use Symfony\Component\HttpKernel\KernelEvents;
  5005. use Symfony\Component\Security\Http\Firewall\AccessListener;
  5006. class Firewall implements EventSubscriberInterface
  5007. {
  5008. private $map;
  5009. private $dispatcher;
  5010. private $exceptionListeners;
  5011. public function __construct(FirewallMapInterface $map, EventDispatcherInterface $dispatcher)
  5012. {
  5013. $this->map = $map;
  5014. $this->dispatcher = $dispatcher;
  5015. $this->exceptionListeners = new \SplObjectStorage();
  5016. }
  5017. public function onKernelRequest(GetResponseEvent $event)
  5018. {
  5019. if (!$event->isMasterRequest()) {
  5020. return;
  5021. }
  5022. $listeners = $this->map->getListeners($event->getRequest());
  5023. $authenticationListeners = $listeners[0];
  5024. $exceptionListener = $listeners[1];
  5025. $logoutListener = isset($listeners[2]) ? $listeners[2] : null;
  5026. if (null !== $exceptionListener) {
  5027. $this->exceptionListeners[$event->getRequest()] = $exceptionListener;
  5028. $exceptionListener->register($this->dispatcher);
  5029. }
  5030. $authenticationListeners = function () use ($authenticationListeners, $logoutListener) {
  5031. $accessListener = null;
  5032. foreach ($authenticationListeners as $listener) {
  5033. if ($listener instanceof AccessListener) {
  5034. $accessListener = $listener;
  5035. continue;
  5036. }
  5037. yield $listener;
  5038. }
  5039. if (null !== $logoutListener) {
  5040. yield $logoutListener;
  5041. }
  5042. if (null !== $accessListener) {
  5043. yield $accessListener;
  5044. }
  5045. };
  5046. $this->handleRequest($event, $authenticationListeners());
  5047. }
  5048. public function onKernelFinishRequest(FinishRequestEvent $event)
  5049. {
  5050. $request = $event->getRequest();
  5051. if (isset($this->exceptionListeners[$request])) {
  5052. $this->exceptionListeners[$request]->unregister($this->dispatcher);
  5053. unset($this->exceptionListeners[$request]);
  5054. }
  5055. }
  5056. public static function getSubscribedEvents()
  5057. {
  5058. return array(
  5059. KernelEvents::REQUEST => array('onKernelRequest', 8),
  5060. KernelEvents::FINISH_REQUEST =>'onKernelFinishRequest',
  5061. );
  5062. }
  5063. protected function handleRequest(GetResponseEvent $event, $listeners)
  5064. {
  5065. foreach ($listeners as $listener) {
  5066. $listener->handle($event);
  5067. if ($event->hasResponse()) {
  5068. break;
  5069. }
  5070. }
  5071. }
  5072. }
  5073. }
  5074. namespace Symfony\Component\Security\Core\User
  5075. {
  5076. use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
  5077. use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
  5078. interface UserProviderInterface
  5079. {
  5080. public function loadUserByUsername($username);
  5081. public function refreshUser(UserInterface $user);
  5082. public function supportsClass($class);
  5083. }
  5084. }
  5085. namespace Symfony\Component\Security\Core\Authentication
  5086. {
  5087. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  5088. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  5089. interface AuthenticationManagerInterface
  5090. {
  5091. public function authenticate(TokenInterface $token);
  5092. }
  5093. }
  5094. namespace Symfony\Component\Security\Core\Authentication
  5095. {
  5096. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  5097. use Symfony\Component\Security\Core\Authentication\Provider\AuthenticationProviderInterface;
  5098. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  5099. use Symfony\Component\Security\Core\AuthenticationEvents;
  5100. use Symfony\Component\Security\Core\Event\AuthenticationEvent;
  5101. use Symfony\Component\Security\Core\Event\AuthenticationFailureEvent;
  5102. use Symfony\Component\Security\Core\Exception\AccountStatusException;
  5103. use Symfony\Component\Security\Core\Exception\AuthenticationException;
  5104. use Symfony\Component\Security\Core\Exception\ProviderNotFoundException;
  5105. class AuthenticationProviderManager implements AuthenticationManagerInterface
  5106. {
  5107. private $providers;
  5108. private $eraseCredentials;
  5109. private $eventDispatcher;
  5110. public function __construct($providers, $eraseCredentials = true)
  5111. {
  5112. if (!$providers) {
  5113. throw new \InvalidArgumentException('You must at least add one authentication provider.');
  5114. }
  5115. $this->providers = $providers;
  5116. $this->eraseCredentials = (bool) $eraseCredentials;
  5117. }
  5118. public function setEventDispatcher(EventDispatcherInterface $dispatcher)
  5119. {
  5120. $this->eventDispatcher = $dispatcher;
  5121. }
  5122. public function authenticate(TokenInterface $token)
  5123. {
  5124. $lastException = null;
  5125. $result = null;
  5126. foreach ($this->providers as $provider) {
  5127. if (!$provider instanceof AuthenticationProviderInterface) {
  5128. throw new \InvalidArgumentException(sprintf('Provider "%s" must implement the AuthenticationProviderInterface.', \get_class($provider)));
  5129. }
  5130. if (!$provider->supports($token)) {
  5131. continue;
  5132. }
  5133. try {
  5134. $result = $provider->authenticate($token);
  5135. if (null !== $result) {
  5136. break;
  5137. }
  5138. } catch (AccountStatusException $e) {
  5139. $lastException = $e;
  5140. break;
  5141. } catch (AuthenticationException $e) {
  5142. $lastException = $e;
  5143. }
  5144. }
  5145. if (null !== $result) {
  5146. if (true === $this->eraseCredentials) {
  5147. $result->eraseCredentials();
  5148. }
  5149. if (null !== $this->eventDispatcher) {
  5150. $this->eventDispatcher->dispatch(AuthenticationEvents::AUTHENTICATION_SUCCESS, new AuthenticationEvent($result));
  5151. }
  5152. return $result;
  5153. }
  5154. if (null === $lastException) {
  5155. $lastException = new ProviderNotFoundException(sprintf('No Authentication Provider found for token of class "%s".', \get_class($token)));
  5156. }
  5157. if (null !== $this->eventDispatcher) {
  5158. $this->eventDispatcher->dispatch(AuthenticationEvents::AUTHENTICATION_FAILURE, new AuthenticationFailureEvent($token, $lastException));
  5159. }
  5160. $lastException->setToken($token);
  5161. throw $lastException;
  5162. }
  5163. }
  5164. }
  5165. namespace Symfony\Component\Security\Core\Authentication\Token\Storage
  5166. {
  5167. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  5168. interface TokenStorageInterface
  5169. {
  5170. public function getToken();
  5171. public function setToken(TokenInterface $token = null);
  5172. }
  5173. }
  5174. namespace Symfony\Component\Security\Core\Authentication\Token\Storage
  5175. {
  5176. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  5177. class TokenStorage implements TokenStorageInterface
  5178. {
  5179. private $token;
  5180. public function getToken()
  5181. {
  5182. return $this->token;
  5183. }
  5184. public function setToken(TokenInterface $token = null)
  5185. {
  5186. $this->token = $token;
  5187. }
  5188. }
  5189. }
  5190. namespace Symfony\Component\Security\Core\Authorization
  5191. {
  5192. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  5193. interface AccessDecisionManagerInterface
  5194. {
  5195. public function decide(TokenInterface $token, array $attributes, $object = null);
  5196. }
  5197. }
  5198. namespace Symfony\Component\Security\Core\Authorization
  5199. {
  5200. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  5201. use Symfony\Component\Security\Core\Authorization\Voter\VoterInterface;
  5202. use Symfony\Component\Security\Core\Exception\LogicException;
  5203. class AccessDecisionManager implements AccessDecisionManagerInterface
  5204. {
  5205. const STRATEGY_AFFIRMATIVE ='affirmative';
  5206. const STRATEGY_CONSENSUS ='consensus';
  5207. const STRATEGY_UNANIMOUS ='unanimous';
  5208. private $voters;
  5209. private $strategy;
  5210. private $allowIfAllAbstainDecisions;
  5211. private $allowIfEqualGrantedDeniedDecisions;
  5212. public function __construct($voters = array(), $strategy = self::STRATEGY_AFFIRMATIVE, $allowIfAllAbstainDecisions = false, $allowIfEqualGrantedDeniedDecisions = true)
  5213. {
  5214. $strategyMethod ='decide'.ucfirst($strategy);
  5215. if (!\is_callable(array($this, $strategyMethod))) {
  5216. throw new \InvalidArgumentException(sprintf('The strategy "%s" is not supported.', $strategy));
  5217. }
  5218. $this->voters = $voters;
  5219. $this->strategy = $strategyMethod;
  5220. $this->allowIfAllAbstainDecisions = (bool) $allowIfAllAbstainDecisions;
  5221. $this->allowIfEqualGrantedDeniedDecisions = (bool) $allowIfEqualGrantedDeniedDecisions;
  5222. }
  5223. public function setVoters(array $voters)
  5224. {
  5225. @trigger_error(sprintf('The %s() method is deprecated since Symfony 3.3 and will be removed in 4.0. Pass the voters to the constructor instead.', __METHOD__), E_USER_DEPRECATED);
  5226. $this->voters = $voters;
  5227. }
  5228. public function decide(TokenInterface $token, array $attributes, $object = null)
  5229. {
  5230. return $this->{$this->strategy}($token, $attributes, $object);
  5231. }
  5232. private function decideAffirmative(TokenInterface $token, array $attributes, $object = null)
  5233. {
  5234. $deny = 0;
  5235. foreach ($this->voters as $voter) {
  5236. $result = $this->vote($voter, $token, $object, $attributes);
  5237. switch ($result) {
  5238. case VoterInterface::ACCESS_GRANTED:
  5239. return true;
  5240. case VoterInterface::ACCESS_DENIED:
  5241. ++$deny;
  5242. break;
  5243. default:
  5244. break;
  5245. }
  5246. }
  5247. if ($deny > 0) {
  5248. return false;
  5249. }
  5250. return $this->allowIfAllAbstainDecisions;
  5251. }
  5252. private function decideConsensus(TokenInterface $token, array $attributes, $object = null)
  5253. {
  5254. $grant = 0;
  5255. $deny = 0;
  5256. foreach ($this->voters as $voter) {
  5257. $result = $this->vote($voter, $token, $object, $attributes);
  5258. switch ($result) {
  5259. case VoterInterface::ACCESS_GRANTED:
  5260. ++$grant;
  5261. break;
  5262. case VoterInterface::ACCESS_DENIED:
  5263. ++$deny;
  5264. break;
  5265. }
  5266. }
  5267. if ($grant > $deny) {
  5268. return true;
  5269. }
  5270. if ($deny > $grant) {
  5271. return false;
  5272. }
  5273. if ($grant > 0) {
  5274. return $this->allowIfEqualGrantedDeniedDecisions;
  5275. }
  5276. return $this->allowIfAllAbstainDecisions;
  5277. }
  5278. private function decideUnanimous(TokenInterface $token, array $attributes, $object = null)
  5279. {
  5280. $grant = 0;
  5281. foreach ($this->voters as $voter) {
  5282. foreach ($attributes as $attribute) {
  5283. $result = $this->vote($voter, $token, $object, array($attribute));
  5284. switch ($result) {
  5285. case VoterInterface::ACCESS_GRANTED:
  5286. ++$grant;
  5287. break;
  5288. case VoterInterface::ACCESS_DENIED:
  5289. return false;
  5290. default:
  5291. break;
  5292. }
  5293. }
  5294. }
  5295. if ($grant > 0) {
  5296. return true;
  5297. }
  5298. return $this->allowIfAllAbstainDecisions;
  5299. }
  5300. private function vote($voter, TokenInterface $token, $subject, $attributes)
  5301. {
  5302. if ($voter instanceof VoterInterface) {
  5303. return $voter->vote($token, $subject, $attributes);
  5304. }
  5305. if (method_exists($voter,'vote')) {
  5306. @trigger_error(sprintf('Calling vote() on an voter without %1$s is deprecated as of 3.4 and will be removed in 4.0. Implement the %1$s on your voter.', VoterInterface::class), E_USER_DEPRECATED);
  5307. return $voter->vote($token, $subject, $attributes);
  5308. }
  5309. throw new LogicException(sprintf('%s should implement the %s interface when used as voter.', \get_class($voter), VoterInterface::class));
  5310. }
  5311. }
  5312. }
  5313. namespace Symfony\Component\Security\Core\Authorization
  5314. {
  5315. interface AuthorizationCheckerInterface
  5316. {
  5317. public function isGranted($attributes, $subject = null);
  5318. }
  5319. }
  5320. namespace Symfony\Component\Security\Core\Authorization
  5321. {
  5322. use Symfony\Component\Security\Core\Authentication\AuthenticationManagerInterface;
  5323. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  5324. use Symfony\Component\Security\Core\Exception\AuthenticationCredentialsNotFoundException;
  5325. class AuthorizationChecker implements AuthorizationCheckerInterface
  5326. {
  5327. private $tokenStorage;
  5328. private $accessDecisionManager;
  5329. private $authenticationManager;
  5330. private $alwaysAuthenticate;
  5331. public function __construct(TokenStorageInterface $tokenStorage, AuthenticationManagerInterface $authenticationManager, AccessDecisionManagerInterface $accessDecisionManager, $alwaysAuthenticate = false)
  5332. {
  5333. $this->tokenStorage = $tokenStorage;
  5334. $this->authenticationManager = $authenticationManager;
  5335. $this->accessDecisionManager = $accessDecisionManager;
  5336. $this->alwaysAuthenticate = $alwaysAuthenticate;
  5337. }
  5338. final public function isGranted($attributes, $subject = null)
  5339. {
  5340. if (null === ($token = $this->tokenStorage->getToken())) {
  5341. throw new AuthenticationCredentialsNotFoundException('The token storage contains no authentication token. One possible reason may be that there is no firewall configured for this URL.');
  5342. }
  5343. if ($this->alwaysAuthenticate || !$token->isAuthenticated()) {
  5344. $this->tokenStorage->setToken($token = $this->authenticationManager->authenticate($token));
  5345. }
  5346. if (!\is_array($attributes)) {
  5347. $attributes = array($attributes);
  5348. }
  5349. return $this->accessDecisionManager->decide($token, $attributes, $subject);
  5350. }
  5351. }
  5352. }
  5353. namespace Symfony\Component\Security\Core\Authorization\Voter
  5354. {
  5355. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  5356. interface VoterInterface
  5357. {
  5358. const ACCESS_GRANTED = 1;
  5359. const ACCESS_ABSTAIN = 0;
  5360. const ACCESS_DENIED = -1;
  5361. public function vote(TokenInterface $token, $subject, array $attributes);
  5362. }
  5363. }
  5364. namespace Symfony\Bundle\SecurityBundle\Security
  5365. {
  5366. final class FirewallConfig
  5367. {
  5368. private $name;
  5369. private $userChecker;
  5370. private $requestMatcher;
  5371. private $securityEnabled;
  5372. private $stateless;
  5373. private $provider;
  5374. private $context;
  5375. private $entryPoint;
  5376. private $accessDeniedHandler;
  5377. private $accessDeniedUrl;
  5378. private $listeners;
  5379. private $switchUser;
  5380. public function __construct($name, $userChecker, $requestMatcher = null, $securityEnabled = true, $stateless = false, $provider = null, $context = null, $entryPoint = null, $accessDeniedHandler = null, $accessDeniedUrl = null, $listeners = array(), $switchUser = null)
  5381. {
  5382. $this->name = $name;
  5383. $this->userChecker = $userChecker;
  5384. $this->requestMatcher = $requestMatcher;
  5385. $this->securityEnabled = $securityEnabled;
  5386. $this->stateless = $stateless;
  5387. $this->provider = $provider;
  5388. $this->context = $context;
  5389. $this->entryPoint = $entryPoint;
  5390. $this->accessDeniedHandler = $accessDeniedHandler;
  5391. $this->accessDeniedUrl = $accessDeniedUrl;
  5392. $this->listeners = $listeners;
  5393. $this->switchUser = $switchUser;
  5394. }
  5395. public function getName()
  5396. {
  5397. return $this->name;
  5398. }
  5399. public function getRequestMatcher()
  5400. {
  5401. return $this->requestMatcher;
  5402. }
  5403. public function isSecurityEnabled()
  5404. {
  5405. return $this->securityEnabled;
  5406. }
  5407. public function allowsAnonymous()
  5408. {
  5409. return \in_array('anonymous', $this->listeners, true);
  5410. }
  5411. public function isStateless()
  5412. {
  5413. return $this->stateless;
  5414. }
  5415. public function getProvider()
  5416. {
  5417. return $this->provider;
  5418. }
  5419. public function getContext()
  5420. {
  5421. return $this->context;
  5422. }
  5423. public function getEntryPoint()
  5424. {
  5425. return $this->entryPoint;
  5426. }
  5427. public function getUserChecker()
  5428. {
  5429. return $this->userChecker;
  5430. }
  5431. public function getAccessDeniedHandler()
  5432. {
  5433. return $this->accessDeniedHandler;
  5434. }
  5435. public function getAccessDeniedUrl()
  5436. {
  5437. return $this->accessDeniedUrl;
  5438. }
  5439. public function getListeners()
  5440. {
  5441. return $this->listeners;
  5442. }
  5443. public function getSwitchUser()
  5444. {
  5445. return $this->switchUser;
  5446. }
  5447. }
  5448. }
  5449. namespace Symfony\Bundle\SecurityBundle\Security
  5450. {
  5451. use Symfony\Component\Security\Http\Firewall\ExceptionListener;
  5452. use Symfony\Component\Security\Http\Firewall\LogoutListener;
  5453. class FirewallContext
  5454. {
  5455. private $listeners;
  5456. private $exceptionListener;
  5457. private $logoutListener;
  5458. private $config;
  5459. public function __construct($listeners, ExceptionListener $exceptionListener = null, $logoutListener = null, FirewallConfig $config = null)
  5460. {
  5461. $this->listeners = $listeners;
  5462. $this->exceptionListener = $exceptionListener;
  5463. if ($logoutListener instanceof FirewallConfig) {
  5464. $this->config = $logoutListener;
  5465. } elseif (null === $logoutListener || $logoutListener instanceof LogoutListener) {
  5466. $this->logoutListener = $logoutListener;
  5467. $this->config = $config;
  5468. } else {
  5469. throw new \InvalidArgumentException(sprintf('Argument 3 passed to %s() must be instance of %s or null, %s given.', __METHOD__, LogoutListener::class, \is_object($logoutListener) ? \get_class($logoutListener) : \gettype($logoutListener)));
  5470. }
  5471. }
  5472. public function getConfig()
  5473. {
  5474. return $this->config;
  5475. }
  5476. public function getContext()
  5477. {
  5478. @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 3.3 and will be removed in 4.0. Use %s::getListeners/getExceptionListener() instead.', __METHOD__, __CLASS__), E_USER_DEPRECATED);
  5479. return array($this->getListeners(), $this->getExceptionListener(), $this->getLogoutListener());
  5480. }
  5481. public function getListeners()
  5482. {
  5483. return $this->listeners;
  5484. }
  5485. public function getExceptionListener()
  5486. {
  5487. return $this->exceptionListener;
  5488. }
  5489. public function getLogoutListener()
  5490. {
  5491. return $this->logoutListener;
  5492. }
  5493. }
  5494. }
  5495. namespace Symfony\Component\HttpFoundation
  5496. {
  5497. interface RequestMatcherInterface
  5498. {
  5499. public function matches(Request $request);
  5500. }
  5501. }
  5502. namespace Symfony\Component\HttpFoundation
  5503. {
  5504. class RequestMatcher implements RequestMatcherInterface
  5505. {
  5506. private $path;
  5507. private $host;
  5508. private $methods = array();
  5509. private $ips = array();
  5510. private $attributes = array();
  5511. private $schemes = array();
  5512. public function __construct($path = null, $host = null, $methods = null, $ips = null, array $attributes = array(), $schemes = null)
  5513. {
  5514. $this->matchPath($path);
  5515. $this->matchHost($host);
  5516. $this->matchMethod($methods);
  5517. $this->matchIps($ips);
  5518. $this->matchScheme($schemes);
  5519. foreach ($attributes as $k => $v) {
  5520. $this->matchAttribute($k, $v);
  5521. }
  5522. }
  5523. public function matchScheme($scheme)
  5524. {
  5525. $this->schemes = null !== $scheme ? array_map('strtolower', (array) $scheme) : array();
  5526. }
  5527. public function matchHost($regexp)
  5528. {
  5529. $this->host = $regexp;
  5530. }
  5531. public function matchPath($regexp)
  5532. {
  5533. $this->path = $regexp;
  5534. }
  5535. public function matchIp($ip)
  5536. {
  5537. $this->matchIps($ip);
  5538. }
  5539. public function matchIps($ips)
  5540. {
  5541. $this->ips = null !== $ips ? (array) $ips : array();
  5542. }
  5543. public function matchMethod($method)
  5544. {
  5545. $this->methods = null !== $method ? array_map('strtoupper', (array) $method) : array();
  5546. }
  5547. public function matchAttribute($key, $regexp)
  5548. {
  5549. $this->attributes[$key] = $regexp;
  5550. }
  5551. public function matches(Request $request)
  5552. {
  5553. if ($this->schemes && !\in_array($request->getScheme(), $this->schemes, true)) {
  5554. return false;
  5555. }
  5556. if ($this->methods && !\in_array($request->getMethod(), $this->methods, true)) {
  5557. return false;
  5558. }
  5559. foreach ($this->attributes as $key => $pattern) {
  5560. if (!preg_match('{'.$pattern.'}', $request->attributes->get($key))) {
  5561. return false;
  5562. }
  5563. }
  5564. if (null !== $this->path && !preg_match('{'.$this->path.'}', rawurldecode($request->getPathInfo()))) {
  5565. return false;
  5566. }
  5567. if (null !== $this->host && !preg_match('{'.$this->host.'}i', $request->getHost())) {
  5568. return false;
  5569. }
  5570. if (IpUtils::checkIp($request->getClientIp(), $this->ips)) {
  5571. return true;
  5572. }
  5573. return 0 === \count($this->ips);
  5574. }
  5575. }
  5576. }
  5577. namespace
  5578. {
  5579. class Twig_Environment
  5580. {
  5581. const VERSION ='1.35.4';
  5582. const VERSION_ID = 13504;
  5583. const MAJOR_VERSION = 1;
  5584. const MINOR_VERSION = 35;
  5585. const RELEASE_VERSION = 4;
  5586. const EXTRA_VERSION ='';
  5587. protected $charset;
  5588. protected $loader;
  5589. protected $debug;
  5590. protected $autoReload;
  5591. protected $cache;
  5592. protected $lexer;
  5593. protected $parser;
  5594. protected $compiler;
  5595. protected $baseTemplateClass;
  5596. protected $extensions;
  5597. protected $parsers;
  5598. protected $visitors;
  5599. protected $filters;
  5600. protected $tests;
  5601. protected $functions;
  5602. protected $globals;
  5603. protected $runtimeInitialized = false;
  5604. protected $extensionInitialized = false;
  5605. protected $loadedTemplates;
  5606. protected $strictVariables;
  5607. protected $unaryOperators;
  5608. protected $binaryOperators;
  5609. protected $templateClassPrefix ='__TwigTemplate_';
  5610. protected $functionCallbacks = array();
  5611. protected $filterCallbacks = array();
  5612. protected $staging;
  5613. private $originalCache;
  5614. private $bcWriteCacheFile = false;
  5615. private $bcGetCacheFilename = false;
  5616. private $lastModifiedExtension = 0;
  5617. private $extensionsByClass = array();
  5618. private $runtimeLoaders = array();
  5619. private $runtimes = array();
  5620. private $optionsHash;
  5621. private $loading = array();
  5622. public function __construct(Twig_LoaderInterface $loader = null, $options = array())
  5623. {
  5624. if (null !== $loader) {
  5625. $this->setLoader($loader);
  5626. } else {
  5627. @trigger_error('Not passing a Twig_LoaderInterface as the first constructor argument of Twig_Environment is deprecated since version 1.21.', E_USER_DEPRECATED);
  5628. }
  5629. $options = array_merge(array('debug'=> false,'charset'=>'UTF-8','base_template_class'=>'Twig_Template','strict_variables'=> false,'autoescape'=>'html','cache'=> false,'auto_reload'=> null,'optimizations'=> -1,
  5630. ), $options);
  5631. $this->debug = (bool) $options['debug'];
  5632. $this->charset = strtoupper($options['charset']);
  5633. $this->baseTemplateClass = $options['base_template_class'];
  5634. $this->autoReload = null === $options['auto_reload'] ? $this->debug : (bool) $options['auto_reload'];
  5635. $this->strictVariables = (bool) $options['strict_variables'];
  5636. $this->setCache($options['cache']);
  5637. $this->addExtension(new Twig_Extension_Core());
  5638. $this->addExtension(new Twig_Extension_Escaper($options['autoescape']));
  5639. $this->addExtension(new Twig_Extension_Optimizer($options['optimizations']));
  5640. $this->staging = new Twig_Extension_Staging();
  5641. if (is_string($this->originalCache)) {
  5642. $r = new ReflectionMethod($this,'writeCacheFile');
  5643. if (__CLASS__ !== $r->getDeclaringClass()->getName()) {
  5644. @trigger_error('The Twig_Environment::writeCacheFile method is deprecated since version 1.22 and will be removed in Twig 2.0.', E_USER_DEPRECATED);
  5645. $this->bcWriteCacheFile = true;
  5646. }
  5647. $r = new ReflectionMethod($this,'getCacheFilename');
  5648. if (__CLASS__ !== $r->getDeclaringClass()->getName()) {
  5649. @trigger_error('The Twig_Environment::getCacheFilename method is deprecated since version 1.22 and will be removed in Twig 2.0.', E_USER_DEPRECATED);
  5650. $this->bcGetCacheFilename = true;
  5651. }
  5652. }
  5653. }
  5654. public function getBaseTemplateClass()
  5655. {
  5656. return $this->baseTemplateClass;
  5657. }
  5658. public function setBaseTemplateClass($class)
  5659. {
  5660. $this->baseTemplateClass = $class;
  5661. $this->updateOptionsHash();
  5662. }
  5663. public function enableDebug()
  5664. {
  5665. $this->debug = true;
  5666. $this->updateOptionsHash();
  5667. }
  5668. public function disableDebug()
  5669. {
  5670. $this->debug = false;
  5671. $this->updateOptionsHash();
  5672. }
  5673. public function isDebug()
  5674. {
  5675. return $this->debug;
  5676. }
  5677. public function enableAutoReload()
  5678. {
  5679. $this->autoReload = true;
  5680. }
  5681. public function disableAutoReload()
  5682. {
  5683. $this->autoReload = false;
  5684. }
  5685. public function isAutoReload()
  5686. {
  5687. return $this->autoReload;
  5688. }
  5689. public function enableStrictVariables()
  5690. {
  5691. $this->strictVariables = true;
  5692. $this->updateOptionsHash();
  5693. }
  5694. public function disableStrictVariables()
  5695. {
  5696. $this->strictVariables = false;
  5697. $this->updateOptionsHash();
  5698. }
  5699. public function isStrictVariables()
  5700. {
  5701. return $this->strictVariables;
  5702. }
  5703. public function getCache($original = true)
  5704. {
  5705. return $original ? $this->originalCache : $this->cache;
  5706. }
  5707. public function setCache($cache)
  5708. {
  5709. if (is_string($cache)) {
  5710. $this->originalCache = $cache;
  5711. $this->cache = new Twig_Cache_Filesystem($cache);
  5712. } elseif (false === $cache) {
  5713. $this->originalCache = $cache;
  5714. $this->cache = new Twig_Cache_Null();
  5715. } elseif (null === $cache) {
  5716. @trigger_error('Using "null" as the cache strategy is deprecated since version 1.23 and will be removed in Twig 2.0.', E_USER_DEPRECATED);
  5717. $this->originalCache = false;
  5718. $this->cache = new Twig_Cache_Null();
  5719. } elseif ($cache instanceof Twig_CacheInterface) {
  5720. $this->originalCache = $this->cache = $cache;
  5721. } else {
  5722. throw new LogicException(sprintf('Cache can only be a string, false, or a Twig_CacheInterface implementation.'));
  5723. }
  5724. }
  5725. public function getCacheFilename($name)
  5726. {
  5727. @trigger_error(sprintf('The %s method is deprecated since version 1.22 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);
  5728. $key = $this->cache->generateKey($name, $this->getTemplateClass($name));
  5729. return !$key ? false : $key;
  5730. }
  5731. public function getTemplateClass($name, $index = null)
  5732. {
  5733. $key = $this->getLoader()->getCacheKey($name).$this->optionsHash;
  5734. return $this->templateClassPrefix.hash('sha256', $key).(null === $index ?'':'_'.$index);
  5735. }
  5736. public function getTemplateClassPrefix()
  5737. {
  5738. @trigger_error(sprintf('The %s method is deprecated since version 1.22 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);
  5739. return $this->templateClassPrefix;
  5740. }
  5741. public function render($name, array $context = array())
  5742. {
  5743. return $this->loadTemplate($name)->render($context);
  5744. }
  5745. public function display($name, array $context = array())
  5746. {
  5747. $this->loadTemplate($name)->display($context);
  5748. }
  5749. public function load($name)
  5750. {
  5751. if ($name instanceof Twig_TemplateWrapper) {
  5752. return $name;
  5753. }
  5754. if ($name instanceof Twig_Template) {
  5755. return new Twig_TemplateWrapper($this, $name);
  5756. }
  5757. return new Twig_TemplateWrapper($this, $this->loadTemplate($name));
  5758. }
  5759. public function loadTemplate($name, $index = null)
  5760. {
  5761. $cls = $mainCls = $this->getTemplateClass($name);
  5762. if (null !== $index) {
  5763. $cls .='_'.$index;
  5764. }
  5765. if (isset($this->loadedTemplates[$cls])) {
  5766. return $this->loadedTemplates[$cls];
  5767. }
  5768. if (!class_exists($cls, false)) {
  5769. if ($this->bcGetCacheFilename) {
  5770. $key = $this->getCacheFilename($name);
  5771. } else {
  5772. $key = $this->cache->generateKey($name, $mainCls);
  5773. }
  5774. if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) {
  5775. $this->cache->load($key);
  5776. }
  5777. if (!class_exists($cls, false)) {
  5778. $loader = $this->getLoader();
  5779. if (!$loader instanceof Twig_SourceContextLoaderInterface) {
  5780. $source = new Twig_Source($loader->getSource($name), $name);
  5781. } else {
  5782. $source = $loader->getSourceContext($name);
  5783. }
  5784. $content = $this->compileSource($source);
  5785. if ($this->bcWriteCacheFile) {
  5786. $this->writeCacheFile($key, $content);
  5787. } else {
  5788. $this->cache->write($key, $content);
  5789. $this->cache->load($key);
  5790. }
  5791. if (!class_exists($mainCls, false)) {
  5792. eval('?>'.$content);
  5793. }
  5794. }
  5795. if (!class_exists($cls, false)) {
  5796. throw new Twig_Error_Runtime(sprintf('Failed to load Twig template "%s", index "%s": cache is corrupted.', $name, $index), -1, $source);
  5797. }
  5798. }
  5799. if (!$this->runtimeInitialized) {
  5800. $this->initRuntime();
  5801. }
  5802. if (isset($this->loading[$cls])) {
  5803. throw new Twig_Error_Runtime(sprintf('Circular reference detected for Twig template "%s", path: %s.', $name, implode(' -> ', array_merge($this->loading, array($name)))));
  5804. }
  5805. $this->loading[$cls] = $name;
  5806. try {
  5807. $this->loadedTemplates[$cls] = new $cls($this);
  5808. unset($this->loading[$cls]);
  5809. } catch (\Exception $e) {
  5810. unset($this->loading[$cls]);
  5811. throw $e;
  5812. }
  5813. return $this->loadedTemplates[$cls];
  5814. }
  5815. public function createTemplate($template)
  5816. {
  5817. $name = sprintf('__string_template__%s', hash('sha256', $template, false));
  5818. $loader = new Twig_Loader_Chain(array(
  5819. new Twig_Loader_Array(array($name => $template)),
  5820. $current = $this->getLoader(),
  5821. ));
  5822. $this->setLoader($loader);
  5823. try {
  5824. $template = $this->loadTemplate($name);
  5825. } catch (Exception $e) {
  5826. $this->setLoader($current);
  5827. throw $e;
  5828. } catch (Throwable $e) {
  5829. $this->setLoader($current);
  5830. throw $e;
  5831. }
  5832. $this->setLoader($current);
  5833. return $template;
  5834. }
  5835. public function isTemplateFresh($name, $time)
  5836. {
  5837. if (0 === $this->lastModifiedExtension) {
  5838. foreach ($this->extensions as $extension) {
  5839. $r = new ReflectionObject($extension);
  5840. if (file_exists($r->getFileName()) && ($extensionTime = filemtime($r->getFileName())) > $this->lastModifiedExtension) {
  5841. $this->lastModifiedExtension = $extensionTime;
  5842. }
  5843. }
  5844. }
  5845. return $this->lastModifiedExtension <= $time && $this->getLoader()->isFresh($name, $time);
  5846. }
  5847. public function resolveTemplate($names)
  5848. {
  5849. if (!is_array($names)) {
  5850. $names = array($names);
  5851. }
  5852. foreach ($names as $name) {
  5853. if ($name instanceof Twig_Template) {
  5854. return $name;
  5855. }
  5856. if ($name instanceof Twig_TemplateWrapper) {
  5857. return $name;
  5858. }
  5859. try {
  5860. return $this->loadTemplate($name);
  5861. } catch (Twig_Error_Loader $e) {
  5862. }
  5863. }
  5864. if (1 === count($names)) {
  5865. throw $e;
  5866. }
  5867. throw new Twig_Error_Loader(sprintf('Unable to find one of the following templates: "%s".', implode('", "', $names)));
  5868. }
  5869. public function clearTemplateCache()
  5870. {
  5871. @trigger_error(sprintf('The %s method is deprecated since version 1.18.3 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);
  5872. $this->loadedTemplates = array();
  5873. }
  5874. public function clearCacheFiles()
  5875. {
  5876. @trigger_error(sprintf('The %s method is deprecated since version 1.22 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);
  5877. if (is_string($this->originalCache)) {
  5878. foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->originalCache), RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
  5879. if ($file->isFile()) {
  5880. @unlink($file->getPathname());
  5881. }
  5882. }
  5883. }
  5884. }
  5885. public function getLexer()
  5886. {
  5887. @trigger_error(sprintf('The %s() method is deprecated since version 1.25 and will be removed in 2.0.', __FUNCTION__), E_USER_DEPRECATED);
  5888. if (null === $this->lexer) {
  5889. $this->lexer = new Twig_Lexer($this);
  5890. }
  5891. return $this->lexer;
  5892. }
  5893. public function setLexer(Twig_LexerInterface $lexer)
  5894. {
  5895. $this->lexer = $lexer;
  5896. }
  5897. public function tokenize($source, $name = null)
  5898. {
  5899. if (!$source instanceof Twig_Source) {
  5900. @trigger_error(sprintf('Passing a string as the $source argument of %s() is deprecated since version 1.27. Pass a Twig_Source instance instead.', __METHOD__), E_USER_DEPRECATED);
  5901. $source = new Twig_Source($source, $name);
  5902. }
  5903. if (null === $this->lexer) {
  5904. $this->lexer = new Twig_Lexer($this);
  5905. }
  5906. return $this->lexer->tokenize($source);
  5907. }
  5908. public function getParser()
  5909. {
  5910. @trigger_error(sprintf('The %s() method is deprecated since version 1.25 and will be removed in 2.0.', __FUNCTION__), E_USER_DEPRECATED);
  5911. if (null === $this->parser) {
  5912. $this->parser = new Twig_Parser($this);
  5913. }
  5914. return $this->parser;
  5915. }
  5916. public function setParser(Twig_ParserInterface $parser)
  5917. {
  5918. $this->parser = $parser;
  5919. }
  5920. public function parse(Twig_TokenStream $stream)
  5921. {
  5922. if (null === $this->parser) {
  5923. $this->parser = new Twig_Parser($this);
  5924. }
  5925. return $this->parser->parse($stream);
  5926. }
  5927. public function getCompiler()
  5928. {
  5929. @trigger_error(sprintf('The %s() method is deprecated since version 1.25 and will be removed in 2.0.', __FUNCTION__), E_USER_DEPRECATED);
  5930. if (null === $this->compiler) {
  5931. $this->compiler = new Twig_Compiler($this);
  5932. }
  5933. return $this->compiler;
  5934. }
  5935. public function setCompiler(Twig_CompilerInterface $compiler)
  5936. {
  5937. $this->compiler = $compiler;
  5938. }
  5939. public function compile(Twig_NodeInterface $node)
  5940. {
  5941. if (null === $this->compiler) {
  5942. $this->compiler = new Twig_Compiler($this);
  5943. }
  5944. return $this->compiler->compile($node)->getSource();
  5945. }
  5946. public function compileSource($source, $name = null)
  5947. {
  5948. if (!$source instanceof Twig_Source) {
  5949. @trigger_error(sprintf('Passing a string as the $source argument of %s() is deprecated since version 1.27. Pass a Twig_Source instance instead.', __METHOD__), E_USER_DEPRECATED);
  5950. $source = new Twig_Source($source, $name);
  5951. }
  5952. try {
  5953. return $this->compile($this->parse($this->tokenize($source)));
  5954. } catch (Twig_Error $e) {
  5955. $e->setSourceContext($source);
  5956. throw $e;
  5957. } catch (Exception $e) {
  5958. throw new Twig_Error_Syntax(sprintf('An exception has been thrown during the compilation of a template ("%s").', $e->getMessage()), -1, $source, $e);
  5959. }
  5960. }
  5961. public function setLoader(Twig_LoaderInterface $loader)
  5962. {
  5963. if (!$loader instanceof Twig_SourceContextLoaderInterface && 0 !== strpos(get_class($loader),'Mock_')) {
  5964. @trigger_error(sprintf('Twig loader "%s" should implement Twig_SourceContextLoaderInterface since version 1.27.', get_class($loader)), E_USER_DEPRECATED);
  5965. }
  5966. $this->loader = $loader;
  5967. }
  5968. public function getLoader()
  5969. {
  5970. if (null === $this->loader) {
  5971. throw new LogicException('You must set a loader first.');
  5972. }
  5973. return $this->loader;
  5974. }
  5975. public function setCharset($charset)
  5976. {
  5977. $this->charset = strtoupper($charset);
  5978. }
  5979. public function getCharset()
  5980. {
  5981. return $this->charset;
  5982. }
  5983. public function initRuntime()
  5984. {
  5985. $this->runtimeInitialized = true;
  5986. foreach ($this->getExtensions() as $name => $extension) {
  5987. if (!$extension instanceof Twig_Extension_InitRuntimeInterface) {
  5988. $m = new ReflectionMethod($extension,'initRuntime');
  5989. if ('Twig_Extension'!== $m->getDeclaringClass()->getName()) {
  5990. @trigger_error(sprintf('Defining the initRuntime() method in the "%s" extension is deprecated since version 1.23. Use the `needs_environment` option to get the Twig_Environment instance in filters, functions, or tests; or explicitly implement Twig_Extension_InitRuntimeInterface if needed (not recommended).', $name), E_USER_DEPRECATED);
  5991. }
  5992. }
  5993. $extension->initRuntime($this);
  5994. }
  5995. }
  5996. public function hasExtension($class)
  5997. {
  5998. $class = ltrim($class,'\\');
  5999. if (!isset($this->extensionsByClass[$class]) && class_exists($class, false)) {
  6000. $class = new ReflectionClass($class);
  6001. $class = $class->name;
  6002. }
  6003. if (isset($this->extensions[$class])) {
  6004. if ($class !== get_class($this->extensions[$class])) {
  6005. @trigger_error(sprintf('Referencing the "%s" extension by its name (defined by getName()) is deprecated since 1.26 and will be removed in Twig 2.0. Use the Fully Qualified Extension Class Name instead.', $class), E_USER_DEPRECATED);
  6006. }
  6007. return true;
  6008. }
  6009. return isset($this->extensionsByClass[$class]);
  6010. }
  6011. public function addRuntimeLoader(Twig_RuntimeLoaderInterface $loader)
  6012. {
  6013. $this->runtimeLoaders[] = $loader;
  6014. }
  6015. public function getExtension($class)
  6016. {
  6017. $class = ltrim($class,'\\');
  6018. if (!isset($this->extensionsByClass[$class]) && class_exists($class, false)) {
  6019. $class = new ReflectionClass($class);
  6020. $class = $class->name;
  6021. }
  6022. if (isset($this->extensions[$class])) {
  6023. if ($class !== get_class($this->extensions[$class])) {
  6024. @trigger_error(sprintf('Referencing the "%s" extension by its name (defined by getName()) is deprecated since 1.26 and will be removed in Twig 2.0. Use the Fully Qualified Extension Class Name instead.', $class), E_USER_DEPRECATED);
  6025. }
  6026. return $this->extensions[$class];
  6027. }
  6028. if (!isset($this->extensionsByClass[$class])) {
  6029. throw new Twig_Error_Runtime(sprintf('The "%s" extension is not enabled.', $class));
  6030. }
  6031. return $this->extensionsByClass[$class];
  6032. }
  6033. public function getRuntime($class)
  6034. {
  6035. if (isset($this->runtimes[$class])) {
  6036. return $this->runtimes[$class];
  6037. }
  6038. foreach ($this->runtimeLoaders as $loader) {
  6039. if (null !== $runtime = $loader->load($class)) {
  6040. return $this->runtimes[$class] = $runtime;
  6041. }
  6042. }
  6043. throw new Twig_Error_Runtime(sprintf('Unable to load the "%s" runtime.', $class));
  6044. }
  6045. public function addExtension(Twig_ExtensionInterface $extension)
  6046. {
  6047. if ($this->extensionInitialized) {
  6048. throw new LogicException(sprintf('Unable to register extension "%s" as extensions have already been initialized.', $extension->getName()));
  6049. }
  6050. $class = get_class($extension);
  6051. if ($class !== $extension->getName()) {
  6052. if (isset($this->extensions[$extension->getName()])) {
  6053. unset($this->extensions[$extension->getName()], $this->extensionsByClass[$class]);
  6054. @trigger_error(sprintf('The possibility to register the same extension twice ("%s") is deprecated since version 1.23 and will be removed in Twig 2.0. Use proper PHP inheritance instead.', $extension->getName()), E_USER_DEPRECATED);
  6055. }
  6056. }
  6057. $this->lastModifiedExtension = 0;
  6058. $this->extensionsByClass[$class] = $extension;
  6059. $this->extensions[$extension->getName()] = $extension;
  6060. $this->updateOptionsHash();
  6061. }
  6062. public function removeExtension($name)
  6063. {
  6064. @trigger_error(sprintf('The %s method is deprecated since version 1.12 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);
  6065. if ($this->extensionInitialized) {
  6066. throw new LogicException(sprintf('Unable to remove extension "%s" as extensions have already been initialized.', $name));
  6067. }
  6068. $class = ltrim($name,'\\');
  6069. if (!isset($this->extensionsByClass[$class]) && class_exists($class, false)) {
  6070. $class = new ReflectionClass($class);
  6071. $class = $class->name;
  6072. }
  6073. if (isset($this->extensions[$class])) {
  6074. if ($class !== get_class($this->extensions[$class])) {
  6075. @trigger_error(sprintf('Referencing the "%s" extension by its name (defined by getName()) is deprecated since 1.26 and will be removed in Twig 2.0. Use the Fully Qualified Extension Class Name instead.', $class), E_USER_DEPRECATED);
  6076. }
  6077. unset($this->extensions[$class]);
  6078. }
  6079. unset($this->extensions[$class]);
  6080. $this->updateOptionsHash();
  6081. }
  6082. public function setExtensions(array $extensions)
  6083. {
  6084. foreach ($extensions as $extension) {
  6085. $this->addExtension($extension);
  6086. }
  6087. }
  6088. public function getExtensions()
  6089. {
  6090. return $this->extensions;
  6091. }
  6092. public function addTokenParser(Twig_TokenParserInterface $parser)
  6093. {
  6094. if ($this->extensionInitialized) {
  6095. throw new LogicException('Unable to add a token parser as extensions have already been initialized.');
  6096. }
  6097. $this->staging->addTokenParser($parser);
  6098. }
  6099. public function getTokenParsers()
  6100. {
  6101. if (!$this->extensionInitialized) {
  6102. $this->initExtensions();
  6103. }
  6104. return $this->parsers;
  6105. }
  6106. public function getTags()
  6107. {
  6108. $tags = array();
  6109. foreach ($this->getTokenParsers()->getParsers() as $parser) {
  6110. if ($parser instanceof Twig_TokenParserInterface) {
  6111. $tags[$parser->getTag()] = $parser;
  6112. }
  6113. }
  6114. return $tags;
  6115. }
  6116. public function addNodeVisitor(Twig_NodeVisitorInterface $visitor)
  6117. {
  6118. if ($this->extensionInitialized) {
  6119. throw new LogicException('Unable to add a node visitor as extensions have already been initialized.');
  6120. }
  6121. $this->staging->addNodeVisitor($visitor);
  6122. }
  6123. public function getNodeVisitors()
  6124. {
  6125. if (!$this->extensionInitialized) {
  6126. $this->initExtensions();
  6127. }
  6128. return $this->visitors;
  6129. }
  6130. public function addFilter($name, $filter = null)
  6131. {
  6132. if (!$name instanceof Twig_SimpleFilter && !($filter instanceof Twig_SimpleFilter || $filter instanceof Twig_FilterInterface)) {
  6133. throw new LogicException('A filter must be an instance of Twig_FilterInterface or Twig_SimpleFilter.');
  6134. }
  6135. if ($name instanceof Twig_SimpleFilter) {
  6136. $filter = $name;
  6137. $name = $filter->getName();
  6138. } else {
  6139. @trigger_error(sprintf('Passing a name as a first argument to the %s method is deprecated since version 1.21. Pass an instance of "Twig_SimpleFilter" instead when defining filter "%s".', __METHOD__, $name), E_USER_DEPRECATED);
  6140. }
  6141. if ($this->extensionInitialized) {
  6142. throw new LogicException(sprintf('Unable to add filter "%s" as extensions have already been initialized.', $name));
  6143. }
  6144. $this->staging->addFilter($name, $filter);
  6145. }
  6146. public function getFilter($name)
  6147. {
  6148. if (!$this->extensionInitialized) {
  6149. $this->initExtensions();
  6150. }
  6151. if (isset($this->filters[$name])) {
  6152. return $this->filters[$name];
  6153. }
  6154. foreach ($this->filters as $pattern => $filter) {
  6155. $pattern = str_replace('\\*','(.*?)', preg_quote($pattern,'#'), $count);
  6156. if ($count) {
  6157. if (preg_match('#^'.$pattern.'$#', $name, $matches)) {
  6158. array_shift($matches);
  6159. $filter->setArguments($matches);
  6160. return $filter;
  6161. }
  6162. }
  6163. }
  6164. foreach ($this->filterCallbacks as $callback) {
  6165. if (false !== $filter = call_user_func($callback, $name)) {
  6166. return $filter;
  6167. }
  6168. }
  6169. return false;
  6170. }
  6171. public function registerUndefinedFilterCallback($callable)
  6172. {
  6173. $this->filterCallbacks[] = $callable;
  6174. }
  6175. public function getFilters()
  6176. {
  6177. if (!$this->extensionInitialized) {
  6178. $this->initExtensions();
  6179. }
  6180. return $this->filters;
  6181. }
  6182. public function addTest($name, $test = null)
  6183. {
  6184. if (!$name instanceof Twig_SimpleTest && !($test instanceof Twig_SimpleTest || $test instanceof Twig_TestInterface)) {
  6185. throw new LogicException('A test must be an instance of Twig_TestInterface or Twig_SimpleTest.');
  6186. }
  6187. if ($name instanceof Twig_SimpleTest) {
  6188. $test = $name;
  6189. $name = $test->getName();
  6190. } else {
  6191. @trigger_error(sprintf('Passing a name as a first argument to the %s method is deprecated since version 1.21. Pass an instance of "Twig_SimpleTest" instead when defining test "%s".', __METHOD__, $name), E_USER_DEPRECATED);
  6192. }
  6193. if ($this->extensionInitialized) {
  6194. throw new LogicException(sprintf('Unable to add test "%s" as extensions have already been initialized.', $name));
  6195. }
  6196. $this->staging->addTest($name, $test);
  6197. }
  6198. public function getTests()
  6199. {
  6200. if (!$this->extensionInitialized) {
  6201. $this->initExtensions();
  6202. }
  6203. return $this->tests;
  6204. }
  6205. public function getTest($name)
  6206. {
  6207. if (!$this->extensionInitialized) {
  6208. $this->initExtensions();
  6209. }
  6210. if (isset($this->tests[$name])) {
  6211. return $this->tests[$name];
  6212. }
  6213. return false;
  6214. }
  6215. public function addFunction($name, $function = null)
  6216. {
  6217. if (!$name instanceof Twig_SimpleFunction && !($function instanceof Twig_SimpleFunction || $function instanceof Twig_FunctionInterface)) {
  6218. throw new LogicException('A function must be an instance of Twig_FunctionInterface or Twig_SimpleFunction.');
  6219. }
  6220. if ($name instanceof Twig_SimpleFunction) {
  6221. $function = $name;
  6222. $name = $function->getName();
  6223. } else {
  6224. @trigger_error(sprintf('Passing a name as a first argument to the %s method is deprecated since version 1.21. Pass an instance of "Twig_SimpleFunction" instead when defining function "%s".', __METHOD__, $name), E_USER_DEPRECATED);
  6225. }
  6226. if ($this->extensionInitialized) {
  6227. throw new LogicException(sprintf('Unable to add function "%s" as extensions have already been initialized.', $name));
  6228. }
  6229. $this->staging->addFunction($name, $function);
  6230. }
  6231. public function getFunction($name)
  6232. {
  6233. if (!$this->extensionInitialized) {
  6234. $this->initExtensions();
  6235. }
  6236. if (isset($this->functions[$name])) {
  6237. return $this->functions[$name];
  6238. }
  6239. foreach ($this->functions as $pattern => $function) {
  6240. $pattern = str_replace('\\*','(.*?)', preg_quote($pattern,'#'), $count);
  6241. if ($count) {
  6242. if (preg_match('#^'.$pattern.'$#', $name, $matches)) {
  6243. array_shift($matches);
  6244. $function->setArguments($matches);
  6245. return $function;
  6246. }
  6247. }
  6248. }
  6249. foreach ($this->functionCallbacks as $callback) {
  6250. if (false !== $function = call_user_func($callback, $name)) {
  6251. return $function;
  6252. }
  6253. }
  6254. return false;
  6255. }
  6256. public function registerUndefinedFunctionCallback($callable)
  6257. {
  6258. $this->functionCallbacks[] = $callable;
  6259. }
  6260. public function getFunctions()
  6261. {
  6262. if (!$this->extensionInitialized) {
  6263. $this->initExtensions();
  6264. }
  6265. return $this->functions;
  6266. }
  6267. public function addGlobal($name, $value)
  6268. {
  6269. if ($this->extensionInitialized || $this->runtimeInitialized) {
  6270. if (null === $this->globals) {
  6271. $this->globals = $this->initGlobals();
  6272. }
  6273. if (!array_key_exists($name, $this->globals)) {
  6274. @trigger_error(sprintf('Registering global variable "%s" at runtime or when the extensions have already been initialized is deprecated since version 1.21.', $name), E_USER_DEPRECATED);
  6275. }
  6276. }
  6277. if ($this->extensionInitialized || $this->runtimeInitialized) {
  6278. $this->globals[$name] = $value;
  6279. } else {
  6280. $this->staging->addGlobal($name, $value);
  6281. }
  6282. }
  6283. public function getGlobals()
  6284. {
  6285. if (!$this->runtimeInitialized && !$this->extensionInitialized) {
  6286. return $this->initGlobals();
  6287. }
  6288. if (null === $this->globals) {
  6289. $this->globals = $this->initGlobals();
  6290. }
  6291. return $this->globals;
  6292. }
  6293. public function mergeGlobals(array $context)
  6294. {
  6295. foreach ($this->getGlobals() as $key => $value) {
  6296. if (!array_key_exists($key, $context)) {
  6297. $context[$key] = $value;
  6298. }
  6299. }
  6300. return $context;
  6301. }
  6302. public function getUnaryOperators()
  6303. {
  6304. if (!$this->extensionInitialized) {
  6305. $this->initExtensions();
  6306. }
  6307. return $this->unaryOperators;
  6308. }
  6309. public function getBinaryOperators()
  6310. {
  6311. if (!$this->extensionInitialized) {
  6312. $this->initExtensions();
  6313. }
  6314. return $this->binaryOperators;
  6315. }
  6316. public function computeAlternatives($name, $items)
  6317. {
  6318. @trigger_error(sprintf('The %s method is deprecated since version 1.23 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);
  6319. return Twig_Error_Syntax::computeAlternatives($name, $items);
  6320. }
  6321. protected function initGlobals()
  6322. {
  6323. $globals = array();
  6324. foreach ($this->extensions as $name => $extension) {
  6325. if (!$extension instanceof Twig_Extension_GlobalsInterface) {
  6326. $m = new ReflectionMethod($extension,'getGlobals');
  6327. if ('Twig_Extension'!== $m->getDeclaringClass()->getName()) {
  6328. @trigger_error(sprintf('Defining the getGlobals() method in the "%s" extension without explicitly implementing Twig_Extension_GlobalsInterface is deprecated since version 1.23.', $name), E_USER_DEPRECATED);
  6329. }
  6330. }
  6331. $extGlob = $extension->getGlobals();
  6332. if (!is_array($extGlob)) {
  6333. throw new UnexpectedValueException(sprintf('"%s::getGlobals()" must return an array of globals.', get_class($extension)));
  6334. }
  6335. $globals[] = $extGlob;
  6336. }
  6337. $globals[] = $this->staging->getGlobals();
  6338. return call_user_func_array('array_merge', $globals);
  6339. }
  6340. protected function initExtensions()
  6341. {
  6342. if ($this->extensionInitialized) {
  6343. return;
  6344. }
  6345. $this->parsers = new Twig_TokenParserBroker(array(), array(), false);
  6346. $this->filters = array();
  6347. $this->functions = array();
  6348. $this->tests = array();
  6349. $this->visitors = array();
  6350. $this->unaryOperators = array();
  6351. $this->binaryOperators = array();
  6352. foreach ($this->extensions as $extension) {
  6353. $this->initExtension($extension);
  6354. }
  6355. $this->initExtension($this->staging);
  6356. $this->extensionInitialized = true;
  6357. }
  6358. protected function initExtension(Twig_ExtensionInterface $extension)
  6359. {
  6360. foreach ($extension->getFilters() as $name => $filter) {
  6361. if ($filter instanceof Twig_SimpleFilter) {
  6362. $name = $filter->getName();
  6363. } else {
  6364. @trigger_error(sprintf('Using an instance of "%s" for filter "%s" is deprecated since version 1.21. Use Twig_SimpleFilter instead.', get_class($filter), $name), E_USER_DEPRECATED);
  6365. }
  6366. $this->filters[$name] = $filter;
  6367. }
  6368. foreach ($extension->getFunctions() as $name => $function) {
  6369. if ($function instanceof Twig_SimpleFunction) {
  6370. $name = $function->getName();
  6371. } else {
  6372. @trigger_error(sprintf('Using an instance of "%s" for function "%s" is deprecated since version 1.21. Use Twig_SimpleFunction instead.', get_class($function), $name), E_USER_DEPRECATED);
  6373. }
  6374. $this->functions[$name] = $function;
  6375. }
  6376. foreach ($extension->getTests() as $name => $test) {
  6377. if ($test instanceof Twig_SimpleTest) {
  6378. $name = $test->getName();
  6379. } else {
  6380. @trigger_error(sprintf('Using an instance of "%s" for test "%s" is deprecated since version 1.21. Use Twig_SimpleTest instead.', get_class($test), $name), E_USER_DEPRECATED);
  6381. }
  6382. $this->tests[$name] = $test;
  6383. }
  6384. foreach ($extension->getTokenParsers() as $parser) {
  6385. if ($parser instanceof Twig_TokenParserInterface) {
  6386. $this->parsers->addTokenParser($parser);
  6387. } elseif ($parser instanceof Twig_TokenParserBrokerInterface) {
  6388. @trigger_error('Registering a Twig_TokenParserBrokerInterface instance is deprecated since version 1.21.', E_USER_DEPRECATED);
  6389. $this->parsers->addTokenParserBroker($parser);
  6390. } else {
  6391. throw new LogicException('getTokenParsers() must return an array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances.');
  6392. }
  6393. }
  6394. foreach ($extension->getNodeVisitors() as $visitor) {
  6395. $this->visitors[] = $visitor;
  6396. }
  6397. if ($operators = $extension->getOperators()) {
  6398. if (!is_array($operators)) {
  6399. throw new InvalidArgumentException(sprintf('"%s::getOperators()" must return an array with operators, got "%s".', get_class($extension), is_object($operators) ? get_class($operators) : gettype($operators).(is_resource($operators) ?'':'#'.$operators)));
  6400. }
  6401. if (2 !== count($operators)) {
  6402. throw new InvalidArgumentException(sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', get_class($extension), count($operators)));
  6403. }
  6404. $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
  6405. $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
  6406. }
  6407. }
  6408. protected function writeCacheFile($file, $content)
  6409. {
  6410. $this->cache->write($file, $content);
  6411. }
  6412. private function updateOptionsHash()
  6413. {
  6414. $hashParts = array_merge(
  6415. array_keys($this->extensions),
  6416. array(
  6417. (int) function_exists('twig_template_get_attributes'),
  6418. PHP_MAJOR_VERSION,
  6419. PHP_MINOR_VERSION,
  6420. self::VERSION,
  6421. (int) $this->debug,
  6422. $this->baseTemplateClass,
  6423. (int) $this->strictVariables,
  6424. )
  6425. );
  6426. $this->optionsHash = implode(':', $hashParts);
  6427. }
  6428. }
  6429. class_alias('Twig_Environment','Twig\Environment', false);
  6430. }
  6431. namespace
  6432. {
  6433. interface Twig_ExtensionInterface
  6434. {
  6435. public function initRuntime(Twig_Environment $environment);
  6436. public function getTokenParsers();
  6437. public function getNodeVisitors();
  6438. public function getFilters();
  6439. public function getTests();
  6440. public function getFunctions();
  6441. public function getOperators();
  6442. public function getGlobals();
  6443. public function getName();
  6444. }
  6445. class_alias('Twig_ExtensionInterface','Twig\Extension\ExtensionInterface', false);
  6446. class_exists('Twig_Environment');
  6447. }
  6448. namespace
  6449. {
  6450. abstract class Twig_Extension implements Twig_ExtensionInterface
  6451. {
  6452. public function initRuntime(Twig_Environment $environment)
  6453. {
  6454. }
  6455. public function getTokenParsers()
  6456. {
  6457. return array();
  6458. }
  6459. public function getNodeVisitors()
  6460. {
  6461. return array();
  6462. }
  6463. public function getFilters()
  6464. {
  6465. return array();
  6466. }
  6467. public function getTests()
  6468. {
  6469. return array();
  6470. }
  6471. public function getFunctions()
  6472. {
  6473. return array();
  6474. }
  6475. public function getOperators()
  6476. {
  6477. return array();
  6478. }
  6479. public function getGlobals()
  6480. {
  6481. return array();
  6482. }
  6483. public function getName()
  6484. {
  6485. return get_class($this);
  6486. }
  6487. }
  6488. class_alias('Twig_Extension','Twig\Extension\AbstractExtension', false);
  6489. class_exists('Twig_Environment');
  6490. }
  6491. namespace
  6492. {
  6493. if (!defined('ENT_SUBSTITUTE')) {
  6494. define('ENT_SUBSTITUTE', 8);
  6495. }
  6496. class Twig_Extension_Core extends Twig_Extension
  6497. {
  6498. protected $dateFormats = array('F j, Y H:i','%d days');
  6499. protected $numberFormat = array(0,'.',',');
  6500. protected $timezone = null;
  6501. protected $escapers = array();
  6502. public function setEscaper($strategy, $callable)
  6503. {
  6504. $this->escapers[$strategy] = $callable;
  6505. }
  6506. public function getEscapers()
  6507. {
  6508. return $this->escapers;
  6509. }
  6510. public function setDateFormat($format = null, $dateIntervalFormat = null)
  6511. {
  6512. if (null !== $format) {
  6513. $this->dateFormats[0] = $format;
  6514. }
  6515. if (null !== $dateIntervalFormat) {
  6516. $this->dateFormats[1] = $dateIntervalFormat;
  6517. }
  6518. }
  6519. public function getDateFormat()
  6520. {
  6521. return $this->dateFormats;
  6522. }
  6523. public function setTimezone($timezone)
  6524. {
  6525. $this->timezone = $timezone instanceof DateTimeZone ? $timezone : new DateTimeZone($timezone);
  6526. }
  6527. public function getTimezone()
  6528. {
  6529. if (null === $this->timezone) {
  6530. $this->timezone = new DateTimeZone(date_default_timezone_get());
  6531. }
  6532. return $this->timezone;
  6533. }
  6534. public function setNumberFormat($decimal, $decimalPoint, $thousandSep)
  6535. {
  6536. $this->numberFormat = array($decimal, $decimalPoint, $thousandSep);
  6537. }
  6538. public function getNumberFormat()
  6539. {
  6540. return $this->numberFormat;
  6541. }
  6542. public function getTokenParsers()
  6543. {
  6544. return array(
  6545. new Twig_TokenParser_For(),
  6546. new Twig_TokenParser_If(),
  6547. new Twig_TokenParser_Extends(),
  6548. new Twig_TokenParser_Include(),
  6549. new Twig_TokenParser_Block(),
  6550. new Twig_TokenParser_Use(),
  6551. new Twig_TokenParser_Filter(),
  6552. new Twig_TokenParser_Macro(),
  6553. new Twig_TokenParser_Import(),
  6554. new Twig_TokenParser_From(),
  6555. new Twig_TokenParser_Set(),
  6556. new Twig_TokenParser_Spaceless(),
  6557. new Twig_TokenParser_Flush(),
  6558. new Twig_TokenParser_Do(),
  6559. new Twig_TokenParser_Embed(),
  6560. new Twig_TokenParser_With(),
  6561. );
  6562. }
  6563. public function getFilters()
  6564. {
  6565. $filters = array(
  6566. new Twig_SimpleFilter('date','twig_date_format_filter', array('needs_environment'=> true)),
  6567. new Twig_SimpleFilter('date_modify','twig_date_modify_filter', array('needs_environment'=> true)),
  6568. new Twig_SimpleFilter('format','sprintf'),
  6569. new Twig_SimpleFilter('replace','twig_replace_filter'),
  6570. new Twig_SimpleFilter('number_format','twig_number_format_filter', array('needs_environment'=> true)),
  6571. new Twig_SimpleFilter('abs','abs'),
  6572. new Twig_SimpleFilter('round','twig_round'),
  6573. new Twig_SimpleFilter('url_encode','twig_urlencode_filter'),
  6574. new Twig_SimpleFilter('json_encode','twig_jsonencode_filter'),
  6575. new Twig_SimpleFilter('convert_encoding','twig_convert_encoding'),
  6576. new Twig_SimpleFilter('title','twig_title_string_filter', array('needs_environment'=> true)),
  6577. new Twig_SimpleFilter('capitalize','twig_capitalize_string_filter', array('needs_environment'=> true)),
  6578. new Twig_SimpleFilter('upper','strtoupper'),
  6579. new Twig_SimpleFilter('lower','strtolower'),
  6580. new Twig_SimpleFilter('striptags','strip_tags'),
  6581. new Twig_SimpleFilter('trim','twig_trim_filter'),
  6582. new Twig_SimpleFilter('nl2br','nl2br', array('pre_escape'=>'html','is_safe'=> array('html'))),
  6583. new Twig_SimpleFilter('join','twig_join_filter'),
  6584. new Twig_SimpleFilter('split','twig_split_filter', array('needs_environment'=> true)),
  6585. new Twig_SimpleFilter('sort','twig_sort_filter'),
  6586. new Twig_SimpleFilter('merge','twig_array_merge'),
  6587. new Twig_SimpleFilter('batch','twig_array_batch'),
  6588. new Twig_SimpleFilter('reverse','twig_reverse_filter', array('needs_environment'=> true)),
  6589. new Twig_SimpleFilter('length','twig_length_filter', array('needs_environment'=> true)),
  6590. new Twig_SimpleFilter('slice','twig_slice', array('needs_environment'=> true)),
  6591. new Twig_SimpleFilter('first','twig_first', array('needs_environment'=> true)),
  6592. new Twig_SimpleFilter('last','twig_last', array('needs_environment'=> true)),
  6593. new Twig_SimpleFilter('default','_twig_default_filter', array('node_class'=>'Twig_Node_Expression_Filter_Default')),
  6594. new Twig_SimpleFilter('keys','twig_get_array_keys_filter'),
  6595. new Twig_SimpleFilter('escape','twig_escape_filter', array('needs_environment'=> true,'is_safe_callback'=>'twig_escape_filter_is_safe')),
  6596. new Twig_SimpleFilter('e','twig_escape_filter', array('needs_environment'=> true,'is_safe_callback'=>'twig_escape_filter_is_safe')),
  6597. );
  6598. if (function_exists('mb_get_info')) {
  6599. $filters[] = new Twig_SimpleFilter('upper','twig_upper_filter', array('needs_environment'=> true));
  6600. $filters[] = new Twig_SimpleFilter('lower','twig_lower_filter', array('needs_environment'=> true));
  6601. }
  6602. return $filters;
  6603. }
  6604. public function getFunctions()
  6605. {
  6606. return array(
  6607. new Twig_SimpleFunction('max','max'),
  6608. new Twig_SimpleFunction('min','min'),
  6609. new Twig_SimpleFunction('range','range'),
  6610. new Twig_SimpleFunction('constant','twig_constant'),
  6611. new Twig_SimpleFunction('cycle','twig_cycle'),
  6612. new Twig_SimpleFunction('random','twig_random', array('needs_environment'=> true)),
  6613. new Twig_SimpleFunction('date','twig_date_converter', array('needs_environment'=> true)),
  6614. new Twig_SimpleFunction('include','twig_include', array('needs_environment'=> true,'needs_context'=> true,'is_safe'=> array('all'))),
  6615. new Twig_SimpleFunction('source','twig_source', array('needs_environment'=> true,'is_safe'=> array('all'))),
  6616. );
  6617. }
  6618. public function getTests()
  6619. {
  6620. return array(
  6621. new Twig_SimpleTest('even', null, array('node_class'=>'Twig_Node_Expression_Test_Even')),
  6622. new Twig_SimpleTest('odd', null, array('node_class'=>'Twig_Node_Expression_Test_Odd')),
  6623. new Twig_SimpleTest('defined', null, array('node_class'=>'Twig_Node_Expression_Test_Defined')),
  6624. new Twig_SimpleTest('sameas', null, array('node_class'=>'Twig_Node_Expression_Test_Sameas','deprecated'=>'1.21','alternative'=>'same as')),
  6625. new Twig_SimpleTest('same as', null, array('node_class'=>'Twig_Node_Expression_Test_Sameas')),
  6626. new Twig_SimpleTest('none', null, array('node_class'=>'Twig_Node_Expression_Test_Null')),
  6627. new Twig_SimpleTest('null', null, array('node_class'=>'Twig_Node_Expression_Test_Null')),
  6628. new Twig_SimpleTest('divisibleby', null, array('node_class'=>'Twig_Node_Expression_Test_Divisibleby','deprecated'=>'1.21','alternative'=>'divisible by')),
  6629. new Twig_SimpleTest('divisible by', null, array('node_class'=>'Twig_Node_Expression_Test_Divisibleby')),
  6630. new Twig_SimpleTest('constant', null, array('node_class'=>'Twig_Node_Expression_Test_Constant')),
  6631. new Twig_SimpleTest('empty','twig_test_empty'),
  6632. new Twig_SimpleTest('iterable','twig_test_iterable'),
  6633. );
  6634. }
  6635. public function getOperators()
  6636. {
  6637. return array(
  6638. array('not'=> array('precedence'=> 50,'class'=>'Twig_Node_Expression_Unary_Not'),'-'=> array('precedence'=> 500,'class'=>'Twig_Node_Expression_Unary_Neg'),'+'=> array('precedence'=> 500,'class'=>'Twig_Node_Expression_Unary_Pos'),
  6639. ),
  6640. array('or'=> array('precedence'=> 10,'class'=>'Twig_Node_Expression_Binary_Or','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'and'=> array('precedence'=> 15,'class'=>'Twig_Node_Expression_Binary_And','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'b-or'=> array('precedence'=> 16,'class'=>'Twig_Node_Expression_Binary_BitwiseOr','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'b-xor'=> array('precedence'=> 17,'class'=>'Twig_Node_Expression_Binary_BitwiseXor','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'b-and'=> array('precedence'=> 18,'class'=>'Twig_Node_Expression_Binary_BitwiseAnd','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'=='=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_Equal','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'!='=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_NotEqual','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'<'=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_Less','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'>'=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_Greater','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'>='=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_GreaterEqual','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'<='=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_LessEqual','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'not in'=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_NotIn','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'in'=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_In','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'matches'=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_Matches','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'starts with'=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_StartsWith','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'ends with'=> array('precedence'=> 20,'class'=>'Twig_Node_Expression_Binary_EndsWith','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'..'=> array('precedence'=> 25,'class'=>'Twig_Node_Expression_Binary_Range','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'+'=> array('precedence'=> 30,'class'=>'Twig_Node_Expression_Binary_Add','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'-'=> array('precedence'=> 30,'class'=>'Twig_Node_Expression_Binary_Sub','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'~'=> array('precedence'=> 40,'class'=>'Twig_Node_Expression_Binary_Concat','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'*'=> array('precedence'=> 60,'class'=>'Twig_Node_Expression_Binary_Mul','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'/'=> array('precedence'=> 60,'class'=>'Twig_Node_Expression_Binary_Div','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'//'=> array('precedence'=> 60,'class'=>'Twig_Node_Expression_Binary_FloorDiv','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'%'=> array('precedence'=> 60,'class'=>'Twig_Node_Expression_Binary_Mod','associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'is'=> array('precedence'=> 100,'associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'is not'=> array('precedence'=> 100,'associativity'=> Twig_ExpressionParser::OPERATOR_LEFT),'**'=> array('precedence'=> 200,'class'=>'Twig_Node_Expression_Binary_Power','associativity'=> Twig_ExpressionParser::OPERATOR_RIGHT),'??'=> array('precedence'=> 300,'class'=>'Twig_Node_Expression_NullCoalesce','associativity'=> Twig_ExpressionParser::OPERATOR_RIGHT),
  6641. ),
  6642. );
  6643. }
  6644. public function getName()
  6645. {
  6646. return'core';
  6647. }
  6648. }
  6649. function twig_cycle($values, $position)
  6650. {
  6651. if (!is_array($values) && !$values instanceof ArrayAccess) {
  6652. return $values;
  6653. }
  6654. return $values[$position % count($values)];
  6655. }
  6656. function twig_random(Twig_Environment $env, $values = null)
  6657. {
  6658. if (null === $values) {
  6659. return mt_rand();
  6660. }
  6661. if (is_int($values) || is_float($values)) {
  6662. return $values < 0 ? mt_rand($values, 0) : mt_rand(0, $values);
  6663. }
  6664. if ($values instanceof Traversable) {
  6665. $values = iterator_to_array($values);
  6666. } elseif (is_string($values)) {
  6667. if (''=== $values) {
  6668. return'';
  6669. }
  6670. if (null !== $charset = $env->getCharset()) {
  6671. if ('UTF-8'!== $charset) {
  6672. $values = twig_convert_encoding($values,'UTF-8', $charset);
  6673. }
  6674. $values = preg_split('/(?<!^)(?!$)/u', $values);
  6675. if ('UTF-8'!== $charset) {
  6676. foreach ($values as $i => $value) {
  6677. $values[$i] = twig_convert_encoding($value, $charset,'UTF-8');
  6678. }
  6679. }
  6680. } else {
  6681. return $values[mt_rand(0, strlen($values) - 1)];
  6682. }
  6683. }
  6684. if (!is_array($values)) {
  6685. return $values;
  6686. }
  6687. if (0 === count($values)) {
  6688. throw new Twig_Error_Runtime('The random function cannot pick from an empty array.');
  6689. }
  6690. return $values[array_rand($values, 1)];
  6691. }
  6692. function twig_date_format_filter(Twig_Environment $env, $date, $format = null, $timezone = null)
  6693. {
  6694. if (null === $format) {
  6695. $formats = $env->getExtension('Twig_Extension_Core')->getDateFormat();
  6696. $format = $date instanceof DateInterval ? $formats[1] : $formats[0];
  6697. }
  6698. if ($date instanceof DateInterval) {
  6699. return $date->format($format);
  6700. }
  6701. return twig_date_converter($env, $date, $timezone)->format($format);
  6702. }
  6703. function twig_date_modify_filter(Twig_Environment $env, $date, $modifier)
  6704. {
  6705. $date = twig_date_converter($env, $date, false);
  6706. $resultDate = $date->modify($modifier);
  6707. return null === $resultDate ? $date : $resultDate;
  6708. }
  6709. function twig_date_converter(Twig_Environment $env, $date = null, $timezone = null)
  6710. {
  6711. if (false !== $timezone) {
  6712. if (null === $timezone) {
  6713. $timezone = $env->getExtension('Twig_Extension_Core')->getTimezone();
  6714. } elseif (!$timezone instanceof DateTimeZone) {
  6715. $timezone = new DateTimeZone($timezone);
  6716. }
  6717. }
  6718. if ($date instanceof DateTimeImmutable) {
  6719. return false !== $timezone ? $date->setTimezone($timezone) : $date;
  6720. }
  6721. if ($date instanceof DateTime || $date instanceof DateTimeInterface) {
  6722. $date = clone $date;
  6723. if (false !== $timezone) {
  6724. $date->setTimezone($timezone);
  6725. }
  6726. return $date;
  6727. }
  6728. if (null === $date ||'now'=== $date) {
  6729. return new DateTime($date, false !== $timezone ? $timezone : $env->getExtension('Twig_Extension_Core')->getTimezone());
  6730. }
  6731. $asString = (string) $date;
  6732. if (ctype_digit($asString) || (!empty($asString) &&'-'=== $asString[0] && ctype_digit(substr($asString, 1)))) {
  6733. $date = new DateTime('@'.$date);
  6734. } else {
  6735. $date = new DateTime($date, $env->getExtension('Twig_Extension_Core')->getTimezone());
  6736. }
  6737. if (false !== $timezone) {
  6738. $date->setTimezone($timezone);
  6739. }
  6740. return $date;
  6741. }
  6742. function twig_replace_filter($str, $from, $to = null)
  6743. {
  6744. if ($from instanceof Traversable) {
  6745. $from = iterator_to_array($from);
  6746. } elseif (is_string($from) && is_string($to)) {
  6747. @trigger_error('Using "replace" with character by character replacement is deprecated since version 1.22 and will be removed in Twig 2.0', E_USER_DEPRECATED);
  6748. return strtr($str, $from, $to);
  6749. } elseif (!is_array($from)) {
  6750. throw new Twig_Error_Runtime(sprintf('The "replace" filter expects an array or "Traversable" as replace values, got "%s".', is_object($from) ? get_class($from) : gettype($from)));
  6751. }
  6752. return strtr($str, $from);
  6753. }
  6754. function twig_round($value, $precision = 0, $method ='common')
  6755. {
  6756. if ('common'== $method) {
  6757. return round($value, $precision);
  6758. }
  6759. if ('ceil'!= $method &&'floor'!= $method) {
  6760. throw new Twig_Error_Runtime('The round filter only supports the "common", "ceil", and "floor" methods.');
  6761. }
  6762. return $method($value * pow(10, $precision)) / pow(10, $precision);
  6763. }
  6764. function twig_number_format_filter(Twig_Environment $env, $number, $decimal = null, $decimalPoint = null, $thousandSep = null)
  6765. {
  6766. $defaults = $env->getExtension('Twig_Extension_Core')->getNumberFormat();
  6767. if (null === $decimal) {
  6768. $decimal = $defaults[0];
  6769. }
  6770. if (null === $decimalPoint) {
  6771. $decimalPoint = $defaults[1];
  6772. }
  6773. if (null === $thousandSep) {
  6774. $thousandSep = $defaults[2];
  6775. }
  6776. return number_format((float) $number, $decimal, $decimalPoint, $thousandSep);
  6777. }
  6778. function twig_urlencode_filter($url)
  6779. {
  6780. if (is_array($url)) {
  6781. if (defined('PHP_QUERY_RFC3986')) {
  6782. return http_build_query($url,'','&', PHP_QUERY_RFC3986);
  6783. }
  6784. return http_build_query($url,'','&');
  6785. }
  6786. return rawurlencode($url);
  6787. }
  6788. if (PHP_VERSION_ID < 50300) {
  6789. function twig_jsonencode_filter($value, $options = 0)
  6790. {
  6791. if ($value instanceof Twig_Markup) {
  6792. $value = (string) $value;
  6793. } elseif (is_array($value)) {
  6794. array_walk_recursive($value,'_twig_markup2string');
  6795. }
  6796. return json_encode($value);
  6797. }
  6798. } else {
  6799. function twig_jsonencode_filter($value, $options = 0)
  6800. {
  6801. if ($value instanceof Twig_Markup) {
  6802. $value = (string) $value;
  6803. } elseif (is_array($value)) {
  6804. array_walk_recursive($value,'_twig_markup2string');
  6805. }
  6806. return json_encode($value, $options);
  6807. }
  6808. }
  6809. function _twig_markup2string(&$value)
  6810. {
  6811. if ($value instanceof Twig_Markup) {
  6812. $value = (string) $value;
  6813. }
  6814. }
  6815. function twig_array_merge($arr1, $arr2)
  6816. {
  6817. if ($arr1 instanceof Traversable) {
  6818. $arr1 = iterator_to_array($arr1);
  6819. } elseif (!is_array($arr1)) {
  6820. throw new Twig_Error_Runtime(sprintf('The merge filter only works with arrays or "Traversable", got "%s" as first argument.', gettype($arr1)));
  6821. }
  6822. if ($arr2 instanceof Traversable) {
  6823. $arr2 = iterator_to_array($arr2);
  6824. } elseif (!is_array($arr2)) {
  6825. throw new Twig_Error_Runtime(sprintf('The merge filter only works with arrays or "Traversable", got "%s" as second argument.', gettype($arr2)));
  6826. }
  6827. return array_merge($arr1, $arr2);
  6828. }
  6829. function twig_slice(Twig_Environment $env, $item, $start, $length = null, $preserveKeys = false)
  6830. {
  6831. if ($item instanceof Traversable) {
  6832. while ($item instanceof IteratorAggregate) {
  6833. $item = $item->getIterator();
  6834. }
  6835. if ($start >= 0 && $length >= 0 && $item instanceof Iterator) {
  6836. try {
  6837. return iterator_to_array(new LimitIterator($item, $start, null === $length ? -1 : $length), $preserveKeys);
  6838. } catch (OutOfBoundsException $exception) {
  6839. return array();
  6840. }
  6841. }
  6842. $item = iterator_to_array($item, $preserveKeys);
  6843. }
  6844. if (is_array($item)) {
  6845. return array_slice($item, $start, $length, $preserveKeys);
  6846. }
  6847. $item = (string) $item;
  6848. if (function_exists('mb_get_info') && null !== $charset = $env->getCharset()) {
  6849. return (string) mb_substr($item, $start, null === $length ? mb_strlen($item, $charset) - $start : $length, $charset);
  6850. }
  6851. return (string) (null === $length ? substr($item, $start) : substr($item, $start, $length));
  6852. }
  6853. function twig_first(Twig_Environment $env, $item)
  6854. {
  6855. $elements = twig_slice($env, $item, 0, 1, false);
  6856. return is_string($elements) ? $elements : current($elements);
  6857. }
  6858. function twig_last(Twig_Environment $env, $item)
  6859. {
  6860. $elements = twig_slice($env, $item, -1, 1, false);
  6861. return is_string($elements) ? $elements : current($elements);
  6862. }
  6863. function twig_join_filter($value, $glue ='')
  6864. {
  6865. if ($value instanceof Traversable) {
  6866. $value = iterator_to_array($value, false);
  6867. }
  6868. return implode($glue, (array) $value);
  6869. }
  6870. function twig_split_filter(Twig_Environment $env, $value, $delimiter, $limit = null)
  6871. {
  6872. if (!empty($delimiter)) {
  6873. return null === $limit ? explode($delimiter, $value) : explode($delimiter, $value, $limit);
  6874. }
  6875. if (!function_exists('mb_get_info') || null === $charset = $env->getCharset()) {
  6876. return str_split($value, null === $limit ? 1 : $limit);
  6877. }
  6878. if ($limit <= 1) {
  6879. return preg_split('/(?<!^)(?!$)/u', $value);
  6880. }
  6881. $length = mb_strlen($value, $charset);
  6882. if ($length < $limit) {
  6883. return array($value);
  6884. }
  6885. $r = array();
  6886. for ($i = 0; $i < $length; $i += $limit) {
  6887. $r[] = mb_substr($value, $i, $limit, $charset);
  6888. }
  6889. return $r;
  6890. }
  6891. function _twig_default_filter($value, $default ='')
  6892. {
  6893. if (twig_test_empty($value)) {
  6894. return $default;
  6895. }
  6896. return $value;
  6897. }
  6898. function twig_get_array_keys_filter($array)
  6899. {
  6900. if ($array instanceof Traversable) {
  6901. while ($array instanceof IteratorAggregate) {
  6902. $array = $array->getIterator();
  6903. }
  6904. if ($array instanceof Iterator) {
  6905. $keys = array();
  6906. $array->rewind();
  6907. while ($array->valid()) {
  6908. $keys[] = $array->key();
  6909. $array->next();
  6910. }
  6911. return $keys;
  6912. }
  6913. $keys = array();
  6914. foreach ($array as $key => $item) {
  6915. $keys[] = $key;
  6916. }
  6917. return $keys;
  6918. }
  6919. if (!is_array($array)) {
  6920. return array();
  6921. }
  6922. return array_keys($array);
  6923. }
  6924. function twig_reverse_filter(Twig_Environment $env, $item, $preserveKeys = false)
  6925. {
  6926. if ($item instanceof Traversable) {
  6927. return array_reverse(iterator_to_array($item), $preserveKeys);
  6928. }
  6929. if (is_array($item)) {
  6930. return array_reverse($item, $preserveKeys);
  6931. }
  6932. if (null !== $charset = $env->getCharset()) {
  6933. $string = (string) $item;
  6934. if ('UTF-8'!== $charset) {
  6935. $item = twig_convert_encoding($string,'UTF-8', $charset);
  6936. }
  6937. preg_match_all('/./us', $item, $matches);
  6938. $string = implode('', array_reverse($matches[0]));
  6939. if ('UTF-8'!== $charset) {
  6940. $string = twig_convert_encoding($string, $charset,'UTF-8');
  6941. }
  6942. return $string;
  6943. }
  6944. return strrev((string) $item);
  6945. }
  6946. function twig_sort_filter($array)
  6947. {
  6948. if ($array instanceof Traversable) {
  6949. $array = iterator_to_array($array);
  6950. } elseif (!is_array($array)) {
  6951. throw new Twig_Error_Runtime(sprintf('The sort filter only works with arrays or "Traversable", got "%s".', gettype($array)));
  6952. }
  6953. asort($array);
  6954. return $array;
  6955. }
  6956. function twig_in_filter($value, $compare)
  6957. {
  6958. if (is_array($compare)) {
  6959. return in_array($value, $compare, is_object($value) || is_resource($value));
  6960. } elseif (is_string($compare) && (is_string($value) || is_int($value) || is_float($value))) {
  6961. return''=== $value || false !== strpos($compare, (string) $value);
  6962. } elseif ($compare instanceof Traversable) {
  6963. if (is_object($value) || is_resource($value)) {
  6964. foreach ($compare as $item) {
  6965. if ($item === $value) {
  6966. return true;
  6967. }
  6968. }
  6969. } else {
  6970. foreach ($compare as $item) {
  6971. if ($item == $value) {
  6972. return true;
  6973. }
  6974. }
  6975. }
  6976. return false;
  6977. }
  6978. return false;
  6979. }
  6980. function twig_trim_filter($string, $characterMask = null, $side ='both')
  6981. {
  6982. if (null === $characterMask) {
  6983. $characterMask =" \t\n\r\0\x0B";
  6984. }
  6985. switch ($side) {
  6986. case'both':
  6987. return trim($string, $characterMask);
  6988. case'left':
  6989. return ltrim($string, $characterMask);
  6990. case'right':
  6991. return rtrim($string, $characterMask);
  6992. default:
  6993. throw new Twig_Error_Runtime('Trimming side must be "left", "right" or "both".');
  6994. }
  6995. }
  6996. function twig_escape_filter(Twig_Environment $env, $string, $strategy ='html', $charset = null, $autoescape = false)
  6997. {
  6998. if ($autoescape && $string instanceof Twig_Markup) {
  6999. return $string;
  7000. }
  7001. if (!is_string($string)) {
  7002. if (is_object($string) && method_exists($string,'__toString')) {
  7003. $string = (string) $string;
  7004. } elseif (in_array($strategy, array('html','js','css','html_attr','url'))) {
  7005. return $string;
  7006. }
  7007. }
  7008. if (null === $charset) {
  7009. $charset = $env->getCharset();
  7010. }
  7011. switch ($strategy) {
  7012. case'html':
  7013. static $htmlspecialcharsCharsets = array('ISO-8859-1'=> true,'ISO8859-1'=> true,'ISO-8859-15'=> true,'ISO8859-15'=> true,'utf-8'=> true,'UTF-8'=> true,'CP866'=> true,'IBM866'=> true,'866'=> true,'CP1251'=> true,'WINDOWS-1251'=> true,'WIN-1251'=> true,'1251'=> true,'CP1252'=> true,'WINDOWS-1252'=> true,'1252'=> true,'KOI8-R'=> true,'KOI8-RU'=> true,'KOI8R'=> true,'BIG5'=> true,'950'=> true,'GB2312'=> true,'936'=> true,'BIG5-HKSCS'=> true,'SHIFT_JIS'=> true,'SJIS'=> true,'932'=> true,'EUC-JP'=> true,'EUCJP'=> true,'ISO8859-5'=> true,'ISO-8859-5'=> true,'MACROMAN'=> true,
  7014. );
  7015. if (isset($htmlspecialcharsCharsets[$charset])) {
  7016. return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
  7017. }
  7018. if (isset($htmlspecialcharsCharsets[strtoupper($charset)])) {
  7019. $htmlspecialcharsCharsets[$charset] = true;
  7020. return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
  7021. }
  7022. $string = twig_convert_encoding($string,'UTF-8', $charset);
  7023. $string = htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE,'UTF-8');
  7024. return twig_convert_encoding($string, $charset,'UTF-8');
  7025. case'js':
  7026. if ('UTF-8'!== $charset) {
  7027. $string = twig_convert_encoding($string,'UTF-8', $charset);
  7028. }
  7029. if (0 == strlen($string) ? false : 1 !== preg_match('/^./su', $string)) {
  7030. throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
  7031. }
  7032. $string = preg_replace_callback('#[^a-zA-Z0-9,\._]#Su','_twig_escape_js_callback', $string);
  7033. if ('UTF-8'!== $charset) {
  7034. $string = twig_convert_encoding($string, $charset,'UTF-8');
  7035. }
  7036. return $string;
  7037. case'css':
  7038. if ('UTF-8'!== $charset) {
  7039. $string = twig_convert_encoding($string,'UTF-8', $charset);
  7040. }
  7041. if (0 == strlen($string) ? false : 1 !== preg_match('/^./su', $string)) {
  7042. throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
  7043. }
  7044. $string = preg_replace_callback('#[^a-zA-Z0-9]#Su','_twig_escape_css_callback', $string);
  7045. if ('UTF-8'!== $charset) {
  7046. $string = twig_convert_encoding($string, $charset,'UTF-8');
  7047. }
  7048. return $string;
  7049. case'html_attr':
  7050. if ('UTF-8'!== $charset) {
  7051. $string = twig_convert_encoding($string,'UTF-8', $charset);
  7052. }
  7053. if (0 == strlen($string) ? false : 1 !== preg_match('/^./su', $string)) {
  7054. throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
  7055. }
  7056. $string = preg_replace_callback('#[^a-zA-Z0-9,\.\-_]#Su','_twig_escape_html_attr_callback', $string);
  7057. if ('UTF-8'!== $charset) {
  7058. $string = twig_convert_encoding($string, $charset,'UTF-8');
  7059. }
  7060. return $string;
  7061. case'url':
  7062. if (PHP_VERSION_ID < 50300) {
  7063. return str_replace('%7E','~', rawurlencode($string));
  7064. }
  7065. return rawurlencode($string);
  7066. default:
  7067. static $escapers;
  7068. if (null === $escapers) {
  7069. $escapers = $env->getExtension('Twig_Extension_Core')->getEscapers();
  7070. }
  7071. if (isset($escapers[$strategy])) {
  7072. return call_user_func($escapers[$strategy], $env, $string, $charset);
  7073. }
  7074. $validStrategies = implode(', ', array_merge(array('html','js','url','css','html_attr'), array_keys($escapers)));
  7075. throw new Twig_Error_Runtime(sprintf('Invalid escaping strategy "%s" (valid ones: %s).', $strategy, $validStrategies));
  7076. }
  7077. }
  7078. function twig_escape_filter_is_safe(Twig_Node $filterArgs)
  7079. {
  7080. foreach ($filterArgs as $arg) {
  7081. if ($arg instanceof Twig_Node_Expression_Constant) {
  7082. return array($arg->getAttribute('value'));
  7083. }
  7084. return array();
  7085. }
  7086. return array('html');
  7087. }
  7088. if (function_exists('mb_convert_encoding')) {
  7089. function twig_convert_encoding($string, $to, $from)
  7090. {
  7091. return mb_convert_encoding($string, $to, $from);
  7092. }
  7093. } elseif (function_exists('iconv')) {
  7094. function twig_convert_encoding($string, $to, $from)
  7095. {
  7096. return iconv($from, $to, $string);
  7097. }
  7098. } else {
  7099. function twig_convert_encoding($string, $to, $from)
  7100. {
  7101. throw new Twig_Error_Runtime('No suitable convert encoding function (use UTF-8 as your encoding or install the iconv or mbstring extension).');
  7102. }
  7103. }
  7104. function _twig_escape_js_callback($matches)
  7105. {
  7106. $char = $matches[0];
  7107. static $shortMap = array('\\'=>'\\\\','/'=>'\\/',"\x08"=>'\b',"\x0C"=>'\f',"\x0A"=>'\n',"\x0D"=>'\r',"\x09"=>'\t',
  7108. );
  7109. if (isset($shortMap[$char])) {
  7110. return $shortMap[$char];
  7111. }
  7112. $char = twig_convert_encoding($char,'UTF-16BE','UTF-8');
  7113. $char = strtoupper(bin2hex($char));
  7114. if (4 >= strlen($char)) {
  7115. return sprintf('\u%04s', $char);
  7116. }
  7117. return sprintf('\u%04s\u%04s', substr($char, 0, -4), substr($char, -4));
  7118. }
  7119. function _twig_escape_css_callback($matches)
  7120. {
  7121. $char = $matches[0];
  7122. if (!isset($char[1])) {
  7123. $hex = ltrim(strtoupper(bin2hex($char)),'0');
  7124. if (0 === strlen($hex)) {
  7125. $hex ='0';
  7126. }
  7127. return'\\'.$hex.' ';
  7128. }
  7129. $char = twig_convert_encoding($char,'UTF-16BE','UTF-8');
  7130. return'\\'.ltrim(strtoupper(bin2hex($char)),'0').' ';
  7131. }
  7132. function _twig_escape_html_attr_callback($matches)
  7133. {
  7134. static $entityMap = array(
  7135. 34 =>'quot',
  7136. 38 =>'amp',
  7137. 60 =>'lt',
  7138. 62 =>'gt',
  7139. );
  7140. $chr = $matches[0];
  7141. $ord = ord($chr);
  7142. if (($ord <= 0x1f &&"\t"!= $chr &&"\n"!= $chr &&"\r"!= $chr) || ($ord >= 0x7f && $ord <= 0x9f)) {
  7143. return'&#xFFFD;';
  7144. }
  7145. if (1 == strlen($chr)) {
  7146. $hex = strtoupper(substr('00'.bin2hex($chr), -2));
  7147. } else {
  7148. $chr = twig_convert_encoding($chr,'UTF-16BE','UTF-8');
  7149. $hex = strtoupper(substr('0000'.bin2hex($chr), -4));
  7150. }
  7151. $int = hexdec($hex);
  7152. if (array_key_exists($int, $entityMap)) {
  7153. return sprintf('&%s;', $entityMap[$int]);
  7154. }
  7155. return sprintf('&#x%s;', $hex);
  7156. }
  7157. if (function_exists('mb_get_info')) {
  7158. function twig_length_filter(Twig_Environment $env, $thing)
  7159. {
  7160. if (null === $thing) {
  7161. return 0;
  7162. }
  7163. if (is_scalar($thing)) {
  7164. return mb_strlen($thing, $env->getCharset());
  7165. }
  7166. if ($thing instanceof \SimpleXMLElement) {
  7167. return count($thing);
  7168. }
  7169. if (is_object($thing) && method_exists($thing,'__toString') && !$thing instanceof \Countable) {
  7170. return mb_strlen((string) $thing, $env->getCharset());
  7171. }
  7172. if ($thing instanceof \Countable || is_array($thing)) {
  7173. return count($thing);
  7174. }
  7175. if ($thing instanceof \IteratorAggregate) {
  7176. return iterator_count($thing);
  7177. }
  7178. return 1;
  7179. }
  7180. function twig_upper_filter(Twig_Environment $env, $string)
  7181. {
  7182. if (null !== $charset = $env->getCharset()) {
  7183. return mb_strtoupper($string, $charset);
  7184. }
  7185. return strtoupper($string);
  7186. }
  7187. function twig_lower_filter(Twig_Environment $env, $string)
  7188. {
  7189. if (null !== $charset = $env->getCharset()) {
  7190. return mb_strtolower($string, $charset);
  7191. }
  7192. return strtolower($string);
  7193. }
  7194. function twig_title_string_filter(Twig_Environment $env, $string)
  7195. {
  7196. if (null !== $charset = $env->getCharset()) {
  7197. return mb_convert_case($string, MB_CASE_TITLE, $charset);
  7198. }
  7199. return ucwords(strtolower($string));
  7200. }
  7201. function twig_capitalize_string_filter(Twig_Environment $env, $string)
  7202. {
  7203. if (null !== $charset = $env->getCharset()) {
  7204. return mb_strtoupper(mb_substr($string, 0, 1, $charset), $charset).mb_strtolower(mb_substr($string, 1, mb_strlen($string, $charset), $charset), $charset);
  7205. }
  7206. return ucfirst(strtolower($string));
  7207. }
  7208. }
  7209. else {
  7210. function twig_length_filter(Twig_Environment $env, $thing)
  7211. {
  7212. if (null === $thing) {
  7213. return 0;
  7214. }
  7215. if (is_scalar($thing)) {
  7216. return strlen($thing);
  7217. }
  7218. if ($thing instanceof \SimpleXMLElement) {
  7219. return count($thing);
  7220. }
  7221. if (is_object($thing) && method_exists($thing,'__toString') && !$thing instanceof \Countable) {
  7222. return strlen((string) $thing);
  7223. }
  7224. if ($thing instanceof \Countable || is_array($thing)) {
  7225. return count($thing);
  7226. }
  7227. if ($thing instanceof \IteratorAggregate) {
  7228. return iterator_count($thing);
  7229. }
  7230. return 1;
  7231. }
  7232. function twig_title_string_filter(Twig_Environment $env, $string)
  7233. {
  7234. return ucwords(strtolower($string));
  7235. }
  7236. function twig_capitalize_string_filter(Twig_Environment $env, $string)
  7237. {
  7238. return ucfirst(strtolower($string));
  7239. }
  7240. }
  7241. function twig_ensure_traversable($seq)
  7242. {
  7243. if ($seq instanceof Traversable || is_array($seq)) {
  7244. return $seq;
  7245. }
  7246. return array();
  7247. }
  7248. function twig_test_empty($value)
  7249. {
  7250. if ($value instanceof Countable) {
  7251. return 0 == count($value);
  7252. }
  7253. if (is_object($value) && method_exists($value,'__toString')) {
  7254. return''=== (string) $value;
  7255. }
  7256. return''=== $value || false === $value || null === $value || array() === $value;
  7257. }
  7258. function twig_test_iterable($value)
  7259. {
  7260. return $value instanceof Traversable || is_array($value);
  7261. }
  7262. function twig_include(Twig_Environment $env, $context, $template, $variables = array(), $withContext = true, $ignoreMissing = false, $sandboxed = false)
  7263. {
  7264. $alreadySandboxed = false;
  7265. $sandbox = null;
  7266. if ($withContext) {
  7267. $variables = array_merge($context, $variables);
  7268. }
  7269. if ($isSandboxed = $sandboxed && $env->hasExtension('Twig_Extension_Sandbox')) {
  7270. $sandbox = $env->getExtension('Twig_Extension_Sandbox');
  7271. if (!$alreadySandboxed = $sandbox->isSandboxed()) {
  7272. $sandbox->enableSandbox();
  7273. }
  7274. }
  7275. $result = null;
  7276. try {
  7277. $result = $env->resolveTemplate($template)->render($variables);
  7278. } catch (Twig_Error_Loader $e) {
  7279. if (!$ignoreMissing) {
  7280. if ($isSandboxed && !$alreadySandboxed) {
  7281. $sandbox->disableSandbox();
  7282. }
  7283. throw $e;
  7284. }
  7285. } catch (Throwable $e) {
  7286. if ($isSandboxed && !$alreadySandboxed) {
  7287. $sandbox->disableSandbox();
  7288. }
  7289. throw $e;
  7290. } catch (Exception $e) {
  7291. if ($isSandboxed && !$alreadySandboxed) {
  7292. $sandbox->disableSandbox();
  7293. }
  7294. throw $e;
  7295. }
  7296. if ($isSandboxed && !$alreadySandboxed) {
  7297. $sandbox->disableSandbox();
  7298. }
  7299. return $result;
  7300. }
  7301. function twig_source(Twig_Environment $env, $name, $ignoreMissing = false)
  7302. {
  7303. $loader = $env->getLoader();
  7304. try {
  7305. if (!$loader instanceof Twig_SourceContextLoaderInterface) {
  7306. return $loader->getSource($name);
  7307. } else {
  7308. return $loader->getSourceContext($name)->getCode();
  7309. }
  7310. } catch (Twig_Error_Loader $e) {
  7311. if (!$ignoreMissing) {
  7312. throw $e;
  7313. }
  7314. }
  7315. }
  7316. function twig_constant($constant, $object = null)
  7317. {
  7318. if (null !== $object) {
  7319. $constant = get_class($object).'::'.$constant;
  7320. }
  7321. return constant($constant);
  7322. }
  7323. function twig_constant_is_defined($constant, $object = null)
  7324. {
  7325. if (null !== $object) {
  7326. $constant = get_class($object).'::'.$constant;
  7327. }
  7328. return defined($constant);
  7329. }
  7330. function twig_array_batch($items, $size, $fill = null)
  7331. {
  7332. if ($items instanceof Traversable) {
  7333. $items = iterator_to_array($items, false);
  7334. }
  7335. $size = ceil($size);
  7336. $result = array_chunk($items, $size, true);
  7337. if (null !== $fill && !empty($result)) {
  7338. $last = count($result) - 1;
  7339. if ($fillCount = $size - count($result[$last])) {
  7340. $result[$last] = array_merge(
  7341. $result[$last],
  7342. array_fill(0, $fillCount, $fill)
  7343. );
  7344. }
  7345. }
  7346. return $result;
  7347. }
  7348. class_alias('Twig_Extension_Core','Twig\Extension\CoreExtension', false);
  7349. }
  7350. namespace
  7351. {
  7352. class Twig_Extension_Escaper extends Twig_Extension
  7353. {
  7354. protected $defaultStrategy;
  7355. public function __construct($defaultStrategy ='html')
  7356. {
  7357. $this->setDefaultStrategy($defaultStrategy);
  7358. }
  7359. public function getTokenParsers()
  7360. {
  7361. return array(new Twig_TokenParser_AutoEscape());
  7362. }
  7363. public function getNodeVisitors()
  7364. {
  7365. return array(new Twig_NodeVisitor_Escaper());
  7366. }
  7367. public function getFilters()
  7368. {
  7369. return array(
  7370. new Twig_SimpleFilter('raw','twig_raw_filter', array('is_safe'=> array('all'))),
  7371. );
  7372. }
  7373. public function setDefaultStrategy($defaultStrategy)
  7374. {
  7375. if (true === $defaultStrategy) {
  7376. @trigger_error('Using "true" as the default strategy is deprecated since version 1.21. Use "html" instead.', E_USER_DEPRECATED);
  7377. $defaultStrategy ='html';
  7378. }
  7379. if ('filename'=== $defaultStrategy) {
  7380. @trigger_error('Using "filename" as the default strategy is deprecated since version 1.27. Use "name" instead.', E_USER_DEPRECATED);
  7381. $defaultStrategy ='name';
  7382. }
  7383. if ('name'=== $defaultStrategy) {
  7384. $defaultStrategy = array('Twig_FileExtensionEscapingStrategy','guess');
  7385. }
  7386. $this->defaultStrategy = $defaultStrategy;
  7387. }
  7388. public function getDefaultStrategy($name)
  7389. {
  7390. if (!is_string($this->defaultStrategy) && false !== $this->defaultStrategy) {
  7391. return call_user_func($this->defaultStrategy, $name);
  7392. }
  7393. return $this->defaultStrategy;
  7394. }
  7395. public function getName()
  7396. {
  7397. return'escaper';
  7398. }
  7399. }
  7400. function twig_raw_filter($string)
  7401. {
  7402. return $string;
  7403. }
  7404. class_alias('Twig_Extension_Escaper','Twig\Extension\EscaperExtension', false);
  7405. }
  7406. namespace
  7407. {
  7408. class Twig_Extension_Optimizer extends Twig_Extension
  7409. {
  7410. protected $optimizers;
  7411. public function __construct($optimizers = -1)
  7412. {
  7413. $this->optimizers = $optimizers;
  7414. }
  7415. public function getNodeVisitors()
  7416. {
  7417. return array(new Twig_NodeVisitor_Optimizer($this->optimizers));
  7418. }
  7419. public function getName()
  7420. {
  7421. return'optimizer';
  7422. }
  7423. }
  7424. class_alias('Twig_Extension_Optimizer','Twig\Extension\OptimizerExtension', false);
  7425. }
  7426. namespace
  7427. {
  7428. interface Twig_LoaderInterface
  7429. {
  7430. public function getSource($name);
  7431. public function getCacheKey($name);
  7432. public function isFresh($name, $time);
  7433. }
  7434. class_alias('Twig_LoaderInterface','Twig\Loader\LoaderInterface', false);
  7435. }
  7436. namespace
  7437. {
  7438. class Twig_Markup implements Countable
  7439. {
  7440. protected $content;
  7441. protected $charset;
  7442. public function __construct($content, $charset)
  7443. {
  7444. $this->content = (string) $content;
  7445. $this->charset = $charset;
  7446. }
  7447. public function __toString()
  7448. {
  7449. return $this->content;
  7450. }
  7451. public function count()
  7452. {
  7453. return function_exists('mb_get_info') ? mb_strlen($this->content, $this->charset) : strlen($this->content);
  7454. }
  7455. }
  7456. class_alias('Twig_Markup','Twig\Markup', false);
  7457. }
  7458. namespace
  7459. {
  7460. interface Twig_TemplateInterface
  7461. {
  7462. const ANY_CALL ='any';
  7463. const ARRAY_CALL ='array';
  7464. const METHOD_CALL ='method';
  7465. public function render(array $context);
  7466. public function display(array $context, array $blocks = array());
  7467. public function getEnvironment();
  7468. }
  7469. }
  7470. namespace
  7471. {
  7472. abstract class Twig_Template implements Twig_TemplateInterface
  7473. {
  7474. protected static $cache = array();
  7475. protected $parent;
  7476. protected $parents = array();
  7477. protected $env;
  7478. protected $blocks = array();
  7479. protected $traits = array();
  7480. public function __construct(Twig_Environment $env)
  7481. {
  7482. $this->env = $env;
  7483. }
  7484. public function __toString()
  7485. {
  7486. return $this->getTemplateName();
  7487. }
  7488. abstract public function getTemplateName();
  7489. public function getDebugInfo()
  7490. {
  7491. return array();
  7492. }
  7493. public function getSource()
  7494. {
  7495. @trigger_error('The '.__METHOD__.' method is deprecated since version 1.27 and will be removed in 2.0. Use getSourceContext() instead.', E_USER_DEPRECATED);
  7496. return'';
  7497. }
  7498. public function getSourceContext()
  7499. {
  7500. return new Twig_Source('', $this->getTemplateName());
  7501. }
  7502. public function getEnvironment()
  7503. {
  7504. @trigger_error('The '.__METHOD__.' method is deprecated since version 1.20 and will be removed in 2.0.', E_USER_DEPRECATED);
  7505. return $this->env;
  7506. }
  7507. public function getParent(array $context)
  7508. {
  7509. if (null !== $this->parent) {
  7510. return $this->parent;
  7511. }
  7512. try {
  7513. $parent = $this->doGetParent($context);
  7514. if (false === $parent) {
  7515. return false;
  7516. }
  7517. if ($parent instanceof self) {
  7518. return $this->parents[$parent->getTemplateName()] = $parent;
  7519. }
  7520. if (!isset($this->parents[$parent])) {
  7521. $this->parents[$parent] = $this->loadTemplate($parent);
  7522. }
  7523. } catch (Twig_Error_Loader $e) {
  7524. $e->setSourceContext(null);
  7525. $e->guess();
  7526. throw $e;
  7527. }
  7528. return $this->parents[$parent];
  7529. }
  7530. protected function doGetParent(array $context)
  7531. {
  7532. return false;
  7533. }
  7534. public function isTraitable()
  7535. {
  7536. return true;
  7537. }
  7538. public function displayParentBlock($name, array $context, array $blocks = array())
  7539. {
  7540. $name = (string) $name;
  7541. if (isset($this->traits[$name])) {
  7542. $this->traits[$name][0]->displayBlock($name, $context, $blocks, false);
  7543. } elseif (false !== $parent = $this->getParent($context)) {
  7544. $parent->displayBlock($name, $context, $blocks, false);
  7545. } else {
  7546. throw new Twig_Error_Runtime(sprintf('The template has no parent and no traits defining the "%s" block.', $name), -1, $this->getSourceContext());
  7547. }
  7548. }
  7549. public function displayBlock($name, array $context, array $blocks = array(), $useBlocks = true)
  7550. {
  7551. $name = (string) $name;
  7552. if ($useBlocks && isset($blocks[$name])) {
  7553. $template = $blocks[$name][0];
  7554. $block = $blocks[$name][1];
  7555. } elseif (isset($this->blocks[$name])) {
  7556. $template = $this->blocks[$name][0];
  7557. $block = $this->blocks[$name][1];
  7558. } else {
  7559. $template = null;
  7560. $block = null;
  7561. }
  7562. if (null !== $template && !$template instanceof self) {
  7563. throw new LogicException('A block must be a method on a Twig_Template instance.');
  7564. }
  7565. if (null !== $template) {
  7566. try {
  7567. $template->$block($context, $blocks);
  7568. } catch (Twig_Error $e) {
  7569. if (!$e->getSourceContext()) {
  7570. $e->setSourceContext($template->getSourceContext());
  7571. }
  7572. if (false === $e->getTemplateLine()) {
  7573. $e->setTemplateLine(-1);
  7574. $e->guess();
  7575. }
  7576. throw $e;
  7577. } catch (Exception $e) {
  7578. throw new Twig_Error_Runtime(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, $template->getSourceContext(), $e);
  7579. }
  7580. } elseif (false !== $parent = $this->getParent($context)) {
  7581. $parent->displayBlock($name, $context, array_merge($this->blocks, $blocks), false);
  7582. } else {
  7583. @trigger_error(sprintf('Silent display of undefined block "%s" in template "%s" is deprecated since version 1.29 and will throw an exception in 2.0. Use the "block(\'%s\') is defined" expression to test for block existence.', $name, $this->getTemplateName(), $name), E_USER_DEPRECATED);
  7584. }
  7585. }
  7586. public function renderParentBlock($name, array $context, array $blocks = array())
  7587. {
  7588. ob_start();
  7589. $this->displayParentBlock($name, $context, $blocks);
  7590. return ob_get_clean();
  7591. }
  7592. public function renderBlock($name, array $context, array $blocks = array(), $useBlocks = true)
  7593. {
  7594. ob_start();
  7595. $this->displayBlock($name, $context, $blocks, $useBlocks);
  7596. return ob_get_clean();
  7597. }
  7598. public function hasBlock($name, array $context = null, array $blocks = array())
  7599. {
  7600. if (null === $context) {
  7601. @trigger_error('The '.__METHOD__.' method is internal and should never be called; calling it directly is deprecated since version 1.28 and won\'t be possible anymore in 2.0.', E_USER_DEPRECATED);
  7602. return isset($this->blocks[(string) $name]);
  7603. }
  7604. if (isset($blocks[$name])) {
  7605. return $blocks[$name][0] instanceof self;
  7606. }
  7607. if (isset($this->blocks[$name])) {
  7608. return true;
  7609. }
  7610. if (false !== $parent = $this->getParent($context)) {
  7611. return $parent->hasBlock($name, $context);
  7612. }
  7613. return false;
  7614. }
  7615. public function getBlockNames(array $context = null, array $blocks = array())
  7616. {
  7617. if (null === $context) {
  7618. @trigger_error('The '.__METHOD__.' method is internal and should never be called; calling it directly is deprecated since version 1.28 and won\'t be possible anymore in 2.0.', E_USER_DEPRECATED);
  7619. return array_keys($this->blocks);
  7620. }
  7621. $names = array_merge(array_keys($blocks), array_keys($this->blocks));
  7622. if (false !== $parent = $this->getParent($context)) {
  7623. $names = array_merge($names, $parent->getBlockNames($context));
  7624. }
  7625. return array_unique($names);
  7626. }
  7627. protected function loadTemplate($template, $templateName = null, $line = null, $index = null)
  7628. {
  7629. try {
  7630. if (is_array($template)) {
  7631. return $this->env->resolveTemplate($template);
  7632. }
  7633. if ($template instanceof self) {
  7634. return $template;
  7635. }
  7636. if ($template instanceof Twig_TemplateWrapper) {
  7637. return $template;
  7638. }
  7639. return $this->env->loadTemplate($template, $index);
  7640. } catch (Twig_Error $e) {
  7641. if (!$e->getSourceContext()) {
  7642. $e->setSourceContext($templateName ? new Twig_Source('', $templateName) : $this->getSourceContext());
  7643. }
  7644. if ($e->getTemplateLine()) {
  7645. throw $e;
  7646. }
  7647. if (!$line) {
  7648. $e->guess();
  7649. } else {
  7650. $e->setTemplateLine($line);
  7651. }
  7652. throw $e;
  7653. }
  7654. }
  7655. public function getBlocks()
  7656. {
  7657. return $this->blocks;
  7658. }
  7659. public function display(array $context, array $blocks = array())
  7660. {
  7661. $this->displayWithErrorHandling($this->env->mergeGlobals($context), array_merge($this->blocks, $blocks));
  7662. }
  7663. public function render(array $context)
  7664. {
  7665. $level = ob_get_level();
  7666. ob_start();
  7667. try {
  7668. $this->display($context);
  7669. } catch (Exception $e) {
  7670. while (ob_get_level() > $level) {
  7671. ob_end_clean();
  7672. }
  7673. throw $e;
  7674. } catch (Throwable $e) {
  7675. while (ob_get_level() > $level) {
  7676. ob_end_clean();
  7677. }
  7678. throw $e;
  7679. }
  7680. return ob_get_clean();
  7681. }
  7682. protected function displayWithErrorHandling(array $context, array $blocks = array())
  7683. {
  7684. try {
  7685. $this->doDisplay($context, $blocks);
  7686. } catch (Twig_Error $e) {
  7687. if (!$e->getSourceContext()) {
  7688. $e->setSourceContext($this->getSourceContext());
  7689. }
  7690. if (false === $e->getTemplateLine()) {
  7691. $e->setTemplateLine(-1);
  7692. $e->guess();
  7693. }
  7694. throw $e;
  7695. } catch (Exception $e) {
  7696. throw new Twig_Error_Runtime(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, $this->getSourceContext(), $e);
  7697. }
  7698. }
  7699. abstract protected function doDisplay(array $context, array $blocks = array());
  7700. final protected function getContext($context, $item, $ignoreStrictCheck = false)
  7701. {
  7702. if (!array_key_exists($item, $context)) {
  7703. if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
  7704. return;
  7705. }
  7706. throw new Twig_Error_Runtime(sprintf('Variable "%s" does not exist.', $item), -1, $this->getSourceContext());
  7707. }
  7708. return $context[$item];
  7709. }
  7710. protected function getAttribute($object, $item, array $arguments = array(), $type = self::ANY_CALL, $isDefinedTest = false, $ignoreStrictCheck = false)
  7711. {
  7712. if (self::METHOD_CALL !== $type) {
  7713. $arrayItem = is_bool($item) || is_float($item) ? (int) $item : $item;
  7714. if ((is_array($object) && (isset($object[$arrayItem]) || array_key_exists($arrayItem, $object)))
  7715. || ($object instanceof ArrayAccess && isset($object[$arrayItem]))
  7716. ) {
  7717. if ($isDefinedTest) {
  7718. return true;
  7719. }
  7720. return $object[$arrayItem];
  7721. }
  7722. if (self::ARRAY_CALL === $type || !is_object($object)) {
  7723. if ($isDefinedTest) {
  7724. return false;
  7725. }
  7726. if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
  7727. return;
  7728. }
  7729. if ($object instanceof ArrayAccess) {
  7730. $message = sprintf('Key "%s" in object with ArrayAccess of class "%s" does not exist.', $arrayItem, get_class($object));
  7731. } elseif (is_object($object)) {
  7732. $message = sprintf('Impossible to access a key "%s" on an object of class "%s" that does not implement ArrayAccess interface.', $item, get_class($object));
  7733. } elseif (is_array($object)) {
  7734. if (empty($object)) {
  7735. $message = sprintf('Key "%s" does not exist as the array is empty.', $arrayItem);
  7736. } else {
  7737. $message = sprintf('Key "%s" for array with keys "%s" does not exist.', $arrayItem, implode(', ', array_keys($object)));
  7738. }
  7739. } elseif (self::ARRAY_CALL === $type) {
  7740. if (null === $object) {
  7741. $message = sprintf('Impossible to access a key ("%s") on a null variable.', $item);
  7742. } else {
  7743. $message = sprintf('Impossible to access a key ("%s") on a %s variable ("%s").', $item, gettype($object), $object);
  7744. }
  7745. } elseif (null === $object) {
  7746. $message = sprintf('Impossible to access an attribute ("%s") on a null variable.', $item);
  7747. } else {
  7748. $message = sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s").', $item, gettype($object), $object);
  7749. }
  7750. throw new Twig_Error_Runtime($message, -1, $this->getSourceContext());
  7751. }
  7752. }
  7753. if (!is_object($object)) {
  7754. if ($isDefinedTest) {
  7755. return false;
  7756. }
  7757. if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
  7758. return;
  7759. }
  7760. if (null === $object) {
  7761. $message = sprintf('Impossible to invoke a method ("%s") on a null variable.', $item);
  7762. } elseif (is_array($object)) {
  7763. $message = sprintf('Impossible to invoke a method ("%s") on an array.', $item);
  7764. } else {
  7765. $message = sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s").', $item, gettype($object), $object);
  7766. }
  7767. throw new Twig_Error_Runtime($message, -1, $this->getSourceContext());
  7768. }
  7769. if (self::METHOD_CALL !== $type && !$object instanceof self) { if (isset($object->$item) || array_key_exists((string) $item, $object)) {
  7770. if ($isDefinedTest) {
  7771. return true;
  7772. }
  7773. if ($this->env->hasExtension('Twig_Extension_Sandbox')) {
  7774. $this->env->getExtension('Twig_Extension_Sandbox')->checkPropertyAllowed($object, $item);
  7775. }
  7776. return $object->$item;
  7777. }
  7778. }
  7779. $class = get_class($object);
  7780. if (!isset(self::$cache[$class])) {
  7781. if ($object instanceof self) {
  7782. $ref = new ReflectionClass($class);
  7783. $methods = array();
  7784. foreach ($ref->getMethods(ReflectionMethod::IS_PUBLIC) as $refMethod) {
  7785. if ('getenvironment'!== strtolower($refMethod->name)) {
  7786. $methods[] = $refMethod->name;
  7787. }
  7788. }
  7789. } else {
  7790. $methods = get_class_methods($object);
  7791. }
  7792. sort($methods);
  7793. $cache = array();
  7794. foreach ($methods as $method) {
  7795. $cache[$method] = $method;
  7796. $cache[$lcName = strtolower($method)] = $method;
  7797. if ('g'=== $lcName[0] && 0 === strpos($lcName,'get')) {
  7798. $name = substr($method, 3);
  7799. $lcName = substr($lcName, 3);
  7800. } elseif ('i'=== $lcName[0] && 0 === strpos($lcName,'is')) {
  7801. $name = substr($method, 2);
  7802. $lcName = substr($lcName, 2);
  7803. } else {
  7804. continue;
  7805. }
  7806. if ($name) {
  7807. if (!isset($cache[$name])) {
  7808. $cache[$name] = $method;
  7809. }
  7810. if (!isset($cache[$lcName])) {
  7811. $cache[$lcName] = $method;
  7812. }
  7813. }
  7814. }
  7815. self::$cache[$class] = $cache;
  7816. }
  7817. $call = false;
  7818. if (isset(self::$cache[$class][$item])) {
  7819. $method = self::$cache[$class][$item];
  7820. } elseif (isset(self::$cache[$class][$lcItem = strtolower($item)])) {
  7821. $method = self::$cache[$class][$lcItem];
  7822. } elseif (isset(self::$cache[$class]['__call'])) {
  7823. $method = $item;
  7824. $call = true;
  7825. } else {
  7826. if ($isDefinedTest) {
  7827. return false;
  7828. }
  7829. if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
  7830. return;
  7831. }
  7832. throw new Twig_Error_Runtime(sprintf('Neither the property "%1$s" nor one of the methods "%1$s()", "get%1$s()"/"is%1$s()" or "__call()" exist and have public access in class "%2$s".', $item, $class), -1, $this->getSourceContext());
  7833. }
  7834. if ($isDefinedTest) {
  7835. return true;
  7836. }
  7837. if ($this->env->hasExtension('Twig_Extension_Sandbox')) {
  7838. $this->env->getExtension('Twig_Extension_Sandbox')->checkMethodAllowed($object, $method);
  7839. }
  7840. try {
  7841. if (!$arguments) {
  7842. $ret = $object->$method();
  7843. } else {
  7844. $ret = call_user_func_array(array($object, $method), $arguments);
  7845. }
  7846. } catch (BadMethodCallException $e) {
  7847. if ($call && ($ignoreStrictCheck || !$this->env->isStrictVariables())) {
  7848. return;
  7849. }
  7850. throw $e;
  7851. }
  7852. if ($object instanceof Twig_TemplateInterface) {
  7853. $self = $object->getTemplateName() === $this->getTemplateName();
  7854. $message = sprintf('Calling "%s" on template "%s" from template "%s" is deprecated since version 1.28 and won\'t be supported anymore in 2.0.', $item, $object->getTemplateName(), $this->getTemplateName());
  7855. if ('renderBlock'=== $method ||'displayBlock'=== $method) {
  7856. $message .= sprintf(' Use block("%s"%s) instead).', $arguments[0], $self ?'':', template');
  7857. } elseif ('hasBlock'=== $method) {
  7858. $message .= sprintf(' Use "block("%s"%s) is defined" instead).', $arguments[0], $self ?'':', template');
  7859. } elseif ('render'=== $method ||'display'=== $method) {
  7860. $message .= sprintf(' Use include("%s") instead).', $object->getTemplateName());
  7861. }
  7862. @trigger_error($message, E_USER_DEPRECATED);
  7863. return''=== $ret ?'': new Twig_Markup($ret, $this->env->getCharset());
  7864. }
  7865. return $ret;
  7866. }
  7867. }
  7868. class_alias('Twig_Template','Twig\Template', false);
  7869. }
  7870. namespace Monolog\Formatter
  7871. {
  7872. interface FormatterInterface
  7873. {
  7874. public function format(array $record);
  7875. public function formatBatch(array $records);
  7876. }
  7877. }
  7878. namespace Monolog\Formatter
  7879. {
  7880. use Exception;
  7881. use Monolog\Utils;
  7882. class NormalizerFormatter implements FormatterInterface
  7883. {
  7884. const SIMPLE_DATE ="Y-m-d H:i:s";
  7885. protected $dateFormat;
  7886. public function __construct($dateFormat = null)
  7887. {
  7888. $this->dateFormat = $dateFormat ?: static::SIMPLE_DATE;
  7889. if (!function_exists('json_encode')) {
  7890. throw new \RuntimeException('PHP\'s json extension is required to use Monolog\'s NormalizerFormatter');
  7891. }
  7892. }
  7893. public function format(array $record)
  7894. {
  7895. return $this->normalize($record);
  7896. }
  7897. public function formatBatch(array $records)
  7898. {
  7899. foreach ($records as $key => $record) {
  7900. $records[$key] = $this->format($record);
  7901. }
  7902. return $records;
  7903. }
  7904. protected function normalize($data, $depth = 0)
  7905. {
  7906. if ($depth > 9) {
  7907. return'Over 9 levels deep, aborting normalization';
  7908. }
  7909. if (null === $data || is_scalar($data)) {
  7910. if (is_float($data)) {
  7911. if (is_infinite($data)) {
  7912. return ($data > 0 ?'':'-') .'INF';
  7913. }
  7914. if (is_nan($data)) {
  7915. return'NaN';
  7916. }
  7917. }
  7918. return $data;
  7919. }
  7920. if (is_array($data)) {
  7921. $normalized = array();
  7922. $count = 1;
  7923. foreach ($data as $key => $value) {
  7924. if ($count++ > 1000) {
  7925. $normalized['...'] ='Over 1000 items ('.count($data).' total), aborting normalization';
  7926. break;
  7927. }
  7928. $normalized[$key] = $this->normalize($value, $depth+1);
  7929. }
  7930. return $normalized;
  7931. }
  7932. if ($data instanceof \DateTime) {
  7933. return $data->format($this->dateFormat);
  7934. }
  7935. if (is_object($data)) {
  7936. if ($data instanceof Exception || (PHP_VERSION_ID > 70000 && $data instanceof \Throwable)) {
  7937. return $this->normalizeException($data);
  7938. }
  7939. if (method_exists($data,'__toString') && !$data instanceof \JsonSerializable) {
  7940. $value = $data->__toString();
  7941. } else {
  7942. $value = $this->toJson($data, true);
  7943. }
  7944. return sprintf("[object] (%s: %s)", Utils::getClass($data), $value);
  7945. }
  7946. if (is_resource($data)) {
  7947. return sprintf('[resource] (%s)', get_resource_type($data));
  7948. }
  7949. return'[unknown('.gettype($data).')]';
  7950. }
  7951. protected function normalizeException($e)
  7952. {
  7953. if (!$e instanceof Exception && !$e instanceof \Throwable) {
  7954. throw new \InvalidArgumentException('Exception/Throwable expected, got '.gettype($e).' / '.Utils::getClass($e));
  7955. }
  7956. $data = array('class'=> Utils::getClass($e),'message'=> $e->getMessage(),'code'=> $e->getCode(),'file'=> $e->getFile().':'.$e->getLine(),
  7957. );
  7958. if ($e instanceof \SoapFault) {
  7959. if (isset($e->faultcode)) {
  7960. $data['faultcode'] = $e->faultcode;
  7961. }
  7962. if (isset($e->faultactor)) {
  7963. $data['faultactor'] = $e->faultactor;
  7964. }
  7965. if (isset($e->detail)) {
  7966. $data['detail'] = $e->detail;
  7967. }
  7968. }
  7969. $trace = $e->getTrace();
  7970. foreach ($trace as $frame) {
  7971. if (isset($frame['file'])) {
  7972. $data['trace'][] = $frame['file'].':'.$frame['line'];
  7973. } elseif (isset($frame['function']) && $frame['function'] ==='{closure}') {
  7974. $data['trace'][] = $frame['function'];
  7975. } else {
  7976. if (isset($frame['args'])) {
  7977. $frame['args'] = array_map(function ($arg) {
  7978. if (is_object($arg) && !($arg instanceof \DateTime || $arg instanceof \DateTimeInterface)) {
  7979. return sprintf("[object] (%s)", Utils::getClass($arg));
  7980. }
  7981. return $arg;
  7982. }, $frame['args']);
  7983. }
  7984. $data['trace'][] = $this->toJson($this->normalize($frame), true);
  7985. }
  7986. }
  7987. if ($previous = $e->getPrevious()) {
  7988. $data['previous'] = $this->normalizeException($previous);
  7989. }
  7990. return $data;
  7991. }
  7992. protected function toJson($data, $ignoreErrors = false)
  7993. {
  7994. if ($ignoreErrors) {
  7995. return @$this->jsonEncode($data);
  7996. }
  7997. $json = $this->jsonEncode($data);
  7998. if ($json === false) {
  7999. $json = $this->handleJsonError(json_last_error(), $data);
  8000. }
  8001. return $json;
  8002. }
  8003. private function jsonEncode($data)
  8004. {
  8005. if (version_compare(PHP_VERSION,'5.4.0','>=')) {
  8006. return json_encode($data, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
  8007. }
  8008. return json_encode($data);
  8009. }
  8010. private function handleJsonError($code, $data)
  8011. {
  8012. if ($code !== JSON_ERROR_UTF8) {
  8013. $this->throwEncodeError($code, $data);
  8014. }
  8015. if (is_string($data)) {
  8016. $this->detectAndCleanUtf8($data);
  8017. } elseif (is_array($data)) {
  8018. array_walk_recursive($data, array($this,'detectAndCleanUtf8'));
  8019. } else {
  8020. $this->throwEncodeError($code, $data);
  8021. }
  8022. $json = $this->jsonEncode($data);
  8023. if ($json === false) {
  8024. $this->throwEncodeError(json_last_error(), $data);
  8025. }
  8026. return $json;
  8027. }
  8028. private function throwEncodeError($code, $data)
  8029. {
  8030. switch ($code) {
  8031. case JSON_ERROR_DEPTH:
  8032. $msg ='Maximum stack depth exceeded';
  8033. break;
  8034. case JSON_ERROR_STATE_MISMATCH:
  8035. $msg ='Underflow or the modes mismatch';
  8036. break;
  8037. case JSON_ERROR_CTRL_CHAR:
  8038. $msg ='Unexpected control character found';
  8039. break;
  8040. case JSON_ERROR_UTF8:
  8041. $msg ='Malformed UTF-8 characters, possibly incorrectly encoded';
  8042. break;
  8043. default:
  8044. $msg ='Unknown error';
  8045. }
  8046. throw new \RuntimeException('JSON encoding failed: '.$msg.'. Encoding: '.var_export($data, true));
  8047. }
  8048. public function detectAndCleanUtf8(&$data)
  8049. {
  8050. if (is_string($data) && !preg_match('//u', $data)) {
  8051. $data = preg_replace_callback('/[\x80-\xFF]+/',
  8052. function ($m) { return utf8_encode($m[0]); },
  8053. $data
  8054. );
  8055. $data = str_replace(
  8056. array('¤','¦','¨','´','¸','¼','½','¾'),
  8057. array('€','Š','š','Ž','ž','Œ','œ','Ÿ'),
  8058. $data
  8059. );
  8060. }
  8061. }
  8062. }
  8063. }
  8064. namespace Monolog\Formatter
  8065. {
  8066. use Monolog\Utils;
  8067. class LineFormatter extends NormalizerFormatter
  8068. {
  8069. const SIMPLE_FORMAT ="[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n";
  8070. protected $format;
  8071. protected $allowInlineLineBreaks;
  8072. protected $ignoreEmptyContextAndExtra;
  8073. protected $includeStacktraces;
  8074. public function __construct($format = null, $dateFormat = null, $allowInlineLineBreaks = false, $ignoreEmptyContextAndExtra = false)
  8075. {
  8076. $this->format = $format ?: static::SIMPLE_FORMAT;
  8077. $this->allowInlineLineBreaks = $allowInlineLineBreaks;
  8078. $this->ignoreEmptyContextAndExtra = $ignoreEmptyContextAndExtra;
  8079. parent::__construct($dateFormat);
  8080. }
  8081. public function includeStacktraces($include = true)
  8082. {
  8083. $this->includeStacktraces = $include;
  8084. if ($this->includeStacktraces) {
  8085. $this->allowInlineLineBreaks = true;
  8086. }
  8087. }
  8088. public function allowInlineLineBreaks($allow = true)
  8089. {
  8090. $this->allowInlineLineBreaks = $allow;
  8091. }
  8092. public function ignoreEmptyContextAndExtra($ignore = true)
  8093. {
  8094. $this->ignoreEmptyContextAndExtra = $ignore;
  8095. }
  8096. public function format(array $record)
  8097. {
  8098. $vars = parent::format($record);
  8099. $output = $this->format;
  8100. foreach ($vars['extra'] as $var => $val) {
  8101. if (false !== strpos($output,'%extra.'.$var.'%')) {
  8102. $output = str_replace('%extra.'.$var.'%', $this->stringify($val), $output);
  8103. unset($vars['extra'][$var]);
  8104. }
  8105. }
  8106. foreach ($vars['context'] as $var => $val) {
  8107. if (false !== strpos($output,'%context.'.$var.'%')) {
  8108. $output = str_replace('%context.'.$var.'%', $this->stringify($val), $output);
  8109. unset($vars['context'][$var]);
  8110. }
  8111. }
  8112. if ($this->ignoreEmptyContextAndExtra) {
  8113. if (empty($vars['context'])) {
  8114. unset($vars['context']);
  8115. $output = str_replace('%context%','', $output);
  8116. }
  8117. if (empty($vars['extra'])) {
  8118. unset($vars['extra']);
  8119. $output = str_replace('%extra%','', $output);
  8120. }
  8121. }
  8122. foreach ($vars as $var => $val) {
  8123. if (false !== strpos($output,'%'.$var.'%')) {
  8124. $output = str_replace('%'.$var.'%', $this->stringify($val), $output);
  8125. }
  8126. }
  8127. if (false !== strpos($output,'%')) {
  8128. $output = preg_replace('/%(?:extra|context)\..+?%/','', $output);
  8129. }
  8130. return $output;
  8131. }
  8132. public function formatBatch(array $records)
  8133. {
  8134. $message ='';
  8135. foreach ($records as $record) {
  8136. $message .= $this->format($record);
  8137. }
  8138. return $message;
  8139. }
  8140. public function stringify($value)
  8141. {
  8142. return $this->replaceNewlines($this->convertToString($value));
  8143. }
  8144. protected function normalizeException($e)
  8145. {
  8146. if (!$e instanceof \Exception && !$e instanceof \Throwable) {
  8147. throw new \InvalidArgumentException('Exception/Throwable expected, got '.gettype($e).' / '.Utils::getClass($e));
  8148. }
  8149. $previousText ='';
  8150. if ($previous = $e->getPrevious()) {
  8151. do {
  8152. $previousText .=', '.Utils::getClass($previous).'(code: '.$previous->getCode().'): '.$previous->getMessage().' at '.$previous->getFile().':'.$previous->getLine();
  8153. } while ($previous = $previous->getPrevious());
  8154. }
  8155. $str ='[object] ('.Utils::getClass($e).'(code: '.$e->getCode().'): '.$e->getMessage().' at '.$e->getFile().':'.$e->getLine().$previousText.')';
  8156. if ($this->includeStacktraces) {
  8157. $str .="\n[stacktrace]\n".$e->getTraceAsString()."\n";
  8158. }
  8159. return $str;
  8160. }
  8161. protected function convertToString($data)
  8162. {
  8163. if (null === $data || is_bool($data)) {
  8164. return var_export($data, true);
  8165. }
  8166. if (is_scalar($data)) {
  8167. return (string) $data;
  8168. }
  8169. if (version_compare(PHP_VERSION,'5.4.0','>=')) {
  8170. return $this->toJson($data, true);
  8171. }
  8172. return str_replace('\\/','/', @json_encode($data));
  8173. }
  8174. protected function replaceNewlines($str)
  8175. {
  8176. if ($this->allowInlineLineBreaks) {
  8177. if (0 === strpos($str,'{')) {
  8178. return str_replace(array('\r','\n'), array("\r","\n"), $str);
  8179. }
  8180. return $str;
  8181. }
  8182. return str_replace(array("\r\n","\r","\n"),' ', $str);
  8183. }
  8184. }
  8185. }
  8186. namespace Monolog\Handler
  8187. {
  8188. use Monolog\Formatter\FormatterInterface;
  8189. interface HandlerInterface
  8190. {
  8191. public function isHandling(array $record);
  8192. public function handle(array $record);
  8193. public function handleBatch(array $records);
  8194. public function pushProcessor($callback);
  8195. public function popProcessor();
  8196. public function setFormatter(FormatterInterface $formatter);
  8197. public function getFormatter();
  8198. }
  8199. }
  8200. namespace Monolog
  8201. {
  8202. interface ResettableInterface
  8203. {
  8204. public function reset();
  8205. }
  8206. }
  8207. namespace Monolog\Handler
  8208. {
  8209. use Monolog\Formatter\FormatterInterface;
  8210. use Monolog\Formatter\LineFormatter;
  8211. use Monolog\Logger;
  8212. use Monolog\ResettableInterface;
  8213. abstract class AbstractHandler implements HandlerInterface, ResettableInterface
  8214. {
  8215. protected $level = Logger::DEBUG;
  8216. protected $bubble = true;
  8217. protected $formatter;
  8218. protected $processors = array();
  8219. public function __construct($level = Logger::DEBUG, $bubble = true)
  8220. {
  8221. $this->setLevel($level);
  8222. $this->bubble = $bubble;
  8223. }
  8224. public function isHandling(array $record)
  8225. {
  8226. return $record['level'] >= $this->level;
  8227. }
  8228. public function handleBatch(array $records)
  8229. {
  8230. foreach ($records as $record) {
  8231. $this->handle($record);
  8232. }
  8233. }
  8234. public function close()
  8235. {
  8236. }
  8237. public function pushProcessor($callback)
  8238. {
  8239. if (!is_callable($callback)) {
  8240. throw new \InvalidArgumentException('Processors must be valid callables (callback or object with an __invoke method), '.var_export($callback, true).' given');
  8241. }
  8242. array_unshift($this->processors, $callback);
  8243. return $this;
  8244. }
  8245. public function popProcessor()
  8246. {
  8247. if (!$this->processors) {
  8248. throw new \LogicException('You tried to pop from an empty processor stack.');
  8249. }
  8250. return array_shift($this->processors);
  8251. }
  8252. public function setFormatter(FormatterInterface $formatter)
  8253. {
  8254. $this->formatter = $formatter;
  8255. return $this;
  8256. }
  8257. public function getFormatter()
  8258. {
  8259. if (!$this->formatter) {
  8260. $this->formatter = $this->getDefaultFormatter();
  8261. }
  8262. return $this->formatter;
  8263. }
  8264. public function setLevel($level)
  8265. {
  8266. $this->level = Logger::toMonologLevel($level);
  8267. return $this;
  8268. }
  8269. public function getLevel()
  8270. {
  8271. return $this->level;
  8272. }
  8273. public function setBubble($bubble)
  8274. {
  8275. $this->bubble = $bubble;
  8276. return $this;
  8277. }
  8278. public function getBubble()
  8279. {
  8280. return $this->bubble;
  8281. }
  8282. public function __destruct()
  8283. {
  8284. try {
  8285. $this->close();
  8286. } catch (\Exception $e) {
  8287. } catch (\Throwable $e) {
  8288. }
  8289. }
  8290. public function reset()
  8291. {
  8292. foreach ($this->processors as $processor) {
  8293. if ($processor instanceof ResettableInterface) {
  8294. $processor->reset();
  8295. }
  8296. }
  8297. }
  8298. protected function getDefaultFormatter()
  8299. {
  8300. return new LineFormatter();
  8301. }
  8302. }
  8303. }
  8304. namespace Monolog\Handler
  8305. {
  8306. use Monolog\ResettableInterface;
  8307. abstract class AbstractProcessingHandler extends AbstractHandler
  8308. {
  8309. public function handle(array $record)
  8310. {
  8311. if (!$this->isHandling($record)) {
  8312. return false;
  8313. }
  8314. $record = $this->processRecord($record);
  8315. $record['formatted'] = $this->getFormatter()->format($record);
  8316. $this->write($record);
  8317. return false === $this->bubble;
  8318. }
  8319. abstract protected function write(array $record);
  8320. protected function processRecord(array $record)
  8321. {
  8322. if ($this->processors) {
  8323. foreach ($this->processors as $processor) {
  8324. $record = call_user_func($processor, $record);
  8325. }
  8326. }
  8327. return $record;
  8328. }
  8329. }
  8330. }
  8331. namespace Monolog\Handler
  8332. {
  8333. use Monolog\Logger;
  8334. class StreamHandler extends AbstractProcessingHandler
  8335. {
  8336. protected $stream;
  8337. protected $url;
  8338. private $errorMessage;
  8339. protected $filePermission;
  8340. protected $useLocking;
  8341. private $dirCreated;
  8342. public function __construct($stream, $level = Logger::DEBUG, $bubble = true, $filePermission = null, $useLocking = false)
  8343. {
  8344. parent::__construct($level, $bubble);
  8345. if (is_resource($stream)) {
  8346. $this->stream = $stream;
  8347. } elseif (is_string($stream)) {
  8348. $this->url = $stream;
  8349. } else {
  8350. throw new \InvalidArgumentException('A stream must either be a resource or a string.');
  8351. }
  8352. $this->filePermission = $filePermission;
  8353. $this->useLocking = $useLocking;
  8354. }
  8355. public function close()
  8356. {
  8357. if ($this->url && is_resource($this->stream)) {
  8358. fclose($this->stream);
  8359. }
  8360. $this->stream = null;
  8361. }
  8362. public function getStream()
  8363. {
  8364. return $this->stream;
  8365. }
  8366. public function getUrl()
  8367. {
  8368. return $this->url;
  8369. }
  8370. protected function write(array $record)
  8371. {
  8372. if (!is_resource($this->stream)) {
  8373. if (null === $this->url ||''=== $this->url) {
  8374. throw new \LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().');
  8375. }
  8376. $this->createDir();
  8377. $this->errorMessage = null;
  8378. set_error_handler(array($this,'customErrorHandler'));
  8379. $this->stream = fopen($this->url,'a');
  8380. if ($this->filePermission !== null) {
  8381. @chmod($this->url, $this->filePermission);
  8382. }
  8383. restore_error_handler();
  8384. if (!is_resource($this->stream)) {
  8385. $this->stream = null;
  8386. throw new \UnexpectedValueException(sprintf('The stream or file "%s" could not be opened: '.$this->errorMessage, $this->url));
  8387. }
  8388. }
  8389. if ($this->useLocking) {
  8390. flock($this->stream, LOCK_EX);
  8391. }
  8392. $this->streamWrite($this->stream, $record);
  8393. if ($this->useLocking) {
  8394. flock($this->stream, LOCK_UN);
  8395. }
  8396. }
  8397. protected function streamWrite($stream, array $record)
  8398. {
  8399. fwrite($stream, (string) $record['formatted']);
  8400. }
  8401. private function customErrorHandler($code, $msg)
  8402. {
  8403. $this->errorMessage = preg_replace('{^(fopen|mkdir)\(.*?\): }','', $msg);
  8404. }
  8405. private function getDirFromStream($stream)
  8406. {
  8407. $pos = strpos($stream,'://');
  8408. if ($pos === false) {
  8409. return dirname($stream);
  8410. }
  8411. if ('file://'=== substr($stream, 0, 7)) {
  8412. return dirname(substr($stream, 7));
  8413. }
  8414. return;
  8415. }
  8416. private function createDir()
  8417. {
  8418. if ($this->dirCreated) {
  8419. return;
  8420. }
  8421. $dir = $this->getDirFromStream($this->url);
  8422. if (null !== $dir && !is_dir($dir)) {
  8423. $this->errorMessage = null;
  8424. set_error_handler(array($this,'customErrorHandler'));
  8425. $status = mkdir($dir, 0777, true);
  8426. restore_error_handler();
  8427. if (false === $status && !is_dir($dir)) {
  8428. throw new \UnexpectedValueException(sprintf('There is no existing directory at "%s" and its not buildable: '.$this->errorMessage, $dir));
  8429. }
  8430. }
  8431. $this->dirCreated = true;
  8432. }
  8433. }
  8434. }
  8435. namespace Monolog\Handler
  8436. {
  8437. use Monolog\Handler\FingersCrossed\ErrorLevelActivationStrategy;
  8438. use Monolog\Handler\FingersCrossed\ActivationStrategyInterface;
  8439. use Monolog\Logger;
  8440. use Monolog\ResettableInterface;
  8441. class FingersCrossedHandler extends AbstractHandler
  8442. {
  8443. protected $handler;
  8444. protected $activationStrategy;
  8445. protected $buffering = true;
  8446. protected $bufferSize;
  8447. protected $buffer = array();
  8448. protected $stopBuffering;
  8449. protected $passthruLevel;
  8450. public function __construct($handler, $activationStrategy = null, $bufferSize = 0, $bubble = true, $stopBuffering = true, $passthruLevel = null)
  8451. {
  8452. if (null === $activationStrategy) {
  8453. $activationStrategy = new ErrorLevelActivationStrategy(Logger::WARNING);
  8454. }
  8455. if (!$activationStrategy instanceof ActivationStrategyInterface) {
  8456. $activationStrategy = new ErrorLevelActivationStrategy($activationStrategy);
  8457. }
  8458. $this->handler = $handler;
  8459. $this->activationStrategy = $activationStrategy;
  8460. $this->bufferSize = $bufferSize;
  8461. $this->bubble = $bubble;
  8462. $this->stopBuffering = $stopBuffering;
  8463. if ($passthruLevel !== null) {
  8464. $this->passthruLevel = Logger::toMonologLevel($passthruLevel);
  8465. }
  8466. if (!$this->handler instanceof HandlerInterface && !is_callable($this->handler)) {
  8467. throw new \RuntimeException("The given handler (".json_encode($this->handler).") is not a callable nor a Monolog\Handler\HandlerInterface object");
  8468. }
  8469. }
  8470. public function isHandling(array $record)
  8471. {
  8472. return true;
  8473. }
  8474. public function activate()
  8475. {
  8476. if ($this->stopBuffering) {
  8477. $this->buffering = false;
  8478. }
  8479. if (!$this->handler instanceof HandlerInterface) {
  8480. $record = end($this->buffer) ?: null;
  8481. $this->handler = call_user_func($this->handler, $record, $this);
  8482. if (!$this->handler instanceof HandlerInterface) {
  8483. throw new \RuntimeException("The factory callable should return a HandlerInterface");
  8484. }
  8485. }
  8486. $this->handler->handleBatch($this->buffer);
  8487. $this->buffer = array();
  8488. }
  8489. public function handle(array $record)
  8490. {
  8491. if ($this->processors) {
  8492. foreach ($this->processors as $processor) {
  8493. $record = call_user_func($processor, $record);
  8494. }
  8495. }
  8496. if ($this->buffering) {
  8497. $this->buffer[] = $record;
  8498. if ($this->bufferSize > 0 && count($this->buffer) > $this->bufferSize) {
  8499. array_shift($this->buffer);
  8500. }
  8501. if ($this->activationStrategy->isHandlerActivated($record)) {
  8502. $this->activate();
  8503. }
  8504. } else {
  8505. $this->handler->handle($record);
  8506. }
  8507. return false === $this->bubble;
  8508. }
  8509. public function close()
  8510. {
  8511. $this->flushBuffer();
  8512. }
  8513. public function reset()
  8514. {
  8515. $this->flushBuffer();
  8516. parent::reset();
  8517. if ($this->handler instanceof ResettableInterface) {
  8518. $this->handler->reset();
  8519. }
  8520. }
  8521. public function clear()
  8522. {
  8523. $this->buffer = array();
  8524. $this->reset();
  8525. }
  8526. private function flushBuffer()
  8527. {
  8528. if (null !== $this->passthruLevel) {
  8529. $level = $this->passthruLevel;
  8530. $this->buffer = array_filter($this->buffer, function ($record) use ($level) {
  8531. return $record['level'] >= $level;
  8532. });
  8533. if (count($this->buffer) > 0) {
  8534. $this->handler->handleBatch($this->buffer);
  8535. }
  8536. }
  8537. $this->buffer = array();
  8538. $this->buffering = true;
  8539. }
  8540. }
  8541. }
  8542. namespace Monolog\Handler
  8543. {
  8544. use Monolog\Logger;
  8545. class FilterHandler extends AbstractHandler
  8546. {
  8547. protected $handler;
  8548. protected $acceptedLevels;
  8549. protected $bubble;
  8550. public function __construct($handler, $minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY, $bubble = true)
  8551. {
  8552. $this->handler = $handler;
  8553. $this->bubble = $bubble;
  8554. $this->setAcceptedLevels($minLevelOrList, $maxLevel);
  8555. if (!$this->handler instanceof HandlerInterface && !is_callable($this->handler)) {
  8556. throw new \RuntimeException("The given handler (".json_encode($this->handler).") is not a callable nor a Monolog\Handler\HandlerInterface object");
  8557. }
  8558. }
  8559. public function getAcceptedLevels()
  8560. {
  8561. return array_flip($this->acceptedLevels);
  8562. }
  8563. public function setAcceptedLevels($minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY)
  8564. {
  8565. if (is_array($minLevelOrList)) {
  8566. $acceptedLevels = array_map('Monolog\Logger::toMonologLevel', $minLevelOrList);
  8567. } else {
  8568. $minLevelOrList = Logger::toMonologLevel($minLevelOrList);
  8569. $maxLevel = Logger::toMonologLevel($maxLevel);
  8570. $acceptedLevels = array_values(array_filter(Logger::getLevels(), function ($level) use ($minLevelOrList, $maxLevel) {
  8571. return $level >= $minLevelOrList && $level <= $maxLevel;
  8572. }));
  8573. }
  8574. $this->acceptedLevels = array_flip($acceptedLevels);
  8575. }
  8576. public function isHandling(array $record)
  8577. {
  8578. return isset($this->acceptedLevels[$record['level']]);
  8579. }
  8580. public function handle(array $record)
  8581. {
  8582. if (!$this->isHandling($record)) {
  8583. return false;
  8584. }
  8585. if (!$this->handler instanceof HandlerInterface) {
  8586. $this->handler = call_user_func($this->handler, $record, $this);
  8587. if (!$this->handler instanceof HandlerInterface) {
  8588. throw new \RuntimeException("The factory callable should return a HandlerInterface");
  8589. }
  8590. }
  8591. if ($this->processors) {
  8592. foreach ($this->processors as $processor) {
  8593. $record = call_user_func($processor, $record);
  8594. }
  8595. }
  8596. $this->handler->handle($record);
  8597. return false === $this->bubble;
  8598. }
  8599. public function handleBatch(array $records)
  8600. {
  8601. $filtered = array();
  8602. foreach ($records as $record) {
  8603. if ($this->isHandling($record)) {
  8604. $filtered[] = $record;
  8605. }
  8606. }
  8607. $this->handler->handleBatch($filtered);
  8608. }
  8609. }
  8610. }
  8611. namespace Monolog\Handler
  8612. {
  8613. class TestHandler extends AbstractProcessingHandler
  8614. {
  8615. protected $records = array();
  8616. protected $recordsByLevel = array();
  8617. public function getRecords()
  8618. {
  8619. return $this->records;
  8620. }
  8621. public function clear()
  8622. {
  8623. $this->records = array();
  8624. $this->recordsByLevel = array();
  8625. }
  8626. public function hasRecords($level)
  8627. {
  8628. return isset($this->recordsByLevel[$level]);
  8629. }
  8630. public function hasRecord($record, $level)
  8631. {
  8632. if (is_string($record)) {
  8633. $record = array('message'=> $record);
  8634. }
  8635. return $this->hasRecordThatPasses(function ($rec) use ($record) {
  8636. if ($rec['message'] !== $record['message']) {
  8637. return false;
  8638. }
  8639. if (isset($record['context']) && $rec['context'] !== $record['context']) {
  8640. return false;
  8641. }
  8642. return true;
  8643. }, $level);
  8644. }
  8645. public function hasRecordThatContains($message, $level)
  8646. {
  8647. return $this->hasRecordThatPasses(function ($rec) use ($message) {
  8648. return strpos($rec['message'], $message) !== false;
  8649. }, $level);
  8650. }
  8651. public function hasRecordThatMatches($regex, $level)
  8652. {
  8653. return $this->hasRecordThatPasses(function ($rec) use ($regex) {
  8654. return preg_match($regex, $rec['message']) > 0;
  8655. }, $level);
  8656. }
  8657. public function hasRecordThatPasses($predicate, $level)
  8658. {
  8659. if (!is_callable($predicate)) {
  8660. throw new \InvalidArgumentException("Expected a callable for hasRecordThatSucceeds");
  8661. }
  8662. if (!isset($this->recordsByLevel[$level])) {
  8663. return false;
  8664. }
  8665. foreach ($this->recordsByLevel[$level] as $i => $rec) {
  8666. if (call_user_func($predicate, $rec, $i)) {
  8667. return true;
  8668. }
  8669. }
  8670. return false;
  8671. }
  8672. protected function write(array $record)
  8673. {
  8674. $this->recordsByLevel[$record['level']][] = $record;
  8675. $this->records[] = $record;
  8676. }
  8677. public function __call($method, $args)
  8678. {
  8679. if (preg_match('/(.*)(Debug|Info|Notice|Warning|Error|Critical|Alert|Emergency)(.*)/', $method, $matches) > 0) {
  8680. $genericMethod = $matches[1] . ('Records'!== $matches[3] ?'Record':'') . $matches[3];
  8681. $level = constant('Monolog\Logger::'. strtoupper($matches[2]));
  8682. if (method_exists($this, $genericMethod)) {
  8683. $args[] = $level;
  8684. return call_user_func_array(array($this, $genericMethod), $args);
  8685. }
  8686. }
  8687. throw new \BadMethodCallException('Call to undefined method '. get_class($this) .'::'. $method .'()');
  8688. }
  8689. }
  8690. }
  8691. namespace Monolog
  8692. {
  8693. use Monolog\Handler\HandlerInterface;
  8694. use Monolog\Handler\StreamHandler;
  8695. use Psr\Log\LoggerInterface;
  8696. use Psr\Log\InvalidArgumentException;
  8697. use Exception;
  8698. class Logger implements LoggerInterface, ResettableInterface
  8699. {
  8700. const DEBUG = 100;
  8701. const INFO = 200;
  8702. const NOTICE = 250;
  8703. const WARNING = 300;
  8704. const ERROR = 400;
  8705. const CRITICAL = 500;
  8706. const ALERT = 550;
  8707. const EMERGENCY = 600;
  8708. const API = 1;
  8709. protected static $levels = array(
  8710. self::DEBUG =>'DEBUG',
  8711. self::INFO =>'INFO',
  8712. self::NOTICE =>'NOTICE',
  8713. self::WARNING =>'WARNING',
  8714. self::ERROR =>'ERROR',
  8715. self::CRITICAL =>'CRITICAL',
  8716. self::ALERT =>'ALERT',
  8717. self::EMERGENCY =>'EMERGENCY',
  8718. );
  8719. protected static $timezone;
  8720. protected $name;
  8721. protected $handlers;
  8722. protected $processors;
  8723. protected $microsecondTimestamps = true;
  8724. protected $exceptionHandler;
  8725. public function __construct($name, array $handlers = array(), array $processors = array())
  8726. {
  8727. $this->name = $name;
  8728. $this->setHandlers($handlers);
  8729. $this->processors = $processors;
  8730. }
  8731. public function getName()
  8732. {
  8733. return $this->name;
  8734. }
  8735. public function withName($name)
  8736. {
  8737. $new = clone $this;
  8738. $new->name = $name;
  8739. return $new;
  8740. }
  8741. public function pushHandler(HandlerInterface $handler)
  8742. {
  8743. array_unshift($this->handlers, $handler);
  8744. return $this;
  8745. }
  8746. public function popHandler()
  8747. {
  8748. if (!$this->handlers) {
  8749. throw new \LogicException('You tried to pop from an empty handler stack.');
  8750. }
  8751. return array_shift($this->handlers);
  8752. }
  8753. public function setHandlers(array $handlers)
  8754. {
  8755. $this->handlers = array();
  8756. foreach (array_reverse($handlers) as $handler) {
  8757. $this->pushHandler($handler);
  8758. }
  8759. return $this;
  8760. }
  8761. public function getHandlers()
  8762. {
  8763. return $this->handlers;
  8764. }
  8765. public function pushProcessor($callback)
  8766. {
  8767. if (!is_callable($callback)) {
  8768. throw new \InvalidArgumentException('Processors must be valid callables (callback or object with an __invoke method), '.var_export($callback, true).' given');
  8769. }
  8770. array_unshift($this->processors, $callback);
  8771. return $this;
  8772. }
  8773. public function popProcessor()
  8774. {
  8775. if (!$this->processors) {
  8776. throw new \LogicException('You tried to pop from an empty processor stack.');
  8777. }
  8778. return array_shift($this->processors);
  8779. }
  8780. public function getProcessors()
  8781. {
  8782. return $this->processors;
  8783. }
  8784. public function useMicrosecondTimestamps($micro)
  8785. {
  8786. $this->microsecondTimestamps = (bool) $micro;
  8787. }
  8788. public function addRecord($level, $message, array $context = array())
  8789. {
  8790. if (!$this->handlers) {
  8791. $this->pushHandler(new StreamHandler('php://stderr', static::DEBUG));
  8792. }
  8793. $levelName = static::getLevelName($level);
  8794. $handlerKey = null;
  8795. reset($this->handlers);
  8796. while ($handler = current($this->handlers)) {
  8797. if ($handler->isHandling(array('level'=> $level))) {
  8798. $handlerKey = key($this->handlers);
  8799. break;
  8800. }
  8801. next($this->handlers);
  8802. }
  8803. if (null === $handlerKey) {
  8804. return false;
  8805. }
  8806. if (!static::$timezone) {
  8807. static::$timezone = new \DateTimeZone(date_default_timezone_get() ?:'UTC');
  8808. }
  8809. if ($this->microsecondTimestamps && PHP_VERSION_ID < 70100) {
  8810. $ts = \DateTime::createFromFormat('U.u', sprintf('%.6F', microtime(true)), static::$timezone);
  8811. } else {
  8812. $ts = new \DateTime(null, static::$timezone);
  8813. }
  8814. $ts->setTimezone(static::$timezone);
  8815. $record = array('message'=> (string) $message,'context'=> $context,'level'=> $level,'level_name'=> $levelName,'channel'=> $this->name,'datetime'=> $ts,'extra'=> array(),
  8816. );
  8817. try {
  8818. foreach ($this->processors as $processor) {
  8819. $record = call_user_func($processor, $record);
  8820. }
  8821. while ($handler = current($this->handlers)) {
  8822. if (true === $handler->handle($record)) {
  8823. break;
  8824. }
  8825. next($this->handlers);
  8826. }
  8827. } catch (Exception $e) {
  8828. $this->handleException($e, $record);
  8829. }
  8830. return true;
  8831. }
  8832. public function close()
  8833. {
  8834. foreach ($this->handlers as $handler) {
  8835. if (method_exists($handler,'close')) {
  8836. $handler->close();
  8837. }
  8838. }
  8839. }
  8840. public function reset()
  8841. {
  8842. foreach ($this->handlers as $handler) {
  8843. if ($handler instanceof ResettableInterface) {
  8844. $handler->reset();
  8845. }
  8846. }
  8847. foreach ($this->processors as $processor) {
  8848. if ($processor instanceof ResettableInterface) {
  8849. $processor->reset();
  8850. }
  8851. }
  8852. }
  8853. public function addDebug($message, array $context = array())
  8854. {
  8855. return $this->addRecord(static::DEBUG, $message, $context);
  8856. }
  8857. public function addInfo($message, array $context = array())
  8858. {
  8859. return $this->addRecord(static::INFO, $message, $context);
  8860. }
  8861. public function addNotice($message, array $context = array())
  8862. {
  8863. return $this->addRecord(static::NOTICE, $message, $context);
  8864. }
  8865. public function addWarning($message, array $context = array())
  8866. {
  8867. return $this->addRecord(static::WARNING, $message, $context);
  8868. }
  8869. public function addError($message, array $context = array())
  8870. {
  8871. return $this->addRecord(static::ERROR, $message, $context);
  8872. }
  8873. public function addCritical($message, array $context = array())
  8874. {
  8875. return $this->addRecord(static::CRITICAL, $message, $context);
  8876. }
  8877. public function addAlert($message, array $context = array())
  8878. {
  8879. return $this->addRecord(static::ALERT, $message, $context);
  8880. }
  8881. public function addEmergency($message, array $context = array())
  8882. {
  8883. return $this->addRecord(static::EMERGENCY, $message, $context);
  8884. }
  8885. public static function getLevels()
  8886. {
  8887. return array_flip(static::$levels);
  8888. }
  8889. public static function getLevelName($level)
  8890. {
  8891. if (!isset(static::$levels[$level])) {
  8892. throw new InvalidArgumentException('Level "'.$level.'" is not defined, use one of: '.implode(', ', array_keys(static::$levels)));
  8893. }
  8894. return static::$levels[$level];
  8895. }
  8896. public static function toMonologLevel($level)
  8897. {
  8898. if (is_string($level) && defined(__CLASS__.'::'.strtoupper($level))) {
  8899. return constant(__CLASS__.'::'.strtoupper($level));
  8900. }
  8901. return $level;
  8902. }
  8903. public function isHandling($level)
  8904. {
  8905. $record = array('level'=> $level,
  8906. );
  8907. foreach ($this->handlers as $handler) {
  8908. if ($handler->isHandling($record)) {
  8909. return true;
  8910. }
  8911. }
  8912. return false;
  8913. }
  8914. public function setExceptionHandler($callback)
  8915. {
  8916. if (!is_callable($callback)) {
  8917. throw new \InvalidArgumentException('Exception handler must be valid callable (callback or object with an __invoke method), '.var_export($callback, true).' given');
  8918. }
  8919. $this->exceptionHandler = $callback;
  8920. return $this;
  8921. }
  8922. public function getExceptionHandler()
  8923. {
  8924. return $this->exceptionHandler;
  8925. }
  8926. protected function handleException(Exception $e, array $record)
  8927. {
  8928. if (!$this->exceptionHandler) {
  8929. throw $e;
  8930. }
  8931. call_user_func($this->exceptionHandler, $e, $record);
  8932. }
  8933. public function log($level, $message, array $context = array())
  8934. {
  8935. $level = static::toMonologLevel($level);
  8936. return $this->addRecord($level, $message, $context);
  8937. }
  8938. public function debug($message, array $context = array())
  8939. {
  8940. return $this->addRecord(static::DEBUG, $message, $context);
  8941. }
  8942. public function info($message, array $context = array())
  8943. {
  8944. return $this->addRecord(static::INFO, $message, $context);
  8945. }
  8946. public function notice($message, array $context = array())
  8947. {
  8948. return $this->addRecord(static::NOTICE, $message, $context);
  8949. }
  8950. public function warn($message, array $context = array())
  8951. {
  8952. return $this->addRecord(static::WARNING, $message, $context);
  8953. }
  8954. public function warning($message, array $context = array())
  8955. {
  8956. return $this->addRecord(static::WARNING, $message, $context);
  8957. }
  8958. public function err($message, array $context = array())
  8959. {
  8960. return $this->addRecord(static::ERROR, $message, $context);
  8961. }
  8962. public function error($message, array $context = array())
  8963. {
  8964. return $this->addRecord(static::ERROR, $message, $context);
  8965. }
  8966. public function crit($message, array $context = array())
  8967. {
  8968. return $this->addRecord(static::CRITICAL, $message, $context);
  8969. }
  8970. public function critical($message, array $context = array())
  8971. {
  8972. return $this->addRecord(static::CRITICAL, $message, $context);
  8973. }
  8974. public function alert($message, array $context = array())
  8975. {
  8976. return $this->addRecord(static::ALERT, $message, $context);
  8977. }
  8978. public function emerg($message, array $context = array())
  8979. {
  8980. return $this->addRecord(static::EMERGENCY, $message, $context);
  8981. }
  8982. public function emergency($message, array $context = array())
  8983. {
  8984. return $this->addRecord(static::EMERGENCY, $message, $context);
  8985. }
  8986. public static function setTimezone(\DateTimeZone $tz)
  8987. {
  8988. self::$timezone = $tz;
  8989. }
  8990. }
  8991. }
  8992. namespace Symfony\Component\HttpKernel\Log
  8993. {
  8994. interface DebugLoggerInterface
  8995. {
  8996. public function getLogs();
  8997. public function countErrors();
  8998. }
  8999. }
  9000. namespace Symfony\Bridge\Monolog
  9001. {
  9002. use Monolog\Logger as BaseLogger;
  9003. use Symfony\Component\HttpKernel\Log\DebugLoggerInterface;
  9004. class Logger extends BaseLogger implements DebugLoggerInterface
  9005. {
  9006. public function getLogs()
  9007. {
  9008. if ($logger = $this->getDebugLogger()) {
  9009. return $logger->getLogs();
  9010. }
  9011. return array();
  9012. }
  9013. public function countErrors()
  9014. {
  9015. if ($logger = $this->getDebugLogger()) {
  9016. return $logger->countErrors();
  9017. }
  9018. return 0;
  9019. }
  9020. public function clear()
  9021. {
  9022. if (($logger = $this->getDebugLogger()) && method_exists($logger,'clear')) {
  9023. $logger->clear();
  9024. }
  9025. }
  9026. private function getDebugLogger()
  9027. {
  9028. foreach ($this->processors as $processor) {
  9029. if ($processor instanceof DebugLoggerInterface) {
  9030. return $processor;
  9031. }
  9032. }
  9033. foreach ($this->handlers as $handler) {
  9034. if ($handler instanceof DebugLoggerInterface) {
  9035. return $handler;
  9036. }
  9037. }
  9038. }
  9039. }
  9040. }
  9041. namespace Monolog\Handler\FingersCrossed
  9042. {
  9043. interface ActivationStrategyInterface
  9044. {
  9045. public function isHandlerActivated(array $record);
  9046. }
  9047. }
  9048. namespace Monolog\Handler\FingersCrossed
  9049. {
  9050. use Monolog\Logger;
  9051. class ErrorLevelActivationStrategy implements ActivationStrategyInterface
  9052. {
  9053. private $actionLevel;
  9054. public function __construct($actionLevel)
  9055. {
  9056. $this->actionLevel = Logger::toMonologLevel($actionLevel);
  9057. }
  9058. public function isHandlerActivated(array $record)
  9059. {
  9060. return $record['level'] >= $this->actionLevel;
  9061. }
  9062. }
  9063. }
  9064. namespace Sensio\Bundle\FrameworkExtraBundle\EventListener
  9065. {
  9066. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  9067. use Sensio\Bundle\FrameworkExtraBundle\Request\ParamConverter\ParamConverterManager;
  9068. use Symfony\Component\HttpFoundation\Request;
  9069. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  9070. use Symfony\Component\HttpKernel\KernelEvents;
  9071. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  9072. class ParamConverterListener implements EventSubscriberInterface
  9073. {
  9074. private $manager;
  9075. private $autoConvert;
  9076. private $isParameterTypeSupported;
  9077. public function __construct(ParamConverterManager $manager, $autoConvert = true)
  9078. {
  9079. $this->manager = $manager;
  9080. $this->autoConvert = $autoConvert;
  9081. $this->isParameterTypeSupported = method_exists('ReflectionParameter','getType');
  9082. }
  9083. public function onKernelController(FilterControllerEvent $event)
  9084. {
  9085. $controller = $event->getController();
  9086. $request = $event->getRequest();
  9087. $configurations = [];
  9088. if ($configuration = $request->attributes->get('_converters')) {
  9089. foreach (\is_array($configuration) ? $configuration : [$configuration] as $configuration) {
  9090. $configurations[$configuration->getName()] = $configuration;
  9091. }
  9092. }
  9093. if (\is_array($controller)) {
  9094. $r = new \ReflectionMethod($controller[0], $controller[1]);
  9095. } elseif (\is_object($controller) && \is_callable($controller,'__invoke')) {
  9096. $r = new \ReflectionMethod($controller,'__invoke');
  9097. } else {
  9098. $r = new \ReflectionFunction($controller);
  9099. }
  9100. if ($this->autoConvert) {
  9101. $configurations = $this->autoConfigure($r, $request, $configurations);
  9102. }
  9103. $this->manager->apply($request, $configurations);
  9104. }
  9105. private function autoConfigure(\ReflectionFunctionAbstract $r, Request $request, $configurations)
  9106. {
  9107. foreach ($r->getParameters() as $param) {
  9108. if ($param->getClass() && $param->getClass()->isInstance($request)) {
  9109. continue;
  9110. }
  9111. $name = $param->getName();
  9112. $class = $param->getClass();
  9113. $hasType = $this->isParameterTypeSupported && $param->hasType();
  9114. if ($class || $hasType) {
  9115. if (!isset($configurations[$name])) {
  9116. $configuration = new ParamConverter([]);
  9117. $configuration->setName($name);
  9118. $configurations[$name] = $configuration;
  9119. }
  9120. if ($class && null === $configurations[$name]->getClass()) {
  9121. $configurations[$name]->setClass($class->getName());
  9122. }
  9123. }
  9124. if (isset($configurations[$name])) {
  9125. $configurations[$name]->setIsOptional($param->isOptional() || $param->isDefaultValueAvailable() || $hasType && $param->getType()->allowsNull());
  9126. }
  9127. }
  9128. return $configurations;
  9129. }
  9130. public static function getSubscribedEvents()
  9131. {
  9132. return [
  9133. KernelEvents::CONTROLLER =>'onKernelController',
  9134. ];
  9135. }
  9136. }
  9137. }
  9138. namespace Sensio\Bundle\FrameworkExtraBundle\Request\ParamConverter
  9139. {
  9140. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  9141. use Symfony\Component\HttpFoundation\Request;
  9142. interface ParamConverterInterface
  9143. {
  9144. public function apply(Request $request, ParamConverter $configuration);
  9145. public function supports(ParamConverter $configuration);
  9146. }
  9147. }
  9148. namespace Sensio\Bundle\FrameworkExtraBundle\Request\ParamConverter
  9149. {
  9150. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  9151. use Symfony\Component\HttpFoundation\Request;
  9152. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  9153. use DateTime;
  9154. class DateTimeParamConverter implements ParamConverterInterface
  9155. {
  9156. public function apply(Request $request, ParamConverter $configuration)
  9157. {
  9158. $param = $configuration->getName();
  9159. if (!$request->attributes->has($param)) {
  9160. return false;
  9161. }
  9162. $options = $configuration->getOptions();
  9163. $value = $request->attributes->get($param);
  9164. if (!$value && $configuration->isOptional()) {
  9165. $request->attributes->set($param, null);
  9166. return true;
  9167. }
  9168. $class = $configuration->getClass();
  9169. if (isset($options['format'])) {
  9170. $date = $class::createFromFormat($options['format'], $value);
  9171. if (0 < DateTime::getLastErrors()['warning_count']) {
  9172. $date = false;
  9173. }
  9174. if (!$date) {
  9175. throw new NotFoundHttpException(sprintf('Invalid date given for parameter "%s".', $param));
  9176. }
  9177. } else {
  9178. if (false === strtotime($value)) {
  9179. throw new NotFoundHttpException(sprintf('Invalid date given for parameter "%s".', $param));
  9180. }
  9181. $date = new $class($value);
  9182. }
  9183. $request->attributes->set($param, $date);
  9184. return true;
  9185. }
  9186. public function supports(ParamConverter $configuration)
  9187. {
  9188. if (null === $configuration->getClass()) {
  9189. return false;
  9190. }
  9191. return'DateTime'=== $configuration->getClass() || is_subclass_of($configuration->getClass(), \PHP_VERSION_ID < 50500 ?'DateTime':'DateTimeInterface');
  9192. }
  9193. }
  9194. }
  9195. namespace Sensio\Bundle\FrameworkExtraBundle\Request\ParamConverter
  9196. {
  9197. use Doctrine\DBAL\Types\ConversionException;
  9198. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  9199. use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
  9200. use Symfony\Component\ExpressionLanguage\SyntaxError;
  9201. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  9202. use Symfony\Component\HttpFoundation\Request;
  9203. use Doctrine\Common\Persistence\ManagerRegistry;
  9204. use Doctrine\ORM\EntityManagerInterface;
  9205. use Doctrine\ORM\NoResultException;
  9206. class DoctrineParamConverter implements ParamConverterInterface
  9207. {
  9208. private $registry;
  9209. private $language;
  9210. private $defaultOptions;
  9211. public function __construct(ManagerRegistry $registry = null, ExpressionLanguage $expressionLanguage = null, array $options = [])
  9212. {
  9213. $this->registry = $registry;
  9214. $this->language = $expressionLanguage;
  9215. $defaultValues = ['entity_manager'=> null,'exclude'=> [],'mapping'=> [],'strip_null'=> false,'expr'=> null,'id'=> null,'repository_method'=> null,'map_method_signature'=> false,'evict_cache'=> false,
  9216. ];
  9217. $this->defaultOptions = array_merge($defaultValues, $options);
  9218. }
  9219. public function apply(Request $request, ParamConverter $configuration)
  9220. {
  9221. $name = $configuration->getName();
  9222. $class = $configuration->getClass();
  9223. $options = $this->getOptions($configuration);
  9224. if (null === $request->attributes->get($name, false)) {
  9225. $configuration->setIsOptional(true);
  9226. }
  9227. $errorMessage = null;
  9228. if ($expr = $options['expr']) {
  9229. $object = $this->findViaExpression($class, $request, $expr, $options, $configuration);
  9230. if (null === $object) {
  9231. $errorMessage = sprintf('The expression "%s" returned null', $expr);
  9232. }
  9233. } elseif (false === $object = $this->find($class, $request, $options, $name)) {
  9234. if (false === $object = $this->findOneBy($class, $request, $options)) {
  9235. if ($configuration->isOptional()) {
  9236. $object = null;
  9237. } else {
  9238. throw new \LogicException(sprintf('Unable to guess how to get a Doctrine instance from the request information for parameter "%s".', $name));
  9239. }
  9240. }
  9241. }
  9242. if (null === $object && false === $configuration->isOptional()) {
  9243. $message = sprintf('%s object not found by the @%s annotation.', $class, $this->getAnnotationName($configuration));
  9244. if ($errorMessage) {
  9245. $message .=' '.$errorMessage;
  9246. }
  9247. throw new NotFoundHttpException($message);
  9248. }
  9249. $request->attributes->set($name, $object);
  9250. return true;
  9251. }
  9252. private function find($class, Request $request, $options, $name)
  9253. {
  9254. if ($options['mapping'] || $options['exclude']) {
  9255. return false;
  9256. }
  9257. $id = $this->getIdentifier($request, $options, $name);
  9258. if (false === $id || null === $id) {
  9259. return false;
  9260. }
  9261. if ($options['repository_method']) {
  9262. $method = $options['repository_method'];
  9263. } else {
  9264. $method ='find';
  9265. }
  9266. $om = $this->getManager($options['entity_manager'], $class);
  9267. if ($options['evict_cache'] && $om instanceof EntityManagerInterface) {
  9268. $cacheProvider = $om->getCache();
  9269. if ($cacheProvider && $cacheProvider->containsEntity($class, $id)) {
  9270. $cacheProvider->evictEntity($class, $id);
  9271. }
  9272. }
  9273. try {
  9274. return $om->getRepository($class)->$method($id);
  9275. } catch (NoResultException $e) {
  9276. return;
  9277. } catch (ConversionException $e) {
  9278. return;
  9279. }
  9280. }
  9281. private function getIdentifier(Request $request, $options, $name)
  9282. {
  9283. if (null !== $options['id']) {
  9284. if (!\is_array($options['id'])) {
  9285. $name = $options['id'];
  9286. } elseif (\is_array($options['id'])) {
  9287. $id = [];
  9288. foreach ($options['id'] as $field) {
  9289. if (false !== strstr($field,'%s')) {
  9290. $field = sprintf($field, $name);
  9291. }
  9292. $id[$field] = $request->attributes->get($field);
  9293. }
  9294. return $id;
  9295. }
  9296. }
  9297. if ($request->attributes->has($name)) {
  9298. return $request->attributes->get($name);
  9299. }
  9300. if ($request->attributes->has('id') && !$options['id']) {
  9301. return $request->attributes->get('id');
  9302. }
  9303. return false;
  9304. }
  9305. private function findOneBy($class, Request $request, $options)
  9306. {
  9307. if (!$options['mapping']) {
  9308. $keys = $request->attributes->keys();
  9309. $options['mapping'] = $keys ? array_combine($keys, $keys) : [];
  9310. }
  9311. foreach ($options['exclude'] as $exclude) {
  9312. unset($options['mapping'][$exclude]);
  9313. }
  9314. if (!$options['mapping']) {
  9315. return false;
  9316. }
  9317. if ($options['id'] && null === $request->attributes->get($options['id'])) {
  9318. return false;
  9319. }
  9320. $criteria = [];
  9321. $em = $this->getManager($options['entity_manager'], $class);
  9322. $metadata = $em->getClassMetadata($class);
  9323. $mapMethodSignature = $options['repository_method']
  9324. && $options['map_method_signature']
  9325. && true === $options['map_method_signature'];
  9326. foreach ($options['mapping'] as $attribute => $field) {
  9327. if ($metadata->hasField($field)
  9328. || ($metadata->hasAssociation($field) && $metadata->isSingleValuedAssociation($field))
  9329. || $mapMethodSignature) {
  9330. $criteria[$field] = $request->attributes->get($attribute);
  9331. }
  9332. }
  9333. if ($options['strip_null']) {
  9334. $criteria = array_filter($criteria, function ($value) {
  9335. return null !== $value;
  9336. });
  9337. }
  9338. if (!$criteria) {
  9339. return false;
  9340. }
  9341. if ($options['repository_method']) {
  9342. $repositoryMethod = $options['repository_method'];
  9343. } else {
  9344. $repositoryMethod ='findOneBy';
  9345. }
  9346. try {
  9347. if ($mapMethodSignature) {
  9348. return $this->findDataByMapMethodSignature($em, $class, $repositoryMethod, $criteria);
  9349. }
  9350. return $em->getRepository($class)->$repositoryMethod($criteria);
  9351. } catch (NoResultException $e) {
  9352. return;
  9353. } catch (ConversionException $e) {
  9354. return;
  9355. }
  9356. }
  9357. private function findDataByMapMethodSignature($em, $class, $repositoryMethod, $criteria)
  9358. {
  9359. $arguments = [];
  9360. $repository = $em->getRepository($class);
  9361. $ref = new \ReflectionMethod($repository, $repositoryMethod);
  9362. foreach ($ref->getParameters() as $parameter) {
  9363. if (array_key_exists($parameter->name, $criteria)) {
  9364. $arguments[] = $criteria[$parameter->name];
  9365. } elseif ($parameter->isDefaultValueAvailable()) {
  9366. $arguments[] = $parameter->getDefaultValue();
  9367. } else {
  9368. throw new \InvalidArgumentException(sprintf('Repository method "%s::%s" requires that you provide a value for the "$%s" argument.', \get_class($repository), $repositoryMethod, $parameter->name));
  9369. }
  9370. }
  9371. return $ref->invokeArgs($repository, $arguments);
  9372. }
  9373. private function findViaExpression($class, Request $request, $expression, $options, ParamConverter $configuration)
  9374. {
  9375. if (null === $this->language) {
  9376. throw new \LogicException(sprintf('To use the @%s tag with the "expr" option, you need to install the ExpressionLanguage component.', $this->getAnnotationName($configuration)));
  9377. }
  9378. $repository = $this->getManager($options['entity_manager'], $class)->getRepository($class);
  9379. $variables = array_merge($request->attributes->all(), ['repository'=> $repository]);
  9380. try {
  9381. return $this->language->evaluate($expression, $variables);
  9382. } catch (NoResultException $e) {
  9383. return;
  9384. } catch (ConversionException $e) {
  9385. return;
  9386. } catch (SyntaxError $e) {
  9387. throw new \LogicException(sprintf('Error parsing expression -- %s -- (%s)', $expression, $e->getMessage()), 0, $e);
  9388. }
  9389. }
  9390. public function supports(ParamConverter $configuration)
  9391. {
  9392. if (null === $this->registry || !\count($this->registry->getManagerNames())) {
  9393. return false;
  9394. }
  9395. if (null === $configuration->getClass()) {
  9396. return false;
  9397. }
  9398. $options = $this->getOptions($configuration, false);
  9399. $em = $this->getManager($options['entity_manager'], $configuration->getClass());
  9400. if (null === $em) {
  9401. return false;
  9402. }
  9403. return !$em->getMetadataFactory()->isTransient($configuration->getClass());
  9404. }
  9405. private function getOptions(ParamConverter $configuration, $strict = true)
  9406. {
  9407. $passedOptions = $configuration->getOptions();
  9408. if (isset($passedOptions['repository_method'])) {
  9409. @trigger_error('The repository_method option of @ParamConverter is deprecated and will be removed in 6.0. Use the expr option or @Entity.', E_USER_DEPRECATED);
  9410. }
  9411. if (isset($passedOptions['map_method_signature'])) {
  9412. @trigger_error('The map_method_signature option of @ParamConverter is deprecated and will be removed in 6.0. Use the expr option or @Entity.', E_USER_DEPRECATED);
  9413. }
  9414. $extraKeys = array_diff(array_keys($passedOptions), array_keys($this->defaultOptions));
  9415. if ($extraKeys && $strict) {
  9416. throw new \InvalidArgumentException(sprintf('Invalid option(s) passed to @%s: %s', $this->getAnnotationName($configuration), implode(', ', $extraKeys)));
  9417. }
  9418. return array_replace($this->defaultOptions, $passedOptions);
  9419. }
  9420. private function getManager($name, $class)
  9421. {
  9422. if (null === $name) {
  9423. return $this->registry->getManagerForClass($class);
  9424. }
  9425. return $this->registry->getManager($name);
  9426. }
  9427. private function getAnnotationName(ParamConverter $configuration)
  9428. {
  9429. $r = new \ReflectionClass($configuration);
  9430. return $r->getShortName();
  9431. }
  9432. }
  9433. }
  9434. namespace Sensio\Bundle\FrameworkExtraBundle\Request\ParamConverter
  9435. {
  9436. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  9437. use Symfony\Component\HttpFoundation\Request;
  9438. class ParamConverterManager
  9439. {
  9440. private $converters = [];
  9441. private $namedConverters = [];
  9442. public function apply(Request $request, $configurations)
  9443. {
  9444. if (\is_object($configurations)) {
  9445. $configurations = [$configurations];
  9446. }
  9447. foreach ($configurations as $configuration) {
  9448. $this->applyConverter($request, $configuration);
  9449. }
  9450. }
  9451. private function applyConverter(Request $request, ParamConverter $configuration)
  9452. {
  9453. $value = $request->attributes->get($configuration->getName());
  9454. $className = $configuration->getClass();
  9455. if (\is_object($value) && $value instanceof $className) {
  9456. return;
  9457. }
  9458. if ($converterName = $configuration->getConverter()) {
  9459. if (!isset($this->namedConverters[$converterName])) {
  9460. throw new \RuntimeException(sprintf("No converter named '%s' found for conversion of parameter '%s'.",
  9461. $converterName,
  9462. $configuration->getName()
  9463. ));
  9464. }
  9465. $converter = $this->namedConverters[$converterName];
  9466. if (!$converter->supports($configuration)) {
  9467. throw new \RuntimeException(sprintf("Converter '%s' does not support conversion of parameter '%s'.",
  9468. $converterName,
  9469. $configuration->getName()
  9470. ));
  9471. }
  9472. $converter->apply($request, $configuration);
  9473. return;
  9474. }
  9475. foreach ($this->all() as $converter) {
  9476. if ($converter->supports($configuration)) {
  9477. if ($converter->apply($request, $configuration)) {
  9478. return;
  9479. }
  9480. }
  9481. }
  9482. }
  9483. public function add(ParamConverterInterface $converter, $priority = 0, $name = null)
  9484. {
  9485. if (null !== $priority) {
  9486. if (!isset($this->converters[$priority])) {
  9487. $this->converters[$priority] = [];
  9488. }
  9489. $this->converters[$priority][] = $converter;
  9490. }
  9491. if (null !== $name) {
  9492. $this->namedConverters[$name] = $converter;
  9493. }
  9494. }
  9495. public function all()
  9496. {
  9497. krsort($this->converters);
  9498. $converters = [];
  9499. foreach ($this->converters as $all) {
  9500. $converters = array_merge($converters, $all);
  9501. }
  9502. return $converters;
  9503. }
  9504. }
  9505. }
  9506. namespace Sensio\Bundle\FrameworkExtraBundle\EventListener
  9507. {
  9508. use Symfony\Component\HttpFoundation\Request;
  9509. use Symfony\Component\HttpFoundation\Response;
  9510. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  9511. use Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent;
  9512. use Symfony\Component\HttpKernel\KernelEvents;
  9513. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  9514. use Symfony\Component\HttpFoundation\StreamedResponse;
  9515. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
  9516. use Sensio\Bundle\FrameworkExtraBundle\Templating\TemplateGuesser;
  9517. class TemplateListener implements EventSubscriberInterface
  9518. {
  9519. private $templateGuesser;
  9520. private $twig;
  9521. public function __construct(TemplateGuesser $templateGuesser, \Twig_Environment $twig = null)
  9522. {
  9523. $this->templateGuesser = $templateGuesser;
  9524. $this->twig = $twig;
  9525. }
  9526. public function onKernelController(FilterControllerEvent $event)
  9527. {
  9528. $request = $event->getRequest();
  9529. $template = $request->attributes->get('_template');
  9530. if (!$template instanceof Template) {
  9531. return;
  9532. }
  9533. $controller = $event->getController();
  9534. if (!\is_array($controller) && method_exists($controller,'__invoke')) {
  9535. $controller = [$controller,'__invoke'];
  9536. }
  9537. $template->setOwner($controller);
  9538. if (null === $template->getTemplate()) {
  9539. $template->setTemplate($this->templateGuesser->guessTemplateName($controller, $request));
  9540. }
  9541. }
  9542. public function onKernelView(GetResponseForControllerResultEvent $event)
  9543. {
  9544. $request = $event->getRequest();
  9545. $template = $request->attributes->get('_template');
  9546. if (!$template instanceof Template) {
  9547. return;
  9548. }
  9549. if (null === $this->twig) {
  9550. throw new \LogicException('You can not use the "@Template" annotation if the Twig Bundle is not available.');
  9551. }
  9552. $parameters = $event->getControllerResult();
  9553. $owner = $template->getOwner();
  9554. list($controller, $action) = $owner;
  9555. if (null === $parameters) {
  9556. $parameters = $this->resolveDefaultParameters($request, $template, $controller, $action);
  9557. }
  9558. if ($template->isStreamable()) {
  9559. $callback = function () use ($template, $parameters) {
  9560. $this->twig->display($template->getTemplate(), $parameters);
  9561. };
  9562. $event->setResponse(new StreamedResponse($callback));
  9563. } else {
  9564. $event->setResponse(new Response($this->twig->render($template->getTemplate(), $parameters)));
  9565. }
  9566. $template->setOwner([]);
  9567. }
  9568. public static function getSubscribedEvents()
  9569. {
  9570. return [
  9571. KernelEvents::CONTROLLER => ['onKernelController', -128],
  9572. KernelEvents::VIEW =>'onKernelView',
  9573. ];
  9574. }
  9575. private function resolveDefaultParameters(Request $request, Template $template, $controller, $action)
  9576. {
  9577. $parameters = [];
  9578. $arguments = $template->getVars();
  9579. if (0 === \count($arguments)) {
  9580. $r = new \ReflectionObject($controller);
  9581. $arguments = [];
  9582. foreach ($r->getMethod($action)->getParameters() as $param) {
  9583. $arguments[] = $param;
  9584. }
  9585. }
  9586. foreach ($arguments as $argument) {
  9587. if ($argument instanceof \ReflectionParameter) {
  9588. $parameters[$name = $argument->getName()] = !$request->attributes->has($name) && $argument->isDefaultValueAvailable() ? $argument->getDefaultValue() : $request->attributes->get($name);
  9589. } else {
  9590. $parameters[$argument] = $request->attributes->get($argument);
  9591. }
  9592. }
  9593. return $parameters;
  9594. }
  9595. }
  9596. }
  9597. namespace Sensio\Bundle\FrameworkExtraBundle\EventListener
  9598. {
  9599. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  9600. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  9601. use Symfony\Component\HttpKernel\KernelEvents;
  9602. use Symfony\Component\HttpFoundation\Response;
  9603. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  9604. use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
  9605. class HttpCacheListener implements EventSubscriberInterface
  9606. {
  9607. private $lastModifiedDates;
  9608. private $etags;
  9609. private $expressionLanguage;
  9610. public function __construct()
  9611. {
  9612. $this->lastModifiedDates = new \SplObjectStorage();
  9613. $this->etags = new \SplObjectStorage();
  9614. }
  9615. public function onKernelController(FilterControllerEvent $event)
  9616. {
  9617. $request = $event->getRequest();
  9618. if (!$configuration = $request->attributes->get('_cache')) {
  9619. return;
  9620. }
  9621. $response = new Response();
  9622. $lastModifiedDate ='';
  9623. if ($configuration->getLastModified()) {
  9624. $lastModifiedDate = $this->getExpressionLanguage()->evaluate($configuration->getLastModified(), $request->attributes->all());
  9625. $response->setLastModified($lastModifiedDate);
  9626. }
  9627. $etag ='';
  9628. if ($configuration->getEtag()) {
  9629. $etag = hash('sha256', $this->getExpressionLanguage()->evaluate($configuration->getEtag(), $request->attributes->all()));
  9630. $response->setEtag($etag);
  9631. }
  9632. if ($response->isNotModified($request)) {
  9633. $event->setController(function () use ($response) {
  9634. return $response;
  9635. });
  9636. $event->stopPropagation();
  9637. } else {
  9638. if ($etag) {
  9639. $this->etags[$request] = $etag;
  9640. }
  9641. if ($lastModifiedDate) {
  9642. $this->lastModifiedDates[$request] = $lastModifiedDate;
  9643. }
  9644. }
  9645. }
  9646. public function onKernelResponse(FilterResponseEvent $event)
  9647. {
  9648. $request = $event->getRequest();
  9649. if (!$configuration = $request->attributes->get('_cache')) {
  9650. return;
  9651. }
  9652. $response = $event->getResponse();
  9653. if (!\in_array($response->getStatusCode(), [200, 203, 300, 301, 302, 304, 404, 410])) {
  9654. return;
  9655. }
  9656. if (!$response->headers->hasCacheControlDirective('s-maxage') && null !== $age = $configuration->getSMaxAge()) {
  9657. $age = $this->convertToSecondsIfNeeded($age);
  9658. $response->setSharedMaxAge($age);
  9659. }
  9660. if ($configuration->mustRevalidate()) {
  9661. $response->headers->addCacheControlDirective('must-revalidate');
  9662. }
  9663. if (!$response->headers->hasCacheControlDirective('max-age') && null !== $age = $configuration->getMaxAge()) {
  9664. $age = $this->convertToSecondsIfNeeded($age);
  9665. $response->setMaxAge($age);
  9666. }
  9667. if (!$response->headers->hasCacheControlDirective('max-stale') && null !== $stale = $configuration->getMaxStale()) {
  9668. $stale = $this->convertToSecondsIfNeeded($stale);
  9669. $response->headers->addCacheControlDirective('max-stale', $stale);
  9670. }
  9671. if (!$response->headers->has('Expires') && null !== $configuration->getExpires()) {
  9672. $date = \DateTime::createFromFormat('U', strtotime($configuration->getExpires()), new \DateTimeZone('UTC'));
  9673. $response->setExpires($date);
  9674. }
  9675. if (!$response->headers->has('Vary') && null !== $configuration->getVary()) {
  9676. $response->setVary($configuration->getVary());
  9677. }
  9678. if ($configuration->isPublic()) {
  9679. $response->setPublic();
  9680. }
  9681. if ($configuration->isPrivate()) {
  9682. $response->setPrivate();
  9683. }
  9684. if (!$response->headers->has('Last-Modified') && isset($this->lastModifiedDates[$request])) {
  9685. $response->setLastModified($this->lastModifiedDates[$request]);
  9686. unset($this->lastModifiedDates[$request]);
  9687. }
  9688. if (!$response->headers->has('Etag') && isset($this->etags[$request])) {
  9689. $response->setEtag($this->etags[$request]);
  9690. unset($this->etags[$request]);
  9691. }
  9692. }
  9693. public static function getSubscribedEvents()
  9694. {
  9695. return [
  9696. KernelEvents::CONTROLLER =>'onKernelController',
  9697. KernelEvents::RESPONSE =>'onKernelResponse',
  9698. ];
  9699. }
  9700. private function getExpressionLanguage()
  9701. {
  9702. if (null === $this->expressionLanguage) {
  9703. if (!class_exists('Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
  9704. throw new \RuntimeException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
  9705. }
  9706. $this->expressionLanguage = new ExpressionLanguage();
  9707. }
  9708. return $this->expressionLanguage;
  9709. }
  9710. private function convertToSecondsIfNeeded($time)
  9711. {
  9712. if (!is_numeric($time)) {
  9713. $now = microtime(true);
  9714. $time = ceil(strtotime($time, $now) - $now);
  9715. }
  9716. return $time;
  9717. }
  9718. }
  9719. }
  9720. namespace Sensio\Bundle\FrameworkExtraBundle\EventListener
  9721. {
  9722. use Psr\Log\LoggerInterface;
  9723. use Sensio\Bundle\FrameworkExtraBundle\Request\ArgumentNameConverter;
  9724. use Sensio\Bundle\FrameworkExtraBundle\Security\ExpressionLanguage;
  9725. use Symfony\Component\HttpKernel\Event\FilterControllerArgumentsEvent;
  9726. use Symfony\Component\HttpKernel\Exception\HttpException;
  9727. use Symfony\Component\HttpKernel\KernelEvents;
  9728. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  9729. use Symfony\Component\Security\Core\Authentication\AuthenticationTrustResolverInterface;
  9730. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  9731. use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
  9732. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  9733. use Symfony\Component\Security\Core\Role\RoleHierarchyInterface;
  9734. class SecurityListener implements EventSubscriberInterface
  9735. {
  9736. private $argumentNameConverter;
  9737. private $tokenStorage;
  9738. private $authChecker;
  9739. private $language;
  9740. private $trustResolver;
  9741. private $roleHierarchy;
  9742. private $logger;
  9743. public function __construct(ArgumentNameConverter $argumentNameConverter, ExpressionLanguage $language = null, AuthenticationTrustResolverInterface $trustResolver = null, RoleHierarchyInterface $roleHierarchy = null, TokenStorageInterface $tokenStorage = null, AuthorizationCheckerInterface $authChecker = null, LoggerInterface $logger = null)
  9744. {
  9745. $this->argumentNameConverter = $argumentNameConverter;
  9746. $this->tokenStorage = $tokenStorage;
  9747. $this->authChecker = $authChecker;
  9748. $this->language = $language;
  9749. $this->trustResolver = $trustResolver;
  9750. $this->roleHierarchy = $roleHierarchy;
  9751. $this->logger = $logger;
  9752. }
  9753. public function onKernelControllerArguments(FilterControllerArgumentsEvent $event)
  9754. {
  9755. $request = $event->getRequest();
  9756. if (!$configurations = $request->attributes->get('_security')) {
  9757. return;
  9758. }
  9759. if (null === $this->tokenStorage || null === $this->trustResolver) {
  9760. throw new \LogicException('To use the @Security tag, you need to install the Symfony Security bundle.');
  9761. }
  9762. if (null === $this->tokenStorage->getToken()) {
  9763. throw new \LogicException('To use the @Security tag, your controller needs to be behind a firewall.');
  9764. }
  9765. if (null === $this->language) {
  9766. throw new \LogicException('To use the @Security tag, you need to use the Security component 2.4 or newer and install the ExpressionLanguage component.');
  9767. }
  9768. foreach ($configurations as $configuration) {
  9769. if (!$this->language->evaluate($configuration->getExpression(), $this->getVariables($event))) {
  9770. if ($statusCode = $configuration->getStatusCode()) {
  9771. throw new HttpException($statusCode, $configuration->getMessage());
  9772. }
  9773. throw new AccessDeniedException($configuration->getMessage() ?: sprintf('Expression "%s" denied access.', $configuration->getExpression()));
  9774. }
  9775. }
  9776. }
  9777. private function getVariables(FilterControllerArgumentsEvent $event)
  9778. {
  9779. $request = $event->getRequest();
  9780. $token = $this->tokenStorage->getToken();
  9781. if (null !== $this->roleHierarchy) {
  9782. $roles = $this->roleHierarchy->getReachableRoles($token->getRoles());
  9783. } else {
  9784. $roles = $token->getRoles();
  9785. }
  9786. $variables = ['token'=> $token,'user'=> $token->getUser(),'object'=> $request,'subject'=> $request,'request'=> $request,'roles'=> array_map(function ($role) {
  9787. return $role->getRole();
  9788. }, $roles),'trust_resolver'=> $this->trustResolver,'auth_checker'=> $this->authChecker,
  9789. ];
  9790. $controllerArguments = $this->argumentNameConverter->getControllerArguments($event);
  9791. if ($diff = array_intersect(array_keys($variables), array_keys($controllerArguments))) {
  9792. foreach ($diff as $key => $variableName) {
  9793. if ($variables[$variableName] === $controllerArguments[$variableName]) {
  9794. unset($diff[$key]);
  9795. }
  9796. }
  9797. if ($diff) {
  9798. $singular = 1 === \count($diff);
  9799. if (null !== $this->logger) {
  9800. $this->logger->warning(sprintf('Controller argument%s "%s" collided with the built-in security expression variables. The built-in value%s are being used for the @Security expression.', $singular ?'':'s', implode('", "', $diff), $singular ?'s':''));
  9801. }
  9802. }
  9803. }
  9804. return array_merge($controllerArguments, $variables);
  9805. }
  9806. public static function getSubscribedEvents()
  9807. {
  9808. return [KernelEvents::CONTROLLER_ARGUMENTS =>'onKernelControllerArguments'];
  9809. }
  9810. }
  9811. }
  9812. namespace Sensio\Bundle\FrameworkExtraBundle\Configuration
  9813. {
  9814. interface ConfigurationInterface
  9815. {
  9816. public function getAliasName();
  9817. public function allowArray();
  9818. }
  9819. }
  9820. namespace Sensio\Bundle\FrameworkExtraBundle\Configuration
  9821. {
  9822. abstract class ConfigurationAnnotation implements ConfigurationInterface
  9823. {
  9824. public function __construct(array $values)
  9825. {
  9826. foreach ($values as $k => $v) {
  9827. if (!method_exists($this, $name ='set'.$k)) {
  9828. throw new \RuntimeException(sprintf('Unknown key "%s" for annotation "@%s".', $k, \get_class($this)));
  9829. }
  9830. $this->$name($v);
  9831. }
  9832. }
  9833. }
  9834. }