Nette PHP Generator

https://github.com/nette/php-generator
Admin
Nette PHP Generator is a library for programmatically generating PHP code, including classes,...
Tokens:41,597
Snippets:604
Trust Score:9.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Method Chaining Example

Source: https://github.com/nette/php-generator/blob/master/_autodocs/README.md

Demonstrates the fluent interface pattern where methods return static to allow sequential configuration.

```php
$class->addProperty('id', 1)
    ->setPrivate()
    ->setType('int')
    ->setInitialized();
```

--------------------------------

### Install Nette PHP Generator using Composer

Source: https://github.com/nette/php-generator/blob/master/readme.md

Download and install the library using the Composer tool. This command ensures you have the latest version compatible with your project.

```shell
composer require nette/php-generator
```

--------------------------------

### Usage of PsrPrinter

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Printer.md

Example of using PsrPrinter to output code with PSR-compliant formatting.

```php
use Nette\PhpGenerator\PsrPrinter;

$printer = new PsrPrinter();
echo $printer->printClass($class);
```

--------------------------------

### Custom Printer Configuration

Source: https://github.com/nette/php-generator/blob/master/readme.md

Provides an example of creating a custom printer by extending the base Printer class and overriding properties to customize code formatting.

```php
class MyPrinter extends Nette\PhpGenerator\Printer
{
	// length of the line after which the line will break
	public int $wrapLength = 120;
	// indentation character, can be replaced with a sequence of spaces
	public string $indentation = "\t";
	// number of blank lines between properties
	public int $linesBetweenProperties = 0;
	// number of blank lines between methods
	public int $linesBetweenMethods = 2;
	// number of blank lines between 'use statements' groups for classes, functions, and constants
	public int $linesBetweenUseTypes = 0;
	// position of the opening curly brace for functions and methods
	public bool $bracesOnNextLine = true;
	// place one parameter on one line, even if it has an attribute or is supported
	public bool $singleParameterOnOneLine = false;
	// omits namespaces that do not contain any class or function
	public bool $omitEmptyNamespaces = true;
	// separator between the right parenthesis and return type of functions and methods
	public string $returnTypeColon = ': ';
}
```

--------------------------------

### Function Generation with Named Variadic Placeholder

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates using the named variadic placeholder '...?:' for PHP 8 named argument expansion from an array, with a commented-out example of the output.

```php
$items = ['foo' => 1, 'bar' => true];
$function->setBody('myfunc(...?:);', [$items]);

// myfunc(foo: 1, bar: true);
```

--------------------------------

### Get All Hooks

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Returns an array of all defined hooks keyed by type.

```php
public function getHooks(): array
```

--------------------------------

### Generate GlobalFunction with Body from Existing Function

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates generating a GlobalFunction object from an existing function, including its body, provided the 'nikic/php-parser' package is installed.

```PHP
$function = Nette\PhpGenerator\GlobalFunction::from('foo', withBody: true);
```

--------------------------------

### PHP Class with Abstract and Final Property Hooks

Source: https://github.com/nette/php-generator/blob/master/readme.md

Shows how to define abstract and final property hooks for 'get' and 'set' operations on class properties.

```php
$class->addProperty('id')
    ->setType('int')
    ->addHook('get')
        ->setAbstract();

$class->addProperty('role')
    ->setType('string')
    ->addHook('set', 'strtolower($value)')
        ->setFinal();
```

--------------------------------

### Generate ClassType with Body from Existing Class

Source: https://github.com/nette/php-generator/blob/master/readme.md

Shows how to generate a ClassType object from an existing class, including its method bodies, provided the 'nikic/php-parser' package is installed.

```PHP
$class = Nette\PhpGenerator\ClassType::from(Foo::class, withBodies: true);
```

--------------------------------

### Generated PHP Class with Property Hooks

Source: https://github.com/nette/php-generator/blob/master/readme.md

The resulting PHP code demonstrating property hooks for setting and getting, including abstract and final modifiers.

```php
class Demo
{
    public string $firstName {
        set(string $value) => strtolower($value);
        get {
            return ucfirst($this->firstName);
        }
    }
}
```

--------------------------------

### Create and configure a global function

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/GlobalFunction.md

Demonstrates how to instantiate a GlobalFunction, add documentation comments, define parameters with types, and set the function body.

```php
use Nette\PhpGenerator\GlobalFunction;

$func = new GlobalFunction('formatPrice');
$func->addComment('Formats price with currency symbol');
$func->addComment('@param float $price Price amount');
$func->addComment('@param string $currency Currency code');
$func->addComment('@return string Formatted price');

$func->addParameter('price')->setType('float');
$func->addParameter('currency', 'USD')->setType('string');
$func->setReturnType('string');

$func->setBody(<<<'PHP'
    $symbols = ['USD' => '$', 'EUR' => '€', 'GBP' => '£'];
    $symbol = $symbols[$currency] ?? $currency;
    return sprintf('%s%.2f', $symbol, $price);
    PHP
);

echo $func;
```

--------------------------------

### Full usage pattern

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/PhpFile.md

Demonstrates the typical workflow for creating a file, adding namespaces, classes, properties, and methods.

```php
use Nette\PhpGenerator\PhpFile;

$file = new PhpFile();
$file->setStrictTypes();
$file->addComment('This file is auto-generated');

$namespace = $file->addNamespace('App');
$class = $file->addClass('App\UserService');
$class->addProperty('db')->setPrivate();

$method = $class->addMethod('getUser');
$method->addParameter('id', 0)->setType('int');
$method->setReturnType('?array');
$method->setBody('return $this->db->find($id);');

echo $file; // outputs complete PHP file
```

--------------------------------

### PHP Class with Property Hooks (Set and Get)

Source: https://github.com/nette/php-generator/blob/master/readme.md

Defines property hooks for 'set' and 'get' operations on a class property, including parameter and body definitions.

