Page::getFolder() - Code Metrics - Inspection of "Clean code" - Cecilapp/Cecil - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature-output-formats ( 98428a...998147 )

by Arnaud

created 2019-02-27 16:00 UTC

Page::getFolder() A

↳ Parent: Page

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
/*
 * Copyright (c) Arnaud Ligny <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cecil\Collection\Page;

use Cecil\Collection\Item;
use Cecil\Config;
use Cecil\Util;
use Cocur\Slugify\Slugify;
use Symfony\Component\Finder\SplFileInfo;

/**
 * Class Page.
 */
class Page extends Item
{
    const SLUGIFY_PATTERN = '/(^\/|[^_a-z0-9\/]|-)+/';

    /**
     * @var SplFileInfo|null
     */
    protected $file;
    /**
     * @var bool
     */
    protected $virtual = false;
    /**
     * @var string
     */
    protected $type;
    /**
     * @var string
     */
    protected $folder;
    /**
     * @var string
     */
    protected $slug;
    /**
     * @var string
     */
    protected $path;
    /**
     * @var string
     */
    protected $section;
    /**
     * @var string
     */
    protected $frontmatter;
    /**
     * @var string
     */
    protected $body;
    /**
     * @var string
     */
    protected $html;

    /**
     * Constructor.
     *
     * @param SplFileInfo|null $file
     */
    public function __construct(SplFileInfo $file = null)
    {
        $this->file = $file;

        // physical page
        if ($this->file instanceof SplFileInfo) {
            /*
             * File path components
             */
            // ie: content/Blog/Post 1.md
            //             |    |      └─ fileExtension
            //             |    └─ fileName
            //             └─ filePath
            $fileExtension = pathinfo($this->file, PATHINFO_EXTENSION);
            $filePath = str_replace(DIRECTORY_SEPARATOR, '/', $this->file->getRelativePath());
            $fileName = $this->file->getBasename('.'.$fileExtension);
            // filePathname = filePath + '/' + fileName
            // ie: content/Blog/Post 1.md -> "Blog/Post 1"
            // ie: content/index.md -> "index"
            // ie: content/Blog/index.md -> "Blog/"
            $filePathname = ($filePath ? $filePath.'/' : '')
                .($filePath && $fileName == 'index' ? '' : $fileName);
            /*
             * Set properties
             *
             * id = path = folder / slug
             */
            $this->folder = $this->slugify($filePath); // ie: "blog"
            $this->slug = $this->slugify(Prefix::subPrefix($fileName)); // ie: "post-1"
            $this->path = $this->slugify(Prefix::subPrefix($filePathname)); // ie: "blog/post-1"
            $this->id = $this->path;
            /*
             * Set protected variables
             */
            $this->setSection(explode('/', $this->folder)[0]); // ie: "blog"
            /*
             * Set overridable variables
             */
            $this->setVariable('title', Prefix::subPrefix($fileName)); // ie: "Post 1"
            $this->setVariable('date', $this->file->getCTime());
            $this->setVariable('updated', $this->file->getMTime());
            $this->setVariable('weight', null);
            // special case: file has a prefix
            if (Prefix::hasPrefix($filePathname)) {
                // prefix is a valid date?
                if (Util::isValidDate(Prefix::getPrefix($filePathname))) {
                    $this->setVariable('date', (string) Prefix::getPrefix($filePathname));
                } else {
                    // prefix is an integer, use for sorting
                    $this->setVariable('weight', (int) Prefix::getPrefix($filePathname));
                }
            }
            // physical file relative path
            $this->setVariable('filepath', $this->file->getRelativePathname());

            parent::__construct($this->id);
        } else {
            // virtual page
            $this->virtual = true;
            // default variables
            $this->setVariables([
                'title'    => 'Page Title',
                'date'     => time(),
                'updated'  => time(),
                'weight'   => null,
                'filepath' => null,
            ]);

            parent::__construct();
        }
        // required
        $this->setType(Type::PAGE);
        $this->setVariables([
            'published'        => true,
            'virtual'          => $this->virtual,
            'content_template' => 'page.content.twig',
        ]);
    }

    /**
     * Parse file content.
     *
     * @return self
     */
    public function parse(): self
    {
        $parser = new Parser($this->file);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        $parsed = $parser->parse();
        $this->frontmatter = $parsed->getFrontmatter();
        $this->body = $parsed->getBody();

        return $this;
    }

    /**
     * Get frontmatter.
     *
     * @return string|null
     */
    public function getFrontmatter(): ?string
    {
        return $this->frontmatter;
    }

