AwsS3V3Adapter::fetchFileMetadata() - Code Metrics - Inspection of "Added test for rawlist connection checker." - thephpleague/flysystem-aws-s3-v3 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 2.x ( 741cb0...393be3 )

by Frank

created 2020-10-13 12:47 UTC

AwsS3V3Adapter::fetchFileMetadata() A

↳ Parent: AwsS3V3Adapter

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	9.6333
c	0
b	0
f	0
cc	3
nc	3
nop	2

<?php

declare(strict_types=1);

namespace League\Flysystem\AwsS3V3;

use Aws\Api\DateTimeResult;
use Aws\S3\S3ClientInterface;
use Generator;
use League\Flysystem\Config;
use League\Flysystem\DirectoryAttributes;
use League\Flysystem\FileAttributes;
use League\Flysystem\FilesystemAdapter;
use League\Flysystem\FilesystemOperationFailed;
use League\Flysystem\PathPrefixer;
use League\Flysystem\StorageAttributes;
use League\Flysystem\UnableToCheckFileExistence;
use League\Flysystem\UnableToCopyFile;
use League\Flysystem\UnableToDeleteFile;
use League\Flysystem\UnableToMoveFile;
use League\Flysystem\UnableToReadFile;
use League\Flysystem\UnableToRetrieveMetadata;
use League\Flysystem\UnableToSetVisibility;
use League\Flysystem\Visibility;
use League\MimeTypeDetection\FinfoMimeTypeDetector;
use League\MimeTypeDetection\MimeTypeDetector;
use Psr\Http\Message\StreamInterface;
use Throwable;

class AwsS3V3Adapter implements FilesystemAdapter
{
    /**
     * @var array
     */
    public const AVAILABLE_OPTIONS = [
        'ACL',
        'CacheControl',
        'ContentDisposition',
        'ContentEncoding',
        'ContentLength',
        'ContentType',
        'Expires',
        'GrantFullControl',
        'GrantRead',
        'GrantReadACP',
        'GrantWriteACP',
        'Metadata',
        'RequestPayer',
        'SSECustomerAlgorithm',
        'SSECustomerKey',
        'SSECustomerKeyMD5',
        'SSEKMSKeyId',
        'ServerSideEncryption',
        'StorageClass',
        'Tagging',
        'WebsiteRedirectLocation',
    ];
    private const EXTRA_METADATA_FIELDS = [
        'Metadata',
        'StorageClass',
        'ETag',
        'VersionId',
    ];

    /**
     * @var S3ClientInterface
     */
    private $client;

    /**
     * @var PathPrefixer
     */
    private $prefixer;

    /**
     * @var string
     */
    private $bucket;

    /**
     * @var VisibilityConverter
     */
    private $visibility;

    /**
     * @var MimeTypeDetector
     */
    private $mimeTypeDetector;

    /**
     * @var array
     */
    private $options;

    /**
     * @var bool
     */
    private $streamReads;

    public function __construct(
        S3ClientInterface $client,
        string $bucket,
        string $prefix = '',
        VisibilityConverter $visibility = null,
        MimeTypeDetector $mimeTypeDetector = null,
        array $options = [],
        bool $streamReads = true
    ) {
        $this->client = $client;
        $this->prefixer = new PathPrefixer($prefix);
        $this->bucket = $bucket;
        $this->visibility = $visibility ?: new PortableVisibilityConverter();
        $this->mimeTypeDetector = $mimeTypeDetector ?: new FinfoMimeTypeDetector();
        $this->options = $options;
        $this->streamReads = $streamReads;
    }

    public function fileExists(string $path): bool
    {
        try {
            return $this->client->doesObjectExist($this->bucket, $this->prefixer->prefixPath($path), $this->options);
        } catch (Throwable $exception) {
            throw UnableToCheckFileExistence::forLocation($path, $exception);
        }
    }

    public function write(string $path, string $contents, Config $config): void
    {
        $this->upload($path, $contents, $config);
    }

