chore: fix merge conflicts

refs: #204

Author: Ni Nelli

src/Commands/MakeEntityCommand.php

@@ -124,6 +124,7 @@ public function handle(): void
         $this->checkConfigs();
         $this->listenEvents();
         $this->parseRelations();
+        $this->entityName = $this->convertToPascalCase($this->entityName);
 
         try {
             $this->generate();
@@ -238,19 +239,20 @@ protected function getCrudOptions(): array
     protected function parseRelations(): void
     {
         $this->relations = new RelationsDTO(
-            hasOne: $this->trimRelations($this->option('has-one')),
-            hasMany: $this->trimRelations($this->option('has-many')),
-            belongsTo: $this->trimRelations($this->option('belongs-to')),
-            belongsToMany: $this->trimRelations($this->option('belongs-to-many')),
+            hasOne: $this->prepareRelations($this->option('has-one')),
+            hasMany: $this->prepareRelations($this->option('has-many')),
+            belongsTo: $this->prepareRelations($this->option('belongs-to')),
+            belongsToMany: $this->prepareRelations($this->option('belongs-to-many')),
         );
     }
 
-    protected function trimRelations(array $relations): array
+    protected function prepareRelations(array $relations): array
     {
-        return array_map(
-            callback: fn ($relation) => Str::trim($relation, '/'),
-            array: $relations,
-        );
+        return array_map(function ($relation) {
+            $relation = Str::trim($relation, '/');
+
+            return $this->convertToPascalCase($relation);
+        }, $relations);
     }
 
     protected function getFields(): array
@@ -305,4 +307,15 @@ protected function listenEvents(): void
             listener: fn (WarningEvent $event) => $this->warn($event->message),
         );
     }
+
+    protected function convertToPascalCase(string $entityName): string
+    {
+        $pascalEntityName = Str::studly($entityName);
+
+        if ($entityName !== $pascalEntityName) {
+            $this->info("{$entityName} was converted to {$pascalEntityName}");
+        }
+
+        return $pascalEntityName;
+    }
 }

src/Generators/AbstractTestsGenerator.php

@@ -175,7 +175,7 @@ protected function getMockModel($model): array
             return [];
         }
 
-        $factoryNamespace = "{$this->getNamespace('factories')}\\{$model}Factory";
+        $factoryNamespace = "{$this->generateNamespace($this->paths['factories'])}\\{$model}Factory";
         $factory = $factoryNamespace::new();
 
         return $factory

src/Generators/ControllerGenerator.php

@@ -5,17 +5,12 @@
 use Illuminate\Contracts\Filesystem\FileNotFoundException;
 use RonasIT\Support\Exceptions\ClassNotExistsException;
 use RonasIT\Support\Events\SuccessCreateMessage;
