feat(composer): composer.lock support (#2255)

Adds logic to support updating the accompanying `composer.lock` file whenever `composer.json` is updated.

Closes #2098

lib/manager/composer/extract.js

@@ -4,7 +4,7 @@ module.exports = {
   extractDependencies,
 };
 
-function extractDependencies(content, packageFile) {
+async function extractDependencies(content, packageFile) {
   logger.debug('composer.extractDependencies()');
   let packageJson;
   try {
@@ -50,5 +50,14 @@ function extractDependencies(content, packageFile) {
   if (!deps.length) {
     return null;
   }
-  return { deps };
+  let composerLock = false;
+  const filePath = packageFile.replace(/\.json$/, '.lock');
+  if (await platform.getFile(filePath)) {
+    logger.debug(
+      { packageFile: packageFile.packageFile },
+      'Found composer.lock'
+    );
+    composerLock = filePath;
+  }
+  return { deps, composerLock };
 }

lib/manager/composer/index.js

@@ -1,10 +1,12 @@
 const { extractDependencies } = require('./extract');
 const { updateDependency } = require('../npm/update');
+const { getLockFile } = require('./lock-file');
 
 const language = 'php';
 
 module.exports = {
   extractDependencies,
+  getLockFile,
   language,
   updateDependency,
   // TODO: support this

lib/manager/composer/lock-file.js

@@ -0,0 +1,69 @@
+const { exec } = require('child-process-promise');
+const fs = require('fs-extra');
+const tmp = require('tmp-promise');
+const upath = require('upath');
+
+module.exports = {
+  getLockFile,
+};
+
+async function getLockFile(
+  packageFileName,
+  updatedDeps,
+  newPackageFileContent
+) {
+  logger.debug(`composer.getLockFile(${packageFileName})`);
+  const composerLockPath = packageFileName.replace(/\.json$/, '.lock');
+  const existingComposerLockContent = await platform.getFile(composerLockPath);
+  if (!existingComposerLockContent) {
+    logger.debug('No composer.lock found');
+    return null;
+  }
+  const tmpDir = await tmp.dir({ unsafeCleanup: true });
+  let stdout;
+  let stderr;
+  try {
+    const composerJsonFileName = upath.join(tmpDir.path, 'composer.json');
+    await fs.outputFile(composerJsonFileName, newPackageFileContent);
+    const composerLockFileName = upath.join(tmpDir.path, 'composer.lock');
+    await fs.outputFile(composerLockFileName, existingComposerLockContent);
+    const env = { HOME: process.env.HOME, PATH: process.env.PATH };
+    const startTime = process.hrtime();
+    const cmd = ('composer update ' + updatedDeps.join(' ')).trim();
+    logger.debug({ cmd });
+    ({ stdout, stderr } = await exec(cmd, {
+      cwd: tmpDir.path,
+      shell: true,
+      env,
+    }));
+    logger.debug(`composer stdout:\n${stdout}`);
+    logger.debug(`composer stderr:\n${stderr}`);
+    const duration = process.hrtime(startTime);
+    const seconds = Math.round(duration[0] + duration[1] / 1e9);
+    const newComposerLockContent = await fs.readFile(
+      composerLockFileName,
+      'utf8'
+    );
+    logger.info(
+      { seconds, type: 'composer.lock', stdout, stderr },
+      'Generated lockfile'
+    );
+    if (newComposerLockContent === existingComposerLockContent) {
+      logger.debug('composer.lock is unchanged');
+      return null;
+    }
+    logger.debug('Returning updated composer.lock');
+    return {
+      name: composerLockPath,
+      contents: newComposerLockContent,
+    };
+  } catch (err) {
+    logger.warn(
+      { err, message: err.message },
+      'Failed to generate composer.lock'
+    );
+    return null;
+  } finally {
+    tmpDir.cleanup();
+  }
+}

lib/workers/branch/get-updated.js

@@ -8,9 +8,15 @@ async function getUpdatedPackageFiles(config) {
   logger.debug('manager.getUpdatedPackageFiles()');
   logger.trace({ config });
   const updatedFileContents = {};
+  const packageFileManagers = {};
+  const packageFileUpdatedDeps = {};
 
   for (const upgrade of config.upgrades) {
-    const { manager, packageFile } = upgrade;
+    const { manager, packageFile, depName } = upgrade;
+    packageFileManagers[packageFile] = manager;
+    packageFileUpdatedDeps[packageFile] =
+      packageFileUpdatedDeps[packageFile] || [];
+    packageFileUpdatedDeps[packageFile].push(depName);
     if (upgrade.updateType !== 'lockFileMaintenance') {
       const existingContent =
         updatedFileContents[packageFile] ||
@@ -46,8 +52,25 @@ async function getUpdatedPackageFiles(config) {
     name,
     contents: updatedFileContents[name],
   }));
+  const updatedLockFiles = [];
+  for (const packageFile of updatedPackageFiles) {
+    const manager = packageFileManagers[packageFile.name];
+    const updatedDeps = packageFileUpdatedDeps[packageFile.name];
+    const getLockFile = get(manager, 'getLockFile');
+    if (getLockFile) {
+      const updatedLockFile = await getLockFile(
+        packageFile.name,
+        updatedDeps,
+        packageFile.contents
+      );
+      if (updatedLockFile) {
+        updatedLockFiles.push(updatedLockFile);
+      }
+    }
+  }
   return {
     parentBranch: config.parentBranch, // Need to overwrite original config
     updatedPackageFiles,
+    updatedLockFiles,
   };
 }