Inheritance diagram for cweagans\Composer\Patches:

Collaboration diagram for cweagans\Composer\Patches:

Public Member Functions
	activate (Composer $composer, IOInterface $io)
	Apply plugin modifications to composer. More...

	checkPatches (Event $event)
	Before running composer install,. More...

	gatherPatches (PackageEvent $event)
	Gather patches from dependencies and store them for later use. More...

	grabPatches ()
	Get the patches from root composer or external file. More...

Static Public Member Functions
static	getSubscribedEvents ()
	Returns an array of event names this subscriber wants to listen to. More...

Protected Member Functions
	getPackageFromOperation (OperationInterface $operation)
	Get a Package object from an OperationInterface object. More...

	getAndApplyPatch (RemoteFilesystem $downloader, $install_path, $patch_url)
	Apply a patch on code in the specified directory. More...

	isPatchingEnabled ()
	Checks if the root package enables patching. More...

	writePatchReport ($patches, $directory)
	Writes a patch report to the target directory. More...

	executeCommand ($cmd)
	Executes a shell command with escaping. More...

Protected Attributes
	$composer

	$io

	$eventDispatcher

	$executor

	$patches

Detailed Description

Definition at line 28 of file Patches.php.

Member Function Documentation

◆ activate()

cweagans\Composer\Patches::activate	(	Composer	$composer,
		IOInterface	$io
	)

Apply plugin modifications to composer.

Parameters

Composer	$composer
IOInterface	$io

Definition at line 57 of file Patches.php.

                                                                {
    $this->composer = $composer;
    $this->io = $io;
    $this->eventDispatcher = $composer->getEventDispatcher();
    $this->executor = new ProcessExecutor($this->io);
    $this->patches = array();
  }

References cweagans\Composer\Patches\$composer, and cweagans\Composer\Patches\$io.

◆ checkPatches()

cweagans\Composer\Patches::checkPatches ( Event $event )

Before running composer install,.

Parameters

Event $event

Definition at line 83 of file Patches.php.

                                             {
    if (!$this->isPatchingEnabled()) {
      return;
    }
 
    try {
      $repositoryManager = $this->composer->getRepositoryManager();
      $localRepository = $repositoryManager->getLocalRepository();
      $installationManager = $this->composer->getInstallationManager();
      $packages = $localRepository->getPackages();
 
      $tmp_patches = $this->grabPatches();
      if ($tmp_patches == FALSE) {
        $this->io->write('<info>No patches supplied.</info>');
        return;
      }
 
      foreach ($packages as $package) {
        $extra = $package->getExtra();
        $patches = isset($extra['patches']) ? $extra['patches'] : array();
        $tmp_patches = array_merge_recursive($tmp_patches, $patches);
      }
 
      // Remove packages for which the patch set has changed.
      foreach ($packages as $package) {
        if (!($package instanceof AliasPackage)) {
          $package_name = $package->getName();
          $extra = $package->getExtra();
          $has_patches = isset($tmp_patches[$package_name]);
          $has_applied_patches = isset($extra['patches_applied']);
          if (($has_patches && !$has_applied_patches)
            || (!$has_patches && $has_applied_patches)
            || ($has_patches && $has_applied_patches && $tmp_patches[$package_name] !== $extra['patches_applied'])) {
            $uninstallOperation = new UninstallOperation($package, 'Removing package so it can be re-installed and re-patched.');
            $this->io->write('<info>Removing package ' . $package_name . ' so that it can be re-installed and re-patched.</info>');
            $installationManager->uninstall($localRepository, $uninstallOperation);
          }
        }
      }
    }
      // If the Locker isn't available, then we don't need to do this.
      // It's the first time packages have been installed.
    catch (\LogicException $e) {
      return;
    }
  }

References cweagans\Composer\Patches\$patches, cweagans\Composer\Patches\grabPatches(), and cweagans\Composer\Patches\isPatchingEnabled().

Here is the call graph for this function:

◆ executeCommand()

