#246

Build # #246

Build Type

push

Committed by

Commit Message

<a href="https://github.com/bovigo/vfsStream/commit/<a class=hub.com/bovigo/vfsStream/commit/88f828f45f080898715aac33995f0f1e62cd2f4b">88f828f45<a href="https://github.com/bovigo/vfsStream/commit/88f828f45f080898715aac33995f0f1e62cd2f4b">">Merge </a><a class="double-link" href="https://github.com/bovigo/vfsStream/commit/<a class="double-link" href="https://github.com/bovigo/vfsStream/commit/9ba554b39188ea888d69c9951f41860ec2cac3c9">9ba554b39</a>">9ba554b39</a><a href="https://github.com/bovigo/vfsStream/commit/88f828f45f080898715aac33995f0f1e62cd2f4b"> into 751b3df1b">751b3df1b</a>

Run Details

379 of 379 new or added lines in 18 files covered. (100.0%)

821 of 888 relevant lines covered (92.45%)

65.77 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.11

/src/vfsDirectory.php

<?php

declare(strict_types=1);

/**
 * This file is part of vfsStream.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace bovigo\vfs;

use bovigo\vfs\internal\Type;
use Iterator;
use IteratorAggregate;
use function array_values;
use function class_alias;
use function count;
use function strlen;
use function strncmp;
use function substr;

/**
 * Directory container.
 *
 * @api
 */
class vfsDirectory extends BasicFile implements IteratorAggregate
{
    /**
     * list of directory children
     *
     * @var  BasicFile[]
     */
    private $children = [];
    /** @var  bool */
    private $isDot;
    /**
     * default directory permissions
     */
    public const DEFAULT_PERMISSIONS = 0777;

    /**
     * constructor
     *
     * @param   int|null $permissions optional
     */
    public function __construct(string $name, ?int $permissions = null)
    {
        parent::__construct($name, $permissions ?? (self::DEFAULT_PERMISSIONS & ~vfsStream::umask()));
        $this->isDot = $name === '.' || $name === '..';
    }

    /**
     * returns the type of the file
     */
    public function type(): int
    {
        return Type::DIR;
    }

    /**
     * returns size of directory
     *
     * The size of a directory is always 0 bytes. To calculate the summarized
     * size of all children in the directory use sizeSummarized().
     */
    public function size(): int
    {
        return 0;
    }

    /**
     * returns summarized size of directory and its children
     */
    public function sizeSummarized(): int
    {
        $size = 0;
        foreach ($this->children as $child) {
            if ($child instanceof self) {
                $size += $child->sizeSummarized();
            } else {
                $size += $child->size();
            }
        }

        return $size;
    }

    /**
     * checks whether the directory can be applied to given name
     */
    public function appliesTo(string $name): bool
    {
        if (parent::appliesTo($name)) {
            return true;
        }

        $segment_name = $this->name() . '/';

        return strncmp($segment_name, $name, strlen($segment_name)) === 0;
    }

    /**
     * adds directory to given directory
     */
    public function at(self $directory): self
    {
        $directory->addChild($this);

        return $this;
    }

    /**
     * sets parent path
     *
     * @internal  only to be set by parent
     *
     * @since   1.2.0
     */
    public function setParentPath(string $parentPath): void
    {
        parent::setParentPath($parentPath);
        foreach ($this->children as $child) {
            $child->setParentPath($this->path());
        }
    }

    /**
     * adds child to the directory
     */
    public function addChild(BasicFile $child): void
    {
        $child->setParentPath($this->path());
        $this->children[$child->name()] = $child;
        $this->updateModifications();
    }

    /**
     * removes child from the directory
     */
    public function removeChild(string $name): bool
    {
        foreach ($this->children as $key => $child) {
            if ($child->appliesTo($name)) {
                $child->removeParentPath();
                unset($this->children[$key]);
                $this->updateModifications();

                return true;
            }
        }

        return false;
    }

