Base::jsonEncode() - Code Metrics - Inspection of "TORG-148: Replaced preg-match/replace of require b..." - netresearch/kite - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c5752c...f61021 )

unknown

created 2016-06-17 08:31 UTC

Base::jsonEncode() A

↳ Parent: Base

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	1
eloc	4
c	1
b	0
f	1
nc	1
nop	1
dl	0
loc	6
rs	9.4285

<?php
/**
 * See class comment
 *
 * PHP Version 5
 *
 * @category   Netresearch
 * @package    Netresearch\Kite\Workflow
 * @subpackage Composer
 * @author     Christian Opitz <[email protected]>
 * @license    http://www.netresearch.de Netresearch Copyright
 * @link       http://www.netresearch.de
 */

namespace Netresearch\Kite\Workflow\Composer;
use Netresearch\Kite\Service\Composer\Package;
use Netresearch\Kite\Workflow;
use Netresearch\Kite\Exception;

/**
 * Abstract for composer workflows
 *
 * @category   Netresearch
 * @package    Netresearch\Kite\Workflow
 * @subpackage Composer
 * @author     Christian Opitz <[email protected]>
 * @license    http://www.netresearch.de Netresearch Copyright
 * @link       http://www.netresearch.de
 */
abstract class Base extends Workflow
{
    /**
     * @var Package[]
     */
    protected $pushPackages = array();

    /**
     * @var array
     */
    protected $whitelists;

    /**
     * Configure the variables
     *
     * @return array
     */
    protected function configureVariables()
    {
        $config = $this->getParent()->get('config');
        if (!array_key_exists('composer', $config)) {
            $config['composer'] = [];
        }
        foreach (['whitelistNames', 'whitelistPaths', 'whitelistRemotes'] as $key) {
            if (!array_key_exists($key, $config['composer'])) {
                $config['composer'][$key] = null;
            }
        }
        return [
            'whitelistNames' => array(
                'default' => '{config["composer"]["whitelistNames"]}',
                'type' => 'string',
                'label' => 'Regular expression for package names, to limit this operation to',
                'option' => true
            ),
            'whitelistPaths' => array(
                'default' => '{config["composer"]["whitelistPaths"]}',
                'type' => 'string',
                'label' => 'Regular expression for package paths, to limit this operation to',
                'option' => true
            ),
            'whitelistRemotes' => array(
                'default' => '{config["composer"]["whitelistRemotes"]}',
                'type' => 'string',
                'label' => 'Regular expression for package remote urls, to limit this operation to',
                'option' => true
            ),
            '--'
        ] + parent::configureVariables();
    }


    /**
     * Push all packages marked to be pushed
     *
     * @return void
     */
    protected function pushPackages()
    {
        foreach ($this->pushPackages as $i => $package) {
            $this->assertPackageAllowed($package);
            $this->console->output("Pushing <comment>$package->name</comment>", false);
            $this->git('push', $package->path, array('u' => 'origin', $package->branch));
            $this->console->output(
                str_repeat(chr(8), strlen($package->name))
                . '<info>' . $package->name . '</info>'
            );
            unset($this->pushPackages[$i]);
        }
    }

    /**
     * doComposerUpdateIfNecessary and possible
     *
     * @return void
     */
    protected function doComposerUpdate()
    {
        try {
            $this->composer('update');
        } catch (\Exception $e) {
            $this->console->output('<warning>Composer update failed</warning>');
            $this->console->output('<comment>This might have occured because previous pushes to git did not reache the composer repo yet</comment>');
            if ($this->confirm('Retry?')) {
                $this->doComposerUpdate();
            } else {
                $this->doExit('', 1);
            }
        }
    }

