initial

Author: IonBazan

.gitignore

@@ -0,0 +1,4 @@
+/vendor
+/composer.lock
+/.php_cs.cache
+/.php_cs

.php_cs.dist

@@ -0,0 +1,18 @@
+<?php
+
+$finder = PhpCsFixer\Finder::create()
+    ->files()
+    ->in(__DIR__.'/src')
+    ->in(__DIR__.'/tests')
+    ->name('*.php')
+;
+
+return PhpCsFixer\Config::create()
+    ->setUsingCache(true)
+    ->setRiskyAllowed(true)
+    ->setRules(array(
+        '@PSR2' => true,
+        '@Symfony' => true,
+        'array_syntax' => array('syntax' => 'long'),
+    ))
+    ->setFinder($finder);

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Ion Bazan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,33 @@
+# Composer Diff Plugin
+
+Generates packages changes report in Markdown format by comparing `composer.lock` files.
+
+# Installation
+
+```shell script
+composer global require ion-bazan/composer-diff
+```
+ 
+# Usage
+
+```shell script
+composer diff # Displays packages changed in current git tree compared with HEAD
+``` 
+
+## Options
+
+ - `--base` (`-b`) - path, URL or git ref to original `composer.lock` file
+ - `--target` (`-t`) - path, URL or git ref to modified `composer.lock` file
+ - `--no-dev` - ignore dev dependencies (`require-dev`)
+ - `--no-prod` - ignore prod dependencies (`require`)
+ - `--with-platform` (`-p`) - include platform dependencies (PHP, extensions, etc.)
+ 
+## Advanced usage
+
+```shell script
+composer diff -b master:composer.lock -t develop:composer.lock -p # Compare master and develop branches, including platform dependencies
+composer diff --no-dev # ignore dev dependencies
+composer diff -p # include platform dependencies
+```
+
+

composer-diff

@@ -0,0 +1,19 @@
+#!/usr/bin/env php
+<?php
+
+foreach ([__DIR__.'/../../autoload.php', __DIR__.'/../autoload.php', __DIR__.'/vendor/autoload.php'] as $file) {
+    if (file_exists($file)) {
+        require_once $file;
+        break;
+    }
+}
+
+unset($file);
+
+use IonBazan\ComposerDiff\Command\DiffCommand;
+use Symfony\Component\Console\Application;
+
+$application = new Application();
+$application->add(new DiffCommand());
+$application->setDefaultCommand('diff',  true);
+$application->run();

composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "ion-bazan/composer-diff",
+    "type": "composer-plugin",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Ion Bazan",
+            "email": "ion.bazan@gmail.com"
+        }
+    ],
+    "require": {
+        "php": "^5.3.2 || ^7.0 || ^8.0",
+        "ext-json": "*",
+        "composer-plugin-api": "^1.1 || ^2.0",
+        "composer/composer": "^1.1 || ^2.0",
+        "symfony/console": "dev-master"
+    },
+    "require-dev": {},
+    "config": {
+        "platform-check": false
+    },
+    "extra": {
+        "class": "IonBazan\\ComposerDiff\\Plugin"
+    },
+    "autoload": {
+        "psr-4": {
+            "IonBazan\\ComposerDiff\\": "src"
+        }
+    },
+    "bin": [
+        "composer-diff"
+    ]
+}

