tfboe / fm-lib

src/TestHelpers/AuthenticatedTestCase.php

Indentation +19 added lines, -19 removed lines

@@ -46,39 +46,39 @@
    */
   protected function jsonAuth(string $method, string $uri, array $data = [], array $headers = [])
   {
-    $headers['Authorization'] = 'Bearer ' . $this->token;
-    return $this->json($method, $uri, $data, $headers);
+	$headers['Authorization'] = 'Bearer ' . $this->token;
+	return $this->json($method, $uri, $data, $headers);
   }
 
   protected function workOnDatabaseDestroy()
   {
-    $this->clearUsers();
-    parent::workOnDatabaseDestroy();
+	$this->clearUsers();
+	parent::workOnDatabaseDestroy();
   }
 
   protected function workOnDatabaseSetUp()
   {
-    $this->clearUsers();
-    parent::workOnDatabaseSetUp();
-    $password = $this->newPassword();
-    $this->user = entity(User::class)->create(['originalPassword' => $password]);
-    /** @noinspection PhpUnhandledExceptionInspection */
-    $this->token = Auth::attempt(['email' => $this->user->getEmail(), 'password' => $password]);
-    $this->refreshApplication();
-    /** @noinspection PhpUndefinedMethodInspection */
-    $this->user = EntityManager::find(User::class, $this->user->getId());
+	$this->clearUsers();
+	parent::workOnDatabaseSetUp();
+	$password = $this->newPassword();
+	$this->user = entity(User::class)->create(['originalPassword' => $password]);
+	/** @noinspection PhpUnhandledExceptionInspection */
+	$this->token = Auth::attempt(['email' => $this->user->getEmail(), 'password' => $password]);
+	$this->refreshApplication();
+	/** @noinspection PhpUndefinedMethodInspection */
+	$this->user = EntityManager::find(User::class, $this->user->getId());
   }
 //</editor-fold desc="Protected Methods">
 
 //<editor-fold desc="Private Methods">
   private function clearUsers()
   {
-    /** @var Connection $connection */
-    /** @noinspection PhpUndefinedMethodInspection */
-    $connection = EntityManager::getConnection();
-    $sql = sprintf('SET FOREIGN_KEY_CHECKS=0;TRUNCATE TABLE %s;SET FOREIGN_KEY_CHECKS=1;', "users");
-    /** @noinspection PhpUnhandledExceptionInspection */
-    $connection->query($sql);
+	/** @var Connection $connection */
+	/** @noinspection PhpUndefinedMethodInspection */
+	$connection = EntityManager::getConnection();
+	$sql = sprintf('SET FOREIGN_KEY_CHECKS=0;TRUNCATE TABLE %s;SET FOREIGN_KEY_CHECKS=1;', "users");
+	/** @noinspection PhpUnhandledExceptionInspection */
+	$connection->query($sql);
   }
 //</editor-fold desc="Private Methods">
 }
\ No newline at end of file

src/TestHelpers/DatabaseTestCase.php

Indentation +59 added lines, -59 removed lines

@@ -41,10 +41,10 @@ 
    */
   public function __construct($name = null, array $data = [], $dataName = '', $clear = false)
   {
-    parent::__construct($name, $data, $dataName);
-    srand(3); //always use the same faker values to get reproducibility
-    $this->faker = Factory::create();
-    $this->clear = $clear;
+	parent::__construct($name, $data, $dataName);
+	srand(3); //always use the same faker values to get reproducibility
+	$this->faker = Factory::create();
+	$this->clear = $clear;
   }
 //</editor-fold desc="Constructor">
 