    /**
     * @param string          $path
     * @param string|resource $body
     * @param Config          $config
     */
    private function upload(string $path, $body, Config $config): void
    {
        $key = $this->prefixer->prefixPath($path);
        $acl = $this->determineAcl($config);
        $options = $this->createOptionsFromConfig($config);
        $shouldDetermineMimetype = $body !== '' && ! array_key_exists('ContentType', $options);

        if ($shouldDetermineMimetype && $mimeType = $this->mimeTypeDetector->detectMimeType($key, $body)) {
            $options['ContentType'] = $mimeType;
        }

        $this->client->upload($this->bucket, $key, $body, $acl, ['params' => $options]);
    }

    private function determineAcl(Config $config): string
    {
        $visibility = (string) $config->get(Config::OPTION_VISIBILITY, Visibility::PRIVATE);

        return $this->visibility->visibilityToAcl($visibility);
    }

    private function createOptionsFromConfig(Config $config): array
    {
        $options = [];

        foreach (static::AVAILABLE_OPTIONS as $option) {
            $value = $config->get($option, '__NOT_SET__');

            if ($value !== '__NOT_SET__') {
                $options[$option] = $value;
            }
        }

        return $options + $this->options;
    }

    public function writeStream(string $path, $contents, Config $config): void
    {
        $this->upload($path, $contents, $config);
    }

    public function read(string $path): string
    {
        $body = $this->readObject($path, false);

        return (string) $body->getContents();
    }

    public function readStream(string $path)
    {
        /** @var resource $resource */
        $resource = $this->readObject($path, true)->detach();

        return $resource;
    }

    public function delete(string $path): void
    {
        $arguments = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
        $command = $this->client->getCommand('DeleteObject', $arguments);

        try {
            $this->client->execute($command);
        } catch (Throwable $exception) {
            throw UnableToDeleteFile::atLocation($path, '', $exception);
        }
    }

    public function deleteDirectory(string $path): void
    {
        $prefix = $this->prefixer->prefixPath($path);
        $prefix = ltrim(rtrim($prefix, '/') . '/', '/');
        $this->client->deleteMatchingObjects($this->bucket, $prefix);
    }

    public function createDirectory(string $path, Config $config): void
    {
        $config = $config->withDefaults(['visibility' => $this->visibility->defaultForDirectories()]);
        $this->upload(rtrim($path, '/') . '/', '', $config);
    }

    public function setVisibility(string $path, $visibility): void
    {
        $arguments = [
            'Bucket' => $this->bucket,
            'Key' => $this->prefixer->prefixPath($path),
            'ACL' => $this->visibility->visibilityToAcl($visibility),
        ];
        $command = $this->client->getCommand('PutObjectAcl', $arguments);

        try {
            $this->client->execute($command);
        } catch (Throwable $exception) {
            throw UnableToSetVisibility::atLocation($path, '', $exception);
        }
    }

    public function visibility(string $path): FileAttributes
    {
        $arguments = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
        $command = $this->client->getCommand('GetObjectAcl', $arguments);

        try {
            $result = $this->client->execute($command);
        } catch (Throwable $exception) {
            throw UnableToRetrieveMetadata::visibility($path, '', $exception);
        }

        $visibility = $this->visibility->aclToVisibility((array) $result->get('Grants'));

        return new FileAttributes($path, null, $visibility);
    }

    private function fetchFileMetadata(string $path, string $type): FileAttributes
    {
        $arguments = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
        $command = $this->client->getCommand('HeadObject', $arguments);

        try {
            $result = $this->client->execute($command);
        } catch (Throwable $exception) {
            throw UnableToRetrieveMetadata::create($path, $type, '', $exception);
        }

        $attributes = $this->mapS3ObjectMetadata($result->toArray(), $path);

        if ( ! $attributes instanceof FileAttributes) {
            throw UnableToRetrieveMetadata::create($path, $type, '');
        }

        return $attributes;
    }

