samsoncms\api\GeneratorApi

Complexity

Total Complexity

34

Size/Duplication

Total Lines	554
Duplicated Lines	12.09 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	13
Bugs	1	Features	8

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	generateEntityTableMethod()	0	14	1
B	createEntityClasses()	0	41	4
B	createEntityClass()	0	54	6
B	createQueryClass()	0	34	2
A	generateQuerableClassHeader()	0	16	2
A	generateTraitsUsage()	0	9	2
A	generateFieldConditionMethod()	0	14	1
A	createCollectionClass()	0	9	1
A	generateConstructorCollectionClass()	15	15	1
B	createGalleryClass()	0	27	3
A	generateConstructorGalleryClass()	0	15	1
B	createTableRowClass()	0	27	2
B	createTableClass()	0	40	2
A	generateTableFieldMethod()	0	12	1
A	generateConstructorTableClass()	16	16	1
A	generateLocalizedFieldConditionMethod()	0	14	1
A	generateConstructorApplicationClass()	18	18	1
A	generateConstructorApplicationCollectionClass()	18	18	1

<?php
//[PHPCOMPRESSOR(remove,start)]
/**
 * Created by PhpStorm.
 * User: VITALYIEGOROV
 * Date: 09.12.15
 * Time: 14:34
 */
namespace samsoncms\api;

use samsoncms\api\generator\exception\ParentEntityNotFound;
use samsoncms\api\generator\Generator;
use samsoncms\api\generator\Metadata;
use samsonframework\orm\DatabaseInterface;

/**
 * Entity classes generator.
 * @package samsoncms\api
 */
class GeneratorApi extends Generator
{

    /**
     * Generator constructor.
     * @param DatabaseInterface $database Database instance
     * @throws ParentEntityNotFound
     * @throws \samsoncms\api\exception\AdditionalFieldTypeNotFound
     */
    public function __construct(DatabaseInterface $database)
    {
        parent::__construct($database);

        /**
         * Fill metadata only with structures which have to be generated
         */
        $this->fillMetadata();
    }

    /**
     * Generate entity related structure table instance.
     *
     * @param string $tableClassName Table entity class name
     * @return string Generated PHP method code
     */
    protected function generateEntityTableMethod($tableClassName)
    {
        $code = "\n\t" . '/**';
        $code .= "\n\t" . ' * Create '.$tableClassName.' instance.';
        $code .= "\n\t" . ' * @param ViewInterface $renderer Renderer';
        $code .= "\n\t" . ' * @param string $locale Locale';
        $code .= "\n\t" . ' * @return '.$tableClassName.'Query Instance of entity table';
        $code .= "\n\t" . ' */';
        $code .= "\n\t" . 'public function ' . lcfirst($tableClassName) . '(ViewInterface $renderer = null, $locale = null)';
        $code .= "\n\t" . "{";
        $code .= "\n\t\t" . 'return new '.$tableClassName.'($this->query, $renderer, $this->id, $locale);';

        return $code . "\n\t" . "}"."\n";
    }

    /**
     * Generate entity classes.
     *
     * @param string $namespace Base namespace for generated classes
     *
     * @return string Generated PHP code for entity classes
     * @throws ParentEntityNotFound
     * @throws \samsoncms\api\exception\AdditionalFieldTypeNotFound
     */
    public function createEntityClasses($namespace = __NAMESPACE__)
    {
        $classes = "\n" . 'namespace ' . $namespace . '\\generated;';
        $classes .= "\n";
        $classes .= "\n" . 'use ' . $namespace . '\field\Row;';
        $classes .= "\n" . 'use \samsoncms\api\Entity;';
        $classes .= "\n" . 'use \samsonframework\core\ViewInterface;';
        $classes .= "\n" . 'use \samsonframework\orm\ArgumentInterface;';
        $classes .= "\n" . 'use \samsonframework\orm\QueryInterface;';
        $classes .= "\n" . 'use \samson\activerecord\dbQuery;';
        $classes .= "\n";

        // Iterate all entities metadata
        foreach ($this->metadata as $metadata) {
            // Generate classes of default type
            if ($metadata->type === Metadata::TYPE_DEFAULT) {
                // Generate entity class
                $classes .= $this->createEntityClass($metadata);
                // Generate query class for queries
                $classes .= $this->createQueryClass($metadata);
                // Generate collection class for rendering
                $classes .= $this->createCollectionClass(
                    $metadata,
                    $this->fullEntityName($metadata->entity . 'Query', $namespace),
                    array(\samsoncms\api\Renderable::class)
                );

                // Generate Gallery classes for this entity
                $classes .= $this->createGalleryClass($metadata);

                // Generate classes of table type
            } elseif ($metadata->type === Metadata::TYPE_TABLE) {
                $classes .= $this->createTableRowClass($metadata);
                $classes .= $this->createQueryClass($metadata, '\samsoncms\api\query\EntityTable' , array(), $namespace, $metadata->entity.'Row');

Space found before comma in function call

                $classes .= $this->createTableClass($metadata);
            }
        }

        // Make correct code formatting
        return $this->formatTab($classes);
    }