```php
$class = new Nette\PhpGenerator\ClassType('Demo');
$prop = $class->addProperty('firstName')
    ->setType('string');

$prop->addHook('set', 'strtolower($value)')
    ->addParameter('value')
	    ->setType('string');

$prop->addHook('get')
	->setBody('return ucfirst($this->firstName);');

echo $class;
```

--------------------------------

### Get All Attributes

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Retrieves an array of all attributes assigned to the property.

```php
public function getAttributes(): array
```

--------------------------------

### Constructor Promotion in PHP

Source: https://github.com/nette/php-generator/blob/master/_autodocs/ADVANCED-USAGE.md

Demonstrates basic constructor promotion and setting visibility for promoted parameters.

```php
$construct = $class->addMethod('__construct');

$name = $construct->addPromotedParameter('name');
$name->setType('string');
$name->setPublic(); // default

$age = $construct->addPromotedParameter('age', 0);
$age->setType('int');
$age->setPrivate();

// Output:
// public function __construct(
//     public string $name,
//     private int $age = 0,
// ) {}
```

```php
$construct->addPromotedParameter('id')->setType('int')->setPublic();
$construct->addPromotedParameter('secret')->setType('string')->setPrivate();
$construct->addPromotedParameter('config')->setType('array')->setProtected();

// Output: public int $id, private string $secret, protected array $config
```

--------------------------------

### Configure Complete PHP File

Source: https://github.com/nette/php-generator/blob/master/_autodocs/configuration.md

Demonstrates setting strict types, adding comments, namespaces, and imports before printing with PsrPrinter.

```php
use Nette\PhpGenerator\PhpFile;
use Nette\PhpGenerator\PsrPrinter;

$file = new PhpFile();
$file->setStrictTypes();
$file->addComment("Generated file - do not edit manually\nLicense: MIT");

$ns = $file->addNamespace('App\Generated');
$ns->addUse('DateTime');
$ns->addUse('Doctrine\ORM\EntityManager', 'EM');

$class = $file->addClass('App\Generated\User');
// ... configure class ...

$printer = new PsrPrinter();
echo $printer->printFile($file);
```

--------------------------------

### Get Property Name

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Retrieves the current name of the property.

```php
public function getName(): string
```

--------------------------------

### Create a PHP file with PhpFile

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Initializes a new PHP file structure with strict types and a namespace.

```php
use Nette\PhpGenerator\PhpFile;

$file = new PhpFile();
$file->setStrictTypes();

$namespace = $file->addNamespace('App');
$class = $file->addClass('App\UserService');
// ... configure class ...

echo $file;
```

--------------------------------

### Get Property Hook

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Retrieves a specific hook by type.

```php
public function getHook(PropertyHookType|string $type): ?PropertyHook
```

--------------------------------

### Create a PHP File with Class and Function

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates creating a PHP file object, adding comments, setting strict types, and adding classes and functions to it.

```PHP
$file = new Nette\PhpGenerator\PhpFile();
$file->addComment('This file is auto-generated.');
$file->setStrictTypes(); // adds declare(strict_types=1)

$class = $file->addClass('Foo\A');
$function = $file->addFunction('Foo\foo');

// or
// $namespace = $file->addNamespace('Foo');
// $class = $namespace->addClass('A');
// $function = $namespace->addFunction('foo');

echo $file;
```

--------------------------------

### Generate PHP Code with Nette

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Demonstrates the basic workflow of creating a PHP file, adding a namespace, defining a class with properties and methods, and printing the result.

```php
use Nette\PhpGenerator\PhpFile;
use Nette\PhpGenerator\PsrPrinter;

$file = new PhpFile();
$file->setStrictTypes();

$ns = $file->addNamespace('App\Services');
$ns->addUse('DateTime');

$class = $file->addClass('App\Services\UserService');
$class->addProperty('db')->setPrivate()->setType('PDO');

$method = $class->addMethod('getUser');
$method->addParameter('id')->setType('int');
$method->setReturnType('?array');
$method->setBody('return $this->db->query("SELECT * FROM users WHERE id = ?", [$id])->fetch();');

$printer = new PsrPrinter();
echo $printer->printFile($file);
```

```php
<?php
declare(strict_types=1);

namespace App\Services;

use DateTime;

class UserService
{
    private PDO $db;

    public function getUser(int $id): ?array
    {
        return $this->db->query("SELECT * FROM users WHERE id = ?", [$id])->fetch();
    }
}
```

--------------------------------

### Get Visibility

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Retrieves the visibility string for a specific access mode.

```php
public function getVisibility(PropertyAccessMode|string $mode = PropertyAccessMode::Get): ?string
```

--------------------------------

### Add Property Hook

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Adds a get or set hook for PHP 8.4+ properties.

```php
public function addHook(PropertyHookType|string $type, string $shortBody = ''): PropertyHook
```

```php
$prop->addHook('get', '$this->_name ?? "N/A"');
$prop->addHook('set', '$this->_name = $value')->setBody('$this->_name = strtoupper($value);');
```

--------------------------------

### Define and configure constants

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Constant.md

Demonstrates creating multiple constants with various types, visibility modifiers, and comments.

```php
use Nette\PhpGenerator\Constant;

$const1 = new Constant('MAX_RETRIES');
$const1->setValue(3);
$const1->setType('int');
$const1->addComment('Maximum retry attempts');

$const2 = new Constant('DEFAULT_TIMEOUT');
$const2->setValue(30);
$const2->setType('int');
$const2->setPublic();

$const3 = new Constant('CONFIG_PATH');
$const3->setValue('/etc/config');
$const3->setType('string');
$const3->setPrivate();
$const3->setFinal();
$const3->addComment('Configuration file path');

$const4 = new Constant('ALLOWED_ROLES');
$const4->setValue(['admin', 'user', 'guest']);
$const4->setType('array');
$const4->setProtected();

echo $const1;
```