    /**
     * Get body as raw.
     *
     * @return string
     */
    public function getBody(): ?string
    {
        return $this->body;
    }

    /**
     * Turn a path (string) into a slug (URL).
     *
     * @param string $path
     *
     * @return string
     */
    public static function slugify(string $path): string
    {
        return Slugify::create([
            'regexp' => self::SLUGIFY_PATTERN,
        ])->slugify($path);
    }

    /**
     * Is current page is virtual?
     *
     * @return bool
     */
    public function isVirtual(): bool
    {
        return $this->virtual;
    }

    /**
     * Set page type.
     *
     * @param string $type
     *
     * @return self
     */
    public function setType(string $type): self
    {
        $this->type = new Type($type);


        return $this;
    }

    /**
     * Get page type.
     *
     * @return string|null
     */
    public function getType(): ?string
    {
        return $this->type;
    }

    /**
     * Set slug.
     *
     * @param string $slug
     *
     * @return self
     */
    public function setSlug(string $slug): self
    {
        $this->slug = $slug;

        return $this;
    }

    /**
     * Get slug.
     *
     * @return string|null
     */
    public function getSlug(): ?string
    {
        return $this->slug;
    }

    /**
     * Set path without slug.
     *
     * @param $folder
     *
     * @return self
     */
    public function setFolder(string $folder): self
    {
        $this->folder = $folder;

        return $this;
    }

    /**
     * Get path without slug.
     *
     * @return string|null
     */
    public function getFolder(): ?string
    {
        return $this->folder;
    }

    /**
     * Set path.
     *
     * @param string $path
     *
     * @return self
     */
    public function setPath(string $path): self
    {
        $this->path = $path;

        return $this;
    }

    /**
     * Get path.
     *
     * @return string|null
     */
    public function getPath(): ?string
    {
        // special case: homepage
        if ($this->path == 'index'
            || (\strlen($this->path) >= 6
            && substr_compare($this->path, 'index/', 0, 6) == 0)) {
            $this->path = '';
        }

        return $this->path;
    }

    /**
     * Backward compatibility.
     */
    public function getPathname()
    {
        return $this->getPath();
    }

    /**
     * Set section.
     *
     * @param string $section
     *
     * @return self
     */
    public function setSection(string $section): self
    {
        $this->section = $section;

        return $this;
    }

    /**
     * Get section.
     *
     * @return string|null
     */
    public function getSection(): ?string
    {
        if (empty($this->section) && !empty($this->folder)) {
            $this->setSection(explode('/', $this->folder)[0]);
        }

        return $this->section;
    }

    /**
     * Set body as HTML.
     *
     * @param string $html
     *
     * @return self
     */
    public function setBodyHtml(string $html): self
    {
        $this->html = $html;

        return $this;
    }

    /**
     * Get body as HTML.
     *
     * @return string|null
     */
    public function getBodyHtml(): ?string
    {
        return $this->html;
    }

    /**
     * @see getBodyHtml()
     *
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->getBodyHtml();
    }

    /**
     * Return output file.
     *
     * Use cases:
     *   - default: path + suffix + extension (ie: blog/post-1/index.html)
     *   - subpath: path + subpath + suffix + extension (ie: blog/post-1/amp/index.html)
     *   - ugly: path + extension (ie: 404.html, sitemap.xml, robots.txt)
     *   - path only (ie: _redirects)
     *
     * @param string $format
     * @param Config $config

     *
     * @return string
     */
    public function getOutputFile(string $format, Config $config = null): string
    {
        $path = $this->getPath();
        $subpath = '';
        $suffix = '/index';
        $extension = 'html';
        $uglyurl = $this->getVariable('uglyurl') ? true : false;

        // site config
        if ($config) {
            $subpath = $config->get(sprintf('site.output.formats.%s.subpath', $format));
            $suffix = $config->get(sprintf('site.output.formats.%s.suffix', $format));
            $extension = $config->get(sprintf('site.output.formats.%s.extension', $format));
        }
        // if ugly URL: not suffix
        if ($uglyurl) {
            $suffix = '';
        }
        // format strings
        if ($subpath) {
            $subpath = sprintf('/%s', ltrim($subpath, '/'));
        }
        if ($suffix) {
            $suffix = sprintf('/%s', ltrim($suffix, '/'));
        }
        if ($extension) {
            $extension = sprintf('.%s', $extension);
        }
        // special case: homepage
        if (!$path && !$suffix) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $path = 'index';
        }