    /**
     * Create entity PHP class code.
     *
     * @param Metadata $metadata  Entity metadata
     * @param string   $namespace Namespace of generated class
     * @return string Generated entity query PHP class code
     */
    protected function createEntityClass(Metadata $metadata, $namespace = __NAMESPACE__)
    {
        /**
         * TODO: Parent problem
         * Should be changed to merging fields instead of extending with OOP for structure_relation support
         * or creating traits and using them on shared parent entities.
         */

        $this->generator
            ->multiComment(array('"' . $metadata->entityRealName . '" entity class'))
            ->defClass($metadata->entity, null !== $metadata->parent ? $this->fullEntityName($metadata->parent->entity, $namespace) : 'Entity')
            ->commentVar('string', '@deprecated Entity full class name, use ::class')
            ->defClassConst('ENTITY', $this->fullEntityName($metadata->entity, $namespace))
            ->commentVar('string', 'Entity manager full class name')
            ->defClassConst('MANAGER', $this->fullEntityName($metadata->entity, $namespace) . 'Query')
            ->commentVar('string', 'Entity database identifier')
            ->defClassConst('IDENTIFIER', $metadata->entityID)
            ->commentVar('string', 'Not transliterated entity name')
            ->defClassVar('$viewName', 'protected static', $metadata->entityRealName);

        foreach ($metadata->allFieldIDs as $fieldID => $fieldName) {
            $this->generator
                ->commentVar('string', $metadata->fieldDescriptions[$fieldID] . ' variable name')
                ->defClassConst('F_' . $fieldName, $fieldName)
                ->commentVar('string', $metadata->fieldDescriptions[$fieldID] . ' additional field identifier')
                ->defClassConst('F_' . $fieldName . '_ID', $fieldID)
                ->commentVar($metadata->allFieldTypes[$fieldID], $metadata->fieldDescriptions[$fieldID])
                ->defClassVar('$' . $fieldName, 'public');
        }

        /** Iterate all metadata to find nested structure tables */
        foreach ($this->metadata as $structureID => $tableMetadata) {
            // Check if this is nested table structure metadata
            if ($tableMetadata->parentID === $metadata->entityID && $tableMetadata->type === Metadata::TYPE_TABLE) {

The strict comparison === seems to always evaluate to false as the types of $tableMetadata->parentID (integer) and $metadata->entityID (string) can never be identical. Maybe you want to use a loose comparison == instead?

                $this->generator->text($this->generateEntityTableMethod($tableMetadata->entity));
            }
        }

        return $this->generator
            ->commentVar('array', 'Collection of navigation identifiers')
            ->defClassVar('$navigationIDs', 'protected static', array($metadata->entityID))
            ->defClassVar('$_sql_select', 'public static ', $metadata->arSelect)
            ->defClassVar('$_attributes', 'public static ', $metadata->arAttributes)
            ->defClassVar('$_map', 'public static ', $metadata->arMap)
            ->defClassVar('$_sql_from', 'public static ', $metadata->arFrom)
            ->defClassVar('$_own_group', 'public static ', $metadata->arGroup)
            ->defClassVar('$_relation_alias', 'public static ', $metadata->arRelationAlias)
            ->defClassVar('$_relation_type', 'public static ', $metadata->arRelationType)
            ->defClassVar('$_relations', 'public static ', $metadata->arRelations)
            ->defClassVar('$fieldIDs', 'protected static ', $metadata->allFieldIDs)
            ->defClassVar('$fieldValueColumns', 'protected static ', $metadata->allFieldValueColumns)
            ->endClass()
            ->flush();
    }

