ResourceLoader::getRelativeResourcePath() - Code Metrics - Inspection of "API: ResourceLoader: Drop findThemedX in favour of..." - sminnee/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — resourceloader ( fc8821...2b8874 )

by Sam

created 2017-06-27 00:36 UTC

ResourceLoader::getRelativeResourcePath() B

↳ Parent: ResourceLoader

Complexity

Conditions	5
Paths	6

Size

Total Lines	18
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	9
nc	6
nop	2
dl	0
loc	18
rs	8.8571
c	0
b	0
f	0

<?php

namespace SilverStripe\Core\Manifest;

// TO DO: allow pluggable provider of client URLs and move that plugin to SilverStripe\Control.
use SilverStripe\Control\Director;

/**
 * Finds resources from 1 or more themes/modules.
 */
class ResourceLoader
{

    /**
     * @var ResourceLoader
     */
    private static $instance;

    protected $base;

    /**
     * List of template "sets" that contain a test manifest, and have an alias.
     * E.g. '$default'
     *
     * @var ThemeList[]
     */
    protected $sets = [];

    /**
     * @return ResourceLoader
     */
    public static function inst()
    {
        return self::$instance ? self::$instance : self::$instance = new self();
    }

    /**
     * Set instance
     *
     * @param ResourceLoader $instance
     */
    public static function set_instance(ResourceLoader $instance)
    {
        self::$instance = $instance;
    }

    public function __construct($base = null)
    {
        $this->base = $base ? $base : BASE_PATH;
    }

    /**
     * Add a new theme manifest for a given identifier. E.g. '$default'
     *
     * @param string $set
     * @param ThemeList $manifest
     */
    public function addSet($set, ThemeList $manifest)
    {
        $this->sets[$set] = $manifest;
    }

    /**
     * Get a named theme set
     *
     * @param string $set
     * @return ThemeList
     */
    public function getSet($set)
    {
        if (isset($this->sets[$set])) {
            return $this->sets[$set];
        }
        return null;
    }

