partial multiple translations added

Author: petk

book/templating.rst

@@ -487,6 +487,52 @@ To get the Profiler for the last request, do the following::
 For specific details on using the profiler inside a test, see the
 :doc:`/cookbook/testing/profiling` cookbook entry.
 
+To avoid collecting data in each test you can set the ``collect`` parameter
+in the configuration:
+
+.. configuration-block::
+
+    .. code-block:: yaml
+
+        # app/config/config_test.yml
+
+        # ...
+        framework:
+            profiler:
+                enabled: true
+                collect: false
+
+    .. code-block:: xml
+
+        <!-- app/config/config.xml -->
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <container xmlns="http://symfony.com/schema/dic/services"
+            xmlns:framework="http://symfony.com/schema/dic/symfony"
+            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd
+                        http://symfony.com/schema/dic/symfony http://symfony.com/schema/dic/symfony/symfony-1.0.xsd">
+
+            <!-- ... -->
+
+            <framework:config>
+                <framework:profiler enabled="true" collect="false" />
+            </framework:config>
+        </container>
+
+    .. code-block:: php
+
+        // app/config/config.php
+
+        // ...
+        $container->loadFromExtension('framework', array(
+            'profiler' => array(
+                'enabled' => true,
+                'collect' => false,
+            ),
+        ));
+
+In this way only tests that call ``enableProfiler()`` will collect data.
+
 Redirecting
 ~~~~~~~~~~~
 

book/testing.rst

@@ -1,20 +1,20 @@
 DoctrineFixturesBundle
 ======================
 
-Fixtures are used to load a controlled set of data into a database. This data
-can be used for testing or could be the initial data required for the
-application to run smoothly. Symfony2 has no built in way to manage fixtures
-but Doctrine2 has a library to help you write fixtures for the Doctrine
-:doc:`ORM</book/doctrine>` or :doc:`ODM</bundles/DoctrineMongoDBBundle/index>`.
+Fiksni podatki (t.i. fixtures) so uporabljeni za nalaganje krmiljenega skupka podatkov v podatkovno bazo. Ti podatki
+so lahko uporabljeni za testiranje ali so lahko začetni podatki zahtevani, da
+aplikacija tekoče deluje. Symfony2 nima vgrajenega načina za upravljanje fiksnih podatkov,
+vendar Doctrine2 ima knjižnico, ki vam pomaga pisati fiksne podatke za Doctrine
+:doc:`ORM</book/doctrine>` ali :doc:`ODM</bundles/DoctrineMongoDBBundle/index>`.
 
-Setup and Configuration
------------------------
+Nastavitve in konfiguracija
+---------------------------
 
-Doctrine fixtures for Symfony are maintained in the `DoctrineFixturesBundle`_.
-The bundle uses external `Doctrine Data Fixtures`_ library.
+Doctrine fiksni podatki za Symfony so vzdrževani v `DoctrineFixturesBundle`_.
+Ta paket uporablja zunanjo knjižnico `Doctrine Data Fixtures`_.
 
-Follow these steps to install the bundle and the library in the Symfony
-Standard edition. Add the following to your ``composer.json`` file:
+Sledite tem korakom za namestitev paketa in knjižnice v Symfony
+standardno izdajo. Dodajte sledeče v vašo datoteko ``composer.json``:
 
 .. code-block:: json
 
@@ -24,22 +24,22 @@ Standard edition. Add the following to your ``composer.json`` file:
         }
     }
 
-Update the vendor libraries:
+Posodobite knjižnice vendor:
 
 .. code-block:: bash
 
     $ php composer.phar update doctrine/doctrine-fixtures-bundle
 
-If everything worked, the ``DoctrineFixturesBundle`` can now be found
-at ``vendor/doctrine/doctrine-fixtures-bundle``.
+Če je vse delovalo v redu, je lahko sedaj ``DoctrineFixturesBundle`` najden
+v ``vendor/doctrine/doctrine-fixtures-bundle``.
 
 .. note::
 
-    ``DoctrineFixturesBundle`` installs
-    `Doctrine Data Fixtures`_ library. The library can be found
-    at ``vendor/doctrine/data-fixtures``.
+    ``DoctrineFixturesBundle`` namesti
+    knjižnico `Doctrine Data Fixtures`_. Knjižnico je moč najti
+    v ``vendor/doctrine/data-fixtures``.
 
