PicoDeprecated::on404ContentLoading() - Code Metrics - theshka/Pico - Measure and Improve Code Quality continuously with Scrutinizer

PicoDeprecated::on404ContentLoading() A
last analyzed 2016-01-26 15:10 UTC

↳ Parent: PicoDeprecated

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php

/**
 * Serve features of Pico deprecated since v1.0
 *
 * This plugin exists for backward compatibility and is disabled by default.
 * It gets automatically enabled when a plugin which doesn't implement
 * {@link PicoPluginInterface} is loaded. This plugin triggers deprecated
 * events and automatically enables {@link PicoParsePagesContent} and
 * {@link PicoExcerpt}. These plugins heavily impact Pico's performance! You
 * can disable this plugin by calling {@link PicoDeprecated::setEnabled()}.
 *
 * The following deprecated events are triggered by this plugin:
 *
 * | Event               | ... triggers the deprecated event                         |
 * | ------------------- | --------------------------------------------------------- |
 * | onPluginsLoaded     | plugins_loaded()                                          |
 * | onConfigLoaded      | config_loaded($config)                                    |
 * | onRequestUrl        | request_url($url)                                         |
 * | onContentLoading    | before_load_content($file)                                |
 * | onContentLoaded     | after_load_content($file, $rawContent)                    |
 * | on404ContentLoading | before_404_load_content($file)                            |
 * | on404ContentLoaded  | after_404_load_content($file, $rawContent)                |
 * | onMetaHeaders       | before_read_file_meta($headers)                           |
 * | onMetaParsed        | file_meta($meta)                                          |
 * | onContentParsing    | before_parse_content($rawContent)                         |
 * | onContentParsed     | after_parse_content($content)                             |
 * | onContentParsed     | content_parsed($content)                                  |
 * | onSinglePageLoaded  | get_page_data($pages, $meta)                              |
 * | onPagesLoaded       | get_pages($pages, $currentPage, $previousPage, $nextPage) |
 * | onTwigRegistration  | before_twig_register()                                    |
 * | onPageRendering     | before_render($twigVariables, $twig, $templateName)       |
 * | onPageRendered      | after_render($output)                                     |
 *
 * Since Pico 1.0 the config is stored in {@path "config/config.php"}. This
 * plugin tries to read {@path "config.php"} in Pico's root dir and overwrites
 * all settings previously specified in {@path "config/config.php"}.
 *
 * @author  Daniel Rudolf
 * @link    http://picocms.org
 * @license http://opensource.org/licenses/MIT
 * @version 1.0
 */
class PicoDeprecated extends AbstractPicoPlugin
{
    /**
     * This plugin is disabled by default
     *
     * @see AbstractPicoPlugin::$enabled
     */
    protected $enabled = false;

    /**
     * The requested file
     *
     * @see PicoDeprecated::getRequestFile()
     * @var string|null
     */
    protected $requestFile;

    /**
     * Enables this plugin on demand and triggers the deprecated event
     * plugins_loaded()
     *
     * @see DummyPlugin::onPluginsLoaded()
     */
    public function onPluginsLoaded(array &$plugins)
    {
        if (!empty($plugins)) {
            foreach ($plugins as $plugin) {
                if (!is_a($plugin, 'PicoPluginInterface')) {
                    // the plugin doesn't implement PicoPluginInterface; it uses deprecated events
                    // enable PicoDeprecated if it hasn't be explicitly enabled/disabled yet
                    if (!$this->isStatusChanged()) {
                        $this->setEnabled(true, true, true);
                    }
                    break;
                }
            }
        } else {
            // no plugins were found, so it actually isn't necessary to call deprecated events
            // anyway, this plugin also ensures compatibility apart from events used by old plugins,
            // so enable PicoDeprecated if it hasn't be explicitly enabled/disabled yet
            if (!$this->isStatusChanged()) {
                $this->setEnabled(true, true, true);
            }
        }

        if ($this->isEnabled()) {
            $this->triggerEvent('plugins_loaded');
        }
    }

