add url for comparison

Author: IonBazan

.github/workflows/test.yml

@@ -56,4 +56,9 @@ jobs:
         run: |
           composer req infection/infection
           vendor/bin/infection --ignore-msi-with-no-mutations --min-covered-msi=100 --min-msi=100 -s -j4
+      - name: Run phpstan
+        if: ${{ matrix.php-versions >= 7.1 && matrix.php-versions < 8.0 }}
+        run: |
+          composer req phpstan/phpstan
+          vendor/bin/phpstan analyse src -l 6
 

README.md

@@ -65,7 +65,9 @@ composer diff # Displays packages changed in current git tree compared with HEAD
  - `--no-dev` - ignore dev dependencies (`require-dev`)
  - `--no-prod` - ignore prod dependencies (`require`)
  - `--with-platform` (`-p`) - include platform dependencies (PHP, extensions, etc.)
+ - `--with-links` (`-l`) - include compare/release URLs
  - `--format` (`-f`) - output format (mdtable, mdlist) - default: `mdtable`
+ - `--gitlab-domains` - custom gitlab domains for compare/release URLs - default: use composer config
 
 ## Advanced usage
 

src/Command/DiffCommand.php

@@ -7,6 +7,7 @@
 use IonBazan\ComposerDiff\Formatter\MarkdownListFormatter;
 use IonBazan\ComposerDiff\Formatter\MarkdownTableFormatter;
 use IonBazan\ComposerDiff\PackageDiff;
+use IonBazan\ComposerDiff\Url\GeneratorContainer;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
@@ -18,13 +19,25 @@ class DiffCommand extends BaseCommand
      */
     protected $packageDiff;
 
-    public function __construct(PackageDiff $packageDiff)
+    /**
+     * @var string[]
+     */
+    protected $gitlabDomains;
+
+    /**
+     * @param string[] $gitlabDomains
+     */
+    public function __construct(PackageDiff $packageDiff, array $gitlabDomains = array())
     {
         $this->packageDiff = $packageDiff;
+        $this->gitlabDomains = $gitlabDomains;
 
         parent::__construct();
     }
 
