VendorPlugin::uninstall() - Code Metrics - Inspection of "FIX: Add missing methods to plugin interface" - silverstripe/vendor-plugin - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#37)

by Sam

created 2020-10-22 01:48 UTC

VendorPlugin::uninstall() A

↳ Parent: VendorPlugin

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	0

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	0
c	0
b	0
f	0
nc	1
nop	2
dl	0
loc	2
rs	10

<?php

namespace SilverStripe\VendorPlugin;

use Composer\Composer;
use Composer\DependencyResolver\Operation\InstallOperation;
use Composer\DependencyResolver\Operation\UninstallOperation;
use Composer\DependencyResolver\Operation\UpdateOperation;
use Composer\EventDispatcher\EventSubscriberInterface;
use Composer\Factory;
use Composer\Installer\PackageEvent;
use Composer\IO\IOInterface;
use Composer\Package\PackageInterface;
use Composer\Plugin\Capability\CommandProvider;
use Composer\Plugin\Capable;
use Composer\Plugin\PluginInterface;
use Composer\Script\Event;
use Composer\Util\Filesystem;
use SilverStripe\VendorPlugin\Console\VendorCommandProvider;

/**
 * Provides public webroot rewrite functionality for vendor modules
 */
class VendorPlugin implements PluginInterface, EventSubscriberInterface, Capable
{
    /**
     * Default module type
     *
     * @deprecated 1.3..2.0 No longer used
     */
    const MODULE_TYPE = 'silverstripe-vendormodule';

    /**
     * Filter for matching library types to expose
     *
     * @deprecated 1.3..2.0 No longer used
     */
    const MODULE_FILTER = '/^silverstripe\-(\w+)$/';

    /**
     * Method env var to query
     */
    const METHOD_ENV = 'SS_VENDOR_METHOD';

    /**
     * Method name for "none" option
     */
    const METHOD_NONE = 'none';

    /**
     * Method name to auto-attempt best method
     */
    const METHOD_AUTO = 'auto';

    /**
     * File name to use for linking method storage
     */
    const METHOD_FILE = '.method';

    /**
     * Define default as 'auto'
     */
    const METHOD_DEFAULT = self::METHOD_AUTO;

    /**
     * @var Filesystem
     */
    protected $filesystem = null;

    public function __construct()
    {
        $this->filesystem = new Filesystem();
    }

    /**
     * Apply vendor plugin
     *
     * @param Composer $composer
     * @param IOInterface $io
     */
    public function activate(Composer $composer, IOInterface $io)
    {
    }

    public static function getSubscribedEvents()
    {
        return [
            'post-package-update' => 'installPackage',
            'post-package-install' => 'installPackage',
            'pre-package-uninstall' => 'uninstallPackage',
            'post-install-cmd' => 'installRootPackage',
            'post-update-cmd' => 'installRootPackage',
        ];
    }

    /**
     * Get vendor module instance for this event
     *
     * @deprecated 1.3..2.0
     * @param PackageEvent $event
     * @return Library|null
     */
    protected function getVendorModule(PackageEvent $event)
    {
        return $this->getLibrary($event);
    }

    /**
     * Gets library being installed
     *
     * @param PackageEvent $event
     * @return Library|null
     */
    public function getLibrary(PackageEvent $event)
    {
        // Ensure package is the valid type
        $package = $this->getOperationPackage($event);
        if (!$package) {

            return null;
        }

        // Get appropriate installer and query install path
        $installer = $event->getComposer()->getInstallationManager()->getInstaller($package->getType());
        $path = $installer->getInstallPath($package);

        // Build module
        return new Library($this->getProjectPath(), $path);
    }

    /**
     * Install resources from an installed or updated package
     *
     * @param PackageEvent $event
     */
    public function installPackage(PackageEvent $event)
    {
        // Ensure module exists and requires exposure
        $library = $this->getLibrary($event);
        if (!$library) {

            return;
        }

        // Install found library
        $this->installLibrary($event->getIO(), $library);
    }

    /**
     * Install resources from the root package
     *
     * @param Event $event
     */
    public function installRootPackage(Event $event)
    {
        // Build library in base path
        $basePath = $this->getProjectPath();
        $library = new Library($basePath, $basePath);

        // Pass to library installer
        $this->installLibrary($event->getIO(), $library);
    }

    /**
     * Get base path to project
     *
     * @return string
     */
    protected function getProjectPath()
    {
        return dirname(realpath(Factory::getComposerFile()));
    }

    /**
     * Remove package
     *
     * @param PackageEvent $event
     */
    public function uninstallPackage(PackageEvent $event)
    {
        // Check if library exists and exposes any directories
        $library = $this->getLibrary($event);
        if (!$library || !$library->requiresExpose()) {

            return;
        }

        // Check path to remove
        $target = $library->getPublicPath();
        if (!is_dir($target)) {
            return;
        }

        // Remove directory
        $name = $library->getName();
        $event->getIO()->write("Removing web directories for module <info>{$name}</info>:");
        $this->filesystem->removeDirectory($target);

        // Cleanup empty vendor dir if this is the last module
        $targetParent = dirname($target);
        if ($this->filesystem->isDirEmpty($targetParent)) {
            $this->filesystem->removeDirectory($targetParent);
        }
    }

