Get the minimum required phing version

@return string
421896
public function getPhingVersion()
    {
        if ($this->phingVersion === null) {
            $this->setPhingVersion(Phing::getPhingVersion());
        }

        return $this->phingVersion;
    }
1049460
public function get_requirements_bin() {
        $requires = 0;
        if ($this->require_data_guarantee()) {
            $requires += cache_store::SUPPORTS_DATA_GUARANTEE;
        }
        if ($this->require_multiple_identifiers()) {
            $requires += cache_store::SUPPORTS_MULTIPLE_IDENTIFIERS;
        }
        if ($this->require_searchable()) {
            $requires += cache_store::IS_SEARCHABLE;
        }
        return $requires;
    }
57973
private function getMaxFileSize(): int
    {
        $validatorConfiguration = $this->assetMapper
            ->getAssetFieldDefinition()
            ->getValidatorConfiguration();

        $maxFileSize = $validatorConfiguration['FileSizeValidator']['maxFileSize'];
        if ($maxFileSize > 0) {
            return min($maxFileSize * 1024 * 1024, $this->maxUploadSize->get());
        }

        return $this->maxUploadSize->get();
    }
1099468
public function checkPHPversion(string $minPhpVersion = null)
    {
        $minVersionPhp = $minPhpVersion;
        $currentPhpVersion = $this->getPhpVersionInfo();
        $supported = false;

        if ($minPhpVersion == null) {
            $minVersionPhp = $this->getMinPhpVersion();
        }

        if (version_compare($currentPhpVersion['version'], $minVersionPhp) >= 0) {
            $supported = true;
        }

        $phpStatus = [
            'full' => $currentPhpVersion['full'],
            'current' => $currentPhpVersion['version'],
            'minimum' => $minVersionPhp,
            'supported' => $supported
        ];

        return $phpStatus;
    }
35510
public function 
    {

        $dmm = $this;

        usort($this->migrations, function ($a, $b) use ($dmm) {

            $av = $a->getVersion();
            $bv = $b->getVersion();

            if ($dmm->direction == 'up') {
                return version_compare($av, $bv);
            } elseif ($dmm->direction == 'down') {
                return version_compare($bv, $av);
            }
        });
    }
151777
public function getVersion()
    {
        $code = $this->runShell('tika --version', $stdout);

        // Parse output
        if (!$code && preg_match('/Apache Tika (?<version>[\.\d]+)/', $stdout, $matches)) {
            return $matches['version'];
        }

        return 0;
    }
933776
public function getLowerVersion($old_version)
    {
        foreach ($this->getPhantomJsVersions() as $idx => $version) {
            // if $old_version is bigger than $version from versions array, return $version
            if (version_compare($old_version, $version) == 1) {
                return $version;
            }
        }
    }
1296273
public function getVersion()
    {
        if (!array_key_exists(self::VERSION_KEY, $this->data)) {
            $this->data[self::VERSION_KEY] = self::MINIMUM_VERSION;
        }

        if (!version_compare($this->data[self::VERSION_KEY], SwaggerParser::MINIMUM_VERSION, '>=')) {
            throw new InvalidVersionException($this->data[self::VERSION_KEY]);
        }

        return $this->data[self::VERSION_KEY];
    }
89954
public static function validateRequirements()
    {

        $requirements = array(
            'version' => '',
            'spl' => '',
            'curl' => '',
            'dom' => ''
        );

        $version = str_replace('.', '', phpversion());

        if ($version < 5427) {
            $requirements['version'] = 'PagSeguroLibrary: PHP version 5.4.27 or greater is required.';
        }

        if (!function_exists('spl_autoload_register')) {
            $requirements['spl'] = 'PagSeguroLibrary: Standard PHP Library (SPL) is required.';
        }

        if (!function_exists('curl_init')) {
            $requirements['curl'] = 'PagSeguroLibrary: cURL library is required.';
        }

        if (!class_exists('DOMDocument')) {
            $requirements['dom'] = 'PagSeguroLibrary: DOM XML extension is required.';
        }

        return $requirements;
    }