    /**
     * Go through all packages and check if packages requiring those packages,
     * still require their (likely new) versions.
     *
     * If not and $autoFix or user agrees, the require-statements in the
     * dependent packages are changed accordingly.
     *
     * @param Package[] $packages Packages
     * @param bool      $autoFix  Whether to autofix wrong requirements
     *
     * @return void
     */
    protected function rewriteRequirements(array &$packages, $autoFix = false)
    {
        $checkedOutPackages = array_keys($packages);
        $unfixedRequirements = 0;
        while ($packageName = array_shift($checkedOutPackages)) {
            $branch = $packages[$packageName]->branch;
            $version = 'dev-' . $branch;
            foreach ($this->getPackages(false, false) as $package) {
                if (array_key_exists($packageName, $package->requires)) {
                    // TODO: Set required version to branch alias, if any
                    $requiredVersion = $package->requires[$packageName];
                    if ($requiredVersion === '@dev') {
                        $requiredVersion = 'dev-master';
                    }
                    if ($requiredVersion !== $version) {
                        $this->assertPackageAllowed($package);
                        if (!$package->git) {
                            throw new Exception("Package {$package->name} required to be installed from source");
                        }
                        if ($autoFix) {
                            $fix = true;
                            $this->output("Changing required version of {$packageName} in {$package->name} from {$requiredVersion} to {$version}");
                        } else {
                            $this->output("<warning>{$package->name} depends on {$packageName} {$package->requires[$packageName]} and not {$version} as expected</warning>");
                            $this->output('<comment>If you don\'t fix that, the branches will probably change with composer update</comment>');
                            $fix = $this->confirm('Fix that?');
                        }
                        if ($fix) {
                            if (!array_key_exists($package->name, $packages)) {
                                $this->checkoutPackage($package, $branch, true);
                                $checkedOutPackages[] = $package->name;
                                $packages[$package->name] = $package;
                            }

                            $this->pushPackages[$packageName] = $packages[$packageName];
                            $this->rewriteRequirement($package, $packageName, $version);
                        } else {
                            $unfixedRequirements++;
                        }
                    }
                }
            }
        }
        if ($unfixedRequirements) {
            $this->doExit(
                'It seems like a composer update is required but due to probably incorrect dependencies you have to do that manually', 1
            );
        }
    }

    /**
     * Change the require statement for $requiredPackage to the newVersion in $package
     *
     * @param Package $package         The package
     * @param string  $requiredPackage The required package
     * @param string  $newVersion      The new version
     *
     * @return void
     */
    protected function rewriteRequirement($package, $requiredPackage, $newVersion)
    {
        $this->assertPackageAllowed($package);

        $currentVersion = $package->requires[$requiredPackage];
        $composerFile = $package->path . '/composer.json';
        $composerFileContents = file_get_contents($composerFile);
        $newComposerFileContents = preg_replace(
            sprintf(
                '/(^\s*"require"\s*:\s*\{[^\}]+"%s"\s*:\s*")%s/m',
                preg_quote($requiredPackage, '/'),
                preg_quote($currentVersion, '/')
            ),
            '$1' . $newVersion,
            $composerFileContents
        );
        file_put_contents($composerFile, $newComposerFileContents);
        $this->reloadRequires($package);

        if ($package->requires[$requiredPackage] !== $newVersion) {
            file_put_contents($composerFile, $composerFileContents);
            $this->output('<error>Could not replace version</error> - generated composer.json was:');
            $this->output($newComposerFileContents);
            throw new Exception('Replacing version failed');
        }

        $this->git('commit', $package->path, array('n' => true, 'm' => "Change required version of $requiredPackage to $newVersion", 'composer.json'));
        if (!isset($package->source)) {
            $package->source = new \stdClass();
        }
        $package->source->reference = $this->git('rev-parse', $package->path, array('HEAD'));

        $this->console->output("Made <comment>$package->name</comment> require <comment>$requiredPackage $newVersion</comment>");

        $this->pushPackages[$package->name] = $package;
    }

    /**
     * Reload the requires from $package composer.json to $package->requires
     *
     * If $detectChanges, and there are changes on the requirements not in $ignorePackages
     * composer update is requested
     *
     * @param Package $package The package
     *
     * @deprecated Use $package->reloadRequires()
     *
     * @return void
     */
    protected function reloadRequires($package)
    {
        $package->reloadRequires();
    }

    /**
     * Checkout a package at a branch
     *
     * @param Package $package The package
     * @param string  $branch  The branch
     * @param bool    $create  Create the branch if it doesn't exist
     *
     * @return bool|null Whether checkout was successful or null when package is already at this branch
     */
    protected function checkoutPackage($package, $branch, $create = false)
    {
        $this->assertPackageAllowed($package);

        if ($package->branch === $branch) {
            return null;
        }
        if (!$package->git) {
            throw new Exception('Non git package can not be checked out');
        }
        $remoteBranch = 'origin/' . $branch;
        $isRemote = in_array($remoteBranch, $package->branches, true);
        if (in_array($branch, $package->branches, true)) {
            $this->git('checkout', $package->path, $branch);
        } elseif ($isRemote) {
            $this->git('checkout', $package->path, array('b' => $branch, $remoteBranch));
        } elseif ($create) {
            $branches = array_unique(
                array_map(
                    function ($el) {
                        $parts = explode('/', $el);
                        return array_pop($parts);
                    },
                    $package->branches
                )
            );
            sort($branches);
            $inferFromBranch = $this->choose(
                "Select branch to create new branch '$branch' from in {$package->name}",
                $branches, in_array('master', $branches, true) ? 'master' : $branch
            );
            if ($inferFromBranch !== $package->branch) {
                $this->checkoutPackage($package, $inferFromBranch);
            }
            $this->git('checkout', $package->path, array('b' => $branch));
            $package->branches[] = $branch;
        } else {
            return false;
        }

        if ($isRemote) {
            if (!isset($package->upstreams[$branch]) || $package->upstreams[$branch] !== $remoteBranch) {
                $this->git('branch', $package->path, array('u' => $remoteBranch));
                $package->upstreams[$branch] = $remoteBranch;
            }
            $this->git('rebase', $package->path);
        }

        $this->console->output("Checked out <comment>{$package->name}</comment> at <comment>$branch</comment>");

        $this->reloadRequires($package);

        $package->version = 'dev-' . $branch;
        $package->branch = $branch;

        return true;
    }

