addUse() public method

Add a class to "use" classes
public addUse ( string $use, string | null $useAlias = null ) : self
$use string
$useAlias string | null
return self
Esempio n. 1
0
 /**
  * ClassDiff constructor.
  *
  * @param string         $currentFilePath
  * @param string         $currentClassName
  * @param ClassGenerator $newClassGenerator
  */
 public function __construct($currentFilePath, $currentClassName, ClassGenerator $newClassGenerator)
 {
     $this->currentFilePath = $currentFilePath;
     $this->currentClassName = $currentClassName;
     $this->currentClassCode = file_get_contents($currentFilePath);
     $this->currentClassGenerator = $this->getGeneratorFromReflection(new ClassReflection($currentClassName));
     $this->newClassGenerator = $newClassGenerator;
     /*
      * PHP Reflections don't take into account use statements, so an entire
      * plugin is needed just for that. //shakes head
      */
     $parser = new Parser(new Lexer());
     $nodes = $parser->parse($this->currentClassCode);
     foreach ($nodes as $node) {
         /** @var $node Namespace_ */
         if (get_class($node) == 'PhpParser\\Node\\Stmt\\Namespace_') {
             /** @var Use_ $stmt */
             foreach ($node->stmts as $stmt) {
                 if (get_class($stmt) == 'PhpParser\\Node\\Stmt\\Use_') {
                     /** @var UseUse $use */
                     foreach ($stmt->uses as $use) {
                         $this->currentClassGenerator->addUse($use->name->toString());
                     }
                 }
             }
         }
     }
     if (in_array($this->currentClassGenerator->getExtendedClass(), $this->currentClassGenerator->getUses())) {
         $extended = new \ReflectionClass($this->currentClassGenerator->getExtendedClass());
         $this->currentClassGenerator->setExtendedClass($extended->getShortName());
     }
 }
Esempio n. 2
0
 public function generate()
 {
     if ($this->controller) {
         $modelBuilder = $this->controller->getModelBuilder();
         $className = $modelBuilder->getName();
     } else {
         $className = $this->class;
     }
     $modelClass = $this->modelClass ? $this->modelClass : $this->class;
     $class = new ClassGenerator();
     $class->setName($className);
     $class->setExtendedClass('CrudController');
     $class->addUse('Boyhagemann\\Crud\\CrudController');
     $class->addUse('Boyhagemann\\Form\\FormBuilder');
     $class->addUse('Boyhagemann\\Model\\ModelBuilder');
     $class->addUse('Boyhagemann\\Overview\\OverviewBuilder');
     $param = new ParameterGenerator();
     $param->setName('fb')->setType('FormBuilder');
     $body = $this->generateFormBuilderBody();
     $docblock = '@param FormBuilder $fb';
     $class->addMethod('buildForm', array($param), MethodGenerator::FLAG_PUBLIC, $body, $docblock);
     $param = new ParameterGenerator();
     $param->setName('mb')->setType('ModelBuilder');
     $body = sprintf('$mb->name(\'%s\')->table(\'%s\');' . PHP_EOL, $modelClass, strtolower(str_replace('\\', '_', $modelClass)));
     $docblock = '@param ModelBuilder $mb';
     $class->addMethod('buildModel', array($param), MethodGenerator::FLAG_PUBLIC, $body, $docblock);
     $param = new ParameterGenerator();
     $param->setName('ob')->setType('OverviewBuilder');
     $body = '';
     $docblock = '@param OverviewBuilder $ob';
     $class->addMethod('buildOverview', array($param), MethodGenerator::FLAG_PUBLIC, $body, $docblock);
     $this->generator->setClass($class);
     return $this->generator->generate();
 }
 /**
  * Build generators
  *
  * @param  State|\Scaffold\State $state
  * @return \Scaffold\State|void
  */
 public function build(State $state)
 {
     $model = $state->getRepositoryModel();
     $generator = new ClassGenerator($model->getName());
     $generator->addUse('Doctrine\\ORM\\EntityRepository');
     $generator->addUse($state->getEntityModel()->getName());
     $generator->setExtendedClass('EntityRepository');
     $this->buildFactory($generator);
     $model->setGenerator($generator);
 }
 /**
  * generate
  *
  * @param string $className
  * @param null   $namespace
  *
  * @return ClassGenerator
  */
 protected function generate($className, $namespace = null)
 {
     $exceptionClass = MigrationException::class;
     $class = new ClassGenerator($className, $namespace, null, 'AbstractMigration', [], [], [new MethodGenerator('up', [], 'public', "throw new \\{$exceptionClass}(\"Not implemented.\");", new DocBlockGenerator('Executed when migrating upwards.', 'TODO: replace body.')), new MethodGenerator('down', [], 'public', "throw new \\{$exceptionClass}(\"Not implemented.\");", new DocBlockGenerator('Executed when migrating downwards.', 'TODO: replace body.'))], new DocBlockGenerator("Migration {$className}"));
     $class->addUse(AbstractMigration::class);
     return $class;
 }
 public function getClass()
 {
     $classGenerator = new ClassGenerator($this->collection, $this->namespace);
     $classGenerator->addUse('ArangoOdm\\Document', 'ArangoDoc');
     $classGenerator->setExtendedClass('ArangoDoc');
     $classGenerator->addMethods($this->getMethods());
     return '<?php' . "\n\n" . $classGenerator->generate();
 }