--------------------------------

### Create a Basic Class with Nette PHP Generator

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates how to create a new class named 'Demo' with modifiers like final, extends, and implements. It also shows how to add comments and properties.

```php
$class = new Nette\PhpGenerator\ClassType('Demo');

$class
	->setFinal()
	->setExtends(ParentClass::class)
	->addImplement(Countable::class)
	->addComment("Class description.\nSecond line\n")
	->addComment('@property-read Nette\Forms\Form $form');

// generate code simply by typecasting to string or using echo:
echo $class;
```

--------------------------------

### Generate a Filter Callback

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Closure.md

A simple example of defining a closure intended for use as a filter callback.

```php
use Nette\PhpGenerator\Closure;

$filter = new Closure();
$filter->addParameter('value');
$filter->setReturnType('bool');
$filter->setBody('return $value > 0;');

// This becomes: function ($value): bool { return $value > 0; }
```

--------------------------------

### Define PropertyHookType Enum

Source: https://github.com/nette/php-generator/blob/master/_autodocs/types.md

Specifies the type of property hook (get or set) for PHP 8.4+ features.

```php
enum PropertyHookType: string
{
    case Set = 'set';
    case Get = 'get';
}
```

--------------------------------

### Printer Constructor

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Printer.md

Initializes a new Printer instance with default configuration settings.

```php
public function __construct()
```

```php
$printer = new Printer();
$printer->wrapLength = 100;
```

--------------------------------

### Use bracketed namespace syntax

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/PhpNamespace.md

Shows how to handle multiple namespaces in a single file using the bracketed syntax.

```php
$file = new PhpFile();

$ns1 = $file->addNamespace('First');
$ns1->add($class1);

$ns2 = $file->addNamespace('Second');
$ns2->add($class2);

echo $file;
// Outputs:
// <?php
// namespace First {
//     class ClassName { ... }
// }
// namespace Second {
//     class OtherClass { ... }
// }
```

--------------------------------

### Get PHPDoc Comment

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Retrieves the property's PHPDoc comment, returning null if none is set.

```php
public function getComment(): ?string
```

--------------------------------

### Create a Single Class

Source: https://github.com/nette/php-generator/blob/master/_autodocs/README.md

Demonstrates how to instantiate a ClassType and add a private string property.

```php
use Nette\PhpGenerator\ClassType;

$class = new ClassType('User');
$class->addProperty('name')->setPrivate()->setType('string');
echo $class;
```

--------------------------------

### Set property visibility

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Configure public visibility for specific access modes like get or set.

```php
$prop->setPublic();
$prop->setPublic('get')->setPrivate('set');
```

--------------------------------

### Create a new Property instance

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Initialize a new property object by specifying its name.

```php
$prop = new Property('name');
```

--------------------------------

### Set Asymmetric Visibility

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Configures asymmetric visibility for get and set access modes, available in PHP 8.4+.

```php
public function setVisibility(Visibility|string|null $get, Visibility|string|null $set = null): static
```

```php
$prop->setVisibility('public', 'private');
```

--------------------------------

### Define a namespace and its contents

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/PhpNamespace.md

Demonstrates creating a namespace, adding use statements, and defining classes and functions within that context.

```php
use Nette\PhpGenerator\PhpNamespace;
use Nette\PhpGenerator\ClassType;

$ns = new PhpNamespace('App\Services');

// Add use statements
$ns->addUse('Doctrine\ORM\EntityManager', 'EM');
$ns->addUse('DateTime');
$ns->addUse('ArrayIterator');

// Add a class
$class = $ns->addClass('UserService');
$class->addProperty('db')->setPrivate()->setType('EM');

// Add a function
$func = $ns->addFunction('formatDate');
$func->addParameter('date')->setType('DateTime');
$func->setReturnType('string');
$func->setBody('return $date->format("Y-m-d");');

// Simplify types using namespace context
echo $ns->simplifyType('App\Services\UserService'); // 'UserService'
echo $ns->simplifyType('DateTime'); // 'DateTime'
echo $ns->simplifyType('Doctrine\ORM\EntityManager'); // 'EM'

echo $ns;
```

--------------------------------

### Create Method Instance

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Method.md

Instantiate a new Method object by providing the method name.

```php
$method = new Method('getName');
```

--------------------------------

### Create Interface and Trait Types

Source: https://github.com/nette/php-generator/blob/master/readme.md

Shows how to instantiate InterfaceType and TraitType objects for defining interfaces and traits.

```php
$interface = new Nette\PhpGenerator\InterfaceType('MyInterface');
$trait = new Nette\PhpGenerator\TraitType('MyTrait');
```

--------------------------------

### Creating a PHP Trait with Properties and Methods

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/TraitType.md

Demonstrates initializing a TraitType, adding protected properties with types, and defining methods with custom bodies.

```php
use Nette\PhpGenerator\TraitType;

$trait = new TraitType('TimestampTrait');
$trait->addComment('Provides timestamp behavior for models');

$trait->addProperty('createdAt', null)
    ->setProtected()
    ->setType('?DateTime');

$trait->addProperty('updatedAt', null)
    ->setProtected()
    ->setType('?DateTime');

$initMethod = $trait->addMethod('initializeTimestamps');
$initMethod->setProtected();
$initMethod->setBody(<<<'PHP'
    $this->createdAt = new DateTime();
    $this->updatedAt = new DateTime();
    PHP
);

$updateMethod = $trait->addMethod('updateTimestamp');
$updateMethod->setProtected();
$updateMethod->setBody('$this->updatedAt = new DateTime();');

echo $trait;
```

--------------------------------

### ClassType Usage Pattern

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/ClassType.md

Demonstrates how to instantiate a ClassType object and use its fluent methods to define class properties, constants, methods, and inheritance.