    /**
     * Merge a $branch into $package's current branch
     *
     * @param Package $package The package
     * @param string  $branch  The branch
     * @param null    $message The commit message (if any)
     * @param bool    $squash  Whether to squash the changes
     *
     * @return void
     */
    protected function mergePackage($package, $branch, $message = null, $squash = false)
    {
        $this->assertPackageAllowed($package);

        if (!$package->git) {
            throw new Exception('Non git package can not be merged');
        }

        $this->git('fetch', $package->path, array('force' => true, 'origin', $branch . ':' . $branch));

        $ff = $branch == 'master' ? 'ff' : 'no-ff';
        $optArg = array($ff => true, 'no-commit' => true);
        if ($squash) {
            $optArg['squash'] = true;
        }
        $optArg[] = $branch;

        try {
            $this->git('merge', $package->path, $optArg);
        } catch (\Exception $e) {
            $diff = $this->git('diff', $package->path, array('name-only' => true, 'diff-filter' => 'U'));
            $conflictedFiles = array_flip(explode("\n", $diff));
            if (array_key_exists('composer.json', $conflictedFiles)) {
                try {
                    $this->resolveRequirementsConflict($package);
                    $this->git('add', $package->path, 'composer.json');
                } catch (Exception $conflictSolvingException) {

                }
            }
            if (array_diff(array_keys($conflictedFiles), ['composer.json'])) {
                throw new Exception(
                    'There are unresolved conflicts - please resolve them and then commit the result',
                    1458307785, isset($conflictSolvingException) ? $conflictSolvingException : null
                );
            } elseif (isset($conflictSolvingException)) {
                throw $conflictSolvingException;
            }
        }
        if (isset($conflictedFiles) || $this->git('status', $package->path, array('porcelain' => true))) {
            if (!$message) {
                $message = $this->answer(
                    'Enter commit message:',
                    'Merged ' . $branch . ' into ' . $package->branch
                );
            }
            $this->git('commit', $package->path, array('n' => true, 'm' => $message));
        }

        $this->console->output("Merged with <comment>$branch</comment> in <comment>{$package->name}</comment>");

        $this->reloadRequires($package);

        $this->pushPackages[$package->name] = $package;
    }

    /**
     * Try to solve conflicts inside the require section of the $package composer.json
     *
     * @param Package $package The package
     *
     * @return void
     */
    private function resolveRequirementsConflict($package)
    {
        $contents = file_get_contents($package->path . '/composer.json');
        $ours = @json_decode(
            preg_replace('/^<{7}.+\n(.+)\n(\|{7}|={7}).+>{7}.+$/smU', '$1', $contents)
        );
        $theirs = @json_decode(
            preg_replace('/^<{7}.+\n={7}\n(.+)\n>{7}.+$/smU', '$1', $contents)
        );
        if (!is_object($ours) || !is_object($theirs)) {
            throw new Exception('Could not regenerate json file from solved conflicts');
        }
        $diff = array_diff_key($theirs = get_object_vars($theirs), $ours = get_object_vars($ours));
        foreach ($ours as $key => $value) {
            if ($key !== 'require' && (!array_key_exists($key, $theirs) || serialize($value) !== serialize($theirs[$key]))) {
                $diff[$key] = $value;
            }
        }
        if ($diff !== array()) {
            throw new Exception('Can not automerge composer.json due to conflicts outside require object', 1458307516);
        }

        $theirs['require'] = $this->mergeRequirements($package, $ours, $theirs);
        file_put_contents($package->path . '/composer.json', $this->jsonEncode($theirs));
    }

    /**
     * Encode a variable for JSON file
     *
     * @param mixed $var The var
     *
     * @return string
     */
    protected function jsonEncode($var)
    {
        return json_encode(
            $var, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE
        ) . "\n";
    }