-use RonasIT\Support\Exceptions\ResourceAlreadyExistsException;
 
 class ControllerGenerator extends EntityGenerator
 {
     public function generate(): void
     {
-        if ($this->classExists('controllers', "{$this->model}Controller")) {
-            $path = $this->getClassPath('controllers', "{$this->model}Controller");
-
-            throw new ResourceAlreadyExistsException($path);
-        }
+        $this->checkResourceExists('controllers', "{$this->model}Controller");
 
         if (!$this->classExists('services', "{$this->model}Service")) {
             $this->throwFailureException(
@@ -45,10 +40,10 @@ protected function getControllerContent($model): string
         return $this->getStub('controller', [
             'entity' => $model,
             'requestsFolder' => $model,
-            'namespace' => $this->getNamespace('controllers'),
-            'requestsNamespace' => $this->getNamespace('requests'),
-            'resourcesNamespace' => $this->getNamespace('resources'),
-            'servicesNamespace' => $this->getNamespace('services'),
+            'namespace' => $this->generateNamespace($this->paths['controllers']),
+            'requestsNamespace' => $this->generateNamespace($this->paths['requests']),
+            'resourcesNamespace' => $this->generateNamespace($this->paths['resources']),
+            'servicesNamespace' => $this->generateNamespace($this->paths['services']),
         ]);
     }
 
@@ -98,7 +93,7 @@ protected function addUseController(string $routesPath): void
         $routesFileContent = file_get_contents($routesPath);
 
         $stub = $this->getStub('use_routes', [
-            'namespace' => $this->getNamespace('controllers'),
+            'namespace' => $this->generateNamespace($this->paths['controllers']),
             'entity' => $this->model
         ]);
 

src/Generators/EntityGenerator.php

@@ -2,18 +2,19 @@
 
 namespace RonasIT\Support\Generators;
 
-use Illuminate\Database\Eloquent\Relations\BelongsTo;
-use Illuminate\Filesystem\Filesystem;
+use Throwable;
+use ReflectionClass;
+use ReflectionMethod;
 use Illuminate\Support\Arr;
-use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Str;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Filesystem\Filesystem;
 use RonasIT\Support\DTO\RelationsDTO;
 use RonasIT\Support\Events\WarningEvent;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use RonasIT\Support\Exceptions\ClassNotExistsException;
 use RonasIT\Support\Exceptions\IncorrectClassPathException;
-use Throwable;
-use ReflectionMethod;
-use ReflectionClass;
+use RonasIT\Support\Exceptions\ResourceAlreadyExistsException;
 
 /**
  * @property Filesystem $fs
@@ -32,6 +33,7 @@ abstract class EntityGenerator
         'database_seeder' => 'database/seeders',
         'tests' => 'tests',
         'routes' => 'routes',
+        'translations' => 'lang/en',
     ];
 
     protected $paths = [];
@@ -51,7 +53,7 @@ public function setCrudOptions(array $crudOptions): self
 
     public function setModel(string $model): self
     {
-        $this->model = Str::studly($model);
+        $this->model = $model;
 
         return $this;
     }
@@ -88,11 +90,13 @@ public function setRelations(RelationsDTO $relations): self
     public function __construct()
     {
         $this->paths = config('entity-generator.paths');
+
+        $this->checkConfigHasCorrectPaths();
     }
 
-    protected function getNamespace(string $configPath, ?string $subFolder = null): string
+    protected function generateNamespace(string $path, ?string $additionalSubFolder = null): string
     {
-        $pathParts = $this->getNamespacePathParts($configPath, $subFolder);
+        $pathParts = $this->getNamespacePathParts($path, $additionalSubFolder);
 
         $namespace = array_map(fn (string $part) => ucfirst($part), $pathParts);
 
@@ -101,7 +105,7 @@ protected function getNamespace(string $configPath, ?string $subFolder = null):
 
     protected function createNamespace(string $configPath, ?string $subFolder = null): void
     {
-        $path = $this->getPath($configPath, $subFolder);
+        $path = $this->getPath($this->paths[$configPath], $subFolder);
 
         $fullPath = base_path($path);
 
@@ -110,26 +114,20 @@ protected function createNamespace(string $configPath, ?string $subFolder = null
         }
     }
 
-    protected function getNamespacePathParts(string $configPath, ?string $subFolder = null): array
+    protected function getNamespacePathParts(string $path, ?string $additionalSubFolder = null): array
     {
-        $pathParts = explode('/', $this->getPath($configPath, $subFolder));
+        $pathParts = explode('/', $this->getPath($path, $additionalSubFolder));
 
         if (Str::endsWith(Arr::last($pathParts), '.php')) {
             array_pop($pathParts);
         }
 
-        foreach ($pathParts as $part) {
-            if (!$this->isFolderHasCorrectCase($part, $configPath)) {
-                throw new IncorrectClassPathException("Incorrect path to {$configPath}, {$part} folder must start with a capital letter, please specify the path according to the PSR.");
-            }
-        }
-
         return $pathParts;
     }
 
-    protected function getPath(string $configPath, ?string $subFolder = null): string
+    protected function getPath(string $path, ?string $subFolder = null): string
     {
-        return when($subFolder, fn () => Str::finish($this->paths[$configPath], '/') . $subFolder, $this->paths[$configPath]);
+        return when($subFolder, fn () => Str::finish($path, '/') . $subFolder, $path);
     }
 
     protected function isFolderHasCorrectCase(string $folder, string $configPath): bool
@@ -145,16 +143,18 @@ abstract public function generate(): void;
 
     protected function classExists(string $path, string $name, ?string $subFolder = null): bool
     {
-        $classPath = $this->getClassPath($path, $name, $subFolder);
+        $relativePath = $this->getClassPath($path, $name, $subFolder);
+
+        $absolutePath = base_path($relativePath);
 
-        return file_exists($classPath);
+        return file_exists($absolutePath);
     }
 
     protected function getClassPath(string $path, string $name, ?string $subFolder = null): string
     {
-        $path = $this->getPath($path, $subFolder);
+        $path = $this->getPath($this->paths[$path], $subFolder);
 
-        return base_path("{$path}/{$name}.php");
+        return "{$path}/{$name}.php";
     }
 
     protected function saveClass($path, $name, $content, ?string $entityFolder = null): string
@@ -267,7 +267,7 @@ protected function getModelClass(string $model): string
     {
         $subfolder = when($model === $this->model, $this->modelSubFolder);
 
-        $modelNamespace = $this->getNamespace('models', $subfolder);
+        $modelNamespace = $this->generateNamespace($this->paths['models'], $subfolder);
 
         return "{$modelNamespace}\\{$model}";
     }
@@ -306,4 +306,26 @@ protected function pathToNamespace(string $name): string
     {
         return ucwords(Str::replace('/', '\\', $name), '\\');
     }
+
+    protected function checkConfigHasCorrectPaths(): void
+    {
+        foreach ($this->paths as $configPath => $path) {
+            $pathParts = $this->getNamespacePathParts($path);
+
+            foreach ($pathParts as $part) {
+                if (!$this->isFolderHasCorrectCase($part, $configPath)) {
+                    throw new IncorrectClassPathException("Incorrect path to {$configPath}, {$part} folder must start with a capital letter, please specify the path according to the PSR.");
+                }
+            }
+        }
+    }
+
+    protected function checkResourceExists(string $path, string $resourceName, ?string $subFolder = null): void
+    {
+        if ($this->classExists($path, $resourceName, $subFolder)) {
+            $filePath = $this->getClassPath($path, $resourceName, $subFolder);
+
+            throw new ResourceAlreadyExistsException($filePath);
+        }
+    }
 }

src/Generators/FactoryGenerator.php

@@ -9,7 +9,6 @@
 use RonasIT\Support\Exceptions\FakerMethodNotFoundException;
 use RonasIT\Support\Exceptions\ClassNotExistsException;
 use RonasIT\Support\Events\SuccessCreateMessage;
-use RonasIT\Support\Exceptions\ResourceAlreadyExistsException;
 
 class FactoryGenerator extends EntityGenerator
 {
@@ -36,11 +35,7 @@ public function generate(): void
             );
         }
 
-        if ($this->classExists('factories', "{$this->model}Factory")) {
-            $path = $this->getClassPath('factories', "{$this->model}Factory");
-
-            throw new ResourceAlreadyExistsException($path);
-        }
+        $this->checkResourceExists('factories', "{$this->model}Factory");
 
         if (!$this->isStubExists('factory')) {
             return;
@@ -49,10 +44,10 @@ public function generate(): void
         $this->createNamespace('factories');
 
         $factoryContent = $this->getStub('factory', [
-            'namespace' => $this->getNamespace('factories'),
+            'namespace' => $this->generateNamespace($this->paths['factories']),
             'entity' => $this->model,
             'fields' => $this->prepareFields(),
-            'modelNamespace' => $this->getNamespace('models', $this->modelSubFolder),
+            'modelNamespace' => $this->generateNamespace($this->paths['models'], $this->modelSubFolder),
         ]);
 
         $this->saveClass('factories', "{$this->model}Factory", $factoryContent);