```APIDOC
## ClassType Usage

### Description
The `ClassType` class is used to generate PHP class code. It allows for the definition of class names, inheritance, interface implementation, properties, constants, and methods.

### Methods
- **new ClassType(string $name)**: Creates a new class definition.
- **setFinal()**: Marks the class as final.
- **addImplement(string $interface)**: Adds an interface to implement.
- **addExtend(string $class)**: Sets the parent class to extend.
- **addProperty(string $name, $value)**: Adds a class property.
- **addConstant(string $name, $value)**: Adds a class constant.
- **addMethod(string $name)**: Adds a new method to the class.

### Example
```php
use Nette\PhpGenerator\ClassType;

$class = new ClassType('UserService');
$class->setFinal();
$class->addImplement('UserServiceInterface');
$class->addExtend('BaseService');

$class->addProperty('db', null)
    ->setPrivate()
    ->setType('?PDO');

$class->addConstant('CACHE_KEY', 'users')
    ->setFinal()
    ->setType('string');

$method = $class->addMethod('find');
$method->addParameter('id')->setType('int');
$method->setReturnType('?array');
$method->setBody('return $this->db->query("SELECT * FROM users WHERE id = ?", [$id]);');

echo $class;
```
```

--------------------------------

### Instantiate PhpNamespace

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/PhpNamespace.md

Create a new namespace instance, using an empty string for the global namespace.

```php
$ns = new PhpNamespace('App\Models');
$ns = new PhpNamespace(''); // global namespace
```

--------------------------------

### Add Parameters

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Configure method parameters, including references, variadic arguments, and promoted parameters.

```php
$param = $method->addParameter('id', 0);
$param->setType('int');

// Reference parameter
$param->setReference();

// Variadic (last parameter only)
$method->setVariadic();

// Default value (PHP 8.0+)
$construct = $class->addMethod('__construct');
$construct->addPromotedParameter('name')->setType('string');
```

--------------------------------

### Printer::__construct

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Printer.md

Creates a new Printer instance with default configuration options.

```APIDOC
## public function __construct()

### Description
Creates a new Printer instance with default configuration. You can modify public properties like `wrapLength` or `indentation` after instantiation.
```

--------------------------------

### Create a new Constant instance

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Constant.md

Initialize a constant by providing its name.

```php
$const = new Constant('MAX_USERS');
```

--------------------------------

### Create File Container

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Initialize a new PHP file object and enable strict types.

```php
$file = new PhpFile();
$file->setStrictTypes();
```

--------------------------------

### PHP Namespace with Class, Interface, and Trait

Source: https://github.com/nette/php-generator/blob/master/readme.md

Illustrates creating a PHP namespace and adding classes, interfaces, and traits to it.

```php
$namespace = new Nette\PhpGenerator\PhpNamespace('Foo');

// create new classes in the namespace
$class = $namespace->addClass('Task');
$interface = $namespace->addInterface('Countable');
$trait = $namespace->addTrait('NameAware');

// or insert an existing class into the namespace
$class = new Nette\PhpGenerator\ClassType('Task');
$namespace->add($class);
```

--------------------------------

### Run Tests and Static Analysis

Source: https://github.com/nette/php-generator/blob/master/AGENTS.md

Commands for executing the test suite and running static analysis tools.

```bash
# Run all tests
vendor/bin/tester tests -s        # or: composer tester
vendor/bin/tester tests/PhpGenerator/ClassType.phpt -s

# Static analysis
composer phpstan
```

--------------------------------

### Generate Complete PHP File

Source: https://github.com/nette/php-generator/blob/master/_autodocs/README.md

Shows how to create a new PHP file with strict types enabled and a defined namespace.

```php
use Nette\PhpGenerator\PhpFile;

$file = new PhpFile();
$file->setStrictTypes();
$ns = $file->addNamespace('App');
$class = $file->addClass('App\User');
echo $file;
```

--------------------------------

### Generate a PHP Class with Properties and Methods

Source: https://github.com/nette/php-generator/blob/master/_autodocs/README.md

Demonstrates the builder pattern to define a class, add a private property, and define a method with a return type.

```php
$class = new ClassType('User');
$class->addProperty('name')->setType('string')->setPrivate();
$class->addMethod('getName')->setReturnType('string');
echo $class;
```

--------------------------------

### Add Namespace

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Add a namespace to the file container and import classes.

```php
$ns = $file->addNamespace('App\Models');
$ns->addUse('DateTime');
```

--------------------------------

### Working with Enums

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Create pure or backed enums and add cases to them.

```php
// Pure enum
$enum = new EnumType('Status');
$enum->addCase('Active');
$enum->addCase('Inactive');

// Backed enum
$enum->setType('string');
$case = $enum->addCase('Pending');
$case->setValue('pending');
```

--------------------------------

### Add a class property

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/ClassType.md

Demonstrates adding a property to a class and configuring it using method chaining.

```php
$prop = $class->addProperty('items', []);
$prop->setPrivate()->setStatic();
```

--------------------------------

### Configure PHP Files

Source: https://github.com/nette/php-generator/blob/master/_autodocs/configuration.md

Manage strict types, file-level comments, namespaces, and global functions.

```php
$file = new PhpFile();

// Strict types
$file->setStrictTypes(true);

// File comment (license, header)
$file->addComment('License: MIT');

// Namespaces
$ns = $file->addNamespace('App\Models');

// Direct items (go to default namespace)
$func = $file->addFunction('globalHelper');
```

--------------------------------

### Define an interface with InterfaceType

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/InterfaceType.md

Demonstrates creating an interface, adding constants, methods with parameters, and validation.

```php
use Nette\PhpGenerator\InterfaceType;

$interface = new InterfaceType('UserRepository');
$interface->addExtend('Traversable');
$interface->addComment('User repository interface');
$interface->addComment('@package App\Repositories');

$interface->addConstant('ROLE_ADMIN', 'admin');
$interface->addConstant('ROLE_USER', 'user');

$findMethod = $interface->addMethod('find');
$findMethod->addParameter('id')->setType('int');
$findMethod->setReturnType('?User');
$findMethod->addComment('Find user by ID');

$saveMethod = $interface->addMethod('save');
$saveMethod->addParameter('user')->setType('User');
$saveMethod->setReturnType('void');

$interface->validate();
echo $interface;
```

