IndexObject::equals() - Code Metrics - Inspection of "Bugfix" - storeman-io/storeman - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a8c5d7...b64b96 )

by Arne

created 2018-06-26 23:27 UTC

IndexObject::equals() B

↳ Parent: IndexObject

Complexity

Conditions	6
Paths	9

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	25
rs	8.8977
c	0
b	0
f	0
cc	6
nc	9
nop	2

<?php

namespace Storeman\Index;

use Storeman\Hash\HashContainer;

/**
 * An index object is the representation of one of this filesystem primitives contained in the index.
 */
class IndexObject
{
    public const TYPE_DIR = 1;
    public const TYPE_FILE = 2;
    public const TYPE_LINK = 3;

    public const CMP_IGNORE_BLOBID = 1;
    public const CMP_IGNORE_INODE = 2;


    /**
     * @var string
     */
    protected $relativePath;

    /**
     * @var int
     */
    protected $type;

    /**
     * @var int
     */
    protected $mtime;

    /**
     * @var int
     */
    protected $ctime;

    /**
     * mode & 0777
     *
     * @var int
     */
    protected $permissions;

    /**
     * @var int
     */
    protected $size;

    /**
     * @var int
     */
    protected $inode;

    /**
     * @var string
     */
    protected $linkTarget;

    /**
     * Content hashes for file index objects.
     *
     * @var HashContainer
     */
    protected $hashes;

    /**
     * @var string
     */
    protected $blobId;

    public function __construct(string $relativePath, int $type, int $mtime, int $ctime, int $permissions, ?int $size, ?int $inode, ?string $linkTarget, ?string $blobId, ?HashContainer $hashContainer)
    {
        assert(($type === static::TYPE_FILE) ^ ($size === null));
        assert(($type === static::TYPE_FILE) || ($blobId === null));
        assert(($type === static::TYPE_FILE) ^ ($hashContainer === null));
        assert(($type === static::TYPE_LINK) ^ ($linkTarget === null));
        assert(!($permissions & ~0777));

        $this->relativePath = $relativePath;
        $this->type = $type;
        $this->mtime = $mtime;
        $this->ctime = $ctime;
        $this->permissions = $permissions;
        $this->size = $size;
        $this->inode = $inode;
        $this->linkTarget = $linkTarget;
        $this->blobId = $blobId;
        $this->hashes = $hashContainer;
    }

    public function getRelativePath(): string
    {
        return $this->relativePath;
    }

    public function getBasename(): string
    {
        $pos = strrpos($this->relativePath, '/');

        return ($pos === false) ? $this->relativePath : substr($this->relativePath, $pos + 1);
    }

    public function getType(): int
    {
        return $this->type;
    }

    public function getTypeName(): string
    {
        return static::getTypeNameMap()[$this->type];
    }

    public function isDirectory(): bool
    {
        return $this->type === static::TYPE_DIR;
    }

    public function isFile(): bool
    {
        return $this->type === static::TYPE_FILE;
    }

    public function isLink(): bool
    {
        return $this->type === static::TYPE_LINK;
    }

    public function getMtime(): int
    {
        return $this->mtime;
    }

    public function getCtime(): int
    {
        return $this->ctime;
    }

    public function getPermissions(): int
    {
        return $this->permissions;
    }

    public function getPermissionsString(): string
    {
        return decoct($this->permissions);
    }

    public function getSize(): ?int
    {
        return $this->size;
    }

    public function getInode(): ?int
    {
        return $this->inode;
    }

    public function getLinkTarget(): ?string
    {
        return $this->linkTarget;
    }

    public function getHashes(): ?HashContainer
    {
        return $this->hashes;
    }

    public function getBlobId(): ?string
    {
        return $this->blobId;
    }

    public function setBlobId(string $blobId): IndexObject
    {
        $this->blobId = $blobId;

        return $this;
    }