    /**
     * Triggers the deprecated event config_loaded($config)
     *
     * This method also defines deprecated constants, reads the `config.php`
     * in Pico's root dir, enables the plugins {@link PicoParsePagesContent}
     * and {@link PicoExcerpt} and makes `$config` globally accessible (the
     * latter was removed with Pico 0.9 and was added again as deprecated
     * feature with Pico 1.0)
     *
     * @see    PicoDeprecated::defineConstants()
     * @see    PicoDeprecated::loadRootDirConfig()
     * @see    PicoDeprecated::enablePlugins()
     * @see    DummyPlugin::onConfigLoaded()
     * @param  array &$config array of config variables
     * @return void
     */
    public function onConfigLoaded(array &$config)
    {
        $this->defineConstants();
        $this->loadRootDirConfig($config);
        $this->enablePlugins();
        $GLOBALS['config'] = &$config;

        $this->triggerEvent('config_loaded', array(&$config));
    }

    /**
     * Defines deprecated constants
     *
     * `ROOT_DIR`, `LIB_DIR`, `PLUGINS_DIR`, `THEMES_DIR` and `CONTENT_EXT`
     * are deprecated since v1.0, `CONTENT_DIR` existed just in v0.9,
     * `CONFIG_DIR` just for a short time between v0.9 and v1.0 and
     * `CACHE_DIR` was dropped with v1.0 without a replacement.
     *
     * @see    PicoDeprecated::onConfigLoaded()
     * @return void
     */
    protected function defineConstants()
    {
        if (!defined('ROOT_DIR')) {
            define('ROOT_DIR', $this->getRootDir());
        }
        if (!defined('CONFIG_DIR')) {
            define('CONFIG_DIR', $this->getConfigDir());
        }
        if (!defined('LIB_DIR')) {
            $picoReflector = new ReflectionClass('Pico');
            define('LIB_DIR', dirname($picoReflector->getFileName()) . '/');
        }
        if (!defined('PLUGINS_DIR')) {
            define('PLUGINS_DIR', $this->getPluginsDir());
        }
        if (!defined('THEMES_DIR')) {
            define('THEMES_DIR', $this->getThemesDir());
        }
        if (!defined('CONTENT_DIR')) {
            define('CONTENT_DIR', $this->getConfig('content_dir'));
        }
        if (!defined('CONTENT_EXT')) {
            define('CONTENT_EXT', $this->getConfig('content_ext'));
        }
    }

    /**
     * Read config.php in Pico's root dir
     *
     * @see    PicoDeprecated::onConfigLoaded()
     * @see    Pico::loadConfig()
     * @param  array &$realConfig array of config variables
     * @return void
     */
    protected function loadRootDirConfig(array &$realConfig)
    {
        if (file_exists($this->getRootDir() . 'config.php')) {
            // config.php in Pico::$rootDir is deprecated
            // use config.php in Pico::$configDir instead
            $config = null;
            require($this->getRootDir() . 'config.php');

            if (is_array($config)) {
                if (isset($config['base_url'])) {
                    $config['base_url'] = rtrim($config['base_url'], '/') . '/';
                }
                if (isset($config['content_dir'])) {
                    $config['content_dir'] = rtrim($config['content_dir'], '/\\') . '/';
                }

                $realConfig = $config + $realConfig;
            }
        }
    }