--------------------------------

### Generate Class Code with Printer

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Printer.md

Demonstrates creating a class structure and printing it to a string.

```php
use Nette\PhpGenerator\Printer;
use Nette\PhpGenerator\ClassType;

$class = new ClassType('Calculator');
$method = $class->addMethod('add');
$method->addParameter('a')->setType('int');
$method->addParameter('b')->setType('int');
$method->setReturnType('int');
$method->setBody('return $a + $b;');

$printer = new Printer();
$code = $printer->printClass($class);
echo $code;

// Output:
// class Calculator
// {
//     public function add(int $a, int $b): int
//     {
//         return $a + $b;
//     }
// }
```

--------------------------------

### Function Generation with Simple Placeholder

Source: https://github.com/nette/php-generator/blob/master/readme.md

Shows how to use a simple placeholder '?' within a function body for string and number insertion, along with the resulting generated code.

```php
$str = 'any string';
$num = 3;
$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->addBody('return substr(?, ?);', [$str, $num]);
echo $function;
```

--------------------------------

### Create a new Parameter instance

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Parameter.md

Instantiate a new parameter by providing its name.

```php
$param = new Parameter('userId');
```

--------------------------------

### Create Global Function

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates generating a global function with parameters and a body.

```php
$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->setBody('return $a + $b;');
$function->addParameter('a');
$function->addParameter('b');
echo $function;

// or use the PsrPrinter for output compliant with PSR-2 / PSR-12 / PER
// echo (new Nette\PhpGenerator\PsrPrinter)->printFunction($function);
```

--------------------------------

### Define a class with ClassType

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/ClassType.md

Demonstrates creating a class with inheritance, interface implementation, properties, constants, and methods using the fluent API.

```php
use Nette\PhpGenerator\ClassType;

$class = new ClassType('UserService');
$class->setFinal();
$class->addImplement('UserServiceInterface');
$class->addExtend('BaseService');

$class->addProperty('db', null)
    ->setPrivate()
    ->setType('?PDO');

$class->addConstant('CACHE_KEY', 'users')
    ->setFinal()
    ->setType('string');

$method = $class->addMethod('find');
$method->addParameter('id')->setType('int');
$method->setReturnType('?array');
$method->setBody('return $this->db->query("SELECT * FROM users WHERE id = ?", [$id]);');

$construct = $class->addMethod('__construct');
$construct->addPromotedParameter('db')->setType('PDO')->setPrivate();

echo $class;
```

--------------------------------

### Define Method Signature Properties

Source: https://github.com/nette/php-generator/blob/master/readme.md

Shows how to set properties for a method, including comments, final, visibility, and return type.

```php
$method = $class->addMethod('count')
	->addComment('Count it.')
	->setFinal()
	->setProtected()
	->setReturnType('?int');
```

--------------------------------

### Function Generation with Variadic Placeholder

Source: https://github.com/nette/php-generator/blob/master/readme.md

Illustrates using the variadic placeholder '...?' to expand an array into arguments for a function call, and the resulting PHP code.

```php
$items = [1, 2, 3];
$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->setBody('myfunc(...?);', [$items]);
echo $function;
```

--------------------------------

### Define class properties with Nette PHP Generator

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Property.md

Demonstrates creating properties with various visibility levels, types, default values, and property hooks.

```php
use Nette\PhpGenerator\Property;

$prop = new Property('email');
$prop->setPrivate();
$prop->setType('string');
$prop->setValue('');
$prop->addComment('User email address');

$prop2 = new Property('age');
$prop2->setPublic();
$prop2->setType('?int');
$prop2->setNullable();

$prop3 = new Property('name');
$prop3->setPublic();
$prop3->setType('string');
$prop3->addHook('set', 'strtoupper($value)');
$prop3->addHook('get', '$this->_name ?? "Unknown"');

echo $prop;
```

--------------------------------

### Define Variadic Parameter

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates how to set a parameter as variadic (using the ... operator) for a method.

```php
$method = $class->addMethod('count');
$method->setVariadic(true);
$method->addParameter('items');
```

--------------------------------

### Defining Parameters with Nette PHP Generator

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Parameter.md

Demonstrates creating various parameter types including strings, arrays, references, and nullable closures with default values.

```php
use Nette\PhpGenerator\Parameter;

$param1 = new Parameter('name');
$param1->setType('string');
$param1->addComment('User name');

$param2 = new Parameter('tags');
$param2->setType('array');
$param2->setDefaultValue([]);
$param2->addComment('List of tags');

$param3 = new Parameter('data');
$param3->setReference();
$param3->setType('array');
$param3->addComment('Data to modify by reference');

$param4 = new Parameter('filter');
$param4->setType('?Closure');
$param4->setDefaultValue(null);
$param4->addComment('Optional filter callback');

echo '$name, ' . $param2 . ', ' . $param3 . ', ' . $param4;
```

--------------------------------

### Add Methods to a Class

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates how to add methods to a class, including setting visibility, return types, and method bodies. It also shows how to add parameters with type hints and default values.

```php
$method = $class->addMethod('count')
	->addComment('Count it.')
	->setFinal()
	->setProtected()
	->setReturnType('?int') // return types for methods
	->setBody('return count($items ?: $this->items);');

$method->addParameter('items', []) // $items = []
	->setReference()           // & $items = []
	->setType('array');        // array & $items = []
```

--------------------------------

### Define a PHP method with Nette

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Method.md

Create a new method instance and configure its visibility, documentation, parameters, return type, and body using a fluent API.

