Application::generalCommand() - Code Metrics - Inspection of "Merge branch 'master' of github.com:consolidation-..." - consolidation/cgr - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3b9c69...0cfff3 )

by Greg

created 2016-10-21 00:33 UTC

Application::generalCommand() A

↳ Parent: Application

Complexity

Conditions	2
Paths	2

Size

Total Lines	14
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	14
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	11
nc	2
nop	5

<?php

namespace Consolidation\Cgr;

class Application
{
    protected $outputFile = '';

    /**
     * Run the cgr tool, a safer alternative to `composer global require`.
     *
     * @param array $argv The global $argv array passed in by PHP
     * @param string $home The path to the user's home directory
     * @return integer
     */
    public function run($argv, $home)
    {
        $optionDefaultValues = $this->getDefaultOptionValues($home);
        $optionDefaultValues = $this->overlayEnvironmentValues($optionDefaultValues);

        list($argv, $options) = $this->parseOutOurOptions($argv, $optionDefaultValues);
        $commandList = $this->separateProjectAndGetCommandList($argv, $home, $options);
        return $this->runCommandList($commandList, $options);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Set up output redirection. Used by tests.
     */
    public function setOutputFile($outputFile)
    {
        $this->outputFile = $outputFile;
    }

    /**
     * Figure out everything we're going to do, but don't do any of it
     * yet, just return the command objects to run.
     */
    public function parseArgvAndGetCommandList($argv, $home)
    {
        $optionDefaultValues = $this->getDefaultOptionValues($home);
        $optionDefaultValues = $this->overlayEnvironmentValues($optionDefaultValues);

        list($argv, $options) = $this->parseOutOurOptions($argv, $optionDefaultValues);
        return $this->separateProjectAndGetCommandList($argv, $home, $options);
    }

    /**
     * Figure out everything we're going to do, but don't do any of it
     * yet, just return the command objects to run.
     */
    public function separateProjectAndGetCommandList($argv, $home, $options)

    {
        list($command, $projects, $composerArgs) = $this->separateProjectsFromArgs($argv, $options);
        $commandList = $this->getCommandsToExec($command, $composerArgs, $projects, $options);
        return $commandList;
    }

    /**
     * Run all of the commands in a list.  Abort early if any fail.
     *
     * @param array $commandList An array of CommandToExec
     * @return integer
     */
    public function runCommandList($commandList, $options)

    {
        foreach ($commandList as $command) {
            $exitCode = $command->run($this->outputFile);
            if ($exitCode) {
                return $exitCode;
            }
        }
        return 0;
    }

    /**
     * Return an array containing a list of commands to execute.  Depending on
     * the composition of the aguments and projects parameters, this list will
     * contain either a single command string to call through to composer (if
     * cgr is being used as a composer alias), or it will contain a list of
     * appropriate replacement 'composer global require' commands that install
     * each project in its own installation directory, while installing each
     * projects' binaries in the global Composer bin directory,
     * ~/.composer/vendor/bin.
     *
     * @param array $composerArgs
     * @param array $projects
     * @param array $options
     * @return CommandToExec
     */
    public function getCommandsToExec($command, $composerArgs, $projects, $options)
    {
        $execPath = $options['composer-path'];
        // If command was not 'global require', 'global update' or
        // 'global remove', then call through to the standard composer
        // with all of the original args.
        if (empty($command)) {
            return array(new CommandToExec($execPath, $composerArgs));
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }
        // Call requireCommand, updateCommand, or removeCommand, as appropriate.
        $methodName = "{$command}Command";
        if (function_exists($methodName)) {
            return $this->$methodName($execPath, $composerArgs, $projects, $options);
        } // If there is no specific implementation for the requested command, then call 'generalCommand'.
        else {
            return $this->generalCommand($command, $execPath, $composerArgs, $projects, $options);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }
    }

    /**
     * Return our list of default option values, with paths relative to
     * the provided home directory.
     * @param string $home The user's home directory
     * @return array
     */
    public function getDefaultOptionValues($home)
    {
        return array(
            'composer' => false,
            'composer-path' => 'composer',
            'base-dir' => "$home/.composer/global",
            'bin-dir' => "$home/.composer/vendor/bin",
        );
    }

    /**
     * Replace option default values with the corresponding
     * environment variable value, if it is set.
     */
    protected function overlayEnvironmentValues($defaults)
    {
        foreach ($defaults as $key => $value) {
            $envKey = 'CGR_' . strtoupper(strtr($key, '-', '_'));
            $envValue = getenv($envKey);
            if ($envValue) {
                $defaults[$key] = $envValue;
            }
        }

        return $defaults;
    }

    /**
     * We use our own special-purpose argv parser. The options that apply
     * to this tool are identified by a simple associative array, where
     * the key is the option name, and the value is its default value.
     * The result of this function is an array of two items containing:
     *  - An array of the items in $argv not used to set an option value
     *  - An array of options containing the user-specified or default values
     *
     * @param array $argv The global $argv passed in by php
     * @param array $optionDefaultValues An associative array
     * @return array
     */
    public function parseOutOurOptions($argv, $optionDefaultValues)
    {
        $argv0 = array_shift($argv);
        $options['composer'] = (strpos($argv0, 'composer') !== false);
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        $passAlongArgvItems = array();
        $options = array();
        while (!empty($argv)) {
            $arg = array_shift($argv);
            if ((substr($arg, 0, 2) == '--') && array_key_exists(substr($arg, 2), $optionDefaultValues)) {
                $options[substr($arg, 2)] = array_shift($argv);
            } else {
                $passAlongArgvItems[] = $arg;
            }
        }
        return array($passAlongArgvItems, $options + $optionDefaultValues);
    }

    /**
     * After our options are removed by parseOutOurOptions, those items remaining
     * in $argv will be separated into a list of projects and versions, and
     * anything else that is not a project:version. Returns an array of two
     * items containing:
     *  - An associative array, where the key is the project name and the value
     *    is the version (or an empty string, if no version was specified)
     *  - The remaining $argv items not used to build the projects array.
     *
     * @param array $argv The $argv array from parseOutOurOptions()
     * @return array
     */
    public function separateProjectsFromArgs($argv, $options)
    {
        $cgrCommands = array('require', 'update', 'remove');
        $command = 'require';
        $composerArgs = array();
        $projects = array();
        $globalMode = !$options['composer'];
        foreach ($argv as $arg) {
            if ($arg[0] == '-') {
                // Any flags (first character is '-') will just be passed
                // through to to composer. Flags interpreted by cgr have
                // already been removed from $argv.
                $composerArgs[] = $arg;
            } elseif (strpos($arg, '/') !== false) {
                // Arguments containing a '/' name projects.  We will split
                // the project from its version, allowing the separator
                // character to be either a '=' or a ':', and then store the
                // result in the $projects array.
                $projectAndVersion = explode(':', strtr($arg, '=', ':'), 2) + array('', '');
                list($project, $version) = $projectAndVersion;
                $projects[$project] = $version;
            } elseif ($this->isComposerVersion($arg)) {
                // If an argument is a composer version, then we will alter
                // the last project we saw, attaching this version to it.
                // This allows us to handle 'a/b:1.0' and 'a/b 1.0' equivalently.
                $keys = array_keys($projects);
                $lastProject = array_pop($keys);
                unset($projects[$lastProject]);
                $projects[$lastProject] = $arg;
            } elseif ($arg == 'global') {
                // Make note if we see the 'global' command.
                $globalMode = true;
            } else {
                // If we see any command other than 'global [require|update|remove]',
                // then we will pass *all* of the arguments through to
                // composer unchanged. We return an empty projects array
                // to indicate that this should be a pass-through call
                // to composer, rather than one or more calls to
                // 'composer require' to install global projects.
                if ((!$globalMode) || (!in_array($arg, $cgrCommands))) {
                    return array('', array(), $argv);
                }
                // Remember which command we saw
                $command = $arg;
            }
        }
        return array($command, $projects, $composerArgs);
    }

    /**
     * Provide a safer version of `composer global require`.  Each project
     * listed in $projects will be installed into its own project directory.
     * The binaries from each project will still be placed in the global
     * composer bin directory.
     *
     * @param string $composerCommand The composer command to run e.g. require
     * @param string $execPath The path to composer
     * @param array $composerArgs Anything from the global $argv to be passed
     *   on to Composer
     * @param array $projects A list of projects to install, with the key
     *   specifying the project name, and the value specifying its version.
     * @param array $options User options from the command line; see
     *   $optionDefaultValues in the main() function.
     * @return array
     */
    public function generalCommand($composerCommand, $execPath, $composerArgs, $projects, $options)
    {
        $globalBaseDir = $options['base-dir'];
        $binDir = $options['bin-dir'];
        $env = array("COMPOSER_BIN_DIR" => $binDir);
        $result = array();
        foreach ($projects as $project => $version) {
            $installLocation = "$globalBaseDir/$project";
            $projectWithVersion = $this->projectWithVersion($project, $version);
            $commandToExec = $this->buildGlobalCommand($composerCommand, $execPath, $composerArgs, $projectWithVersion, $env, $installLocation);
            $result[] = $commandToExec;
        }
        return $result;
    }

    /**
     * Run `composer global update`. Not only do we want to update the
     * "global" Composer project, we also want to update all of the
     * "isolated" projects installed via cgr in ~/.composer/global.
     *
     * @param string $command The path to composer
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param array $composerArgs Anything from the global $argv to be passed
     *   on to Composer
     * @param array $projects A list of projects to update.
     * @param array $options User options from the command line; see
     *   $optionDefaultValues in the main() function.
     * @return array
     */
    public function updateCommand($execPath, $composerArgs, $projects, $options)
    {
        // TODO: if projects are empty, make a list of everything currently installed
        return $this->generalCommand('update', $execPath, $composerArgs, $projects, $options);
    }

    /**
     * Return $project:$version, or just $project if there is no $version.
     *
     * @param string $project The project to install
     * @param string $version The version desired
     * @return string
     */
    public function projectWithVersion($project, $version)
    {
        if (empty($version)) {
            return $project;
        }
        return "$project:$version";
    }

    /**
     * Generate command string to call `composer require` to install one project.
     *
     * @param string $command The path to composer
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param array $composerArgs The arguments to pass to composer
     * @param string $projectWithVersion The project:version to install
     * @param array $env Environment to set prior to exec
     * @param string $installLocation Location to install the project
     * @return CommandToExec
     */
    public function buildGlobalCommand($composerCommand, $execPath, $composerArgs, $projectWithVersion, $env, $installLocation)
    {
        $projectSpecificArgs = array("--working-dir=$installLocation", $composerCommand, $projectWithVersion);
        $arguments = array_merge($composerArgs, $projectSpecificArgs);
        return new CommandToExec($execPath, $arguments, $env, $installLocation);
    }

    /**
     * Identify an argument that could be a Composer version string.
     *
     * @param string $arg The argument to test
     * @return boolean
     */
    public function isComposerVersion($arg)
    {
        $specialVersionChars = array('^', '~', '<', '>');
        return is_numeric($arg[0]) || in_array($arg[0], $specialVersionChars);
    }
}


1			<?php
2
3			namespace Consolidation\Cgr;
4
5			class Application
6			{
7			protected $outputFile = '';
8
9			/**
10			* Run the cgr tool, a safer alternative to `composer global require`.
11			*
12			* @param array $argv The global $argv array passed in by PHP
13			* @param string $home The path to the user's home directory
14			* @return integer
15			*/
16			public function run($argv, $home)
17			{
18			$optionDefaultValues = $this->getDefaultOptionValues($home);
19			$optionDefaultValues = $this->overlayEnvironmentValues($optionDefaultValues);
20
21			list($argv, $options) = $this->parseOutOurOptions($argv, $optionDefaultValues);
22			$commandList = $this->separateProjectAndGetCommandList($argv, $home, $options);
23			return $this->runCommandList($commandList, $options);
			0 ignored issues – show Documentation introduced 2016-08-09 02:42 UTC by Report Bug Copy Issue Report `$commandList` is of type `object<Consolidation\Cgr\CommandToExec>`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
24			}
25
26			/**
27			* Set up output redirection. Used by tests.
28			*/
29			public function setOutputFile($outputFile)
30			{
31			$this->outputFile = $outputFile;
32			}
33
34			/**
35			* Figure out everything we're going to do, but don't do any of it
36			* yet, just return the command objects to run.
37			*/
38			public function parseArgvAndGetCommandList($argv, $home)
39			{
40			$optionDefaultValues = $this->getDefaultOptionValues($home);
41			$optionDefaultValues = $this->overlayEnvironmentValues($optionDefaultValues);
42
43			list($argv, $options) = $this->parseOutOurOptions($argv, $optionDefaultValues);
44			return $this->separateProjectAndGetCommandList($argv, $home, $options);
45			}
46
47			/**
48			* Figure out everything we're going to do, but don't do any of it
49			* yet, just return the command objects to run.
50			*/
51			public function separateProjectAndGetCommandList($argv, $home, $options)
			0 ignored issues – show Unused Code introduced 2016-06-04 01:45 UTC by Report Bug Copy Issue Report The parameter `$home` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
52			{
53			list($command, $projects, $composerArgs) = $this->separateProjectsFromArgs($argv, $options);
54			$commandList = $this->getCommandsToExec($command, $composerArgs, $projects, $options);
55			return $commandList;
56			}
57
58			/**
59			* Run all of the commands in a list. Abort early if any fail.
60			*
61			* @param array $commandList An array of CommandToExec
62			* @return integer
63			*/
64			public function runCommandList($commandList, $options)
			0 ignored issues – show Unused Code introduced 2016-06-04 04:08 UTC by Report Bug Copy Issue Report The parameter `$options` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
65			{
66			foreach ($commandList as $command) {
67			$exitCode = $command->run($this->outputFile);
68			if ($exitCode) {
69			return $exitCode;
70			}
71			}
72			return 0;
73			}
74
75			/**
76			* Return an array containing a list of commands to execute. Depending on
77			* the composition of the aguments and projects parameters, this list will
78			* contain either a single command string to call through to composer (if
79			* cgr is being used as a composer alias), or it will contain a list of
80			* appropriate replacement 'composer global require' commands that install
81			* each project in its own installation directory, while installing each
82			* projects' binaries in the global Composer bin directory,
83			* ~/.composer/vendor/bin.
84			*
85			* @param array $composerArgs
86			* @param array $projects
87			* @param array $options
88			* @return CommandToExec
89			*/
90			public function getCommandsToExec($command, $composerArgs, $projects, $options)
91			{
92			$execPath = $options['composer-path'];
93			// If command was not 'global require', 'global update' or
94			// 'global remove', then call through to the standard composer
95			// with all of the original args.
96			if (empty($command)) {
97			return array(new CommandToExec($execPath, $composerArgs));
			0 ignored issues – show Bug Best Practice introduced 2016-08-09 02:42 UTC by Report Bug Copy Issue Report The return type of `return array(new \Consol...cPath, $composerArgs));` (`Consolidation\Cgr\CommandToExec[]`) is incompatible with the return type documented by `Consolidation\Cgr\Application::getCommandsToExec` of type `Consolidation\Cgr\CommandToExec`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
98			}
99			// Call requireCommand, updateCommand, or removeCommand, as appropriate.
100			$methodName = "{$command}Command";
101			if (function_exists($methodName)) {
102			return $this->$methodName($execPath, $composerArgs, $projects, $options);
103			} // If there is no specific implementation for the requested command, then call 'generalCommand'.
104			else {
105			return $this->generalCommand($command, $execPath, $composerArgs, $projects, $options);
			0 ignored issues – show Bug Best Practice introduced 2016-10-21 00:15 UTC by Report Bug Copy Issue Report The return type of `return $this->generalCom..., $projects, $options);` (`array`) is incompatible with the return type documented by `Consolidation\Cgr\Application::getCommandsToExec` of type `Consolidation\Cgr\CommandToExec`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
106			}
107			}
108
109			/**
110			* Return our list of default option values, with paths relative to
111			* the provided home directory.
112			* @param string $home The user's home directory
113			* @return array
114			*/
115			public function getDefaultOptionValues($home)
116			{
117			return array(
118			'composer' => false,
119			'composer-path' => 'composer',
120			'base-dir' => "$home/.composer/global",
121			'bin-dir' => "$home/.composer/vendor/bin",
122			);
123			}
124
125			/**
126			* Replace option default values with the corresponding
127			* environment variable value, if it is set.
128			*/
129			protected function overlayEnvironmentValues($defaults)
130			{
131			foreach ($defaults as $key => $value) {
132			$envKey = 'CGR_' . strtoupper(strtr($key, '-', '_'));
133			$envValue = getenv($envKey);
134			if ($envValue) {
135			$defaults[$key] = $envValue;
136			}
137			}
138
139			return $defaults;
140			}
141
142			/**
143			* We use our own special-purpose argv parser. The options that apply
144			* to this tool are identified by a simple associative array, where
145			* the key is the option name, and the value is its default value.
146			* The result of this function is an array of two items containing:
147			* - An array of the items in $argv not used to set an option value
148			* - An array of options containing the user-specified or default values
149			*
150			* @param array $argv The global $argv passed in by php
151			* @param array $optionDefaultValues An associative array
152			* @return array
153			*/
154			public function parseOutOurOptions($argv, $optionDefaultValues)
155			{
156			$argv0 = array_shift($argv);
157			$options['composer'] = (strpos($argv0, 'composer') !== false);
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-08-09 02:42 UTC by Report Bug Copy Issue Report `$options` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$options = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
158			$passAlongArgvItems = array();
159			$options = array();
160			while (!empty($argv)) {
161			$arg = array_shift($argv);
162			if ((substr($arg, 0, 2) == '--') && array_key_exists(substr($arg, 2), $optionDefaultValues)) {
163			$options[substr($arg, 2)] = array_shift($argv);
164			} else {
165			$passAlongArgvItems[] = $arg;
166			}
167			}
168			return array($passAlongArgvItems, $options + $optionDefaultValues);
169			}
170
171			/**
172			* After our options are removed by parseOutOurOptions, those items remaining
173			* in $argv will be separated into a list of projects and versions, and
174			* anything else that is not a project:version. Returns an array of two
175			* items containing:
176			* - An associative array, where the key is the project name and the value
177			* is the version (or an empty string, if no version was specified)
178			* - The remaining $argv items not used to build the projects array.
179			*
180			* @param array $argv The $argv array from parseOutOurOptions()
181			* @return array
182			*/
183			public function separateProjectsFromArgs($argv, $options)
184			{
185			$cgrCommands = array('require', 'update', 'remove');
186			$command = 'require';
187			$composerArgs = array();
188			$projects = array();
189			$globalMode = !$options['composer'];
190			foreach ($argv as $arg) {
191			if ($arg[0] == '-') {
192			// Any flags (first character is '-') will just be passed
193			// through to to composer. Flags interpreted by cgr have
194			// already been removed from $argv.
195			$composerArgs[] = $arg;
196			} elseif (strpos($arg, '/') !== false) {
197			// Arguments containing a '/' name projects. We will split
198			// the project from its version, allowing the separator
199			// character to be either a '=' or a ':', and then store the
200			// result in the $projects array.
201			$projectAndVersion = explode(':', strtr($arg, '=', ':'), 2) + array('', '');
202			list($project, $version) = $projectAndVersion;
203			$projects[$project] = $version;
204			} elseif ($this->isComposerVersion($arg)) {
205			// If an argument is a composer version, then we will alter
206			// the last project we saw, attaching this version to it.
207			// This allows us to handle 'a/b:1.0' and 'a/b 1.0' equivalently.
208			$keys = array_keys($projects);
209			$lastProject = array_pop($keys);
210			unset($projects[$lastProject]);
211			$projects[$lastProject] = $arg;
212			} elseif ($arg == 'global') {
213			// Make note if we see the 'global' command.
214			$globalMode = true;
215			} else {
216			// If we see any command other than 'global [require\|update\|remove]',
217			// then we will pass all of the arguments through to
218			// composer unchanged. We return an empty projects array
219			// to indicate that this should be a pass-through call
220			// to composer, rather than one or more calls to
221			// 'composer require' to install global projects.
222			if ((!$globalMode) \|\| (!in_array($arg, $cgrCommands))) {
223			return array('', array(), $argv);
224			}
225			// Remember which command we saw
226			$command = $arg;
227			}
228			}
229			return array($command, $projects, $composerArgs);
230			}
231
232			/**
233			* Provide a safer version of `composer global require`. Each project
234			* listed in $projects will be installed into its own project directory.
235			* The binaries from each project will still be placed in the global
236			* composer bin directory.
237			*
238			* @param string $composerCommand The composer command to run e.g. require
239			* @param string $execPath The path to composer
240			* @param array $composerArgs Anything from the global $argv to be passed
241			* on to Composer
242			* @param array $projects A list of projects to install, with the key
243			* specifying the project name, and the value specifying its version.
244			* @param array $options User options from the command line; see
245			* $optionDefaultValues in the main() function.
246			* @return array
247			*/
248			public function generalCommand($composerCommand, $execPath, $composerArgs, $projects, $options)
249			{
250			$globalBaseDir = $options['base-dir'];
251			$binDir = $options['bin-dir'];
252			$env = array("COMPOSER_BIN_DIR" => $binDir);
253			$result = array();
254			foreach ($projects as $project => $version) {
255			$installLocation = "$globalBaseDir/$project";
256			$projectWithVersion = $this->projectWithVersion($project, $version);
257			$commandToExec = $this->buildGlobalCommand($composerCommand, $execPath, $composerArgs, $projectWithVersion, $env, $installLocation);
258			$result[] = $commandToExec;
259			}
260			return $result;
261			}
262
263			/**
264			* Run `composer global update`. Not only do we want to update the
265			* "global" Composer project, we also want to update all of the
266			* "isolated" projects installed via cgr in ~/.composer/global.
267			*
268			* @param string $command The path to composer
			0 ignored issues – show Bug introduced 2016-08-09 02:42 UTC by Report Bug Copy Issue Report There is no parameter named `$command`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
269			* @param array $composerArgs Anything from the global $argv to be passed
270			* on to Composer
271			* @param array $projects A list of projects to update.
272			* @param array $options User options from the command line; see
273			* $optionDefaultValues in the main() function.
274			* @return array
275			*/
276			public function updateCommand($execPath, $composerArgs, $projects, $options)
277			{
278			// TODO: if projects are empty, make a list of everything currently installed
279			return $this->generalCommand('update', $execPath, $composerArgs, $projects, $options);
280			}
281
282			/**
283			* Return $project:$version, or just $project if there is no $version.
284			*
285			* @param string $project The project to install
286			* @param string $version The version desired
287			* @return string
288			*/
289			public function projectWithVersion($project, $version)
290			{
291			if (empty($version)) {
292			return $project;
293			}
294			return "$project:$version";
295			}
296
297			/**
298			* Generate command string to call `composer require` to install one project.
299			*
300			* @param string $command The path to composer
			0 ignored issues – show Documentation introduced 2016-10-21 00:15 UTC by Report Bug Copy Issue Report There is no parameter named `$command`. Did you maybe mean `$composerCommand`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
301			* @param array $composerArgs The arguments to pass to composer
302			* @param string $projectWithVersion The project:version to install
303			* @param array $env Environment to set prior to exec
304			* @param string $installLocation Location to install the project
305			* @return CommandToExec
306			*/
307			public function buildGlobalCommand($composerCommand, $execPath, $composerArgs, $projectWithVersion, $env, $installLocation)
308			{
309			$projectSpecificArgs = array("--working-dir=$installLocation", $composerCommand, $projectWithVersion);
310			$arguments = array_merge($composerArgs, $projectSpecificArgs);
311			return new CommandToExec($execPath, $arguments, $env, $installLocation);
312			}
313
314			/**
315			* Identify an argument that could be a Composer version string.
316			*
317			* @param string $arg The argument to test
318			* @return boolean
319			*/
320			public function isComposerVersion($arg)
321			{
322			$specialVersionChars = array('^', '~', '<', '>');
323			return is_numeric($arg[0]) \|\| in_array($arg[0], $specialVersionChars);
324			}
325			}
326

consolidation / cgr

Push — master ( 3b9c69...0cfff3 )

Application::generalCommand() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like