@@ -56,16 +56,16 @@ 
    */
   protected function clearDatabase()
   {
-    /** @var \Doctrine\DBAL\Connection $connection */
-    /** @noinspection PhpUndefinedMethodInspection */
-    $connection = EntityManager::getConnection();
-    $connection->query(sprintf('SET FOREIGN_KEY_CHECKS = 0;'));
-    $tables = $connection->getSchemaManager()->listTables();
-    foreach ($tables as $table) {
-      $sql = sprintf('TRUNCATE TABLE %s', $table->getName());
-      $connection->query($sql);
-    }
-    $connection->query(sprintf('SET FOREIGN_KEY_CHECKS = 1;'));
+	/** @var \Doctrine\DBAL\Connection $connection */
+	/** @noinspection PhpUndefinedMethodInspection */
+	$connection = EntityManager::getConnection();
+	$connection->query(sprintf('SET FOREIGN_KEY_CHECKS = 0;'));
+	$tables = $connection->getSchemaManager()->listTables();
+	foreach ($tables as $table) {
+	  $sql = sprintf('TRUNCATE TABLE %s', $table->getName());
+	  $connection->query($sql);
+	}
+	$connection->query(sprintf('SET FOREIGN_KEY_CHECKS = 1;'));
   }
 
   /**
@@ -75,11 +75,11 @@ 
    */
   protected function createPlayers(int $number = 1): array
   {
-    $result = [];
-    for ($i = 0; $i < $number; $i++) {
-      $result[] = entity(Player::class)->create();
-    }
-    return $result;
+	$result = [];
+	for ($i = 0; $i < $number; $i++) {
+	  $result[] = entity(Player::class)->create();
+	}
+	return $result;
   }
 
   /**
@@ -90,16 +90,16 @@ 
    */
   protected function createTeams(int $number, $playerPerTeam = 1): array
   {
-    $result = [];
-    for ($i = 0; $i < $number; $i++) {
-      /** @var Team $team */
-      $team = entity(Team::class)->create(['startNumber' => $i + 1, 'rank' => $number - $i]);
-      foreach ($this->createPlayers($playerPerTeam) as $player) {
-        $team->getPlayers()->add($player);
-      }
-      $result[] = $team;
-    }
-    return $result;
+	$result = [];
+	for ($i = 0; $i < $number; $i++) {
+	  /** @var Team $team */
+	  $team = entity(Team::class)->create(['startNumber' => $i + 1, 'rank' => $number - $i]);
+	  foreach ($this->createPlayers($playerPerTeam) as $player) {
+		$team->getPlayers()->add($player);
+	  }
+	  $result[] = $team;
+	}
+	return $result;
   }
 
   /**
@@ -108,13 +108,13 @@ 
    */
   protected function createUser()
   {
-    $password = $this->newPassword();
-    /** @var User $user */
-    $user = entity(User::class)->create(['originalPassword' => $password]);
-    return [
-      'password' => $password,
-      'user' => $user
-    ];
+	$password = $this->newPassword();
+	/** @var User $user */
+	$user = entity(User::class)->create(['originalPassword' => $password]);
+	return [
+	  'password' => $password,
+	  'user' => $user
+	];
   }
 
   /**
@@ -123,7 +123,7 @@ 
    */
   protected function newPassword()
   {
-    return $this->faker->password(8, 30);
+	return $this->faker->password(8, 30);
   }
 
   /**
@@ -134,28 +134,28 @@ 
    */
   protected function setUpTraits()
   {
-    srand(3); //always use the same faker values to get reproducibility
-    $clear = $this->clear;
-    parent::setUpTraits();
-    if ($clear) {
-      $this->clearDatabase();
-      $this->workOnDatabaseSetUp();
-    } else {
-      $this->workOnDatabaseSetUp();
-      /** @noinspection PhpUndefinedMethodInspection */
-      EntityManager::beginTransaction();
-    }
-
-    $this->beforeApplicationDestroyed(function () use ($clear) {
-      if ($clear) {
-        $this->workOnDatabaseDestroy();
-        $this->clearDatabase();
-      } else {
-        /** @noinspection PhpUndefinedMethodInspection */
-        EntityManager::rollback();
-        $this->workOnDatabaseDestroy();
-      }
-    });
+	srand(3); //always use the same faker values to get reproducibility
+	$clear = $this->clear;
+	parent::setUpTraits();
+	if ($clear) {
+	  $this->clearDatabase();
+	  $this->workOnDatabaseSetUp();
+	} else {
+	  $this->workOnDatabaseSetUp();
+	  /** @noinspection PhpUndefinedMethodInspection */
+	  EntityManager::beginTransaction();
+	}
+
+	$this->beforeApplicationDestroyed(function () use ($clear) {
+	  if ($clear) {
+		$this->workOnDatabaseDestroy();
+		$this->clearDatabase();
+	  } else {
+		/** @noinspection PhpUndefinedMethodInspection */
+		EntityManager::rollback();
+		$this->workOnDatabaseDestroy();
+	  }
+	});
   }
 
   protected function workOnDatabaseDestroy()

src/TestHelpers/ReflectionMethods.php

Indentation +14 added lines, -14 removed lines

