/**
* Checks the remote version file against the local version file.
*
* @return string
*/
public function check()
{
//Parse local version file
$versionFile = base_path('version.json');
if (!file_exists($versionFile)) {
return view('self-updater::error')->with('error', 'No version file found.');
}
$localVersionFile = file_get_contents(base_path('version.json'));
$localVersionJson = json_decode($localVersionFile, true);
//Parse remote version file
$remoteVersionFile = @file_get_contents(config('self-updater.remote_uri') . '/remote_version.json');
if ($remoteVersionFile === false) {
return view('self-updater::error')->with('error', 'Can not read remote version file.');
}
$remoteVersionJson = json_decode($remoteVersionFile, true);
$remoteVersion = $remoteVersionJson['version'];
$localVersion = $localVersionJson['version'];
$newVersion = Compare::greaterThan(Parser::parse($remoteVersion), Parser::parse($localVersion));
return view('self-updater::checker', compact('localVersion', 'remoteVersion', 'newVersion'));
}
private function greaterOrEqual($givenAppVersion, $pluginMinAppVersion)
{
try {
$givenAppVersionSem = Parser::parse($givenAppVersion);
$pluginMinAppVersionSem = Parser::parse($pluginMinAppVersion);
return Compare::greaterThan($givenAppVersionSem, $pluginMinAppVersionSem) || Compare::equals($givenAppVersionSem, $pluginMinAppVersionSem);
} catch (\Exception $e) {
return false;
}
}
/**
* Assert that of two version strings the first is bigger than the other
*
* @return void
**/
private function assertVersionBiggerThan($v1String, $v2String)
{
// Parse them
$v1 = Parser::parse($v1String);
$v2 = Parser::parse($v2String);
// Versions should not be equal
$this->assertFalse(Compare::equals($v1, $v2), 'Version "' . $v1 . '" should *not* be equal to "' . $v2 . '"');
// Greater than and not greater than
$this->assertTrue(Compare::greaterThan($v1, $v2), 'Version "' . $v1 . '" should be greater than "' . $v2 . '"');
$this->assertFalse(Compare::greaterThan($v2, $v1), 'Version "' . $v2 . '" should be greater than "' . $v1 . '"');
// Smaller than and not smaller than
$this->assertTrue(Compare::smallerThan($v2, $v1), 'Version "' . $v2 . '" should be smaller than "' . $v1 . '"');
$this->assertFalse(Compare::smallerThan($v1, $v2), 'Version "' . $v1 . '" should *not* be smaller than "' . $v2 . '"');
}
/**
* Get the next logical version relative to the provided base version. If
* no base is supplied, base will be the same as the current version.
*
* @param Version|string|null $base
* @return Version
* @throws InvalidArgumentException
*/
public function next($base = null)
{
// Ensure that $base is a Version. Parse it if we must, use ourself if
// it is empty.
if (empty($base)) {
$base = $this;
} else {
if (is_string($base)) {
$base = Parser::parse($base);
} elseif (!$base instanceof Version) {
throw new InvalidArgumentException("\$base must be of type Version");
}
}
// If the base is ahead of this Version then the next version will be
// the base.
if (Compare::greaterThan($base, $this)) {
return $base->cleanCopy();
}
$next = new Version();
$next->setMajor($this->getMajor());
$next->setMinor($this->getMinor());
$next->setPatch($this->getPatch());
if ($base->hasPreRelease()) {
if ($this->hasPreRelease()) {
// We already know that $base is less than or equal to $this
// and we won't be jumping to the next greek value. So it is
// safe use $this prerelease and just increment the release
// number.
$pre = new PreRelease();
$pre->setGreek($this->getPreRelease()->getGreek());
$pre->setReleaseNumber($this->getPreRelease()->getReleaseNumber() + 1);
$next->setPreRelease($pre);
} else {
throw new InvalidArgumentException("This version has left prerelease without updating the base. Base should not be prerelease.");
}
} elseif (!$this->hasPreRelease()) {
$next->setPatch($this->getPatch() + 1);
}
// The case of $this having a pre-release when $base does not means
// that we are essentially just leaving pre-release. Nothing needs to
// be done.
return $next;
}
/**
* Sort an array of Versions
*
* unlike sort() this method accepts only an array of Version instances
*
* This method uses QuickSort for the actual sorting
*
* @param array[int]Version
* @return array[int]Version
**/
public static function sortArray(array $versions)
{
// Empty array does not needs sorting
if (count($versions) === 0) {
return array();
}
// Array of one item (pivot) from the middle
$pivotArray = array_splice($versions, (int) floor((count($versions) - 1) / 2), 1);
// Smaller/greater than pivot stack
$smaller = array();
$greater = array();
// Fill stacks
foreach ($versions as $version) {
if (Compare::greaterThan($version, $pivotArray[0])) {
$greater[] = $version;
} else {
$smaller[] = $version;
}
}
// Recurse and merge results
return array_merge(self::sortArray($smaller), $pivotArray, self::sortArray($greater));
}