    /**
     * Create entity query PHP class code.
     *
     * @param Metadata $metadata      Entity metadata
     * @param string   $defaultParent Parent class name
     * @param array    $use           Collection of traits
     * @param string   $namespace     Namespace of generated class
     * @param string   $returnClass   Query methods return class
     *
     * @return string Generated entity query PHP class code
     */
    protected function createQueryClass(Metadata $metadata, $defaultParent = '\samsoncms\api\query\Entity', $use = array(), $namespace = __NAMESPACE__, $returnClass = null)
    {
        $this->generateQuerableClassHeader($metadata, 'Query', $defaultParent, $use, $namespace, $returnClass);

        foreach ($metadata->allFieldIDs as $fieldID => $fieldName) {
            // TODO: Add different method generation depending on their field type
            $this->generator->text($this->generateFieldConditionMethod(
                $fieldName,
                $fieldID,
                $metadata->allFieldTypes[$fieldID]
            ));
        }

        return $this->generator
            ->commentVar('array', 'Collection of real additional field names')
            ->defClassVar('$fieldRealNames', 'public static', $metadata->realNames)
            ->commentVar('array', 'Collection of additional field names')
            ->defClassVar('$fieldNames', 'public static', $metadata->allFieldNames)
            // TODO: two above fields should be protected
            ->commentVar('array', 'Collection of navigation identifiers')
            ->defClassVar('$navigationIDs', 'protected static', array($metadata->entityID))
            ->commentVar('string', 'Entity full class name')
            ->defClassVar('$identifier', 'protected static', $this->fullEntityName($metadata->entity, $namespace))
            ->commentVar('array', 'Collection of localized additional fields identifiers')
            ->defClassVar('$localizedFieldIDs', 'protected static', $metadata->localizedFieldIDs)
            ->commentVar('array', 'Collection of NOT localized additional fields identifiers')
            ->defClassVar('$notLocalizedFieldIDs', 'protected static', $metadata->notLocalizedFieldIDs)
            ->commentVar('array', 'Collection of localized additional fields identifiers')
            ->defClassVar('$fieldIDs', 'protected static', $metadata->allFieldIDs)
            ->commentVar('array', 'Collection of additional fields value column names')
            ->defClassVar('$fieldValueColumns', 'protected static', $metadata->allFieldValueColumns)
            ->endClass()
            ->flush();
    }

    /**
     * Start quearable class declaration.
     *
     * @param Metadata $metadata      Entity metadata
     * @param string   $suffix        Entity class name suffix
     * @param string   $defaultParent Parent class name
     * @param array    $use           Collection of traits
     * @param string   $namespace     Namespace of generated class
     * @param string   $returnClass   Query methods return class
     */
    protected function generateQuerableClassHeader(Metadata $metadata, $suffix, $defaultParent, $use, $namespace = __NAMESPACE__, $returnClass = null)
    {
        $returnClass = null === $returnClass ? $this->fullEntityName($metadata->entity, $namespace) : $returnClass;

        $this->generator
            ->multiComment(array(
                'Class for fetching "' . $metadata->entityRealName . '" instances from database',
                '@method ' . $returnClass . ' first();',
                '@method ' . $returnClass . '[] find();',
            ))
            ->defClass($metadata->entity . $suffix, $defaultParent);


        // Add traits to generated classes
        $this->generateTraitsUsage($use);
    }

    /**
     * Generate class traits usage.
     *
     * @param array $use Collection of trait names
     */
    protected function generateTraitsUsage($use = array())
    {
        // Add traits to generated classes
        foreach ($use as $trait) {
            $this->generator->newLine();
            $this->generator->tabs('use \\' . ltrim($trait, '\\') . ';');
        }
        $this->generator->newLine();
    }

