* renaming php directory

1 files changed, 572 insertions, 0 deletions

diff --git a/app/frontend/web/ClientScriptManager.php b/app/frontend/web/ClientScriptManager.php
new file mode 100644
index 0000000..223c6e2
--- /dev/null
+++ b/app/frontend/web/ClientScriptManager.php
@@ -0,0 +1,572 @@
+<?php
+
+Prado::using('Application.layouts.Layout');
+
+class ClientScriptManager extends TClientScriptManager {
+
+    private $_page;
+    public function __construct(TPage $page) {
+        $this->_page = $page;
+        parent::__construct($page);
+    }
+
+    // Base path of the entire application
+    private function _getBasePath() {
+        return Prado::getPathOfNamespace('Web');
+    }
+
+    // Translate URLs to filesystem paths, index return array by URLs
+    private function _getBasePaths(array $urls) {
+        $basePath = $this->_getBasePath();
+        return array_combine(
+            $urls,
+            array_map(
+                function($path) use($basePath) {
+                    return $basePath . DIRECTORY_SEPARATOR . $path;
+                },
+                $urls
+            )
+        );
+    }
+
+    // Base cache path, suffixed with subdirectory, create on demand
+    private function _getCachePath(string $subdir = 'assets') {
+        $cachePath = $this->Application->RuntimePath
+            . DIRECTORY_SEPARATOR
+            . $subdir;
+        if (!is_dir($cachePath)) {
+            if (file_exists($cachePath)) {
+                throw new TIOException(
+                    sprintf(
+                        'Client script manager cache path "%s" exists and is not a directory',
+                        $cachePath
+                    )
+                );
+            } else {
+                mkdir($cachePath);
+            }
+        }
+        return $cachePath;
+    }
+
+    // Cache path for a file of specified type
+    private function _getCacheFilePath($path, $type) {
+        return $this->_getCachePath($type)
+            . DIRECTORY_SEPARATOR
+            . $path;
+    }
+
+    // Cache key for specific file set, including current theme
+    private function _getFileCollectionCacheKey(array $files) {
+        sort($files);
+        if ($this->_page->Theme) {
+            $files[] = $this->_page->Theme->Name;
+        }
+        return md5(implode(PHP_EOL, $files));
+    }
+
+    // Last modification time of a file set
+    private function _getFileCollectionMTime(array $files) {
+        return max(array_map('filemtime', $files));
+    }
+
+    // Storage (application cache) key for list of rendered assets of specified type
+    // Rendered[ASSET_TYPE].[VIEW_ID] (VIEW_ID as rendered in Layout hidden field)
+    private function _getRenderedAssetsStoreKey($type) {
+        $template = $this->_page->Master;
+        if (!$template instanceof Layout) {
+            throw new TNotSupportedException(
+                'Compiled assets may only be used within Layout master class controls'
+            );
+        }
+        return sprintf('Rendered%s.%s', $type, $template->generateViewID());
+    }
+
+    // Shorthand for JS assets cache key
+    private function _getRenderedScriptsStoreKey() {
+        return $this->_getRenderedAssetsStoreKey('Scripts');
+    }
+
+    // Shorthand for CSS assets cache key
+    private function _getRenderedSheetsStoreKey() {
+        return $this->_getRenderedAssetsStoreKey('Sheets');
+    }
+
+    // Application (primary) cache module, required to keep track of assets rendered on current page
+    private function _getCache() {
+        $cache = $this->Application->Cache;
+        if (!$cache) {
+            throw new TNotSupportedException(
+                'Compiled assets require cache to be configured'
+            );
+        }
+        return $cache;
+    }
+
+    // Check cache file validity, comparing to source file set
+    private function _isCacheValid($cacheFile, array $paths) {
+        return file_exists($cacheFile)
+            && (filemtime($cacheFile) >= $this->_getFileCollectionMTime($paths));
+    }
+
+    // Determine whether specific URL points to a local asset (i.e. existing on the filesystem)
+    private function _isFileLocal($file) {
+        $basePath = $this->_getBasePath();
+        return file_exists($basePath . DIRECTORY_SEPARATOR . $file);
+    }
+
+    // Filter URL set to leave only local assets
+    private function _determineLocalFiles($files) {
+        return array_filter(
+            $files, [$this, '_isFileLocal']
+        );
+    }
+
+    // Scripts - internal methods
+
+    private $_renderedScriptsInitialized = FALSE;
+
+    // Retrieve scripts already rendered on current page from application cache,
+    // maintaining the state over callbacks
+    private function _getRenderedScripts() {
+        $sessionKey = $this->_getRenderedScriptsStoreKey();
+        if ($this->_page->IsCallBack || $this->_renderedScriptsInitialized) {
+            return $this->_getCache()->get($sessionKey) ?: [];
+        } else {
+            $this->_getCache()->delete($sessionKey);
+            $this->_renderedScriptsInitialized = TRUE;
+            return [];
+        }
+    }
+
+    // Store information on rendered scripts in application cache
+    private function _appendRenderedScripts(array $newScripts, $compiledFileKey) {
+        $scripts = $this->_getRenderedScripts();
+        if (!isset($scripts[$compiledFileKey])) {
+            $scripts[$compiledFileKey] = [];
+        }
+        $scripts[$compiledFileKey] = array_unique(
+            array_merge(
+                $scripts[$compiledFileKey],
+                $newScripts
+            )
+        );
+        $this->_getCache()->set(
+            $this->_getRenderedScriptsStoreKey(),
+            $scripts
+        );
+    }
+
+    // Compress JS file and return its content
+    private function _getCompressedScript($path) {
+        return trim(TJavaScript::JSMin(
+            file_get_contents($path)
+        ));
+    }
+
+    // Join multiple script files into single asset, mark all of them as rendered in parent
+    private function _compileScriptFiles(array $files) {
+        foreach ($files as $file) {
+            $this->markScriptFileAsRendered($file);
+        }
+        $paths = $this->_getBasePaths($files);
+        $cacheFile = $this->_getCacheFilePath(
+            $this->_getFileCollectionCacheKey($paths) . '.js',
+            'scripts'
+        );
+        $this->_appendRenderedScripts($files, $cacheFile);
+        if (!$this->_isCacheValid($cacheFile, $paths)) {
+            $scriptContent = implode(
+                PHP_EOL,
+                array_map(
+                    [$this, '_getCompressedScript'],
+                    $paths
+                )
+            );
+            file_put_contents($cacheFile, $scriptContent);
+        }
+        return $this->Application->AssetManager->publishFilePath($cacheFile);
+    }
+
+    // Write output tag for a single, compiled JS asset, consisting of multiple local assets
+    private function _renderLocalScriptFiles(THtmlWriter $writer, array $localFiles) {
+        if ($localFiles) {
+            $assetPath = $this->_compileScriptFiles($localFiles);
+            $writer->write(TJavascript::renderScriptFile($assetPath));
+        }
+    }
+
+    // Keep track of external JS scripts rendered on the page
+    private function _renderExternalScriptFiles(THtmlWriter $writer, array $externalFiles) {
+        if ($externalFiles) {
+            foreach ($externalFiles as $file) {
+                $this->markScriptFileAsRendered($file);
+                $this->_appendRenderedScripts([$file], $file);
+            }
+            parent::renderScriptFiles($writer, $externalFiles);
+        }
+    }
+
+    // Determine actual asset URL that a source JS file was rendered as (after compilation/compression)
+    // FALSE means script wasn't rendered at all (i.e. was just registered in current callback)
+    private function _getRenderedScriptUrl($registeredScript) {
+        $renderedScripts = $this->_getRenderedScripts();
+        foreach ($renderedScripts as $compiledFile => $scripts) {
+            if (in_array($registeredScript, $scripts)) {
+                if (file_exists($compiledFile)) {
+                    return $this->Application->AssetManager->getPublishedUrl(
+                        $compiledFile
+                    );
+                } else {
+                    return $registeredScript;
+                }
+            }
+        }
+        return FALSE;
+    }
+
+    // Scripts - public interface overrides
+
+    // In application modes "higher" than Debug, compile JS assets to as few files as possible
+    public function renderScriptFiles($writer, Array $files) {
+        if ($this->getApplication()->getMode() !== TApplicationMode::Debug) {
+            if ($files) {
+                $localFiles = $this->_determineLocalFiles($files);
+                $this->_renderLocalScriptFiles($writer, $localFiles);
+                $externalFiles = array_diff($files, $localFiles);
+                $this->_renderExternalScriptFiles($writer, $externalFiles);
+            }
+        } else {
+            parent::renderScriptFiles($writer, $files);
+        }
+    }
+
+    // When above compilation occurs, list of JS URLs a callback requires
+    // significantly deviates from parent implementation.
+    // Also, new scripts that have been registered in current callback may need compiling, too.
+    public function getScriptUrls() {
+        if ($this->getApplication()->getMode() !== TApplicationMode::Debug) {
+            $registeredScripts = array_unique(
+                array_merge(
+                    $this->_scripts, $this->_headScripts
+                )
+            );
+            $scriptUrls = [];
+            $newScripts = [];
+            foreach ($registeredScripts as $registeredScript) {
+                $renderedScriptUrl = $this->_getRenderedScriptUrl($registeredScript);
+                if ($renderedScriptUrl) {
+                    $scriptUrls[] = $renderedScriptUrl;
+                } else {
+                    $newScripts[] = $registeredScript;
+                }
+            }
+            $newLocalScripts = $this->_determineLocalFiles($newScripts);
+            $newRemoteScripts = array_diff($newScripts, $newLocalScripts);
+            if ($newLocalScripts) {
+                $scriptUrls[] = $this->_compileScriptFiles($newLocalScripts);
+            }
+            $scriptUrls = array_values(
+                array_unique(array_merge($scriptUrls, $newRemoteScripts))
+            );
+            return $scriptUrls;
+        }
+        return parent::getScriptUrls();
+    }
+
+    private $_scripts = [];
+    private $_headScripts = [];
+
+    // Keep track of what we're registering
+    public function registerScriptFile($key, $file) {
+        $this->_scripts[$key] = $file;
+        return parent::registerScriptFile($key, $file);
+    }
+
+    // Keep track of what we're registering
+    public function registerHeadScriptFile($key, $file) {
+        $this->_headScripts[$key] = $file;
+        return parent::registerHeadScriptFile($key, $file);
+    }
+
+    // Stylesheets - internal methods
+
+    private $_renderedSheetsInitialized = FALSE;
+
+    // Retrieve stylesheets already rendered on current page from application cache,
+    // maintaining the state over callbacks
+    private function _getRenderedSheets() {
+        $sessionKey = $this->_getRenderedSheetsStoreKey();
+        if ($this->_page->IsCallBack || $this->_renderedSheetsInitialized) {
+            return $this->_getCache()->get($sessionKey) ?: [];
+        } else {
+            $this->_getCache()->delete($sessionKey);
+            $this->_renderedSheetsInitialized = TRUE;
+            return [];
+        }
+    }
+
+    // Store information on rendered stylesheets in application cache
+    private function _appendRenderedSheets(array $newSheets, $compiledFileKey) {
+        $sheets = $this->_getRenderedSheets();
+        if (!isset($sheets[$compiledFileKey])) {
+            $sheets[$compiledFileKey] = [];
+        }
+        $sheets[$compiledFileKey] = array_merge(
+            $sheets[$compiledFileKey],
+            $newSheets
+        );
+        $this->_getCache()->set(
+            $this->_getRenderedSheetsStoreKey(),
+            $sheets
+        );
+    }
+
+    // Resolve all "url(FILE)" CSS directives pointing
+    // to relative resources to specified path
+    private function _fixStyleSheetPaths($content, $originalUrl) {
+        $originalDir = dirname($originalUrl . '.');
+        return preg_replace_callback(
+            '/url\s*\([\'"]?(.*?)[\'"]?\)/',
+            function($matches) use($originalDir) {
+                $url = parse_url($matches[1]);
+                // ignore absolute URLs and paths
+                if (isset($url['scheme'])
+                    || isset($url['host'])
+                    || $url['path'][0] == '/') {
+                    return $matches[0];
+                }
+                // resolve relative paths
+                return str_replace(
+                    $matches[1],
+                    $originalDir . '/' . $matches[1],
+                    $matches[0]
+                );
+            },
+            $content
+        );
+    }
+
+    // Compress CSS file and return its content
+    private function _getCompressedSheet($origPath, $path) {
+        Prado::using('Lib.cssmin.CssMin');
+        return trim(CssMin::minify(
+            $this->_fixStyleSheetPaths(
+                file_get_contents($path),
+                $origPath
+            )
+        ));
+    }
+
+    // Join multiple stylesheet files into single asset
+    private function _compileSheetFiles(array $files) {
+        $paths = $this->_getBasePaths(
+            array_map('reset', $files)
+        );
+        // determine if file was registered as a themed sheet
+        $correctedPaths = [];
+        foreach ($paths as $url => $path) {
+            $correctedPaths[
+                in_array($url, $this->_themeStyles) && $this->_page->Theme
+                ? $this->_page->Theme->BaseUrl . DIRECTORY_SEPARATOR
+                : $url
+            ] = $path;
+        }
+        $cacheFile = $this->_getCacheFilePath(
+            $this->_getFileCollectionCacheKey($paths) . '.css',
+            'styles'
+        );
+        $this->_appendRenderedSheets($files, $cacheFile);
+        if (!$this->_isCacheValid($cacheFile, $paths)) {
+            $styleContent = implode(
+                PHP_EOL,
+                array_map(
+                    [$this, '_getCompressedSheet'],
+                    array_keys($correctedPaths),
+                    $correctedPaths
+                )
+            );
+            file_put_contents($cacheFile, $styleContent);
+        }
+        return $this->Application->AssetManager->publishFilePath($cacheFile);
+    }
+
+    // Filter only local stylesheet file entries
+    private function _determineLocalSheetFiles(array $files) {
+        $basePath = $this->_getBasePath();
+        return array_filter(
+            $files,
+            function($file) use($basePath) {
+                return file_exists($basePath . DIRECTORY_SEPARATOR . $file[0]);
+            }
+        );
+    }
+
+    // Write HTML markup for CSS stylesheet
+    private function _renderSheetFileTag(THtmlWriter $writer, $href, $media) {
+        $writer->addAttribute('rel', 'stylesheet');
+        $writer->addAttribute('type', 'text/css');
+        $writer->addAttribute('media', $media);
+        $writer->addAttribute('href', $href);
+        $writer->renderBeginTag('link');
+        $writer->write(PHP_EOL);
+    }
+
+    // Group registered local CSS assets by media query string and render markup for compiled sheets
+    private function _renderLocalSheetFiles(THtmlWriter $writer, array $localFiles) {
+        if ($localFiles) {
+            $fileTypes = [];
+            foreach ($localFiles as $file) {
+                $type = $file[1] ?: 'all';
+                if (!isset($fileTypes[$type])) {
+                    $fileTypes[$type] = [];
+                }
+                $fileTypes[$type][] = $file;
+            }
+            foreach ($fileTypes as $type => $files) {
+                $assetPath = $this->_compileSheetFiles($files);
+                $this->_renderSheetFileTag($writer, $assetPath, $type);
+            }
+        }
+    }
+
+    // Render markup for external stylesheets
+    private function _renderExternalSheetFiles(THtmlWriter $writer, array $externalFiles) {
+        if ($externalFiles) {
+            foreach ($externalFiles as $file) {
+                $this->_appendRenderedSheets([$file], $file[0]);
+                $this->_renderSheetFileTag($writer, $file[0], $file[1] ?: 'all');
+            }
+        }
+    }
+
+    // Determine actual asset URL that a source CSS file was rendered as (after compilation/compression)
+    // FALSE means sheet wasn't rendered at all (i.e. was just registered in current callback)
+    // Media query types can easily be ignored in a callback request, only URLs matter
+    private function _getRenderedSheetUrl($registeredSheet) {
+        $renderedSheets = $this->_getRenderedSheets();
+        foreach ($renderedSheets as $compiledFile => $sheets) {
+            foreach ($sheets as $sheet) {
+                if ($registeredSheet[0] == $sheet[0]) {
+                    if (file_exists($compiledFile)) {
+                        return $this->Application->AssetManager->getPublishedUrl(
+                            $compiledFile
+                        );
+                    } else {
+                        return $registeredSheet[0];
+                    }
+                }
+            }
+        }
+        return FALSE;
+    }
+
+    // Stylesheets - public interface overrides
+
+    // In application modes "higher" than Debug, compile CSS assets to as few files as possible
+    public function renderStyleSheetFiles($writer) {
+        if ($this->getApplication()->getMode() !== TApplicationMode::Debug) {
+            $files = $this->_styles;
+            if ($files) {
+                $localFiles = $this->_determineLocalSheetFiles($files);
+                $this->_renderLocalSheetFiles($writer, $localFiles);
+                $externalFiles = array_diff_key($files, $localFiles);
+                $this->_renderExternalSheetFiles($writer, $externalFiles);
+            }
+        } else {
+            parent::renderStyleSheetFiles($writer);
+        }
+    }
+
+    // When above compilation occurs, list of CSS URLs a callback requires
+    // significantly deviates from parent implementation.
+    // New stylesheets may need compiling, as well.
+    public function getStyleSheetUrls() {
+        if ($this->getApplication()->getMode() !== TApplicationMode::Debug) {
+            $registeredSheets = $this->_styles;
+            $sheetUrls = [];
+            $newSheets = [];
+            foreach ($registeredSheets as $registeredSheet) {
+                $renderedSheetUrl = $this->_getRenderedSheetUrl(
+                    $registeredSheet
+                );
+                if ($renderedSheetUrl) {
+                    $sheetUrls[] = $renderedSheetUrl;
+                } else {
+                    $newSheets[] = $registeredSheet;
+                }
+            }
+            $newLocalSheets = $this->_determineLocalSheetFiles($newSheets);
+            $newLocalUrls = array_map('reset', $newLocalSheets);
+            $newRemoteSheets = array_filter(
+                $newSheets,
+                function($sheet) use($newLocalUrls) {
+                    return !in_array($sheet[0], $newLocalUrls);
+                }
+            );
+            $newRemoteUrls = array_map('reset', $newRemoteSheets);
+            if ($newLocalSheets) {
+                $sheetUrls[] = $this->_compileSheetFiles($newLocalSheets);
+            }
+            $sheetUrls = array_values(
+                array_unique(array_merge($sheetUrls, $newRemoteUrls))
+            );
+            return $sheetUrls;
+        }
+        // And even in Debug mode, theme sheets before fixing paths
+        // might also have been published via assets manager,
+        // so we have to discard these from parent list.
+        return array_diff(
+            parent::getStyleSheetUrls(),
+            $this->_fixedStyleFiles
+        );
+    }
+
+    private $_styles = [];
+
+    // Keep track of what we're registering
+    public function registerStyleSheetFile($key, $file, $media = '') {
+        $this->_styles[$key] = [$file, $media];
+        return parent::registerStyleSheetFile($key, $file, $media ?: 'all');
+    }
+
+    private $_themeStyles = [];
+    private $_fixedStyleFiles = [];
+
+    // New method, automatically corrects URLs within stylesheet to current page theme
+    // when sheets are not compiled (when they are, it's done on compilation anyways).
+    // Such files are rewritten (not in place, though) and registered so that they don't show up
+    // within published assets returned from asset manager, as they don't end up in the markup.
+    public function registerThemeStyleSheetFile($key, $file, $media = '') {
+        if ($this->getApplication()->getMode() !== TApplicationMode::Debug) {
+            $this->_themeStyles[$key] = $file;
+        } else {
+            if ($this->_isFileLocal($file) && $this->_page->Theme) {
+                $tempFile = $this->_getCacheFilePath(
+                    $this->_getFileCollectionCacheKey([
+                        $this->_getBasePath()
+                        . DIRECTORY_SEPARATOR
+                        . $file
+                    ])
+                    . '.' . basename($file),
+                    $this->_page->Theme->Name
+                );
+                file_put_contents(
+                    $tempFile,
+                    $this->_fixStyleSheetPaths(
+                        file_get_contents(
+                            $this->_getBasePath() . DIRECTORY_SEPARATOR . $file
+                        ),
+                        $this->_page->Theme->BaseUrl . DIRECTORY_SEPARATOR
+                    )
+                );
+                $this->_fixedStyleFiles[] = $file;
+                $file = $this->Application->AssetManager->publishFilePath($tempFile);
+            }
+        }
+        return $this->registerStyleSheetFile($key, $file, $media ?: 'all');
+    }
+
+}
+
+?>