    /**
     * Equality check with all attributes.
     *
     * @param IndexObject $other
     * @param int $options
     * @return bool
     */
    public function equals(?IndexObject $other, int $options = 0): bool
    {
        if ($other === null)
        {
            return false;
        }

        $equals = true;
        $equals &= $this->relativePath === $other->relativePath;
        $equals &= $this->type === $other->type;
        $equals &= $this->mtime === $other->mtime;
        $equals &= $this->ctime === $other->ctime;
        $equals &= $this->permissions === $other->permissions;
        $equals &= $this->size === $other->size;
        $equals &= ($options & static::CMP_IGNORE_INODE) || ($this->inode === $other->inode);
        $equals &= $this->linkTarget === $other->linkTarget;
        $equals &= ($options & static::CMP_IGNORE_BLOBID) || ($this->blobId === $other->blobId);

        if ($this->hashes && $other->hashes)
        {
            $equals &= $this->hashes->equals($other->hashes);
        }

        return $equals;
    }

    public function __toString(): string
    {
        $inode = $this->inode ?: '-';

        $parts = [
            $this->getTypeName(),
            "mtime: {$this->mtime}",
            "ctime: {$this->ctime}",
            "permissions: {$this->getPermissionsString()}",
            "inode: {$inode}"
        ];

        if ($this->isFile())
        {
            $blobId = $this->blobId ?: '-';

            $parts = array_merge($parts, [
                "size: {$this->size}",
                "blobId: {$blobId}",
            ]);
        }
        elseif ($this->isLink())
        {
            $parts = array_merge($parts, [
                "target: {$this->linkTarget}",
            ]);
        }

        $attributesString = implode(', ', $parts);

        return "{$this->relativePath} ({$attributesString})";
    }

    public static function getTypeNameMap(): array
    {
        return [
            static::TYPE_DIR => 'DIR',
            static::TYPE_FILE => 'FILE',
            static::TYPE_LINK => 'LINK',
        ];
    }
}


