add generated TableFactory that can create Tables with custom Connection or TableManager

src/Scaffolding/Definitions.php

@@ -16,6 +16,7 @@ final class Definitions implements \IteratorAggregate
 		private ClassDefinition $modificationsClass,
 		private ?ClassDefinition $primaryKeyClass,
 		private ClassDefinition $tableClass,
+		private ?ClassDefinition $factoryClass,
 	) {}
 
 	public static function from(
@@ -23,6 +24,7 @@ final class Definitions implements \IteratorAggregate
 		ClassDefinition $modificationsClass,
 		ClassDefinition $primaryKeyClass,
 		ClassDefinition $tableClass,
+		ClassDefinition $factoryClass,
 	): self
 	{
 		return new self(
@@ -30,6 +32,7 @@ final class Definitions implements \IteratorAggregate
 			$modificationsClass,
 			$primaryKeyClass,
 			$tableClass,
+			$factoryClass,
 		);
 	}
 
@@ -63,6 +66,18 @@ final class Definitions implements \IteratorAggregate
 		return $this;
 	}
 
+	public function factoryClassWith(Capability $capability, Capability ...$capabilities): self
+	{
+		$this->factoryClass = $this->factoryClass?->with($capability, ...$capabilities);
+		return $this;
+	}
+
+	public function withoutFactory(): self
+	{
+		$this->factoryClass = null;
+		return $this;
+	}
+
 
 	public function getIterator(): \Traversable
 	{
@@ -72,6 +87,9 @@ final class Definitions implements \IteratorAggregate
 		if ($this->primaryKeyClass !== null) {
 			yield $this->primaryKeyClass;
 		}
+		if ($this->factoryClass !== null) {
+			yield $this->factoryClass;
+		}
 	}
 
 }

src/Scaffolding/TableFactoryImplementation.php

+<?php
+
+declare(strict_types=1);
+
+namespace Grifart\Tables\Scaffolding;
+
+use Dibi\IConnection;
+use Grifart\ClassScaffolder\Capabilities\Capability;
+use Grifart\ClassScaffolder\ClassInNamespace;
+use Grifart\ClassScaffolder\Definition\ClassDefinition;
+use Grifart\Tables\SingleConnectionTableManager;
+use Grifart\Tables\TableFactory;
+use Grifart\Tables\TableManager;
+use Grifart\Tables\TypeResolver;
+use Nette\PhpGenerator\Literal;
+use Nette\PhpGenerator\Parameter;
+use Nette\PhpGenerator\PromotedParameter;
+
+final readonly class TableFactoryImplementation implements Capability
+{
+	public function __construct(
+		private string $tableClass,
+	) {}
+
+	public function applyTo(
+		ClassDefinition $definition,
+		ClassInNamespace $draft,
+		?ClassInNamespace $current,
+	): void
+	{
+		$namespace = $draft->getNamespace();
+		$classType = $draft->getClassType();
+
+		$classType->addImplement(TableFactory::class);
+		$classType->setReadOnly();
+
+		$namespace->addUse(TypeResolver::class);
+		$namespace->addUse(TableManager::class);
+
+		$classType->addMethod('__construct')
+			->setPublic()
+			->setParameters([
+				(new PromotedParameter('tableManager'))
+					->setPrivate()
+					->setType(TableManager::class),
+				(new PromotedParameter('typeResolver'))
+					->setPrivate()
+					->setType(TypeResolver::class),
+			]);
+
+		$namespace->addUse($this->tableClass);
+
+		$classType->addMethod('create')
+			->setPublic()
+			->setReturnType($this->tableClass)
+			->setBody('return new ?($this->tableManager, $this->typeResolver);', [new Literal($namespace->simplifyName($this->tableClass))]);
+
+		$classType->addMethod('withTableManager')
+			->setPublic()
+			->setReturnType($this->tableClass)
+			->setParameters([(new Parameter('tableManager'))->setType(TableManager::class)])
+			->setBody('return new ?($tableManager, $this->typeResolver);', [new Literal($namespace->simplifyName($this->tableClass))]);
+
+		$namespace->addUse(IConnection::class);
+		$namespace->addUse(SingleConnectionTableManager::class);
+		$classType->addMethod('withConnection')
+			->setPublic()
+			->setReturnType($this->tableClass)
+			->setParameters([(new Parameter('connection'))->setType(IConnection::class)])
+			->addBody('$tableManager = new ?($connection);', [new Literal($namespace->simplifyName(SingleConnectionTableManager::class))])
+			->addBody('return new ?($tableManager, $this->typeResolver);', [new Literal($namespace->simplifyName($this->tableClass))]);
+	}
+}

src/Scaffolding/TablesDefinitions.php

@@ -17,7 +17,6 @@ use function Grifart\ClassScaffolder\Capabilities\implementedInterface;
 use function Grifart\ClassScaffolder\Capabilities\namedConstructor;
 use function Grifart\ClassScaffolder\Capabilities\privatizedConstructor;
 use function Grifart\ClassScaffolder\Definition\Types\nullable;
-use function Phun\map;
 use function Phun\mapWithKeys;
 
 final class TablesDefinitions
@@ -101,6 +100,9 @@ final class TablesDefinitions
 				$columnPhpTypes,
 			));
 
-		return Definitions::from($rowClass, $modificationsClass, $primaryKeyClass, $tableClass);
+		$factoryClass = (new ClassDefinition($tableClassName . 'Factory'))
+			->with(new TableFactoryImplementation($tableClassName));
+
+		return Definitions::from($rowClass, $modificationsClass, $primaryKeyClass, $tableClass, $factoryClass);
 	}
 }