    /**
     * Returns the absolute path to the given resource.
     *
     * @param string|array $module 1 or more modules or themes to searrh
     * @return string|null The absolute path to the file, if it exists. Returns null if the file can't be found
     */
    public function getResourcePath($module, $resource)
    {
        $path = $this->getRelativeResourcePath($module, $resource);
        if ($path) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return $this->base . '/' . $path;
        }
    }

    /**
     * Returns the URL of the given resource.
     *
     * The URL will be relative to the domain root, unless assets are on a different path (not currently supported but
     * may be added in the future.
     *
     * @param string|array $module A module or list of modules to
     * @return string|null The URL of the resource, if it exists
     */
    public function getResourceURL($module, $resource)
    {
        $path = $this->getRelativeResourcePath($module, $resource);
        if ($path) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return Director::baseURL() . $path;
        }
    }

    /**
     * Returns the path to the given resource, relative to BASE_PATH
     *
     * @param string|array $module 1 or more modules or themes to searrh
     * @return string|null The absolute path to the file, if it exists. Returns null if the file can't be found
     */
    public function getRelativeResourcePath($module, $resource)
    {
        if ($resource[0] !== '/') {
            $resource = '/' . $resource;
        }

        $paths = $this->getThemePaths(is_array($module) ? $module : [$module]);

        foreach ($paths as $themePath) {
            $abspath = $themePath;
            if (file_exists(BASE_PATH . '/' . $abspath . $resource)) {
                return $themePath . $resource;
            }
        }

        // Resource exists in no context
        return null;
    }

    /**
     * Given a theme identifier, determine the path from the root directory
     *
     * The mapping from $identifier to path follows these rules:
     * - A simple theme name ('mytheme') which maps to the standard themes dir (/themes/mytheme)
     * - A theme path with a leading slash ('/mymodule/themes/mytheme') which maps directly to that path.
     * - or a vendored theme path. (vendor/mymodule:mytheme) which maps to the nested 'theme' within
     *   that module. ('/mymodule/themes/mytheme').
     * - A vendored module with no nested theme (vendor/mymodule) which maps to the root directory
     *   of that module. ('/mymodule').
     *
     * @param string $identifier Theme identifier.
     * @return string Path from root, not including leading or trailing forward slash. E.g. themes/mytheme
     */
    public function getThemePath($identifier)
    {
        $slashPos = strpos($identifier, '/');

        // If identifier starts with "/", it's a path from root
        if ($slashPos === 0) {
            return substr($identifier, 1);
        } // Otherwise if there is a "/", identifier is a vendor'ed module
        elseif ($slashPos !== false) {
            // Extract from <vendor>/<module>:<theme> format.
            // <vendor> is optional, and if <theme> is omitted it defaults to the module root dir.
            // If <theme> is included, this is the name of the directory under moduleroot/themes/
            // which contains the theme.
            // <module> is always the name of the install directory, not necessarily the composer name.
            $parts = explode(':', $identifier, 2);

            if (count($parts) > 1) {
                $theme = $parts[1];
                // "module/vendor:/sub/path"
                if ($theme[0] === '/') {
                    $subpath = $theme;

                // "module/vendor:subtheme"
                } else {
                    $subpath = '/themes/' . $theme;
                }

            // "module/vendor"
            } else {
                $subpath = '';
            }

            $package = $parts[0];

            // Find matching module for this package
            $module = ModuleLoader::inst()->getManifest()->getModule($package);
            if ($module) {
                $modulePath = $module->getRelativePath();
            } else {
                // fall back to dirname
                list(, $modulePath) = explode('/', $parts[0], 2);

                // If the module is in the themes/<module>/ prefer that
                if (is_dir(THEMES_PATH . '/' .$modulePath)) {
                    $modulePath = THEMES_DIR . '/' . $$modulePath;
                }
            }

            return ltrim($modulePath . $subpath, '/');
        } // Otherwise it's a (deprecated) old-style "theme" identifier
        else {
            return THEMES_DIR.'/'.$identifier;
        }
    }

    /**
     * Attempts to find possible candidate templates from a set of template
     * names from modules, current theme directory and finally the application
     * folder.
     *
     * The template names can be passed in as plain strings, or be in the
     * format "type/name", where type is the type of template to search for
     * (e.g. Includes, Layout).
     *
     * @param string|array $template Template name, or template spec in array format with the keys
     * 'type' (type string) and 'templates' (template hierarchy in order of precedence).
     * If 'templates' is ommitted then any other item in the array will be treated as the template
     * list, or list of templates each in the array spec given.
     * Templates with an .ss extension will be treated as file paths, and will bypass
     * theme-coupled resolution.
     * @param array $themes List of themes to use to resolve themes. In most cases
     * you should pass in {@see SSViewer::get_themes()}
     * @return string Absolute path to resolved template file, or null if not resolved.
     * File location will be in the format themes/<theme>/templates/<directories>/<type>/<basename>.ss
     * Note that type (e.g. 'Layout') is not the root level directory under 'templates'.
     */
    public function findTemplate($template, $themes)
    {
        $type = '';
        if (is_array($template)) {
            // Check if templates has type specified
            if (array_key_exists('type', $template)) {
                $type = $template['type'];
                unset($template['type']);
            }
            // Templates are either nested in 'templates' or just the rest of the list
            $templateList = array_key_exists('templates', $template) ? $template['templates'] : $template;
        } else {
            $templateList = array($template);
        }

        foreach ($templateList as $i => $template) {
            // Check if passed list of templates in array format
            if (is_array($template)) {
                $path = $this->findTemplate($template, $themes);
                if ($path) {
                    return $path;
                }
                continue;
            }

            // If we have an .ss extension, this is a path, not a template name. We should
            // pass in templates without extensions in order for template manifest to find
            // files dynamically.
            if (substr($template, -3) == '.ss' && file_exists($template)) {
                return $template;
            }

            // Check string template identifier
            $template = str_replace('\\', '/', $template);
            $parts = explode('/', $template);

            $tail = array_pop($parts);
            $head = implode('/', $parts);

            $themePaths = $this->getThemePaths($themes);
            foreach ($themePaths as $themePath) {
                // Join path
                $pathParts = [ $this->base, $themePath, 'templates', $head, $type, $tail ];
                $path = implode('/', array_filter($pathParts)) . '.ss';
                if (file_exists($path)) {
                    return $path;
                }
            }
        }

        // No template found
        return null;
    }

    /**
     * Resolve all themes to the list of root folders relative to site root
     *
     * @param array $themes List of themes to resolve. Supports named theme sets.
     * @return array List of root-relative folders in order of precendence.
     */
    public function getThemePaths($themes)
    {
        $paths = [];
        foreach ($themes as $themename) {
            // Expand theme sets
            $set = $this->getSet($themename);
            $subthemes = $set ? $set->getThemes() : [$themename];

            // Resolve paths
            foreach ($subthemes as $theme) {
                $paths[] = $this->getThemePath($theme);
            }
        }
        return $paths;
    }
}


