public function testGenerate()
    {
        $generator = new ClassGenerator('Abc\\Test');
        $generator->setAbstract(true);
        $generator->addTrait('ATrait');
        $generator->addUse('ATrait');
        $generator->addTrait('BTrait');
        $generator->setImplementedInterfaces(['ITestA', 'ITestB']);
        $generator->setExtendedClass('ParentClass');
        $generator->addProperty('abc');
        $generator->addMethod('bar');
        $data = <<<EOF
namespace Abc;

use ATrait;

abstract class Test extends ParentClass implements ITestA, ITestB
{

    use ATrait,
        BTrait;

    public \$abc = null;

    public function bar()
    {
    }


}

EOF;
        $this->assertEquals($data, $generator->generate());
    }
    /**
     * @param  State|\Scaffold\State $state
     * @return State|void
     */
    public function build(State $state)
    {
        $model = $state->getModel('options-factory');
        $generator = new ClassGenerator($model->getName());
        $generator->setImplementedInterfaces(['FactoryInterface']);
        $model->setGenerator($generator);
        $generator->addUse('Zend\\ServiceManager\\FactoryInterface');
        $generator->addUse('Zend\\ServiceManager\\ServiceLocatorInterface');
        $options = $state->getModel('options');
        $key = $options->getServiceName();
        $key = substr($key, 0, -7);
        $body = <<<EOF
\$config = \$serviceLocator->get('Config');
return new {$options->getClassName()}(
    isset(\$config['{$key}'])
        ? \$config['{$key}']
        : []
);
EOF;
        $method = new MethodGenerator('createService');
        $method->setParameter(new ParameterGenerator('serviceLocator', 'ServiceLocatorInterface'));
        $method->setBody($body);
        $doc = new DocBlockGenerator('');
        $doc->setTag(new Tag(['name' => 'inhertidoc']));
        $method->setDocBlock($doc);
        $generator->addMethodFromGenerator($method);
    }
 /**
  * @param  State|\Scaffold\State $state
  * @return State|void
  */
 public function build(State $state)
 {
     $model = $state->getModel('options');
     $generator = new ClassGenerator($model->getName());
     $generator->setExtendedClass('AbstractOptions');
     $model->setGenerator($generator);
     $generator->addUse('Zend\\Stdlib\\AbstractOptions');
 }
    public function addTestIdMethod(ClassGenerator $generator, State $state)
    {
        $method = new MethodGenerator('testGetSetId');
        $class = $state->getEntityModel()->getClassName();
        $code = <<<EOF
\$object = new {$class}();
\$object->setId(123);
\$this->assertEquals(123, \$object->getId());
EOF;
        $method->setBody($code);
        $generator->addMethodFromGenerator($method);
    }
 /**
  * Build generators
  *
  * @param  State|State          $state
  * @return \Scaffold\State|void
  */
 public function build(State $state)
 {
     $model = $state->getControllerModel();
     $generator = new ClassGenerator($model->getName());
     $generator->setExtendedClass('AbstractRestfulController');
     $generator->addUse('Zend\\Mvc\\Controller\\AbstractRestfulController');
     $generator->addUse('Doctrine\\ORM\\EntityManager');
     $generator->addUse('Zend\\Form\\Form');
     $generator->addUse($state->getServiceTraitModel()->getName());
     $generator->addTrait($state->getServiceTraitModel()->getClassName());
     $this->addProperty($generator, 'entityManager', 'EntityManager');
     $this->buildGetEntityManager($generator, $state);
     $model->setGenerator($generator);
 }
 protected function buildEntityManager(ClassGenerator $generator)
 {
     $setter = $this->getSetter('entityManager', 'EntityManager');
     $getter = $this->getLazyGetter('entityManager', 'EntityManager', '$this->getServiceLocator()->get(\'entity_manager\')');
     $generator->addMethodFromGenerator($setter);
     $generator->addMethodFromGenerator($getter);
 }
    /**
     * @param ClassGenerator $generator
     * @param State          $state
     */
    public function addGetEntityManager(ClassGenerator $generator, State $state)
    {
        $doc = "@return \\PHPUnit_Framework_MockObject_MockObject|EntityManager";
        $body = <<<EOF
return \$this->getMockBuilder('Doctrine\\ORM\\EntityManager')
    ->disableOriginalConstructor()
    ->getMock();
EOF;
        $method = new MethodGenerator('getEntityManager', [], MethodGenerator::FLAG_PUBLIC, $body, $doc);
        $generator->addMethodFromGenerator($method);
    }
    public function buildEditAction(ClassGenerator $generator, State $state)
    {
        $service = 'get' . $state->getServiceModel()->getClassName();
        $name = lcfirst($state->getEntityModel()->getClassName());
        $method = new MethodGenerator('editAction');
        $method->setDocBlock(new DocBlockGenerator('Show one entity'));
        $method->setBody(<<<EOF
            \$id = \$this->params()->fromRoute('id');
\${$name} = \$this->{$service}()->loadById(\$id);
/** @var Form \$form */
\$form = \$this->getServiceLocator()->get('{$state->getFormFactoryModel()->getServiceName()}');
\$form->bind(\${$name});

if (\$this->getRequest()->isPost()) {
    \$form->setData(\$this->params()->fromPost());
    if (\$form->isValid()) {
        \$this->{$service}()->save(\${$name});
        \$this->getEntityManager()->flush();

        \$this->flashMessenger()->addSuccessMessage('Saved');
        \$this->redirect()->toRoute('home');
    }
}

return array(
    'form' => \$form
);
EOF
);
        $generator->addMethodFromGenerator($method);
    }