235946
public function getModuleVersion() {
        // Get the module path
        $module_path = $this->directoryReader->getModuleDir('', 'CheckoutCom_Magento2');

        // Get the content of composer.json
        $json = file_get_contents($module_path . '/composer.json');

        // Decode the data and return
        $data = json_decode($json);

        return $data->version;
    }
428338
public function requirements()
    {
        $phpSupportInfo = $this->requirements->checkPHPversion(
            config('installer.core.minPhpVersion')
        );
        $requirements = $this->requirements->check(
            config('installer.requirements')
        );

        return view('vendor.installer.requirements', compact('requirements', 'phpSupportInfo'));
    }
18833
public function browserVersion()
    {
        $UserAgent = self::agent();
        $B_Agent = self::Browser()['agent'];
        if ($B_Agent !== null) {
            $known = ['Version', $B_Agent, 'other'];
            $pattern = '#(?<browser>'.implode('|', $known).
            ')[/ ]+(?<version>[0-9.|a-zA-Z.]*)#';
            if (!preg_match_all($pattern, $UserAgent, $matches)) {
            }
            $i = count($matches['browser']);
            if ($i != 1) {
                if (strripos($UserAgent, 'Version') < strripos($UserAgent, $B_Agent)) {
                    $Version = $matches['version'][0];
                } else {
                    $Version = $matches['version'][0];
                }
            } else {
                $Version = $matches['version'][0];
            }
        }

        return $Version;
    }
791646
private function getAppVersion()
    {
        $version = $this->app->version();
        if (substr($version, 0, 7) === 'Lumen (') {
            $version = array_first(explode(')', str_replace('Lumen (', '', $version)));
        }
        return $version;
    }
1155147
public function getVersion() {
    $version = $this->Cache->read('version', null);
    if ($version !== null) {
      return $version;
    }
    $version = array(2, 0, 0);

    $lines = array();
    $result = $this->Process->run($this->config['ffmpeg.bin'], array('-version'), $lines);
    if ($result == 0 && $lines && preg_match('/^\w+\s(version\s)?(\d+)\.(\d+)\.(\d+).*/', $lines[0], $m)) {
      $version = array($m[2], $m[3], $m[4]);
    } else if ($result == 0 && $lines && preg_match('/^\w+\s(version\s)?\S*N-(\d+)-.*/', $lines[0], $m)) {
      $winVersion = $m[2];
      if ($winVersion <= 30610) {
        $version = array(0, 6, 0);
      } else if ($winVersion <= 30956) {
        $version = array(0, 7, 0);
      } else if ($winVersion <= 48409) {
        $version = array(0, 8, 0);
      } else if ($winVersion <= 48610) {
        $version = array(1, 0, 1);
      } else if ($winVersion <= 49044) {
        $version = array(1, 1, 0);
      } else {
        $version = array(2, 0, 0);
      }
    }
    $this->Cache->write('version', $version);
    return $version;
  }
876523
public function getVerifier()
    {
        Deprecated::method(3.3);

        if (! $this->verifier) {
            $verifier = new LowlevelChecks($this);
            $this->verifier = $verifier;
        }

        return $this->verifier;
    }
1372263
private function comparePhingVersion($version)
    {
        $current = strtolower(self::getPhingVersion());
        $current = trim(str_replace('phing', '', $current));

        // make sure that version checks are not applied to trunk
        if ('dev' === $current) {
            return 1;
        }

        if (-1 == version_compare($current, $version)) {
            throw new BuildException(
                sprintf('Incompatible Phing version (%s). Version "%s" required.', $current, $version)
            );
        }
    }
1033869
public function getOperatingSystemVersion()
    {
        $os = $this->getOperatingSystem();

        return $this->prepareVersion([$os->major, $os->minor, $os->patch]);
    }