    private function mapS3ObjectMetadata(array $metadata, string $path = null): StorageAttributes
    {
        if ($path === null) {
            $path = $this->prefixer->stripPrefix($metadata['Key'] ?? $metadata['Prefix']);
        }

        if (substr($path, -1) === '/') {
            return new DirectoryAttributes(rtrim($path, '/'));
        }

        $mimetype = $metadata['ContentType'] ?? null;
        $fileSize = $metadata['ContentLength'] ?? $metadata['Size'] ?? null;
        $fileSize = $fileSize === null ? null : (int) $fileSize;
        $dateTime = $metadata['LastModified'] ?? null;
        $lastModified = $dateTime instanceof DateTimeResult ? $dateTime->getTimeStamp() : null;

        return new FileAttributes(
            $path, $fileSize, null, $lastModified, $mimetype, $this->extractExtraMetadata($metadata)
        );
    }

    private function extractExtraMetadata(array $metadata): array
    {
        $extracted = [];

        foreach (static::EXTRA_METADATA_FIELDS as $field) {
            if (isset($metadata[$field]) && $metadata[$field] !== '') {
                $extracted[$field] = $metadata[$field];
            }
        }

        return $extracted;
    }

    public function mimeType(string $path): FileAttributes
    {
        return $this->fetchFileMetadata($path, FileAttributes::ATTRIBUTE_MIME_TYPE);
    }

    public function lastModified(string $path): FileAttributes
    {
        return $this->fetchFileMetadata($path, FileAttributes::ATTRIBUTE_LAST_MODIFIED);
    }

    public function fileSize(string $path): FileAttributes
    {
        return $this->fetchFileMetadata($path, FileAttributes::ATTRIBUTE_FILE_SIZE);
    }

    public function listContents(string $path, bool $deep): iterable
    {
        $prefix = trim($this->prefixer->prefixPath($path), '/');
        $prefix = empty($prefix) ? '' : $prefix . '/';
        $options = ['Bucket' => $this->bucket, 'Prefix' => $prefix];

        if ($deep === false) {
            $options['Delimiter'] = '/';
        }

        $listing = $this->retrievePaginatedListing($options);

        foreach ($listing as $item) {
            yield $this->mapS3ObjectMetadata($item);
        }
    }

    private function retrievePaginatedListing(array $options): Generator
    {
        $resultPaginator = $this->client->getPaginator('ListObjects', $options + $this->options);

        foreach ($resultPaginator as $result) {
            yield from ($result->get('CommonPrefixes') ?: []);
            yield from ($result->get('Contents') ?: []);
        }
    }

    public function move(string $source, string $destination, Config $config): void
    {
        try {
            $this->copy($source, $destination, $config);
            $this->delete($source);
        } catch (FilesystemOperationFailed $exception) {
            throw UnableToMoveFile::fromLocationTo($source, $destination, $exception);
        }
    }

    public function copy(string $source, string $destination, Config $config): void
    {
        try {
            /** @var string $visibility */
            $visibility = $this->visibility($source)->visibility();
        } catch (Throwable $exception) {
            throw UnableToCopyFile::fromLocationTo(
                $source,
                $destination,
                $exception
            );
        }

        try {
            $this->client->copy(
                $this->bucket,
                $this->prefixer->prefixPath($source),
                $this->bucket,
                $this->prefixer->prefixPath($destination),
                $this->visibility->visibilityToAcl($visibility),
                $this->options
            );
        } catch (Throwable $exception) {
            throw UnableToCopyFile::fromLocationTo($source, $destination, $exception);
        }
    }

    private function readObject(string $path, bool $wantsStream): StreamInterface
    {
        $options = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];

        if ($wantsStream && $this->streamReads && ! isset($this->options['@http']['stream'])) {
            $options['@http']['stream'] = true;
        }

        $command = $this->client->getCommand('GetObject', $options + $this->options);