Esempio n. 6
0
 public function generate(Generator\ClassGenerator $class, PHPClass $type)
 {
     if (!($extends = $type->getExtends()) && class_exists($type->getNamespace())) {
         $extendNamespace = $type->getNamespace();
         $extendNamespace = explode('\\', $extendNamespace);
         $extendClass = array_pop($extendNamespace);
         $extendNamespace = implode('\\', $extendNamespace);
         $extends = new PHPClass();
         $extends->setName($extendClass);
         $extends->setNamespace($extendNamespace);
         $class->setExtendedClass($extends);
     }
     if ($extends->getName() == "string" && $extends->getNamespace() == "" && class_exists($type->getNamespace() . '\\String')) {
         $extends->setName('String');
         $extends->setNamespace($type->getNamespace());
     } elseif ($extends->getName() == "string" && $extends->getNamespace() == "" && class_exists($type->getNamespace())) {
         $extendNamespace = $type->getNamespace();
         $extendNamespace = explode('\\', $extendNamespace);
         $extendClass = array_pop($extendNamespace);
         $extendNamespace = implode('\\', $extendNamespace);
         $extends = new PHPClass();
         $extends->setName($extendClass);
         $extends->setNamespace($extendNamespace);
         $class->setExtendedClass($extends);
     }
     $docblock = new DocBlockGenerator("Class representing " . $type->getName());
     if ($type->getDoc()) {
         $docblock->setLongDescription($type->getDoc());
     }
     $class->setNamespaceName($type->getNamespace());
     $class->setName($type->getName());
     $class->setDocblock($docblock);
     $class->setExtendedClass($extends->getName());
     if ($extends->getNamespace() != $type->getNamespace()) {
         if ($extends->getName() == $type->getName()) {
             $class->addUse($type->getExtends()->getFullName(), $extends->getName() . "Base");
             $class->setExtendedClass($extends->getName() . "Base");
         } else {
             $class->addUse($extends->getFullName());
         }
     }
     if ($this->handleBody($class, $type)) {
         return true;
     }
 }
Esempio n. 7
0
 /**
  * @param        $name
  * @param        $namespace
  * @param        $uses
  * @param string $extends
  * @param array  $implements
  *
  * @return ClassGenerator
  */
 public static function classGen($name, $namespace, $uses = [], $extends = '', $implements = [])
 {
     $class = new ClassGenerator();
     $class->setName($name)->setNamespaceName($namespace)->setExtendedClass($extends)->setImplementedInterfaces($implements)->setIndentation(Generator::$indentation);
     foreach ($uses as $use) {
         $class->addUse($use);
     }
     return $class;
 }
 /**
  * Build generators
  *
  * @param  State|\Scaffold\State $state
  * @return \Scaffold\State|void
  */
 public function build(State $state)
 {
     $model = $this->model;
     $generator = new ClassGenerator($model->getName());
     $generator->addUse('Zend\\ServiceManager\\FactoryInterface');
     $generator->addUse('Zend\\ServiceManager\\ServiceLocatorInterface');
     $generator->addUse('Zend\\ServiceManager\\ServiceManager');
     $generator->addUse($state->getServiceModel()->getName());
     $generator->setImplementedInterfaces(['FactoryInterface']);
     $method = new MethodGenerator('createService');
     $method->setParameter(new ParameterGenerator('serviceLocator', 'ServiceLocatorInterface'));
     $method->setBody('return new ' . $state->getServiceModel()->getClassName() . '($serviceLocator);');
     $doc = new DocBlockGenerator('Create service');
     $doc->setTag(new Tag\GenericTag('param', 'ServiceLocatorInterface|ServiceManager $serviceLocator'));
     $doc->setTag(new Tag\GenericTag('return', $state->getServiceModel()->getClassName()));
     $method->setDocBlock($doc);
     $generator->addMethodFromGenerator($method);
     $model->setGenerator($generator);
 }
 /**
  * Build generators
  *
  * @param  State $state
  * @return void
  */
 public function build(State $state)
 {
     $model = $state->getFormFactoryModel();
     $generator = new ClassGenerator($model->getName());
     $generator->setImplementedInterfaces(['FactoryInterface']);
     $generator->addUse('Doctrine\\ORM\\EntityManager');
     $generator->addUse('DoctrineModule\\Stdlib\\Hydrator\\DoctrineObject');
     $generator->addUse('Zend\\ServiceManager\\FactoryInterface');
     $generator->addUse('Zend\\ServiceManager\\ServiceLocatorInterface');
     $generator->addUse('Zend\\Form\\Form');
     $generator->addUse('Zend\\Form\\Element');
     $generator->addUse('Zend\\InputFilter\\Factory');
     $generator->addUse('Zend\\InputFilter\\InputFilterInterface');
     $this->buildCreateService($generator, $state);
     $this->buildGetInputFilter($generator, $state);
     $model->setGenerator($generator);
 }