+    /**
+     * @return void
+     */
     protected function configure()
     {
         $this->setName('diff')
@@ -34,25 +47,33 @@ protected function configure()
             ->addOption('no-dev', null, InputOption::VALUE_NONE, 'Ignore dev dependencies')
             ->addOption('no-prod', null, InputOption::VALUE_NONE, 'Ignore prod dependencies')
             ->addOption('with-platform', 'p', InputOption::VALUE_NONE, 'Include platform dependencies (PHP version, extensions, etc.)')
+            ->addOption('with-links', 'l', InputOption::VALUE_NONE, 'Include compare/release URLs')
             ->addOption('format', 'f', InputOption::VALUE_REQUIRED, 'Output format (mdtable, mdlist)', 'mdtable')
+            ->addOption('gitlab-domains', null, InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY, 'Gitlab domains', array())
         ;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     protected function execute(InputInterface $input, OutputInterface $output)
     {
         $base = $input->getOption('base');
         $target = $input->getOption('target');
         $withPlatform = $input->getOption('with-platform');
+        $withUrls = $input->getOption('with-links');
+        $this->gitlabDomains = array_merge($this->gitlabDomains, $input->getOption('gitlab-domains'));
+
         $formatter = $this->getFormatter($input, $output);
 
         if (!$input->getOption('no-prod')) {
             $operations = $this->packageDiff->getPackageDiff($base, $target, false, $withPlatform);
-            $formatter->render($operations, 'Prod Packages', $output);
+            $formatter->render($operations, 'Prod Packages', $withUrls);
         }
 
         if (!$input->getOption('no-dev')) {
             $operations = $this->packageDiff->getPackageDiff($base, $target, true, $withPlatform);
-            $formatter->render($operations, 'Dev Packages', $output);
+            $formatter->render($operations, 'Dev Packages', $withUrls);
         }
 
         return 0;
@@ -63,12 +84,14 @@ protected function execute(InputInterface $input, OutputInterface $output)
      */
     private function getFormatter(InputInterface $input, OutputInterface $output)
     {
+        $urlGenerators = new GeneratorContainer($this->gitlabDomains);
+
         switch ($input->getOption('format')) {
             case 'mdlist':
-                return new MarkdownListFormatter($output);
+                return new MarkdownListFormatter($output, $urlGenerators);
             case 'mdtable':
             default:
-                return new MarkdownTableFormatter($output);
+                return new MarkdownTableFormatter($output, $urlGenerators);
         }
     }
 }

src/Formatter/AbstractFormatter.php

@@ -2,17 +2,94 @@
 
 namespace IonBazan\ComposerDiff\Formatter;
 
+use Composer\DependencyResolver\Operation\InstallOperation;
+use Composer\DependencyResolver\Operation\OperationInterface;
+use Composer\DependencyResolver\Operation\UninstallOperation;
 use Composer\DependencyResolver\Operation\UpdateOperation;
+use Composer\Package\PackageInterface;
 use Composer\Semver\Semver;
 use Composer\Semver\VersionParser;
+use IonBazan\ComposerDiff\Url\GeneratorContainer;
+use Symfony\Component\Console\Output\OutputInterface;
 
 abstract class AbstractFormatter implements Formatter
 {
+    /**
+     * @var OutputInterface
+     */
+    protected $output;
+
+    /**
+     * @var GeneratorContainer
+     */
+    protected $generators;
+
+    public function __construct(OutputInterface $output, GeneratorContainer $generators)
+    {
+        $this->output = $output;
+        $this->generators = $generators;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getUrl(OperationInterface $operation)
+    {
+        if ($operation instanceof UpdateOperation) {
+            return $this->getCompareUrl($operation->getInitialPackage(), $operation->getTargetPackage());
+        }
+
+        if ($operation instanceof InstallOperation || $operation instanceof UninstallOperation) {
+            return $this->getReleaseUrl($operation->getPackage());
+        }
+
+        return null;
+    }
+
+    /**
+     * @return string|null
+     */
+    private function getCompareUrl(PackageInterface $basePackage, PackageInterface $targetPackage)
+    {
+        $generator = $this->generators->get($targetPackage);
+
+        if (!$generator) {
+            return null;
+        }
+
+        return $generator->getCompareUrl($basePackage, $targetPackage);
+    }
+
+    /**
+     * @return string|null
+     */
+    private function getReleaseUrl(PackageInterface $package)
+    {
+        $generator = $this->generators->get($package);
+
+        if (!$generator) {
+            return null;
+        }
+
+        return $generator->getReleaseUrl($package);
+    }
+
+    /**
+     * @param string $url
+     * @param string $title
+     *
+     * @return string
+     */
+    abstract protected function formatUrl($url, $title);
+
+    /**
+     * @return bool
+     */
     protected static function isUpgrade(UpdateOperation $operation)
     {
         $versionParser = new VersionParser();
-        $normalizedFrom = $versionParser->normalize($operation->getInitialPackage()->getFullPrettyVersion());
-        $normalizedTo = $versionParser->normalize($operation->getTargetPackage()->getFullPrettyVersion());
+        $normalizedFrom = $versionParser->normalize($operation->getInitialPackage()->getVersion());
+        $normalizedTo = $versionParser->normalize($operation->getTargetPackage()->getVersion());
 
         $sorted = Semver::sort(array($normalizedTo, $normalizedFrom));
 

src/Formatter/Formatter.php

@@ -9,8 +9,14 @@ interface Formatter
     /**
      * @param OperationInterface[] $operations
      * @param string               $title
+     * @param bool                 $withUrls
      *
      * @return void
      */
-    public function render(array $operations, $title);
+    public function render(array $operations, $title, $withUrls);
+
+    /**
+     * @return string|null
+     */
+    public function getUrl(OperationInterface $operation);
 }

src/Formatter/Helper/MarkdownTable.php

@@ -11,14 +11,20 @@ class MarkdownTable
      */
     protected $output;
 
+    /**
+     * @var string[]
+     */
     protected $headers = array();
 
+    /**
+     * @var string[][]
+     */
     protected $rows = array();
 
     /**
      * Column widths cache.
      *
-     * @var array
+     * @var int[]
      */
     private $columnWidths = array();
 
@@ -27,13 +33,23 @@ public function __construct(OutputInterface $output)
         $this->output = $output;
     }
 
+    /**
+     * @param string[] $headers
+     *
+     * @return $this
+     */
     public function setHeaders(array $headers)
     {
         $this->headers = $headers;
 
         return $this;
     }
 
+    /**
+     * @param string[][] $rows
+     *
+     * @return $this
+     */
     public function setRows(array $rows)
     {
         $this->rows = array();
@@ -45,6 +61,9 @@ public function setRows(array $rows)
         return $this;
     }
 
+    /**
+     * @return void
+     */
     public function render()
     {
         $this->renderRow($this->headers);
@@ -55,11 +74,21 @@ public function render()
         }
     }
 
+    /**
+     * @param string[] $row
+     *
+     * @return void
+     */
     private function renderRow(array $row)
     {
         $this->output->writeln(sprintf('| %s |', implode(' | ', $this->prepareRow($row))));
     }
 
+    /**
+     * @param string[] $row
+     *
+     * @return string[]
+     */
     private function prepareRow(array $row)
     {
         $line = array();
@@ -71,6 +100,9 @@ private function prepareRow(array $row)
         return $line;
     }
 
+    /**
+     * @return void
+     */
     private function renderHorizontalLine()
     {
         $line = array();
@@ -82,17 +114,30 @@ private function renderHorizontalLine()
         $this->output->writeln(sprintf('|%s|', implode('|', $line)));
     }
 
+    /**
+     * @param string[] $row
+     * @param int      $column
+     *
+     * @return string
+     */
     private function prepareCell(array $row, $column)
     {
         return str_pad($row[$column], $this->getColumnWidth($column));
     }
 
+    /**
+     * @param int $column
+     *
+     * @return int
+     */
     private function getColumnWidth($column)
     {
         if (isset($this->columnWidths[$column])) {
             return $this->columnWidths[$column];
         }
 
+        $lengths = array();
+
         foreach (array_merge(array($this->headers), $this->rows) as $row) {
             $lengths[] = strlen($row[$column]);
         }

src/Formatter/MarkdownFormatter.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace IonBazan\ComposerDiff\Formatter;
+
+abstract class MarkdownFormatter extends AbstractFormatter
+{
+    /**
+     * @param string|null $url
+     * @param string      $title
+     *
+     * @return string
+     */
+    protected function formatUrl($url, $title)
+    {
+        return null !== $url ? sprintf('[%s](%s)', $title, $url) : '';
+    }
+}