    /**
     * Generate Query::where() analog for specific field.
     *
     * @param string $fieldName Field name
     * @param string $fieldId Field primary identifier
     * @param string $fieldType Field PHP type
     * @return string Generated PHP method code
     */
    protected function generateFieldConditionMethod($fieldName, $fieldId, $fieldType)
    {
        $code = "\n\t" . '/**';
        $code .= "\n\t" . ' * Add '.$fieldName.'(#' . $fieldId . ') field query condition.';
        $code .= "\n\t" . ' * @param ' . $fieldType . ' $value Field value';
        $code .= "\n\t" . ' * @return $this Chaining';
        $code .= "\n\t" . ' * @see Generic::where()';
        $code .= "\n\t" . ' */';
        $code .= "\n\t" . 'public function ' . $fieldName . '($value, $relation = ArgumentInterface::EQUAL)';
        $code .= "\n\t" . "{";
        $code .= "\n\t\t" . 'return $this->where("' . $fieldName . '", $value, $relation);';

        return $code . "\n\t" . "}"."\n";
    }

    /**
     * Create entity collection PHP class code.
     *
     * @param Metadata $metadata      Entity metadata
     * @param string   $suffix        Generated class name suffix
     * @param string   $defaultParent Parent class name
     * @param array    $use           Collection of traits
     * @param string   $namespace     Namespace of generated class
     *
     * @return string Generated entity query PHP class code
     */
    protected function createCollectionClass(Metadata $metadata, $defaultParent, $use = array(), $suffix = 'Collection', $namespace = __NAMESPACE__)

The parameter $suffix is not used and could be removed.

    {
        $this->generateQuerableClassHeader($metadata, 'Collection', $defaultParent, $use, $namespace);

        return $this->generator
            ->text($this->generateConstructorCollectionClass())
            ->endClass()
            ->flush();
    }

    /**
     * Generate constructor for collection class.
     */
    protected function generateConstructorCollectionClass()

This method seems to be duplicated in your project.

    {
        $class = "\n\t".'/**';
        $class .= "\n\t".' * @param ViewInterface $renderer Rendering instance';
        $class .= "\n\t" . ' * @param QueryInterface $query Database query instance';
        $class .= "\n\t".' * @param string $locale Localization identifier';
        $class .= "\n\t".' */';
        $class .= "\n\t" . 'public function __construct(ViewInterface $renderer, QueryInterface $query = null, $locale = null)';
        $class .= "\n\t".'{';
        $class .= "\n\t\t" . '$this->renderer = $renderer;';
        $class .= "\n\t\t" . 'parent::__construct(isset($query) ? $query : new dbQuery(), $locale);';
        $class .= "\n\t".'}'."\n";

        return $class;
    }

    /**
     * Generate classes for entity additional field gallery.
     *
     * @param Metadata $metadata Entity metadata
     *
     * @return string Generated Gallery additional field class
     */
    public function createGalleryClass(Metadata $metadata)
    {
        // Iterate entity additional fields
        foreach ($metadata->allFieldCmsTypes as $fieldID => $fieldType) {
            // We need only gallery fields
            if ($fieldType === Field::TYPE_GALLERY) {
                $fieldName = $metadata->allFieldIDs[$fieldID];
                // Declare class
                $this->generateQuerableClassHeader(
                    $metadata,
                    ucfirst($fieldName) . 'Gallery',
                    '\\' . \samsoncms\api\Gallery::class,
                    array(\samsoncms\api\Renderable::class)
                );

                return $this->generator
                    ->text($this->generateConstructorGalleryClass(
                        $metadata->entity . '::F_' . strtoupper($fieldName) . '_ID',
                        $metadata->entity
                    ))
                    ->endClass()
                    ->flush();
            }
        }


    }

    /**
     * Generate constructor for gallery class.
     */
    protected function generateConstructorGalleryClass($fieldID, $entityType)
    {
        $class = "\n\t" . '/**';
        $class .= "\n\t" . ' * @param ViewInterface $renderer Rendering instance';
        $class .= "\n\t" . ' * @param ' . $entityType . ' $entity Parent entity';
        $class .= "\n\t" . ' * @param QueryInterface $query Database query instance';
        $class .= "\n\t" . ' */';
        $class .= "\n\t" . 'public function __construct(ViewInterface $renderer, ' . $entityType . ' $entity, QueryInterface $query = null)';
        $class .= "\n\t" . '{';
        $class .= "\n\t\t" . '$this->renderer = $renderer;';
        $class .= "\n\t\t" . 'parent::__construct(isset($query) ? $query : new dbQuery(), $entity->id, ' . $fieldID . ');';
        $class .= "\n\t" . '}' . "\n";

        return $class;
    }

