nette/di 3.2

dependency-injection/bg/configuration.texy

@@ -228,6 +228,7 @@ search:
 search:
 	-	in: %appDir%
 		exclude:
+файлове: ...
 			classes: ...
 			extends: ...
 			implements: ...

dependency-injection/bg/factory.texy

@@ -170,39 +170,45 @@ services:
 interface MultiFactory
 {
 	function createArticle(): Article;
-	function createFoo(): Model\Foo;
 	function getDb(): PDO;
 }
 ```
 
 Така че вместо да предадем няколко генерирани фабрики и аксесори, ще предадем друга сложна фабрика, която може да прави повече.
 
-Алтернативно, вместо няколко метода, можем да използваме параметрите `create()` и `get()`:
+Вместо това можете да използвате `get()` с параметър вместо няколко метода:
 
 ```php
 interface MultiFactoryAlt
 {
-	function create($name);
 	function get($name): PDO;
 }
 ```
 
-Тогава `MultiFactory::createArticle()` прави същото като `MultiFactoryAlt::create('article')`. Алтернативният запис обаче има недостатъка, че не е ясно кои стойности поддържа `$name` и не е логически възможно да се разграничат различните стойности на връщане за различните `$name` в интерфейса.
+В този случай `MultiFactory::getArticle()` прави същото, което и `MultiFactoryAlt::get('article')`. Алтернативният синтаксис обаче има няколко недостатъка. Не е ясно кои стойности на `$name` се поддържат, а типът на връщане не може да бъде посочен в интерфейса, когато се използват няколко различни стойности на `$name`.
 
 
 Определение за списък .[#toc-definition-with-a-list]
 ----------------------------------------------------
-И как да дефинираме множество фабрики в конфигурацията? Ще създадем три услуги за създаване/извличане и след това самата фабрика:
+Този начин може да се използва за дефиниране на множество фабрики в конфигурацията: .{data-version:3.2.0}
+
+```neon
+services:
+	- MultiFactory(
+		article: Article                      # defines createArticle()
+		db: PDO(%dsn%, %user%, %password%)    # defines getDb()
+	)
+```
+
+Или в дефиницията на фабриката можем да се позовем на съществуващи услуги с помощта на референция:
 
 ```neon
 services:
 	article: Article
-	- Model\Foo
 	- PDO(%dsn%, %user%, %password%)
 	- MultiFactory(
-		article: @article  # createArticle()
-		foo: @Model\Foo    # createFoo()
-		db: @\PDO          # getDb()
+		article: @article    # defines createArticle()
+		db: @\PDO            # defines getDb()
 	)
 ```
 

dependency-injection/bg/services.texy

@@ -249,6 +249,13 @@ Collator::create(%locale%)
 @Nette\Database\Connection
 ```
 
+Използвайте синтаксис на първокласни извиквания: .{data-version:3.2.0}
+
+```neon
+# creating a callback, equivalent to [@user, logout]
+@user::logout(...)
+```
+
 Използвайте константи:
 
 ```neon

dependency-injection/cs/configuration.texy

@@ -228,6 +228,7 @@ Lze definovat i vylučující pravidla, tj. masky názvu třídy nebo dědičné
 search:
 	-	in: %appDir%
 		exclude:
+			files: ...
 			classes: ...
 			extends: ...
 			implements: ...

dependency-injection/cs/factory.texy

@@ -170,39 +170,45 @@ Naše továrny a accessory uměly zatím vždy vyrábět nebo vracet jen jeden o
 interface MultiFactory
 {
 	function createArticle(): Article;
-	function createFoo(): Model\Foo;
 	function getDb(): PDO;
 }
 ```
 
 Takže místo toho, abych si předávali několik generovaných továren a accessorů, předáme jednu komplexnější továrnu, která toho umí víc.
 
-Alternativně lze místo několika metod použít `create()` a `get()` s parameterem:
+Alternativně lze místo několika metod použít `get()` s parameterem:
 
 ```php
 interface MultiFactoryAlt
 {
-	function create($name);
 	function get($name): PDO;
 }
 ```
 
