Standards::getInstalledStandardPath() - Code Metrics - Inspection of "Drop phar" - Symplify/PHP7_CodeSniffer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#6)

by Tomáš

created 2016-06-25 16:13 UTC

Standards::getInstalledStandardPath() A

↳ Parent: Standards

Complexity

Conditions	4
Paths	5

Size

Total Lines	20
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	11
c	1
b	0
f	0
nc	5
nop	1
dl	0
loc	20
rs	9.2

<?php
/**
 * Functions for helping process standards.
 *
 * @author    Greg Sherwood <[email protected]>
 * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600)
 * @license   https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
 */

namespace PHP_CodeSniffer\Util;

use PHP_CodeSniffer\Config;

class Standards
{


    /**
     * Get a list paths where standards are installed.
     *
     * @return array
     */
    public static function getInstalledStandardPaths()
    {
        $installedPaths = array(Common::realPath(__DIR__.DIRECTORY_SEPARATOR.'..'.DIRECTORY_SEPARATOR.'Standards'));
        $configPaths    = Config::getConfigData('installed_paths');
        if ($configPaths !== null) {
            $installedPaths = array_merge($installedPaths, explode(',', $configPaths));
        }

        $resolvedInstalledPaths = array();
        foreach ($installedPaths as $installedPath) {
            if (substr($installedPath, 0, 1) === '.') {
                $installedPath = Common::realPath(__DIR__.DIRECTORY_SEPARATOR.'..'.DIRECTORY_SEPARATOR.'..'.DIRECTORY_SEPARATOR.$installedPath);
            }

            $resolvedInstalledPaths[] = $installedPath;
        }

        return $resolvedInstalledPaths;

    }//end getInstalledStandardPaths()


    /**
     * Get a list of all coding standards installed.
     *
     * Coding standards are directories located in the
     * CodeSniffer/Standards directory. Valid coding standards
     * include a Sniffs subdirectory.
     *
     * @param boolean $includeGeneric If true, the special "Generic"
     *                                coding standard will be included
     *                                if installed.
     * @param string  $standardsDir   A specific directory to look for standards
     *                                in. If not specified, PHP_CodeSniffer will
     *                                look in its default locations.
     *
     * @return array
     * @see    isInstalledStandard()
     */
    public static function getInstalledStandards(
        $includeGeneric=false,
        $standardsDir=''
    ) {
        $installedStandards = array();

        if ($standardsDir === '') {
            $installedPaths = self::getInstalledStandardPaths();
        } else {
            $installedPaths = array($standardsDir);
        }

        foreach ($installedPaths as $standardsDir) {
            // Check if the installed dir is actually a standard itself.
            $csFile = $standardsDir.'/ruleset.xml';
            if (is_file($csFile) === true) {
                $installedStandards[] = basename($standardsDir);
                continue;
            }

            $di = new \DirectoryIterator($standardsDir);
            foreach ($di as $file) {
                if ($file->isDir() === true && $file->isDot() === false) {
                    $filename = $file->getFilename();

                    // Ignore the special "Generic" standard.
                    if ($includeGeneric === false && $filename === 'Generic') {
                        continue;
                    }

                    // Valid coding standard dirs include a ruleset.
                    $csFile = $file->getPathname().'/ruleset.xml';
                    if (is_file($csFile) === true) {
                        $installedStandards[] = $filename;
                    }
                }
            }
        }//end foreach

        return $installedStandards;

    }//end getInstalledStandards()


    /**
     * Determine if a standard is installed.
     *
     * Coding standards are directories located in the
     * CodeSniffer/Standards directory. Valid coding standards
     * include a ruleset.xml file.
     *
     * @param string $standard The name of the coding standard.
     *
     * @return boolean
     * @see    getInstalledStandards()
     */
    public static function isInstalledStandard($standard)
    {
        $path = self::getInstalledStandardPath($standard);
        if ($path !== null && strpos($path, 'ruleset.xml') !== false) {
            return true;
        } else {
            // This could be a custom standard, installed outside our
            // standards directory.
            $standard = Common::realPath($standard);

            // Might be an actual ruleset file itUtil.
            // If it has an XML extension, let's at least try it.
            if (is_file($standard) === true
                && (substr(strtolower($standard), -4) === '.xml'
                || substr(strtolower($standard), -9) === '.xml.dist')
            ) {
                return true;
            }

            // If it is a directory with a ruleset.xml file in it,
            // it is a standard.
            $ruleset = rtrim($standard, ' /\\').DIRECTORY_SEPARATOR.'ruleset.xml';
            if (is_file($ruleset) === true) {
                return true;
            }
        }//end if

        return false;

    }//end isInstalledStandard()