src/Command/DiffCommand.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace IonBazan\ComposerDiff\Command;
+
+use Composer\Command\BaseCommand;
+use Composer\DependencyResolver\Operation\InstallOperation;
+use Composer\DependencyResolver\Operation\OperationInterface;
+use Composer\DependencyResolver\Operation\UninstallOperation;
+use Composer\DependencyResolver\Operation\UpdateOperation;
+use IonBazan\ComposerDiff\MarkdownTable;
+use IonBazan\ComposerDiff\PackageDiff;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class DiffCommand extends BaseCommand
+{
+    protected function configure()
+    {
+        $this->setName('diff')
+            ->setDescription('Displays package diff')
+            ->addOption('base', 'b', InputOption::VALUE_REQUIRED, 'Base composer.lock file path or git ref', 'HEAD:composer.lock')
+            ->addOption('target', 't', InputOption::VALUE_REQUIRED, 'Target composer.lock file path or git ref', 'composer.lock')
+            ->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.)')
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $base = $input->getOption('base');
+        $target = $input->getOption('target');
+        $withPlatform = $input->getOption('with-platform');
+        $diff = new PackageDiff();
+
+        if (!$input->getOption('no-prod')) {
+            $operations = $diff->getPackageDiff($base, $target, false, $withPlatform);
+            $this->displayTable($operations, 'Prod Packages', $output);
+        }
+
+        if (!$input->getOption('no-dev')) {
+            $operations = $diff->getPackageDiff($base, $target, true, $withPlatform);
+            $this->displayTable($operations, 'Dev Packages', $output);
+        }
+
+        return 0;
+    }
+
+    protected function displayTable(array $operations, $header, OutputInterface $output)
+    {
+        $table = new MarkdownTable($output);
+
+        foreach ($operations as $operation) {
+            $table->addRow($this->getTableRow($operation));
+        }
+
+        $table->setHeaders(array($header, 'Base', 'Target'))->render();
+        $output->writeln('');
+    }
+
+    protected function getTableRow(OperationInterface $operation)
+    {
+        if ($operation instanceof InstallOperation) {
+            return array(
+                $operation->getPackage()->getName(),
+                'New',
+                $operation->getPackage()->getFullPrettyVersion(),
+            );
+        }
+
+        if ($operation instanceof UpdateOperation) {
+            return array(
+                $operation->getInitialPackage()->getName(),
+                $operation->getInitialPackage()->getFullPrettyVersion(),
+                $operation->getTargetPackage()->getFullPrettyVersion(),
+            );
+        }
+
+        if ($operation instanceof UninstallOperation) {
+            return array(
+                $operation->getPackage()->getName(),
+                $operation->getPackage()->getFullPrettyVersion(),
+                'Removed',
+            );
+        }
+
+        throw new \InvalidArgumentException('Invalid operation');
+    }
+}

src/MarkdownTable.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace IonBazan\ComposerDiff;
+
+use Symfony\Component\Console\Helper\TableSeparator;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class MarkdownTable
+{
+    /**
+     * @var OutputInterface
+     */
+    protected $output;
+
+    protected $headers = array();
+
+    protected $rows = array();
+
+    /**
+     * Column widths cache.
+     *
+     * @var array
+     */
+    private $columnWidths = array();
+
+    public function __construct(OutputInterface $output)
+    {
+        $this->output = $output;
+    }
+
+    public function setHeaders(array $headers)
+    {
+        $this->headers = array_values($headers);
+
+        return $this;
+    }
+
+    public function setRows(array $rows)
+    {
+        $this->rows = array();
+
+        return $this->addRows($rows);
+    }
+
+    public function addRows(array $rows)
+    {
+        foreach ($rows as $row) {
+            $this->addRow($row);
+        }
+
+        return $this;
+    }
+
+    public function addRow(array $row)
+    {
+        $this->rows[] = array_values($row);
+
+        return $this;
+    }
+
+    public function render()
+    {
+        $this->renderRow($this->headers);
+        $this->renderHorizontalLine();
+
+        foreach ($this->rows as $row) {
+            $this->renderRow($row);
+        }
+    }
+
+    private function renderRow(array $row)
+    {
+        $this->output->writeln(sprintf('| %s |', implode(' | ', $this->prepareRow($row))));
+    }
+
+    private function prepareRow(array $row)
+    {
+        $line = array();
+
+        foreach ($row as $column => $cell) {
+            $line[] = $this->prepareCell($row, $column);
+        }
+
+        return $line;
+    }
+
+    private function renderHorizontalLine()
+    {
+        $line = array();
+
+        foreach ($this->headers as $column => $cell) {
+            $line[] = str_repeat('-', $this->getColumnWidth($column) + 2);
+        }
+
+        $this->output->writeln(sprintf('|%s|', implode('|', $line)));
+    }
+
+    private function prepareCell(array $row, $column)
+    {
+        return str_pad($row[$column], $this->getColumnWidth($column));
+    }
+
+    private function getColumnWidth($column)
+    {
+        if (isset($this->columnWidths[$column])) {
+            return $this->columnWidths[$column];
+        }
+
+        foreach (array_merge($this->headers, $this->rows) as $row) {
+            if ($row instanceof TableSeparator) {
+                continue;
+            }
+
+            $lengths[] = strlen($row[$column]);
+        }
+
+        return $this->columnWidths[$column] = max($lengths);
+    }
+}