-Pak platí, že `MultiFactory::createArticle()` dělá totéž jako `MultiFactoryAlt::create('article')`. Nicméně alternativní zápis má tu nevýhodu, že není zřejmé, jaké hodnoty `$name` jsou podporované a logicky také nelze v rozhraní odlišit různé návratové hodnoty pro různé `$name`.
+Pak platí, že `MultiFactory::getArticle()` dělá totéž jako `MultiFactoryAlt::get('article')`. Nicméně alternativní zápis má tu nevýhodu, že není zřejmé, jaké hodnoty `$name` jsou podporované a logicky také nelze v rozhraní odlišit různé návratové hodnoty pro různé `$name`.
 
 
 Definice seznamem
 -----------------
-A jak definovat vícenásobnou továrnu v konfiguraci? Vytvoříme tři služby, které bude vytvářet/vracet, a potom samotnou továrnu:
+Tímto způsobem lze definovat vícenásobnou továrnu v konfiguraci: .{data-version:3.2.0}
+
+```neon
+services:
+	- MultiFactory(
+		article: Article                      # definuje createArticle()
+		db: PDO(%dsn%, %user%, %password%)    # definuje getDb()
+	)
+```
+
+Nebo se můžeme v definici továrny odkázat na existující služby pomocí reference:
 
 ```neon
 services:
 	article: Article
-	- Model\Foo
 	- PDO(%dsn%, %user%, %password%)
 	- MultiFactory(
-		article: @article  # createArticle()
-		foo: @Model\Foo    # createFoo()
-		db: @\PDO          # getDb()
+		article: @article    # definuje createArticle()
+		db: @\PDO            # definuje getDb()
 	)
 ```
 

dependency-injection/cs/services.texy

@@ -249,6 +249,13 @@ Odkazovat se na služby buď jejich jménem nebo pomocí typu:
 @Nette\Database\Connection
 ```
 
+Používat first-class callable syntax: .{data-version:3.2.0}
+
+```neon
+# vytvoření callbacku, obdoba [@user, logout]
+@user::logout(...)
+```
+
 Používat konstanty:
 
 ```neon

dependency-injection/de/configuration.texy

@@ -228,6 +228,7 @@ Sie können auch negative Regeln definieren, z. B. Klassennamensmasken oder Vorf
 search:
 	-	in: %appDir%
 		exclude:
+Dateien: ...
 			classes: ...
 			extends: ...
 			implements: ...

dependency-injection/de/factory.texy

@@ -170,39 +170,45 @@ Bisher konnten die Fabriken und Accessoren nur ein einziges Objekt erstellen ode
 interface MultiFactory
 {
 	function createArticle(): Article;
-	function createFoo(): Model\Foo;
 	function getDb(): PDO;
 }
 ```
 
 Anstatt mehrere generierte Fabriken und Accessoren zu übergeben, können Sie nur eine komplexe Multifabrik übergeben.
 
-Alternativ können Sie auch `create()` und `get()` mit einem Parameter anstelle mehrerer Methoden verwenden:
+Alternativ können Sie auch `get()` mit einem Parameter anstelle von mehreren Methoden verwenden:
 
 ```php
 interface MultiFactoryAlt
 {
-	function create($name);
 	function get($name): PDO;
 }
 ```
 
-In diesem Fall bewirkt `MultiFactory::createArticle()` das Gleiche wie `MultiFactoryAlt::create('article')`. Die alternative Syntax hat jedoch einige Nachteile. Es ist nicht klar, welche `$name` Werte unterstützt werden und der Rückgabetyp kann nicht in der Schnittstelle angegeben werden, wenn mehrere verschiedene `$name` Werte verwendet werden.
+In diesem Fall bewirkt `MultiFactory::getArticle()` dasselbe wie `MultiFactoryAlt::get('article')`. Die alternative Syntax hat jedoch einige Nachteile. Es ist nicht klar, welche `$name` Werte unterstützt werden, und der Rückgabetyp kann nicht in der Schnittstelle angegeben werden, wenn mehrere verschiedene `$name` Werte verwendet werden.
 
 
 Definition mit einer Liste .[#toc-definition-with-a-list]
 ---------------------------------------------------------
-Wie definieren Sie eine Multifabrik in Ihrer Konfiguration? Lassen Sie uns drei Dienste erstellen, die von der Multifabrik zurückgegeben werden, und die Multifabrik selbst:
+Auf diese Weise können Sie in der Konfiguration eine Mehrfachfabrik definieren: .{data-version:3.2.0}
+
+```neon
+services:
+	- MultiFactory(
+		article: Article                      # defines createArticle()
+		db: PDO(%dsn%, %user%, %password%)    # defines getDb()
+	)
+```
+
+Oder wir können in der Fabrikdefinition auf bestehende Dienste mit einer Referenz verweisen:
 
 ```neon
 services:
 	article: Article