@@ -26,9 +26,9 @@ 
    */
   protected static function callProtectedMethod($object, string $method, array $args = [])
   {
-    // ReflectionException => get_class is a valid class
-    /** @noinspection PhpUnhandledExceptionInspection */
-    return self::getMethod(get_class($object), $method)->invokeArgs($object, $args);
+	// ReflectionException => get_class is a valid class
+	/** @noinspection PhpUnhandledExceptionInspection */
+	return self::getMethod(get_class($object), $method)->invokeArgs($object, $args);
   }
 
   /**
@@ -40,10 +40,10 @@ 
    */
   protected static function getMethod(string $class, string $name): \ReflectionMethod
   {
-    $class = new \ReflectionClass($class);
-    $method = $class->getMethod($name);
-    $method->setAccessible(true);
-    return $method;
+	$class = new \ReflectionClass($class);
+	$method = $class->getMethod($name);
+	$method->setAccessible(true);
+	return $method;
   }
 
   /**
@@ -55,13 +55,13 @@ 
    */
   protected static function getProperty(string $class, string $name): \ReflectionProperty
   {
-    $class = new \ReflectionClass($class);
-    /** @noinspection PhpStatementHasEmptyBodyInspection */
-    while (!$class->hasProperty($name) && ($class = $class->getParentClass()) !== null) {
-    }
-    $property = $class->getProperty($name);
-    $property->setAccessible(true);
-    return $property;
+	$class = new \ReflectionClass($class);
+	/** @noinspection PhpStatementHasEmptyBodyInspection */
+	while (!$class->hasProperty($name) && ($class = $class->getParentClass()) !== null) {
+	}
+	$property = $class->getProperty($name);
+	$property->setAccessible(true);
+	return $property;
   }
 //</editor-fold desc="Protected Methods">
 }
\ No newline at end of file

src/TestHelpers/UnitTestCase.php

Indentation +43 added lines, -43 removed lines

@@ -34,11 +34,11 @@ 
    */
   protected function createStub(string $class, array $methodResults): MockObject
   {
-    $entity = $this->createMock($class);
-    foreach ($methodResults as $method => $result) {
-      $entity->method($method)->willReturn($result);
-    }
-    return $entity;
+	$entity = $this->createMock($class);
+	foreach ($methodResults as $method => $result) {
+	  $entity->method($method)->willReturn($result);
+	}
+	return $entity;
   }
 
   /**
@@ -50,7 +50,7 @@ 
    */
   protected function createStubWithId(string $class, $entityId = "entity-id", $getterMethod = 'getId')
   {
-    return $this->createStub($class, [$getterMethod => $entityId]);
+	return $this->createStub($class, [$getterMethod => $entityId]);
   }
 
   /**
@@ -62,26 +62,26 @@ 
    * @return MockObject the mocked entity manager
    */
   protected function getEntityManagerMockForQuery(array $result, ?string $expectedQuery = null,
-                                                  array $otherMockedMethods = [])
+												  array $otherMockedMethods = [])
   {
-    $entityManager = $this->getMockForAbstractClass(EntityManager::class, [], '',
-      false, true, true, array_merge($otherMockedMethods, ['createQueryBuilder']));
-    $queryBuilder = $this->getMockForAbstractClass(QueryBuilder::class, [$entityManager],
-      '', true, true, true, ['getQuery']);
-    $query = $this->createMock(AbstractQuery::class);
-    $query->expects(static::once())->method('getResult')->willReturn($result);
-    if ($expectedQuery !== null) {
-      $queryBuilder->expects(static::once())->method('getQuery')->willReturnCallback(
-        function () use ($queryBuilder, $query, $expectedQuery) {
-          /** @var QueryBuilder $queryBuilder */
-          self::assertEquals($expectedQuery, $queryBuilder->getDQL());
-          return $query;
-        });
-    } else {
-      $queryBuilder->expects(static::once())->method('getQuery')->willReturn($query);
-    }
-    $entityManager->expects(static::once())->method('createQueryBuilder')->willReturn($queryBuilder);
-    return $entityManager;
+	$entityManager = $this->getMockForAbstractClass(EntityManager::class, [], '',
+	  false, true, true, array_merge($otherMockedMethods, ['createQueryBuilder']));
+	$queryBuilder = $this->getMockForAbstractClass(QueryBuilder::class, [$entityManager],
+	  '', true, true, true, ['getQuery']);
+	$query = $this->createMock(AbstractQuery::class);
+	$query->expects(static::once())->method('getResult')->willReturn($result);
+	if ($expectedQuery !== null) {
+	  $queryBuilder->expects(static::once())->method('getQuery')->willReturnCallback(
+		function () use ($queryBuilder, $query, $expectedQuery) {
+		  /** @var QueryBuilder $queryBuilder */
+		  self::assertEquals($expectedQuery, $queryBuilder->getDQL());
+		  return $query;
+		});
+	} else {
+	  $queryBuilder->expects(static::once())->method('getQuery')->willReturn($query);
+	}
+	$entityManager->expects(static::once())->method('createQueryBuilder')->willReturn($queryBuilder);
+	return $entityManager;
   }
 
   /** @noinspection PhpDocMissingThrowsInspection */