    /**
     * Merge the requirements from different sides of the current $package
     *
     * @param Package $package The current package
     * @param array   $ours    Our composer.json as array
     * @param array   $theirs  Their composer.json as array
     *
     * @return array
     */
    private function mergeRequirements($package, array $ours, array $theirs)
    {
        $oursRequire = isset($ours['require']) && is_object($ours['require']) ? get_object_vars($ours['require']) : [];
        $theirsRequire = isset($theirs['require']) && is_object($theirs['require']) ? get_object_vars($theirs['require']) : [];
        $mergedRequires = array_merge($oursRequire, $theirsRequire);
        $packages = $this->getPackages(false, false);
        $preferredVersion = 'dev-' . $package->branch;
        foreach ($mergedRequires as $packageName => $version) {
            $actualVersion = ($version === '@dev') ? 'dev-master' : $version;
            if (array_key_exists($packageName, $oursRequire)
                && $version !== $oursRequire[$packageName]
                && $actualVersion !== $oursRequire[$packageName]
                && $actualVersion !== $preferredVersion
                && array_key_exists($packageName, $packages)
                && in_array($package->branch, $packages[$packageName]->branches, true)
            ) {
                $mergedRequires[$packageName] = $preferredVersion;
            }
        }
        return $mergedRequires;
    }

    /**
     * Get the allowed packages
     *
     * @param bool $gitOnly     If git packages should be returned only
     * @param bool $allowedOnly If allowed packages should be returned only
     *
     * @return \Netresearch\Kite\Service\Composer\Package[]
     */
    protected function getPackages($gitOnly = true, $allowedOnly = true)
    {
        /* @var $packages \Netresearch\Kite\Service\Composer\Package[] */
        /* @var $package \Netresearch\Kite\Service\Composer\Package */
        $packages = array();
        foreach ($this->get('composer.packages') as $package) {
            if ((!$gitOnly || $package->git) && (!$allowedOnly || $this->isPackageAllowed($package))) {
                $packages[$package->name] = $package;
            }
        }
        return $packages;
    }

    /**
     * Assert that package is allowed
     *
     * @param Package $package The package
     *
     * @throws Exception
     *
     * @return void
     */
    protected function assertPackageAllowed($package)
    {
        if (!$this->isPackageAllowed($package)) {
            throw new Exception("Package {$package->name} is not in white list");
        }
    }

    /**
     * Determine if a package is whitelisted
     *
     * @param Package $package The package
     *
     * @return bool
     */
    protected function isPackageAllowed(Package $package)
    {
        $whitelistTypes = ['path', 'remote', 'name'];
        if (!is_array($this->whitelists)) {
            $this->whitelists = [];
            foreach ($whitelistTypes as $whitelistType) {
                $option = $this->get('whitelist' . ucfirst($whitelistType) . 's');
                if ($option) {
                    $this->whitelists[$whitelistType] = '#^' . $option . '$#';
                }
            }
        }

        if (!$this->whitelists) {

            // Without whitelists, all packages are allowed
            return true;
        }

        foreach ($this->whitelists as $type => $pattern) {
            $subject = $package->$type;
            if ($type === 'path') {
                $subject = rtrim(
                    $this->console->getFilesystem()->findShortestPath(
                        $this->get('composer.rootPackage.path'),
                        $subject,
                        true
                    ),
                    '/'
                );
            }
            if (preg_match($pattern, $subject)) {
                return true;
            }
        }

        return false;
    }
}
?>


