Nette PhpGenerator

Sınıflar, fonksiyonlar ya da eksiksiz dosyalar için PHP kodu üretecek bir araç mı arıyorsunuz?

En son PHP özelliklerinin tümünü destekler (property hook'lar, enum'lar, nitelikler vb.)
Var olan sınıfları kolayca değiştirmenizi sağlar
PSR-12 / PER kodlama biçimine uygun çıktı
Olgun, kararlı ve yaygın kullanılan bir kütüphane

Kurulum

Kütüphaneyi Composer aracını kullanarak indirin ve kurun:

composer require nette/php-generator

PHP uyumluluğu için uyumluluk tablosuna bakın.

Sınıflar

ClassType kullanarak bir sınıf oluşturma örneğiyle başlayalım:

$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');

// kodu yalnızca dizeye dönüştürerek ya da echo kullanarak üretin:
echo $class;

Bu şu sonucu döndürür:

/**
 * Class description.
 * Second line
 *
 * @property-read Nette\Forms\Form $form
 */
final class Demo extends ParentClass implements Countable
{
}

Kodu üretmek için, echo $class ifadesinin tersine daha fazla yapılandırılabilen bir printer da kullanabilirsiniz:

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

Sabitler (Constant sınıfı) ve özellikler (Property sınıfı) ekleyebilirsiniz:

$class->addConstant('ID', 123)
	->setProtected() // sabitin görünürlüğü
	->setType('int')
	->setFinal();

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

$class->addProperty('list')
	->setType('?array')
	->setInitialized(); // '= null' çıktılar

Bu şunu üretir:

final protected const int ID = 123;

/** @var int[] */
private static $items = [1, 2, 3];
public ?array $list = null;

Ve metotlar ekleyebilirsiniz:

$method = $class->addMethod('count')
	->addComment('Count it.')
	->setFinal()
	->setProtected()
	->setReturnType('?int') // metotlar için dönüş tipleri
	->setBody('return count($items ?: $this->items);');

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

Sonuç şudur:

/**
 * Count it.
 */
final protected function count(array &$items = []): ?int
{
	return count($items ?: $this->items);
}

PHP 8.0'da tanıtılan promoted parametreler yapıcıya aktarılabilir:

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

Sonuç şudur:

public function __construct(
	public $name,
	private $args = [],
) {
}

Readonly özellikler ve sınıflar setReadOnly() fonksiyonuyla işaretlenebilir.

Eklenen bir özellik, sabit, metot ya da trait zaten varsa istisna fırlatılır. Parametreler ise tersine, üzerine yazılır.

Sınıf üyeleri removeProperty(), removeConstant(), removeMethod() ya da removeParameter() kullanılarak kaldırılabilir.

Sınıfa var olan Method, Property ya da Constant nesnelerini de ekleyebilirsiniz:

$method = new Nette\PhpGenerator\Method('getHandle');
$property = new Nette\PhpGenerator\Property('handle');
$const = new Nette\PhpGenerator\Constant('ROLE');

$class = (new Nette\PhpGenerator\ClassType('Demo'))
	->addMember($method)
	->addMember($property)
	->addMember($const);

Var olan metotları, özellikleri ve sabitleri cloneWithName() kullanarak farklı bir adla klonlayabilirsiniz:

$methodCount = $class->getMethod('count');
$methodRecount = $methodCount->cloneWithName('recount');
$class->addMember($methodRecount);

Arayüzler ya da Trait'ler

Arayüzler ve trait'ler oluşturabilirsiniz (InterfaceType ve TraitType sınıfları):

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

Bir trait kullanma:

$class = new Nette\PhpGenerator\ClassType('Demo');
$class->addTrait('SmartObject');
$class->addTrait('MyTrait')
	->addResolution('sayHello as protected')
	->addComment('@use MyTrait<Foo>');
echo $class;

Sonuç şudur:

class Demo
{
	use SmartObject;
	/** @use MyTrait<Foo> */
	use MyTrait {
		sayHello as protected;
	}
}