-Finally, register the Bundle ``DoctrineFixturesBundle`` in ``app/AppKernel.php``.
+Na koncu registrirajte paket ``DoctrineFixturesBundle`` v ``app/AppKernel.php``.
 
 .. code-block:: php
 
@@ -54,21 +54,21 @@ Finally, register the Bundle ``DoctrineFixturesBundle`` in ``app/AppKernel.php``
         // ...
     }
 
-Writing Simple Fixtures
------------------------
+Pisanje enostavnih fiksnih podatkov
+-----------------------------------
 
-Doctrine2 fixtures are PHP classes where you can create objects and persist
-them to the database. Like all classes in Symfony2, fixtures should live inside
-one of your application bundles.
+Doctrine2 fiksni podatki so razredi PHP, kjer lahko ustvarite objekte in jih podate
+v podatkovno bazo. Kot vsi razredi v Symfony2 bi morali fiksni podatki obstojati znotraj
+enega izmed vaših paketov aplikacije.
 
-For a bundle located at ``src/Acme/HelloBundle``, the fixture classes
-should live inside ``src/Acme/HelloBundle/DataFixtures/ORM`` or
-``src/Acme/HelloBundle/DataFixtures/MongoDB`` respectively for the ORM and ODM,
-This tutorial assumes that you are using the ORM - but fixtures can be added
-just as easily if you're using the ODM.
+Za paket lociran v ``src/Acme/HelloBundle`` bi se morali razredi fiksnih podatkov
+nahajati znotraj ``src/Acme/HelloBundle/DataFixtures/ORM`` ali
+``src/Acme/HelloBundle/DataFixtures/MongoDB`` za ORM in ODM.
+Ta vodič predpostavlja, da uporabljate ORM - vendar fiksni podatki so lahko dodani
+enako enostavno, če uporabljate ODM.
 
-Imagine that you have a ``User`` class, and you'd like to load one ``User``
-entry:
+Predstavljajte si, da imate razred ``User`` in bi želeli naložiti eno entiteto
+``User``:
 
 .. code-block:: php
 
@@ -96,66 +96,66 @@ entry:
         }
     }
 
-In Doctrine2, fixtures are just objects where you load data by interacting
-with your entities as you normally do. This allows you to create the exact
-fixtures you need for your application.
+V Doctrine2 so fiksni podatki samo objekti, kjer naložite podatke z interakcijo
+z vašimi entitetami kot to običajno naredite. To vam omogoča, da ustvarite točne
+fiksne podatke, ki jih potrebujete za vašo aplikacijo.
 
-The most serious limitation is that you cannot share objects between fixtures.
-Later, you'll see how to overcome this limitation.
+Najresnejša omejitev je, da ne morete deliti objektov med fiksnimi podatki.
+Kasneje boste videli, kako to omejitev premagati.
 
-Executing Fixtures
-------------------
+Izvrševanje fiksnih podatkov
+----------------------------
 
-Once your fixtures have been written, you can load them via the command
-line by using the ``doctrine:fixtures:load`` command:
+Ko so enkrat fiksni podatki bili napisani, jih lahko naložite preko ukazne
+vrstice z uporabo ukaza ``doctrine:fixtures:load``:
 
 .. code-block:: bash
 
     php app/console doctrine:fixtures:load
 
-If you're using the ODM, use the ``doctrine:mongodb:fixtures:load`` command instead:
+Če uporabljate ODM, uporabite namesto tega ukaz ``doctrine:mongodb:fixtures:load``:
 
 .. code-block:: bash
 
     php app/console doctrine:mongodb:fixtures:load
 
-The task will look inside the ``DataFixtures/ORM`` (or ``DataFixtures/MongoDB``
-for the ODM) directory of each bundle and execute each class that implements
-the ``FixtureInterface``.
+Opravilo bo pogledalo znotraj ``DataFixtures/ORM`` (ali ``DataFixtures/MongoDB``
+za ODM) direktorij za vsak paket in izvršilo vsak razred, ki implementira
+``FixtureInterface``.
 
-Both commands come with a few options:
+Oba ukaza prihajata z nekaj opcijami:
 