    /**
     * Enables the plugins PicoParsePagesContent and PicoExcerpt
     *
     * @see    PicoParsePagesContent
     * @see    PicoExcerpt
     * @return void
     */
    protected function enablePlugins()
    {
        // enable PicoParsePagesContent and PicoExcerpt
        // we can't enable them during onPluginsLoaded because we can't know
        // if the user disabled us (PicoDeprecated) manually in the config
        $plugins = $this->getPlugins();
        if (isset($plugins['PicoParsePagesContent'])) {
            // parse all pages content if this plugin hasn't
            // be explicitly enabled/disabled yet
            if (!$plugins['PicoParsePagesContent']->isStatusChanged()) {
                $plugins['PicoParsePagesContent']->setEnabled(true, true, true);
            }
        }
        if (isset($plugins['PicoExcerpt'])) {
            // enable excerpt plugin if it hasn't be explicitly enabled/disabled yet
            if (!$plugins['PicoExcerpt']->isStatusChanged()) {
                $plugins['PicoExcerpt']->setEnabled(true, true, true);
            }
        }
    }

    /**
     * Triggers the deprecated event request_url($url)
     *
     * @see DummyPlugin::onRequestUrl()
     */
    public function onRequestUrl(&$url)
    {
        $this->triggerEvent('request_url', array(&$url));
    }

    /**
     * Sets PicoDeprecated::$requestFile to trigger the deprecated
     * events after_load_content() and after_404_load_content()
     *
     * @see PicoDeprecated::onContentLoaded()
     * @see PicoDeprecated::on404ContentLoaded()
     * @see DummyPlugin::onRequestFile()
     */
    public function onRequestFile(&$file)
    {
        $this->requestFile = &$file;
    }

    /**
     * Triggers the deprecated before_load_content($file)
     *
     * @see DummyPlugin::onContentLoading()
     */
    public function onContentLoading(&$file)
    {
        $this->triggerEvent('before_load_content', array(&$file));
    }

    /**
     * Triggers the deprecated event after_load_content($file, $rawContent)
     *
     * @see DummyPlugin::onContentLoaded()
     */
    public function onContentLoaded(&$rawContent)
    {
        $this->triggerEvent('after_load_content', array(&$this->requestFile, &$rawContent));
    }

    /**
     * Triggers the deprecated before_404_load_content($file)
     *
     * @see DummyPlugin::on404ContentLoading()
     */
    public function on404ContentLoading(&$file)
    {
        $this->triggerEvent('before_404_load_content', array(&$file));
    }

    /**
     * Triggers the deprecated event after_404_load_content($file, $rawContent)
     *
     * @see DummyPlugin::on404ContentLoaded()
     */
    public function on404ContentLoaded(&$rawContent)
    {
        $this->triggerEvent('after_404_load_content', array(&$this->requestFile, &$rawContent));
    }

    /**
     * Triggers the deprecated event before_read_file_meta($headers)
     *
     * @see DummyPlugin::onMetaHeaders()
     */
    public function onMetaHeaders(array &$headers)
    {
        $this->triggerEvent('before_read_file_meta', array(&$headers));
    }

    /**
     * Triggers the deprecated event file_meta($meta)
     *
     * @see DummyPlugin::onMetaParsed()
     */
    public function onMetaParsed(array &$meta)
    {
        $this->triggerEvent('file_meta', array(&$meta));
    }

    /**
     * Triggers the deprecated event before_parse_content($rawContent)
     *
     * @see DummyPlugin::onContentParsing()
     */
    public function onContentParsing(&$rawContent)
    {
        $this->triggerEvent('before_parse_content', array(&$rawContent));
    }

    /**
     * Triggers the deprecated events after_parse_content($content) and
     * content_parsed($content)
     *
     * @see DummyPlugin::onContentParsed()
     */
    public function onContentParsed(&$content)
    {
        $this->triggerEvent('after_parse_content', array(&$content));

        // deprecated since v0.8
        $this->triggerEvent('content_parsed', array(&$content));
    }

    /**
     * Triggers the deprecated event get_page_data($pages, $meta)
     *
     * @see DummyPlugin::onSinglePageLoaded()
     */
    public function onSinglePageLoaded(array &$pageData)
    {
        $this->triggerEvent('get_page_data', array(&$pageData, $pageData['meta']));
    }

