Config.php
No OneTemporary
Actions

Size

57 KB

Referenced Files

None

Subscribers

None

Config.php
View Options

	<?php
	/**
	* Stores the configuration used to run PHPCS and PHPCBF.
	*
	* Parses the command line to determine user supplied values
	* and provides functions to access data stored in config files.
	*
	* @author Greg Sherwood <gsherwood@squiz.net>
	* @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600)
	* @license https://github.com/PHPCSStandards/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
	*/

	namespace PHP_CodeSniffer;

	use Exception;
	use Phar;
	use PHP_CodeSniffer\Exceptions\DeepExitException;
	use PHP_CodeSniffer\Exceptions\RuntimeException;
	use PHP_CodeSniffer\Util\Common;
	use PHP_CodeSniffer\Util\Help;
	use PHP_CodeSniffer\Util\Standards;

	/**
	* Stores the configuration used to run PHPCS and PHPCBF.
	*
	* @property string[] $files The files and directories to check.
	* @property string[] $standards The standards being used for checking.
	* @property int $verbosity How verbose the output should be.
	* 0: no unnecessary output
	* 1: basic output for files being checked
	* 2: ruleset and file parsing output
	* 3: sniff execution output
	* @property bool $interactive Enable interactive checking mode.
	* @property int $parallel Check files in parallel.
	* @property bool $cache Enable the use of the file cache.
	* @property string $cacheFile Path to the file where the cache data should be written
	* @property bool $colors Display colours in output.
	* @property bool $explain Explain the coding standards.
	* @property bool $local Process local files in directories only (no recursion).
	* @property bool $showSources Show sniff source codes in report output.
	* @property bool $showProgress Show basic progress information while running.
	* @property bool $quiet Quiet mode; disables progress and verbose output.
	* @property bool $annotations Process phpcs: annotations.
	* @property int $tabWidth How many spaces each tab is worth.
	* @property string $encoding The encoding of the files being checked.
	* @property string[] $sniffs The sniffs that should be used for checking.
	* If empty, all sniffs in the supplied standards will be used.
	* @property string[] $exclude The sniffs that should be excluded from checking.
	* If empty, all sniffs in the supplied standards will be used.
	* @property string[] $ignored Regular expressions used to ignore files and folders during checking.
	* @property string $reportFile A file where the report output should be written.
	* @property string $generator The documentation generator to use.
	* @property string $filter The filter to use for the run.
	* @property string[] $bootstrap One of more files to include before the run begins.
	* @property int\|string $reportWidth The maximum number of columns that reports should use for output.
	* Set to "auto" for have this value changed to the width of the terminal.
	* @property int $errorSeverity The minimum severity an error must have to be displayed.
	* @property int $warningSeverity The minimum severity a warning must have to be displayed.
	* @property bool $recordErrors Record the content of error messages as well as error counts.
	* @property string $suffix A suffix to add to fixed files.
	* @property string $basepath A file system location to strip from the paths of files shown in reports.
	* @property bool $stdin Read content from STDIN instead of supplied files.
	* @property string $stdinContent Content passed directly to PHPCS on STDIN.
	* @property string $stdinPath The path to use for content passed on STDIN.
	* @property bool $trackTime Whether or not to track sniff run time.
	*
	* @property array<string, string> $extensions File extensions that should be checked, and what tokenizer to use.
	* E.g., array('inc' => 'PHP');
	* @property array<string, string\|null> $reports The reports to use for printing output after the run.
	* The format of the array is:
	* array(
	* 'reportName1' => 'outputFile',
	* 'reportName2' => null,
	* );
	* If the array value is NULL, the report will be written to the screen.
	*
	* @property string[] $unknown Any arguments gathered on the command line that are unknown to us.
	* E.g., using `phpcs -c` will give array('c');
	*/
	class Config
	{

	/**
	* The current version.
	*
	* @var string
	*/
	const VERSION = '3.10.3';

	/**
	* Package stability; either stable, beta or alpha.
	*
	* @var string
	*/
	const STABILITY = 'stable';

	/**
	* Default report width when no report width is provided and 'auto' does not yield a valid width.
	*
	* @var int
	*/
	const DEFAULT_REPORT_WIDTH = 80;

	/**
	* An array of settings that PHPCS and PHPCBF accept.
	*
	* This array is not meant to be accessed directly. Instead, use the settings
	* as if they are class member vars so the __get() and __set() magic methods
	* can be used to validate the values. For example, to set the verbosity level to
	* level 2, use $this->verbosity = 2; instead of accessing this property directly.
	*
	* Each of these settings is described in the class comment property list.
	*
	* @var array<string, mixed>
	*/
	private $settings = [
	'files' => null,
	'standards' => null,
	'verbosity' => null,
	'interactive' => null,
	'parallel' => null,
	'cache' => null,
	'cacheFile' => null,
	'colors' => null,
	'explain' => null,
	'local' => null,
	'showSources' => null,
	'showProgress' => null,
	'quiet' => null,
	'annotations' => null,
	'tabWidth' => null,
	'encoding' => null,
	'extensions' => null,
	'sniffs' => null,
	'exclude' => null,
	'ignored' => null,
	'reportFile' => null,
	'generator' => null,
	'filter' => null,
	'bootstrap' => null,
	'reports' => null,
	'basepath' => null,
	'reportWidth' => null,
	'errorSeverity' => null,
	'warningSeverity' => null,
	'recordErrors' => null,
	'suffix' => null,
	'stdin' => null,
	'stdinContent' => null,
	'stdinPath' => null,
	'trackTime' => null,
	'unknown' => null,
	];

	/**
	* Whether or not to kill the process when an unknown command line arg is found.
	*
	* If FALSE, arguments that are not command line options or file/directory paths
	* will be ignored and execution will continue. These values will be stored in
	* $this->unknown.
	*
	* @var boolean
	*/
	public $dieOnUnknownArg;

	/**
	* The current command line arguments we are processing.
	*
	* @var string[]
	*/
	private $cliArgs = [];

	/**
	* Command line values that the user has supplied directly.
	*
	* @var array<string, true\|array<string, true>>
	*/
	private static $overriddenDefaults = [];

	/**
	* Config file data that has been loaded for the run.
	*
	* @var array<string, string>
	*/
	private static $configData = null;

	/**
	* The full path to the config data file that has been loaded.
	*
	* @var string
	*/
	private static $configDataFile = null;

	/**
	* Automatically discovered executable utility paths.
	*
	* @var array<string, string>
	*/
	private static $executablePaths = [];


	/**
	* Get the value of an inaccessible property.
	*
	* @param string $name The name of the property.
	*
	* @return mixed
	* @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the setting name is invalid.
	*/
	public function __get($name)
	{
	if (array_key_exists($name, $this->settings) === false) {
	throw new RuntimeException("ERROR: unable to get value of property \"$name\"");
	}

	// Figure out what the terminal width needs to be for "auto".
	if ($name === 'reportWidth' && $this->settings[$name] === 'auto') {
	if (function_exists('shell_exec') === true) {
	$dimensions = shell_exec('stty size 2>&1');
	if (is_string($dimensions) === true && preg_match('\|\d+ (\d+)\|', $dimensions, $matches) === 1) {
	$this->settings[$name] = (int) $matches[1];
	}
	}

	if ($this->settings[$name] === 'auto') {
	// If shell_exec wasn't available or didn't yield a usable value, set to the default.
	// This will prevent subsequent retrievals of the reportWidth from making another call to stty.
	$this->settings[$name] = self::DEFAULT_REPORT_WIDTH;
	}
	}

	return $this->settings[$name];

	}//end __get()


	/**
	* Set the value of an inaccessible property.
	*
	* @param string $name The name of the property.
	* @param mixed $value The value of the property.
	*
	* @return void
	* @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the setting name is invalid.
	*/
	public function __set($name, $value)
	{
	if (array_key_exists($name, $this->settings) === false) {
	throw new RuntimeException("Can't __set() $name; setting doesn't exist");
	}

	switch ($name) {
	case 'reportWidth' :
	if (is_string($value) === true && $value === 'auto') {
	// Nothing to do. Leave at 'auto'.
	break;
	}

	if (is_int($value) === true) {
	$value = abs($value);
	} else if (is_string($value) === true && preg_match('`^\d+$`', $value) === 1) {
	$value = (int) $value;
	} else {
	$value = self::DEFAULT_REPORT_WIDTH;
	}
	break;

	case 'standards' :
	$cleaned = [];

	// Check if the standard name is valid, or if the case is invalid.
	$installedStandards = Standards::getInstalledStandards();
	foreach ($value as $standard) {
	foreach ($installedStandards as $validStandard) {
	if (strtolower($standard) === strtolower($validStandard)) {
	$standard = $validStandard;
	break;
	}
	}

	$cleaned[] = $standard;
	}

	$value = $cleaned;
	break;

	// Only track time when explicitly needed.
	case 'verbosity':
	if ($value > 2) {
	$this->settings['trackTime'] = true;
	}
	break;
	case 'reports':
	$reports = array_change_key_case($value, CASE_LOWER);
	if (array_key_exists('performance', $reports) === true) {
	$this->settings['trackTime'] = true;
	}
	break;

	default :
	// No validation required.
	break;
	}//end switch

	$this->settings[$name] = $value;

	}//end __set()


	/**
	* Check if the value of an inaccessible property is set.
	*
	* @param string $name The name of the property.
	*
	* @return bool
	*/
	public function __isset($name)
	{
	return isset($this->settings[$name]);

	}//end __isset()


	/**
	* Unset the value of an inaccessible property.
	*
	* @param string $name The name of the property.
	*
	* @return void
	*/
	public function __unset($name)
	{
	$this->settings[$name] = null;

	}//end __unset()


	/**
	* Get the array of all config settings.
	*
	* @return array<string, mixed>
	*/
	public function getSettings()
	{
	return $this->settings;

	}//end getSettings()


	/**
	* Set the array of all config settings.
	*
	* @param array<string, mixed> $settings The array of config settings.
	*
	* @return void
	*/
	public function setSettings($settings)
	{
	return $this->settings = $settings;

	}//end setSettings()


	/**
	* Creates a Config object and populates it with command line values.
	*
	* @param array $cliArgs An array of values gathered from CLI args.
	* @param bool $dieOnUnknownArg Whether or not to kill the process when an
	* unknown command line arg is found.
	*
	* @return void
	*/
	public function __construct(array $cliArgs=[], $dieOnUnknownArg=true)
	{
	if (defined('PHP_CODESNIFFER_IN_TESTS') === true) {
	// Let everything through during testing so that we can
	// make use of PHPUnit command line arguments as well.
	$this->dieOnUnknownArg = false;
	} else {
	$this->dieOnUnknownArg = $dieOnUnknownArg;
	}

	if (empty($cliArgs) === true) {
	$cliArgs = $_SERVER['argv'];
	array_shift($cliArgs);
	}

	$this->restoreDefaults();
	$this->setCommandLineValues($cliArgs);

	if (isset(self::$overriddenDefaults['standards']) === false) {
	// They did not supply a standard to use.
	// Look for a default ruleset in the current directory or higher.
	$currentDir = getcwd();

	$defaultFiles = [
	'.phpcs.xml',
	'phpcs.xml',
	'.phpcs.xml.dist',
	'phpcs.xml.dist',
	];

	do {
	foreach ($defaultFiles as $defaultFilename) {
	$default = $currentDir.DIRECTORY_SEPARATOR.$defaultFilename;
	if (is_file($default) === true) {
	$this->standards = [$default];
	break(2);
	}
	}

	$lastDir = $currentDir;
	$currentDir = dirname($currentDir);
	} while ($currentDir !== '.' && $currentDir !== $lastDir && Common::isReadable($currentDir) === true);
	}//end if

	if (defined('STDIN') === false
	\|\| stripos(PHP_OS, 'WIN') === 0
	) {
	return;
	}

	$handle = fopen('php://stdin', 'r');

	// Check for content on STDIN.
	if ($this->stdin === true
	\|\| (Common::isStdinATTY() === false
	&& feof($handle) === false)
	) {
	$readStreams = [$handle];
	$writeSteams = null;

	$fileContents = '';
	while (is_resource($handle) === true && feof($handle) === false) {
	// Set a timeout of 200ms.
	if (stream_select($readStreams, $writeSteams, $writeSteams, 0, 200000) === 0) {
	break;
	}

	$fileContents .= fgets($handle);
	}

	if (trim($fileContents) !== '') {
	$this->stdin = true;
	$this->stdinContent = $fileContents;
	self::$overriddenDefaults['stdin'] = true;
	self::$overriddenDefaults['stdinContent'] = true;
	}
	}//end if

	fclose($handle);

	}//end __construct()


	/**
	* Set the command line values.
	*
	* @param array $args An array of command line arguments to set.
	*
	* @return void
	*/
	public function setCommandLineValues($args)
	{
	$this->cliArgs = $args;
	$numArgs = count($args);

	for ($i = 0; $i < $numArgs; $i++) {
	$arg = $this->cliArgs[$i];
	if ($arg === '') {
	continue;
	}

	if ($arg[0] === '-') {
	if ($arg === '-') {
	// Asking to read from STDIN.
	$this->stdin = true;
	self::$overriddenDefaults['stdin'] = true;
	continue;
	}

	if ($arg === '--') {
	// Empty argument, ignore it.
	continue;
	}

	if ($arg[1] === '-') {
	$this->processLongArgument(substr($arg, 2), $i);
	} else {
	$switches = str_split($arg);
	foreach ($switches as $switch) {
	if ($switch === '-') {
	continue;
	}

	$this->processShortArgument($switch, $i);
	}
	}
	} else {
	$this->processUnknownArgument($arg, $i);
	}//end if
	}//end for

	}//end setCommandLineValues()


	/**
	* Restore default values for all possible command line arguments.
	*
	* @return void
	*/
	public function restoreDefaults()
	{
	$this->files = [];
	$this->standards = ['PEAR'];
	$this->verbosity = 0;
	$this->interactive = false;
	$this->cache = false;
	$this->cacheFile = null;
	$this->colors = false;
	$this->explain = false;
	$this->local = false;
	$this->showSources = false;
	$this->showProgress = false;
	$this->quiet = false;
	$this->annotations = true;
	$this->parallel = 1;
	$this->tabWidth = 0;
	$this->encoding = 'utf-8';
	$this->extensions = [
	'php' => 'PHP',
	'inc' => 'PHP',
	'js' => 'JS',
	'css' => 'CSS',
	];
	$this->sniffs = [];
	$this->exclude = [];
	$this->ignored = [];
	$this->reportFile = null;
	$this->generator = null;
	$this->filter = null;
	$this->bootstrap = [];
	$this->basepath = null;
	$this->reports = ['full' => null];
	$this->reportWidth = 'auto';
	$this->errorSeverity = 5;
	$this->warningSeverity = 5;
	$this->recordErrors = true;
	$this->suffix = '';
	$this->stdin = false;
	$this->stdinContent = null;
	$this->stdinPath = null;
	$this->trackTime = false;
	$this->unknown = [];

	$standard = self::getConfigData('default_standard');
	if ($standard !== null) {
	$this->standards = explode(',', $standard);
	}

	$reportFormat = self::getConfigData('report_format');
	if ($reportFormat !== null) {
	$this->reports = [$reportFormat => null];
	}

	$tabWidth = self::getConfigData('tab_width');
	if ($tabWidth !== null) {
	$this->tabWidth = (int) $tabWidth;
	}

	$encoding = self::getConfigData('encoding');
	if ($encoding !== null) {
	$this->encoding = strtolower($encoding);
	}

	$severity = self::getConfigData('severity');
	if ($severity !== null) {
	$this->errorSeverity = (int) $severity;
	$this->warningSeverity = (int) $severity;
	}

	$severity = self::getConfigData('error_severity');
	if ($severity !== null) {
	$this->errorSeverity = (int) $severity;
	}

	$severity = self::getConfigData('warning_severity');
	if ($severity !== null) {
	$this->warningSeverity = (int) $severity;
	}

	$showWarnings = self::getConfigData('show_warnings');
	if ($showWarnings !== null) {
	$showWarnings = (bool) $showWarnings;
	if ($showWarnings === false) {
	$this->warningSeverity = 0;
	}
	}

	$reportWidth = self::getConfigData('report_width');
	if ($reportWidth !== null) {
	$this->reportWidth = $reportWidth;
	}

	$showProgress = self::getConfigData('show_progress');
	if ($showProgress !== null) {
	$this->showProgress = (bool) $showProgress;
	}

	$quiet = self::getConfigData('quiet');
	if ($quiet !== null) {
	$this->quiet = (bool) $quiet;
	}

	$colors = self::getConfigData('colors');
	if ($colors !== null) {
	$this->colors = (bool) $colors;
	}

	if (defined('PHP_CODESNIFFER_IN_TESTS') === false) {
	$cache = self::getConfigData('cache');
	if ($cache !== null) {
	$this->cache = (bool) $cache;
	}

	$parallel = self::getConfigData('parallel');
	if ($parallel !== null) {
	$this->parallel = max((int) $parallel, 1);
	}
	}

	}//end restoreDefaults()


	/**
	* Processes a short (-e) command line argument.
	*
	* @param string $arg The command line argument.
	* @param int $pos The position of the argument on the command line.
	*
	* @return void
	* @throws \PHP_CodeSniffer\Exceptions\DeepExitException
	*/
	public function processShortArgument($arg, $pos)
	{
	switch ($arg) {
	case 'h':
	case '?':
	ob_start();
	$this->printUsage();
	$output = ob_get_contents();
	ob_end_clean();
	throw new DeepExitException($output, 0);
	case 'i' :
	ob_start();
	Standards::printInstalledStandards();
	$output = ob_get_contents();
	ob_end_clean();
	throw new DeepExitException($output, 0);
	case 'v' :
	if ($this->quiet === true) {
	// Ignore when quiet mode is enabled.
	break;
	}

	$this->verbosity++;
	self::$overriddenDefaults['verbosity'] = true;
	break;
	case 'l' :
	$this->local = true;
	self::$overriddenDefaults['local'] = true;
	break;
	case 's' :
	$this->showSources = true;
	self::$overriddenDefaults['showSources'] = true;
	break;
	case 'a' :
	$this->interactive = true;
	self::$overriddenDefaults['interactive'] = true;
	break;
	case 'e':
	$this->explain = true;
	self::$overriddenDefaults['explain'] = true;
	break;
	case 'p' :
	if ($this->quiet === true) {
	// Ignore when quiet mode is enabled.
	break;
	}

	$this->showProgress = true;
	self::$overriddenDefaults['showProgress'] = true;
	break;
	case 'q' :
	// Quiet mode disables a few other settings as well.
	$this->quiet = true;
	$this->showProgress = false;
	$this->verbosity = 0;

	self::$overriddenDefaults['quiet'] = true;
	break;
	case 'm' :
	$this->recordErrors = false;
	self::$overriddenDefaults['recordErrors'] = true;
	break;
	case 'd' :
	$ini = explode('=', $this->cliArgs[($pos + 1)]);
	$this->cliArgs[($pos + 1)] = '';
	if (isset($ini[1]) === true) {
	ini_set($ini[0], $ini[1]);
	} else {
	ini_set($ini[0], true);
	}
	break;
	case 'n' :
	if (isset(self::$overriddenDefaults['warningSeverity']) === false) {
	$this->warningSeverity = 0;
	self::$overriddenDefaults['warningSeverity'] = true;
	}
	break;
	case 'w' :
	if (isset(self::$overriddenDefaults['warningSeverity']) === false) {
	$this->warningSeverity = $this->errorSeverity;
	self::$overriddenDefaults['warningSeverity'] = true;
	}
	break;
	default:
	if ($this->dieOnUnknownArg === false) {
	$unknown = $this->unknown;
	$unknown[] = $arg;
	$this->unknown = $unknown;
	} else {
	$this->processUnknownArgument('-'.$arg, $pos);
	}
	}//end switch

	}//end processShortArgument()


	/**
	* Processes a long (--example) command-line argument.
	*
	* @param string $arg The command line argument.
	* @param int $pos The position of the argument on the command line.
	*
	* @return void
	* @throws \PHP_CodeSniffer\Exceptions\DeepExitException
	*/
	public function processLongArgument($arg, $pos)
	{
	switch ($arg) {
	case 'help':
	ob_start();
	$this->printUsage();
	$output = ob_get_contents();
	ob_end_clean();
	throw new DeepExitException($output, 0);
	case 'version':
	$output = 'PHP_CodeSniffer version '.self::VERSION.' ('.self::STABILITY.') ';
	$output .= 'by Squiz and PHPCSStandards'.PHP_EOL;
	throw new DeepExitException($output, 0);
	case 'colors':
	if (isset(self::$overriddenDefaults['colors']) === true) {
	break;
	}

	$this->colors = true;
	self::$overriddenDefaults['colors'] = true;
	break;
	case 'no-colors':
	if (isset(self::$overriddenDefaults['colors']) === true) {
	break;
	}

	$this->colors = false;
	self::$overriddenDefaults['colors'] = true;
	break;
	case 'cache':
	if (isset(self::$overriddenDefaults['cache']) === true) {
	break;
	}

	if (defined('PHP_CODESNIFFER_IN_TESTS') === false) {
	$this->cache = true;
	self::$overriddenDefaults['cache'] = true;
	}
	break;
	case 'no-cache':
	if (isset(self::$overriddenDefaults['cache']) === true) {
	break;
	}

	$this->cache = false;
	self::$overriddenDefaults['cache'] = true;
	break;
	case 'ignore-annotations':
	if (isset(self::$overriddenDefaults['annotations']) === true) {
	break;
	}

	$this->annotations = false;
	self::$overriddenDefaults['annotations'] = true;
	break;
	case 'config-set':
	if (isset($this->cliArgs[($pos + 1)]) === false
	\|\| isset($this->cliArgs[($pos + 2)]) === false
	) {
	$error = 'ERROR: Setting a config option requires a name and value'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}

	$key = $this->cliArgs[($pos + 1)];
	$value = $this->cliArgs[($pos + 2)];
	$current = self::getConfigData($key);

	try {
	$this->setConfigData($key, $value);
	} catch (Exception $e) {
	throw new DeepExitException($e->getMessage().PHP_EOL, 3);
	}

	$output = 'Using config file: '.self::$configDataFile.PHP_EOL.PHP_EOL;

	if ($current === null) {
	$output .= "Config value \"$key\" added successfully".PHP_EOL;
	} else {
	$output .= "Config value \"$key\" updated successfully; old value was \"$current\"".PHP_EOL;
	}
	throw new DeepExitException($output, 0);
	case 'config-delete':
	if (isset($this->cliArgs[($pos + 1)]) === false) {
	$error = 'ERROR: Deleting a config option requires the name of the option'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}

	$output = 'Using config file: '.self::$configDataFile.PHP_EOL.PHP_EOL;

	$key = $this->cliArgs[($pos + 1)];
	$current = self::getConfigData($key);
	if ($current === null) {
	$output .= "Config value \"$key\" has not been set".PHP_EOL;
	} else {
	try {
	$this->setConfigData($key, null);
	} catch (Exception $e) {
	throw new DeepExitException($e->getMessage().PHP_EOL, 3);
	}

	$output .= "Config value \"$key\" removed successfully; old value was \"$current\"".PHP_EOL;
	}
	throw new DeepExitException($output, 0);
	case 'config-show':
	ob_start();
	$data = self::getAllConfigData();
	echo 'Using config file: '.self::$configDataFile.PHP_EOL.PHP_EOL;
	$this->printConfigData($data);
	$output = ob_get_contents();
	ob_end_clean();
	throw new DeepExitException($output, 0);
	case 'runtime-set':
	if (isset($this->cliArgs[($pos + 1)]) === false
	\|\| isset($this->cliArgs[($pos + 2)]) === false
	) {
	$error = 'ERROR: Setting a runtime config option requires a name and value'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}

	$key = $this->cliArgs[($pos + 1)];
	$value = $this->cliArgs[($pos + 2)];
	$this->cliArgs[($pos + 1)] = '';
	$this->cliArgs[($pos + 2)] = '';
	self::setConfigData($key, $value, true);
	if (isset(self::$overriddenDefaults['runtime-set']) === false) {
	self::$overriddenDefaults['runtime-set'] = [];
	}

	self::$overriddenDefaults['runtime-set'][$key] = true;
	break;
	default:
	if (substr($arg, 0, 7) === 'sniffs=') {
	if (isset(self::$overriddenDefaults['sniffs']) === true) {
	break;
	}

	$sniffs = explode(',', substr($arg, 7));
	foreach ($sniffs as $sniff) {
	if (substr_count($sniff, '.') !== 2) {
	$error = 'ERROR: The specified sniff code "'.$sniff.'" is invalid'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}
	}

	$this->sniffs = $sniffs;
	self::$overriddenDefaults['sniffs'] = true;
	} else if (substr($arg, 0, 8) === 'exclude=') {
	if (isset(self::$overriddenDefaults['exclude']) === true) {
	break;
	}

	$sniffs = explode(',', substr($arg, 8));
	foreach ($sniffs as $sniff) {
	if (substr_count($sniff, '.') !== 2) {
	$error = 'ERROR: The specified sniff code "'.$sniff.'" is invalid'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}
	}

	$this->exclude = $sniffs;
	self::$overriddenDefaults['exclude'] = true;
	} else if (defined('PHP_CODESNIFFER_IN_TESTS') === false
	&& substr($arg, 0, 6) === 'cache='
	) {
	if ((isset(self::$overriddenDefaults['cache']) === true
	&& $this->cache === false)
	\|\| isset(self::$overriddenDefaults['cacheFile']) === true
	) {
	break;
	}

	// Turn caching on.
	$this->cache = true;
	self::$overriddenDefaults['cache'] = true;

	$this->cacheFile = Common::realpath(substr($arg, 6));

	// It may not exist and return false instead.
	if ($this->cacheFile === false) {
	$this->cacheFile = substr($arg, 6);

	$dir = dirname($this->cacheFile);
	if (is_dir($dir) === false) {
	$error = 'ERROR: The specified cache file path "'.$this->cacheFile.'" points to a non-existent directory'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}

	if ($dir === '.') {
	// Passed cache file is a file in the current directory.
	$this->cacheFile = getcwd().'/'.basename($this->cacheFile);
	} else {
	if ($dir[0] === '/') {
	// An absolute path.
	$dir = Common::realpath($dir);
	} else {
	$dir = Common::realpath(getcwd().'/'.$dir);
	}

	if ($dir !== false) {
	// Cache file path is relative.
	$this->cacheFile = $dir.'/'.basename($this->cacheFile);
	}
	}
	}//end if

	self::$overriddenDefaults['cacheFile'] = true;

	if (is_dir($this->cacheFile) === true) {
	$error = 'ERROR: The specified cache file path "'.$this->cacheFile.'" is a directory'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}
	} else if (substr($arg, 0, 10) === 'bootstrap=') {
	$files = explode(',', substr($arg, 10));
	$bootstrap = [];
	foreach ($files as $file) {
	$path = Common::realpath($file);
	if ($path === false) {
	$error = 'ERROR: The specified bootstrap file "'.$file.'" does not exist'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}

	$bootstrap[] = $path;
	}

	$this->bootstrap = array_merge($this->bootstrap, $bootstrap);
	self::$overriddenDefaults['bootstrap'] = true;
	} else if (substr($arg, 0, 10) === 'file-list=') {
	$fileList = substr($arg, 10);
	$path = Common::realpath($fileList);
	if ($path === false) {
	$error = 'ERROR: The specified file list "'.$fileList.'" does not exist'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}

	$files = file($path);
	foreach ($files as $inputFile) {
	$inputFile = trim($inputFile);

	// Skip empty lines.
	if ($inputFile === '') {
	continue;
	}

	$this->processFilePath($inputFile);
	}
	} else if (substr($arg, 0, 11) === 'stdin-path=') {
	if (isset(self::$overriddenDefaults['stdinPath']) === true) {
	break;
	}

	$this->stdinPath = Common::realpath(substr($arg, 11));

	// It may not exist and return false instead, so use whatever they gave us.
	if ($this->stdinPath === false) {
	$this->stdinPath = trim(substr($arg, 11));
	}

	self::$overriddenDefaults['stdinPath'] = true;
	} else if (PHP_CODESNIFFER_CBF === false && substr($arg, 0, 12) === 'report-file=') {
	if (isset(self::$overriddenDefaults['reportFile']) === true) {
	break;
	}

	$this->reportFile = Common::realpath(substr($arg, 12));

	// It may not exist and return false instead.
	if ($this->reportFile === false) {
	$this->reportFile = substr($arg, 12);

	$dir = Common::realpath(dirname($this->reportFile));
	if (is_dir($dir) === false) {
	$error = 'ERROR: The specified report file path "'.$this->reportFile.'" points to a non-existent directory'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}

	$this->reportFile = $dir.'/'.basename($this->reportFile);
	}//end if

	self::$overriddenDefaults['reportFile'] = true;

	if (is_dir($this->reportFile) === true) {
	$error = 'ERROR: The specified report file path "'.$this->reportFile.'" is a directory'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}
	} else if (substr($arg, 0, 13) === 'report-width=') {
	if (isset(self::$overriddenDefaults['reportWidth']) === true) {
	break;
	}

	$this->reportWidth = substr($arg, 13);
	self::$overriddenDefaults['reportWidth'] = true;
	} else if (substr($arg, 0, 9) === 'basepath=') {
	if (isset(self::$overriddenDefaults['basepath']) === true) {
	break;
	}

	self::$overriddenDefaults['basepath'] = true;

	if (substr($arg, 9) === '') {
	$this->basepath = null;
	break;
	}

	$this->basepath = Common::realpath(substr($arg, 9));

	// It may not exist and return false instead.
	if ($this->basepath === false) {
	$this->basepath = substr($arg, 9);
	}

	if (is_dir($this->basepath) === false) {
	$error = 'ERROR: The specified basepath "'.$this->basepath.'" points to a non-existent directory'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}
	} else if ((substr($arg, 0, 7) === 'report=' \|\| substr($arg, 0, 7) === 'report-')) {
	$reports = [];

	if ($arg[6] === '-') {
	// This is a report with file output.
	$split = strpos($arg, '=');
	if ($split === false) {
	$report = substr($arg, 7);
	$output = null;
	} else {
	$report = substr($arg, 7, ($split - 7));
	$output = substr($arg, ($split + 1));
	if ($output === false) {
	$output = null;
	} else {
	$dir = Common::realpath(dirname($output));
	if (is_dir($dir) === false) {
	$error = 'ERROR: The specified '.$report.' report file path "'.$output.'" points to a non-existent directory'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}

	$output = $dir.'/'.basename($output);

	if (is_dir($output) === true) {
	$error = 'ERROR: The specified '.$report.' report file path "'.$output.'" is a directory'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}
	}//end if
	}//end if

	$reports[$report] = $output;
	} else {
	// This is a single report.
	if (isset(self::$overriddenDefaults['reports']) === true) {
	break;
	}

	$reportNames = explode(',', substr($arg, 7));
	foreach ($reportNames as $report) {
	$reports[$report] = null;
	}
	}//end if

	// Remove the default value so the CLI value overrides it.
	if (isset(self::$overriddenDefaults['reports']) === false) {
	$this->reports = $reports;
	} else {
	$this->reports = array_merge($this->reports, $reports);
	}

	self::$overriddenDefaults['reports'] = true;
	} else if (substr($arg, 0, 7) === 'filter=') {
	if (isset(self::$overriddenDefaults['filter']) === true) {
	break;
	}

	$this->filter = substr($arg, 7);
	self::$overriddenDefaults['filter'] = true;
	} else if (substr($arg, 0, 9) === 'standard=') {
	$standards = trim(substr($arg, 9));
	if ($standards !== '') {
	$this->standards = explode(',', $standards);
	}

	self::$overriddenDefaults['standards'] = true;
	} else if (substr($arg, 0, 11) === 'extensions=') {
	if (isset(self::$overriddenDefaults['extensions']) === true) {
	break;
	}

	$extensions = explode(',', substr($arg, 11));
	$newExtensions = [];
	foreach ($extensions as $ext) {
	$slash = strpos($ext, '/');
	if ($slash !== false) {
	// They specified the tokenizer too.
	list($ext, $tokenizer) = explode('/', $ext);
	$newExtensions[$ext] = strtoupper($tokenizer);
	continue;
	}

	if (isset($this->extensions[$ext]) === true) {
	$newExtensions[$ext] = $this->extensions[$ext];
	} else {
	$newExtensions[$ext] = 'PHP';
	}
	}

	$this->extensions = $newExtensions;
	self::$overriddenDefaults['extensions'] = true;
	} else if (substr($arg, 0, 7) === 'suffix=') {
	if (isset(self::$overriddenDefaults['suffix']) === true) {
	break;
	}

	$this->suffix = substr($arg, 7);
	self::$overriddenDefaults['suffix'] = true;
	} else if (substr($arg, 0, 9) === 'parallel=') {
	if (isset(self::$overriddenDefaults['parallel']) === true) {
	break;
	}

	$this->parallel = max((int) substr($arg, 9), 1);
	self::$overriddenDefaults['parallel'] = true;
	} else if (substr($arg, 0, 9) === 'severity=') {
	$this->errorSeverity = (int) substr($arg, 9);
	$this->warningSeverity = $this->errorSeverity;
	if (isset(self::$overriddenDefaults['errorSeverity']) === false) {
	self::$overriddenDefaults['errorSeverity'] = true;
	}

	if (isset(self::$overriddenDefaults['warningSeverity']) === false) {
	self::$overriddenDefaults['warningSeverity'] = true;
	}
	} else if (substr($arg, 0, 15) === 'error-severity=') {
	if (isset(self::$overriddenDefaults['errorSeverity']) === true) {
	break;
	}

	$this->errorSeverity = (int) substr($arg, 15);
	self::$overriddenDefaults['errorSeverity'] = true;
	} else if (substr($arg, 0, 17) === 'warning-severity=') {
	if (isset(self::$overriddenDefaults['warningSeverity']) === true) {
	break;
	}

	$this->warningSeverity = (int) substr($arg, 17);
	self::$overriddenDefaults['warningSeverity'] = true;
	} else if (substr($arg, 0, 7) === 'ignore=') {
	if (isset(self::$overriddenDefaults['ignored']) === true) {
	break;
	}

	// Split the ignore string on commas, unless the comma is escaped
	// using 1 or 3 slashes (\, or \\\,).
	$patterns = preg_split(
	'/(?<=(?<!\\\\)\\\\\\\\),\|(?<!\\\\),/',
	substr($arg, 7)
	);

	$ignored = [];
	foreach ($patterns as $pattern) {
	$pattern = trim($pattern);
	if ($pattern === '') {
	continue;
	}

	$ignored[$pattern] = 'absolute';
	}

	$this->ignored = $ignored;
	self::$overriddenDefaults['ignored'] = true;
	} else if (substr($arg, 0, 10) === 'generator='
	&& PHP_CODESNIFFER_CBF === false
	) {
	if (isset(self::$overriddenDefaults['generator']) === true) {
	break;
	}

	$this->generator = substr($arg, 10);
	self::$overriddenDefaults['generator'] = true;
	} else if (substr($arg, 0, 9) === 'encoding=') {
	if (isset(self::$overriddenDefaults['encoding']) === true) {
	break;
	}

	$this->encoding = strtolower(substr($arg, 9));
	self::$overriddenDefaults['encoding'] = true;
	} else if (substr($arg, 0, 10) === 'tab-width=') {
	if (isset(self::$overriddenDefaults['tabWidth']) === true) {
	break;
	}

	$this->tabWidth = (int) substr($arg, 10);
	self::$overriddenDefaults['tabWidth'] = true;
	} else {
	if ($this->dieOnUnknownArg === false) {
	$eqPos = strpos($arg, '=');
	try {
	$unknown = $this->unknown;

	if ($eqPos === false) {
	$unknown[$arg] = $arg;
	} else {
	$value = substr($arg, ($eqPos + 1));
	$arg = substr($arg, 0, $eqPos);
	$unknown[$arg] = $value;
	}

	$this->unknown = $unknown;
	} catch (RuntimeException $e) {
	// Value is not valid, so just ignore it.
	}
	} else {
	$this->processUnknownArgument('--'.$arg, $pos);
	}
	}//end if
	break;
	}//end switch

	}//end processLongArgument()


	/**
	* Processes an unknown command line argument.
	*
	* Assumes all unknown arguments are files and folders to check.
	*
	* @param string $arg The command line argument.
	* @param int $pos The position of the argument on the command line.
	*
	* @return void
	* @throws \PHP_CodeSniffer\Exceptions\DeepExitException
	*/
	public function processUnknownArgument($arg, $pos)
	{
	// We don't know about any additional switches; just files.
	if ($arg[0] === '-') {
	if ($this->dieOnUnknownArg === false) {
	return;
	}

	$error = "ERROR: option \"$arg\" not known".PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	}

	$this->processFilePath($arg);

	}//end processUnknownArgument()


	/**
	* Processes a file path and add it to the file list.
	*
	* @param string $path The path to the file to add.
	*
	* @return void
	* @throws \PHP_CodeSniffer\Exceptions\DeepExitException
	*/
	public function processFilePath($path)
	{
	// If we are processing STDIN, don't record any files to check.
	if ($this->stdin === true) {
	return;
	}

	$file = Common::realpath($path);
	if (file_exists($file) === false) {
	if ($this->dieOnUnknownArg === false) {
	return;
	}

	$error = 'ERROR: The file "'.$path.'" does not exist.'.PHP_EOL.PHP_EOL;
	$error .= $this->printShortUsage(true);
	throw new DeepExitException($error, 3);
	} else {
	// Can't modify the files array directly because it's not a real
	// class member, so need to use this little get/modify/set trick.
	$files = $this->files;
	$files[] = $file;
	$this->files = $files;
	self::$overriddenDefaults['files'] = true;
	}

	}//end processFilePath()


	/**
	* Prints out the usage information for this script.
	*
	* @return void
	*/
	public function printUsage()
	{
	echo PHP_EOL;

	if (PHP_CODESNIFFER_CBF === true) {
	$this->printPHPCBFUsage();
	} else {
	$this->printPHPCSUsage();
	}

	echo PHP_EOL;

	}//end printUsage()


	/**
	* Prints out the short usage information for this script.
	*
	* @param bool $return If TRUE, the usage string is returned
	* instead of output to screen.
	*
	* @return string\|void
	*/
	public function printShortUsage($return=false)
	{
	if (PHP_CODESNIFFER_CBF === true) {
	$usage = 'Run "phpcbf --help" for usage information';
	} else {
	$usage = 'Run "phpcs --help" for usage information';
	}

	$usage .= PHP_EOL.PHP_EOL;

	if ($return === true) {
	return $usage;
	}

	echo $usage;

	}//end printShortUsage()


	/**
	* Prints out the usage information for PHPCS.
	*
	* @return void
	*/
	public function printPHPCSUsage()
	{
	$longOptions = explode(',', Help::DEFAULT_LONG_OPTIONS);
	$longOptions[] = 'cache';
	$longOptions[] = 'no-cache';
	$longOptions[] = 'report';
	$longOptions[] = 'report-file';
	$longOptions[] = 'report-report';
	$longOptions[] = 'config-explain';
	$longOptions[] = 'config-set';
	$longOptions[] = 'config-delete';
	$longOptions[] = 'config-show';
	$longOptions[] = 'generator';

	$shortOptions = Help::DEFAULT_SHORT_OPTIONS.'aems';

	(new Help($this, $longOptions, $shortOptions))->display();

	}//end printPHPCSUsage()


	/**
	* Prints out the usage information for PHPCBF.
	*
	* @return void
	*/
	public function printPHPCBFUsage()
	{
	$longOptions = explode(',', Help::DEFAULT_LONG_OPTIONS);
	$longOptions[] = 'suffix';
	$shortOptions = Help::DEFAULT_SHORT_OPTIONS;

	(new Help($this, $longOptions, $shortOptions))->display();

	}//end printPHPCBFUsage()


	/**
	* Get a single config value.
	*
	* @param string $key The name of the config value.
	*
	* @return string\|null
	* @see setConfigData()
	* @see getAllConfigData()
	*/
	public static function getConfigData($key)
	{
	$phpCodeSnifferConfig = self::getAllConfigData();

	if ($phpCodeSnifferConfig === null) {
	return null;
	}

	if (isset($phpCodeSnifferConfig[$key]) === false) {
	return null;
	}

	return $phpCodeSnifferConfig[$key];

	}//end getConfigData()


	/**
	* Get the path to an executable utility.
	*
	* @param string $name The name of the executable utility.
	*
	* @return string\|null
	* @see getConfigData()
	*/
	public static function getExecutablePath($name)
	{
	$data = self::getConfigData($name.'_path');
	if ($data !== null) {
	return $data;
	}

	if ($name === "php") {
	// For php, we know the executable path. There's no need to look it up.
	return PHP_BINARY;
	}

	if (array_key_exists($name, self::$executablePaths) === true) {
	return self::$executablePaths[$name];
	}

	if (stripos(PHP_OS, 'WIN') === 0) {
	$cmd = 'where '.escapeshellarg($name).' 2> nul';
	} else {
	$cmd = 'which '.escapeshellarg($name).' 2> /dev/null';
	}

	$result = exec($cmd, $output, $retVal);
	if ($retVal !== 0) {
	$result = null;
	}

	self::$executablePaths[$name] = $result;
	return $result;

	}//end getExecutablePath()


	/**
	* Set a single config value.
	*
	* @param string $key The name of the config value.
	* @param string\|null $value The value to set. If null, the config
	* entry is deleted, reverting it to the
	* default value.
	* @param boolean $temp Set this config data temporarily for this
	* script run. This will not write the config
	* data to the config file.
	*
	* @return bool
	* @see getConfigData()
	* @throws \PHP_CodeSniffer\Exceptions\DeepExitException If the config file can not be written.
	*/
	public static function setConfigData($key, $value, $temp=false)
	{
	if (isset(self::$overriddenDefaults['runtime-set']) === true
	&& isset(self::$overriddenDefaults['runtime-set'][$key]) === true
	) {
	return false;
	}

	if ($temp === false) {
	$path = '';
	if (is_callable('\Phar::running') === true) {
	$path = Phar::running(false);
	}

	if ($path !== '') {
	$configFile = dirname($path).DIRECTORY_SEPARATOR.'CodeSniffer.conf';
	} else {
	$configFile = dirname(__DIR__).DIRECTORY_SEPARATOR.'CodeSniffer.conf';
	}

	if (is_file($configFile) === true
	&& is_writable($configFile) === false
	) {
	$error = 'ERROR: Config file '.$configFile.' is not writable'.PHP_EOL.PHP_EOL;
	throw new DeepExitException($error, 3);
	}
	}//end if

	$phpCodeSnifferConfig = self::getAllConfigData();

	if ($value === null) {
	if (isset($phpCodeSnifferConfig[$key]) === true) {
	unset($phpCodeSnifferConfig[$key]);
	}
	} else {
	$phpCodeSnifferConfig[$key] = $value;
	}

	if ($temp === false) {
	$output = '<'.'?php'."\n".' $phpCodeSnifferConfig = ';
	$output .= var_export($phpCodeSnifferConfig, true);
	$output .= ";\n?".'>';

	if (file_put_contents($configFile, $output) === false) {
	$error = 'ERROR: Config file '.$configFile.' could not be written'.PHP_EOL.PHP_EOL;
	throw new DeepExitException($error, 3);
	}

	self::$configDataFile = $configFile;
	}

	self::$configData = $phpCodeSnifferConfig;

	// If the installed paths are being set, make sure all known
	// standards paths are added to the autoloader.
	if ($key === 'installed_paths') {
	$installedStandards = Standards::getInstalledStandardDetails();
	foreach ($installedStandards as $details) {
	Autoload::addSearchPath($details['path'], $details['namespace']);
	}
	}

	return true;

	}//end setConfigData()


	/**
	* Get all config data.
	*
	* @return array<string, string>
	* @see getConfigData()
	* @throws \PHP_CodeSniffer\Exceptions\DeepExitException If the config file could not be read.
	*/
	public static function getAllConfigData()
	{
	if (self::$configData !== null) {
	return self::$configData;
	}

	$path = '';
	if (is_callable('\Phar::running') === true) {
	$path = Phar::running(false);
	}

	if ($path !== '') {
	$configFile = dirname($path).DIRECTORY_SEPARATOR.'CodeSniffer.conf';
	} else {
	$configFile = dirname(__DIR__).DIRECTORY_SEPARATOR.'CodeSniffer.conf';
	if (is_file($configFile) === false
	&& strpos('@data_dir@', '@data_dir') === false
	) {
	$configFile = '@data_dir@/PHP_CodeSniffer/CodeSniffer.conf';
	}
	}

	if (is_file($configFile) === false) {
	self::$configData = [];
	return [];
	}

	if (Common::isReadable($configFile) === false) {
	$error = 'ERROR: Config file '.$configFile.' is not readable'.PHP_EOL.PHP_EOL;
	throw new DeepExitException($error, 3);
	}

	include $configFile;
	self::$configDataFile = $configFile;
	self::$configData = $phpCodeSnifferConfig;
	return self::$configData;

	}//end getAllConfigData()


	/**
	* Prints out the gathered config data.
	*
	* @param array $data The config data to print.
	*
	* @return void
	*/
	public function printConfigData($data)
	{
	$max = 0;
	$keys = array_keys($data);
	foreach ($keys as $key) {
	$len = strlen($key);
	if (strlen($key) > $max) {
	$max = $len;
	}
	}

	if ($max === 0) {
	return;
	}

	$max += 2;
	ksort($data);
	foreach ($data as $name => $value) {
	echo str_pad($name.': ', $max).$value.PHP_EOL;
	}

	}//end printConfigData()


	}//end class

File Metadata

Mime Type: text/x-php
Expires: Sat, May 16, 21:39 (1 d, 3 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 15/dc/0920373ac79df8fed8a308be5228
Default Alt Text: Config.php (57 KB)

Config.phpNo OneTemporaryActions

Config.phpView Options

File Metadata

Event Timeline

Config.php
No OneTemporary
Actions

Config.php
View Options