cweagans\Composer\Patches::executeCommand ( $cmd )

protected

Executes a shell command with escaping.

Parameters

string $cmd

Returns: bool

Definition at line 407 of file Patches.php.

                                          {
    // Shell-escape all arguments except the command.
    $args = func_get_args();
    foreach ($args as $index => $arg) {
      if ($index !== 0) {
        $args[$index] = escapeshellarg($arg);
      }
    }
 
    // And replace the arguments.
    $command = call_user_func_array('sprintf', $args);
    $output = '';
    if ($this->io->isVerbose()) {
      $this->io->write('<comment>' . $command . '</comment>');
      $io = $this->io;
      $output = function ($type, $data) use ($io) {
        if ($type == Process::ERR) {
          $io->write('<error>' . $data . '</error>');
        }
        else {
          $io->write('<comment>' . $data . '</comment>');
        }
      };
    }
    return ($this->executor->execute($command, $output) == 0);
  }

References $data, $index, cweagans\Composer\Patches\$io, Sabre\VObject\$output, and $type.

Referenced by cweagans\Composer\Patches\getAndApplyPatch().

Here is the caller graph for this function:

◆ gatherPatches()

cweagans\Composer\Patches::gatherPatches ( PackageEvent $event )

Gather patches from dependencies and store them for later use.

Parameters

PackageEvent $event

Definition at line 135 of file Patches.php.

                                                     {
    // If we've already done this, then don't do it again.
    if (isset($this->patches['_patchesGathered'])) {
      return;
    }
    // If patching has been disabled, bail out here.
    elseif (!$this->isPatchingEnabled()) {
      return;
    }
 
    $this->patches = $this->grabPatches();
    if (empty($this->patches)) {
      $this->io->write('<info>No patches supplied.</info>');
    }
 
    // Now add all the patches from dependencies that will be installed.
    $operations = $event->getOperations();
    $this->io->write('<info>Gathering patches for dependencies. This might take a minute.</info>');
    foreach ($operations as $operation) {
      if ($operation->getJobType() == 'install' || $operation->getJobType() == 'update') {
        $package = $this->getPackageFromOperation($operation);
        $extra = $package->getExtra();
        if (isset($extra['patches'])) {
          $this->patches = array_merge_recursive($this->patches, $extra['patches']);
        }
      }
    }
 
    // If we're in verbose mode, list the projects we're going to patch.
    if ($this->io->isVerbose()) {
      foreach ($this->patches as $package => $patches) {
        $number = count($patches);
        $this->io->write('<info>Found ' . $number . ' patches for ' . $package . '.</info>');
      }
    }
 
    // Make sure we don't gather patches again. Extra keys in $this->patches
    // won't hurt anything, so we'll just stash it there.
    $this->patches['_patchesGathered'] = TRUE;
  }

References cweagans\Composer\Patches\$patches, cweagans\Composer\Patches\getPackageFromOperation(), cweagans\Composer\Patches\grabPatches(), and cweagans\Composer\Patches\isPatchingEnabled().

Here is the call graph for this function:

◆ getAndApplyPatch()

cweagans\Composer\Patches::getAndApplyPatch	(	RemoteFilesystem	$downloader,
			$install_path,
			$patch_url
	)

protected

Apply a patch on code in the specified directory.

Parameters

RemoteFilesystem	$downloader
	$install_path
	$patch_url

Exceptions

Exception

