Use JSON output for composer licenses command (#37)

* Use JSON output for composer licenses command

Use a well-known format instead of manually parsing text to extract the required information.

Author: dominikb

composer-license-checker

@@ -8,6 +8,7 @@ use Dominikb\ComposerLicenseChecker\LicenseLookup;
 use Dominikb\ComposerLicenseChecker\ReportCommand;
 use Symfony\Component\Console\Output\ConsoleOutput;
 use Dominikb\ComposerLicenseChecker\DependencyLoader;
+use Dominikb\ComposerLicenseChecker\JSONDependencyParser;
 use Dominikb\ComposerLicenseChecker\ConstraintViolationDetector;
 
 function includeIfExists(string $file): bool
@@ -35,11 +36,11 @@ $licenceLookUp = new LicenseLookup($httpClient);
 $checkCommand = new CheckCommand;
 $checkCommand->setLicenseLookup($licenceLookUp);
 $checkCommand->setLicenseConstraintHandler(new ConstraintViolationDetector);
-$checkCommand->setDependencyLoader(new DependencyLoader);
+$checkCommand->setDependencyLoader(new DependencyLoader(new JSONDependencyParser()));
 
 $reportCommand = new ReportCommand;
 $reportCommand->setLicenseLookup($licenceLookUp);
-$reportCommand->setDependencyLoader(new DependencyLoader);
+$reportCommand->setDependencyLoader(new DependencyLoader(new JSONDependencyParser()));
 
 $application = new Application('composer-license-checker', '2.2.0');
 

composer.json

@@ -18,6 +18,7 @@
     ],
     "require": {
         "php": "^7.3|^8.0",
+        "ext-json": "*",
         "composer/composer": "^1.10.27|~2.2.22|^2.6.4",
         "guzzlehttp/guzzle": "^6.3|^7.2",
         "psr/simple-cache": "^1.0|^2.0|^3.0",

src/Contracts/DependencyParser.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Dominikb\ComposerLicenseChecker\Contracts;
+
+use Dominikb\ComposerLicenseChecker\Dependency;
+
+interface DependencyParser
+{
+    /**
+     * @return Dependency[]
+     */
+    public function parse(string $dependencyOutput): array;
+}

src/DependencyLoader.php

@@ -5,42 +5,32 @@
 namespace Dominikb\ComposerLicenseChecker;
 
 use Dominikb\ComposerLicenseChecker\Contracts\DependencyLoader as DependencyLoaderContract;
+use Dominikb\ComposerLicenseChecker\Contracts\DependencyParser;
 
 class DependencyLoader implements DependencyLoaderContract
 {
-    const LINES_BEFORE_DEPENDENCY_VERSIONS = 6;
+    /**
+     * @var DependencyParser
+     */
+    private $dependencyParser;
 
-    public function loadDependencies(string $composer, string $project): array
+    public function __construct(DependencyParser $dependencyParser)
     {
-        $commandOutput = $this->runComposerLicenseCommand($composer, $project);
-
-        $cleanOutput = $this->stripHeadersFromOutput($commandOutput);
-
-        return $this->splitColumnsIntoDependencies($cleanOutput);
+        $this->dependencyParser = $dependencyParser;
     }
 
-    private function runComposerLicenseCommand(string $composer, string $project): array
+    public function loadDependencies(string $composer, string $project): array
     {
-        $command = sprintf('%s licenses -d %s', $composer, $project);
-
-        return $this->exec($command);
-    }
+        $commandOutput = $this->runComposerLicenseCommand($composer, $project);
 
-    private function stripHeadersFromOutput(array $output): array
-    {
-        return array_slice($output, self::LINES_BEFORE_DEPENDENCY_VERSIONS);
+        return $this->dependencyParser->parse(join(PHP_EOL, $commandOutput));
     }
 
-    private function splitColumnsIntoDependencies(array $output): array
+    private function runComposerLicenseCommand(string $composer, string $project, string $format = 'json'): array
     {
-        $parser = new DependencyParser;
-
-        $mappedToObjects = [];
-        foreach ($output as $dependency) {
-            $mappedToObjects[] = $parser->parse($dependency);
-        }
+        $command = sprintf('%s licenses -f %s -d %s', $composer, $format, $project);
 
-        return $mappedToObjects;
+        return $this->exec($command);
     }
 
     protected function exec(string $command)

src/DependencyParser.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Dominikb\ComposerLicenseChecker;
+
+use Dominikb\ComposerLicenseChecker\Contracts\DependencyParser as DependencyParserContract;
+
+class JSONDependencyParser implements DependencyParserContract
+{
+    public function parse(string $dependencyOutput): array
+    {
+        $dependencyOutput = json_decode($dependencyOutput, true);
+
+        $parsed = [];
+        foreach ($dependencyOutput['dependencies'] as $name => $info) {
+            $parsed[] = (new Dependency)
+                ->setName($name)
+                ->setVersion($info['version'])
+                ->setLicenses($info['license']);
+        }
+
+        return $parsed;
+    }
+}

src/JSONDependencyParser.php

@@ -191,9 +191,9 @@ protected function outputFormattedLicenses(OutputInterface $output, InputInterfa
 
             for ($i = 0; $i < $columnWidth; $i++) {
                 $licenseTable->addRow([
-                    'CAN'    => $can[$i],
+                    'CAN' => $can[$i],
                     'CANNOT' => $cannot[$i],
-                    'MUST'   => $must[$i],
+                    'MUST' => $must[$i],
                 ]);
             }
             $licenseTable->render();

src/ReportCommand.php

@@ -4,6 +4,7 @@
 
 namespace Dominikb\ComposerLicenseChecker\Tests;
 
+use Dominikb\ComposerLicenseChecker\Contracts\DependencyParser;
 use Dominikb\ComposerLicenseChecker\DependencyLoader;
 use Mockery;
 
@@ -12,28 +13,31 @@ class DependencyLoaderTest extends TestCase
     /** @test */
     public function it_runs_the_command_with_the_given_inputs()
     {
-        $loader = Mockery::mock(DependencyLoader::class)
-                         ->shouldAllowMockingProtectedMethods()
+        $loader = Mockery::mock(DependencyLoader::class, [$this->createNoOpParser()])
                          ->makePartial();
 
         $command = '';
-        $loader->shouldReceive('exec')
+        $loader->shouldAllowMockingProtectedMethods()
+               ->shouldReceive('exec')
                ->once()
                ->withArgs(function ($c) use (&$command) {
                    return (bool) ($command = $c);
                })
-               ->andReturn([
-                   'Name: dominikb/composer-license-checker',
-                   'Version: dev-master',
-                   'Licenses: MIT',
-                   'Dependencies:',
-                   '',
-                   'Name                                  Version              License   ',
-                   'dominikb/composer-license-checker     dev-master f12312    MIT',
-               ]);
+               ->andReturn([]);
 
         $loader->loadDependencies('./composerpath/composer-binary', '/some/directory');
 
-        $this->assertEquals('./composerpath/composer-binary licenses -d /some/directory', $command);
+        $this->assertEquals('./composerpath/composer-binary licenses -f json -d /some/directory', $command);
+    }
+
+    public function createNoOpParser(): DependencyParser
+    {
+        return new class implements DependencyParser
+        {
+            public function parse(string $dependencyOutput): array
+            {
+                return [];
+            }
+        };
     }
 }