Esempio n. 10
0
 /**
  * @group 4990
  */
 public function testAddOneUseWithAliasTwiceOnlyAddsOne()
 {
     $classGenerator = new ClassGenerator();
     $classGenerator->setName('My\\Class');
     $classGenerator->addUse('My\\First\\Use\\Class', 'MyAlias');
     $classGenerator->addUse('My\\First\\Use\\Class', 'MyAlias');
     $generated = $classGenerator->generate();
     $this->assertCount(1, $classGenerator->getUses());
     $this->assertContains('use My\\First\\Use\\Class as MyAlias;', $generated);
 }
Esempio n. 11
0
 /**
  * Create view helper factory
  *
  * @return bool
  */
 public function createViewHelperFactory()
 {
     // get needed options to shorten code
     $moduleName = $this->requestOptions->getModuleName();
     $viewHelperClass = $this->requestOptions->getViewHelperClass();
     $viewHelperPath = $this->requestOptions->getViewHelperPath();
     $factoryClass = $viewHelperClass . 'Factory';
     $factoryFile = $factoryClass . '.php';
     $factoryFilePath = $viewHelperPath . $factoryFile;
     // check for factory class
     if (file_exists($factoryFilePath)) {
         throw new GeneratorException('The factory for this view helper exists already.');
     }
     // create controller class with class generator
     $code = new ClassGenerator();
     $code->setNamespaceName($moduleName . '\\View\\Helper');
     $code->addUse('Zend\\ServiceManager\\FactoryInterface');
     $code->addUse('Zend\\ServiceManager\\ServiceLocatorInterface');
     $code->setName($factoryClass);
     $code->setImplementedInterfaces(array('FactoryInterface'));
     $code->addMethodFromGenerator($this->generateCreateServiceMethod($viewHelperClass, 'viewHelperManager', 'viewHelper'));
     // add optional doc block
     if ($this->flagCreateApiDocs) {
         $code->setDocBlock(new DocBlockGenerator('Factory for ' . $viewHelperClass, 'Please add a proper description for the ' . $viewHelperClass . ' factory', array($this->generatePackageTag($moduleName))));
     }
     // create file with file generator
     $file = new FileGenerator();
     $file->setClass($code);
     // add optional doc block
     if ($this->flagCreateApiDocs) {
         $file->setDocBlock(new DocBlockGenerator('This file was generated by FrilleZFTool.', null, array($this->generatePackageTag($moduleName), $this->generateSeeTag())));
     }
     // write controller class
     if (!file_put_contents($factoryFilePath, $file->generate())) {
         return false;
     }
     return true;
 }
 /**
  * Method for add USE for new form
  * For add more USE - add more ->addUse('namespace')
  */
 private function addUseForNewFilter()
 {
     $this->newFilter->addUse('InepZend\\Filter\\Filter')->addUse($this->getStrModuleName() . '\\Message\\Message');
 }
 protected function createRealCommandQuery($commandPath, $name, $moduleName)
 {
     $this->directoryService->makeSureDirExist($commandPath);
     $this->directoryService->createAllNamespacedDir($name, $commandPath);
     $nameParts = explode('/', trim($name, '/'));
     $className = sprintf('%s%s', $nameParts[count($nameParts) - 1], $this->getSuffixClass());
     $handlerName = sprintf('%s%s', $className, 'Handler');
     $handlerFactoryName = sprintf('%s%s', $handlerName, 'Factory');
     unset($nameParts[count($nameParts) - 1]);
     //Set namespace for generated files
     $namespace = sprintf('%s\\%s\\%s', $moduleName, $this->getDirectory(), implode('\\', $nameParts));
     $classGenerator = new ClassGenerator();
     $classGenerator->setNamespaceName(trim($namespace, '\\'));
     $handlerGenerator = new ClassGenerator();
     $handlerGenerator->setNamespaceName(trim($namespace, '\\'));
     $handlerFactoryGenerator = new ClassGenerator();
     $handlerFactoryGenerator->setNamespaceName(trim($namespace, '\\'));
     //Set basic properties for command
     $commandQueryInterfaceToImplement = $this->getCommandQueryInterfaceToImplement();
     $classGenerator->setName($className);
     //        $classGenerator->addUse($commandQueryInterfaceToImplement);
     $tmpRef = new \ReflectionClass($commandQueryInterfaceToImplement);
     $classGenerator->setImplementedInterfaces([$tmpRef->getName()]);
     $this->addMethodsFromInterface($commandQueryInterfaceToImplement, $classGenerator);
     //Set basic properties for command handler
     $commandHandlerClassToImplement = $this->getAbstractHandlerClassName();
     $tmpRef = new \ReflectionClass($commandHandlerClassToImplement);
     $handlerGenerator->setName($handlerName);
     $handlerGenerator->setExtendedClass($tmpRef->getName());
     $this->addMethodsFromAbstractClass($commandHandlerClassToImplement, $handlerGenerator);
     //Set basic properties for command handler factory
     $commandHandlerFactoryClassToImplement = FactoryInterface::class;
     $handlerFactoryGenerator->setName($handlerFactoryName);
     $handlerFactoryGenerator->addUse($commandHandlerFactoryClassToImplement);
     $handlerFactoryGenerator->setImplementedInterfaces([FactoryInterface::class]);
     $this->addMethodsFromInterface($commandHandlerFactoryClassToImplement, $handlerFactoryGenerator);
     //        $method = $handlerFactoryGenerator->getMethod('__invoke');
     ////        $method->setParameters()
     //        $method->setBody(sprintf('return new %s();', $handlerGenerator->getName()));
     //GENERATE IT !!!
     $fileGenerator = FileGenerator::fromArray(['classes' => [$classGenerator]]);
     file_put_contents(sprintf('%s%s%s%s%s%s', $commandPath, DIRECTORY_SEPARATOR, implode(DIRECTORY_SEPARATOR, $nameParts), DIRECTORY_SEPARATOR, $className, '.php'), $fileGenerator->generate());
     $fileGenerator = FileGenerator::fromArray(['classes' => [$handlerGenerator]]);
     file_put_contents(sprintf('%s%s%s%s%s%s', $commandPath, DIRECTORY_SEPARATOR, implode(DIRECTORY_SEPARATOR, $nameParts), DIRECTORY_SEPARATOR, $handlerName, '.php'), $fileGenerator->generate());
     $fileGenerator = FileGenerator::fromArray(['classes' => [$handlerFactoryGenerator]]);
     file_put_contents(sprintf('%s%s%s%s%s%s', $commandPath, DIRECTORY_SEPARATOR, implode(DIRECTORY_SEPARATOR, $nameParts), DIRECTORY_SEPARATOR, $handlerFactoryName, '.php'), $fileGenerator->generate());
     return [sprintf('%s\\%s', $classGenerator->getNamespaceName(), $classGenerator->getName()), sprintf('%s\\%s', $handlerGenerator->getNamespaceName(), $handlerGenerator->getName()), sprintf('%s\\%s', $handlerFactoryGenerator->getNamespaceName(), $handlerFactoryGenerator->getName())];
 }
