Zicht\Bundle\FrameworkExtraBundle\Fixture\Builder

Complexity

Total Complexity

30

Size/Duplication

Total Lines	200
Duplicated Lines	0 %

Importance

Changes	7
Bugs	2	Features	2

9 Methods

Rating	Name	Duplication	Size	Complexity
A	peek()	0	8	2
A	current()	0	6	2
A	push()	0	3	1
A	always()	0	4	1
D	end()	0	53	14
A	__construct()	0	5	1
A	create()	0	3	1
A	resolve()	0	9	3
A	__call()	0	28	5

<?php
/**
 * @author Gerard van Helden <gerard@zicht.nl>
 * @copyright Zicht Online <http://zicht.nl>
 */
namespace Zicht\Bundle\FrameworkExtraBundle\Fixture;

use Zicht\Util\Str;

/**
 * Fixture builder helper class. Provides a fluent interface for building fixture objects in Doctrine ORM.
 */
class Builder
{
    /**
     * Creates a builder for the specified namespace
     *
     * @param string $namespaces
     * @return Builder
     */
    public static function create($namespaces)
    {
        return new self($namespaces);
    }


    /**
     * Constructor, initializes the builder object. To use the builder, call Builder::create(...)
     *
     * @param string $namespaces
     */
    private function __construct($namespaces)
    {
        $this->namespaces = (array)$namespaces;

The property namespaces does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->stack    = array();

The property stack does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->alwaysDo = array();

The property alwaysDo does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }


    /**
     * Adds a method call to all fixture objects, typically array($manager, 'persist')
     *
     * @param callable $do
     * @return Builder
     */
    public function always($do)
    {
        $this->alwaysDo[]= $do;

The property alwaysDo does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        return $this;
    }


    /**
     * Implements the builder / fluent interface for building fixture objects.
     *
     * @param string $method
     * @param array $args
     * @return Builder
     *
     * @throws \BadMethodCallException
     */
    public function __call($method, $args)
    {
        if (method_exists($this->current(), $method)) {
            call_user_func_array(array($this->current(), $method), $args);
        } else {
            $entity = $method;

            $className = $this->resolve($entity);
            if ($className) {
                $class = new \ReflectionClass($className);
                if ($args) {

The expression $args of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    $entityInstance = $class->newInstanceArgs($args);
                } else {
                    $entityInstance = $class->newInstance();
                }
                $this->push($entityInstance);
            } else {
                throw new \BadMethodCallException(
                    "No class found for {$entity} in [" . join(", ", $this->namespaces) . "]"
                    . (
                        $this->current()
                            ? ", nor is it a method in " . get_class($this->current())
                            : ""
                    )
                );
            }
        }
        return $this;
    }


    /**
     * Resolve the entity name to any of the configured namespaces.
     * Returns null if not found.
     *
     * @param string $entity
     * @return null|string
     */
    private function resolve($entity)
    {
        foreach ($this->namespaces as $namespace) {
            $className = $namespace . '\\' . ucfirst($entity);
            if (class_exists($className)) {
                return $className;
            }
        }
        return null;
    }


    /**
     * Returns the top of the stack.
     *
     * @return mixed
     */
    protected function current()
    {
        if (count($this->stack)) {
            return $this->stack[count($this->stack) -1];
        }
        return null;
    }


    /**
     * Pushes an object onto the stack
     *
     * @param object $entity
     */
    protected function push($entity)
    {
        $this->stack[]= $entity;

The property stack does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }


    /**
     * Returns one level up in the tree.
     *
     * @param null $setter

Are you sure the doc-type for parameter $setter is correct as it would always require null to be passed?

     * @return Builder
     */
    public function end($setter = null)
    {
        if (!count($this->stack)) {
            throw new \UnexpectedValueException("Stack is empty. Did you call end() too many times?");
        }
        $current = array_pop($this->stack);
        if ($parent = $this->current()) {
            $parentClassName = get_class($parent);
            $entityLocalName = Str::classname(get_class($current));

            if ($current instanceof $parentClassName) {
                if (method_exists($parent, 'addChildren')) {
                    call_user_func(array($parent, 'addChildren'), $current);
                }
            }
            if (is_null($setter)) {

The condition is_null($setter) is always true.

                foreach (array('set', 'add') as $methodPrefix) {
                    $methodName = $methodPrefix . $entityLocalName;

                    if (method_exists($parent, $methodName)) {
                        $setter = $methodName;
                        break;
                    }
                }
            }
            if (!is_null($setter)) {
                call_user_func(array($parent, $setter), $current);
            }

            $parentClassNames = array_merge(class_parents($parentClassName), array($parentClassName));

            foreach (array_reverse($parentClassNames) as $lParentClassName) {
                $lParentClass = Str::classname($lParentClassName);
                $parentSetter = 'set' . $lParentClass;
                if ($lParentClassName == get_class($current)) {
                    $parentSetter = 'setParent';
                }
                if (method_exists($current, $parentSetter)) {
                    call_user_func(
                        array($current, $parentSetter),
                        $parent
                    );
                    break;
                }
            }
            foreach ($this->alwaysDo as $callable) {
                call_user_func($callable, $parent);
            }
        }
        foreach ($this->alwaysDo as $callable) {
            call_user_func($callable, $current);
        }
        return $this;
    }


    /**
     * Returns the object that is currently the subject of building
     *
     * @return mixed
     * @throws \UnexpectedValueException
     */
    public function peek()
    {
        $c = count($this->stack);
        if ($c == 0) {
            throw new \UnexpectedValueException("The stack is empty. You should probably peek() before the last end() call.");
        }
        $ret = $this->stack[$c -1];
        return $ret;
    }
}