1			<?php
2			/**
3			* See class comment
4			*
5			* PHP Version 5
6			*
7			* @category Netresearch
8			* @package Netresearch\Kite\Workflow
9			* @subpackage Composer
10			* @author Christian Opitz <[email protected]>
11			* @license http://www.netresearch.de Netresearch Copyright
12			* @link http://www.netresearch.de
13			*/
14
15			namespace Netresearch\Kite\Workflow\Composer;
16			use Netresearch\Kite\Service\Composer\Package;
17			use Netresearch\Kite\Workflow;
18			use Netresearch\Kite\Exception;
19
20			/**
21			* Abstract for composer workflows
22			*
23			* @category Netresearch
24			* @package Netresearch\Kite\Workflow
25			* @subpackage Composer
26			* @author Christian Opitz <[email protected]>
27			* @license http://www.netresearch.de Netresearch Copyright
28			* @link http://www.netresearch.de
29			*/
30			abstract class Base extends Workflow
31			{
32			/**
33			* @var Package[]
34			*/
35			protected $pushPackages = array();
36
37			/**
38			* @var array
39			*/
40			protected $whitelists;
41
42			/**
43			* Configure the variables
44			*
45			* @return array
46			*/
47			protected function configureVariables()
48			{
49			$config = $this->getParent()->get('config');
50			if (!array_key_exists('composer', $config)) {
51			$config['composer'] = [];
52			}
53			foreach (['whitelistNames', 'whitelistPaths', 'whitelistRemotes'] as $key) {
54			if (!array_key_exists($key, $config['composer'])) {
55			$config['composer'][$key] = null;
56			}
57			}
58			return [
59			'whitelistNames' => array(
60			'default' => '{config["composer"]["whitelistNames"]}',
61			'type' => 'string',
62			'label' => 'Regular expression for package names, to limit this operation to',
63			'option' => true
64			),
65			'whitelistPaths' => array(
66			'default' => '{config["composer"]["whitelistPaths"]}',
67			'type' => 'string',
68			'label' => 'Regular expression for package paths, to limit this operation to',
69			'option' => true
70			),
71			'whitelistRemotes' => array(
72			'default' => '{config["composer"]["whitelistRemotes"]}',
73			'type' => 'string',
74			'label' => 'Regular expression for package remote urls, to limit this operation to',
75			'option' => true
76			),
77			'--'
78			] + parent::configureVariables();
79			}
80
81
82			/**
83			* Push all packages marked to be pushed
84			*
85			* @return void
86			*/
87			protected function pushPackages()
88			{
89			foreach ($this->pushPackages as $i => $package) {
90			$this->assertPackageAllowed($package);
91			$this->console->output("Pushing <comment>$package->name</comment>", false);
92			$this->git('push', $package->path, array('u' => 'origin', $package->branch));
93			$this->console->output(
94			str_repeat(chr(8), strlen($package->name))
95			. '<info>' . $package->name . '</info>'
96			);
97			unset($this->pushPackages[$i]);
98			}
99			}
100
101			/**
102			* doComposerUpdateIfNecessary and possible
103			*
104			* @return void
105			*/
106			protected function doComposerUpdate()
107			{
108			try {
109			$this->composer('update');
110			} catch (\Exception $e) {
111			$this->console->output('<warning>Composer update failed</warning>');
112			$this->console->output('<comment>This might have occured because previous pushes to git did not reache the composer repo yet</comment>');
113			if ($this->confirm('Retry?')) {
114			$this->doComposerUpdate();
115			} else {
116			$this->doExit('', 1);
117			}
118			}
119			}
120
121			/**
122			* Go through all packages and check if packages requiring those packages,
123			* still require their (likely new) versions.
124			*
125			* If not and $autoFix or user agrees, the require-statements in the
126			* dependent packages are changed accordingly.
127			*
128			* @param Package[] $packages Packages
129			* @param bool $autoFix Whether to autofix wrong requirements
130			*
131			* @return void
132			*/
133			protected function rewriteRequirements(array &$packages, $autoFix = false)
134			{
135			$checkedOutPackages = array_keys($packages);
136			$unfixedRequirements = 0;
137			while ($packageName = array_shift($checkedOutPackages)) {
138			$branch = $packages[$packageName]->branch;
139			$version = 'dev-' . $branch;
140			foreach ($this->getPackages(false, false) as $package) {
141			if (array_key_exists($packageName, $package->requires)) {
142			// TODO: Set required version to branch alias, if any
143			$requiredVersion = $package->requires[$packageName];
144			if ($requiredVersion === '@dev') {
145			$requiredVersion = 'dev-master';
146			}
147			if ($requiredVersion !== $version) {
148			$this->assertPackageAllowed($package);
149			if (!$package->git) {
150			throw new Exception("Package {$package->name} required to be installed from source");
151			}
152			if ($autoFix) {
153			$fix = true;
154			$this->output("Changing required version of {$packageName} in {$package->name} from {$requiredVersion} to {$version}");
155			} else {
156			$this->output("<warning>{$package->name} depends on {$packageName} {$package->requires[$packageName]} and not {$version} as expected</warning>");
157			$this->output('<comment>If you don\'t fix that, the branches will probably change with composer update</comment>');
158			$fix = $this->confirm('Fix that?');
159			}
160			if ($fix) {
161			if (!array_key_exists($package->name, $packages)) {
162			$this->checkoutPackage($package, $branch, true);
163			$checkedOutPackages[] = $package->name;
164			$packages[$package->name] = $package;
165			}
166
167			$this->pushPackages[$packageName] = $packages[$packageName];
168			$this->rewriteRequirement($package, $packageName, $version);
169			} else {
170			$unfixedRequirements++;
171			}
172			}
173			}
174			}
175			}
176			if ($unfixedRequirements) {
177			$this->doExit(
178			'It seems like a composer update is required but due to probably incorrect dependencies you have to do that manually', 1
179			);
180			}
181			}
182
183			/**
184			* Change the require statement for $requiredPackage to the newVersion in $package
185			*
186			* @param Package $package The package
187			* @param string $requiredPackage The required package
188			* @param string $newVersion The new version
189			*
190			* @return void
191			*/
192			protected function rewriteRequirement($package, $requiredPackage, $newVersion)
193			{
194			$this->assertPackageAllowed($package);
195
196			$currentVersion = $package->requires[$requiredPackage];
197			$composerFile = $package->path . '/composer.json';
198			$composerFileContents = file_get_contents($composerFile);
199			$newComposerFileContents = preg_replace(
200			sprintf(
201			'/(^\s"require"\s:\s\{[^\}]+"%s"\s:\s*")%s/m',
202			preg_quote($requiredPackage, '/'),
203			preg_quote($currentVersion, '/')
204			),
205			'$1' . $newVersion,
206			$composerFileContents
207			);
208			file_put_contents($composerFile, $newComposerFileContents);
209			$this->reloadRequires($package);
			0 ignored issues – show Deprecated Code introduced 2016-05-10 09:23 UTC by Report Bug Copy Issue Report The method `Netresearch\Kite\Workflo...\Base::reloadRequires()` has been deprecated with message: Use $package->reloadRequires() This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
210			if ($package->requires[$requiredPackage] !== $newVersion) {
211			file_put_contents($composerFile, $composerFileContents);
212			$this->output('<error>Could not replace version</error> - generated composer.json was:');
213			$this->output($newComposerFileContents);
214			throw new Exception('Replacing version failed');
215			}
216
217			$this->git('commit', $package->path, array('n' => true, 'm' => "Change required version of $requiredPackage to $newVersion", 'composer.json'));
218			if (!isset($package->source)) {
219			$package->source = new \stdClass();
220			}
221			$package->source->reference = $this->git('rev-parse', $package->path, array('HEAD'));
222
223			$this->console->output("Made <comment>$package->name</comment> require <comment>$requiredPackage $newVersion</comment>");
224
225			$this->pushPackages[$package->name] = $package;
226			}
227
228			/**
229			* Reload the requires from $package composer.json to $package->requires
230			*
231			* If $detectChanges, and there are changes on the requirements not in $ignorePackages
232			* composer update is requested
233			*
234			* @param Package $package The package
235			*
236			* @deprecated Use $package->reloadRequires()
237			*
238			* @return void
239			*/
240			protected function reloadRequires($package)
241			{
242			$package->reloadRequires();
243			}
244
245			/**
246			* Checkout a package at a branch
247			*
248			* @param Package $package The package
249			* @param string $branch The branch
250			* @param bool $create Create the branch if it doesn't exist
251			*
252			* @return bool\|null Whether checkout was successful or null when package is already at this branch
253			*/
254			protected function checkoutPackage($package, $branch, $create = false)
255			{
256			$this->assertPackageAllowed($package);
257
258			if ($package->branch === $branch) {
259			return null;
260			}
261			if (!$package->git) {
262			throw new Exception('Non git package can not be checked out');
263			}
264			$remoteBranch = 'origin/' . $branch;
265			$isRemote = in_array($remoteBranch, $package->branches, true);
266			if (in_array($branch, $package->branches, true)) {
267			$this->git('checkout', $package->path, $branch);
268			} elseif ($isRemote) {
269			$this->git('checkout', $package->path, array('b' => $branch, $remoteBranch));
270			} elseif ($create) {
271			$branches = array_unique(
272			array_map(
273			function ($el) {
274			$parts = explode('/', $el);
275			return array_pop($parts);
276			},
277			$package->branches
278			)
279			);
280			sort($branches);
281			$inferFromBranch = $this->choose(
282			"Select branch to create new branch '$branch' from in {$package->name}",
283			$branches, in_array('master', $branches, true) ? 'master' : $branch
284			);
285			if ($inferFromBranch !== $package->branch) {
286			$this->checkoutPackage($package, $inferFromBranch);
287			}
288			$this->git('checkout', $package->path, array('b' => $branch));
289			$package->branches[] = $branch;
290			} else {
291			return false;
292			}
293
294			if ($isRemote) {
295			if (!isset($package->upstreams[$branch]) \|\| $package->upstreams[$branch] !== $remoteBranch) {
296			$this->git('branch', $package->path, array('u' => $remoteBranch));
297			$package->upstreams[$branch] = $remoteBranch;
298			}
299			$this->git('rebase', $package->path);
300			}
301
302			$this->console->output("Checked out <comment>{$package->name}</comment> at <comment>$branch</comment>");
303
304			$this->reloadRequires($package);
			0 ignored issues – show Deprecated Code introduced 2016-05-10 09:23 UTC by Report Bug Copy Issue Report The method `Netresearch\Kite\Workflo...\Base::reloadRequires()` has been deprecated with message: Use $package->reloadRequires() This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
305			$package->version = 'dev-' . $branch;
306			$package->branch = $branch;
307
308			return true;
309			}
310
311			/**
312			* Merge a $branch into $package's current branch
313			*
314			* @param Package $package The package
315			* @param string $branch The branch
316			* @param null $message The commit message (if any)
317			* @param bool $squash Whether to squash the changes
318			*
319			* @return void
320			*/
321			protected function mergePackage($package, $branch, $message = null, $squash = false)
322			{
323			$this->assertPackageAllowed($package);
324
325			if (!$package->git) {
326			throw new Exception('Non git package can not be merged');
327			}
328
329			$this->git('fetch', $package->path, array('force' => true, 'origin', $branch . ':' . $branch));
330
331			$ff = $branch == 'master' ? 'ff' : 'no-ff';
332			$optArg = array($ff => true, 'no-commit' => true);
333			if ($squash) {
334			$optArg['squash'] = true;
335			}
336			$optArg[] = $branch;
337
338			try {
339			$this->git('merge', $package->path, $optArg);
340			} catch (\Exception $e) {
341			$diff = $this->git('diff', $package->path, array('name-only' => true, 'diff-filter' => 'U'));
342			$conflictedFiles = array_flip(explode("\n", $diff));
343			if (array_key_exists('composer.json', $conflictedFiles)) {
344			try {
345			$this->resolveRequirementsConflict($package);
346			$this->git('add', $package->path, 'composer.json');
347			} catch (Exception $conflictSolvingException) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-03-18 14:36 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
348			}
349			}
350			if (array_diff(array_keys($conflictedFiles), ['composer.json'])) {
351			throw new Exception(
352			'There are unresolved conflicts - please resolve them and then commit the result',
353			1458307785, isset($conflictSolvingException) ? $conflictSolvingException : null
354			);
355			} elseif (isset($conflictSolvingException)) {
356			throw $conflictSolvingException;
357			}
358			}
359			if (isset($conflictedFiles) \|\| $this->git('status', $package->path, array('porcelain' => true))) {
360			if (!$message) {
361			$message = $this->answer(
362			'Enter commit message:',
363			'Merged ' . $branch . ' into ' . $package->branch
364			);
365			}
366			$this->git('commit', $package->path, array('n' => true, 'm' => $message));
367			}
368
369			$this->console->output("Merged with <comment>$branch</comment> in <comment>{$package->name}</comment>");
370
371			$this->reloadRequires($package);
			0 ignored issues – show Deprecated Code introduced 2016-05-10 09:23 UTC by Report Bug Copy Issue Report The method `Netresearch\Kite\Workflo...\Base::reloadRequires()` has been deprecated with message: Use $package->reloadRequires() This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
372			$this->pushPackages[$package->name] = $package;
373			}
374
375			/**
376			* Try to solve conflicts inside the require section of the $package composer.json
377			*
378			* @param Package $package The package
379			*
380			* @return void
381			*/
382			private function resolveRequirementsConflict($package)
383			{
384			$contents = file_get_contents($package->path . '/composer.json');
385			$ours = @json_decode(
386			preg_replace('/^<{7}.+\n(.+)\n(\\|{7}\|={7}).+>{7}.+$/smU', '$1', $contents)
387			);
388			$theirs = @json_decode(
389			preg_replace('/^<{7}.+\n={7}\n(.+)\n>{7}.+$/smU', '$1', $contents)
390			);
391			if (!is_object($ours) \|\| !is_object($theirs)) {
392			throw new Exception('Could not regenerate json file from solved conflicts');
393			}
394			$diff = array_diff_key($theirs = get_object_vars($theirs), $ours = get_object_vars($ours));
395			foreach ($ours as $key => $value) {
396			if ($key !== 'require' && (!array_key_exists($key, $theirs) \|\| serialize($value) !== serialize($theirs[$key]))) {
397			$diff[$key] = $value;
398			}
399			}
400			if ($diff !== array()) {
401			throw new Exception('Can not automerge composer.json due to conflicts outside require object', 1458307516);
402			}
403
404			$theirs['require'] = $this->mergeRequirements($package, $ours, $theirs);
405			file_put_contents($package->path . '/composer.json', $this->jsonEncode($theirs));
406			}
407
408			/**
409			* Encode a variable for JSON file
410			*
411			* @param mixed $var The var
412			*
413			* @return string
414			*/
415			protected function jsonEncode($var)
416			{
417			return json_encode(
418			$var, JSON_PRETTY_PRINT \| JSON_UNESCAPED_SLASHES \| JSON_UNESCAPED_UNICODE
419			) . "\n";
420			}
421
422			/**
423			* Merge the requirements from different sides of the current $package
424			*
425			* @param Package $package The current package
426			* @param array $ours Our composer.json as array
427			* @param array $theirs Their composer.json as array
428			*
429			* @return array
430			*/
431			private function mergeRequirements($package, array $ours, array $theirs)
432			{
433			$oursRequire = isset($ours['require']) && is_object($ours['require']) ? get_object_vars($ours['require']) : [];
434			$theirsRequire = isset($theirs['require']) && is_object($theirs['require']) ? get_object_vars($theirs['require']) : [];
435			$mergedRequires = array_merge($oursRequire, $theirsRequire);
436			$packages = $this->getPackages(false, false);
437			$preferredVersion = 'dev-' . $package->branch;
438			foreach ($mergedRequires as $packageName => $version) {
439			$actualVersion = ($version === '@dev') ? 'dev-master' : $version;
440			if (array_key_exists($packageName, $oursRequire)
441			&& $version !== $oursRequire[$packageName]
442			&& $actualVersion !== $oursRequire[$packageName]
443			&& $actualVersion !== $preferredVersion
444			&& array_key_exists($packageName, $packages)
445			&& in_array($package->branch, $packages[$packageName]->branches, true)
446			) {
447			$mergedRequires[$packageName] = $preferredVersion;
448			}
449			}
450			return $mergedRequires;
451			}
452
453			/**
454			* Get the allowed packages
455			*
456			* @param bool $gitOnly If git packages should be returned only
457			* @param bool $allowedOnly If allowed packages should be returned only
458			*
459			* @return \Netresearch\Kite\Service\Composer\Package[]
460			*/
461			protected function getPackages($gitOnly = true, $allowedOnly = true)
462			{
463			/* @var $packages \Netresearch\Kite\Service\Composer\Package[] */
464			/* @var $package \Netresearch\Kite\Service\Composer\Package */
465			$packages = array();
466			foreach ($this->get('composer.packages') as $package) {
467			if ((!$gitOnly \|\| $package->git) && (!$allowedOnly \|\| $this->isPackageAllowed($package))) {
468			$packages[$package->name] = $package;
469			}
470			}
471			return $packages;
472			}
473
474			/**
475			* Assert that package is allowed
476			*
477			* @param Package $package The package
478			*
479			* @throws Exception
480			*
481			* @return void
482			*/
483			protected function assertPackageAllowed($package)
484			{
485			if (!$this->isPackageAllowed($package)) {
486			throw new Exception("Package {$package->name} is not in white list");
487			}
488			}
489
490			/**
491			* Determine if a package is whitelisted
492			*
493			* @param Package $package The package
494			*
495			* @return bool
496			*/
497			protected function isPackageAllowed(Package $package)
498			{
499			$whitelistTypes = ['path', 'remote', 'name'];
500			if (!is_array($this->whitelists)) {
501			$this->whitelists = [];
502			foreach ($whitelistTypes as $whitelistType) {
503			$option = $this->get('whitelist' . ucfirst($whitelistType) . 's');
504			if ($option) {
505			$this->whitelists[$whitelistType] = '#^' . $option . '$#';
506			}
507			}
508			}
509
510			if (!$this->whitelists) {
			0 ignored issues – show Bug Best Practice introduced 2016-03-18 14:36 UTC by Report Bug Copy Issue Report The expression `$this->whitelists` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
511			// Without whitelists, all packages are allowed
512			return true;
513			}
514
515			foreach ($this->whitelists as $type => $pattern) {
516			$subject = $package->$type;
517			if ($type === 'path') {
518			$subject = rtrim(
519			$this->console->getFilesystem()->findShortestPath(
520			$this->get('composer.rootPackage.path'),
521			$subject,
522			true
523			),
524			'/'
525			);
526			}
527			if (preg_match($pattern, $subject)) {
528			return true;
529			}
530			}
531
532			return false;
533			}
534			}
535			?>
536

netresearch / kite

GitHub Access Token became invalid

Push — master ( c5752c...f61021 )

Base::jsonEncode() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like