    /**
     * Return the path of an installed coding standard.
     *
     * Coding standards are directories located in the
     * CodeSniffer/Standards directory. Valid coding standards
     * include a ruleset.xml file.
     *
     * @param string $standard The name of the coding standard.
     *
     * @return string|null
     */
    public static function getInstalledStandardPath($standard)
    {
        $installedPaths = self::getInstalledStandardPaths();
        foreach ($installedPaths as $installedPath) {
            if (basename($installedPath) === $standard) {
                $standardPath = $installedPath;
            } else {
                $standardPath = $installedPath.DIRECTORY_SEPARATOR.$standard;
            }

            $path = Common::realpath($standardPath.DIRECTORY_SEPARATOR.'ruleset.xml');

            if (is_file($path) === true) {
                return $path;
            }
        }

        return null;

    }//end getInstalledStandardPath()


    /**
     * Prints out a list of installed coding standards.
     *
     * @return void
     */
    public static function printInstalledStandards()
    {
        $installedStandards = self::getInstalledStandards();
        $numStandards       = count($installedStandards);

        if ($numStandards === 0) {
            echo 'No coding standards are installed.'.PHP_EOL;
        } else {
            $lastStandard = array_pop($installedStandards);
            if ($numStandards === 1) {
                echo "The only coding standard installed is $lastStandard".PHP_EOL;
            } else {
                $standardList  = implode(', ', $installedStandards);
                $standardList .= ' and '.$lastStandard;
                echo 'The installed coding standards are '.$standardList.PHP_EOL;
            }
        }

    }//end printInstalledStandards()


}//end class


