ToolkitLab\ASCII\AbstractFormatter

Complexity

Total Complexity

37

Size/Duplication

Total Lines	291
Duplicated Lines	0 %

Test Coverage

Coverage

95.36%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	format()	0	15	2
A	addRow()	0	14	3
A	addTopBorder()	0	7	2
A	addHeader()	0	8	2
A	addDataRow()	0	7	1
A	addHeaderBorder()	0	6	1
A	getAbcRange()	0	10	3
C	initSidebar()	0	23	8
B	initHeader()	0	22	6
A	addRows()	0	3	1
A	setParams()	0	6	2
A	init()	0	12	2
A	__construct()	0	2	1
A	getParam()	0	2	1
A	addBottomBorder()	0	7	2

<?php

namespace ToolkitLab\ASCII;

use ToolkitLab\ASCII\Table;

abstract class AbstractFormatter implements FormatterInterface {
    
    const
        DEFAULT_MODE              = 0x0,

        HEADER_FIRST_ROW_MODE     = 0X1,
        HEADER_NUMERIC_MODE       = 0x2,
        HEADER_ABC_MODE           = 0X4,
            
        SIDEBAR_NUMERIC_MODE      = 0X10,
        SIDEBAR_ABC_MODE          = 0x20,
            
        SPREADSHEET_MODE          = 0X14;

    /**
     * @var Table
     */
    protected $table;

    /**
     * @var array
     */
    protected $metadata = [];

    /**
     * @var string
     */
    protected $output = '';

    /**
     * The data to be formatted
     * @var array
     */
    protected $data = [];
    
    /**
     * @var boolean
     */
    protected $useHeader = false;

    /**
     * Formatting parameters
     * @var array
     */
    protected $params = [
        'mode' => self::DEFAULT_MODE,
        'rotate' => false,
        'max_cell_length' => 100,
        'max_cell_ending' => '...',
    ];

    /**
     * Constructor
     * @param array $params
     */
    public function __construct($params = []) {
        $this->setParams($params);
    }

    /**
     * Converts an array into ASCII-formatted string (table)
     * @param Table $table
     * @param array $params
     * @return string
     */
    public function format($data, $params = []) {
        $table = $data instanceof Table ? $data : new Table($data);
        $this->init($table, $params);
//                if (($this->getParam('mode') & self::SPREADSHEET_MODE) === self::SPREADSHEET_MODE) {
//            
//            print '<pre>';
//            print_r($this->table->getDimensionX());
//            print '</pre>';
//            exit;
//        }
        $this->addTopBorder();
        $this->addHeader();
        $this->addRows();
        $this->addBottomBorder();
        return $this->output;
    }

    /**
     * Initializes the data/parameters before formatting
     * @param Table $table
     * @param array $params
     * @return void
     */
    protected function init(Table $table, $params = []) {
        $this->output = '';
        $this->setParams($params);
        $this->table = $table;
        if ($this->getParam('rotate') !== false) {
            $this->table->rotate($this->getParam('rotate'));
        }
        $this->initHeader();
        $this->initSidebar();
        $maxLength = $this->getParam('max_cell_length');
        $ending = $this->getParam('max_cell_ending');
        $this->table->truncate($maxLength, $ending);
    }
    
    protected function initHeader() {
        $count = 0;
        $mode = $this->getParam('mode');
        $data = $this->table->getData();
        $x = $this->table->getDimensionX();
        if (($mode & self::HEADER_FIRST_ROW_MODE) === self::HEADER_FIRST_ROW_MODE) {
            $count++;
        }
        if (($mode & self::HEADER_ABC_MODE) === self::HEADER_ABC_MODE) {
            $data = array_merge([$this->getAbcRange($x)], $data);
            $count++;
        }
        if (($mode & self::HEADER_NUMERIC_MODE) === self::HEADER_NUMERIC_MODE) {
            $data = array_merge([range(1, $x)], $data);
            $count++;
        }
        if ($count > 1) {
            throw new \LogicException('There should be only one header.');
        }
        if ($count) {
            $this->useHeader = true;
            $this->table->setData($data);
        }
    }
    