        return $path.$subpath.$suffix.$extension;
    }

    /**
     * Return URL.
     *
     * @param string $format
     * @param Config $config

     *
     * @return string
     */
    public function getUrl(string $format = 'html', Config $config = null): string
    {
        $uglyurl = $this->getVariable('uglyurl') ? true : false;
        $output = $this->getOutputFile($format, $config);

        if (!$uglyurl) {
            $output = str_replace('index.html', '', $output);
        }

        return $output;
    }

    /*
     * Helper to set and get variables.
     */

    /**
     * Set an array as variables.
     *
     * @param array $variables
     *
     * @throws \Exception
     *
     * @return $this
     */
    public function setVariables($variables)
    {
        if (!is_array($variables)) {
            throw new \Exception('Can\'t set variables: parameter is not an array');
        }
        foreach ($variables as $key => $value) {
            $this->setVariable($key, $value);
        }

        return $this;
    }

    /**
     * Get all variables.
     *
     * @return array
     */
    public function getVariables(): array
    {
        return $this->properties;
    }

    /**
     * Set a variable.
     *
     * @param $name
     * @param $value
     *
     * @throws \Exception
     *
     * @return $this
     */
    public function setVariable($name, $value)
    {
        if (is_bool($value)) {
            $value = $value ?: 0;
        }
        switch ($name) {
            case 'date':
                try {
                    if ($value instanceof \DateTime) {
                        $date = $value;
                    } else {
                        // timestamp
                        if (is_numeric($value)) {
                            $date = (new \DateTime())->setTimestamp($value);
                        } else {
                            // ie: 2019-01-01
                            if (is_string($value)) {
                                $date = new \DateTime($value);
                            }
                        }
                    }
                } catch (\Exception $e) {
                    throw new \Exception(sprintf('Expected date string for "date" in "%s": "%s"',
                        $this->getId(),
                        $value
                    ));
                }
                $this->offsetSet('date', $date);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                break;
            case 'draft':
                if ($value === true) {
                    $this->offsetSet('published', false);
                }
                break;
            case 'url':
                $slug = self::slugify($value);
                if ($value != $slug) {
                    throw new \Exception(sprintf(
                        "'url' variable should be '%s', not '%s', in page '%s'",
                        $slug,
                        $value,
                        $this->getId()
                    ));
                }
                break;
            default:
                $this->offsetSet($name, $value);
        }

        return $this;
    }

    /**
     * Is variable exist?
     *
     * @param $name
     *
     * @return bool
     */
    public function hasVariable($name)
    {
        return $this->offsetExists($name);
    }

    /**
     * Get a variable.
     *
     * @param string $name
     *
     * @return mixed|null
     */
    public function getVariable($name)
    {
        if ($this->offsetExists($name)) {
            return $this->offsetGet($name);
        }
    }

    /**
     * Unset a variable.
     *
     * @param $name
     *
     * @return $this
     */
    public function unVariable($name)
    {
        if ($this->offsetExists($name)) {
            $this->offsetUnset($name);
        }

        return $this;
    }
}


