Contributing to the Documentation Symfony 2.0 by Jonathand Serrano.

root · root · commit 05850200bd7a · 2011-06-02T08:10:56.000-05:00
diff --git a/book/doctrine/orm.rst b/book/doctrine/orm.rst
@@ -234,6 +234,13 @@ you just need to run the following command:
 Now your database will be updated and the new column added to the database
 table.
 
+In this case we can easily obtain an object of our entity from the id as follows:
+
+* @extra: Route ("/ path / {id} /", name = "_path_name)
+* @extra ParameterConverter ("parameter" class = "MyBundle: Entity")
+
+Having done this the parameter that is entered by the function will be an object of our entity
+
 .. index::
    single: Configuration; Doctrine ORM
    single: Doctrine; ORM Configuration
@@ -285,6 +292,9 @@ The following example shows an overview of the caching configurations:
                 port: 11211
                 instance_class: Memcache
 
+ 
+This will allow us to specify that everything will work from PHP
+
 Mapping Configuration
 ~~~~~~~~~~~~~~~~~~~~~
 
@@ -352,6 +362,18 @@ The following configuration shows a bunch of mapping examples:
                     dir: %kernel.root_dir%/../src/vendor/DoctrineExtensions/lib/DoctrineExtensions/Entity
                     prefix: DoctrineExtensions\Entity\
                     alias: DExt
+You should be aware that you can also espeficar the configuration of each bundle, as follows:
+
+/ app / config / config.yml
+orm:
+         auto_generate_proxy_classes:% kernel.debug%
+         default_entity_manager: default
+         entity_managers:
+             default:
+                 mappings:
+                     AcmeDemoBundle: ~
+                     MyBundle:
+                         type: annotation
 
 Multiple Entity Managers
 ~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/book/forms.rst b/book/forms.rst
@@ -666,6 +666,10 @@ Placing the form logic into its own class means that the form can be easily
 reused elsewhere in your project. This is the best way to create forms, but
 the choice is ultimately up to you.
 
+The documentation for beginners on this is very confusing, since it takes into account detailed aspects for understanding the concepts and apply them easily. It should make a tutorial step by step detail to ensure a specific outcome.
+
+It should specify about AbstractType class that contains methods and how to get data for Form class
+
 .. index::
    single: Forms; Doctrine
 
@@ -714,7 +718,7 @@ Embedded Forms
 --------------
 
 Often, you'll want to build a form that will include fields from many different
-objects. For example, a registration form must contain data belonging to
+objects. For example, a registration form must (required) contain data belonging to
 a ``User`` object as well as many ``Address`` objects. Fortunately, this
 is easy and natural with the form component.
 
diff --git a/book/testing.rst b/book/testing.rst
@@ -19,6 +19,19 @@ it yet, you can read its excellent `documentation`_.
 
     Symfony2 works with PHPUnit 3.5.11 or later.
 
+For linux:
+How to install phpunit in 2 steps:
+1. Installing and upgrading PHP Pear.
+To install phpunit, go to the console:
+      $ sudo apt-get update
+      $ sudo apt-get install php-pear
+      $ sudo pear upgrade pear
+2. Adding channels, downloading and installing PHPUnit
+     $ pear channel-discover pear.phpunit.de
+     $ pear channel-discover components.ez.no
+     $ pear channel-discover pear.symfony-project.com
+     $pear install phpunit / PHPUnit
+
 The default PHPUnit configuration looks for tests under the ``Tests/``
 sub-directory of your bundles:
 
@@ -121,13 +134,25 @@ for ``HelloController`` that reads as follows::
         }
     }
 
-The ``createClient()`` method returns a client tied to the current application::
+The ``createClient()`` method returns a client tied to the current application.This client is the one used during the test, the client can perform all actions that would conduct a customer in practice::
 
     $crawler = $client->request('GET', 'hello/Fabien');
 
 The ``request()`` method returns a ``Crawler`` object which can be used to
 select elements in the Response, to click on links, and to submit forms.
 
+..Notes:: 
+	The functions that are protected by authentication security, the customer must enter the simulation through the system and apply the tests to each of the 		functions. If authentication is not performed, will not be possible to test these functions.It is very important to use the same client throughout the test. 
+ 	For example:
+	$client = $this->createClient();
+        $crawler = $client->request('GET', '/login');
+        $form = $crawler->selectButton('login')->form();
+        $client->submit($form,array('_username'=>'admin',
+                                    '_password'=>'adminpass',));
+	//....your test
+
+
+
 .. tip::
 
     The Crawler can only be used if the Response content is an XML or an HTML
diff --git a/quick_tour/the_architecture.rst b/quick_tour/the_architecture.rst
@@ -108,6 +108,10 @@ to use pre-built features packaged in third-party bundles or to distribute
 your own bundles. It makes it easy to pick and choose which features to enable
 in your application and optimize them the way you want.
 
+For beginners:
+Within the project we created a file.php usually called, the name of the folder of my project, followed by the name of the bundle folder. That is, if my project is called JAS, and the folder of my bundle is called TutorialBundle, my Bundle JASTutorialBundle be called, that is to follow a standard symfony project.
+
+
 Registering a Bundle
 ~~~~~~~~~~~~~~~~~~~~
 
diff --git a/quick_tour/the_controller.rst b/quick_tour/the_controller.rst
@@ -56,6 +56,9 @@ match. In this example, if you try to request the ``/demo/hello/Fabien.js``
 resource, you will get a 404 HTTP error, as it does not match the ``_format``
 requirement.
 
+For beginners: 
+the controllers are created in a folder called Controller, in our project folder and turn in the respective folder Bundle. The name of the Controller (by convention) ends in the word Controller, that is, if my Controller is called tutorial, you should be tutorialController. 
+
 Redirecting and Forwarding
 --------------------------
 
@@ -252,4 +255,4 @@ That's all there is to it, and I'm not even sure we have spent the full
 10 minutes. We briefly introduced bundles in the first part, and all the
 features we've learned about so far are part of the core framework bundle.
 But thanks to bundles, everything in Symfony2 can be extended or replaced.
-That's the topic of the next part of this tutorial.
+That's the topic of the next part of this tutorial.