-	- Model\Foo
 	- PDO(%dsn%, %user%, %password%)
 	- MultiFactory(
-		article: @article  # createArticle()
-		foo: @Model\Foo    # createFoo()
-		db: @\PDO          # getDb()
+		article: @article    # defines createArticle()
+		db: @\PDO            # defines getDb()
 	)
 ```
 

dependency-injection/de/services.texy

@@ -249,6 +249,13 @@ Beziehen Sie sich auf Dienste entweder durch ihren Namen oder durch ihren Typ:
 @Nette\Database\Connection
 ```
 
+Verwenden Sie die Syntax von First-Class Callables: .{data-version:3.2.0}
+
+```neon
+# creating a callback, equivalent to [@user, logout]
+@user::logout(...)
+```
+
 Verwenden Sie Konstanten:
 
 ```neon

dependency-injection/el/configuration.texy

@@ -228,6 +228,7 @@ search:
 search:
 	-	in: %appDir%
 		exclude:
+αρχεία: ...
 			classes: ...
 			extends: ...
 			implements: ...

dependency-injection/el/factory.texy

@@ -170,39 +170,45 @@ Multifactory/Accessor .[#toc-multifactory-accessor]
 interface MultiFactory
 {
 	function createArticle(): Article;
-	function createFoo(): Model\Foo;
 	function getDb(): PDO;
 }
 ```
 
 Αντί να περνάτε πολλαπλά παραγόμενα εργοστάσια και accessors, μπορείτε να περνάτε μόνο ένα σύνθετο multifactory.
 
-Εναλλακτικά, μπορείτε να χρησιμοποιήσετε τις διευθύνσεις `create()` και `get()` με μια παράμετρο αντί για πολλαπλές μεθόδους:
+Εναλλακτικά, μπορείτε να χρησιμοποιήσετε το `get()` με μια παράμετρο αντί για πολλαπλές μεθόδους:
 
 ```php
 interface MultiFactoryAlt
 {
-	function create($name);
 	function get($name): PDO;
 }
 ```
 