1			<?php
2			/*
3			* Copyright (c) Arnaud Ligny <[email protected]>
4			*
5			* For the full copyright and license information, please view the LICENSE
6			* file that was distributed with this source code.
7			*/
8
9			namespace Cecil\Collection\Page;
10
11			use Cecil\Collection\Item;
12			use Cecil\Config;
13			use Cecil\Util;
14			use Cocur\Slugify\Slugify;
15			use Symfony\Component\Finder\SplFileInfo;
16
17			/**
18			* Class Page.
19			*/
20			class Page extends Item
21			{
22			const SLUGIFY_PATTERN = '/(^\/\|[^_a-z0-9\/]\|-)+/';
23
24			/**
25			* @var SplFileInfo\|null
26			*/
27			protected $file;
28			/**
29			* @var bool
30			*/
31			protected $virtual = false;
32			/**
33			* @var string
34			*/
35			protected $type;
36			/**
37			* @var string
38			*/
39			protected $folder;
40			/**
41			* @var string
42			*/
43			protected $slug;
44			/**
45			* @var string
46			*/
47			protected $path;
48			/**
49			* @var string
50			*/
51			protected $section;
52			/**
53			* @var string
54			*/
55			protected $frontmatter;
56			/**
57			* @var string
58			*/
59			protected $body;
60			/**
61			* @var string
62			*/
63			protected $html;
64
65			/**
66			* Constructor.
67			*
68			* @param SplFileInfo\|null $file
69			*/
70			public function __construct(SplFileInfo $file = null)
71			{
72			$this->file = $file;
73
74			// physical page
75			if ($this->file instanceof SplFileInfo) {
76			/*
77			* File path components
78			*/
79			// ie: content/Blog/Post 1.md
80			// \| \| └─ fileExtension
81			// \| └─ fileName
82			// └─ filePath
83			$fileExtension = pathinfo($this->file, PATHINFO_EXTENSION);
84			$filePath = str_replace(DIRECTORY_SEPARATOR, '/', $this->file->getRelativePath());
85			$fileName = $this->file->getBasename('.'.$fileExtension);
86			// filePathname = filePath + '/' + fileName
87			// ie: content/Blog/Post 1.md -> "Blog/Post 1"
88			// ie: content/index.md -> "index"
89			// ie: content/Blog/index.md -> "Blog/"
90			$filePathname = ($filePath ? $filePath.'/' : '')
91			.($filePath && $fileName == 'index' ? '' : $fileName);
92			/*
93			* Set properties
94			*
95			* id = path = folder / slug
96			*/
97			$this->folder = $this->slugify($filePath); // ie: "blog"
98			$this->slug = $this->slugify(Prefix::subPrefix($fileName)); // ie: "post-1"
99			$this->path = $this->slugify(Prefix::subPrefix($filePathname)); // ie: "blog/post-1"
100			$this->id = $this->path;
101			/*
102			* Set protected variables
103			*/
104			$this->setSection(explode('/', $this->folder)[0]); // ie: "blog"
105			/*
106			* Set overridable variables
107			*/
108			$this->setVariable('title', Prefix::subPrefix($fileName)); // ie: "Post 1"
109			$this->setVariable('date', $this->file->getCTime());
110			$this->setVariable('updated', $this->file->getMTime());
111			$this->setVariable('weight', null);
112			// special case: file has a prefix
113			if (Prefix::hasPrefix($filePathname)) {
114			// prefix is a valid date?
115			if (Util::isValidDate(Prefix::getPrefix($filePathname))) {
116			$this->setVariable('date', (string) Prefix::getPrefix($filePathname));
117			} else {
118			// prefix is an integer, use for sorting
119			$this->setVariable('weight', (int) Prefix::getPrefix($filePathname));
120			}
121			}
122			// physical file relative path
123			$this->setVariable('filepath', $this->file->getRelativePathname());
124
125			parent::__construct($this->id);
126			} else {
127			// virtual page
128			$this->virtual = true;
129			// default variables
130			$this->setVariables([
131			'title' => 'Page Title',
132			'date' => time(),
133			'updated' => time(),
134			'weight' => null,
135			'filepath' => null,
136			]);
137
138			parent::__construct();
139			}
140			// required
141			$this->setType(Type::PAGE);
142			$this->setVariables([
143			'published' => true,
144			'virtual' => $this->virtual,
145			'content_template' => 'page.content.twig',
146			]);
147			}
148
149			/**
150			* Parse file content.
151			*
152			* @return self
153			*/
154			public function parse(): self
155			{
156			$parser = new Parser($this->file);
			0 ignored issues – show Bug introduced 2019-02-27 16:02 UTC by Report Bug Copy Issue Report It seems like `$this->file` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
157			$parsed = $parser->parse();
158			$this->frontmatter = $parsed->getFrontmatter();
159			$this->body = $parsed->getBody();
160
161			return $this;
162			}
163
164			/**
165			* Get frontmatter.
166			*
167			* @return string\|null
168			*/
169			public function getFrontmatter(): ?string
170			{
171			return $this->frontmatter;
172			}
173
174			/**
175			* Get body as raw.
176			*
177			* @return string
178			*/
179			public function getBody(): ?string
180			{
181			return $this->body;
182			}
183
184			/**
185			* Turn a path (string) into a slug (URL).
186			*
187			* @param string $path
188			*
189			* @return string
190			*/
191			public static function slugify(string $path): string
192			{
193			return Slugify::create([
194			'regexp' => self::SLUGIFY_PATTERN,
195			])->slugify($path);
196			}
197
198			/**
199			* Is current page is virtual?
200			*
201			* @return bool
202			*/
203			public function isVirtual(): bool
204			{
205			return $this->virtual;
206			}
207
208			/**
209			* Set page type.
210			*
211			* @param string $type
212			*
213			* @return self
214			*/
215			public function setType(string $type): self
216			{
217			$this->type = new Type($type);
			0 ignored issues – show Documentation Bug introduced 2019-02-23 15:43 UTC by Report Bug Copy Issue Report It seems like `new \Cecil\Collection\Page\Type($type)` of type `object<Cecil\Collection\Page\Type>` is incompatible with the declared type `string` of property `$type`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
218
219			return $this;
220			}
221
222			/**
223			* Get page type.
224			*
225			* @return string\|null
226			*/
227			public function getType(): ?string
228			{
229			return $this->type;
230			}
231
232			/**
233			* Set slug.
234			*
235			* @param string $slug
236			*
237			* @return self
238			*/
239			public function setSlug(string $slug): self
240			{
241			$this->slug = $slug;
242
243			return $this;
244			}
245
246			/**
247			* Get slug.
248			*
249			* @return string\|null
250			*/
251			public function getSlug(): ?string
252			{
253			return $this->slug;
254			}
255
256			/**
257			* Set path without slug.
258			*
259			* @param $folder
260			*
261			* @return self
262			*/
263			public function setFolder(string $folder): self
264			{
265			$this->folder = $folder;
266
267			return $this;
268			}
269
270			/**
271			* Get path without slug.
272			*
273			* @return string\|null
274			*/
275			public function getFolder(): ?string
276			{
277			return $this->folder;
278			}
279
280			/**
281			* Set path.
282			*
283			* @param string $path
284			*
285			* @return self
286			*/
287			public function setPath(string $path): self
288			{
289			$this->path = $path;
290
291			return $this;
292			}
293
294			/**
295			* Get path.
296			*
297			* @return string\|null
298			*/
299			public function getPath(): ?string
300			{
301			// special case: homepage
302			if ($this->path == 'index'
303			\|\| (\strlen($this->path) >= 6
304			&& substr_compare($this->path, 'index/', 0, 6) == 0)) {
305			$this->path = '';
306			}
307
308			return $this->path;
309			}
310
311			/**
312			* Backward compatibility.
313			*/
314			public function getPathname()
315			{
316			return $this->getPath();
317			}
318
319			/**
320			* Set section.
321			*
322			* @param string $section
323			*
324			* @return self
325			*/
326			public function setSection(string $section): self
327			{
328			$this->section = $section;
329
330			return $this;
331			}
332
333			/**
334			* Get section.
335			*
336			* @return string\|null
337			*/
338			public function getSection(): ?string
339			{
340			if (empty($this->section) && !empty($this->folder)) {
341			$this->setSection(explode('/', $this->folder)[0]);
342			}
343
344			return $this->section;
345			}
346
347			/**
348			* Set body as HTML.
349			*
350			* @param string $html
351			*
352			* @return self
353			*/
354			public function setBodyHtml(string $html): self
355			{
356			$this->html = $html;
357
358			return $this;
359			}
360
361			/**
362			* Get body as HTML.
363			*
364			* @return string\|null
365			*/
366			public function getBodyHtml(): ?string
367			{
368			return $this->html;
369			}
370
371			/**
372			* @see getBodyHtml()
373			*
374			* @return string\|null
375			*/
376			public function getContent(): ?string
377			{
378			return $this->getBodyHtml();
379			}
380
381			/**
382			* Return output file.
383			*
384			* Use cases:
385			* - default: path + suffix + extension (ie: blog/post-1/index.html)
386			* - subpath: path + subpath + suffix + extension (ie: blog/post-1/amp/index.html)
387			* - ugly: path + extension (ie: 404.html, sitemap.xml, robots.txt)
388			* - path only (ie: _redirects)
389			*
390			* @param string $format
391			* @param Config $config
			0 ignored issues – show Documentation introduced 2019-02-12 00:25 UTC by Report Bug Copy Issue Report Should the type for parameter `$config` not be `null\|Config`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
392			*
393			* @return string
394			*/
395			public function getOutputFile(string $format, Config $config = null): string
396			{
397			$path = $this->getPath();
398			$subpath = '';
399			$suffix = '/index';
400			$extension = 'html';
401			$uglyurl = $this->getVariable('uglyurl') ? true : false;
402
403			// site config
404			if ($config) {
405			$subpath = $config->get(sprintf('site.output.formats.%s.subpath', $format));
406			$suffix = $config->get(sprintf('site.output.formats.%s.suffix', $format));
407			$extension = $config->get(sprintf('site.output.formats.%s.extension', $format));
408			}
409			// if ugly URL: not suffix
410			if ($uglyurl) {
411			$suffix = '';
412			}
413			// format strings
414			if ($subpath) {
415			$subpath = sprintf('/%s', ltrim($subpath, '/'));
416			}
417			if ($suffix) {
418			$suffix = sprintf('/%s', ltrim($suffix, '/'));
419			}
420			if ($extension) {
421			$extension = sprintf('.%s', $extension);
422			}
423			// special case: homepage
424			if (!$path && !$suffix) {
			0 ignored issues – show Bug Best Practice introduced 2019-02-20 15:43 UTC by Report Bug Copy Issue Report The expression `$path` of type `string\|null` is loosely compared to `false`; 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...
425			$path = 'index';
426			}
427
428			return $path.$subpath.$suffix.$extension;
429			}
430
431			/**
432			* Return URL.
433			*
434			* @param string $format
435			* @param Config $config
			0 ignored issues – show Documentation introduced 2019-02-12 00:25 UTC by Report Bug Copy Issue Report Should the type for parameter `$config` not be `null\|Config`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
436			*
437			* @return string
438			*/
439			public function getUrl(string $format = 'html', Config $config = null): string
440			{
441			$uglyurl = $this->getVariable('uglyurl') ? true : false;
442			$output = $this->getOutputFile($format, $config);
443
444			if (!$uglyurl) {
445			$output = str_replace('index.html', '', $output);
446			}
447
448			return $output;
449			}
450
451			/*
452			* Helper to set and get variables.
453			*/
454
455			/**
456			* Set an array as variables.
457			*
458			* @param array $variables
459			*
460			* @throws \Exception
461			*
462			* @return $this
463			*/
464			public function setVariables($variables)
465			{
466			if (!is_array($variables)) {
467			throw new \Exception('Can\'t set variables: parameter is not an array');
468			}
469			foreach ($variables as $key => $value) {
470			$this->setVariable($key, $value);
471			}
472
473			return $this;
474			}
475
476			/**
477			* Get all variables.
478			*
479			* @return array
480			*/
481			public function getVariables(): array
482			{
483			return $this->properties;
484			}
485
486			/**
487			* Set a variable.
488			*
489			* @param $name
490			* @param $value
491			*
492			* @throws \Exception
493			*
494			* @return $this
495			*/
496			public function setVariable($name, $value)
497			{
498			if (is_bool($value)) {
499			$value = $value ?: 0;
500			}
501			switch ($name) {
502			case 'date':
503			try {
504			if ($value instanceof \DateTime) {
505			$date = $value;
506			} else {
507			// timestamp
508			if (is_numeric($value)) {
509			$date = (new \DateTime())->setTimestamp($value);
510			} else {
511			// ie: 2019-01-01
512			if (is_string($value)) {
513			$date = new \DateTime($value);
514			}
515			}
516			}
517			} catch (\Exception $e) {
518			throw new \Exception(sprintf('Expected date string for "date" in "%s": "%s"',
519			$this->getId(),
520			$value
521			));
522			}
523			$this->offsetSet('date', $date);
			0 ignored issues – show Bug introduced 2019-02-01 15:38 UTC by Report Bug Copy Issue Report The variable `$date` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
524			break;
525			case 'draft':
526			if ($value === true) {
527			$this->offsetSet('published', false);
528			}
529			break;
530			case 'url':
531			$slug = self::slugify($value);
532			if ($value != $slug) {
533			throw new \Exception(sprintf(
534			"'url' variable should be '%s', not '%s', in page '%s'",
535			$slug,
536			$value,
537			$this->getId()
538			));
539			}
540			break;
541			default:
542			$this->offsetSet($name, $value);
543			}
544
545			return $this;
546			}
547
548			/**
549			* Is variable exist?
550			*
551			* @param $name
552			*
553			* @return bool
554			*/
555			public function hasVariable($name)
556			{
557			return $this->offsetExists($name);
558			}
559
560			/**
561			* Get a variable.
562			*
563			* @param string $name
564			*
565			* @return mixed\|null
566			*/
567			public function getVariable($name)
568			{
569			if ($this->offsetExists($name)) {
570			return $this->offsetGet($name);
571			}
572			}
573
574			/**
575			* Unset a variable.
576			*
577			* @param $name
578			*
579			* @return $this
580			*/
581			public function unVariable($name)
582			{
583			if ($this->offsetExists($name)) {
584			$this->offsetUnset($name);
585			}
586
587			return $this;
588			}
589			}
590

Cecilapp / Cecil

Push — feature-output-formats ( 98428a...998147 )

Page::getFolder() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like