Sunnysideup\UpgradeToSilverstripe4\ReplacementData\LoadReplacementData

Complexity

Total Complexity

29

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	setTo()	0	5	1
B	__construct()	0	21	7
A	getLanguages()	0	3	1
A	getFlatFindArray()	0	3	1
A	getReplacementArrays()	0	11	3
A	getPaths()	0	13	3
B	mergeConfig()	0	41	8
A	getTos()	0	3	1
A	getData()	0	18	3
A	getFlatReplacedArray()	0	3	1

<?php

namespace Sunnysideup\UpgradeToSilverstripe4\ReplacementData;

use SilverStripe\Upgrader\Util\ConfigFile;

/**
 * loads yml data if strings to replace in
 * code.
 *
 * The replacements should be in the same folder as this class.
 *
 * Alternatively, you can specify another folderContainingLocationData in the
 * construct method.
 *
 * It will also search the root folders for any packages / projects being upgraded.
 */


use Sunnysideup\UpgradeToSilverstripe4\ModuleUpgrader;

class LoadReplacementData
{
    /**
     * Standard file name
     */
    protected $ymlFileName = '.upgrade.replacements.yml';

    /**
     * Module Object
     * @var ModuleUpgrader
     */
    protected $mu = null;

    protected $params = '';

    protected $folderContainingLocationData = '';

    protected $to = 'SS4';

    protected $fullArray = [];

    protected $tos = [];

    protected $languages = [];

    protected $flatFindArray = [];

    protected $flatReplacedArray = [];

    protected $paths = [];

    public function __construct($mu, $folderContainingLocationData = '', $params = [])
    {
        $this->folderContainingLocationData = $folderContainingLocationData ?: __DIR__;
        $this->params = $params;
        $this->mu = $mu;
        $this->fullArray = $this->getData();
        $count = 0;
        foreach ($this->fullArray as $to => $toArray) {
            $this->tos[$to] = $to;
            foreach ($toArray as $path => $pathArray) {
                foreach ($pathArray as $language => $languageArray) {
                    $this->languages[$language] = $language;
                    foreach ($languageArray as $findKey => $findKeyArray) {
                        if (! isset($findKeyArray['R'])) {
                            user_error('replacement key not set: ' . print_r($findKeyArray, 1));
                        }
                        $replaceKey = $findKeyArray['R'];
                        $key = strtolower($to . '_' . $language . '_' . $path . '_' . $count);
                        $this->flatFindArray[$key] = $findKey;
                        $this->flatReplacedArray[$key] = $replaceKey;
                        $count++;
                    }
                }
            }
        }
    }

    public function setTo($s)
    {
        $this->to = $s;

        return $this;
    }

    public function getReplacementArrays()
    {
        if (! $this->to) {
            return $this->fullArray;
        }
        if (isset($this->fullArray[$this->to])) {
            return $this->fullArray[$this->to];
        }
        user_error('no data is available for upgrading to: ' . $this->to);

        return [];
    }

    public function getTos()
    {
        return $this->tos;
    }

    public function getLanguages()
    {
        return $this->languages;
    }

    public function getFlatFindArray()
    {
        return $this->flatFindArray;
    }

    public function getFlatReplacedArray()
    {
        return $this->flatReplacedArray;
    }

    protected function getPaths()
    {
        $array = [];
        foreach ($this->mu->getExistingModuleDirLocations() as $moduleDir) {
            $array[$moduleDir] = $moduleDir;
        }
        $globalFixes = $this->mu->checkIfPathExistsAndCleanItUp($this->folderContainingLocationData);
        if ($globalFixes) {
            $array[$globalFixes] = $globalFixes;
        }
        $this->paths = $array;

        return $this->paths;
    }

    protected function getData()
    {
        $this->getPaths();
        // Merge with any other upgrade spec in the top level
        $config = [];
        foreach ($this->paths as $path) {
            $nextFile = $path . DIRECTORY_SEPARATOR . $this->ymlFileName;
            if (file_exists($nextFile)) {
                $nextConfig = ConfigFile::loadConfig($nextFile);
                // Merge
                $config = $this->mergeConfig($config, $nextConfig);
            } else {
                $this->mu->colourPrint('could not find: ' . $nextFile);
            }
        }
        ksort($config);

        return $config;
    }

    protected static function mergeConfig(array $left, array $right)
    {
        //see ConfigFile for original
        $merged = $left;
        foreach ($right as $key => $value) {
            // if non-associative, just merge in unique items
            if (is_numeric($key)) {
                if (! in_array($value, $merged, true)) {
                    $merged[] = $value;
                }
                continue;
            }

            // If not merged into left hand side, then simply assign
            if (! isset($merged[$key])) {
                $merged[$key] = $value;
                continue;
            }

            // Make sure both sides are the same type
            if (is_array($merged[$key]) !== is_array($value)) {
                user_error(
                    "Config option ${key} cannot merge non-array with array value."
                );
            }

            // If array type, then merge
            if (is_array($value)) {
                $merged[$key] = self::mergeConfig($merged[$key], $value);
                continue;
            }

            // If non array types, don't merge, but instead assert both values are set
            if ($merged[$key] !== $value) {
                user_error(
                    "Config option ${key} is defined with different values in multiple files."
                );
            }
        }

        return $merged;
    }
}