```php
use Nette\PhpGenerator\Method;

$method = new Method('processUser');
$method->setPublic();
$method->addComment('Processes user data');
$method->addComment('@param array $data User data');
$method->addComment('@return bool Success status');

$method->addParameter('data')->setType('array');
$method->setReturnType('bool');

$method->setBody(<<<'PHP'
    if (empty($data['name'])) {
        return false;
    }
    $this->validate($data);
    $this->save($data);
    return true;
    PHP
);

echo $method;
```

--------------------------------

### Manage namespaces with PhpNamespace

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Creates a namespace container and manages class imports.

```php
use Nette\PhpGenerator\PhpNamespace;

$ns = new PhpNamespace('App\Services');
$ns->addUse('DateTime');
$ns->addUse('PDO', 'DB');

$class = $ns->addClass('UserService');
```

--------------------------------

### Configure Compact Formatting

Source: https://github.com/nette/php-generator/blob/master/_autodocs/configuration.md

Sets line wrapping and reduces vertical spacing for a more compact output.

```php
use Nette\PhpGenerator\Printer;

$printer = new Printer();
$printer->wrapLength = 80;           // wrap at 80 chars
$printer->linesBetweenProperties = 0;
$printer->linesBetweenMethods = 1;
$printer->bracesOnNextLine = false;

echo $printer->printClass($class);
```

--------------------------------

### Add Documentation and Attributes

Source: https://github.com/nette/php-generator/blob/master/_autodocs/configuration.md

Attach comments and PHP attributes to class definitions.

```php
$class->addComment('Class description');
$class->addComment('@property Type $prop Description');
$class->addAttribute('Entity', ['table' => 'users']);
```

--------------------------------

### Builder vs. String Names

Source: https://github.com/nette/php-generator/blob/master/_autodocs/README.md

Shows the flexibility of adding members either by passing an object instance or by providing a string name to trigger automatic object creation.

```php
// Direct object
$class->addMember($method);

// String name (creates object)
$prop = $class->addProperty('name');
```

--------------------------------

### Add a method to the class

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/ClassType.md

Create a new method definition and configure its parameters, return type, and body.

```php
$method = $class->addMethod('getName');
$method->addParameter('default', '')->setType('string');
$method->setReturnType('string');
$method->setBody('return $this->name ?? $default;');
```

--------------------------------

### Generated Class Output

Source: https://github.com/nette/php-generator/blob/master/readme.md

The resulting PHP code for the 'Demo' class, demonstrating how aliases and fully qualified names are handled.

```PHP
namespace Foo;

use Bar\AliasedClass;

class Demo implements A
{
	use AliasedClass;

	/**
	 * @return D
	 */
	public function method(\Bar\OtherClass $arg)
	{
	}
}
```

--------------------------------

### Print Namespace

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Printer.md

Generates code for a given PhpNamespace object.

```php
public function printNamespace(PhpNamespace $namespace): string
```

--------------------------------

### Configure custom Dumper settings

Source: https://github.com/nette/php-generator/blob/master/_autodocs/configuration.md

Adjust recursion depth, line wrapping, and indentation for the Dumper instance.

```php
use Nette\PhpGenerator\Dumper;
use Nette\PhpGenerator\DumpContext;

$dumper = new Dumper();
$dumper->maxDepth = 100;
$dumper->wrapLength = 80;
$dumper->indentation = '  '; // 2 spaces

$dumper->context = DumpContext::Property;
$code = $dumper->dump(['key' => 'value']);
```

--------------------------------

### PHP Namespace with Use Clauses

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates how to define 'use' statements for classes, functions, and aliases within a PHP namespace.

```php
// use Http\Request;
$namespace->addUse(Http\Request::class);
// use Http\Request as HttpReq;
$namespace->addUse(Http\Request::class, 'HttpReq');
// use function iter\range;
$namespace->addUseFunction('iter\range');
```

--------------------------------

### Setting Member Type as String

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates setting the type for a member (e.g., property or parameter) using a string representation.

```php
$member->setType('array'); // or Type::Array;
$member->setType('?array'); // or Type::nullable(Type::Array);
$member->setType('array|string'); // or Type::union(Type::Array, Type::String)
$member->setType('Foo&Bar'); // or Type::intersection(Foo::class, Bar::class)
$member->setType(null); // removes the type
```

--------------------------------

### Reuse printer configuration for batch output

Source: https://github.com/nette/php-generator/blob/master/_autodocs/ADVANCED-USAGE.md

Instantiate a PsrPrinter once and reuse it across multiple class printing operations to optimize resource usage.

```php
// Reuse printer for multiple classes
$printer = new PsrPrinter();

foreach ($classes as $class) {
    $code = $printer->printClass($class);
    file_put_contents("$class->getName().php", $code);
}
```

--------------------------------

### Optimize member creation with batch processing

Source: https://github.com/nette/php-generator/blob/master/_autodocs/ADVANCED-USAGE.md

Collect metadata in arrays before iterating to add properties and methods to a class to improve performance.

```php
// Efficient: collect operations
$properties = [];
$methods = [];

for ($i = 0; $i < 100; $i++) {
    $properties[] = ['name' => "field$i", 'type' => 'string'];
    $methods[] = ['name' => "get" . ucfirst("field$i"), 'return' => 'string'];
}

foreach ($properties as $prop) {
    $p = $class->addProperty($prop['name'])->setPrivate();
    $p->setType($prop['type']);
}

foreach ($methods as $method) {
    $m = $class->addMethod($method['name'])->setPublic();
    $m->setReturnType($method['return']);
}
```

--------------------------------

### PsrPrinter Configuration

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Printer.md

Shows the default configuration properties for the PsrPrinter class.

```php
class PsrPrinter extends Printer
{
    public string $indentation = '    ';
    public int $linesBetweenMethods = 1;
    public int $linesBetweenUseTypes = 1;
}
```