    /**
     * checks whether the container contains a child with the given name
     */
    public function hasChild(string $name): bool
    {
        return $this->getChild($name) !== null;
    }

    /**
     * returns the child with the given name
     */
    public function getChild(string $name): ?BasicFile
    {
        $childName = $this->getRealChildName($name);
        foreach ($this->children as $child) {
            if ($child->name() === $childName) {
                return $child;
            }

            if (! $child instanceof self) {
                continue;
            }

            if ($child->appliesTo($childName) && $child->hasChild($childName)) {
                return $child->getChild($childName);
            }
        }

        return null;
    }

    /**
     * helper method to detect the real child name
     */
    protected function getRealChildName(string $name): string
    {
        if ($this->appliesTo($name) === true) {
            return self::getChildName($name, $this->name());
        }

        return $name;
    }

    /**
     * helper method to calculate the child name
     */
    protected static function getChildName(string $name, string $ownName): string
    {
        if ($name === $ownName) {
            return $name;
        }

        return substr($name, strlen($ownName) + 1);
    }

    /**
     * checks whether directory contains any children
     *
     * @since   0.10.0
     */
    public function hasChildren(): bool
    {
        return count($this->children) > 0;
    }

    /**
     * returns a list of children for this directory
     *
     * @return  BasicFile[]
     */
    public function getChildren(): array
    {
        return array_values($this->children);
    }

    /**
     * returns iterator for the children
     *
     * @return  vfsDirectoryIterator
     */
    public function getIterator(): Iterator
    {
        return new vfsDirectoryIterator($this->children);
    }

    /**
     * checks whether dir is a dot dir
     */
    public function isDot(): bool
    {
        return $this->isDot;
    }
}

class_alias('bovigo\vfs\vfsDirectory', 'org\bovigo\vfs\vfsStreamDirectory');