Enum'lar

PHP 8.1'de tanıtılan enum'ları şöyle kolayca oluşturabilirsiniz (EnumType sınıfı):

$enum = new Nette\PhpGenerator\EnumType('Suit');
$enum->addCase('Clubs');
$enum->addCase('Diamonds');
$enum->addCase('Hearts');
$enum->addCase('Spades');

echo $enum;

Sonuç şudur:

enum Suit
{
	case Clubs;
	case Diamonds;
	case Hearts;
	case Spades;
}

Skaler karşılıkları tanımlayıp backed enum da oluşturabilirsiniz:

$enum = new Nette\PhpGenerator\EnumType('Suit');
$enum->addCase('Clubs', '♣');
$enum->addCase('Diamonds', '♦');

Her case için addComment() ya da addAttribute() kullanarak bir yorum veya nitelikler ekleyebilirsiniz.

Anonim Sınıflar

Ad olarak null aktarın ve elinizde anonim bir sınıf olsun:

$class = new Nette\PhpGenerator\ClassType(null);
$class->addMethod('__construct')
	->addParameter('foo');

echo '$obj = new class ($val) ' . $class . ';';

Sonuç şudur:

$obj = new class ($val) {
	public function __construct($foo)
	{
	}
};

Küresel Fonksiyonlar

Küresel fonksiyonların kodu GlobalFunction sınıfıyla üretilir:

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

// ya da PSR-2 / PSR-12 / PER uyumlu çıktı için PsrPrinter kullanın
// echo (new Nette\PhpGenerator\PsrPrinter)->printFunction($function);

Sonuç şudur:

function foo($a, $b)
{
	return $a + $b;
}

Anonim Fonksiyonlar