-* ``--fixtures=/path/to/fixture`` - Use this option to manually specify the
-  directory where the fixtures classes should be loaded;
+* ``--fixtures=/path/to/fixture`` - Uporabite to opcijo, da ročno določite
+  direktorij, kjer bi morali biti naloženi razredi fiksnih podatkov;
 
-* ``--append`` - Use this flag to append data instead of deleting data before
-  loading it (deleting first is the default behavior);
+* ``--append`` - Uporabite to zastavico, da pripnete podatke namesto brisanja podatkov pred
+  nalaganjem (brisanje najprej je privzeto obnašanje);
 
-* ``--em=manager_name`` - Manually specify the entity manager to use for
-  loading the data.
+* ``--em=manager_name`` - Ročno določite upravljalnika entitet za uporabo pri
+  nalaganju podatkov.
 
 .. note::
 
-   If using the ``doctrine:mongodb:fixtures:load`` task, replace the ``--em=``
-   option with ``--dm=`` to manually specify the document manager.
+   Če uporabljate opravilo ``doctrine:mongodb:fixtures:load``, zamenjajte opcijo ``--em=``
+   z ``--dm=``, da ročno določite upravljalnika dokumenta.
 
-A full example use might look like this:
+Celotni primer uporabe lahko izgleda takole:
 
 .. code-block:: bash
 
    php app/console doctrine:fixtures:load --fixtures=/path/to/fixture1 --fixtures=/path/to/fixture2 --append --em=foo_manager
 
-Sharing Objects between Fixtures
---------------------------------
+Deljenje objektov med fiksnimi podatki
+--------------------------------------
 
-Writing a basic fixture is simple. But what if you have multiple fixture classes
-and want to be able to refer to the data loaded in other fixture classes?
-For example, what if you load a ``User`` object in one fixture, and then
-want to refer to reference it in a different fixture in order to assign that
-user to a particular group?
+Pisanje osnovnih fiksnih podatkov je enostavno. Vendar kaj, če imate več razredov fiksnih podatkov
+in želite biti zmožni se sklicevati na podatke naložene v drugih razredih fiksnih podatkov?
+Na primer, kaj če želite naložiti objekt ``User`` v enem fiksnem podatki in nato
+se želite sklicevati na njegov sklic v drugem fiksnem podatku, da določite tega uporabnika
+določeni skupini?
 
-The Doctrine fixtures library handles this easily by allowing you to specify
-the order in which fixtures are loaded.
+Knjižnica Doctrine fixtures upravlja s tem enostavno z omogočanjem vam, da določite
+vrstni red v katerem so fiksni podatki naloženi.
 
 .. code-block:: php
 
@@ -193,10 +193,10 @@ the order in which fixtures are loaded.
         }
     }
 
-The fixture class now implements ``OrderedFixtureInterface``, which tells
-Doctrine that you want to control the order of your fixtures. Create another
-fixture class and make it load after ``LoadUserData`` by returning an order
-of 2:
+Razred fiksnih podatkov sedaj implementira ``OrderedFixtureInterface``, ki pove
+Doctrine, da želite kontrolirati vrstni red vaših fiksnih podatkov. Ustvarite drug
+razred fiksnih podatkov in ga naložite za ``LoadUserData`` z vračilom vrstnega reda
+2:
 
 .. code-block:: php
 
@@ -234,11 +234,11 @@ of 2:
         }
     }
 
-Both of the fixture classes extend ``AbstractFixture``, which allows you
-to create objects and then set them as references so that they can be used
-later in other fixtures. For example, the ``$userAdmin`` and ``$groupAdmin``
-objects can be referenced later via the ``admin-user`` and ``admin-group``
-references:
+Oba razreda fiksnih podatkov razširjata ``AbstractFixture``, ki vam omogočata
+ustvariti objekte in jih nato nastaviti kot sklice, da sta lahko uporabljena
+kasneje v drugih fiksnih podatkih. Na primer objekta ``$userAdmin`` in ``$groupAdmin``
+sta lahko sklicana kasneje preko sklicev ``admin-user`` in
+``admin-group``:
 
 .. code-block:: php
 
@@ -275,26 +275,26 @@ references:
         }
     }
 