    /**
     * Create fields table row PHP class code.
     *
     * @param Metadata $metadata metadata of entity
     * @param string $namespace Namespace of generated class
     *
     * @return string Generated entity query PHP class code
     * @throws exception\AdditionalFieldTypeNotFound
     */
    protected function createTableRowClass(Metadata $metadata, $namespace = __NAMESPACE__)

The parameter $namespace is not used and could be removed.

    {
        $this->generator
            ->multiComment(array('Class for getting "' . $metadata->entityRealName . '" fields table rows'))
            ->defClass($metadata->entity . 'Row', 'Row');

        $fieldIDs = array();
        foreach ($this->navigationFields($metadata->entityID) as $fieldID => $fieldRow) {
            $fieldName = $this->fieldName($fieldRow['Name']);

            // Fill field ids array
            $fieldIDs[$fieldName] = $fieldID;

            $this->generator
                ->commentVar($metadata->allFieldTypes[$fieldID], $fieldRow['Description'] . ' Field #' . $fieldID . ' variable name')
                ->defClassConst('F_' . strtoupper($fieldName), $fieldName)
                ->commentVar($metadata->allFieldTypes[$fieldID], $fieldRow['Description'] . ' Field #' . $fieldID . ' row value')
                ->defVar('public $' . $fieldName)
                ->text("\n");
        }

        return $this->generator
            ->commentVar('array', 'Collection of additional fields identifiers')
            ->defClassVar('$fieldIDs', 'public static', $fieldIDs)
            ->endClass()
            ->flush();
    }

    /**
     * Create fields table PHP class code.
     *
     * @param Metadata $metadata metadata of entity
     * @param string $namespace Namespace of generated class
     * @return string Generated entity query PHP class code
     * @throws exception\AdditionalFieldTypeNotFound
     */
    protected function createTableClass(Metadata $metadata, $namespace = __NAMESPACE__)

The parameter $namespace is not used and could be removed.

    {
        $this->generator
            ->multiComment(array('Class for getting "'.$metadata->entityRealName.'" fields table'))
            ->defClass($metadata->entity, '\samsoncms\api\field\Table');

        // Add renderable trait
        $this->generateTraitsUsage(array(\samsoncms\api\Renderable::class));

        // Iterate additional fields
        $fields = array();
        foreach ($this->navigationFields($metadata->entityID) as $fieldID => $fieldRow) {
            $fieldName = $this->fieldName($fieldRow['Name']);

            $this->generator
                ->text($this->generateTableFieldMethod(
                    $fieldName,
                    $fieldRow[Field::F_PRIMARY],
                    $fieldRow[Field::F_TYPE]
                ))
                ->commentVar($metadata->allFieldTypes[$fieldID], $fieldRow['Description'] . ' Field #' . $fieldID . ' variable name')
                ->defClassConst('F_' . $fieldName, $fieldName);

            // Collection original to new one field names
            $fields[$fieldRow['Name']] = $fieldName;
        }

        return $this->generator
            ->text($this->generateConstructorTableClass())
            ->commentVar('string', 'Entity database identifier')
            ->defClassConst('IDENTIFIER', $metadata->entityID)
            ->commentVar('array', 'Collection of real additional field names')
            ->defClassVar('$fieldsRealNames', 'public static', $fields)
            ->commentVar('array', 'Collection of navigation identifiers')
            ->defClassVar('$navigationIDs', 'protected static', array($metadata->entityID))
            ->commentVar('string', 'Row class name')
            ->defClassVar('$identifier', 'protected', $this->fullEntityName($this->entityName($metadata->entityRealName) . 'TableRow'))
            ->endClass()
            ->flush();
    }

    /**
     * Generate FieldsTable::values() analog for specific field.
     *
     * @param string $fieldName Field name
     * @param string $fieldId   Field primary identifier
     * @param string $fieldType Field PHP type
     *
     * @return string Generated PHP method code
     */
    protected function generateTableFieldMethod($fieldName, $fieldId, $fieldType)
    {
        $code = "\n\t" . '/**';
        $code .= "\n\t" . ' * Get table column ' . $fieldName . '(#' . $fieldId . ') values.';
        $code .= "\n\t" . ' * @return array Collection(' . Field::phpType($fieldType) . ') of table column values';
        $code .= "\n\t" . ' */';
        $code .= "\n\t" . 'public function ' . $fieldName . '()';
        $code .= "\n\t" . "{";
        $code .= "\n\t\t" . 'return $this->values(' . $fieldId . ');';

        return $code . "\n\t" . "}" . "\n";
    }