Definition at line 313 of file Patches.php.

                                                                                               {
 
    // Local patch file.
    if (file_exists($patch_url)) {
      $filename = $patch_url;
    }
    else {
      // Generate random (but not cryptographically so) filename.
      $filename = uniqid("/tmp/") . ".patch";
 
      // Download file from remote filesystem to this location.
      $hostname = parse_url($patch_url, PHP_URL_HOST);
      $downloader->copy($hostname, $patch_url, $filename, FALSE);
    }
 
    // Modified from drush6:make.project.inc
    $patched = FALSE;
    // The order here is intentional. p1 is most likely to apply with git apply.
    // p0 is next likely. p2 is extremely unlikely, but for some special cases,
    // it might be useful.
    $patch_levels = array('-p1', '-p0', '-p2');
    foreach ($patch_levels as $patch_level) {
      $checked = $this->executeCommand('cd %s && GIT_DIR=. git apply --check %s %s', $install_path, $patch_level, $filename);
      if ($checked) {
        // Apply the first successful style.
        $patched = $this->executeCommand('cd %s && GIT_DIR=. git apply %s %s', $install_path, $patch_level, $filename);
        break;
      }
    }
 
    // In some rare cases, git will fail to apply a patch, fallback to using
    // the 'patch' command.
    if (!$patched) {
      foreach ($patch_levels as $patch_level) {
        // --no-backup-if-mismatch here is a hack that fixes some
        // differences between how patch works on windows and unix.
        if ($patched = $this->executeCommand("patch %s --no-backup-if-mismatch -d %s < %s", $patch_level, $install_path, $filename)) {
          break;
        }
      }
    }
 
    // Clean up the temporary patch file.
    if (isset($hostname)) {
      unlink($filename);
    }
    // If the patch *still* isn't applied, then give up and throw an Exception.
    // Otherwise, let the user know it worked.
    if (!$patched) {
      throw new \Exception("Cannot apply patch $patch_url");
    }
  }

References $filename, and cweagans\Composer\Patches\executeCommand().

Here is the call graph for this function:

◆ getPackageFromOperation()

cweagans\Composer\Patches::getPackageFromOperation ( OperationInterface $operation )

protected

Get a Package object from an OperationInterface object.

Parameters

OperationInterface $operation

Returns: PackageInterface

Exceptions

Exception

Definition at line 291 of file Patches.php.

                                                                            {
    if ($operation instanceof InstallOperation) {
      $package = $operation->getPackage();
    }
    elseif ($operation instanceof UpdateOperation) {
      $package = $operation->getTargetPackage();
    }
    else {
      throw new \Exception('Unknown operation: ' . get_class($operation));
    }
 
    return $package;
  }

Referenced by cweagans\Composer\Patches\gatherPatches().

Here is the caller graph for this function:

◆ getSubscribedEvents()

static cweagans\Composer\Patches::getSubscribedEvents ( )

static

Returns an array of event names this subscriber wants to listen to.

Definition at line 68 of file Patches.php.

                                               {
    return array(
      ScriptEvents::PRE_INSTALL_CMD => "checkPatches",
      ScriptEvents::PRE_UPDATE_CMD => "checkPatches",
      PackageEvents::PRE_PACKAGE_INSTALL => "gatherPatches",
      PackageEvents::PRE_PACKAGE_UPDATE => "gatherPatches",
      PackageEvents::POST_PACKAGE_INSTALL => "postInstall",
      PackageEvents::POST_PACKAGE_UPDATE => "postInstall",
    );
  }

◆ grabPatches()

cweagans\Composer\Patches::grabPatches ( )

Get the patches from root composer or external file.

Returns: Patches

Exceptions

Exception

Definition at line 181 of file Patches.php.

                                {
      // First, try to get the patches from the root composer.json.
    $extra = $this->composer->getPackage()->getExtra();
    if (isset($extra['patches'])) {
      $this->io->write('<info>Gathering patches for root package.</info>');
      $patches = $extra['patches'];
      return $patches;
    }
    // If it's not specified there, look for a patches-file definition.
    elseif (isset($extra['patches-file'])) {
      $this->io->write('<info>Gathering patches from patch file.</info>');
      $patches = file_get_contents($extra['patches-file']);
      $patches = json_decode($patches, TRUE);
      $error = json_last_error();
      if ($error != 0) {
        switch ($error) {
          case JSON_ERROR_DEPTH:
            $msg = ' - Maximum stack depth exceeded';
            break;
          case JSON_ERROR_STATE_MISMATCH:
            $msg =  ' - Underflow or the modes mismatch';
            break;
          case JSON_ERROR_CTRL_CHAR:
            $msg = ' - Unexpected control character found';
            break;
          case JSON_ERROR_SYNTAX:
            $msg =  ' - Syntax error, malformed JSON';
            break;
          case JSON_ERROR_UTF8:
            $msg =  ' - Malformed UTF-8 characters, possibly incorrectly encoded';
            break;
          default:
            $msg =  ' - Unknown error';
            break;
          }
          throw new \Exception('There was an error in the supplied patches file:' . $msg);
        }
      if (isset($patches['patches'])) {
        $patches = $patches['patches'];
        return $patches;
      }
      elseif(!$patches) {
        throw new \Exception('There was an error in the supplied patch file');
      }
    }
    else {
      return array();
    }
  }