    /**
     * Get target package from operation
     *
     * @param PackageEvent $event
     * @return PackageInterface
     */
    protected function getOperationPackage(PackageEvent $event)
    {
        $operation = $event->getOperation();
        if ($operation instanceof UpdateOperation) {
            return $operation->getTargetPackage();
        }
        if ($operation instanceof InstallOperation) {
            return $operation->getPackage();
        }
        if ($operation instanceof UninstallOperation) {
            return $operation->getPackage();
        }
        return null;
    }

    public function getCapabilities()
    {
        return [
            CommandProvider::class => VendorCommandProvider::class
        ];
    }

    /**
     * Expose the given Library object
     *
     * @param IOInterface $IO
     * @param Library $library
     */
    protected function installLibrary(IOInterface $IO, Library $library)
    {
        if (!$library || !$library->requiresExpose()) {

            return;
        }

        // Create exposure task
        $task = new VendorExposeTask(
            $this->getProjectPath(),
            $this->filesystem,
            $library->getBasePublicPath()
        );
        $task->process($IO, [$library]);
    }

    /**
     * Required by the composer 2 plugin interface
     */
    public function deactivate(Composer $composer, IOInterface $io)
    {
    }

    /**
     * Required by the composer 2 plugin interface
     */
    public function uninstall(Composer $composer, IOInterface $io)
    {
    }
}