-Στην περίπτωση αυτή, η `MultiFactory::createArticle()` κάνει το ίδιο πράγμα με την `MultiFactoryAlt::create('article')`. Ωστόσο, η εναλλακτική σύνταξη έχει μερικά μειονεκτήματα. Δεν είναι σαφές ποιες τιμές `$name` υποστηρίζονται και ο τύπος επιστροφής δεν μπορεί να καθοριστεί στη διεπαφή όταν χρησιμοποιούνται πολλαπλές διαφορετικές τιμές `$name`.
+Σε αυτή την περίπτωση, το `MultiFactory::getArticle()` κάνει το ίδιο πράγμα με το `MultiFactoryAlt::get('article')`. Ωστόσο, η εναλλακτική σύνταξη έχει μερικά μειονεκτήματα. Δεν είναι σαφές ποιες τιμές `$name` υποστηρίζονται και ο τύπος επιστροφής δεν μπορεί να καθοριστεί στη διεπαφή όταν χρησιμοποιούνται πολλές διαφορετικές τιμές `$name`.
 
 
 Ορισμός με λίστα .[#toc-definition-with-a-list]
 -----------------------------------------------
-Πώς να ορίσετε ένα multifactory στη διαμόρφωσή σας; Ας δημιουργήσουμε τρεις υπηρεσίες που θα επιστρέφονται από το multifactory, καθώς και το ίδιο το multifactory:
+Αυτός ο τρόπος μπορεί να χρησιμοποιηθεί για τον ορισμό ενός πολλαπλού εργοστασίου στη διαμόρφωση: .{data-version:3.2.0}
+
+```neon
+services:
+	- MultiFactory(
+		article: Article                      # defines createArticle()
+		db: PDO(%dsn%, %user%, %password%)    # defines getDb()
+	)
+```
+
+Ή, στον ορισμό του εργοστασίου, μπορούμε να αναφερθούμε σε υπάρχουσες υπηρεσίες χρησιμοποιώντας μια αναφορά:
 
 ```neon
 services:
 	article: Article
-	- Model\Foo
 	- PDO(%dsn%, %user%, %password%)
 	- MultiFactory(
-		article: @article  # createArticle()
-		foo: @Model\Foo    # createFoo()
-		db: @\PDO          # getDb()
+		article: @article    # defines createArticle()
+		db: @\PDO            # defines getDb()
 	)
 ```
 

dependency-injection/el/services.texy

@@ -249,6 +249,13 @@ Collator::create(%locale%)
 @Nette\Database\Connection
 ```
 
+Χρησιμοποιήστε σύνταξη πρώτης κατηγορίας callable: .{data-version:3.2.0}
+
+```neon
+# creating a callback, equivalent to [@user, logout]
+@user::logout(...)
+```
+
 Χρήση σταθερών:
 
 ```neon

dependency-injection/en/configuration.texy

@@ -228,6 +228,7 @@ You can also define negative rules, ie class name masks or ancestors and if they
 search:
 	-	in: %appDir%
 		exclude:
+			files: ...
 			classes: ...
 			extends: ...
 			implements: ...

dependency-injection/en/factory.texy

@@ -170,39 +170,45 @@ So far, the factories and accessors could only create or return just one object.
 interface MultiFactory
 {
 	function createArticle(): Article;
-	function createFoo(): Model\Foo;
 	function getDb(): PDO;
 }
 ```
 
 Instead of passing multiple generated factories and accessors, you can pass just one complex multifactory.
 
-Alternatively, you can use `create()` and `get()` with a parameter instead of multiple methods:
+Alternatively, you can use `get()` with a parameter instead of multiple methods:
 
 ```php
 interface MultiFactoryAlt
 {
-	function create($name);
 	function get($name): PDO;
 }
 ```
 
-In this case, `MultiFactory::createArticle()` does the same thing as `MultiFactoryAlt::create('article')`. However, the alternative syntax has a few disadvantages. It's not clear which `$name` values are supported and the return type cannot be specified in the interface when using multiple different `$name` values.
+In this case, `MultiFactory::getArticle()` does the same thing as `MultiFactoryAlt::get('article')`. However, the alternative syntax has a few disadvantages. It's not clear which `$name` values are supported and the return type cannot be specified in the interface when using multiple different `$name` values.
 
 
 Definition with a List
 ----------------------
-Hos to define a multifactory in your configuration? Let's create three services which will be returned by the multifactory, and the multifactory itself:
+This way can be used to define a multiple factory in the configuration: .{data-version:3.2.0}
+
+```neon
+services:
+	- MultiFactory(
+		article: Article                      # defines createArticle()
+		db: PDO(%dsn%, %user%, %password%)    # defines getDb()
+	)
+```
+
+Or, in the factory definition, we can refer to existing services using a reference:
 
 ```neon
 services:
 	article: Article
-	- Model\Foo
 	- PDO(%dsn%, %user%, %password%)
 	- MultiFactory(
-		article: @article  # createArticle()
-		foo: @Model\Foo    # createFoo()
-		db: @\PDO          # getDb()
+		article: @article    # defines createArticle()
+		db: @\PDO            # defines getDb()
 	)
 ```
 

dependency-injection/en/services.texy

@@ -249,6 +249,13 @@ Refer to services either by their name or by type:
 @Nette\Database\Connection
 ```
 
+Use first-class callable syntax: .{data-version:3.2.0}
+
+```neon
+# creating a callback, equivalent to [@user, logout]
+@user::logout(...)
+```
+
 Use constants:
 
 ```neon

dependency-injection/es/configuration.texy

@@ -228,6 +228,7 @@ También se pueden definir reglas negativas, es decir, máscaras de nombres de c
 search:
 	-	in: %appDir%
 		exclude:
+archivos: ...
 			classes: ...
 			extends: ...
 			implements: ...