@@ -94,16 +94,16 @@ 
    * @return MockObject the mocked object
    */
   protected final function getMockWithMockedArguments(string $className, array $arguments = [],
-                                                      array $mockedMethods = []): MockObject
+													  array $mockedMethods = []): MockObject
   {
-    /** @noinspection PhpUnhandledExceptionInspection */
-    $reflection = new \ReflectionClass($className);
-    $params = $reflection->getConstructor()->getParameters();
-    $allArguments = $arguments;
-    for ($i = count($arguments); $i < count($params); $i++) {
-      $allArguments[] = $this->createMock($params[$i]->getClass()->name);
-    }
-    return $this->getMockForAbstractClass($className, $allArguments, '', true, true, true, $mockedMethods);
+	/** @noinspection PhpUnhandledExceptionInspection */
+	$reflection = new \ReflectionClass($className);
+	$params = $reflection->getConstructor()->getParameters();
+	$allArguments = $arguments;
+	for ($i = count($arguments); $i < count($params); $i++) {
+	  $allArguments[] = $this->createMock($params[$i]->getClass()->name);
+	}
+	return $this->getMockForAbstractClass($className, $allArguments, '', true, true, true, $mockedMethods);
   }
 
   /** @noinspection PhpDocMissingThrowsInspection */
@@ -116,19 +116,19 @@ 
    */
   protected final function getObjectWithMockedArguments($className, array $arguments = [])
   {
-    /** @noinspection PhpUnhandledExceptionInspection */
-    $reflection = new \ReflectionClass($className);
-    $params = $reflection->getConstructor()->getParameters();
-    $allArguments = $arguments;
-    for ($i = count($arguments); $i < count($params); $i++) {
-      $allArguments[$i] = $this->createMock($params[$i]->getClass()->name);
-    }
-    return new $className(...$allArguments);
+	/** @noinspection PhpUnhandledExceptionInspection */
+	$reflection = new \ReflectionClass($className);
+	$params = $reflection->getConstructor()->getParameters();
+	$allArguments = $arguments;
+	for ($i = count($arguments); $i < count($params); $i++) {
+	  $allArguments[$i] = $this->createMock($params[$i]->getClass()->name);
+	}
+	return new $className(...$allArguments);
   }
 
   public function tearDown()
   {
-    parent::tearDown();
+	parent::tearDown();
   }
 //</editor-fold desc="Protected Methods">
 }
\ No newline at end of file

src/TestHelpers/OnlyTestLogging.php

Indentation +1 added lines, -1 removed lines

@@ -25,7 +25,7 @@
    */
   public function setTestingTrue()
   {
-    Logging::$testing = true;
+	Logging::$testing = true;
   }
 //</editor-fold desc="Public Methods">
 }
\ No newline at end of file

src/Service/DynamicServiceLoadingService.php

Indentation +10 added lines, -10 removed lines

@@ -30,7 +30,7 @@ 
    */
   public function __construct(Container $app)
   {
-    $this->app = $app;
+	$this->app = $app;
   }
 //</editor-fold desc="Constructor">
 
@@ -40,7 +40,7 @@ 
    */
   public function loadRankingSystemService(string $name): RankingSystemInterface
   {
-    return $this->app->make($this->getClassWithNamespace($name, 'Tfboe\FmLib\Service\RankingSystem'));
+	return $this->app->make($this->getClassWithNamespace($name, 'Tfboe\FmLib\Service\RankingSystem'));
   }
 //</editor-fold desc="Public Methods">
 
@@ -53,14 +53,14 @@ 
    */
   protected function getClassWithNamespace(string $class, string $namespace): string
   {
-    if (strpos($class, 'Interface') === false) {
-      $class .= 'Interface';
-    }
-    if (strpos($class, '\\') === false) {
-      return $namespace . '\\' . $class;
-    } else {
-      return $class;
-    }
+	if (strpos($class, 'Interface') === false) {
+	  $class .= 'Interface';
+	}
+	if (strpos($class, '\\') === false) {
+	  return $namespace . '\\' . $class;
+	} else {
+	  return $class;
+	}
   }
 //</editor-fold desc="Protected Methods">
 //<editor-fold desc="Private Methods">

src/Service/RankingSystem/EloRanking.php

Indentation +116 added lines, -116 removed lines

@@ -46,7 +46,7 @@ 
    */
   protected function getAdditionalFields(): array
   {
-    return ['playedGames' => 0, 'ratedGames' => 0, 'provisoryRanking' => 1200.0];
+	return ['playedGames' => 0, 'ratedGames' => 0, 'provisoryRanking' => 1200.0];
   }
 
   /**
@@ -54,51 +54,51 @@ 
    */
   protected function getChanges(TournamentHierarchyEntity $entity, RankingSystemList $list): array
   {
-    /** @var Game $game */
-    $game = $entity;
-    $changes = [];
-
-    if (!$game->isPlayed() || $game->getResult() === Result::NOT_YET_FINISHED ||
-      $game->getResult() === Result::NULLED) {
-      //game gets not elo rated
-      $this->addNotRatedChanges($changes, $game->getPlayersA(), $entity, $list->getRankingSystem());
-      $this->addNotRatedChanges($changes, $game->getPlayersB(), $entity, $list->getRankingSystem());
-      return $changes;
-    }
-
-    $entriesA = $this->getEntriesOfPlayers($game->getPlayersA(), $list);
-    $entriesB = $this->getEntriesOfPlayers($game->getPlayersB(), $list);
-
-    $isAProvisory = $this->hasProvisoryEntry($entriesA);
-    $isBProvisory = $this->hasProvisoryEntry($entriesB);
-
-    $averageA = $this->getEloAverage($entriesA);
-    $averageB = $this->getEloAverage($entriesB);
-
-    $expectationA = 1 / (1 + 10 ** (($averageB - $averageA) / self::EXP_DIFF));
-    $expectationB = 1 - $expectationA;
-
-    $resultA = 0.0;
-
-    switch ($game->getResult()) {
-      case Result::TEAM_A_WINS:
-        $resultA = 1.0;
-        break;
-      case Result::DRAW:
-        $resultA = 0.5;
-        break;
-    }
-    $resultB = 1 - $resultA;
-
-    $expectationDiffA = $resultA - $expectationA;
-    $expectationDiffB = $resultB - $expectationB;
-
-
-    $this->computeChanges($changes, $entriesA, $resultA, $expectationDiffA, $game, $averageA, $averageB,
-      $isAProvisory, $isBProvisory);
-    $this->computeChanges($changes, $entriesB, $resultB, $expectationDiffB, $game, $averageB, $averageA,
-      $isBProvisory, $isAProvisory);
-    return $changes;
+	/** @var Game $game */
+	$game = $entity;
+	$changes = [];
+
+	if (!$game->isPlayed() || $game->getResult() === Result::NOT_YET_FINISHED ||
+	  $game->getResult() === Result::NULLED) {
+	  //game gets not elo rated
+	  $this->addNotRatedChanges($changes, $game->getPlayersA(), $entity, $list->getRankingSystem());
+	  $this->addNotRatedChanges($changes, $game->getPlayersB(), $entity, $list->getRankingSystem());
+	  return $changes;
+	}
+
+	$entriesA = $this->getEntriesOfPlayers($game->getPlayersA(), $list);
+	$entriesB = $this->getEntriesOfPlayers($game->getPlayersB(), $list);
+
+	$isAProvisory = $this->hasProvisoryEntry($entriesA);
+	$isBProvisory = $this->hasProvisoryEntry($entriesB);
+
+	$averageA = $this->getEloAverage($entriesA);
+	$averageB = $this->getEloAverage($entriesB);
+
+	$expectationA = 1 / (1 + 10 ** (($averageB - $averageA) / self::EXP_DIFF));
+	$expectationB = 1 - $expectationA;
+
+	$resultA = 0.0;
+
+	switch ($game->getResult()) {
+	  case Result::TEAM_A_WINS:
+		$resultA = 1.0;
+		break;
+	  case Result::DRAW:
+		$resultA = 0.5;
+		break;
+	}
+	$resultB = 1 - $resultA;
+
+	$expectationDiffA = $resultA - $expectationA;
+	$expectationDiffB = $resultB - $expectationB;
+
+
+	$this->computeChanges($changes, $entriesA, $resultA, $expectationDiffA, $game, $averageA, $averageB,
+	  $isAProvisory, $isBProvisory);
+	$this->computeChanges($changes, $entriesB, $resultB, $expectationDiffB, $game, $averageB, $averageA,
+	  $isBProvisory, $isAProvisory);
+	return $changes;
   }
 
   /** @noinspection PhpMissingParentCallCommonInspection */
@@ -107,7 +107,7 @@ 
    */
   protected function startPoints(): float
   {
-    return 1200.0;
+	return 1200.0;
   }
 //</editor-fold desc="Protected Methods">
 
@@ -120,16 +120,16 @@ 
    * @param \Tfboe\FmLib\Entity\RankingSystem $ranking
    */
   private function addNotRatedChanges(array &$changes, Collection $players, TournamentHierarchyEntity $entity,
-                                      RankingSystem $ranking)
+									  RankingSystem $ranking)
   {
-    foreach ($players as $player) {
-      $change = $this->getOrCreateChange($entity, $ranking, $player);
-      $change->setPointsChange(0.0);
-      $change->setPlayedGames(0);
-      $change->setRatedGames(0);
-      $change->setProvisoryRanking(0.0);
-      $changes[] = $change;
-    }
+	foreach ($players as $player) {
+	  $change = $this->getOrCreateChange($entity, $ranking, $player);
+	  $change->setPointsChange(0.0);
+	  $change->setPlayedGames(0);
+	  $change->setRatedGames(0);
+	  $change->setProvisoryRanking(0.0);
+	  $changes[] = $change;
+	}
   }
 
   /** @noinspection PhpTooManyParametersInspection */ //TODO refactor this method
@@ -145,56 +145,56 @@ 
    * @param bool $opponentHasProvisory
    */
   private function computeChanges(array &$changes, array $entries, float $result, float $expectationDiff, Game $game,
-                                  float $teamAverage, float $opponentAverage, bool $teamHasProvisory,
-                                  bool $opponentHasProvisory)
+								  float $teamAverage, float $opponentAverage, bool $teamHasProvisory,
+								  bool $opponentHasProvisory)
   {
-    foreach ($entries as $entry) {
-      $change = $this->getOrCreateChange($game, $entry->getRankingSystemList()->getRankingSystem(),
-        $entry->getPlayer());
-      $change->setPlayedGames(1);
-      $factor = 2 * $result - 1;
-      if ($entry->getPlayedGames() < self::NUM_PROVISORY_GAMES) {
-        //provisory entry => recalculate
-        if (count($entries) > 1) {
-          $teamMatesAverage = ($teamAverage * count($entries) - $entry->getProvisoryRanking()) /
-            (count($entries) - 1);
-          if ($teamMatesAverage > $opponentAverage + self::MAX_DIFF_TO_OPPONENT_FOR_PROVISORY) {
-            $teamMatesAverage = $opponentAverage + self::MAX_DIFF_TO_OPPONENT_FOR_PROVISORY;
-          }
-          if ($teamMatesAverage < $opponentAverage - self::MAX_DIFF_TO_OPPONENT_FOR_PROVISORY) {
-            $teamMatesAverage = $opponentAverage - self::MAX_DIFF_TO_OPPONENT_FOR_PROVISORY;
-          }
-          $performance = $opponentAverage * (1 + self::PROVISORY_PARTNER_FACTOR) -
-            $teamMatesAverage * self::PROVISORY_PARTNER_FACTOR;
-        } else {
-          $performance = $opponentAverage;
-        }
-        if ($performance < self::START) {
-          $performance = self::START;
-        }
-        $performance += self::EXP_DIFF * $factor;
-        //old average performance = $entry->getProvisoryRating()
-        //=> new average performance = ($entry->getProvisoryRating() * $entry->getRatedGames() + $performance) /
-        //                             ($entry->getRatedGames() + 1)
-        //=> performance change = ($entry->getProvisoryRating() * $entry->getRatedGames() + $performance) /
-        //                        ($entry->getRatedGames() + 1) - $entry->getProvisoryRating()
-        //                      = ($performance - $entry->getProvisoryRating()) / ($entry->getRatedGames() + 1)
-        $change->setProvisoryRanking(($performance - $entry->getProvisoryRanking()) / ($entry->getRatedGames() + 1));
-        $change->setPointsChange(0.0);
-        $change->setRatedGames(1);
-      } else if (!$teamHasProvisory && !$opponentHasProvisory) {
-        //real elo ranking
-        $change->setProvisoryRanking(0.0);
-        $change->setPointsChange(self::K * $expectationDiff);
-        $change->setRatedGames(1);
-      } else {
-        //does not get rated
-        $change->setProvisoryRanking(0.0);
-        $change->setPointsChange(0.0);
-        $change->setRatedGames(0);
-      }
-      $changes[] = $change;
-    }
+	foreach ($entries as $entry) {
+	  $change = $this->getOrCreateChange($game, $entry->getRankingSystemList()->getRankingSystem(),
+		$entry->getPlayer());
+	  $change->setPlayedGames(1);
+	  $factor = 2 * $result - 1;
+	  if ($entry->getPlayedGames() < self::NUM_PROVISORY_GAMES) {
+		//provisory entry => recalculate
+		if (count($entries) > 1) {
+		  $teamMatesAverage = ($teamAverage * count($entries) - $entry->getProvisoryRanking()) /
+			(count($entries) - 1);
+		  if ($teamMatesAverage > $opponentAverage + self::MAX_DIFF_TO_OPPONENT_FOR_PROVISORY) {
+			$teamMatesAverage = $opponentAverage + self::MAX_DIFF_TO_OPPONENT_FOR_PROVISORY;
+		  }
+		  if ($teamMatesAverage < $opponentAverage - self::MAX_DIFF_TO_OPPONENT_FOR_PROVISORY) {
+			$teamMatesAverage = $opponentAverage - self::MAX_DIFF_TO_OPPONENT_FOR_PROVISORY;
+		  }
+		  $performance = $opponentAverage * (1 + self::PROVISORY_PARTNER_FACTOR) -
+			$teamMatesAverage * self::PROVISORY_PARTNER_FACTOR;
+		} else {
+		  $performance = $opponentAverage;
+		}
+		if ($performance < self::START) {
+		  $performance = self::START;
+		}
+		$performance += self::EXP_DIFF * $factor;
+		//old average performance = $entry->getProvisoryRating()
+		//=> new average performance = ($entry->getProvisoryRating() * $entry->getRatedGames() + $performance) /
+		//                             ($entry->getRatedGames() + 1)
+		//=> performance change = ($entry->getProvisoryRating() * $entry->getRatedGames() + $performance) /
+		//                        ($entry->getRatedGames() + 1) - $entry->getProvisoryRating()
+		//                      = ($performance - $entry->getProvisoryRating()) / ($entry->getRatedGames() + 1)
+		$change->setProvisoryRanking(($performance - $entry->getProvisoryRanking()) / ($entry->getRatedGames() + 1));
+		$change->setPointsChange(0.0);
+		$change->setRatedGames(1);
+	  } else if (!$teamHasProvisory && !$opponentHasProvisory) {
+		//real elo ranking
+		$change->setProvisoryRanking(0.0);
+		$change->setPointsChange(self::K * $expectationDiff);
+		$change->setRatedGames(1);
+	  } else {
+		//does not get rated
+		$change->setProvisoryRanking(0.0);
+		$change->setPointsChange(0.0);
+		$change->setRatedGames(0);
+	  }
+	  $changes[] = $change;
+	}
   }
 
   /**
@@ -204,11 +204,11 @@ 
    */
   private function getEloAverage(array $entries): float
   {
-    $sum = 0;
-    foreach ($entries as $entry) {
-      $sum += $entry->getRatedGames() < self::NUM_PROVISORY_GAMES ? $entry->getProvisoryRanking() : $entry->getPoints();
-    }
-    return $sum / count($entries);
+	$sum = 0;
+	foreach ($entries as $entry) {
+	  $sum += $entry->getRatedGames() < self::NUM_PROVISORY_GAMES ? $entry->getProvisoryRanking() : $entry->getPoints();
+	}
+	return $sum / count($entries);
   }
 
   /**
@@ -218,12 +218,12 @@ 
    */
   private function hasProvisoryEntry(array $entries): bool
   {
-    foreach ($entries as $entry) {
-      if ($entry->getPlayedGames() < self::NUM_PROVISORY_GAMES) {
-        return true;
-      }
-    }
-    return false;
+	foreach ($entries as $entry) {
+	  if ($entry->getPlayedGames() < self::NUM_PROVISORY_GAMES) {
+		return true;
+	  }
+	}
+	return false;
   }
 //</editor-fold desc="Private Methods">
 }
\ No newline at end of file

src/Service/RankingSystem/EntityComparerByTimeStartTimeAndLocalIdentifier.php

Indentation +45 added lines, -45 removed lines

@@ -31,7 +31,7 @@ 
    */
   public function __construct(TimeServiceInterface $timeService)
   {
-    $this->timeService = $timeService;
+	$this->timeService = $timeService;
   }
 //</editor-fold desc="Constructor">
 
@@ -42,18 +42,18 @@ 
    */
   public function compareEntities(TournamentHierarchyInterface $entity1, TournamentHierarchyInterface $entity2): int
   {
-    $tmpE1 = $entity1;
-    $tmpE2 = $entity2;
-    while ($tmpE1 !== null && $tmpE2 !== null && $tmpE1->getId() !== $tmpE2->getId()) {
-      $comparison = $this->compareEntityTimes($tmpE1, $tmpE2);
-      if ($comparison !== 0) {
-        return $comparison;
-      }
-      $tmpE1 = $tmpE1->getParent();
-      $tmpE2 = $tmpE2->getParent();
-    }
+	$tmpE1 = $entity1;
+	$tmpE2 = $entity2;
+	while ($tmpE1 !== null && $tmpE2 !== null && $tmpE1->getId() !== $tmpE2->getId()) {
+	  $comparison = $this->compareEntityTimes($tmpE1, $tmpE2);
+	  if ($comparison !== 0) {
+		return $comparison;
+	  }
+	  $tmpE1 = $tmpE1->getParent();
+	  $tmpE2 = $tmpE2->getParent();
+	}
 
-    return $this->compareLocalIdentifiersWithinTournament($entity1, $entity2);
+	return $this->compareLocalIdentifiersWithinTournament($entity1, $entity2);
   }
 //</editor-fold desc="Public Methods">
 
@@ -66,23 +66,23 @@ 
    *             entity2 are before the times of entity1 and 0 if they have the same times
    */
   protected function compareEntityTimes(TournamentHierarchyInterface $entity1,
-                                        TournamentHierarchyInterface $entity2)
+										TournamentHierarchyInterface $entity2)
   {
-    $time1 = $this->timeService->getTime($entity1);
-    $time2 = $this->timeService->getTime($entity2);
-    if ($time1 < $time2) {
-      return -1;
-    } else if ($time1 > $time2) {
-      return 1;
-    }
-    if ($entity1->getStartTime() !== null && $entity2->getStartTime() !== null) {
-      if ($entity1->getStartTime() < $entity2->getStartTime()) {
-        return -1;
-      } else if ($entity1->getStartTime() > $entity2->getStartTime()) {
-        return 1;
-      }
-    }
-    return 0;
+	$time1 = $this->timeService->getTime($entity1);
+	$time2 = $this->timeService->getTime($entity2);
+	if ($time1 < $time2) {
+	  return -1;
+	} else if ($time1 > $time2) {
+	  return 1;
+	}
+	if ($entity1->getStartTime() !== null && $entity2->getStartTime() !== null) {
+	  if ($entity1->getStartTime() < $entity2->getStartTime()) {
+		return -1;
+	  } else if ($entity1->getStartTime() > $entity2->getStartTime()) {
+		return 1;
+	  }
+	}
+	return 0;
   }
 
   /**
@@ -93,20 +93,20 @@ 
    *             and 0 if the two entities are equal (<=> all predecessors have same local identifiers)
    */
   protected function compareLocalIdentifiersWithinTournament(TournamentHierarchyInterface $entity1,
-                                                             TournamentHierarchyInterface $entity2)
+															 TournamentHierarchyInterface $entity2)
   {
-    //compare unique identifiers within tournament
-    $predecessors1 = $this->getPredecessors($entity1);
-    $predecessors2 = $this->getPredecessors($entity2);
+	//compare unique identifiers within tournament
+	$predecessors1 = $this->getPredecessors($entity1);
+	$predecessors2 = $this->getPredecessors($entity2);
 
-    for ($i = count($predecessors1) - 1; $i >= 0; $i--) {
-      if ($predecessors1[$i]->getLocalIdentifier() !== $predecessors2[$i]->getLocalIdentifier()) {
-        return $predecessors1[$i]->getLocalIdentifier() <=> $predecessors2[$i]->getLocalIdentifier();
-      }
-    }
+	for ($i = count($predecessors1) - 1; $i >= 0; $i--) {
+	  if ($predecessors1[$i]->getLocalIdentifier() !== $predecessors2[$i]->getLocalIdentifier()) {
+		return $predecessors1[$i]->getLocalIdentifier() <=> $predecessors2[$i]->getLocalIdentifier();
+	  }
+	}
 
-    //the two entities are equal
-    return 0;
+	//the two entities are equal
+	return 0;
   }
 //</editor-fold desc="Protected Methods">
 
@@ -118,12 +118,12 @@ 
    */
   private function getPredecessors(TournamentHierarchyInterface $entity): array
   {
-    $res = [];
-    while ($entity !== null) {
-      $res[] = $entity;
-      $entity = $entity->getParent();
-    }
-    return $res;
+	$res = [];
+	while ($entity !== null) {
+	  $res[] = $entity;
+	  $entity = $entity->getParent();
+	}
+	return $res;
   }
 //</editor-fold desc="Private Methods">
 }
\ No newline at end of file

src/Service/RankingSystem/RankingSystemInterface.php

Indentation +1 added lines, -1 removed lines

@@ -39,7 +39,7 @@
    *                       tournament before the change
    */
   public function updateRankingForTournament(RankingSystem $ranking, Tournament $tournament,
-                                             ?\DateTime $oldInfluence);
+											 ?\DateTime $oldInfluence);
 
   /**
    * Updates the rankings assuming all changes happened after $from.