        try {
            return $this->client->execute($command)->get('Body');
        } catch (Throwable $exception) {
            throw UnableToReadFile::fromLocation($path, '', $exception);
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace League\Flysystem\AwsS3V3;
6
7			use Aws\Api\DateTimeResult;
8			use Aws\S3\S3ClientInterface;
9			use Generator;
10			use League\Flysystem\Config;
11			use League\Flysystem\DirectoryAttributes;
12			use League\Flysystem\FileAttributes;
13			use League\Flysystem\FilesystemAdapter;
14			use League\Flysystem\FilesystemOperationFailed;
15			use League\Flysystem\PathPrefixer;
16			use League\Flysystem\StorageAttributes;
17			use League\Flysystem\UnableToCheckFileExistence;
18			use League\Flysystem\UnableToCopyFile;
19			use League\Flysystem\UnableToDeleteFile;
20			use League\Flysystem\UnableToMoveFile;
21			use League\Flysystem\UnableToReadFile;
22			use League\Flysystem\UnableToRetrieveMetadata;
23			use League\Flysystem\UnableToSetVisibility;
24			use League\Flysystem\Visibility;
25			use League\MimeTypeDetection\FinfoMimeTypeDetector;
26			use League\MimeTypeDetection\MimeTypeDetector;
27			use Psr\Http\Message\StreamInterface;
28			use Throwable;
29
30			class AwsS3V3Adapter implements FilesystemAdapter
31			{
32			/**
33			* @var array
34			*/
35			public const AVAILABLE_OPTIONS = [
36			'ACL',
37			'CacheControl',
38			'ContentDisposition',
39			'ContentEncoding',
40			'ContentLength',
41			'ContentType',
42			'Expires',
43			'GrantFullControl',
44			'GrantRead',
45			'GrantReadACP',
46			'GrantWriteACP',
47			'Metadata',
48			'RequestPayer',
49			'SSECustomerAlgorithm',
50			'SSECustomerKey',
51			'SSECustomerKeyMD5',
52			'SSEKMSKeyId',
53			'ServerSideEncryption',
54			'StorageClass',
55			'Tagging',
56			'WebsiteRedirectLocation',
57			];
58			private const EXTRA_METADATA_FIELDS = [
59			'Metadata',
60			'StorageClass',
61			'ETag',
62			'VersionId',
63			];
64
65			/**
66			* @var S3ClientInterface
67			*/
68			private $client;
69
70			/**
71			* @var PathPrefixer
72			*/
73			private $prefixer;
74
75			/**
76			* @var string
77			*/
78			private $bucket;
79
80			/**
81			* @var VisibilityConverter
82			*/
83			private $visibility;
84
85			/**
86			* @var MimeTypeDetector
87			*/
88			private $mimeTypeDetector;
89
90			/**
91			* @var array
92			*/
93			private $options;
94
95			/**
96			* @var bool
97			*/
98			private $streamReads;
99
100			public function __construct(
101			S3ClientInterface $client,
102			string $bucket,
103			string $prefix = '',
104			VisibilityConverter $visibility = null,
105			MimeTypeDetector $mimeTypeDetector = null,
106			array $options = [],
107			bool $streamReads = true
108			) {
109			$this->client = $client;
110			$this->prefixer = new PathPrefixer($prefix);
111			$this->bucket = $bucket;
112			$this->visibility = $visibility ?: new PortableVisibilityConverter();
113			$this->mimeTypeDetector = $mimeTypeDetector ?: new FinfoMimeTypeDetector();
114			$this->options = $options;
115			$this->streamReads = $streamReads;
116			}
117
118			public function fileExists(string $path): bool
119			{
120			try {
121			return $this->client->doesObjectExist($this->bucket, $this->prefixer->prefixPath($path), $this->options);
122			} catch (Throwable $exception) {
123			throw UnableToCheckFileExistence::forLocation($path, $exception);
124			}
125			}
126
127			public function write(string $path, string $contents, Config $config): void
128			{
129			$this->upload($path, $contents, $config);
130			}
131
132			/**
133			* @param string $path
134			* @param string\|resource $body
135			* @param Config $config
136			*/
137			private function upload(string $path, $body, Config $config): void
138			{
139			$key = $this->prefixer->prefixPath($path);
140			$acl = $this->determineAcl($config);
141			$options = $this->createOptionsFromConfig($config);
142			$shouldDetermineMimetype = $body !== '' && ! array_key_exists('ContentType', $options);
143
144			if ($shouldDetermineMimetype && $mimeType = $this->mimeTypeDetector->detectMimeType($key, $body)) {
145			$options['ContentType'] = $mimeType;
146			}
147
148			$this->client->upload($this->bucket, $key, $body, $acl, ['params' => $options]);
149			}
150
151			private function determineAcl(Config $config): string
152			{
153			$visibility = (string) $config->get(Config::OPTION_VISIBILITY, Visibility::PRIVATE);
154
155			return $this->visibility->visibilityToAcl($visibility);
156			}
157
158			private function createOptionsFromConfig(Config $config): array
159			{
160			$options = [];
161
162			foreach (static::AVAILABLE_OPTIONS as $option) {
163			$value = $config->get($option, '__NOT_SET__');
164
165			if ($value !== '__NOT_SET__') {
166			$options[$option] = $value;
167			}
168			}
169
170			return $options + $this->options;
171			}
172
173			public function writeStream(string $path, $contents, Config $config): void
174			{
175			$this->upload($path, $contents, $config);
176			}
177
178			public function read(string $path): string
179			{
180			$body = $this->readObject($path, false);
181
182			return (string) $body->getContents();
183			}
184
185			public function readStream(string $path)
186			{
187			/** @var resource $resource */
188			$resource = $this->readObject($path, true)->detach();
189
190			return $resource;
191			}
192
193			public function delete(string $path): void
194			{
195			$arguments = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
196			$command = $this->client->getCommand('DeleteObject', $arguments);
197
198			try {
199			$this->client->execute($command);
200			} catch (Throwable $exception) {
201			throw UnableToDeleteFile::atLocation($path, '', $exception);
202			}
203			}
204
205			public function deleteDirectory(string $path): void
206			{
207			$prefix = $this->prefixer->prefixPath($path);
208			$prefix = ltrim(rtrim($prefix, '/') . '/', '/');
209			$this->client->deleteMatchingObjects($this->bucket, $prefix);
210			}
211
212			public function createDirectory(string $path, Config $config): void
213			{
214			$config = $config->withDefaults(['visibility' => $this->visibility->defaultForDirectories()]);
215			$this->upload(rtrim($path, '/') . '/', '', $config);
216			}
217
218			public function setVisibility(string $path, $visibility): void
219			{
220			$arguments = [
221			'Bucket' => $this->bucket,
222			'Key' => $this->prefixer->prefixPath($path),
223			'ACL' => $this->visibility->visibilityToAcl($visibility),
224			];
225			$command = $this->client->getCommand('PutObjectAcl', $arguments);
226
227			try {
228			$this->client->execute($command);
229			} catch (Throwable $exception) {
230			throw UnableToSetVisibility::atLocation($path, '', $exception);
231			}
232			}
233
234			public function visibility(string $path): FileAttributes
235			{
236			$arguments = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
237			$command = $this->client->getCommand('GetObjectAcl', $arguments);
238
239			try {
240			$result = $this->client->execute($command);
241			} catch (Throwable $exception) {
242			throw UnableToRetrieveMetadata::visibility($path, '', $exception);
243			}
244
245			$visibility = $this->visibility->aclToVisibility((array) $result->get('Grants'));
246
247			return new FileAttributes($path, null, $visibility);
248			}
249
250			private function fetchFileMetadata(string $path, string $type): FileAttributes
251			{
252			$arguments = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
253			$command = $this->client->getCommand('HeadObject', $arguments);
254
255			try {
256			$result = $this->client->execute($command);
257			} catch (Throwable $exception) {
258			throw UnableToRetrieveMetadata::create($path, $type, '', $exception);
259			}
260
261			$attributes = $this->mapS3ObjectMetadata($result->toArray(), $path);
262
263			if ( ! $attributes instanceof FileAttributes) {
264			throw UnableToRetrieveMetadata::create($path, $type, '');
265			}
266
267			return $attributes;
268			}
269
270			private function mapS3ObjectMetadata(array $metadata, string $path = null): StorageAttributes
271			{
272			if ($path === null) {
273			$path = $this->prefixer->stripPrefix($metadata['Key'] ?? $metadata['Prefix']);
274			}
275
276			if (substr($path, -1) === '/') {
277			return new DirectoryAttributes(rtrim($path, '/'));
278			}
279
280			$mimetype = $metadata['ContentType'] ?? null;
281			$fileSize = $metadata['ContentLength'] ?? $metadata['Size'] ?? null;
282			$fileSize = $fileSize === null ? null : (int) $fileSize;
283			$dateTime = $metadata['LastModified'] ?? null;
284			$lastModified = $dateTime instanceof DateTimeResult ? $dateTime->getTimeStamp() : null;
285
286			return new FileAttributes(
287			$path, $fileSize, null, $lastModified, $mimetype, $this->extractExtraMetadata($metadata)
288			);
289			}
290
291			private function extractExtraMetadata(array $metadata): array
292			{
293			$extracted = [];
294
295			foreach (static::EXTRA_METADATA_FIELDS as $field) {
296			if (isset($metadata[$field]) && $metadata[$field] !== '') {
297			$extracted[$field] = $metadata[$field];
298			}
299			}
300
301			return $extracted;
302			}
303
304			public function mimeType(string $path): FileAttributes
305			{
306			return $this->fetchFileMetadata($path, FileAttributes::ATTRIBUTE_MIME_TYPE);
307			}
308
309			public function lastModified(string $path): FileAttributes
310			{
311			return $this->fetchFileMetadata($path, FileAttributes::ATTRIBUTE_LAST_MODIFIED);
312			}
313
314			public function fileSize(string $path): FileAttributes
315			{
316			return $this->fetchFileMetadata($path, FileAttributes::ATTRIBUTE_FILE_SIZE);
317			}
318
319			public function listContents(string $path, bool $deep): iterable
320			{
321			$prefix = trim($this->prefixer->prefixPath($path), '/');
322			$prefix = empty($prefix) ? '' : $prefix . '/';
323			$options = ['Bucket' => $this->bucket, 'Prefix' => $prefix];
324
325			if ($deep === false) {
326			$options['Delimiter'] = '/';
327			}
328
329			$listing = $this->retrievePaginatedListing($options);
330
331			foreach ($listing as $item) {
332			yield $this->mapS3ObjectMetadata($item);
333			}
334			}
335
336			private function retrievePaginatedListing(array $options): Generator
337			{
338			$resultPaginator = $this->client->getPaginator('ListObjects', $options + $this->options);
339
340			foreach ($resultPaginator as $result) {
341			yield from ($result->get('CommonPrefixes') ?: []);
342			yield from ($result->get('Contents') ?: []);
343			}
344			}
345
346			public function move(string $source, string $destination, Config $config): void
347			{
348			try {
349			$this->copy($source, $destination, $config);
350			$this->delete($source);
351			} catch (FilesystemOperationFailed $exception) {
352			throw UnableToMoveFile::fromLocationTo($source, $destination, $exception);
353			}
354			}
355
356			public function copy(string $source, string $destination, Config $config): void
357			{
358			try {
359			/** @var string $visibility */
360			$visibility = $this->visibility($source)->visibility();
361			} catch (Throwable $exception) {
362			throw UnableToCopyFile::fromLocationTo(
363			$source,
364			$destination,
365			$exception
366			);
367			}
368
369			try {
370			$this->client->copy(
371			$this->bucket,
372			$this->prefixer->prefixPath($source),
373			$this->bucket,
374			$this->prefixer->prefixPath($destination),
375			$this->visibility->visibilityToAcl($visibility),
376			$this->options
377			);
378			} catch (Throwable $exception) {
379			throw UnableToCopyFile::fromLocationTo($source, $destination, $exception);
380			}
381			}
382
383			private function readObject(string $path, bool $wantsStream): StreamInterface
384			{
385			$options = ['Bucket' => $this->bucket, 'Key' => $this->prefixer->prefixPath($path)];
386
387			if ($wantsStream && $this->streamReads && ! isset($this->options['@http']['stream'])) {
388			$options['@http']['stream'] = true;
389			}
390
391			$command = $this->client->getCommand('GetObject', $options + $this->options);
392
393			try {
394			return $this->client->execute($command)->get('Body');
395			} catch (Throwable $exception) {
396			throw UnableToReadFile::fromLocation($path, '', $exception);
397			}
398			}
399			}
400

thephpleague / flysystem-aws-s3-v3

Push — 2.x ( 741cb0...393be3 )

AwsS3V3Adapter::fetchFileMetadata() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like