1			<?php
2
3			namespace SilverStripe\Core\Manifest;
4
5			// TO DO: allow pluggable provider of client URLs and move that plugin to SilverStripe\Control.
6			use SilverStripe\Control\Director;
7
8			/**
9			* Finds resources from 1 or more themes/modules.
10			*/
11			class ResourceLoader
12			{
13
14			/**
15			* @var ResourceLoader
16			*/
17			private static $instance;
18
19			protected $base;
20
21			/**
22			* List of template "sets" that contain a test manifest, and have an alias.
23			* E.g. '$default'
24			*
25			* @var ThemeList[]
26			*/
27			protected $sets = [];
28
29			/**
30			* @return ResourceLoader
31			*/
32			public static function inst()
33			{
34			return self::$instance ? self::$instance : self::$instance = new self();
35			}
36
37			/**
38			* Set instance
39			*
40			* @param ResourceLoader $instance
41			*/
42			public static function set_instance(ResourceLoader $instance)
43			{
44			self::$instance = $instance;
45			}
46
47			public function __construct($base = null)
48			{
49			$this->base = $base ? $base : BASE_PATH;
50			}
51
52			/**
53			* Add a new theme manifest for a given identifier. E.g. '$default'
54			*
55			* @param string $set
56			* @param ThemeList $manifest
57			*/
58			public function addSet($set, ThemeList $manifest)
59			{
60			$this->sets[$set] = $manifest;
61			}
62
63			/**
64			* Get a named theme set
65			*
66			* @param string $set
67			* @return ThemeList
68			*/
69			public function getSet($set)
70			{
71			if (isset($this->sets[$set])) {
72			return $this->sets[$set];
73			}
74			return null;
75			}
76
77			/**
78			* Returns the absolute path to the given resource.
79			*
80			* @param string\|array $module 1 or more modules or themes to searrh
81			* @return string\|null The absolute path to the file, if it exists. Returns null if the file can't be found
82			*/
83			public function getResourcePath($module, $resource)
84			{
85			$path = $this->getRelativeResourcePath($module, $resource);
86			if ($path) {
			0 ignored issues – show Bug Best Practice introduced 2017-06-26 22:43 UTC by Report Bug Copy Issue Report The expression `$path` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
87			return $this->base . '/' . $path;
88			}
89			}
90
91			/**
92			* Returns the URL of the given resource.
93			*
94			* The URL will be relative to the domain root, unless assets are on a different path (not currently supported but
95			* may be added in the future.
96			*
97			* @param string\|array $module A module or list of modules to
98			* @return string\|null The URL of the resource, if it exists
99			*/
100			public function getResourceURL($module, $resource)
101			{
102			$path = $this->getRelativeResourcePath($module, $resource);
103			if ($path) {
			0 ignored issues – show Bug Best Practice introduced 2017-06-26 22:43 UTC by Report Bug Copy Issue Report The expression `$path` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
104			return Director::baseURL() . $path;
105			}
106			}
107
108			/**
109			* Returns the path to the given resource, relative to BASE_PATH
110			*
111			* @param string\|array $module 1 or more modules or themes to searrh
112			* @return string\|null The absolute path to the file, if it exists. Returns null if the file can't be found
113			*/
114			public function getRelativeResourcePath($module, $resource)
115			{
116			if ($resource[0] !== '/') {
117			$resource = '/' . $resource;
118			}
119
120			$paths = $this->getThemePaths(is_array($module) ? $module : [$module]);
121
122			foreach ($paths as $themePath) {
123			$abspath = $themePath;
124			if (file_exists(BASE_PATH . '/' . $abspath . $resource)) {
125			return $themePath . $resource;
126			}
127			}
128
129			// Resource exists in no context
130			return null;
131			}
132
133			/**
134			* Given a theme identifier, determine the path from the root directory
135			*
136			* The mapping from $identifier to path follows these rules:
137			* - A simple theme name ('mytheme') which maps to the standard themes dir (/themes/mytheme)
138			* - A theme path with a leading slash ('/mymodule/themes/mytheme') which maps directly to that path.
139			* - or a vendored theme path. (vendor/mymodule:mytheme) which maps to the nested 'theme' within
140			* that module. ('/mymodule/themes/mytheme').
141			* - A vendored module with no nested theme (vendor/mymodule) which maps to the root directory
142			* of that module. ('/mymodule').
143			*
144			* @param string $identifier Theme identifier.
145			* @return string Path from root, not including leading or trailing forward slash. E.g. themes/mytheme
146			*/
147			public function getThemePath($identifier)
148			{
149			$slashPos = strpos($identifier, '/');
150
151			// If identifier starts with "/", it's a path from root
152			if ($slashPos === 0) {
153			return substr($identifier, 1);
154			} // Otherwise if there is a "/", identifier is a vendor'ed module
155			elseif ($slashPos !== false) {
156			// Extract from <vendor>/<module>:<theme> format.
157			// <vendor> is optional, and if <theme> is omitted it defaults to the module root dir.
158			// If <theme> is included, this is the name of the directory under moduleroot/themes/
159			// which contains the theme.
160			// <module> is always the name of the install directory, not necessarily the composer name.
161			$parts = explode(':', $identifier, 2);
162
163			if (count($parts) > 1) {
164			$theme = $parts[1];
165			// "module/vendor:/sub/path"
166			if ($theme[0] === '/') {
167			$subpath = $theme;
168
169			// "module/vendor:subtheme"
170			} else {
171			$subpath = '/themes/' . $theme;
172			}
173
174			// "module/vendor"
175			} else {
176			$subpath = '';
177			}
178
179			$package = $parts[0];
180
181			// Find matching module for this package
182			$module = ModuleLoader::inst()->getManifest()->getModule($package);
183			if ($module) {
184			$modulePath = $module->getRelativePath();
185			} else {
186			// fall back to dirname
187			list(, $modulePath) = explode('/', $parts[0], 2);
188
189			// If the module is in the themes/<module>/ prefer that
190			if (is_dir(THEMES_PATH . '/' .$modulePath)) {
191			$modulePath = THEMES_DIR . '/' . $$modulePath;
192			}
193			}
194
195			return ltrim($modulePath . $subpath, '/');
196			} // Otherwise it's a (deprecated) old-style "theme" identifier
197			else {
198			return THEMES_DIR.'/'.$identifier;
199			}
200			}
201
202			/**
203			* Attempts to find possible candidate templates from a set of template
204			* names from modules, current theme directory and finally the application
205			* folder.
206			*
207			* The template names can be passed in as plain strings, or be in the
208			* format "type/name", where type is the type of template to search for
209			* (e.g. Includes, Layout).
210			*
211			* @param string\|array $template Template name, or template spec in array format with the keys
212			* 'type' (type string) and 'templates' (template hierarchy in order of precedence).
213			* If 'templates' is ommitted then any other item in the array will be treated as the template
214			* list, or list of templates each in the array spec given.
215			* Templates with an .ss extension will be treated as file paths, and will bypass
216			* theme-coupled resolution.
217			* @param array $themes List of themes to use to resolve themes. In most cases
218			* you should pass in {@see SSViewer::get_themes()}
219			* @return string Absolute path to resolved template file, or null if not resolved.
220			* File location will be in the format themes/<theme>/templates/<directories>/<type>/<basename>.ss
221			* Note that type (e.g. 'Layout') is not the root level directory under 'templates'.
222			*/
223			public function findTemplate($template, $themes)
224			{
225			$type = '';
226			if (is_array($template)) {
227			// Check if templates has type specified
228			if (array_key_exists('type', $template)) {
229			$type = $template['type'];
230			unset($template['type']);
231			}
232			// Templates are either nested in 'templates' or just the rest of the list
233			$templateList = array_key_exists('templates', $template) ? $template['templates'] : $template;
234			} else {
235			$templateList = array($template);
236			}
237
238			foreach ($templateList as $i => $template) {
239			// Check if passed list of templates in array format
240			if (is_array($template)) {
241			$path = $this->findTemplate($template, $themes);
242			if ($path) {
243			return $path;
244			}
245			continue;
246			}
247
248			// If we have an .ss extension, this is a path, not a template name. We should
249			// pass in templates without extensions in order for template manifest to find
250			// files dynamically.
251			if (substr($template, -3) == '.ss' && file_exists($template)) {
252			return $template;
253			}
254
255			// Check string template identifier
256			$template = str_replace('\\', '/', $template);
257			$parts = explode('/', $template);
258
259			$tail = array_pop($parts);
260			$head = implode('/', $parts);
261
262			$themePaths = $this->getThemePaths($themes);
263			foreach ($themePaths as $themePath) {
264			// Join path
265			$pathParts = [ $this->base, $themePath, 'templates', $head, $type, $tail ];
266			$path = implode('/', array_filter($pathParts)) . '.ss';
267			if (file_exists($path)) {
268			return $path;
269			}
270			}
271			}
272
273			// No template found
274			return null;
275			}
276
277			/**
278			* Resolve all themes to the list of root folders relative to site root
279			*
280			* @param array $themes List of themes to resolve. Supports named theme sets.
281			* @return array List of root-relative folders in order of precendence.
282			*/
283			public function getThemePaths($themes)
284			{
285			$paths = [];
286			foreach ($themes as $themename) {
287			// Expand theme sets
288			$set = $this->getSet($themename);
289			$subthemes = $set ? $set->getThemes() : [$themename];
290
291			// Resolve paths
292			foreach ($subthemes as $theme) {
293			$paths[] = $this->getThemePath($theme);
294			}
295			}
296			return $paths;
297			}
298			}
299

sminnee / silverstripe-framework

Push — resourceloader ( fc8821...2b8874 )

ResourceLoader::getRelativeResourcePath() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like