wapmorgan\UnifiedArchive\Commands\TableCommand::execute()

Complexity

Conditions	12
Paths	108

Size

Total Lines	98
Code Lines	54

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    public function execute(InputInterface $input, OutputInterface $output)
    {
        $archive = $this->getArchive($input, $output);
        $filter = $input->getArgument('filter');
        $human_readable_size = $input->getOption('human-readable-size');
        $detect_mimetype = $input->getOption('detect-mimetype');
        $sort = $input->getOption('sort');
        $sort_desc = $input->getOption('sort-desc');

        $headers = [
            'Filename',
            'Size',
            'xSize',
            'Ratio',
            'Date',
//            'Crc',
            'Comment'
        ];
        if ($detect_mimetype) {
            array_splice($headers, 4, 0, ['Mimetype']);
        }

        $sort_field = array_search($sort, array_map('strtolower', $headers));

        if (!empty($filter) && strpos($filter, '*') === false) {

It seems like $filter can also be of type string[]; however, parameter $haystack of strpos() does only seem to accept string, maybe add an additional type check?

            $filter .= '*';
        }

        $table = new Table($output);
        $table->setHeaders($headers);

        $rows = [];

        foreach ($archive->getFileNames($filter) as $i => $file) {

It seems like $filter can also be of type string[]; however, parameter $filter of wapmorgan\UnifiedArchive\UnifiedArchive::getFileNames() does only seem to accept null|string, maybe add an additional type check?

            $details = $archive->getFileData($file);

            if ($human_readable_size) {
                $un_comp_size = implode($this->formatSize($details->uncompressedSize));
                $comp_size = implode($this->formatSize($details->compressedSize));
            } else {
                $un_comp_size = $details->uncompressedSize;
                $comp_size = $details->compressedSize;
            }

            $row = [
                $details->path,
                $un_comp_size,
                $comp_size,
                $details->uncompressedSize > 0
                    ? round($details->compressedSize / $details->uncompressedSize, 1)
                    : '-',
                $this->formatDate($details->modificationTime),
//                $details->crc32,
                $details->comment,
            ];
            if ($detect_mimetype) {
                // @todo May be a bug in future. Need to review
                array_splice($row, 4, 0, [
                    $this->getMimeTypeByStream($archive->getFileStream($file))
                ]);
            }
            $rows[] = $row;
//            $table->setRow($i, $row);

//            $len = strlen($un_comp_size);
//            if ($len > $uncomp_size_length) {
//                $uncomp_size_length = $len;
//            }
//            $len = strlen($comp_size);
//            if ($len > $comp_size_length) {
//                $comp_size_length = $len;
//            }
        }

        if ($sort !== null) {
            usort($rows, function (array $a, array $b) use ($sort_field) {
                if ($a[$sort_field] > $b[$sort_field]) {
                    return 1;
                }
                if ($a[$sort_field] < $b[$sort_field]) {
                    return -1;
                }
                return 0;
            });
            if ($sort_desc) {
                $rows = array_reverse($rows);
            }
        }

        $table->setRows($rows);

//        $table->setColumnWidth(0, 0);
//        $table->setColumnWidth(1, $uncomp_size_length);
//        $table->setColumnWidth(2, $comp_size_length);
//        $table->setColumnWidth(3, 18);
        $table->render();

        return 0;
    }