-The fixtures will now be executed in the ascending order of the value returned
-by ``getOrder()``. Any object that is set with the ``setReference()`` method
-can be accessed via ``getReference()`` in fixture classes that have a higher
-order.
+Fiksni podatki bodo sedaj izvršeni v naraščajočem vrstnem redu vrnjene vrednosti
+z ``getOrder()``. Katerikoli objekt, ki je nastavljen z metodo ``setReference()``
+je lahko dostopan preko ``getReference()`` v razredu fiksnih podatkov, ki imajo višji
+vrstni red.
 
-Fixtures allow you to create any type of data you need via the normal PHP
-interface for creating and persisting objects. By controlling the order of
-fixtures and setting references, almost anything can be handled by fixtures.
+Fiksni podatki vam omogočajo ustvariti kakršnikoli tip podatkov potrebujete preko običajnega PHP
+vmesnika za izdelavo in pridobivanje objektov. S krmiljenjem vrstnega reda
+fiksnih podatkov in nastavitvijo sklicev je lahko skoraj vse upravljano s strani fiksnih podatkov.
 
-Using the Container in the Fixtures
------------------------------------
+Uporaba kontejnerja v fiksnih podatkih
+--------------------------------------
 
-In some cases you may need to access some services to load the fixtures.
-Symfony2 makes it really easy: the container will be injected in all fixture
-classes implementing :class:`Symfony\\Component\\DependencyInjection\\ContainerAwareInterface`.
+V nekaterih primerih boste morda potrebovali dostopati do storitev in naložiti fiksne podatke.
+Symfony2 naredi to res enostavno: kontejner bo injiciran v vse
+razrede fiksnih podatkov, ki implementirajo :class:`Symfony\\Component\\DependencyInjection\\ContainerAwareInterface`.
 
-Let's rewrite the first fixture to encode the password before it's stored
-in the database (a very good practice). This will use the encoder factory
-to encode the password, ensuring it is encoded in the way used by the security
-component when checking it:
+Prepišimo prvi fiksni podatek za enkodiranje gesla preden je shranjen
+v podatkovno bazo (zelo dobra praksa). To bo uporabilo tovarno enkoder
+za enkodiranje gesla in zagotavljalo, da je enkodirano na način uporabljen s strani varnostne
+komponente, ko se ga preverja:
 
 .. code-block:: php
 
@@ -343,17 +343,17 @@ component when checking it:
         }
     }
 
-As you can see, all you need to do is add :class:`Symfony\\Component\\DependencyInjection\\ContainerAwareInterface`
-to the class and then create a new :method:`Symfony\\Component\\DependencyInjection\\ContainerInterface::setContainer`
-method that implements that interface. Before the fixture is executed, Symfony
-will call the :method:`Symfony\\Component\\DependencyInjection\\ContainerInterface::setContainer`
-method automatically. As long as you store the container as a property on the
-class (as shown above), you can access it in the ``load()`` method.
+Kot vidite, je vse kar je potrebno dodati, :class:`Symfony\\Component\\DependencyInjection\\ContainerAwareInterface`
+razredu in nato ustvariti novo metodo :method:`Symfony\\Component\\DependencyInjection\\ContainerInterface::setContainer`,
+ki implementira ta vmesnik. Preden je fiksni podatek izvršen, bo Symfony
+poklical metodo :method:`Symfony\\Component\\DependencyInjection\\ContainerInterface::setContainer`
+avtomatično. Dokler shranjujete kontejner kot lastnost na
+razredu (kot prikazano zgoraj), lahko do njega dostopate v metodi ``load()``.
 
 .. note::
 
-    If you are too lazy to implement the needed method :method:`Symfony\\Component\\DependencyInjection\\ContainerInterface::setContainer`,
-    you can then extend your class with :class:`Symfony\\Component\\DependencyInjection\\ContainerAware`.
+    Če ste preveč leni za implementacijo potrebne metode :method:`Symfony\\Component\\DependencyInjection\\ContainerInterface::setContainer`,
+    lahko vaš razred razširite z :class:`Symfony\\Component\\DependencyInjection\\ContainerAware`.
 
 .. _DoctrineFixturesBundle: https://github.com/doctrine/DoctrineFixturesBundle
 .. _`Doctrine Data Fixtures`: https://github.com/doctrine/data-fixtures