1			<?php
2			/**
3			* Functions for helping process standards.
4			*
5			* @author Greg Sherwood <[email protected]>
6			* @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600)
7			* @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
8			*/
9
10			namespace PHP_CodeSniffer\Util;
11
12			use PHP_CodeSniffer\Config;
13
14			class Standards
15			{
16
17
18			/**
19			* Get a list paths where standards are installed.
20			*
21			* @return array
22			*/
23			public static function getInstalledStandardPaths()
24			{
25			$installedPaths = array(Common::realPath(__DIR__.DIRECTORY_SEPARATOR.'..'.DIRECTORY_SEPARATOR.'Standards'));
26			$configPaths = Config::getConfigData('installed_paths');
27			if ($configPaths !== null) {
28			$installedPaths = array_merge($installedPaths, explode(',', $configPaths));
29			}
30
31			$resolvedInstalledPaths = array();
32			foreach ($installedPaths as $installedPath) {
33			if (substr($installedPath, 0, 1) === '.') {
34			$installedPath = Common::realPath(__DIR__.DIRECTORY_SEPARATOR.'..'.DIRECTORY_SEPARATOR.'..'.DIRECTORY_SEPARATOR.$installedPath);
35			}
36
37			$resolvedInstalledPaths[] = $installedPath;
38			}
39
40			return $resolvedInstalledPaths;
41
42			}//end getInstalledStandardPaths()
43
44
45			/**
46			* Get a list of all coding standards installed.
47			*
48			* Coding standards are directories located in the
49			* CodeSniffer/Standards directory. Valid coding standards
50			* include a Sniffs subdirectory.
51			*
52			* @param boolean $includeGeneric If true, the special "Generic"
53			* coding standard will be included
54			* if installed.
55			* @param string $standardsDir A specific directory to look for standards
56			* in. If not specified, PHP_CodeSniffer will
57			* look in its default locations.
58			*
59			* @return array
60			* @see isInstalledStandard()
61			*/
62			public static function getInstalledStandards(
63			$includeGeneric=false,
64			$standardsDir=''
65			) {
66			$installedStandards = array();
67
68			if ($standardsDir === '') {
69			$installedPaths = self::getInstalledStandardPaths();
70			} else {
71			$installedPaths = array($standardsDir);
72			}
73
74			foreach ($installedPaths as $standardsDir) {
75			// Check if the installed dir is actually a standard itself.
76			$csFile = $standardsDir.'/ruleset.xml';
77			if (is_file($csFile) === true) {
78			$installedStandards[] = basename($standardsDir);
79			continue;
80			}
81
82			$di = new \DirectoryIterator($standardsDir);
83			foreach ($di as $file) {
84			if ($file->isDir() === true && $file->isDot() === false) {
85			$filename = $file->getFilename();
86
87			// Ignore the special "Generic" standard.
88			if ($includeGeneric === false && $filename === 'Generic') {
89			continue;
90			}
91
92			// Valid coding standard dirs include a ruleset.
93			$csFile = $file->getPathname().'/ruleset.xml';
94			if (is_file($csFile) === true) {
95			$installedStandards[] = $filename;
96			}
97			}
98			}
99			}//end foreach
100
101			return $installedStandards;
102
103			}//end getInstalledStandards()
104
105
106			/**
107			* Determine if a standard is installed.
108			*
109			* Coding standards are directories located in the
110			* CodeSniffer/Standards directory. Valid coding standards
111			* include a ruleset.xml file.
112			*
113			* @param string $standard The name of the coding standard.
114			*
115			* @return boolean
116			* @see getInstalledStandards()
117			*/
118			public static function isInstalledStandard($standard)
119			{
120			$path = self::getInstalledStandardPath($standard);
121			if ($path !== null && strpos($path, 'ruleset.xml') !== false) {
122			return true;
123			} else {
124			// This could be a custom standard, installed outside our
125			// standards directory.
126			$standard = Common::realPath($standard);
127
128			// Might be an actual ruleset file itUtil.
129			// If it has an XML extension, let's at least try it.
130			if (is_file($standard) === true
131			&& (substr(strtolower($standard), -4) === '.xml'
132			\|\| substr(strtolower($standard), -9) === '.xml.dist')
133			) {
134			return true;
135			}
136
137			// If it is a directory with a ruleset.xml file in it,
138			// it is a standard.
139			$ruleset = rtrim($standard, ' /\\').DIRECTORY_SEPARATOR.'ruleset.xml';
140			if (is_file($ruleset) === true) {
141			return true;
142			}
143			}//end if
144
145			return false;
146
147			}//end isInstalledStandard()
148
149
150			/**
151			* Return the path of an installed coding standard.
152			*
153			* Coding standards are directories located in the
154			* CodeSniffer/Standards directory. Valid coding standards
155			* include a ruleset.xml file.
156			*
157			* @param string $standard The name of the coding standard.
158			*
159			* @return string\|null
160			*/
161			public static function getInstalledStandardPath($standard)
162			{
163			$installedPaths = self::getInstalledStandardPaths();
164			foreach ($installedPaths as $installedPath) {
165			if (basename($installedPath) === $standard) {
166			$standardPath = $installedPath;
167			} else {
168			$standardPath = $installedPath.DIRECTORY_SEPARATOR.$standard;
169			}
170
171			$path = Common::realpath($standardPath.DIRECTORY_SEPARATOR.'ruleset.xml');
172
173			if (is_file($path) === true) {
174			return $path;
175			}
176			}
177
178			return null;
179
180			}//end getInstalledStandardPath()
181
182
183			/**
184			* Prints out a list of installed coding standards.
185			*
186			* @return void
187			*/
188			public static function printInstalledStandards()
189			{
190			$installedStandards = self::getInstalledStandards();
191			$numStandards = count($installedStandards);
192
193			if ($numStandards === 0) {
194			echo 'No coding standards are installed.'.PHP_EOL;
195			} else {
196			$lastStandard = array_pop($installedStandards);
197			if ($numStandards === 1) {
198			echo "The only coding standard installed is $lastStandard".PHP_EOL;
199			} else {
200			$standardList = implode(', ', $installedStandards);
201			$standardList .= ' and '.$lastStandard;
202			echo 'The installed coding standards are '.$standardList.PHP_EOL;
203			}
204			}
205
206			}//end printInstalledStandards()
207
208
209			}//end class
210

Symplify / PHP7_CodeSniffer

Pull Request — master (#6)

Standards::getInstalledStandardPath() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like