    protected function initSidebar() {
        $count = 0;
        $mode = $this->getParam('mode');
        $data = $this->table->getData();
        $x = $this->table->getDimensionX();
        if (($mode & self::SIDEBAR_ABC_MODE) === self::SIDEBAR_ABC_MODE) {
            foreach ($data as $key => $val) {
                $data[$key] = array_merge($this->getAbcRange($x), $val);
            }
            $count++;
        }
        if (($mode & self::SIDEBAR_NUMERIC_MODE) === self::SIDEBAR_NUMERIC_MODE) {
            foreach ($data as $key => $val) {
                $data[$key] = array_merge([$key ? $key : ''], $val);
            }
            $count++;
        }
        if ($count > 1) {
            throw new \LogicException('There should be only one sidebar.');
        }
        
        if ($count) {
            $this->table->setData($data);
        }
    }
    
    /**
     * Updates the parameters with new values
     * @param array $params
     * @throws \InvalidArgumentException
     */
    protected function setParams($params) {
        $unknownParams = array_diff(array_keys($params), array_keys($this->params));
        if (count($unknownParams)) {
            throw new \InvalidArgumentException('Unknown parameter(-s): ' . implode(', ', $unknownParams));
        }
        $this->params = array_merge($this->params, $params);
    }

    /**
     * Get the specified parameter
     * @param string $key
     * @return mixed
     */
    protected function getParam($key) {
        return $this->params[$key];
    }

    /**
     * Adds the top border to the output
     * @return void
     */
    protected function addTopBorder() {
        if ($this->metadata['top_border']) {
            $this->addRow(
                $this->metadata['top_border']['left'],
                $this->metadata['top_border']['middle'],
                $this->metadata['top_border']['right'],
                $this->metadata['top_border']['pad']
            );
        }
    }

    /**
     * Adds the header row to the output
     * @return void
     */
    protected function addHeader() {
        if ($this->useHeader) {
            $data = $this->table->getData();
            $x = $this->table->getDimensionX();
            $y = $this->table->getDimensionY();
            $this->addDataRow(array_shift($data));
            $this->addHeaderBorder();
            $data = $this->table->setData($data, $x, $y);

Are you sure the assignment to $data is correct as $this->table->setData($data, $x, $y) targeting ToolkitLab\ASCII\Table::setData() seems to always return null.

The assignment to $data is dead and can be removed.

        }
    }
    
    final protected function getAbcRange($length) {
        $baseRange = range('A', 'Z');
        $range = range('A', 'Z');
        while (count($range) < $length && count($baseRange) > 1) {
            $letter = array_shift($baseRange);
            $tmpRange = range('A', 'Z');
            array_walk($tmpRange, function(&$e) use ($letter) { $e = $letter . $e; });
            $range = array_merge($range, $tmpRange);
        }
        return array_slice($range, 0, $length);
    }

    /**
     * Adds the rows to the output
     */
    protected function addRows() {
        $data = $this->table->getData();
        array_walk($data, [$this, 'addDataRow']);
    }

    /**
     * Adds the row with the specified data to the output
     * @param array $row
     * @return void
     */
    protected function addDataRow($row) {
        $this->addRow(
            $this->metadata['content']['left'],
            $this->metadata['content']['middle'],
            $this->metadata['content']['right'],
            $this->metadata['content']['pad'],
            $row
        );
    }

    /**
     * Adds the bottom border of the header to the output
     * @return void
     */
    protected function addHeaderBorder() {
        $this->addRow(
            $this->metadata['header']['left'],
            $this->metadata['header']['middle'],
            $this->metadata['header']['right'],
            $this->metadata['header']['pad']
        );
    }

    /**
     * Adds the bottom border to the output
     * @return void
     */
    protected function addBottomBorder() {
        if ($this->metadata['bottom_border']) {
            $this->addRow(
                $this->metadata['bottom_border']['left'],
                $this->metadata['bottom_border']['middle'],
                $this->metadata['bottom_border']['right'],
                $this->metadata['bottom_border']['pad']
            );
        }
    }

    /**
     * Adds the row to the output
     * @param string $lb
     * @param string $bm
     * @param string $br
     * @param string $pad
     * @param array $row
     * @return void
     */
    protected function addRow($lb, $bm, $br, $pad, $row = []) {
        $delimiter = $lb;
        for ($i = 0; $i < $this->table->getDimensionX(); $i++) {
            $maxLength = $this->table->getColumnsMaxLength($i);
            $this->output .= $delimiter;
            if (count($row)) {
                $spaces = str_repeat($pad, $maxLength - strlen($row[$i]));
                $this->output .= " {$row[$i]}{$spaces} ";
            } else {
                $this->output .= str_repeat($pad, $maxLength + 2);
            }
            $delimiter = $bm;
        }
        $this->output .= $br . PHP_EOL;
    }

}