DoS\ResourceBundle\Form\Factory

Complexity

Total Complexity

28

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes	3
Bugs	2	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	setPrefixAndReplacement()	0	5	3
C	createNamedBuilder()	0	29	7
A	setSecurityTokenStorage()	0	4	1
A	resolveType()	0	19	3
D	createBuilderForProperty()	0	35	9
A	getUser()	0	6	2
A	getUserAwareChoiceBuilder()	0	9	2

<?php

namespace DoS\ResourceBundle\Form;

use Doctrine\ORM\EntityRepository;
use Symfony\Component\Form\Exception\UnexpectedTypeException;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormFactory;
use Symfony\Component\Form\FormRegistryInterface;
use Symfony\Component\Form\FormTypeInterface;
use Symfony\Component\Form\ResolvedFormTypeInterface;
use Symfony\Component\Form\ResolvedFormTypeFactoryInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use DoS\UserBundle\Model\UserInterface;

class Factory extends FormFactory
{
    protected $pattern;
    protected $replacement = 'dos_';

    /**
     * @var FormRegistryInterface
     */
    private $registry;

Consider using a different property name as you override a private property of the parent class.

    /**
     * @var ResolvedFormTypeFactoryInterface
     */
    private $resolvedTypeFactory;

Consider using a different property name as you override a private property of the parent class.

    public function __construct(FormRegistryInterface $registry, ResolvedFormTypeFactoryInterface $resolvedTypeFactory)
    {
        $this->registry = $registry;
        $this->resolvedTypeFactory = $resolvedTypeFactory;

        parent::__construct($registry, $resolvedTypeFactory);
    }

    /**
     * @var TokenStorageInterface
     */
    protected $tokenStorage;

    /**
     * @param TokenStorageInterface $tokenStorage
     */
    public function setSecurityTokenStorage(TokenStorageInterface $tokenStorage)
    {
        $this->tokenStorage = $tokenStorage;
    }

    /**
     * @param string $pattern ereg pattern
     * @param string $replacement
     */
    public function setPrefixAndReplacement($pattern = null, $replacement = null)
    {
        $this->pattern = $pattern ?: $this->pattern;
        $this->replacement = $replacement ?: $this->replacement;
    }

    /**
     * @inheritdoc
     */
    public function createNamedBuilder($name, $type = 'form', $data = null, array $options = array())
    {
        if ($this->pattern) {
            $name = preg_replace($this->pattern, $this->replacement, $name);

            if (null !== $data && !array_key_exists('data', $options)) {
                $options['data'] = $data;
            }

            if ($type instanceof FormTypeInterface) {
                $type = $this->resolveType($type);
            } elseif (is_string($type)) {
                $type = $this->registry->getType($type);
            } elseif (!$type instanceof ResolvedFormTypeInterface) {
                throw new UnexpectedTypeException($type, 'string, Symfony\Component\Form\ResolvedFormTypeInterface or Symfony\Component\Form\FormTypeInterface');
            }
        }

        $builder = $type->createBuilder($this, $name, $options);

It seems like $type is not always an object, but can also be of type string. Maybe add an additional type check?

        // set default user
        $builder->setAttribute('user_aware', $this->getUser());

        // Explicitly call buildForm() in order to be able to override either
        // createBuilder() or buildForm() in the resolved form type
        $type->buildForm($builder, $builder->getOptions());

        return $builder;
    }

    /**
     * @inheritdoc
     */
    private function resolveType(FormTypeInterface $type)

Consider using a different method name as you override a private method of the parent class.

    {
        $parentType = $type->getParent();

        if ($parentType instanceof FormTypeInterface) {
            $parentType = $this->resolveType($parentType);
        } elseif (null !== $parentType) {
            $parentType = $this->registry->getType($parentType);
        }

        return $this->resolvedTypeFactory->createResolvedType(
            $type,
            // Type extensions are not supported for unregistered type instances,
            // i.e. type instances that are passed to the FormFactory directly,
            // nor for their parents, if getParent() also returns a type instance.
            array(),
            $parentType
        );
    }

    /**
     * {@inheritdoc}
     */
    public function createBuilderForProperty($class, $property, $data = null, array $options = array())
    {
        if (null === $guesser = $this->registry->getTypeGuesser()) {
            return $this->createNamedBuilder($property, 'text', $data, $options);
        }

        $typeGuess = $guesser->guessType($class, $property);
        $maxLengthGuess = $guesser->guessMaxLength($class, $property);
        $requiredGuess = $guesser->guessRequired($class, $property);
        $patternGuess = $guesser->guessPattern($class, $property);

        $type = $typeGuess ? $typeGuess->getType() : 'text';

        $maxLength = $maxLengthGuess ? $maxLengthGuess->getValue() : null;
        $pattern = $patternGuess ? $patternGuess->getValue() : null;

        if (null !== $pattern) {
            $options = array_replace_recursive(array('attr' => array('pattern' => $pattern)), $options);
        }

        if (null !== $maxLength) {
            $options = array_replace_recursive(array('attr' => array('maxlength' => $maxLength)), $options);
        }

        if ($requiredGuess) {
            $options = array_merge(array('required' => $requiredGuess->getValue()), $options);
        }

        // user options may override guessed options
        if ($typeGuess) {
            $options = array_merge($typeGuess->getOptions(), $options);
        }

        return $this->createNamedBuilder($property, $type, $data, $options);
    }

    /**
     * @return UserInterface
     */
    private function getUser()
    {
        $token = $this->tokenStorage->getToken();

        return $token ? $token->getUser() : null;
    }

    /**
     * @param FormBuilderInterface $builder
     * @param UserInterface|null   $user
     *
     * @return callable
     */
    public static function getUserAwareChoiceBuilder(FormBuilderInterface $builder, UserInterface $user = null)
    {
        return function (EntityRepository $objectRepository) use ($builder, $user) {
            return $objectRepository->createQueryBuilder('o')
                ->andWhere('o.user = :user')
                ->setParameter('user', $user ?: $builder->getAttribute('user_aware'))
            ;
        };
    }
}