--------------------------------

### Initialize ClassManipulator

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates how to initialize a ClassManipulator with a ClassType object to enable class manipulation.

```PHP
$class = new Nette\PhpGenerator\ClassType('Demo');
$manipulator = new Nette\PhpGenerator\ClassManipulator($class);
```

--------------------------------

### Create From Reflection

Source: https://github.com/nette/php-generator/blob/master/_autodocs/README.md

Initializes a ClassType object from an existing class using reflection to allow modification.

```php
$class = ClassType::from(ExistingClass::class);
$class->addMethod('newMethod');
echo $class;
```

--------------------------------

### Generate Class Code using Printer

Source: https://github.com/nette/php-generator/blob/master/readme.md

Shows how to use the Nette\PhpGenerator\Printer to generate the string representation of a class object. This offers more configuration options than direct typecasting.

```php
$printer = new Nette\PhpGenerator\Printer;
echo $printer->printClass($class);
```

--------------------------------

### Add Promoted Constructor Parameters

Source: https://github.com/nette/php-generator/blob/master/readme.md

Shows how to add promoted parameters to a constructor, a feature introduced in PHP 8.0. This allows defining properties directly in the constructor signature.

```php
$method = $class->addMethod('__construct');
$method->addPromotedParameter('name');
$method->addPromotedParameter('args', [])
	->setPrivate();
```

--------------------------------

### Load PhpFile from PHP Code String

Source: https://github.com/nette/php-generator/blob/master/readme.md

Shows how to load an entire PHP file, including classes, functions, and namespaces, from a string containing PHP code. Requires 'nikic/php-parser'.

```PHP
$file = Nette\PhpGenerator\PhpFile::fromCode(file_get_contents('classes.php'));
```

--------------------------------

### Configure Class Methods

Source: https://github.com/nette/php-generator/blob/master/_autodocs/configuration.md

Use these methods to define visibility, modifiers, return types, parameters, body content, and documentation for a class method.

```php
$method = $class->addMethod('myMethod');

// Visibility
$method->setPublic();      // or setProtected(), setPrivate()

// Modifiers
$method->setStatic();
$method->setFinal();
$method->setAbstract();

// Return type
$method->setReturnType('string');
$method->setReturnNullable(true);
$method->setReturnReference(true);

// Parameters
$param = $method->addParameter('name');
$param->setType('string');
$param->setDefaultValue('default');
$param->setReference();

// Body
$method->setBody('return $this->value;');
$method->addBody('$this->validate();');

// Documentation
$method->addComment('Method description');
$method->addAttribute('Route', ['path' => '/endpoint']);
```

--------------------------------

### Configure PsrPrinter for PSR-12 compliance

Source: https://github.com/nette/php-generator/blob/master/_autodocs/configuration.md

Instantiate PsrPrinter to generate code following PSR-12 standards.

```php
use Nette\PhpGenerator\PsrPrinter;

$printer = new PsrPrinter();
echo $printer->printClass($class);
// Generates PSR-12 compliant code
```

--------------------------------

### Add use bindings to a closure

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Closure.md

Demonstrates adding variable bindings to the closure's use list and configuring them as references.

```php
$closure->addUse('count')->setReference();
$closure->addUse('prefix');
```

--------------------------------

### Add Constants and Properties to a Class

Source: https://github.com/nette/php-generator/blob/master/readme.md

Illustrates adding constants and properties to a class. You can specify visibility, type, initial values, and comments for these members.

```php
$class->addConstant('ID', 123)
	->setProtected() // constant visibility
	->setType('int')
	->setFinal();

$class->addProperty('items', [1, 2, 3])
	->setPrivate() // or setVisibility('private')
	->setStatic()
	->addComment('@var int[]');

$class->addProperty('list')
	->setType('?array')
	->setInitialized(); // outputs '= null'
```

--------------------------------

### Configure Allman Style Formatting

Source: https://github.com/nette/php-generator/blob/master/_autodocs/configuration.md

Adjusts indentation, brace placement, and spacing between methods for the Printer class.

```php
use Nette\PhpGenerator\Printer;

$printer = new Printer();
$printer->indentation = '    '; // 4 spaces
$printer->bracesOnNextLine = true; // brace on next line
$printer->linesBetweenMethods = 2;

echo $printer->printClass($class);
```

--------------------------------

### Add and configure a parameter

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Closure.md

Adds a parameter to the closure and sets its type hint.

```php
$param = $closure->addParameter('name');
$param->setType('string');
```

--------------------------------

### Catch and Handle Configuration Exceptions

Source: https://github.com/nette/php-generator/blob/master/_autodocs/errors.md

Uses try-catch blocks to handle potential state or argument exceptions when modifying class members.

```php
use Nette\InvalidStateException;
use Nette\InvalidArgumentException;

try {
    $class->addProperty('name');
    $prop = $class->getProperty('name');
    $prop->setType('string');
} catch (InvalidStateException $e) {
    // Handle duplicate member
    error_log('Member already exists: ' . $e->getMessage());
} catch (InvalidArgumentException $e) {
    // Handle invalid name/type
    error_log('Invalid configuration: ' . $e->getMessage());
}
```

--------------------------------

### Create a new Closure instance

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Closure.md

Instantiates a new Closure object.

```php
$closure = new Closure();
```

--------------------------------

### Configure Return by Reference

Source: https://github.com/nette/php-generator/blob/master/_autodocs/ADVANCED-USAGE.md

Set a method to return by reference using setReturnReference.

```php
$method = $class->addMethod('getRef');
$method->setReturnReference();
$method->setReturnType('string');
$method->setBody('return $this->_value;');

// Output: function getRef(): string { ... }
// Note: & is handled by printer
```

--------------------------------

### getUses()

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Closure.md

Retrieves all current use bindings.

```APIDOC
## getUses()

### Description
Returns all use bindings.

### Returns
- **Parameter[]** - Array of Parameter objects
```