1			<?php
2
3			namespace SilverStripe\VendorPlugin;
4
5			use Composer\Composer;
6			use Composer\DependencyResolver\Operation\InstallOperation;
7			use Composer\DependencyResolver\Operation\UninstallOperation;
8			use Composer\DependencyResolver\Operation\UpdateOperation;
9			use Composer\EventDispatcher\EventSubscriberInterface;
10			use Composer\Factory;
11			use Composer\Installer\PackageEvent;
12			use Composer\IO\IOInterface;
13			use Composer\Package\PackageInterface;
14			use Composer\Plugin\Capability\CommandProvider;
15			use Composer\Plugin\Capable;
16			use Composer\Plugin\PluginInterface;
17			use Composer\Script\Event;
18			use Composer\Util\Filesystem;
19			use SilverStripe\VendorPlugin\Console\VendorCommandProvider;
20
21			/**
22			* Provides public webroot rewrite functionality for vendor modules
23			*/
24			class VendorPlugin implements PluginInterface, EventSubscriberInterface, Capable
25			{
26			/**
27			* Default module type
28			*
29			* @deprecated 1.3..2.0 No longer used
30			*/
31			const MODULE_TYPE = 'silverstripe-vendormodule';
32
33			/**
34			* Filter for matching library types to expose
35			*
36			* @deprecated 1.3..2.0 No longer used
37			*/
38			const MODULE_FILTER = '/^silverstripe\-(\w+)$/';
39
40			/**
41			* Method env var to query
42			*/
43			const METHOD_ENV = 'SS_VENDOR_METHOD';
44
45			/**
46			* Method name for "none" option
47			*/
48			const METHOD_NONE = 'none';
49
50			/**
51			* Method name to auto-attempt best method
52			*/
53			const METHOD_AUTO = 'auto';
54
55			/**
56			* File name to use for linking method storage
57			*/
58			const METHOD_FILE = '.method';
59
60			/**
61			* Define default as 'auto'
62			*/
63			const METHOD_DEFAULT = self::METHOD_AUTO;
64
65			/**
66			* @var Filesystem
67			*/
68			protected $filesystem = null;
69
70			public function __construct()
71			{
72			$this->filesystem = new Filesystem();
73			}
74
75			/**
76			* Apply vendor plugin
77			*
78			* @param Composer $composer
79			* @param IOInterface $io
80			*/
81			public function activate(Composer $composer, IOInterface $io)
82			{
83			}
84
85			public static function getSubscribedEvents()
86			{
87			return [
88			'post-package-update' => 'installPackage',
89			'post-package-install' => 'installPackage',
90			'pre-package-uninstall' => 'uninstallPackage',
91			'post-install-cmd' => 'installRootPackage',
92			'post-update-cmd' => 'installRootPackage',
93			];
94			}
95
96			/**
97			* Get vendor module instance for this event
98			*
99			* @deprecated 1.3..2.0
100			* @param PackageEvent $event
101			* @return Library\|null
102			*/
103			protected function getVendorModule(PackageEvent $event)
104			{
105			return $this->getLibrary($event);
106			}
107
108			/**
109			* Gets library being installed
110			*
111			* @param PackageEvent $event
112			* @return Library\|null
113			*/
114			public function getLibrary(PackageEvent $event)
115			{
116			// Ensure package is the valid type
117			$package = $this->getOperationPackage($event);
118			if (!$package) {
			0 ignored issues – show introduced 2019-01-25 00:57 UTC by Report Bug Copy Issue Report `$package` is of type `Composer\Package\PackageInterface`, thus it always evaluated to `true`. Loading history...
119			return null;
120			}
121
122			// Get appropriate installer and query install path
123			$installer = $event->getComposer()->getInstallationManager()->getInstaller($package->getType());
124			$path = $installer->getInstallPath($package);
125
126			// Build module
127			return new Library($this->getProjectPath(), $path);
128			}
129
130			/**
131			* Install resources from an installed or updated package
132			*
133			* @param PackageEvent $event
134			*/
135			public function installPackage(PackageEvent $event)
136			{
137			// Ensure module exists and requires exposure
138			$library = $this->getLibrary($event);
139			if (!$library) {
			0 ignored issues – show introduced 2019-01-25 00:57 UTC by Report Bug Copy Issue Report `$library` is of type `SilverStripe\VendorPlugin\Library`, thus it always evaluated to `true`. Loading history...
140			return;
141			}
142
143			// Install found library
144			$this->installLibrary($event->getIO(), $library);
145			}
146
147			/**
148			* Install resources from the root package
149			*
150			* @param Event $event
151			*/
152			public function installRootPackage(Event $event)
153			{
154			// Build library in base path
155			$basePath = $this->getProjectPath();
156			$library = new Library($basePath, $basePath);
157
158			// Pass to library installer
159			$this->installLibrary($event->getIO(), $library);
160			}
161
162			/**
163			* Get base path to project
164			*
165			* @return string
166			*/
167			protected function getProjectPath()
168			{
169			return dirname(realpath(Factory::getComposerFile()));
170			}
171
172			/**
173			* Remove package
174			*
175			* @param PackageEvent $event
176			*/
177			public function uninstallPackage(PackageEvent $event)
178			{
179			// Check if library exists and exposes any directories
180			$library = $this->getLibrary($event);
181			if (!$library \|\| !$library->requiresExpose()) {
			0 ignored issues – show introduced 2019-01-25 00:57 UTC by Report Bug Copy Issue Report `$library` is of type `SilverStripe\VendorPlugin\Library`, thus it always evaluated to `true`. Loading history...
182			return;
183			}
184
185			// Check path to remove
186			$target = $library->getPublicPath();
187			if (!is_dir($target)) {
188			return;
189			}
190
191			// Remove directory
192			$name = $library->getName();
193			$event->getIO()->write("Removing web directories for module <info>{$name}</info>:");
194			$this->filesystem->removeDirectory($target);
195
196			// Cleanup empty vendor dir if this is the last module
197			$targetParent = dirname($target);
198			if ($this->filesystem->isDirEmpty($targetParent)) {
199			$this->filesystem->removeDirectory($targetParent);
200			}
201			}
202
203			/**
204			* Get target package from operation
205			*
206			* @param PackageEvent $event
207			* @return PackageInterface
208			*/
209			protected function getOperationPackage(PackageEvent $event)
210			{
211			$operation = $event->getOperation();
212			if ($operation instanceof UpdateOperation) {
213			return $operation->getTargetPackage();
214			}
215			if ($operation instanceof InstallOperation) {
216			return $operation->getPackage();
217			}
218			if ($operation instanceof UninstallOperation) {
219			return $operation->getPackage();
220			}
221			return null;
222			}
223
224			public function getCapabilities()
225			{
226			return [
227			CommandProvider::class => VendorCommandProvider::class
228			];
229			}
230
231			/**
232			* Expose the given Library object
233			*
234			* @param IOInterface $IO
235			* @param Library $library
236			*/
237			protected function installLibrary(IOInterface $IO, Library $library)
238			{
239			if (!$library \|\| !$library->requiresExpose()) {
			0 ignored issues – show introduced 2019-01-25 00:57 UTC by Report Bug Copy Issue Report `$library` is of type `SilverStripe\VendorPlugin\Library`, thus it always evaluated to `true`. Loading history...
240			return;
241			}
242
243			// Create exposure task
244			$task = new VendorExposeTask(
245			$this->getProjectPath(),
246			$this->filesystem,
247			$library->getBasePublicPath()
248			);
249			$task->process($IO, [$library]);
250			}
251
252			/**
253			* Required by the composer 2 plugin interface
254			*/
255			public function deactivate(Composer $composer, IOInterface $io)
256			{
257			}
258
259			/**
260			* Required by the composer 2 plugin interface
261			*/
262			public function uninstall(Composer $composer, IOInterface $io)
263			{
264			}
265			}
266

silverstripe / vendor-plugin

Pull Request — master (#37)

VendorPlugin::uninstall() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like