require __DIR__ . "/../vendor/autoload.php";
$name = "Client";
$namespace = "CallFire\\Api";
$restNamespace = "Rest";
$extendedClass = "AbstractClient";
$swaggerUrl = 'https://www.callfire.com/api/1.1/wsdl/swagger';
$requestNamespacePart = RestGenerator::REQUEST_NAMESPACE_ALIAS;
$requestNamespace = "{$namespace}\\Rest\\{$requestNamespacePart}";
$responseNamespacePart = RestGenerator::RESPONSE_NAMESPACE_ALIAS;
$responseNamespace = "{$namespace}\\Rest\\{$responseNamespacePart}";
$structureNamespacePart = RestGenerator::STRUCTURE_NAMESPACE_ALIAS;
$structureNamespace = "{$namespace}\\Rest\\{$structureNamespacePart}";
$sourceDirectory = realpath(__DIR__ . "/../src") . '/' . str_replace('\\', '/', $namespace);
$generator = new RestGenerator($swaggerUrl);
$classGenerator = new ClassGenerator($name, "{$namespace}\\{$restNamespace}\\Client", null, $extendedClass);
$classGenerator->addUse("{$namespace}\\{$restNamespace}\\{$extendedClass}");
$generator->setClassGenerator($classGenerator);
$generator->generateClasses($requestNamespace, $responseNamespace, $structureNamespace);
$classFiles = $generator->generateClassFiles();
$requestClassFiles = $generator->generateRequestClassFiles();
if (!is_dir($sourceDirectory)) {
    mkdir($sourceDirectory, 0777, true);
}
if (!is_dir("{$sourceDirectory}/{$restNamespace}")) {
    mkdir("{$sourceDirectory}/{$restNamespace}", 0777, true);
}
if (!is_dir("{$sourceDirectory}/{$restNamespace}/Client")) {
    mkdir("{$sourceDirectory}/{$restNamespace}/Client", 0777, true);
}
if (!is_dir("{$sourceDirectory}/{$restNamespace}/Request")) {
    mkdir("{$sourceDirectory}/{$restNamespace}/Request", 0777, true);
 /**
  * generates code for base grid and saves in file (overrides file if exists)
  *
  * @param DataSetDescriptorInterface $dataSet
  * @return string full name of generated class
  */
 protected function generateBaseGrid(DataSetDescriptorInterface $dataSet)
 {
     $name = $dataSet->getName();
     $className = "Base" . $this->underscoreToCamelCase->filter($name) . "Grid";
     $namespace = $this->params->getParam("moduleName") . "\\Grid\\BaseGrid";
     $fullClassName = '\\' . $namespace . '\\' . $className;
     $class = new ClassGenerator();
     $class->setName($className);
     $class->setNamespaceName($namespace);
     $class->setExtendedClass($this->baseGridParent);
     foreach ($this->baseGridUses as $use) {
         $class->addUse($use);
     }
     $this->generateConfigProperty($class);
     $this->generateHeaderProperty($class, $dataSet);
     $this->generateInitMehod($class, $dataSet);
     $this->generateInitFiltersMehod($class, $dataSet);
     $file = new FileGenerator();
     $docBlock = new \Zend\Code\Generator\DocblockGenerator(sprintf($this->codeLibrary()->get('filter.generatedConfigDescription'), $name));
     $docBlock->setTag(new GenericTag('author', $this->params->getParam('author')))->setTag(new GenericTag('project', $this->params->getParam('project')))->setTag(new GenericTag('license', $this->params->getParam('license')))->setTag(new GenericTag('copyright', $this->params->getParam('copyright')));
     $file->setClass($class)->setDocBlock($docBlock);
     $modelClassFilePath = $this->moduleRoot() . "/src/" . $this->params->getParam("moduleName") . "/Grid/BaseGrid/" . $className . ".php";
     file_put_contents($modelClassFilePath, $file->generate());
     return $fullClassName;
 }
 private function addCacheAnnotation(ClassGenerator $classGenerator)
 {
     $uses = $classGenerator->getUses();
     if (!in_array(Cache::class, $uses)) {
         $classGenerator->addUse(Cache::class);
     }
 }
 /**
  * generates code for base model and saves in file (overrides file if exists)
  *
  * @param DataSetDescriptorInterface $dataSet
  * @return string name of generated class
  */
 protected function generateBaseModel(DataSetDescriptorInterface $dataSet)
 {
     $name = $dataSet->getName();
     $className = "Base" . $this->underscoreToCamelCase->filter($name);
     $namespace = $this->params->getParam("moduleName") . "\\Model\\BaseModel";
     $fullClassName = '\\' . $namespace . '\\' . $className;
     $class = new ClassGenerator();
     $class->setName($className);
     $class->setNamespaceName($namespace);
     $class->setExtendedClass($this->baseModelParent);
     foreach ($this->baseModelUses as $use) {
         $class->addUse($use);
     }
     $this->addEventsMethods($class);
     foreach ($dataSet->listFields() as $name) {
         $column = $dataSet->getFieldDescriptor($name);
         $this->generateColumnRelatedElements($class, $column);
     }
     $file = new FileGenerator();
     $docBlock = new \Zend\Code\Generator\DocblockGenerator(sprintf($this->codeLibrary()->get('model.generatedConfigDescription'), $name));
     $docBlock->setTag(new GenericTag('author', $this->params->getParam('author')))->setTag(new GenericTag('project', $this->params->getParam('project')))->setTag(new GenericTag('license', $this->params->getParam('license')))->setTag(new GenericTag('copyright', $this->params->getParam('copyright')));
     $class->setDocBlock($docBlock);
     $file->setClass($class);
     $modelClassFilePath = $this->moduleRoot() . "/src/" . $this->params->getParam("moduleName") . "/Model/BaseModel/" . $className . ".php";
     file_put_contents($modelClassFilePath, $file->generate());
     return $fullClassName;
 }
Esempio n. 18
0
 /**
  * Append methods to Api class
  *
  * @param Generator\ClassGenerator $class
  * @param string                   $operation
  * @param mixed                    $apiMetadata
  * @param FileGenerator            $demoFile
  */
 protected function generateApiOperationFromMetadata(Generator\ClassGenerator &$class, $httpMethod, $apiMetadata)
 {
     $console = $this->getServiceLocator()->get('console');
     $modelClassName = 'Mailjet\\Model\\' . $class->getName();
     $model = $class->getName();
     $class->addUse('Zend\\Json\\Json')->addUse('Zend\\InputFilter');
     $httpMethod = strtoupper($httpMethod);
     switch ($httpMethod) {
         case 'GET':
             if ($apiMetadata->Filters) {
                 $class->addMethods(array(new Generator\MethodGenerator('getList', array(new Generator\ParameterGenerator('filters', 'array', array())), Generator\MethodGenerator::FLAG_PUBLIC, 'return parent::_list($filters);', new Generator\DocBlockGenerator("Return list of {$modelClassName}", "Return list of {$modelClassName} filtered by \$filters if provided" . PHP_EOL, array(new ParamTag(array('name' => 'filters', 'datatype' => 'array', 'description' => 'key/val filters')), new ReturnTag(array('datatype' => 'ResultSet\\ResultSet', 'description' => "List of {$modelClassName}")))))));
                 foreach ($apiMetadata->Filters as $filterInfo) {
                     try {
                         $filterName = $filterInfo->Name;
                         $dataTypeInfos = $this->getNormalizedFilterOrProperty($filterInfo);
                         $dataType = $dataTypeInfos['dataType'];
                         foreach ($dataTypeInfos['uses'] as $use) {
                             $class->addUse($use);
                         }
                         $isKey = $filterName == $apiMetadata->UniqueKey;
                         if ($isKey) {
                             $bodyMethod = sprintf('return $this->_get($%s);' . PHP_EOL, $filterName);
                         } else {
                             $bodyMethod = sprintf('$result = $this->getList(array(\'%s\' => $%s));' . PHP_EOL . 'return $result;', $filterName, $filterName);
                         }
                         $class->addMethods(array(new Generator\MethodGenerator('getBy' . $filterName, array(new Generator\ParameterGenerator($filterName, $dataType)), Generator\MethodGenerator::FLAG_PUBLIC, $bodyMethod, new Generator\DocBlockGenerator($isKey ? "Return {$modelClassName}" : "Return list of {$modelClassName} with {$filterName} = \${$filterName}", '', array(new ParamTag(array('name' => $filterName, 'datatype' => $dataType)), new ReturnTag(array('datatype' => $isKey ? $modelClassName : 'ResultSet\\ResultSet')))))));
                     } catch (\Exception $e) {
                         $console->writeLine('[' . $class->getName() . ']' . $e->getMessage(), Color::YELLOW);
                     }
                 }
                 $param = new Generator\ParameterGenerator('id', 'int');
                 $class->addMethods(array(new Generator\MethodGenerator('get', array($param), Generator\MethodGenerator::FLAG_PUBLIC, 'if (empty($id)) {' . PHP_EOL . '    throw new Exception\\InvalidArgumentException("You must specify the ID");' . PHP_EOL . '}' . PHP_EOL . PHP_EOL . 'return parent::_get($id);', new Generator\DocBlockGenerator("Return {$modelClassName} with id = \$id", '', array(new ParamTag(array('name' => 'id', 'datatype' => 'int', 'description' => 'Id of resource to get')), new ReturnTag(array('datatype' => $modelClassName)))))));
             } else {
                 $class->addMethods(array(new Generator\MethodGenerator('current', array(), Generator\MethodGenerator::FLAG_PUBLIC, 'return parent::_get();', new Generator\DocBlockGenerator("Return current {$modelClassName}", '', array(new ReturnTag(array('datatype' => $modelClassName)))))));
             }
             break;
         case 'DELETE':
             $class->addMethods(array(new Generator\MethodGenerator('delete', array(new Generator\ParameterGenerator('id')), Generator\MethodGenerator::FLAG_PUBLIC, 'return parent::_delete($id);', new Generator\DocBlockGenerator("Delete the {$model} with id = \$id", '', array(new ParamTag(array('name' => 'id', 'datatype' => 'integer', 'description' => 'Id to delete')), new ReturnTag(array('datatype' => 'bool', 'description' => 'True on success')))))));
             break;
         case 'POST':
             $modelParameter = new Generator\ParameterGenerator($model, $modelClassName);
             $modelParameter->setPassedByReference(true);
             $class->addMethods(array(new Generator\MethodGenerator('create', array($modelParameter), Generator\MethodGenerator::FLAG_PUBLIC, "return parent::_create(\${$model});", new Generator\DocBlockGenerator("Create a new {$model}", '', array(new ParamTag(array('name' => $model, 'datatype' => $modelClassName)), new ReturnTag(array('datatype' => "{$modelClassName}|false", 'description' => 'Object created or false')))))));
             break;
         case 'PUT':
             $modelParameter = new Generator\ParameterGenerator($model, $modelClassName);
             $modelParameter->setPassedByReference(true);
             $class->addMethods(array(new Generator\MethodGenerator('update', array($modelParameter), Generator\MethodGenerator::FLAG_PUBLIC, "return parent::_update(\${$model});", new Generator\DocBlockGenerator("Update existing {$model}", '', array(new ParamTag(array('name' => $model, 'datatype' => $modelClassName)), new ReturnTag(array('datatype' => "{$modelClassName}|false", 'description' => 'Object created or false')))))));
             break;
         default:
             break;
     }
 }
Esempio n. 19
0
 /**
  * @param Tag $tagItem
  * @return ClassGenerator
  */
 protected function createClass(Tag $tagItem)
 {
     $className = ucfirst($this->stringToCamelCaseConverter->convert($tagItem->getName()));
     $class = new ClassGenerator();
     $class->setNamespaceName('Flex\\Code\\Html\\Tag');
     $class->setName($className);
     $class->addUse('Flex\\Code\\Html\\Tag\\Model\\AbstractTag');
     $class->setExtendedClass('AbstractTag');
     $implementedInterfaces = [];
     if ($tagItem->isGlobalAttributeAware()) {
         $implementedInterfaces[] = 'GlobalAttributeAwareInterface';
         $class->addUse('Flex\\Code\\Html\\Tag\\Attribute\\GlobalAttributeAwareInterface');
         $class->addUse('Flex\\Code\\Html\\Tag\\Attribute\\GlobalAttributeAwareTrait');
         $class->addTrait('GlobalAttributeAwareTrait');
     }
     if ($tagItem->isClipboardEventAware()) {
         $implementedInterfaces[] = 'ClipboardEventAwareInterface';
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\ClipboardEventAwareInterface');
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\ClipboardEventAwareTrait');
         $class->addTrait('ClipboardEventAwareTrait');
     }
     if ($tagItem->isFormEventAware()) {
         $implementedInterfaces[] = 'FormEventAwareInterface';
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\FormEventAwareInterface');
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\FormEventAwareTrait');
         $class->addTrait('FormEventAwareTrait');
     }
     if ($tagItem->isKeyboardEventAware()) {
         $implementedInterfaces[] = 'KeyboardEventAwareInterface';
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\KeyboardEventAwareInterface');
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\KeyboardEventAwareTrait');
         $class->addTrait('KeyboardEventAwareTrait');
     }
     if ($tagItem->isMediaEventAware()) {
         $implementedInterfaces[] = 'MediaEventAwareInterface';
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\MediaEventAwareInterface');
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\MediaEventAwareTrait');
         $class->addTrait('MediaEventAwareTrait');
     }
     if ($tagItem->isMiscEventAware()) {
         $implementedInterfaces[] = 'MiscEventAwareInterface';
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\MiscEventAwareInterface');
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\MiscEventAwareTrait');
         $class->addTrait('MiscEventAwareTrait');
     }
     if ($tagItem->isMouseEventAware()) {
         $implementedInterfaces[] = 'MouseEventAwareInterface';
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\MouseEventAwareInterface');
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\MouseEventAwareTrait');
         $class->addTrait('MouseEventAwareTrait');
     }
     if ($tagItem->isWindowEventAware()) {
         $implementedInterfaces[] = 'WindowEventAwareInterface';
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\WindowEventAwareInterface');
         $class->addUse('Flex\\Code\\Html\\Tag\\Event\\WindowEventAwareTrait');
         $class->addTrait('WindowEventAwareTrait');
     }
     $class->setImplementedInterfaces($implementedInterfaces);
     $docBlock = new DocBlockGenerator();
     $docBlock->setTag(new GenericTag('author', 'elnebuloso/flex-code-html-generator'));
     $docBlock->setTag(new GenericTag('link', $tagItem->getLink()));
     if (!is_null($tagItem->getShortDescription())) {
         $docBlock->setShortDescription($tagItem->getShortDescription());
     }
     if (!is_null($tagItem->getLongDescription())) {
         $docBlock->setLongDescription($tagItem->getLongDescription());
     }
     $class->setDocBlock($docBlock);
     return $class;
 }
Esempio n. 20
0
 /**
  * @param string $sourceFile
  * @return string
  */
 protected function generateClass($sourceFile)
 {
     $sourceContent = json_decode(file_get_contents($sourceFile));
     $class = new ClassGenerator();
     $className = null;
     $mappingClasses = array();
     $propNameMap = $this->setPropNameMap($sourceContent);
     $isCollection = false;
     foreach ($sourceContent as $property => $value) {
         $ourPropertyName = array_search($property, $propNameMap);
         if ($ourPropertyName) {
             $property = $ourPropertyName;
         }
         if ($property === '@name') {
             //Class name
             $className = $value;
             if ($this->namespace) {
                 $class->setNamespaceName($this->namespace);
             }
             $class->setName($value);
         } elseif ($property === '@type') {
             continue;
         } elseif ($value === 'number' || $value === 'int' || $value === 'integer') {
             //Create property type number
             $class->addProperty($property, null, PropertyGenerator::FLAG_PROTECTED);
             $class->addMethods(array(MethodGenerator::fromArray($this->generateGetMethod($property, 'int')), MethodGenerator::fromArray($this->generateSetMethod($property, 'int'))));
         } elseif ($value === 'float' || $value === 'double' || $value === 'real') {
             //Create property type number
             $class->addProperty($property, null, PropertyGenerator::FLAG_PROTECTED);
             $class->addMethods(array(MethodGenerator::fromArray($this->generateGetMethod($property, $value)), MethodGenerator::fromArray($this->generateSetMethod($property, $value))));
         } elseif ($value === 'string') {
             //Create property type string
             $class->addProperty($property, null, PropertyGenerator::FLAG_PROTECTED);
             $class->addMethods(array(MethodGenerator::fromArray($this->generateGetMethod($property, $value)), MethodGenerator::fromArray($this->generateSetMethod($property, $value))));
         } elseif ($value === 'date') {
             //Create property type date
             $class->addProperty($property, null, PropertyGenerator::FLAG_PROTECTED);
             $class->addMethods(array(MethodGenerator::fromArray($this->generateGetMethod($property, 'string')), MethodGenerator::fromArray($this->generateSetMethod($property, 'string'))));
         } elseif ($value === 'array') {
             //Create property type date
             $class->addProperty($property, null, PropertyGenerator::FLAG_PROTECTED);
             $class->addMethods(array(MethodGenerator::fromArray($this->generateGetMethod($property, 'array')), MethodGenerator::fromArray($this->generateSetMethod($property, 'array'))));
         } elseif ($value === 'boolean' || $value === 'bool') {
             //Create property type boolean
             $class->addProperty($property, null, PropertyGenerator::FLAG_PROTECTED);
             $class->addMethods(array(MethodGenerator::fromArray($this->generateGetMethod($property, $value)), MethodGenerator::fromArray($this->generateSetMethod($property, $value))));
         } elseif ($property === "@model") {
             if ($this->namespace) {
                 $class->addUse($this->namespace . '\\' . ucfirst($value));
             }
         } elseif ($property === "@collection") {
             $isCollection = true;
             $class->addProperty('collection', array(), PropertyGenerator::FLAG_PROTECTED);
             $class->addMethods($this->getMethodsForCollection($value->model));
         } elseif ($property === "@parent") {
             //"@parent": "\\Classes\\Items",
             $class->setExtendedClass($value);
         } elseif (strpos($value, '@') === 0) {
             if ($className !== ucfirst(substr($value, 1))) {
                 if ($this->namespace) {
                     $class->addUse($this->namespace . '\\' . ucfirst(substr($value, 1)));
                 }
             }
             if ($this->namespace) {
                 $mappingClasses[$property] = $this->namespace . '\\' . ucfirst(substr($value, 1));
             } else {
                 $mappingClasses[$property] = ucfirst(substr($value, 1));
             }
             //Create property type Class
             $class->addProperty($property, null, PropertyGenerator::FLAG_PROTECTED);
             $class->addMethods(array(MethodGenerator::fromArray($this->generateGetMethod($property, ucfirst(substr($value, 1)))), MethodGenerator::fromArray($this->generateSetMethod($property, ucfirst(substr($value, 1))))));
         } else {
             var_dump($value, $property);
             exit;
         }
     }
     if ($isCollection === true) {
         if ($this->rootClassNameForCollection) {
             $class->setExtendedClass($this->rootClassNameForCollection);
             $class->addUse($this->rootClassForCollectionNamespace);
         }
     } else {
         if ($this->rootClassName) {
             $class->setExtendedClass($this->rootClassName);
             $class->addUse($this->rootClassNamespace);
         }
     }
     $class->addProperty($this->mappingClassesPropertyName, $mappingClasses, PropertyGenerator::FLAG_PROTECTED);
     $class->addProperty($this->mappingPropertyName, $propNameMap, PropertyGenerator::FLAG_PROTECTED);
     $file = new FileGenerator(array('classes' => array($class)));
     $code = $file->generate();
     $path = realpath($this->destinationDir) . '/' . ucfirst($className) . '.php';
     $code = str_replace("\n\n}\n", '}', $code);
     file_put_contents($path, $code);
     return $path;
 }
    /**
     * @group ZF2-151
     */
    public function testAddUses()
    {
        $classGenerator = new ClassGenerator();
        $classGenerator->setName('My\Class');
        $classGenerator->addUse('My\First\Use\Class');
        $classGenerator->addUse('My\Second\Use\Class', 'MyAlias');
        $generated = $classGenerator->generate();

        $this->assertContains('use My\First\Use\Class;', $generated);
        $this->assertContains('use My\Second\Use\Class as MyAlias;', $generated);
    }
Esempio n. 22
0
 /**
  * @param string $className
  * @param string $namespace
  *
  * @return ClassGenerator
  *
  * @throws CliException
  */
 protected function generate($className, $namespace = null)
 {
     $class = new ClassGenerator($className, $namespace, null, 'SimpleMigration', [], [], [new MethodGenerator('up', [], 'public', null, new DocBlockGenerator('Executed when migrating upwards.', 'TODO: implement')), new MethodGenerator('down', [], 'public', null, new DocBlockGenerator('Executed when migrating downwards / rolling back.', 'TODO: implement'))], new DocBlockGenerator($className . ' class', null, [new GenericTag('link', 'http://baleen.org')]));
     $class->addUse(SimpleMigration::class);
     return $class;
 }