Anonim fonksiyonların (closure'ların) kodu Closure sınıfıyla üretilir:

$closure = new Nette\PhpGenerator\Closure;
$closure->setBody('return $a + $b;');
$closure->addParameter('a');
$closure->addParameter('b');
$closure->addUse('c')
	->setReference();
echo $closure;

// ya da PSR-2 / PSR-12 / PER uyumlu çıktı için PsrPrinter kullanın
// echo (new Nette\PhpGenerator\PsrPrinter)->printClosure($closure);

Sonuç şudur:

function ($a, $b) use (&$c) {
	return $a + $b;
}

Kısa Ok Fonksiyonları

Printer kullanarak kısa bir ok fonksiyonu da çıktılayabilirsiniz:

$closure = new Nette\PhpGenerator\Closure;
$closure->setBody('$a + $b');
$closure->addParameter('a');
$closure->addParameter('b');

echo (new Nette\PhpGenerator\Printer)->printArrowFunction($closure);

Sonuç şudur:

fn($a, $b) => $a + $b;

Metot ve Fonksiyon İmzaları

Metotlar Method sınıfıyla temsil edilir. Görünürlüğü, dönüş tipini ayarlayabilir, yorumlar, nitelikler vb. ekleyebilirsiniz:

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

Tek tek parametreler Parameter sınıfıyla temsil edilir. Yine akla gelebilecek tüm özellikleri ayarlayabilirsiniz:

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

// function count(array &$items = [])

Değişken sayıda parametre (splat operatörü olarak da bilinir) tanımlamak için setVariadic() kullanın:

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

Bu şunu üretir:

function count(...$items)
{
}

Metot ve Fonksiyon Gövdeleri

Gövde, setBody() metoduna tek seferde ya da addBody() yinelemeli çağrılarak aşamalı (satır satır) aktarılabilir:

$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->addBody('$a = rand(10, 20);');
$function->addBody('return $a;');
echo $function;

Sonuç şudur:

function foo()
{
	$a = rand(10, 20);
	return $a;
}

Değişkenleri kolayca eklemek için özel yer tutucular kullanabilirsiniz.

Basit ? yer tutucuları:

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

Sonuç şudur:

function foo()
{
	return substr('any string', 3);
}

Değişken sayıda parametre için ...? yer tutucusu:

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

Sonuç şudur:

function foo()
{
	myfunc(1, 2, 3);
}

PHP 8 için adlandırılmış parametreleri ...?: ile de kullanabilirsiniz:

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

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

Yer tutucu, ters eğik çizgiyle \? kaçırılır:

$num = 3;
$function = new Nette\PhpGenerator\GlobalFunction('foo');
$function->addParameter('a');
$function->addBody('return $a \? 10 : ?;', [$num]);
echo $function;

Sonuç şudur:

function foo($a)
{
	return $a ? 10 : 3;
}

Printer ve PSR Uyumluluğu

PHP kodu üretmek için Printer sınıfı kullanılır:

$class = new Nette\PhpGenerator\ClassType('Demo');
// ...

$printer = new Nette\PhpGenerator\Printer;
echo $printer->printClass($class); // şununla aynı: echo $class

Diğer tüm elemanlar için kod üretebilir ve printFunction(), printNamespace() gibi metotlar sunar.

Çıktısı PSR-2 / PSR-12 / PER kodlama biçimine uyan PsrPrinter sınıfı da vardır:

$printer = new Nette\PhpGenerator\PsrPrinter;
echo $printer->printClass($class);

Davranışı özelleştirmeniz mi gerekiyor? Printer sınıfından kalıtarak kendi sürümünüzü oluşturun. Şu değişkenleri yeniden yapılandırabilirsiniz:

class MyPrinter extends Nette\PhpGenerator\Printer
{
	// satır sarmasının gerçekleştiği satır uzunluğu
	public int $wrapLength = 120;
	// girinti karakteri, bir boşluk dizisiyle değiştirilebilir
	public string $indentation = "\t";
	// özellikler arasındaki boş satır sayısı
	public int $linesBetweenProperties = 0;
	// metotlar arasındaki boş satır sayısı
	public int $linesBetweenMethods = 2;
	// sınıflar, fonksiyonlar ve sabitler için 'use statement' grupları arasındaki boş satır sayısı
	public int $linesBetweenUseTypes = 0;
	// fonksiyonlar ve metotlar için açılan süslü parantezin konumu
	public bool $bracesOnNextLine = true;
	// tek parametreyi, niteliği olsa ya da promoted olsa bile tek satıra koy
	public bool $singleParameterOnOneLine = false;
	// hiçbir sınıf ya da fonksiyon içermeyen ad alanlarını atlar
	public bool $omitEmptyNamespaces = true;
	// declare(strict_types) ifadesini <?php ile aynı satıra koyar
	public bool $declareOnOpenTag = false;
	// sağ parantez ile fonksiyonların ve metotların dönüş tipi arasındaki ayırıcı
	public string $returnTypeColon = ': ';
}

Standart Printer ile PsrPrinter aslında nasıl ve neden ayrılır? Neden pakette tek bir printer, PsrPrinter, yok?

Standart Printer, kodu Nette'in tamamında yaptığımız gibi biçimlendirir. Nette PSR'den çok daha önce oluşturulduğundan ve PSR standartları da sıklıkla geç geldiğinden (bazen yeni bir PHP özelliği tanıtıldıktan yıllar sonra), Nette kodlama standardı birkaç küçük ayrıntıda ayrılır. Ana fark, boşluk yerine sekme kullanılmasıdır. Projelerimizde sekme kullanmanın genişlik özelleştirmesine olanak tanıdığını biliyoruz; bu, görme engelli insanlar için temeldir. Küçük bir farkın örneği, fonksiyonlar ve metotlar için açılan süslü parantezin her zaman ayrı bir satıra konmasıdır. PSR önerisi bize mantıksız görünüyor ve kodun anlaşılırlığını azaltmaya yol açıyor.

Tipler

Her tip ya da union/intersection tipi bir dize olarak aktarılabilir; yerel tipler için önceden tanımlı sabitleri de kullanabilirsiniz:

use Nette\PhpGenerator\Type;

$member->setType('array'); // ya da Type::Array
$member->setType('?array'); // ya da Type::nullable(Type::Array)
$member->setType('array|string'); // ya da Type::union(Type::Array, Type::String)
$member->setType('Foo&Bar'); // ya da Type::intersection(Foo::class, Bar::class)
$member->setType(null); // tipi kaldırır

Aynısı setReturnType() metodu için de geçerlidir.

Literal'lar

Literal kullanarak, örneğin özelliklerin ya da parametrelerin varsayılan değerleri için herhangi bir PHP kodunu aktarabilirsiniz:

use Nette\PhpGenerator\Literal;

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

$class->addProperty('foo', new Literal('Iterator::SELF_FIRST'));

$class->addMethod('bar')
	->addParameter('id', new Literal('1 + 2'));

echo $class;

Sonuç:

class Demo
{
	public $foo = Iterator::SELF_FIRST;

	public function bar($id = 1 + 2)
	{
	}
}

Literal sınıfına parametreler de aktarabilir ve onları yer tutucular kullanarak geçerli PHP koduna biçimlendirtebilirsiniz:

new Literal('substr(?, ?)', [$a, $b]);
// örneğin şunu üretir: substr('hello', 5)

Yeni bir nesnenin oluşturulmasını temsil eden bir literal, new metodu kullanılarak kolayca üretilebilir:

Literal::new(Demo::class, [$a, 'foo' => $b]);
// örneğin şunu üretir: new Demo(10, foo: 20)

Nitelikler

PHP 8 nitelikleri; tüm sınıflara, metotlara, özelliklere, sabitlere, enum'lara, fonksiyonlara, closure'lara ve parametrelere eklenebilir. Parametre değerleri olarak literal'lar da kullanılabilir.

$class = new Nette\PhpGenerator\ClassType('Demo');
$class->addAttribute('Table', [
	'name' => 'user',
	'constraints' => [
		Literal::new('UniqueConstraint', ['name' => 'ean', 'columns' => ['ean']]),
	],
]);

$class->addProperty('list')
	->addAttribute('Deprecated');

$method = $class->addMethod('count')
	->addAttribute('Foo\Cached', ['mode' => true]);

$method->addParameter('items')
	->addAttribute('Bar');

echo $class;

Sonuç:

#[Table(name: 'user', constraints: [new UniqueConstraint(name: 'ean', columns: ['ean'])])]
class Demo
{
	#[Deprecated]
	public $list;


	#[Foo\Cached(mode: true)]
	public function count(
		#[Bar]
		$items,
	) {
	}
}

Property Hook'lar

Property hook'ları (PropertyHook sınıfıyla temsil edilir) kullanarak, PHP 8.4'te tanıtılan bir özellik olan get ve set işlemlerini özellikler için tanımlayabilirsiniz:

$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;

Bu şunu üretir:

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

Özellikler ve property hook'lar abstract ya da final olabilir:

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

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

Asimetrik Görünürlük

PHP 8.4, özellikler için asimetrik görünürlüğü tanıtır. Okuma ve yazma için farklı erişim düzeyleri ayarlayabilirsiniz.

Görünürlük ya iki parametreli setVisibility() metoduyla ya da görünürlüğün özelliği okumaya mı yazmaya mı uygulandığını belirten mode parametresiyle birlikte setPublic(), setProtected() veya setPrivate() kullanılarak ayarlanabilir. Varsayılan mod 'get' değeridir.

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

$class->addProperty('name')
    ->setType('string')
    ->setVisibility('public', 'private'); // okuma için public, yazma için private

$class->addProperty('id')
    ->setType('int')
    ->setProtected('set'); // yazma için protected

echo $class;

Bu şunu üretir:

class Demo
{
    public private(set) string $name;

    protected(set) int $id;
}

Ad Alanı

Sınıflar, trait'ler, arayüzler ve enum'lar (bundan sonra sınıflar diye anılacak) PhpNamespace sınıfıyla temsil edilen ad alanlarında gruplanabilir:

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

// ad alanında yeni sınıflar oluştur
$class = $namespace->addClass('Task');
$interface = $namespace->addInterface('Countable');
$trait = $namespace->addTrait('NameAware');

// ya da var olan bir sınıfı veya fonksiyonu ad alanına ekle
$class = new Nette\PhpGenerator\ClassType('Task');
$namespace->add($class);

Ad alanında aynı adı taşıyan bir sınıf zaten varsa istisna fırlatılır.

use bildirimleri tanımlayabilirsiniz:

// 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');

Tam nitelikli bir sınıf, fonksiyon ya da sabit adını, tanımlı alias'lara veya geçerli ad alanına göre basitleştirmek için simplifyName metodunu kullanın:

echo $namespace->simplifyName('Foo\Bar'); // 'Bar', çünkü 'Foo' geçerli ad alanı
echo $namespace->simplifyName('iter\range', $namespace::NameFunction); // 'range', tanımlı use bildirimi sayesinde

Tersine, basitleştirilmiş bir sınıf, fonksiyon ya da sabit adını resolveName metoduyla tam nitelikli ada geri dönüştürebilirsiniz:

echo $namespace->resolveName('Bar'); // 'Foo\Bar'
echo $namespace->resolveName('range', $namespace::NameFunction); // 'iter\range'

Sınıf Adlarının Çözümü

Bir sınıf bir ad alanının parçası olduğunda biraz farklı render edilir: tüm tipler (örneğin tip ipuçları, dönüş tipleri, ana sınıf adı, gerçekleştirilen arayüzler, kullanılan trait'ler ve nitelikler) otomatik çözülür (aşağıya bakıp kapatmadıysanız). Bu, tanımlarda tam nitelikli sınıf adları kullanmanız gerektiği ve ortaya çıkan kodda onların alias'larla (use bildirimlerine göre) ya da basitleştirilmiş adlarla (aynı ad alanındaysa) değiştirileceği anlamına gelir:

$namespace = new Nette\PhpGenerator\PhpNamespace('Foo');
$namespace->addUse('Bar\AliasedClass');

$class = $namespace->addClass('Demo');
$class->addImplement('Foo\A') // A olarak basitleştirilecek
	->addTrait('Bar\AliasedClass'); // AliasedClass olarak basitleştirilecek

$method = $class->addMethod('method');
$method->addComment('@return ' . $namespace->simplifyType('Foo\D')); // yorumlarda elle basitleştiriyoruz
$method->addParameter('arg')
	->setType('Bar\OtherClass'); // \Bar\OtherClass olarak çevrilecek

echo $namespace;

// ya da PSR-2 / PSR-12 / PER uyumlu çıktı için PsrPrinter kullanın
// echo (new Nette\PhpGenerator\PsrPrinter)->printNamespace($namespace);

Sonuç:

namespace Foo;

use Bar\AliasedClass;

class Demo implements A
{
	use AliasedClass;

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

Otomatik çözüm şöyle kapatılabilir:

$printer = new Nette\PhpGenerator\Printer; // ya da PsrPrinter
$printer->setTypeResolving(false);
echo $printer->printNamespace($namespace);

PHP Dosyaları

Sınıflar, fonksiyonlar ve ad alanları, PhpFile sınıfıyla temsil edilen PHP dosyalarında gruplanabilir:

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

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

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

echo $file;

// ya da PSR-2 / PSR-12 / PER uyumlu çıktı için PsrPrinter kullanın
// echo (new Nette\PhpGenerator\PsrPrinter)->printFile($file);

Sonuç:

<?php

/**
 * This file is auto-generated.
 */

declare(strict_types=1);

namespace Foo;

class A
{
}

function foo()
{
}

Var olan sınıf, fonksiyon ve ad alanı nesnelerini dosyaya add() metoduyla da ekleyebilirsiniz:

$file = new Nette\PhpGenerator\PhpFile;
$class = new Nette\PhpGenerator\ClassType('Demo');
$file->add($class);

Dikkat: Dosyalara, fonksiyonların, sınıfların ya da ad alanlarının dışında ek kod (örneğin echo 'hello') eklenemez.

Var Olan Elemanlardan Üretme

Sınıfları ve fonksiyonları yukarıda anlatılan API ile modellemenin yanı sıra, onları reflection kullanarak var olanlardan otomatik ürettirebilirsiniz:

// PDO sınıfıyla özdeş bir sınıf oluşturur
$class = Nette\PhpGenerator\ClassType::from(PDO::class);

// trim() fonksiyonuyla özdeş bir fonksiyon oluşturur
$function = Nette\PhpGenerator\GlobalFunction::from('trim');

// verilen closure'a dayanan bir closure oluşturur
$closure = Nette\PhpGenerator\Closure::from(
	function (stdClass $a, $b = null) {},
);

Fonksiyon ve metot gövdeleri varsayılan olarak boştur. Onları da yüklemek isterseniz şu yöntemi kullanın (nikic/php-parser paketinin kurulu olmasını gerektirir):

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

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

PHP Dosyalarından Yükleme

Fonksiyonları, sınıfları, arayüzleri ve enum'ları PHP kodu içeren bir dizeden doğrudan da yükleyebilirsiniz. Örneğin bir ClassType nesnesi oluşturmak için:

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

	class Demo
	{
		public $foo;
	}
	XX);

Sınıflar PHP kodundan yüklenirken, metot gövdelerinin dışındaki tek satırlık yorumlar (örneğin özellikler için olanlar) yok sayılır; çünkü bu kütüphanenin onlarla çalışacak bir API'si yoktur.

İstediğiniz kadar sınıf, fonksiyon, hatta ad alanı içerebilen bir PHP dosyasının tamamını da doğrudan yükleyebilirsiniz:

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

Dosyanın baştaki yorumu ve strict_types bildirimi de yüklenir. Ancak diğer tüm küresel kod yok sayılır.

nikic/php-parser paketinin kurulu olmasını gerektirir.

Dosyalardaki küresel kodu ya da metot gövdelerinin içindeki tek tek deyimleri değiştirmeniz gerekiyorsa, doğrudan nikic/php-parser kütüphanesini kullanmanız daha iyidir.

Sınıf Manipülatörü

ClassManipulator sınıfı, sınıfları değiştirmek için araçlar sunar.

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

inheritMethod() metodu, bir ana sınıftan ya da gerçekleştirilen bir arayüzden bir metodu sizin sınıfınıza kopyalar. Bu, metodu geçersiz kılmanızı ya da imzasını genişletmenizi sağlar:

$method = $manipulator->inheritMethod('bar');
$method->setBody('...');

inheritProperty() metodu, bir ana sınıftan bir özelliği sizin sınıfınıza kopyalar. Bu, sınıfınızda aynı özelliğin, belki farklı bir varsayılan değerle bulunmasını istediğinizde yararlıdır:

$property = $manipulator->inheritProperty('foo');
$property->setValue('new value');

implement() metodu, verilen arayüzdeki ya da soyut sınıftaki tüm soyut metotları ve özellikleri sınıfınızda otomatik gerçekleştirir:

$manipulator->implement(SomeInterface::class);
// Artık sınıfınız SomeInterface arayüzünü gerçekleştiriyor ve tüm metotları için taslaklar içeriyor

Değişken Dökümü

Dumper sınıfı, bir değişkeni ayrıştırılabilir PHP koduna dönüştürür. Standart var_export() fonksiyonundan daha iyi ve daha anlaşılır bir çıktı sunar.

$dumper = new Nette\PhpGenerator\Dumper;

$var = ['a', 'b', 123];

echo $dumper->dump($var); // ['a', 'b', 123] çıktılar

Uyumluluk Tablosu

PhpGenerator 4.2, PHP 8.1'den 8.5'e dek uyumludur.

Daha yeni bir sürüme yükseltiyorsanız yükseltme sayfasına bakın.