adding dependencies for command line tools

diff --git a/lib/private/app/dependencyanalyzer.php b/lib/private/app/dependencyanalyzer.php
index fb4b376165632878d6afa967471ab0bba749b73c..172b8e88c06f209cbbae9db90004c3cc3f0ecb19 100644 (file)
--- a/lib/private/app/dependencyanalyzer.php
+++ b/lib/private/app/dependencyanalyzer.php
@@ -10,31 +10,31 @@
 
 namespace OC\App;
 
+use OCP\IL10N;
+
 class DependencyAnalyzer {
 
        /** @var Platform */
-       private $system;
+       private $platform;
 
        /** @var \OCP\IL10N */
        private $l;
 
        /** @var array  */
-       private $missing;
+       private $missing = array();
 
        /** @var array  */
-       private $dependencies;
+       private $dependencies = array();
 
        /**
         * @param array $app
         * @param Platform $platform
         * @param \OCP\IL10N $l
         */
-       function __construct(array $app, $platform, $l) {
-               $this->system = $platform;
+       function __construct(array $app, Platform $platform, IL10N $l) {
+               $this->platform = $platform;
                $this->l = $l;
-               $this->missing = array();
-               $this->dependencies = array();
-               if (array_key_exists('dependencies', $app)) {
+               if (isset($app['dependencies'])) {
                        $this->dependencies = $app['dependencies'];
                }
        }
@@ -46,20 +46,21 @@ class DependencyAnalyzer {
        public function analyze() {
                $this->analysePhpVersion();
                $this->analyseSupportedDatabases();
+               $this->analyseCommands();
                return $this->missing;
        }
 
        private function analysePhpVersion() {
                if (isset($this->dependencies['php']['@attributes']['min-version'])) {
                        $minVersion = $this->dependencies['php']['@attributes']['min-version'];
-                       if (version_compare($this->system->getPhpVersion(), $minVersion, '<')) {
-                               $this->missing[] = (string)$this->l->t('PHP %s or higher is required.', $minVersion);
+                       if (version_compare($this->platform->getPhpVersion(), $minVersion, '<')) {
+                               $this->addMissing((string)$this->l->t('PHP %s or higher is required.', $minVersion));
                        }
                }
                if (isset($this->dependencies['php']['@attributes']['max-version'])) {
                        $maxVersion = $this->dependencies['php']['@attributes']['max-version'];
-                       if (version_compare($this->system->getPhpVersion(), $maxVersion, '>')) {
-                               $this->missing[] = (string)$this->l->t('PHP with a version less then %s is required.', $maxVersion);
+                       if (version_compare($this->platform->getPhpVersion(), $maxVersion, '>')) {
+                               $this->addMissing((string)$this->l->t('PHP with a version less then %s is required.', $maxVersion));
                        }
                }
        }
@@ -74,14 +75,46 @@ class DependencyAnalyzer {
                        return;
                }
                $supportedDatabases = array_map(function($db) {
-                       if (isset($db['@value'])) {
-                               return $db['@value'];
-                       }
-                       return $db;
+                       return $this->getValue($db);
                }, $supportedDatabases);
-               $currentDatabase = $this->system->getDatabase();
+               $currentDatabase = $this->platform->getDatabase();
                if (!in_array($currentDatabase, $supportedDatabases)) {
-                       $this->missing[] = (string)$this->l->t('Following databases are supported: %s', join(', ', $supportedDatabases));
+                       $this->addMissing((string)$this->l->t('Following databases are supported: %s', join(', ', $supportedDatabases)));
+               }
+       }
+
+       private function analyseCommands() {
+               if (!isset($this->dependencies['command'])) {
+                       return;
+               }
+
+               $commands = $this->dependencies['command'];
+               $os = $this->platform->getOS();
+               foreach($commands as $command) {
+                       if (isset($command['@attributes']['os']) && $command['@attributes']['os'] !== $os) {
+                               continue;
+                       }
+                       $commandName = $this->getValue($command);
+                       if (!$this->platform->isCommandKnown($commandName)) {
+                               $this->addMissing((string)$this->l->t('The command line tool %s could not be found', $commandName));
+                       }
                }
        }
+
+       /**
+        * @param $element
+        * @return mixed
+        */
+       private function getValue($element) {
+               if (isset($element['@value']))
+                       return $element['@value'];
+               return strval($element);
+       }
+
+       /**
+        * @param $minVersion
+        */
+       private function addMissing($message) {
+               $this->missing[] = $message;
+       }
 }

diff --git a/lib/private/app/platform.php b/lib/private/app/platform.php
index 39f8a2979f9267cc3fd3e016378c6ebd64ff5329..da515a235a2fdc505cb734677e1f102cc9b57f0a 100644 (file)
--- a/lib/private/app/platform.php
+++ b/lib/private/app/platform.php
@@ -12,16 +12,32 @@ namespace OC\App;
 
 use OCP\IConfig;
 
+/**
+ * Class Platform
+ *
+ * This class basically abstracts any kind of information which can be retrieved from the underlying system.
+ *
+ * @package OC\App
+ */
 class Platform {
 
+       /**
+        * @param IConfig $config
+        */
        function __construct(IConfig $config) {
                $this->config = $config;
        }
 
+       /**
+        * @return string
+        */
        public function getPhpVersion() {
                return phpversion();
        }
 
+       /**
+        * @return string
+        */
        public function getDatabase() {
                $dbType = $this->config->getSystemValue('dbtype', 'sqlite');
                if ($dbType === 'sqlite3') {
@@ -30,4 +46,20 @@ class Platform {
 
                return $dbType;
        }
+
+       /**
+        * @return string
+        */
+       public function getOS() {
+               return php_uname('s');
+       }
+
+       /**
+        * @param $command
+        * @return bool
+        */
+       public function isCommandKnown($command) {
+               $path = \OC_Helper::findBinaryPath($command);
+               return ($path !== null);
+       }
 }

diff --git a/tests/lib/app/dependencyanalyzer.php b/tests/lib/app/dependencyanalyzer.php
index 7d06842e8ad039fce12355ac686c652ecd9e60e2..a21b53264bc30d77c5284841790ae59e1a831e5c 100644 (file)
--- a/tests/lib/app/dependencyanalyzer.php
+++ b/tests/lib/app/dependencyanalyzer.php
@@ -35,6 +35,15 @@ class DependencyAnalyzer extends \PHPUnit_Framework_TestCase {
                $this->platformMock->expects($this->any())
                        ->method('getDatabase')
                        ->will( $this->returnValue('mysql'));
+               $this->platformMock->expects($this->any())
+                       ->method('getOS')
+                       ->will( $this->returnValue('Linux'));
+               $this->platformMock->expects($this->any())
+                       ->method('isCommandKnown')
+                       ->will( $this->returnCallback(function($command) {
+                               return ($command === 'grep');
+                       }));
+
                $this->l10nMock = $this->getMockBuilder('\OCP\IL10N')
                        ->disableOriginalConstructor()
                        ->getMock();
@@ -64,7 +73,6 @@ class DependencyAnalyzer extends \PHPUnit_Framework_TestCase {
                $missing = $analyser->analyze();
 
                $this->assertTrue(is_array($missing));
-               $this->assertEquals(count($expectedMissing), count($missing));
                $this->assertEquals($expectedMissing, $missing);
        }
 
@@ -83,10 +91,41 @@ class DependencyAnalyzer extends \PHPUnit_Framework_TestCase {
                $missing = $analyser->analyze();
 
                $this->assertTrue(is_array($missing));
-               $this->assertEquals(count($expectedMissing), count($missing));
                $this->assertEquals($expectedMissing, $missing);
        }
 
+       /**
+        * @dataProvider providesCommands
+        */
+       public function testCommand($expectedMissing, $commands) {
+               $app = array(
+                       'dependencies' => array(
+                       )
+               );
+               if (!is_null($commands)) {
+                       $app['dependencies']['command'] = $commands;
+               }
+               $analyser = new \OC\App\DependencyAnalyzer($app, $this->platformMock, $this->l10nMock);
+               $missing = $analyser->analyze();
+
+               $this->assertTrue(is_array($missing));
+               $this->assertEquals($expectedMissing, $missing);
+       }
+
+       function providesCommands() {
+               return array(
+                       array(array(), null),
+                       // grep is known on linux
+                       array(array(), array(array('@attributes' => array('os' => 'Linux'), '@value' => 'grep'))),
+                       // grepp is not known on linux
+                       array(array('The command line tool grepp could not be found'), array(array('@attributes' => array('os' => 'Linux'), '@value' => 'grepp'))),
+                       // we don't care about tools on Windows - we are on Linux
+                       array(array(), array(array('@attributes' => array('os' => 'Windows'), '@value' => 'grepp'))),
+                       // grep is known on all systems
+                       array(array(), array('grep')),
+               );
+       }
+
        function providesDatabases() {
                return array(
                        // non BC - in case on databases are defined -> all are supported