src/TableFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Grifart\Tables;
+
+use Dibi\IConnection;
+
+interface TableFactory
+{
+	public function create(): Table;
+	public function withTableManager(TableManager $tableManager): Table;
+	public function withConnection(IConnection $connection): Table;
+}

tests/Fixtures/ConfigTableFactory.php

+<?php
+
+/**
+ * Do not edit. This is generated file. Modify definition file instead.
+ */
+
+declare(strict_types=1);
+
+namespace Grifart\Tables\Tests\Fixtures;
+
+use Dibi\IConnection;
+use Grifart\Tables\SingleConnectionTableManager;
+use Grifart\Tables\TableManager;
+use Grifart\Tables\TypeResolver;
+
+final readonly class ConfigTableFactory implements \Grifart\Tables\TableFactory
+{
+	public function __construct(
+		private TableManager $tableManager,
+		private TypeResolver $typeResolver,
+	) {
+	}
+
+
+	public function create(): ConfigTable
+	{
+		return new ConfigTable($this->tableManager, $this->typeResolver);
+	}
+
+
+	public function withTableManager(TableManager $tableManager): ConfigTable
+	{
+		return new ConfigTable($tableManager, $this->typeResolver);
+	}
+
+
+	public function withConnection(IConnection $connection): ConfigTable
+	{
+		$tableManager = new SingleConnectionTableManager($connection);
+		return new ConfigTable($tableManager, $this->typeResolver);
+	}
+}

tests/Fixtures/GeneratedTableFactory.php

+<?php
+
+/**
+ * Do not edit. This is generated file. Modify definition file instead.
+ */
+
+declare(strict_types=1);
+
+namespace Grifart\Tables\Tests\Fixtures;
+
+use Dibi\IConnection;
+use Grifart\Tables\SingleConnectionTableManager;
+use Grifart\Tables\TableManager;
+use Grifart\Tables\TypeResolver;
+
+final readonly class GeneratedTableFactory implements \Grifart\Tables\TableFactory
+{
+	public function __construct(
+		private TableManager $tableManager,
+		private TypeResolver $typeResolver,
+	) {
+	}
+
+
+	public function create(): GeneratedTable
+	{
+		return new GeneratedTable($this->tableManager, $this->typeResolver);
+	}
+
+
+	public function withTableManager(TableManager $tableManager): GeneratedTable
+	{
+		return new GeneratedTable($tableManager, $this->typeResolver);
+	}
+
+
+	public function withConnection(IConnection $connection): GeneratedTable
+	{
+		$tableManager = new SingleConnectionTableManager($connection);
+		return new GeneratedTable($tableManager, $this->typeResolver);
+	}
+}

tests/Fixtures/PackagesTableFactory.php

+<?php
+
+/**
+ * Do not edit. This is generated file. Modify definition file instead.
+ */
+
+declare(strict_types=1);
+
+namespace Grifart\Tables\Tests\Fixtures;
+
+use Dibi\IConnection;
+use Grifart\Tables\SingleConnectionTableManager;
+use Grifart\Tables\TableManager;
+use Grifart\Tables\TypeResolver;
+
+final readonly class PackagesTableFactory implements \Grifart\Tables\TableFactory
+{
+	public function __construct(
+		private TableManager $tableManager,
+		private TypeResolver $typeResolver,
+	) {
+	}
+
+
+	public function create(): PackagesTable
+	{
+		return new PackagesTable($this->tableManager, $this->typeResolver);
+	}
+
+
+	public function withTableManager(TableManager $tableManager): PackagesTable
+	{
+		return new PackagesTable($tableManager, $this->typeResolver);
+	}
+
+
+	public function withConnection(IConnection $connection): PackagesTable
+	{
+		$tableManager = new SingleConnectionTableManager($connection);
+		return new PackagesTable($tableManager, $this->typeResolver);
+	}
+}

tests/Fixtures/TestsTableFactory.php

+<?php
+
+/**
+ * Do not edit. This is generated file. Modify definition file instead.
+ */
+
+declare(strict_types=1);
+
+namespace Grifart\Tables\Tests\Fixtures;
+
+use Dibi\IConnection;
+use Grifart\Tables\SingleConnectionTableManager;
+use Grifart\Tables\TableManager;
+use Grifart\Tables\TypeResolver;
+
+final readonly class TestsTableFactory implements \Grifart\Tables\TableFactory
+{
+	public function __construct(
+		private TableManager $tableManager,
+		private TypeResolver $typeResolver,
+	) {
+	}
+
+
+	public function create(): TestsTable
+	{
+		return new TestsTable($this->tableManager, $this->typeResolver);
+	}
+
+
+	public function withTableManager(TableManager $tableManager): TestsTable
+	{
+		return new TestsTable($tableManager, $this->typeResolver);
+	}
+
+
+	public function withConnection(IConnection $connection): TestsTable
+	{
+		$tableManager = new SingleConnectionTableManager($connection);
+		return new TestsTable($tableManager, $this->typeResolver);
+	}
+}

tests/Scaffolding/ScaffoldingTest.phpt

@@ -34,5 +34,5 @@ $results = $fileProcessor->processFile(
 	},
 );
 
-Assert::count(16, $results->getDefinitions());
+Assert::count(20, $results->getDefinitions());
 Assert::true($results->isSuccessful());