    /**
     * Triggers the deprecated event
     * get_pages($pages, $currentPage, $previousPage, $nextPage)
     *
     * Please note that the `get_pages()` event gets `$pages` passed without a
     * array index. The index is rebuild later using either the `id` array key
     * or is derived from the `url` array key. Duplicates are prevented by
     * adding `~dup` when necessary.
     *
     * @see DummyPlugin::onPagesLoaded()
     */
    public function onPagesLoaded(
        array &$pages,
        array &$currentPage = null,
        array &$previousPage = null,
        array &$nextPage = null
    ) {
        // remove keys of pages array
        $plainPages = array();
        foreach ($pages as &$pageData) {
            $plainPages[] = &$pageData;
        }
        unset($pageData);

        $this->triggerEvent('get_pages', array(&$plainPages, &$currentPage, &$previousPage, &$nextPage));

        // re-index pages array
        $pages = array();
        foreach ($plainPages as &$pageData) {
            if (!isset($pageData['id'])) {
                $urlPrefixLength = strlen($this->getBaseUrl()) + intval(!$this->isUrlRewritingEnabled());
                $pageData['id'] = substr($pageData['url'], $urlPrefixLength);
            }

            // prevent duplicates
            $id = $pageData['id'];
            for ($i = 1; isset($pages[$id]); $i++) {
                $id = $pageData['id'] . '~dup' . $i;
            }

            $pages[$id] = &$pageData;
        }
    }

    /**
     * Triggers the deprecated event before_twig_register()
     *
     * @see DummyPlugin::onTwigRegistration()
     */
    public function onTwigRegistration()
    {
        $this->triggerEvent('before_twig_register');
    }

    /**
     * Triggers the deprecated event before_render($twigVariables, $twig, $templateName)
     *
     * Please note that the `before_render()` event gets `$templateName` passed
     * without its file extension. The file extension is later added again.
     *
     * @see DummyPlugin::onPageRendering()
     */
    public function onPageRendering(Twig_Environment &$twig, array &$twigVariables, &$templateName)
    {
        // template name contains file extension since Pico 1.0
        $fileExtension = '';
        if (($fileExtensionPos = strrpos($templateName, '.')) !== false) {
            $fileExtension = substr($templateName, $fileExtensionPos);
            $templateName = substr($templateName, 0, $fileExtensionPos);
        }

        $this->triggerEvent('before_render', array(&$twigVariables, &$twig, &$templateName));

        // add original file extension
        $templateName = $templateName . $fileExtension;
    }

    /**
     * Triggers the deprecated event after_render($output)
     *
     * @see DummyPlugin::onPageRendered()
     */
    public function onPageRendered(&$output)
    {
        $this->triggerEvent('after_render', array(&$output));
    }

    /**
     * Triggers a deprecated event on all plugins
     *
     * Deprecated events are also triggered on plugins which implement
     * {@link PicoPluginInterface}. Please note that the methods are called
     * directly and not through {@link PicoPluginInterface::handleEvent()}.
     *
     * @param  string $eventName event to trigger
     * @param  array  $params    parameters to pass
     * @return void
     */
    protected function triggerEvent($eventName, array $params = array())
    {
        foreach ($this->getPlugins() as $plugin) {
            if (method_exists($plugin, $eventName)) {
                call_user_func_array(array($plugin, $eventName), $params);
            }
        }
    }
}