--------------------------------

### Generate files with bracketed namespace syntax

Source: https://github.com/nette/php-generator/blob/master/_autodocs/ADVANCED-USAGE.md

Define multiple distinct namespaces within a single file using the addNamespace method.

```php
$file = new PhpFile();

// Multiple namespaces in one file
$ns1 = $file->addNamespace('App\First');
$class1 = $ns1->addClass('Helper');

$ns2 = $file->addNamespace('App\Second');
$class2 = $ns2->addClass('Processor');

// Output:
// <?php
// namespace App\First { ... }
// namespace App\Second { ... }
```

--------------------------------

### Using Attributes

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Attach attributes to classes, methods, or properties.

```php
$class->addAttribute('Entity', ['table' => 'users']);

$method->addAttribute('Route', ['path' => '/api/users/{id}']);

$prop->addAttribute('Validate', ['min' => 1, 'max' => 100]);
```

--------------------------------

### Basic Function Body Generation

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates adding a simple return statement to a function body and echoing the generated function.

```php
$function->addBody('return $a;');
echo $function;
```

--------------------------------

### Create Class-Like Type

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Add a class to the namespace and define its parent class.

```php
$class = $file->addClass('App\Models\User');
$class->addExtend('BaseModel');
```

--------------------------------

### PhpFile::add

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/PhpFile.md

Adds a namespace, class-like type, or function to the file.

```APIDOC
## add(ClassType|InterfaceType|TraitType|EnumType|GlobalFunction|PhpNamespace $item)

### Description
Adds a namespace, class-like type, or function to the file. Classes, interfaces, traits, and enums are placed into their respective namespace (created if needed). Functions without explicit namespace go to the global namespace.

### Parameters
- **item** (ClassType|InterfaceType|TraitType|EnumType|GlobalFunction|PhpNamespace) - Required - Item to add to file

### Returns
- **static** - Self for method chaining

### Throws
- Nette\InvalidStateException - if a namespace with same name already exists
```

--------------------------------

### PHP Class with Asymmetric Property Visibility

Source: https://github.com/nette/php-generator/blob/master/readme.md

Demonstrates setting asymmetric visibility for properties, allowing different access levels for reading and writing.

```php
$class = new Nette\PhpGenerator\ClassType('Demo');

$class->addProperty('name')
    ->setType('string')
    ->setVisibility('public', 'private'); // public for read, private for write

$class->addProperty('id')
    ->setType('int')
    ->setProtected('set'); // protected for write

echo $class;
```

--------------------------------

### Configure Dumper Settings

Source: https://github.com/nette/php-generator/blob/master/_autodocs/API-OVERVIEW.md

Control recursion depth and formatting context when dumping complex structures.

```php
$dumper = new Dumper();
$dumper->maxDepth = 100;
$dumper->wrapLength = 80;
$dumper->context = DumpContext::Property;
```

--------------------------------

### PHP Namespace Name Simplification

Source: https://github.com/nette/php-generator/blob/master/readme.md

Shows how to use the simplifyName method to convert fully qualified names to simplified names within a namespace context.

```php
echo $namespace->simplifyName('Foo\Bar'); // 'Bar', because 'Foo' is the current namespace
echo $namespace->simplifyName('iter\range', $namespace::NameFunction); // 'range', due to the defined use-statement
```

--------------------------------

### Organize multiple classes in a shared namespace

Source: https://github.com/nette/php-generator/blob/master/_autodocs/ADVANCED-USAGE.md

Use a single PhpFile instance to define multiple classes under the same namespace with shared use statements.

```php
$file = new PhpFile();
$file->setStrictTypes();

$ns = $file->addNamespace('App\Models');
$ns->addUse('DateTime');
$ns->addUse('Doctrine\ORM\EntityManager', 'EM');

// First class
$class1 = $file->addClass('App\Models\User');
// ... configure ...

// Second class
$class2 = $file->addClass('App\Models\Post');
// ... configure ...

echo $file;
// Both classes in same namespace with shared use statements
```

--------------------------------

### Custom Printer Configuration

Source: https://github.com/nette/php-generator/blob/master/_autodocs/ADVANCED-USAGE.md

Configures the Printer instance to control indentation, brace placement, spacing, and namespace handling.

```php
use Nette\PhpGenerator\Printer;

$printer = new Printer();

// Code style
$printer->indentation = '  '; // 2 spaces
$printer->wrapLength = 80;
$printer->bracesOnNextLine = true;

// Method/property spacing
$printer->linesBetweenProperties = 1;
$printer->linesBetweenMethods = 2;
$printer->linesBetweenUseTypes = 1;

// Return type formatting
$printer->returnTypeColon = ' : '; // with spaces

// Parameters
$printer->singleParameterOnOneLine = true;

// Namespace handling
$printer->omitEmptyNamespaces = false; // keep empty namespaces
$printer->declareOnOpenTag = true; // declare right after <?php

echo $printer->printFile($file);
```

--------------------------------

### Load ClassType from PHP Code String

Source: https://github.com/nette/php-generator/blob/master/readme.md

Illustrates creating a ClassType object by parsing a string containing PHP code for a class definition.

```PHP
$class = Nette\PhpGenerator\ClassType::fromCode(<<<XX
	<?php

	class Demo
	{
		public $foo;
	}
	XX);
```

--------------------------------

### Generate Closure from Existing Closure

Source: https://github.com/nette/php-generator/blob/master/readme.md

Illustrates creating a Closure object based on an existing closure definition.

```PHP
$closure = Nette\PhpGenerator\Closure::from(
	function (stdClass $a, $b = null) {},
);
```

--------------------------------

### Mark parameter as reference

Source: https://github.com/nette/php-generator/blob/master/_autodocs/api-reference/Parameter.md

Configure the parameter to be passed by reference.

```php
$param->setReference();
```
Tokens:
Raw