1	<?php
2
3	declare(strict_types=1);
4
5	/**
6	* This file is part of vfsStream.
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	namespace bovigo\vfs;
13
14	use bovigo\vfs\internal\Type;
15	use Iterator;
16	use IteratorAggregate;
17	use function array_values;
18	use function class_alias;
19	use function count;
20	use function strlen;
21	use function strncmp;
22	use function substr;
23
24	/**
25	* Directory container.
26	*
27	* @api
28	*/
29	class vfsDirectory extends BasicFile implements IteratorAggregate
30	{
31	/**
32	* list of directory children
33	*
34	* @var BasicFile[]
35	*/
36	private $children = [];
37	/** @var bool */
38	private $isDot;
39	/**
40	* default directory permissions
41	*/
42	public const DEFAULT_PERMISSIONS = 0777;
43
44	/**
45	* constructor
46	*
47	* @param int\|null $permissions optional
48	*/
49	public function __construct(string $name, ?int $permissions = null)
50	{
51	parent::__construct($name, $permissions ?? (self::DEFAULT_PERMISSIONS & ~vfsStream::umask()));	405✔
52	$this->isDot = $name === '.' \|\| $name === '..';	405✔
53	}	405✔
54
55	/**
56	* returns the type of the file
57	*/
58	public function type(): int
59	{
60	return Type::DIR;	70✔
61	}
62
63	/**
64	* returns size of directory
65	*
66	* The size of a directory is always 0 bytes. To calculate the summarized
67	* size of all children in the directory use sizeSummarized().
68	*/
69	public function size(): int
70	{
71	return 0;	42✔
72	}
73
74	/**
75	* returns summarized size of directory and its children
76	*/
77	public function sizeSummarized(): int
78	{
79	$size = 0;	12✔
80	foreach ($this->children as $child) {	12✔
81	if ($child instanceof self) {	11✔
82	$size += $child->sizeSummarized();	4✔
83	} else {
84	$size += $child->size();	11✔
85	}
86	}
87
88	return $size;	12✔
89	}
90
91	/**
92	* checks whether the directory can be applied to given name
93	*/
94	public function appliesTo(string $name): bool
95	{
96	if (parent::appliesTo($name)) {	286✔
97	return true;	10✔
98	}
99
100	$segment_name = $this->name() . '/';	284✔
101
102	return strncmp($segment_name, $name, strlen($segment_name)) === 0;	284✔
103	}
104
105	/**
106	* adds directory to given directory
107	*/
108	public function at(self $directory): self
109	{
110	$directory->addChild($this);	268✔
111
112	return $this;	268✔
113	}
114
115	/**
116	* sets parent path
117	*
118	* @internal only to be set by parent
119	*
120	* @since 1.2.0
121	*/
122	public function setParentPath(string $parentPath): void
123	{
124	parent::setParentPath($parentPath);	270✔
125	foreach ($this->children as $child) {	270✔
126	$child->setParentPath($this->path());	19✔
127	}
128	}	270✔
129
130	/**
131	* adds child to the directory
132	*/
133	public function addChild(BasicFile $child): void
134	{
135	$child->setParentPath($this->path());	342✔
136	$this->children[$child->name()] = $child;	342✔
137	$this->updateModifications();	342✔
138	}	342✔
139
140	/**
141	* removes child from the directory
142	*/
143	public function removeChild(string $name): bool
144	{
145	foreach ($this->children as $key => $child) {	21✔
146	if ($child->appliesTo($name)) {	20✔
147	$child->removeParentPath();	20✔
148	unset($this->children[$key]);	20✔
149	$this->updateModifications();	20✔
150
151	return true;	20✔
152	}
153	}
154
155	return false;	1✔
156	}
157
158	/**
159	* checks whether the container contains a child with the given name
160	*/
161	public function hasChild(string $name): bool
162	{
163	return $this->getChild($name) !== null;	278✔
164	}
165
166	/**
167	* returns the child with the given name
168	*/
169	public function getChild(string $name): ?BasicFile
170	{
171	$childName = $this->getRealChildName($name);	281✔
172	foreach ($this->children as $child) {	281✔
173	if ($child->name() === $childName) {	275✔
174	return $child;	261✔
175	}
176
177	if (! $child instanceof self) {	191✔
178	continue;	90✔
179	}
180
181	if ($child->appliesTo($childName) && $child->hasChild($childName)) {	191✔
182	return $child->getChild($childName);	74✔
183	}
184	}
185
186	return null;	84✔
187	}
188
189	/**
190	* helper method to detect the real child name
191	*/
192	protected function getRealChildName(string $name): string
193	{
194	if ($this->appliesTo($name) === true) {	281✔
195	return self::getChildName($name, $this->name());	264✔
196	}
197
198	return $name;	95✔
199	}
200
201	/**
202	* helper method to calculate the child name
203	*/
204	protected static function getChildName(string $name, string $ownName): string
205	{
206	if ($name === $ownName) {	264✔
207	return $name;	1✔
208	}
209
210	return substr($name, strlen($ownName) + 1);	264✔
211	}
212
213	/**
214	* checks whether directory contains any children
215	*
216	* @since 0.10.0
217	*/
218	public function hasChildren(): bool
219	{
220	return count($this->children) > 0;	17✔
221	}
222
223	/**
224	* returns a list of children for this directory
225	*
226	* @return BasicFile[]
227	*/
228	public function getChildren(): array
229	{
230	return array_values($this->children);	8✔
231	}
232
233	/**
234	* returns iterator for the children
235	*
236	* @return vfsDirectoryIterator
237	*/
238	public function getIterator(): Iterator
239	{
240	return new vfsDirectoryIterator($this->children);	20✔
241	}
242
243	/**
244	* checks whether dir is a dot dir
245	*/
246	public function isDot(): bool
247	{
248	return $this->isDot;	3✔
249	}
250	}
251
252	class_alias('bovigo\vfs\vfsDirectory', 'org\bovigo\vfs\vfsStreamDirectory');	×

bovigo / vfsStream / #246

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous