cs-fixer

src/Application/Event/EventManager.php

@@ -127,7 +127,7 @@ public function getRepo()
      */
     public function setReturnType($returnType = EventAggregateRepositoryInterface::RETURN_AS_ARRAY)
     {
-        if(!in_array($returnType, [EventAggregateRepositoryInterface::RETURN_AS_ARRAY, EventAggregateRepositoryInterface::RETURN_AS_OBJECT])){
+        if (!in_array($returnType, [EventAggregateRepositoryInterface::RETURN_AS_ARRAY, EventAggregateRepositoryInterface::RETURN_AS_OBJECT])) {
             throw new NotSupportedReturnTypeException($returnType . ' is not a valid returnType value.');
         }
 
@@ -167,8 +167,8 @@ public function setElasticServer(array $hosts = [])
     public function storeEvents($aggregateName, array $events = [])
     {
         $aggregate = $this->checkIfAggregateExistsOrReturnNewInstance($aggregateName);
-        foreach ($events as $event){
-            if(!$event instanceof EventInterface){
+        foreach ($events as $event) {
+            if (!$event instanceof EventInterface) {
                 throw new NotValidEventException('Not a valid instance of EventInterface was provided.');
             }
 
@@ -177,7 +177,7 @@ public function storeEvents($aggregateName, array $events = [])
 
         $this->repo->save($aggregate);
 
-        if($this->elastic){
+        if ($this->elastic) {
             $this->elastic->addAggregateToIndex($aggregate);
         }
     }
@@ -189,7 +189,7 @@ public function storeEvents($aggregateName, array $events = [])
      */
     private function checkIfAggregateExistsOrReturnNewInstance($aggregateName)
     {
-        if($this->repo->exists($aggregateName)){
+        if ($this->repo->exists($aggregateName)) {
             return $this->repo->byName($aggregateName, EventAggregateRepositoryInterface::RETURN_AS_OBJECT);
         }
 

src/Application/Event/EventQuery.php

@@ -52,7 +52,7 @@ public function fromAggregate($aggregateName)
     {
         $stream = $this->repo->byName($aggregateName, $this->returnType);
 
-        if($this->returnType === EventAggregateRepositoryInterface::RETURN_AS_ARRAY){
+        if ($this->returnType === EventAggregateRepositoryInterface::RETURN_AS_ARRAY) {
             return (isset($stream['events'])) ? $stream['events'] : [];
         }
 
@@ -67,7 +67,7 @@ public function fromAggregates(array $aggregates)
     {
         $streams = [];
 
-        foreach ($aggregates as $aggregate){
+        foreach ($aggregates as $aggregate) {
             $streams = array_merge($streams, $this->fromAggregate($aggregate));
         }
 
@@ -84,7 +84,7 @@ public function query(array $stream, array $filters = [])
     {
         $qb = QueryBuilder::create((array)$stream);
 
-        foreach ($filters as $key => $value){
+        foreach ($filters as $key => $value) {
             $qb->addCriterion($key, $value);
         }
 
@@ -102,7 +102,7 @@ public function streamCount($aggregateName)
     {
         $stream = $this->repo->byName($aggregateName, $this->returnType);
 
-        if($this->returnType === EventAggregateRepositoryInterface::RETURN_AS_ARRAY){
+        if ($this->returnType === EventAggregateRepositoryInterface::RETURN_AS_ARRAY) {
             return count($stream['events']);
         }
 

src/Application/Event/EventRepresentation.php

@@ -71,4 +71,4 @@ private function paginateAggregate($array, $page, $maxPerPage)
     {
         return array_slice($array, ($page - 1) * $maxPerPage, $maxPerPage);
     }
-}
+}

src/Application/Projector/ProjectionManager.php

@@ -25,7 +25,7 @@ class ProjectionManager
      */
     public function register(Projector $projector)
     {
-        foreach ($projector->subcribedEvents() as $subcribedEvent){
+        foreach ($projector->subcribedEvents() as $subcribedEvent) {
             $this->projectors[$subcribedEvent] = $projector;
         }
     }
@@ -36,8 +36,8 @@ public function register(Projector $projector)
      */
     public function projectFromAnEventAggregate(EventAggregate $aggregate)
     {
-        foreach ($aggregate->events() as $event){
-            if (!isset($this->projectors[get_class($event)])){
+        foreach ($aggregate->events() as $event) {
+            if (!isset($this->projectors[get_class($event)])) {
                 throw new ProjectorDoesNotExistsException('No Projector found for event ' . get_class($event) . '.');
             }
 

src/Infrastructure/DataTransformers/Representations/EventObjectRepresentation.php

@@ -21,11 +21,11 @@ class EventObjectRepresentation
 
     public function __construct($event)
     {
-        if(is_array($event)){
+        if (is_array($event)) {
             $this->fromArray($event);
         }
 
-        if($event instanceof EventInterface){
+        if ($event instanceof EventInterface) {
             $this->fromEventInterface($event);
         }
     }

src/Infrastructure/Persistence/InMemoryEventAggregateRepository.php

@@ -49,8 +49,8 @@ public function byName($name, $returnType = self::RETURN_AS_ARRAY)
     {
         $aggregateName = HashGeneratorService::computeStringHash($name);
 
-        foreach ($this->aggregates as $aggregate){
-            if($aggregate->name() === $aggregateName){
+        foreach ($this->aggregates as $aggregate) {
+            if ($aggregate->name() === $aggregateName) {
                 return $this->buildAggregate($aggregate, $returnType);
             }
         }
@@ -65,7 +65,7 @@ public function byName($name, $returnType = self::RETURN_AS_ARRAY)
      */
     private function buildAggregate(EventAggregate $aggregate, $returnType)
     {
-        if($returnType === self::RETURN_AS_ARRAY){
+        if ($returnType === self::RETURN_AS_ARRAY) {
             return $this->buildAggregateAsArray($aggregate);
         }
 
@@ -90,8 +90,8 @@ public function exists($name)
     {
         $aggregateName = HashGeneratorService::computeStringHash($name);
 
-        foreach ($this->aggregates as $aggregate){
-            if($aggregate->name() === $aggregateName){
+        foreach ($this->aggregates as $aggregate) {
+            if ($aggregate->name() === $aggregateName) {
                 return true;
             }
         }
@@ -117,7 +117,7 @@ private function buildAggregateAsArray(EventAggregate $aggregate)
         $returnArray['id'] = (string) $aggregate->id();
         $returnArray['name'] = $aggregate->name();
 
-        foreach ($aggregate->events() as $event){
+        foreach ($aggregate->events() as $event) {
             $returnArray['events'][] = [
                 'id' => (string) $event->id(),
                 'name' => $event->name(),

src/Infrastructure/Persistence/MongoEventAggregateRepository.php

@@ -55,7 +55,7 @@ public function __construct(Database $mongo)
      */
     public function byId(EventAggregateId $eventAggregateId, $returnType = self::RETURN_AS_ARRAY)
     {
-        if($document = $this->aggregates->findOne(['id' => (string) $eventAggregateId])){
+        if ($document = $this->aggregates->findOne(['id' => (string) $eventAggregateId])) {
             return $this->buildAggregate($document, $returnType);
         }
 
@@ -70,7 +70,7 @@ public function byId(EventAggregateId $eventAggregateId, $returnType = self::RET
      */
     public function byName($name, $returnType = self::RETURN_AS_ARRAY)
     {
-        if($document = $this->aggregates->findOne(['name' => HashGeneratorService::computeStringHash($name)])){
+        if ($document = $this->aggregates->findOne(['name' => HashGeneratorService::computeStringHash($name)])) {
             return $this->buildAggregate($document, $returnType);
         }
 
@@ -83,7 +83,7 @@ public function byName($name, $returnType = self::RETURN_AS_ARRAY)
      */
     private function buildAggregate($document, $returnType)
     {
-        if($returnType === self::RETURN_AS_ARRAY){
+        if ($returnType === self::RETURN_AS_ARRAY) {
             return $this->buildAggregateAsArray($document);
         }
 
@@ -113,16 +113,16 @@ public function exists($name)
      */
     public function save(EventAggregate $aggregate)
     {
-        if(false === $this->exists($aggregate->name())){
+        if (false === $this->exists($aggregate->name())) {
             $this->aggregates->insertOne([
                 'id' => (string) $aggregate->id(),
                 'name' => $aggregate->name()
             ]);
         }
 
         /** @var Event $event */
-        foreach ($aggregate->events() as $event){
-            if(false === $this->existsEvent($event)){
+        foreach ($aggregate->events() as $event) {
+            if (false === $this->existsEvent($event)) {
                 $this->saveEvent($event, $aggregate);
             }
         }
@@ -173,7 +173,7 @@ private function buildAggregateAsArray(BSONDocument $document)
         $returnArray['name'] = $document->name;
 
         $events = $this->events->find(['aggregate.id' => (string) $document->id])->toArray();
-        foreach ($events as $event){
+        foreach ($events as $event) {
             $returnArray['events'][] = [
                 'id' => (string) $event->id,
                 'name' => $event->name,
@@ -198,7 +198,7 @@ private function buildAggregateAsObject(BSONDocument $document)
         );
 
         $events = $this->events->find(['aggregate.id' => (string) $aggregate->id()])->toArray();
-        foreach ($events as $event){
+        foreach ($events as $event) {
             $aggregate->addEvent(
                 new Event(
                     $event->name,

src/Infrastructure/Persistence/PdoEventAggregateRepository.php

@@ -18,7 +18,7 @@
 use SimpleEventStoreManager\Domain\Model\EventId;
 use SimpleEventStoreManager\Infrastructure\Services\HashGeneratorService;
 
-class PdoEventAggregateRepository  implements EventAggregateRepositoryInterface
+class PdoEventAggregateRepository implements EventAggregateRepositoryInterface
 {
     /**
      * @var \PDO
@@ -102,7 +102,7 @@ public function byName($name, $returnType = self::RETURN_AS_ARRAY)
      */
     private function buildAggregate(array $rows, $returnType)
     {
-        if($returnType === self::RETURN_AS_ARRAY){
+        if ($returnType === self::RETURN_AS_ARRAY) {
             return $this->buildAggregateAsArray($rows);
         }
 
@@ -154,7 +154,7 @@ public function save(EventAggregate $aggregate)
         $stmt->execute();
 
         /** @var Event $event */
-        foreach ($aggregate->events() as $event){
+        foreach ($aggregate->events() as $event) {
             $this->saveEvent($event, $aggregate);
         }
     }
@@ -194,7 +194,7 @@ private function buildAggregateAsArray(array $rows)
         $returnArray['id'] = (string) $rows[0]['aggregate_id'];
         $returnArray['name'] = $rows[0]['aggregate_name'];
 
-        foreach ($rows as $row){
+        foreach ($rows as $row) {
             $returnArray['events'][] = [
                 'id' => (string) $row['event_id'],
                 'name' => $row['event_name'],
@@ -218,7 +218,7 @@ private function buildAggregateAsObject(array $rows)
             new EventAggregateId($rows[0]['aggregate_id'])
         );
 
-        foreach ($rows as $row){
+        foreach ($rows as $row) {
             $aggregate->addEvent(
                 new Event(
                     $row['event_name'],

src/Infrastructure/Persistence/RedisEventAggregateRepository.php

@@ -75,7 +75,7 @@ public function byName($name, $returnType = self::RETURN_AS_ARRAY)
      */
     private function buildAggregate($eventAggregateId, array $aggregateEvents, $returnType)
     {
-        if($returnType === self::RETURN_AS_ARRAY){
+        if ($returnType === self::RETURN_AS_ARRAY) {
             return $this->buildAggregateAsArray($eventAggregateId, $aggregateEvents);
         }
 
@@ -110,7 +110,7 @@ public function save(EventAggregate $aggregate)
         $this->client->set(HashGeneratorService::computeAggregateNameHash($aggregate->name()), $aggregate->id());
 
         /** @var Event $event */
-        foreach ($aggregate->events() as $event){
+        foreach ($aggregate->events() as $event) {
             $this->saveEvent($event, $aggregate);
         }
     }
@@ -144,7 +144,7 @@ private function buildAggregateAsArray($eventAggregateId, array $aggregateEvents
         $returnArray['id'] = $eventAggregateId;
         $returnArray['name'] = $this->client->get(HashGeneratorService::computeAggregateHash($eventAggregateId));
 
-        foreach ($aggregateEvents as $event){
+        foreach ($aggregateEvents as $event) {
             $event = unserialize($event);
             $returnArray['events'][] = [
                 'id' => (string) $event['id'],
@@ -170,7 +170,7 @@ private function buildAggregateAsObject($eventAggregateId, array $aggregateEvent
             new EventAggregateId($eventAggregateId)
         );
 
-        foreach ($aggregateEvents as $event){
+        foreach ($aggregateEvents as $event) {
             $event = unserialize($event);
             $aggregate->addEvent(
                 new Event(

src/Infrastructure/Services/ElasticService.php

@@ -41,7 +41,7 @@ public function addAggregateToIndex(EventAggregate $aggregate)
     {
         $this->manageAggregateIndex($aggregate->name());
 
-        foreach ($aggregate->events() as $event){
+        foreach ($aggregate->events() as $event) {
             $params = [
                 'index' => self::EVENTS_INDEX,
                 'type' => $aggregate->name(),
@@ -51,7 +51,7 @@ public function addAggregateToIndex(EventAggregate $aggregate)
 
             try {
                 $this->elastic->index($params);
-            } catch (\Exception $e){
+            } catch (\Exception $e) {
                 throw new AggregateNotPersistedInElasticIndexException($e->getMessage());
             }
         }
@@ -62,7 +62,7 @@ public function addAggregateToIndex(EventAggregate $aggregate)
      */
     private function manageAggregateIndex($aggregate)
     {
-        if(false === $this->elastic->indices()->exists(['index' => self::EVENTS_INDEX])){
+        if (false === $this->elastic->indices()->exists(['index' => self::EVENTS_INDEX])) {
             $params = [
                 'index' => self::EVENTS_INDEX,
                 'body' => [

src/Infrastructure/Services/HashGeneratorService.php

@@ -20,7 +20,7 @@ class HashGeneratorService
      */
     const HASH_SEPARATOR = '-';
     const LOWERCASE = true;
-    const REGEXP_PATTERN = '/([^A-Za-z0-9]|-)+/';
+    const REGEXP_PATTERN = '/([^A-Za-z0-9*]|-)+/';
     const RULESET = 'default';
 
     /**

tests/Application/EventQueryTest.php

@@ -100,7 +100,7 @@ public function it_should_store_and_query_events_and_send_them_to_elastic()
 
         $returnTypes = [EventAggregateRepositoryInterface::RETURN_AS_ARRAY, EventAggregateRepositoryInterface::RETURN_AS_OBJECT];
 
-        foreach ($returnTypes as $returnType){
+        foreach ($returnTypes as $returnType) {
             $eventManager = EventManager::build()
                 ->setDriver('mongo')
                 ->setConnection($this->mongo_parameters)