    /**
     * Generate constructor for table class.
     */
    protected function generateConstructorTableClass()

This method seems to be duplicated in your project.

    {
        $class = "\n\t" . '/**';
        $class .= "\n\t" . ' * @param QueryInterface $query Database query instance';
        $class .= "\n\t" . ' * @param ViewInterface $renderer Rendering instance';
        $class .= "\n\t" . ' * @param integer $entityID Entity identifier to whom this table belongs';
        $class .= "\n\t" . ' * @param string $locale Localization identifier';
        $class .= "\n\t" . ' */';
        $class .= "\n\t" . 'public function __construct(QueryInterface $query, ViewInterface $renderer, $entityID, $locale = null)';
        $class .= "\n\t" . '{';
        $class .= "\n\t\t" . '$this->renderer = $renderer;';
        $class .= "\n\t\t" . 'parent::__construct($query, static::$navigationIDs, $entityID, $locale);';
        $class .= "\n\t" . '}' . "\n";

        return $class;
    }

    /**
     * Generate Query::where() analog for specific field.
     *
     * @param string $fieldName Field name
     * @param string $fieldId   Field primary identifier
     * @param string $fieldType Field PHP type
     *
     * @return string Generated PHP method code
     */
    protected function generateLocalizedFieldConditionMethod($fieldName, $fieldId, $fieldType)
    {
        $code = "\n\t" . '/**';
        $code .= "\n\t" . ' * Add ' . $fieldName . '(#' . $fieldId . ') field query condition.';
        $code .= "\n\t" . ' * @param ' . Field::phpType($fieldType) . ' $value Field value';
        $code .= "\n\t" . ' * @return $this Chaining';
        $code .= "\n\t" . ' * @see Generic::where()';
        $code .= "\n\t" . ' */';
        $code .= "\n\t" . 'public function ' . $fieldName . '($value)';
        $code .= "\n\t" . "{";
        $code .= "\n\t\t" . 'return $this->where("' . $fieldName . '", $value);';

        return $code . "\n\t" . "}" . "\n";
    }

    /**
     * Generate constructor for application class.
     */
    protected function generateConstructorApplicationClass()

This method seems to be duplicated in your project.

    {
        $class = "\n\t" . '/**';
        $class .= "\n\t" . ' * Render materials list with pager';
        $class .= "\n\t" . ' *';
        $class .= "\n\t" . ' * @param string $navigationId Structure identifier';
        $class .= "\n\t" . ' * @param string $search Keywords to filter table';
        $class .= "\n\t" . ' * @param int $page Current table page';
        $class .= "\n\t" . ' * @return array Asynchronous response containing status and materials list with pager on success';
        $class .= "\n\t" . ' * or just status on asynchronous controller failure';
        $class .= "\n\t" . ' */';
        $class .= "\n\t" . 'public function __async_collection($navigationId = \'0\', $search = \'\', $page = 1)';
        $class .= "\n\t" . '{';
        $class .= "\n\t\t" . 'return parent::__async_collection(self::$navigation, $search, $page);';
        $class .= "\n\t" . '}' . "\n";

        return $class;
    }

    /**
     * Generate constructor for application class.
     */
    protected function generateConstructorApplicationCollectionClass()

This method seems to be duplicated in your project.

    {
        $class = "\n\t" . '/**';
        $class .= "\n\t" . ' * Generic collection constructor';
        $class .= "\n\t" . ' *';
        $class .= "\n\t" . ' * @param RenderInterface $renderer View render object';
        $class .= "\n\t" . ' * @param QueryInterface $query Query object';
        $class .= "\n\t" . ' */';
        $class .= "\n\t" . 'public function __async_collection($renderer, $query = null, $pager = null)';
        $class .= "\n\t" . '{';
        $class .= "\n\t\t" . 'return parent::__async_collection($renderer, $query = null, $pager = null);';
        $class .= "\n\t\t" . '$this->fields = array(';
        $class .= "\n\t\t\t" . 'new Control(),';
        $class .= "\n\t\t" . ');';
        $class .= "\n\t" . '}' . "\n";

        return $class;
    }
}
//[PHPCOMPRESSOR(remove,end)]