References cweagans\Composer\Patches\$patches.

Referenced by cweagans\Composer\Patches\checkPatches(), and cweagans\Composer\Patches\gatherPatches().

Here is the caller graph for this function:

◆ isPatchingEnabled()

cweagans\Composer\Patches::isPatchingEnabled ( )

protected

Checks if the root package enables patching.

Returns: bool Whether patching is enabled. Defaults to TRUE.

Definition at line 372 of file Patches.php.

                                         {
    $extra = $this->composer->getPackage()->getExtra();
 
    if (empty($extra['patches'])) {
      // The root package has no patches of its own, so only allow patching if
      // it has specifically opted in.
      return isset($extra['enable-patching']) ? $extra['enable-patching'] : FALSE;
    }
    else {
      return TRUE;
    }
  }

Referenced by cweagans\Composer\Patches\checkPatches(), and cweagans\Composer\Patches\gatherPatches().

Here is the caller graph for this function:

◆ writePatchReport()

cweagans\Composer\Patches::writePatchReport	(	$patches,
		$directory
	)

protected

Writes a patch report to the target directory.

Parameters

array	$patches
string	$directory

Definition at line 391 of file Patches.php.

                                                            {
    $output = "This file was automatically generated by Composer Patches (https://github.com/cweagans/composer-patches)\n";
    $output .= "Patches applied to this directory:\n\n";
    foreach ($patches as $description => $url) {
      $output .= $description . "\n";
      $output .= 'Source: ' . $url . "\n\n\n";
    }
    file_put_contents($directory . "/PATCHES.txt", $output);
  }

References $description, Sabre\VObject\$output, cweagans\Composer\Patches\$patches, and $url.

Field Documentation

◆ $composer

Composer cweagans\Composer\Patches::$composer

protected

Definition at line 33 of file Patches.php.

Referenced by cweagans\Composer\Patches\activate().

◆ $eventDispatcher

EventDispatcher cweagans\Composer\Patches::$eventDispatcher

protected

Definition at line 41 of file Patches.php.

◆ $executor

ProcessExecutor cweagans\Composer\Patches::$executor

protected

Definition at line 45 of file Patches.php.

◆ $io

IOInterface cweagans\Composer\Patches::$io

protected

Definition at line 37 of file Patches.php.

Referenced by cweagans\Composer\Patches\activate(), and cweagans\Composer\Patches\executeCommand().

◆ $patches

array cweagans\Composer\Patches::$patches

protected

Definition at line 49 of file Patches.php.

Referenced by cweagans\Composer\Patches\checkPatches(), cweagans\Composer\Patches\gatherPatches(), cweagans\Composer\Patches\grabPatches(), and cweagans\Composer\Patches\writePatchReport().

The documentation for this class was generated from the following file:

libs/composer/vendor/cweagans/composer-patches/src/Patches.php

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ activate()

◆ checkPatches()

◆ executeCommand()

◆ gatherPatches()

◆ getAndApplyPatch()

◆ getPackageFromOperation()

◆ getSubscribedEvents()

◆ grabPatches()

◆ isPatchingEnabled()

◆ writePatchReport()

Field Documentation

◆ $composer

◆ $eventDispatcher

◆ $executor

◆ $io

◆ $patches