Form factories vs my approach?

Hi,

I have recently come with this approach in my projects and I want just to start discussion whether it is good or not, and why (and if possible compare advantages and disadvantages to typical Form + Form Factory approach).

So here is my idea:

1. I create an CompilerExtension for my project, with its own config.neon file, containing services part and forms part. Example:

services:
	- App\Model\Repositories\ArticleRepository
	- App\Model\Repositories\UserRepository

forms:
	- App\Forms\PublicModule\User\LoginForm
	- App\Forms\PublicModule\User\RegisterForm

2. In my extension i just parse it like this:

$config = $this->loadFromFile(__DIR__ . '/config.neon');
$this->compiler->parseServices($builder, $config, $this->name);

if (isset($config['forms']) && is_array($config['forms'])) {
	foreach ($config['forms'] as $form) {
		$builder->addDefinition($this->prefix($this->fixFormServiceName($form)))
			->setClass($form);
	}
}

// fixFormServiceName is a function, that just strips out of FQN name characters that cannot be used as service name

This might look like it does nothing more than standart service, but I just like to have it separated, also I can easily e.g. set translator for every form. Of course I can just leave forms in services and it will work normally.

3. Every form extends some BaseForm, which looks like this:

abstract class BaseForm
{

	public function create()
	{
		$form = new Form; // this is Nette\Application\UI\Form or any custom child of it
		$this->initialize($form);

		$form->onValidate[] = [$this, 'validateData'];
		$form->onSuccess[] = [$this, 'formSuccess'];

		return $form;
	}


	abstract public function initialize(Form $form);
	abstract public function validateData(Form $form);
	abstract public function formSuccess(Form $form);

}

4. And now for some concrete form:

class RegisterForm extends BaseForm
{

	/** @var UserRepository */
	private $userRepository;

	/** @var User */
	private $user;


	public function __construct(UserRepository $userRepository, User $user)
	{
		$this->userRepository = $userRepository;
		$this->user = $user;
	}

	public function initialize(Form $form)
	{
		$form->addText('nick', 'Nick')
			->setRequired('Please enter nick.')
			->addRule($form::PATTERN, 'Nick can contain only alphanumerical characters.', '[a-zA-Z0-9]+');

		$form->addPassword('password', 'Password')
			->setRequired('Please enter password.');

		$form->addPassword('password_check', 'Password again')
			->addRule($form::EQUAL, 'Passwords must match, please double-check them.', $form['password']);

		$form->addSubmit('register', 'Register');

	}


	public function validateData(Form $form)
	{
		$nickControl = $form['nick'];
		if ($this->userRepository->getByNick($nickControl->getValue())) {
			$nickControl->addError('User with this nick already exists.');
		}
	}


	public function formSuccess(Form $form)
	{
		$values = $form->getValues();
		$user = $this->userRepository->register($values->nick, $values->password);
		$this->user->login(new Identity($user->id, [$user->role], [
			'nick' => $user->nick,
		]));
	}
}

5. Finally, we use form in presenter:

/** @var RegisterForm @inject */
public $registerForm;

protected function createComponentRegisterForm()
{
	$form = $this->registerForm->create();
	$form->onSuccess[] = $this->registerFormSuccess;
	return $form;
}

public function registerFormSuccess(Form $form)
{
	$this->flashSuccess('Registration successful, you have been logged in.');
	$this->redirect('somehwere');
}

---

Okay, thats it. I know the RegisterForm used in example is not really a form, but a factory, and should be named RegisterFormFactory, but it can be easily changed and I have left it there from previous variations of my approach.

Advantages I see against normal Form + Form Factory approach:

• you dont have to create two files, two classes, it is less writing
• you can use “natively” form classes (in constructor, you require things you need and you just use them)
• and this approach just fits me more than the Form + Form Factory

---

Now it is time to ask you: is this approach complete useless? Or its good enough to use, if it fits me? Or should I just keep the Form + Form Factory approach and forgot about inventing a wheel? Any comment is appreciated, as long as you provide some arguments why to use or not to use :)

Thanks, greeny