1			<?php
2
3			namespace Storeman\Index;
4
5			use Storeman\Hash\HashContainer;
6
7			/**
8			* An index object is the representation of one of this filesystem primitives contained in the index.
9			*/
10			class IndexObject
11			{
12			public const TYPE_DIR = 1;
13			public const TYPE_FILE = 2;
14			public const TYPE_LINK = 3;
15
16			public const CMP_IGNORE_BLOBID = 1;
17			public const CMP_IGNORE_INODE = 2;
18
19
20			/**
21			* @var string
22			*/
23			protected $relativePath;
24
25			/**
26			* @var int
27			*/
28			protected $type;
29
30			/**
31			* @var int
32			*/
33			protected $mtime;
34
35			/**
36			* @var int
37			*/
38			protected $ctime;
39
40			/**
41			* mode & 0777
42			*
43			* @var int
44			*/
45			protected $permissions;
46
47			/**
48			* @var int
49			*/
50			protected $size;
51
52			/**
53			* @var int
54			*/
55			protected $inode;
56
57			/**
58			* @var string
59			*/
60			protected $linkTarget;
61
62			/**
63			* Content hashes for file index objects.
64			*
65			* @var HashContainer
66			*/
67			protected $hashes;
68
69			/**
70			* @var string
71			*/
72			protected $blobId;
73
74			public function __construct(string $relativePath, int $type, int $mtime, int $ctime, int $permissions, ?int $size, ?int $inode, ?string $linkTarget, ?string $blobId, ?HashContainer $hashContainer)
75			{
76			assert(($type === static::TYPE_FILE) ^ ($size === null));
77			assert(($type === static::TYPE_FILE) \|\| ($blobId === null));
78			assert(($type === static::TYPE_FILE) ^ ($hashContainer === null));
79			assert(($type === static::TYPE_LINK) ^ ($linkTarget === null));
80			assert(!($permissions & ~0777));
81
82			$this->relativePath = $relativePath;
83			$this->type = $type;
84			$this->mtime = $mtime;
85			$this->ctime = $ctime;
86			$this->permissions = $permissions;
87			$this->size = $size;
88			$this->inode = $inode;
89			$this->linkTarget = $linkTarget;
90			$this->blobId = $blobId;
91			$this->hashes = $hashContainer;
92			}
93
94			public function getRelativePath(): string
95			{
96			return $this->relativePath;
97			}
98
99			public function getBasename(): string
100			{
101			$pos = strrpos($this->relativePath, '/');
102
103			return ($pos === false) ? $this->relativePath : substr($this->relativePath, $pos + 1);
104			}
105
106			public function getType(): int
107			{
108			return $this->type;
109			}
110
111			public function getTypeName(): string
112			{
113			return static::getTypeNameMap()[$this->type];
114			}
115
116			public function isDirectory(): bool
117			{
118			return $this->type === static::TYPE_DIR;
119			}
120
121			public function isFile(): bool
122			{
123			return $this->type === static::TYPE_FILE;
124			}
125
126			public function isLink(): bool
127			{
128			return $this->type === static::TYPE_LINK;
129			}
130
131			public function getMtime(): int
132			{
133			return $this->mtime;
134			}
135
136			public function getCtime(): int
137			{
138			return $this->ctime;
139			}
140
141			public function getPermissions(): int
142			{
143			return $this->permissions;
144			}
145
146			public function getPermissionsString(): string
147			{
148			return decoct($this->permissions);
149			}
150
151			public function getSize(): ?int
152			{
153			return $this->size;
154			}
155
156			public function getInode(): ?int
157			{
158			return $this->inode;
159			}
160
161			public function getLinkTarget(): ?string
162			{
163			return $this->linkTarget;
164			}
165
166			public function getHashes(): ?HashContainer
167			{
168			return $this->hashes;
169			}
170
171			public function getBlobId(): ?string
172			{
173			return $this->blobId;
174			}
175
176			public function setBlobId(string $blobId): IndexObject
177			{
178			$this->blobId = $blobId;
179
180			return $this;
181			}
182
183			/**
184			* Equality check with all attributes.
185			*
186			* @param IndexObject $other
187			* @param int $options
188			* @return bool
189			*/
190			public function equals(?IndexObject $other, int $options = 0): bool
191			{
192			if ($other === null)
193			{
194			return false;
195			}
196
197			$equals = true;
198			$equals &= $this->relativePath === $other->relativePath;
199			$equals &= $this->type === $other->type;
200			$equals &= $this->mtime === $other->mtime;
201			$equals &= $this->ctime === $other->ctime;
202			$equals &= $this->permissions === $other->permissions;
203			$equals &= $this->size === $other->size;
204			$equals &= ($options & static::CMP_IGNORE_INODE) \|\| ($this->inode === $other->inode);
205			$equals &= $this->linkTarget === $other->linkTarget;
206			$equals &= ($options & static::CMP_IGNORE_BLOBID) \|\| ($this->blobId === $other->blobId);
207
208			if ($this->hashes && $other->hashes)
209			{
210			$equals &= $this->hashes->equals($other->hashes);
211			}
212
213			return $equals;
214			}
215
216			public function __toString(): string
217			{
218			$inode = $this->inode ?: '-';
219
220			$parts = [
221			$this->getTypeName(),
222			"mtime: {$this->mtime}",
223			"ctime: {$this->ctime}",
224			"permissions: {$this->getPermissionsString()}",
225			"inode: {$inode}"
226			];
227
228			if ($this->isFile())
229			{
230			$blobId = $this->blobId ?: '-';
231
232			$parts = array_merge($parts, [
233			"size: {$this->size}",
234			"blobId: {$blobId}",
235			]);
236			}
237			elseif ($this->isLink())
238			{
239			$parts = array_merge($parts, [
240			"target: {$this->linkTarget}",
241			]);
242			}
243
244			$attributesString = implode(', ', $parts);
245
246			return "{$this->relativePath} ({$attributesString})";
247			}
248
249			public static function getTypeNameMap(): array
250			{
251			return [
252			static::TYPE_DIR => 'DIR',
253			static::TYPE_FILE => 'FILE',
254			static::TYPE_LINK => 'LINK',
255			];
256			}
257			}
258

storeman-io / storeman

Push — master ( a8c5d7...b64b96 )

IndexObject::equals() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like