1			<?php
2
3			/**
4			* Serve features of Pico deprecated since v1.0
5			*
6			* This plugin exists for backward compatibility and is disabled by default.
7			* It gets automatically enabled when a plugin which doesn't implement
8			* {@link PicoPluginInterface} is loaded. This plugin triggers deprecated
9			* events and automatically enables {@link PicoParsePagesContent} and
10			* {@link PicoExcerpt}. These plugins heavily impact Pico's performance! You
11			* can disable this plugin by calling {@link PicoDeprecated::setEnabled()}.
12			*
13			* The following deprecated events are triggered by this plugin:
14			*
15			* \| Event \| ... triggers the deprecated event \|
16			* \| ------------------- \| --------------------------------------------------------- \|
17			* \| onPluginsLoaded \| plugins_loaded() \|
18			* \| onConfigLoaded \| config_loaded($config) \|
19			* \| onRequestUrl \| request_url($url) \|
20			* \| onContentLoading \| before_load_content($file) \|
21			* \| onContentLoaded \| after_load_content($file, $rawContent) \|
22			* \| on404ContentLoading \| before_404_load_content($file) \|
23			* \| on404ContentLoaded \| after_404_load_content($file, $rawContent) \|
24			* \| onMetaHeaders \| before_read_file_meta($headers) \|
25			* \| onMetaParsed \| file_meta($meta) \|
26			* \| onContentParsing \| before_parse_content($rawContent) \|
27			* \| onContentParsed \| after_parse_content($content) \|
28			* \| onContentParsed \| content_parsed($content) \|
29			* \| onSinglePageLoaded \| get_page_data($pages, $meta) \|
30			* \| onPagesLoaded \| get_pages($pages, $currentPage, $previousPage, $nextPage) \|
31			* \| onTwigRegistration \| before_twig_register() \|
32			* \| onPageRendering \| before_render($twigVariables, $twig, $templateName) \|
33			* \| onPageRendered \| after_render($output) \|
34			*
35			* Since Pico 1.0 the config is stored in {@path "config/config.php"}. This
36			* plugin tries to read {@path "config.php"} in Pico's root dir and overwrites
37			* all settings previously specified in {@path "config/config.php"}.
38			*
39			* @author Daniel Rudolf
40			* @link http://picocms.org
41			* @license http://opensource.org/licenses/MIT
42			* @version 1.0
43			*/
44			class PicoDeprecated extends AbstractPicoPlugin
45			{
46			/**
47			* This plugin is disabled by default
48			*
49			* @see AbstractPicoPlugin::$enabled
50			*/
51			protected $enabled = false;
52
53			/**
54			* The requested file
55			*
56			* @see PicoDeprecated::getRequestFile()
57			* @var string\|null
58			*/
59			protected $requestFile;
60
61			/**
62			* Enables this plugin on demand and triggers the deprecated event
63			* plugins_loaded()
64			*
65			* @see DummyPlugin::onPluginsLoaded()
66			*/
67			public function onPluginsLoaded(array &$plugins)
68			{
69			if (!empty($plugins)) {
70			foreach ($plugins as $plugin) {
71			if (!is_a($plugin, 'PicoPluginInterface')) {
72			// the plugin doesn't implement PicoPluginInterface; it uses deprecated events
73			// enable PicoDeprecated if it hasn't be explicitly enabled/disabled yet
74			if (!$this->isStatusChanged()) {
75			$this->setEnabled(true, true, true);
76			}
77			break;
78			}
79			}
80			} else {
81			// no plugins were found, so it actually isn't necessary to call deprecated events
82			// anyway, this plugin also ensures compatibility apart from events used by old plugins,
83			// so enable PicoDeprecated if it hasn't be explicitly enabled/disabled yet
84			if (!$this->isStatusChanged()) {
85			$this->setEnabled(true, true, true);
86			}
87			}
88
89			if ($this->isEnabled()) {
90			$this->triggerEvent('plugins_loaded');
91			}
92			}
93
94			/**
95			* Triggers the deprecated event config_loaded($config)
96			*
97			* This method also defines deprecated constants, reads the `config.php`
98			* in Pico's root dir, enables the plugins {@link PicoParsePagesContent}
99			* and {@link PicoExcerpt} and makes `$config` globally accessible (the
100			* latter was removed with Pico 0.9 and was added again as deprecated
101			* feature with Pico 1.0)
102			*
103			* @see PicoDeprecated::defineConstants()
104			* @see PicoDeprecated::loadRootDirConfig()
105			* @see PicoDeprecated::enablePlugins()
106			* @see DummyPlugin::onConfigLoaded()
107			* @param array &$config array of config variables
108			* @return void
109			*/
110			public function onConfigLoaded(array &$config)
111			{
112			$this->defineConstants();
113			$this->loadRootDirConfig($config);
114			$this->enablePlugins();
115			$GLOBALS['config'] = &$config;
116
117			$this->triggerEvent('config_loaded', array(&$config));
118			}
119
120			/**
121			* Defines deprecated constants
122			*
123			* `ROOT_DIR`, `LIB_DIR`, `PLUGINS_DIR`, `THEMES_DIR` and `CONTENT_EXT`
124			* are deprecated since v1.0, `CONTENT_DIR` existed just in v0.9,
125			* `CONFIG_DIR` just for a short time between v0.9 and v1.0 and
126			* `CACHE_DIR` was dropped with v1.0 without a replacement.
127			*
128			* @see PicoDeprecated::onConfigLoaded()
129			* @return void
130			*/
131			protected function defineConstants()
132			{
133			if (!defined('ROOT_DIR')) {
134			define('ROOT_DIR', $this->getRootDir());
135			}
136			if (!defined('CONFIG_DIR')) {
137			define('CONFIG_DIR', $this->getConfigDir());
138			}
139			if (!defined('LIB_DIR')) {
140			$picoReflector = new ReflectionClass('Pico');
141			define('LIB_DIR', dirname($picoReflector->getFileName()) . '/');
142			}
143			if (!defined('PLUGINS_DIR')) {
144			define('PLUGINS_DIR', $this->getPluginsDir());
145			}
146			if (!defined('THEMES_DIR')) {
147			define('THEMES_DIR', $this->getThemesDir());
148			}
149			if (!defined('CONTENT_DIR')) {
150			define('CONTENT_DIR', $this->getConfig('content_dir'));
151			}
152			if (!defined('CONTENT_EXT')) {
153			define('CONTENT_EXT', $this->getConfig('content_ext'));
154			}
155			}
156
157			/**
158			* Read config.php in Pico's root dir
159			*
160			* @see PicoDeprecated::onConfigLoaded()
161			* @see Pico::loadConfig()
162			* @param array &$realConfig array of config variables
163			* @return void
164			*/
165			protected function loadRootDirConfig(array &$realConfig)
166			{
167			if (file_exists($this->getRootDir() . 'config.php')) {
168			// config.php in Pico::$rootDir is deprecated
169			// use config.php in Pico::$configDir instead
170			$config = null;
171			require($this->getRootDir() . 'config.php');
172
173			if (is_array($config)) {
174			if (isset($config['base_url'])) {
175			$config['base_url'] = rtrim($config['base_url'], '/') . '/';
176			}
177			if (isset($config['content_dir'])) {
178			$config['content_dir'] = rtrim($config['content_dir'], '/\\') . '/';
179			}
180
181			$realConfig = $config + $realConfig;
182			}
183			}
184			}
185
186			/**
187			* Enables the plugins PicoParsePagesContent and PicoExcerpt
188			*
189			* @see PicoParsePagesContent
190			* @see PicoExcerpt
191			* @return void
192			*/
193			protected function enablePlugins()
194			{
195			// enable PicoParsePagesContent and PicoExcerpt
196			// we can't enable them during onPluginsLoaded because we can't know
197			// if the user disabled us (PicoDeprecated) manually in the config
198			$plugins = $this->getPlugins();
199			if (isset($plugins['PicoParsePagesContent'])) {
200			// parse all pages content if this plugin hasn't
201			// be explicitly enabled/disabled yet
202			if (!$plugins['PicoParsePagesContent']->isStatusChanged()) {
203			$plugins['PicoParsePagesContent']->setEnabled(true, true, true);
204			}
205			}
206			if (isset($plugins['PicoExcerpt'])) {
207			// enable excerpt plugin if it hasn't be explicitly enabled/disabled yet
208			if (!$plugins['PicoExcerpt']->isStatusChanged()) {
209			$plugins['PicoExcerpt']->setEnabled(true, true, true);
210			}
211			}
212			}
213
214			/**
215			* Triggers the deprecated event request_url($url)
216			*
217			* @see DummyPlugin::onRequestUrl()
218			*/
219			public function onRequestUrl(&$url)
220			{
221			$this->triggerEvent('request_url', array(&$url));
222			}
223
224			/**
225			* Sets PicoDeprecated::$requestFile to trigger the deprecated
226			* events after_load_content() and after_404_load_content()
227			*
228			* @see PicoDeprecated::onContentLoaded()
229			* @see PicoDeprecated::on404ContentLoaded()
230			* @see DummyPlugin::onRequestFile()
231			*/
232			public function onRequestFile(&$file)
233			{
234			$this->requestFile = &$file;
235			}
236
237			/**
238			* Triggers the deprecated before_load_content($file)
239			*
240			* @see DummyPlugin::onContentLoading()
241			*/
242			public function onContentLoading(&$file)
243			{
244			$this->triggerEvent('before_load_content', array(&$file));
245			}
246
247			/**
248			* Triggers the deprecated event after_load_content($file, $rawContent)
249			*
250			* @see DummyPlugin::onContentLoaded()
251			*/
252			public function onContentLoaded(&$rawContent)
253			{
254			$this->triggerEvent('after_load_content', array(&$this->requestFile, &$rawContent));
255			}
256
257			/**
258			* Triggers the deprecated before_404_load_content($file)
259			*
260			* @see DummyPlugin::on404ContentLoading()
261			*/
262			public function on404ContentLoading(&$file)
263			{
264			$this->triggerEvent('before_404_load_content', array(&$file));
265			}
266
267			/**
268			* Triggers the deprecated event after_404_load_content($file, $rawContent)
269			*
270			* @see DummyPlugin::on404ContentLoaded()
271			*/
272			public function on404ContentLoaded(&$rawContent)
273			{
274			$this->triggerEvent('after_404_load_content', array(&$this->requestFile, &$rawContent));
275			}
276
277			/**
278			* Triggers the deprecated event before_read_file_meta($headers)
279			*
280			* @see DummyPlugin::onMetaHeaders()
281			*/
282			public function onMetaHeaders(array &$headers)
283			{
284			$this->triggerEvent('before_read_file_meta', array(&$headers));
285			}
286
287			/**
288			* Triggers the deprecated event file_meta($meta)
289			*
290			* @see DummyPlugin::onMetaParsed()
291			*/
292			public function onMetaParsed(array &$meta)
293			{
294			$this->triggerEvent('file_meta', array(&$meta));
295			}
296
297			/**
298			* Triggers the deprecated event before_parse_content($rawContent)
299			*
300			* @see DummyPlugin::onContentParsing()
301			*/
302			public function onContentParsing(&$rawContent)
303			{
304			$this->triggerEvent('before_parse_content', array(&$rawContent));
305			}
306
307			/**
308			* Triggers the deprecated events after_parse_content($content) and
309			* content_parsed($content)
310			*
311			* @see DummyPlugin::onContentParsed()
312			*/
313			public function onContentParsed(&$content)
314			{
315			$this->triggerEvent('after_parse_content', array(&$content));
316
317			// deprecated since v0.8
318			$this->triggerEvent('content_parsed', array(&$content));
319			}
320
321			/**
322			* Triggers the deprecated event get_page_data($pages, $meta)
323			*
324			* @see DummyPlugin::onSinglePageLoaded()
325			*/
326			public function onSinglePageLoaded(array &$pageData)
327			{
328			$this->triggerEvent('get_page_data', array(&$pageData, $pageData['meta']));
329			}
330
331			/**
332			* Triggers the deprecated event
333			* get_pages($pages, $currentPage, $previousPage, $nextPage)
334			*
335			* Please note that the `get_pages()` event gets `$pages` passed without a
336			* array index. The index is rebuild later using either the `id` array key
337			* or is derived from the `url` array key. Duplicates are prevented by
338			* adding `~dup` when necessary.
339			*
340			* @see DummyPlugin::onPagesLoaded()
341			*/
342			public function onPagesLoaded(
343			array &$pages,
344			array &$currentPage = null,
345			array &$previousPage = null,
346			array &$nextPage = null
347			) {
348			// remove keys of pages array
349			$plainPages = array();
350			foreach ($pages as &$pageData) {
351			$plainPages[] = &$pageData;
352			}
353			unset($pageData);
354
355			$this->triggerEvent('get_pages', array(&$plainPages, &$currentPage, &$previousPage, &$nextPage));
356
357			// re-index pages array
358			$pages = array();
359			foreach ($plainPages as &$pageData) {
360			if (!isset($pageData['id'])) {
361			$urlPrefixLength = strlen($this->getBaseUrl()) + intval(!$this->isUrlRewritingEnabled());
362			$pageData['id'] = substr($pageData['url'], $urlPrefixLength);
363			}
364
365			// prevent duplicates
366			$id = $pageData['id'];
367			for ($i = 1; isset($pages[$id]); $i++) {
368			$id = $pageData['id'] . '~dup' . $i;
369			}
370
371			$pages[$id] = &$pageData;
372			}
373			}
374
375			/**
376			* Triggers the deprecated event before_twig_register()
377			*
378			* @see DummyPlugin::onTwigRegistration()
379			*/
380			public function onTwigRegistration()
381			{
382			$this->triggerEvent('before_twig_register');
383			}
384
385			/**
386			* Triggers the deprecated event before_render($twigVariables, $twig, $templateName)
387			*
388			* Please note that the `before_render()` event gets `$templateName` passed
389			* without its file extension. The file extension is later added again.
390			*
391			* @see DummyPlugin::onPageRendering()
392			*/
393			public function onPageRendering(Twig_Environment &$twig, array &$twigVariables, &$templateName)
394			{
395			// template name contains file extension since Pico 1.0
396			$fileExtension = '';
397			if (($fileExtensionPos = strrpos($templateName, '.')) !== false) {
398			$fileExtension = substr($templateName, $fileExtensionPos);
399			$templateName = substr($templateName, 0, $fileExtensionPos);
400			}
401
402			$this->triggerEvent('before_render', array(&$twigVariables, &$twig, &$templateName));
403
404			// add original file extension
405			$templateName = $templateName . $fileExtension;
406			}
407
408			/**
409			* Triggers the deprecated event after_render($output)
410			*
411			* @see DummyPlugin::onPageRendered()
412			*/
413			public function onPageRendered(&$output)
414			{
415			$this->triggerEvent('after_render', array(&$output));
416			}
417
418			/**
419			* Triggers a deprecated event on all plugins
420			*
421			* Deprecated events are also triggered on plugins which implement
422			* {@link PicoPluginInterface}. Please note that the methods are called
423			* directly and not through {@link PicoPluginInterface::handleEvent()}.
424			*
425			* @param string $eventName event to trigger
426			* @param array $params parameters to pass
427			* @return void
428			*/
429			protected function triggerEvent($eventName, array $params = array())
430			{
431			foreach ($this->getPlugins() as $plugin) {
432			if (method_exists($plugin, $eventName)) {
433			call_user_func_array(array($plugin, $eventName), $params);
434			}
435			}
436			}
437			}
438

theshka / Pico

PicoDeprecated::on404ContentLoading() A last analyzed 2016-01-26 15:10 UTC

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like

PicoDeprecated::on404ContentLoading() A
last analyzed 2016-01-26 15:10 UTC