[MANUAL] English:

- structural fixes (no translations needed)

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@20810 44c647ce-9c0f-0410-b52a-842ac1e357ba

documentation/manual/en/module_specs/Zend_Service-ReCaptcha.xml

@@ -37,6 +37,7 @@
 
         <example id="zend.service.recaptcha.example-1">
             <title>Creating an instance of the reCAPTCHA service</title>
+
             <programlisting language="php"><![CDATA[
 $recaptcha = new Zend_Service_ReCaptcha($pubKey, $privKey);
 ]]></programlisting>
@@ -49,6 +50,7 @@ $recaptcha = new Zend_Service_ReCaptcha($pubKey, $privKey);
 
         <example id="zend.service.recaptcha.example-2">
             <title>Displaying the reCAPTCHA</title>
+
             <programlisting language="php"><![CDATA[
 echo $recaptcha->getHTML();
 ]]></programlisting>
@@ -62,6 +64,7 @@ echo $recaptcha->getHTML();
 
         <example id="zend.service.recaptcha.example-3">
             <title>Verifying the form fields</title>
+
             <programlisting language="php"><![CDATA[
 $result = $recaptcha->verify(
     $_POST['recaptcha_challenge_field'],
@@ -78,6 +81,7 @@ $result = $recaptcha->verify(
 
         <example id="zend.service.recaptcha.example-4">
             <title>Validating the reCAPTCHA</title>
+
             <programlisting language="php"><![CDATA[
 if (!$result->isValid()) {
     // Failed validation
@@ -105,13 +109,16 @@ if (!$result->isValid()) {
             window with a reCAPTCHA challenge. Solving the challenge will reveal the complete
             email address.
         </para>
+
         <para>
             In order to use this component you will need
             <ulink url="http://recaptcha.net/whyrecaptcha.html">an account</ulink> to generate
             public and private keys for the mailhide API.
         </para>
+
         <example id="zend.service.recaptcha.mailhide.example-1">
             <title>Using the mail hide component</title>
+
             <programlisting language="php"><![CDATA[
 // The mail address we want to hide
 $mail = 'mail@example.com';
@@ -127,16 +134,20 @@ $mailHide->setEmail($mail);
 print($mailHide);
 ]]></programlisting>
         </example>
+
         <para>
             The example above will display "m...@example.com" where "..." has a link that opens up
             a popup window with a reCAPTCHA challenge.
         </para>
+
         <para>
             The public key, private key, and the email address can also be specified in the
             constructor of the class. A fourth argument also exists that enables you to set some
             options for the component. The available options are listed in the following table:
+
             <table id="zend.service.recaptcha.mailhide.options.table">
                 <title>Zend_Service_ReCaptcha_MailHide options</title>
+
                 <tgroup cols="4">
                     <thead>
                         <row>
@@ -146,6 +157,7 @@ print($mailHide);
                             <entry>Default Value</entry>
                         </row>
                     </thead>
+
                     <tbody>
                         <row>
                             <entry>linkTitle</entry>
@@ -153,18 +165,21 @@ print($mailHide);
                             <entry>string</entry>
                             <entry>'Reveal this e-mail address'</entry>
                         </row>
+
                         <row>
                             <entry>linkHiddenText</entry>
                             <entry>The text that includes the popup link</entry>
                             <entry>string</entry>
                             <entry>'...'</entry>
                         </row>
+
                         <row>
                             <entry>popupWidth</entry>
                             <entry>The width of the popup window</entry>
                             <entry>int</entry>
                             <entry>500</entry>
                         </row>
+
                         <row>
                             <entry>popupHeight</entry>
                             <entry>The height of the popup window</entry>
@@ -175,13 +190,16 @@ print($mailHide);
                 </tgroup>
             </table>
         </para>
+
         <para>
             The configuration options can be set by sending them as the fourth argument to the
             constructor or by calling <methodname>setOptions($options)</methodname>, which takes
             an associative array or an instance of <link linkend="zend.config">Zend_Config</link>.
         </para>
+
         <example id="zend.service.recaptcha.mailhide.example-2">
             <title>Generating many hidden email addresses</title>
+
             <programlisting language="php"><![CDATA[
 // Create an instance of the mailhide component, passing it your public
 // and private keys, as well as some configuration options

documentation/manual/en/module_specs/Zend_Service_WindowsAzure.xml

@@ -65,7 +65,6 @@
                 documentation</ulink> for detailed description of the service. You will need to be
             familiar with basic concepts in order to use this service.
         </para>
-
     </sect2>
 
     <sect2 id="zend.service.windowsazure.features">
@@ -111,9 +110,9 @@
             Windows Azure's features, no matter if it is hosted on the Windows Azure platform or on
             an in-premise web server.
         </para>
-  </sect2>
+    </sect2>
 
-  <xi:include href="Zend_Service_WindowsAzure_Blob.xml" />
-  <xi:include href="Zend_Service_WindowsAzure_Table.xml" />
-  <xi:include href="Zend_Service_WindowsAzure_Queue.xml" />
+    <xi:include href="Zend_Service_WindowsAzure_Blob.xml" />
+    <xi:include href="Zend_Service_WindowsAzure_Table.xml" />
+    <xi:include href="Zend_Service_WindowsAzure_Queue.xml" />
 </sect1>

documentation/manual/en/module_specs/Zend_Service_WindowsAzure_Table.xml

@@ -332,9 +332,10 @@ public $Age;
                 To use the <classname>Zend_Service_WindowsAzure_Storage_Table</classname> class
                 without defining a schema, you can make use of the
                 <classname>Zend_Service_WindowsAzure_Storage_DynamicTableEntity</classname> class.
-                This class inherits <classname>Zend_Service_WindowsAzure_Storage_TableEntity</classname>
-                like an enforced schema class does, but contains additional logic to make it dynamic
-                and not bound to a schema.
+                This class inherits
+                <classname>Zend_Service_WindowsAzure_Storage_TableEntity</classname> like an
+                enforced schema class does, but contains additional logic to make it dynamic and not
+                bound to a schema.
             </para>
 
             <para>
@@ -378,7 +379,10 @@ public $Age;
             </para>
 
             <example id="zend.service.windowsazure.storage.table.entities.dynamic.schema">
-                <title>Dynamicaly adding properties to Zend_Service_WindowsAzure_Storage_DynamicTableEntity</title>
+                <title>
+                    Dynamicaly adding properties
+                    Zend_Service_WindowsAzure_Storage_DynamicTableEntity
+                </title>
 
                 <programlisting language="php"><![CDATA[
 $target = new Zend_Service_WindowsAzure_Storage_DynamicTableEntity(
@@ -393,8 +397,11 @@ $target->Age  = 25;     // Will add property "Age" of type "Edm.Int32"
                 Optionally, a property type can be enforced:
             </para>
 
-            <example id="zend.service.windowsazure.storage.table.entities.dynamic.schema-forcedproperties">
-                <title>Forcing property types on Zend_Service_WindowsAzure_Storage_DynamicTableEntity</title>
+            <example
+                id="zend.service.windowsazure.storage.table.entities.dynamic.schema-forcedproperties">
+                <title>
+                    Forcing property types on Zend_Service_WindowsAzure_Storage_DynamicTableEntity
+                </title>
 
                 <programlisting language="php"><![CDATA[
 $target = new Zend_Service_WindowsAzure_Storage_DynamicTableEntity(
@@ -456,7 +463,8 @@ echo 'Etag: ' . $result->getEtag() . "\n";
                     key.  Note that the table and entity have already been created before.
                 </para>
 
-                <example id="zend.service.windowsazure.storage.table.entities.api.retrieve-by-id.example">
+                <example
+                    id="zend.service.windowsazure.storage.table.entities.api.retrieve-by-id.example">
                     <title>Retrieving an entity by partition key and row key</title>
 
                     <programlisting language="php"><![CDATA[
@@ -501,7 +509,8 @@ $result = $storageClient->updateEntity('testtable', $entity);
                     newer data.
                 </para>
 
-                <example id="zend.service.windowsazure.storage.table.entities.api.updating.example-etag">
+                <example
+                    id="zend.service.windowsazure.storage.table.entities.api.updating.example-etag">
                     <title>Updating an entity (with Etag check)</title>
 
                     <programlisting language="php"><![CDATA[

documentation/manual/en/module_specs/Zend_Session-AdvancedUsage.xml

@@ -1,43 +1,42 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- Reviewed: no -->
 <sect1 id="zend.session.advanced_usage">
-
     <title>Advanced Usage</title>
 
     <para>
-        While the basic usage examples are a perfectly acceptable way to utilize Zend Framework sessions, there are some
-        best practices to consider. This section discusses the finer details of session handling and illustrates more
-        advanced usage of the <classname>Zend_Session</classname> component.
+        While the basic usage examples are a perfectly acceptable way to utilize Zend Framework
+        sessions, there are some best practices to consider. This section discusses the finer
+        details of session handling and illustrates more advanced usage of the
+        <classname>Zend_Session</classname> component.
     </para>
 
     <sect2 id="zend.session.advanced_usage.starting_a_session">
-
         <title>Starting a Session</title>
 
         <para>
-            If you want all requests to have a session facilitated by <classname>Zend_Session</classname>, then start the session in the
-            bootstrap file:
+            If you want all requests to have a session facilitated by
+            <classname>Zend_Session</classname>, then start the session in the bootstrap file:
         </para>
 
         <example id="zend.session.advanced_usage.starting_a_session.example">
-
             <title>Starting the Global Session</title>
 
             <programlisting language="php"><![CDATA[
 Zend_Session::start();
 ]]></programlisting>
-
         </example>
 
         <para>
-            By starting the session in the bootstrap file, you avoid the possibility that your session might be started
-            after headers have been sent to the browser, which results in an exception, and possibly a broken page for
-            website viewers. Various advanced features require <methodname>Zend_Session::start()</methodname> first. (More on
-            advanced features later.)
+            By starting the session in the bootstrap file, you avoid the possibility that your
+            session might be started after headers have been sent to the browser, which results in
+            an exception, and possibly a broken page for website viewers. Various advanced features
+            require <methodname>Zend_Session::start()</methodname> first. (More on advanced features
+            later.)
         </para>
 
         <para>
-            There are four ways to start a session, when using <classname>Zend_Session</classname>. Two are wrong.
+            There are four ways to start a session, when using <classname>Zend_Session</classname>.
+            Two are wrong.
         </para>
 
         <orderedlist>
@@ -55,87 +54,105 @@ php_value session.auto_start 0
 ]]></programlisting>
                 </para>
             </listitem>
+
             <listitem>
                 <para>
-                    Wrong: Do not use <acronym>PHP</acronym>'s
-                    <ulink url="http://www.php.net/session_start"><methodname>session_start()</methodname></ulink> function
-                    directly. If you use <methodname>session_start()</methodname> directly, and then start using
-                    <classname>Zend_Session_Namespace</classname>, an exception will be thrown by
-                    <methodname>Zend_Session::start()</methodname> ("session has already been started"). If you call
-                    <methodname>session_start()</methodname> after using <classname>Zend_Session_Namespace</classname> or calling
-                    <methodname>Zend_Session::start()</methodname>, an error of level <constant>E_NOTICE</constant> will be generated, and
-                    the call will be ignored.
+                    Wrong: Do not use <acronym>PHP</acronym>'s <ulink
+                        url="http://www.php.net/session_start"><methodname>session_start()</methodname></ulink>
+                    function directly. If you use <methodname>session_start()</methodname> directly,
+                    and then start using <classname>Zend_Session_Namespace</classname>, an exception
+                    will be thrown by <methodname>Zend_Session::start()</methodname> ("session has
+                    already been started"). If you call <methodname>session_start()</methodname>
+                    after using <classname>Zend_Session_Namespace</classname> or calling
+                    <methodname>Zend_Session::start()</methodname>, an error of level
+                    <constant>E_NOTICE</constant> will be generated, and the call will be ignored.
                 </para>
             </listitem>
+
             <listitem>
                 <para>
-                    Correct: Use <methodname>Zend_Session::start()</methodname>. If you want all requests to have and use
-                    sessions, then place this function call early and unconditionally in your bootstrap code.
-                    Sessions have some overhead. If some requests need sessions, but other requests will not need to use
-                    sessions, then:
+                    Correct: Use <methodname>Zend_Session::start()</methodname>. If you want all
+                    requests to have and use sessions, then place this function call early and
+                    unconditionally in your bootstrap code. Sessions have some overhead. If some
+                    requests need sessions, but other requests will not need to use sessions, then:
                 </para>
+
                 <itemizedlist mark="opencircle">
                     <listitem>
                         <para>
-                            Unconditionally set the <code>strict</code> option to <constant>TRUE</constant> using
+                            Unconditionally set the <code>strict</code> option to
+                            <constant>TRUE</constant> using
                             <methodname>Zend_Session::setOptions()</methodname> in your bootstrap.
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
-                            Call <methodname>Zend_Session::start()</methodname> only for requests that need to use sessions and
-                            before any <classname>Zend_Session_Namespace</classname> objects are instantiated.
+                            Call <methodname>Zend_Session::start()</methodname> only for requests
+                            that need to use sessions and before any
+                            <classname>Zend_Session_Namespace</classname> objects are instantiated.
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
-                            Use "<code>new Zend_Session_Namespace()</code>" normally, where needed, but make sure
-                            <methodname>Zend_Session::start()</methodname> has been called previously.
+                            Use "<code>new Zend_Session_Namespace()</code>" normally, where needed,
+                            but make sure <methodname>Zend_Session::start()</methodname> has been
+                            called previously.
                         </para>
                     </listitem>
                 </itemizedlist>
+
                 <para>
-                    The <code>strict</code> option prevents <code>new Zend_Session_Namespace()</code> from automatically
-                    starting the session using <methodname>Zend_Session::start()</methodname>. Thus, this option helps application
-                    developers enforce a design decision to avoid using sessions for certain requests, since it causes
-                    an exception to be thrown when <classname>Zend_Session_Namespace</classname> is instantiated before
-                    <methodname>Zend_Session::start()</methodname> is called. Developers should carefully consider the impact of
-                    using <methodname>Zend_Session::setOptions()</methodname>, since these options have global effect, owing to
-                    their correspondence to the underlying options for ext/session.
+                    The <code>strict</code> option prevents
+                    <code>new Zend_Session_Namespace()</code> from automatically starting the
+                    session using <methodname>Zend_Session::start()</methodname>. Thus, this option
+                    helps application developers enforce a design decision to avoid using sessions
+                    for certain requests, since it causes an exception to be thrown when
+                    <classname>Zend_Session_Namespace</classname> is instantiated before
+                    <methodname>Zend_Session::start()</methodname> is called. Developers should
+                    carefully consider the impact of using
+                    <methodname>Zend_Session::setOptions()</methodname>, since these options have
+                    global effect, owing to their correspondence to the underlying options for
+                    ext/session.
                 </para>
             </listitem>
+
             <listitem>
                 <para>
-                    Correct: Just instantiate <classname>Zend_Session_Namespace</classname> whenever needed, and the underlying
-                    <acronym>PHP</acronym> session will be automatically started. This offers extremely simple usage that works well in
-                    most situations. However, you then become responsible for ensuring that the first
-                    <code>new Zend_Session_Namespace()</code> happens <emphasis>before</emphasis> any
-                    output (e.g., <ulink url="http://www.php.net/headers_sent">HTTP headers</ulink>) has been sent by
-                    <acronym>PHP</acronym> to the client, if you are using the default, cookie-based sessions (strongly recommended). See
-                    <xref linkend="zend.session.global_session_management.headers_sent" /> for more information.
+                    Correct: Just instantiate <classname>Zend_Session_Namespace</classname> whenever
+                    needed, and the underlying <acronym>PHP</acronym> session will be automatically
+                    started. This offers extremely simple usage that works well in most situations.
+                    However, you then become responsible for ensuring that the first
+                    <code>new Zend_Session_Namespace()</code> happens <emphasis>before</emphasis>
+                    any output (e.g., <ulink url="http://www.php.net/headers_sent">HTTP
+                        headers</ulink>) has been sent by <acronym>PHP</acronym> to the client, if
+                    you are using the default, cookie-based sessions (strongly recommended). See
+                    <xref linkend="zend.session.global_session_management.headers_sent" /> for more
+                    information.
                 </para>
             </listitem>
         </orderedlist>
-
     </sect2>
 
     <sect2 id="zend.session.advanced_usage.locking">
-
         <title>Locking Session Namespaces</title>
 
         <para>
-            Session namespaces can be locked, to prevent further alterations to the data in that namespace. Use
-            <methodname>lock()</methodname> to make a specific namespace read-only, <methodname>unLock()</methodname> to make a read-only
-            namespace read-write, and <methodname>isLocked()</methodname> to test if a namespace has been previously locked. Locks
-            are transient and do not persist from one request to the next. Locking the namespace has no effect on setter
-            methods of objects stored in the namespace, but does prevent the use of the namespace's setter method to
-            remove or replace objects stored directly in the namespace. Similarly, locking
-            <classname>Zend_Session_Namespace</classname> instances does not prevent the use of symbol table aliases to the same
-            data (see <ulink url="http://www.php.net/references">PHP references</ulink>).
+            Session namespaces can be locked, to prevent further alterations to the data in that
+            namespace. Use <methodname>lock()</methodname> to make a specific namespace read-only,
+            <methodname>unLock()</methodname> to make a read-only namespace read-write, and
+            <methodname>isLocked()</methodname> to test if a namespace has been previously locked.
+            Locks are transient and do not persist from one request to the next. Locking the
+            namespace has no effect on setter methods of objects stored in the namespace, but does
+            prevent the use of the namespace's setter method to remove or replace objects stored
+            directly in the namespace. Similarly, locking
+            <classname>Zend_Session_Namespace</classname> instances does not prevent the use of
+            symbol table aliases to the same data (see <ulink
+                url="http://www.php.net/references">PHP references</ulink>).
         </para>
 
         <example id="zend.session.advanced_usage.locking.example.basic">
-
             <title>Locking Session Namespaces</title>
 
             <programlisting language="php"><![CDATA[
@@ -149,24 +166,21 @@ if ($userProfileNamespace->isLocked()) {
     $userProfileNamespace->unLock();
 }
 ]]></programlisting>
-
         </example>
-
     </sect2>
 
     <sect2 id="zend.session.advanced_usage.expiration">
-
         <title>Namespace Expiration</title>
 
         <para>
-            Limits can be placed on the longevity of both namespaces and individual keys in namespaces. Common use cases
-            include passing temporary information between requests, and reducing exposure to certain security risks by
-            removing access to potentially sensitive information some time after authentication occurred. Expiration can
-            be based on either elapsed seconds or the number of "hops", where a hop occurs for each successive request.
+            Limits can be placed on the longevity of both namespaces and individual keys in
+            namespaces. Common use cases include passing temporary information between requests, and
+            reducing exposure to certain security risks by removing access to potentially sensitive
+            information some time after authentication occurred. Expiration can be based on either
+            elapsed seconds or the number of "hops", where a hop occurs for each successive request.
         </para>
 
         <example id="zend.session.advanced_usage.expiration.example">
-
             <title>Expiration Examples</title>
 
             <programlisting language="php"><![CDATA[
@@ -185,36 +199,35 @@ $s->setExpirationSeconds(60);
 // the first request received after 60 seconds have elapsed,
 // or in 5 hops, whichever happens first.
 ]]></programlisting>
-
         </example>
 
         <para>
-            When working with data expiring from the session in the current request, care should be used when retrieving
-            them. Although the data are returned by reference, modifying the data will not make expiring data persist
-            past the current request. In order to "reset" the expiration time, fetch the data into temporary variables,
-            use the namespace to unset them, and then set the appropriate keys again.
+            When working with data expiring from the session in the current request, care should be
+            used when retrieving them. Although the data are returned by reference, modifying the
+            data will not make expiring data persist past the current request. In order to "reset"
+            the expiration time, fetch the data into temporary variables, use the namespace to unset
+            them, and then set the appropriate keys again.
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.advanced_usage.controllers">
-
         <title>Session Encapsulation and Controllers</title>
 
         <para>
-            Namespaces can also be used to separate session access by controllers to protect variables from
-            contamination. For example, an authentication controller might keep its session state data separate from all
-            other controllers for meeting security requirements.
+            Namespaces can also be used to separate session access by controllers to protect
+            variables from contamination. For example, an authentication controller might keep its
+            session state data separate from all other controllers for meeting security
+            requirements.
         </para>
 
         <example id="zend.session.advanced_usage.controllers.example">
-
             <title>Namespaced Sessions for Controllers with Automatic Expiration</title>
 
             <para>
-                The following code, as part of a controller that displays a test question, initiates a boolean variable
-                to represent whether or not a submitted answer to the test question should be accepted. In this case,
-                the application user is given 300 seconds to answer the displayed question.
+                The following code, as part of a controller that displays a test question, initiates
+                a boolean variable to represent whether or not a submitted answer to the test
+                question should be accepted. In this case, the application user is given 300 seconds
+                to answer the displayed question.
             </para>
 
             <programlisting language="php"><![CDATA[
@@ -228,8 +241,9 @@ $testSpace->accept_answer = true;
 ]]></programlisting>
 
             <para>
-                Below, the controller that processes the answers to test questions determines whether or not to accept
-                an answer based on whether the user submitted the answer within the allotted time:
+                Below, the controller that processes the answers to test questions determines
+                whether or not to accept an answer based on whether the user submitted the answer
+                within the allotted time:
             </para>
 
             <programlisting language="php"><![CDATA[
@@ -245,27 +259,26 @@ else {
 // ...
 ]]></programlisting>
         </example>
-
     </sect2>
 
     <sect2 id="zend.session.advanced_usage.single_instance">
-
         <title>Preventing Multiple Instances per Namespace</title>
 
         <para>
-            Although <link linkend="zend.session.advanced_usage.locking">session locking</link> provides a good degree
-            of protection against unintended use of namespaced session data, <classname>Zend_Session_Namespace</classname> also
-            features the ability to prevent the creation of multiple instances corresponding to a single namespace.
+            Although <link linkend="zend.session.advanced_usage.locking">session locking</link>
+            provides a good degree of protection against unintended use of namespaced session data,
+            <classname>Zend_Session_Namespace</classname> also features the ability to prevent the
+            creation of multiple instances corresponding to a single namespace.
         </para>
 
         <para>
-            To enable this behavior, pass <constant>TRUE</constant> to the second constructor argument when creating the last
-            allowed instance of <classname>Zend_Session_Namespace</classname>. Any subsequent attempt to instantiate the same
-            namespace would result in a thrown exception.
+            To enable this behavior, pass <constant>TRUE</constant> to the second constructor
+            argument when creating the last allowed instance of
+            <classname>Zend_Session_Namespace</classname>. Any subsequent attempt to instantiate the
+            same namespace would result in a thrown exception.
         </para>
 
         <example id="zend.session.advanced_usage.single_instance.example">
-
             <title>Limiting Session Namespace Access to a Single Instance</title>
 
             <programlisting language="php"><![CDATA[
@@ -290,36 +303,35 @@ try {
          '$authSpaceAccessor2 was created\n';
 }
 ]]></programlisting>
-
         </example>
 
         <para>
-            The second parameter in the constructor above tells <classname>Zend_Session_Namespace</classname> that any future
-            instances with the "<classname>Zend_Auth</classname>" namespace are not allowed. Attempting to create such an instance
-            causes an exception to be thrown by the constructor. The developer therefore becomes responsible for storing
-            a reference to an instance object (<varname>$authSpaceAccessor1</varname>, <varname>$authSpaceAccessor2</varname>, or
-            <varname>$authSpaceAccessor3</varname> in the example above) somewhere, if access to the session namespace is
-            needed at a later time during the same request. For example, a developer may store the reference in a static
-            variable, add the reference to a
-            <ulink url="http://www.martinfowler.com/eaaCatalog/registry.html">registry</ulink> (see
-            <xref linkend="zend.registry" />), or otherwise make it available to other methods that may need access to
-            the session namespace.
+            The second parameter in the constructor above tells
+            <classname>Zend_Session_Namespace</classname> that any future instances with the
+            "<classname>Zend_Auth</classname>" namespace are not allowed. Attempting to create such
+            an instance causes an exception to be thrown by the constructor. The developer therefore
+            becomes responsible for storing a reference to an instance object
+            (<varname>$authSpaceAccessor1</varname>, <varname>$authSpaceAccessor2</varname>, or
+            <varname>$authSpaceAccessor3</varname> in the example above) somewhere, if access to the
+            session namespace is needed at a later time during the same request. For example, a
+            developer may store the reference in a static variable, add the reference to a <ulink
+                url="http://www.martinfowler.com/eaaCatalog/registry.html">registry</ulink> (see
+            <xref linkend="zend.registry" />), or otherwise make it available to other methods that
+            may need access to the session namespace.
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.advanced_usage.arrays">
-
         <title>Working with Arrays</title>
 
         <para>
-            Due to the implementation history of <acronym>PHP</acronym> magic methods, modifying an array inside a namespace may not work
-            under <acronym>PHP</acronym> versions before 5.2.1. If you will only be working with <acronym>PHP</acronym> 5.2.1 or later, then you may <link
-            linkend="zend.session.advanced_usage.objects">skip to the next section</link>.
+            Due to the implementation history of <acronym>PHP</acronym> magic methods, modifying an
+            array inside a namespace may not work under <acronym>PHP</acronym> versions before
+            5.2.1. If you will only be working with <acronym>PHP</acronym> 5.2.1 or later, then you
+            may <link linkend="zend.session.advanced_usage.objects">skip to the next section</link>.
         </para>
 
         <example id="zend.session.advanced_usage.arrays.example.modifying">
-
             <title>Modifying Array Data with a Session Namespace</title>
 
             <para>
@@ -334,37 +346,35 @@ $sessionNamespace->array = array();
 $sessionNamespace->array['testKey'] = 1;
 echo $sessionNamespace->array['testKey'];
 ]]></programlisting>
-
         </example>
 
         <example id="zend.session.advanced_usage.arrays.example.building_prior">
-
             <title>Building Arrays Prior to Session Storage</title>
 
             <para>
-                If possible, avoid the problem altogether by storing arrays into a session namespace only after all
-                desired array values have been set.
+                If possible, avoid the problem altogether by storing arrays into a session namespace
+                only after all desired array values have been set.
             </para>
 
             <programlisting language="php"><![CDATA[
 $sessionNamespace = new Zend_Session_Namespace('Foo');
 $sessionNamespace->array = array('a', 'b', 'c');
 ]]></programlisting>
-
         </example>
 
         <para>
-            If you are using an affected version of <acronym>PHP</acronym> and need to modify the array after assigning it to a session
-            namespace key, you may use either or both of the following workarounds.
+            If you are using an affected version of <acronym>PHP</acronym> and need to modify the
+            array after assigning it to a session namespace key, you may use either or both of the
+            following workarounds.
         </para>
 
         <example id="zend.session.advanced_usage.arrays.example.workaround.reassign">
-
             <title>Workaround: Reassign a Modified Array</title>
 
             <para>
-                In the code that follows, a copy of the stored array is created, modified, and reassigned to the
-                location from which the copy was created, overwriting the original array.
+                In the code that follows, a copy of the stored array is created, modified, and
+                reassigned to the location from which the copy was created, overwriting the original
+                array.
             </para>
 
             <programlisting language="php"><![CDATA[
@@ -384,16 +394,14 @@ $sessionNamespace->array = $tmp;
 
 echo $sessionNamespace->array['fruit']; // prints "peach"
 ]]></programlisting>
-
         </example>
 
         <example id="zend.session.advanced_usage.arrays.example.workaround.reference">
-
             <title>Workaround: store array containing reference</title>
 
             <para>
-                Alternatively, store an array containing a reference to the desired array, and then access it
-                indirectly.
+                Alternatively, store an array containing a reference to the desired array, and then
+                access it indirectly.
             </para>
 
             <programlisting language="php"><![CDATA[
@@ -403,55 +411,56 @@ $myNamespace->someArray = array( &$a );
 $a['foo'] = 'bar';
 echo $myNamespace->someArray['foo']; // prints "bar"
 ]]></programlisting>
-
         </example>
-
     </sect2>
 
     <sect2 id="zend.session.advanced_usage.objects">
-
         <title>Using Sessions with Objects</title>
 
         <para>
-            If you plan to persist objects in the <acronym>PHP</acronym> session, know that they will be
-            <ulink url="http://www.php.net/manual/en/language.oop.serialization.php">serialized</ulink> for storage.
-            Thus, any object persisted with the <acronym>PHP</acronym> session must be unserialized upon retrieval from storage. The
-            implication is that the developer must ensure that the classes for the persisted objects must have been
-            defined before the object is unserialized from session storage. If an unserialized object's class is not
+            If you plan to persist objects in the <acronym>PHP</acronym> session, know that they
+            will be <ulink
+                url="http://www.php.net/manual/en/language.oop.serialization.php">serialized</ulink>
+            for storage. Thus, any object persisted with the <acronym>PHP</acronym> session must be
+            unserialized upon retrieval from storage. The implication is that the developer must
+            ensure that the classes for the persisted objects must have been defined before the
+            object is unserialized from session storage. If an unserialized object's class is not
             defined, then it becomes an instance of <code>stdClass</code>.
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.advanced_usage.testing">
-
         <title>Using Sessions with Unit Tests</title>
 
         <para>
-            Zend Framework relies on PHPUnit to facilitate testing of itself. Many developers extend the existing
-            suite of unit tests to cover the code in their applications. The exception
+            Zend Framework relies on PHPUnit to facilitate testing of itself. Many developers extend
+            the existing suite of unit tests to cover the code in their applications. The exception
             "<emphasis>Zend_Session is currently marked as read-only</emphasis>" is thrown while
-            performing unit tests, if any write-related methods are used after ending the session. However, unit tests
-            using <classname>Zend_Session</classname> require extra attention, because closing (<methodname>Zend_Session::writeClose()</methodname>), or
-            destroying a session (<methodname>Zend_Session::destroy()</methodname>) prevents any further setting or unsetting of
-            keys in any instance of <classname>Zend_Session_Namespace</classname>. This behavior is a direct result of the
-            underlying ext/session mechanism and <acronym>PHP</acronym>'s <methodname>session_destroy()</methodname> and
-            <methodname>session_write_close()</methodname>, which have no "undo" mechanism to facilitate setup/teardown with unit
-            tests.
+            performing unit tests, if any write-related methods are used after ending the session.
+            However, unit tests using <classname>Zend_Session</classname> require extra attention,
+            because closing (<methodname>Zend_Session::writeClose()</methodname>), or destroying a
+            session (<methodname>Zend_Session::destroy()</methodname>) prevents any further setting
+            or unsetting of keys in any instance of <classname>Zend_Session_Namespace</classname>.
+            This behavior is a direct result of the underlying ext/session mechanism and
+            <acronym>PHP</acronym>'s <methodname>session_destroy()</methodname> and
+            <methodname>session_write_close()</methodname>, which have no "undo" mechanism to
+            facilitate setup/teardown with unit tests.
         </para>
 
         <para>
-            To work around this, see the unit test <methodname>testSetExpirationSeconds()</methodname> in
-            <code>SessionTest.php</code> and <code>SessionTestHelper.php</code>, both located in
-            <code>tests/Zend/Session</code>, which make use of <acronym>PHP</acronym>'s <methodname>exec()</methodname> to launch a separate process.
-            The new process more accurately simulates a second, successive request from a browser. The separate process
-            begins with a "clean" session, just like any <acronym>PHP</acronym> script execution for a web request. Also, any changes to
-            <varname>$_SESSION</varname> made in the calling process become available to the child process, provided the
-            parent closed the session before using <methodname>exec()</methodname>.
+            To work around this, see the unit test
+            <methodname>testSetExpirationSeconds()</methodname> in <code>SessionTest.php</code> and
+            <code>SessionTestHelper.php</code>, both located in <code>tests/Zend/Session</code>,
+            which make use of <acronym>PHP</acronym>'s <methodname>exec()</methodname> to launch a
+            separate process. The new process more accurately simulates a second, successive request
+            from a browser. The separate process begins with a "clean" session, just like any
+            <acronym>PHP</acronym> script execution for a web request. Also, any changes to
+            <varname>$_SESSION</varname> made in the calling process become available to the child
+            process, provided the parent closed the session before using
+            <methodname>exec()</methodname>.
         </para>
 
         <example id="zend.session.advanced_usage.testing.example">
-
             <title>PHPUnit Testing Code Dependent on Zend_Session</title>
 
             <programlisting language="php"><![CDATA[
@@ -500,9 +509,6 @@ session_start(); // resume artificially suspended session
 $this->assertTrue($result === ';p === plum',
     "iteration over named Zend_Session namespace failed (result=$result)");
 ]]></programlisting>
-
         </example>
-
     </sect2>
-
 </sect1>

documentation/manual/en/module_specs/Zend_Session-BasicUsage.xml

@@ -1,22 +1,24 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- Reviewed: no -->
 <sect1 id="zend.session.basic_usage">
-
     <title>Basic Usage</title>
 
     <para>
-        <classname>Zend_Session_Namespace</classname> instances provide the primary <acronym>API</acronym> for manipulating session data in the Zend
-        Framework. Namespaces are used to segregate all session data, although a default namespace exists for those who
-        only want one namespace for all their session data. <classname>Zend_Session</classname> utilizes ext/session and its
-        special <varname>$_SESSION</varname> superglobal as the storage mechanism for session state data. While
-        <varname>$_SESSION</varname> is still available in <acronym>PHP</acronym>'s global namespace, developers should refrain from directly
-        accessing it, so that <classname>Zend_Session</classname> and <classname>Zend_Session_Namespace</classname> can most effectively and
-        securely provide its suite of session related functionality.
+        <classname>Zend_Session_Namespace</classname> instances provide the primary
+        <acronym>API</acronym> for manipulating session data in the Zend Framework. Namespaces are
+        used to segregate all session data, although a default namespace exists for those who only
+        want one namespace for all their session data. <classname>Zend_Session</classname> utilizes
+        ext/session and its special <varname>$_SESSION</varname> superglobal as the storage
+        mechanism for session state data. while <varname>$_SESSION</varname> is still available in
+        <acronym>PHP</acronym>'s global namespace, developers should refrain from directly accessing
+        it, so that <classname>Zend_Session</classname> and
+        <classname>Zend_Session_Namespace</classname> can most effectively and securely provide its
+        suite of session related functionality.
     </para>
 
     <para>
-        Each instance of <classname>Zend_Session_Namespace</classname> corresponds to an entry of the <varname>$_SESSION</varname>
-        superglobal array, where the namespace is used as the key.
+        Each instance of <classname>Zend_Session_Namespace</classname> corresponds to an entry of
+        the <varname>$_SESSION</varname> superglobal array, where the namespace is used as the key.
 
         <programlisting language="php"><![CDATA[
 $myNamespace = new Zend_Session_Namespace('myNamespace');
@@ -24,25 +26,26 @@ $myNamespace = new Zend_Session_Namespace('myNamespace');
 // $myNamespace corresponds to $_SESSION['myNamespace']
 ]]></programlisting>
 
-        It is possible to use Zend_Session in conjunction with other code that uses <varname>$_SESSION</varname> directly. To
-        avoid problems, however, it is highly recommended that such code only uses parts of <varname>$_SESSION</varname> that
-        do not correspond to instances of <classname>Zend_Session_Namespace</classname>.
+        It is possible to use Zend_Session in conjunction with other code that uses
+        <varname>$_SESSION</varname> directly. To avoid problems, however, it is highly recommended
+        that such code only uses parts of <varname>$_SESSION</varname> that do not correspond to
+        instances of <classname>Zend_Session_Namespace</classname>.
     </para>
 
     <sect2 id="zend.session.basic_usage.basic_examples">
-
         <title>Tutorial Examples</title>
 
         <para>
-            If no namespace is specified when instantiating <classname>Zend_Session_Namespace</classname>, all data will be
-            transparently stored in a namespace called "<code>Default</code>". <classname>Zend_Session</classname> is not intended
-            to work directly on the contents of session namespace containers. Instead, we use
-            <classname>Zend_Session_Namespace</classname>. The example below demonstrates use of this default namespace, showing
-            how to count the number of client requests during a session:
+            If no namespace is specified when instantiating
+            <classname>Zend_Session_Namespace</classname>, all data will be transparently stored in
+            a namespace called "<code>Default</code>". <classname>Zend_Session</classname> is not
+            intended to work directly on the contents of session namespace containers. Instead, we
+            use <classname>Zend_Session_Namespace</classname>. The example below demonstrates use of
+            this default namespace, showing how to count the number of client requests during a
+            session:
         </para>
 
         <example id="zend.session.basic_usage.basic_examples.example.counting_page_views">
-
             <title>Counting Page Views</title>
 
             <programlisting language="php"><![CDATA[
@@ -58,25 +61,25 @@ if (isset($defaultNamespace->numberOfPageRequests)) {
 echo "Page requests this session: ",
     $defaultNamespace->numberOfPageRequests;
 ]]></programlisting>
-
         </example>
 
         <para>
-            When multiple modules use instances of <classname>Zend_Session_Namespace</classname> having different namespaces, each
-            module obtains data encapsulation for its session data. The <classname>Zend_Session_Namespace</classname> constructor
-            can be passed an optional <varname>$namespace</varname> argument, which allows developers to partition session
-            data into separate namespaces. Namespacing provides an effective and popular way to secure session state
-            data against changes due to accidental naming collisions.
+            When multiple modules use instances of <classname>Zend_Session_Namespace</classname>
+            having different namespaces, each module obtains data encapsulation for its session
+            data. The <classname>Zend_Session_Namespace</classname> constructor can be passed an
+            optional <varname>$namespace</varname> argument, which allows developers to partition
+            session data into separate namespaces. Namespacing provides an effective and popular way
+            to secure session state data against changes due to accidental naming collisions.
         </para>
 
         <para>
-            Namespace names are restricted to character sequences represented as non-empty <acronym>PHP</acronym> strings that do not begin
-            with an underscore ("<code>_</code>") character. Only core components included in Zend Framework should
-            use namespace names starting with "<code>Zend</code>".
+            Namespace names are restricted to character sequences represented as non-empty
+            <acronym>PHP</acronym> strings that do not begin with an underscore ("<code>_</code>")
+            character. Only core components included in Zend Framework should use namespace names
+            starting with "<code>Zend</code>".
         </para>
 
         <example id="zend.session.basic_usage.basic_examples.example.namespaces.new">
-
             <title>New Way: Namespaces Avoid Collisions</title>
 
             <programlisting language="php"><![CDATA[
@@ -88,39 +91,33 @@ $authNamespace->user = "myusername";
 $webServiceNamespace = new Zend_Session_Namespace('Some_Web_Service');
 $webServiceNamespace->user = "mywebusername";
 ]]></programlisting>
-
         </example>
 
         <para>
-            The example above achieves the same effect as the code below, except that the session objects above preserve
-            encapsulation of session data within their respective namespaces.
+            The example above achieves the same effect as the code below, except that the session
+            objects above preserve encapsulation of session data within their respective namespaces.
         </para>
 
         <example id="zend.session.basic_usage.basic_examples.example.namespaces.old">
-
             <title>Old Way: PHP Session Access</title>
 
             <programlisting language="php"><![CDATA[
 $_SESSION['Zend_Auth']['user'] = "myusername";
 $_SESSION['Some_Web_Service']['user'] = "mywebusername";
 ]]></programlisting>
-
         </example>
-
     </sect2>
 
     <sect2 id="zend.session.basic_usage.iteration">
-
         <title>Iterating Over Session Namespaces</title>
 
         <para>
-            <classname>Zend_Session_Namespace</classname> provides the full
-            <ulink url="http://www.php.net/~helly/php/ext/spl/interfaceIteratorAggregate.html">IteratorAggregate
-            interface</ulink>, including support for the <code>foreach</code> statement:
+            <classname>Zend_Session_Namespace</classname> provides the full <ulink
+                url="http://www.php.net/~helly/php/ext/spl/interfaceIteratorAggregate.html">IteratorAggregate
+                interface</ulink>, including support for the <code>foreach</code> statement:
         </para>
 
         <example id="zend.session.basic_usage.iteration.example">
-
             <title>Session Iteration</title>
 
             <programlisting language="php"><![CDATA[
@@ -131,25 +128,22 @@ foreach ($aNamespace as $index => $value) {
     echo "aNamespace->$index = '$value';\n";
 }
 ]]></programlisting>
-
         </example>
-
     </sect2>
 
     <sect2 id="zend.session.basic_usage.accessors">
-
         <title>Accessors for Session Namespaces</title>
 
         <para>
-            <classname>Zend_Session_Namespace</classname> implements the <methodname>__get()</methodname>, <methodname>__set()</methodname>,
-            <methodname>__isset()</methodname>, and <methodname>__unset()</methodname>
-            <ulink url="http://www.php.net/manual/en/language.oop5.overloading.php">magic methods</ulink>, which should
-            not be invoked directly, except from within a subclass. Instead, the normal operators automatically invoke
-            these methods, such as in the following example:
+            <classname>Zend_Session_Namespace</classname> implements the
+            <methodname>__get()</methodname>, <methodname>__set()</methodname>,
+            <methodname>__isset()</methodname>, and <methodname>__unset()</methodname> <ulink
+                url="http://www.php.net/manual/en/language.oop5.overloading.php">magic methods</ulink>,
+            which should not be invoked directly, except from within a subclass. Instead, the normal
+            operators automatically invoke these methods, such as in the following example:
         </para>
 
         <example id="zend.session.basic_usage.accessors.example">
-
             <title>Accessing Session Data</title>
 
             <programlisting language="php"><![CDATA[
@@ -165,9 +159,6 @@ if (!isset($namespace->bar)) {
 
 unset($namespace->foo);
 ]]></programlisting>
-
         </example>
-
     </sect2>
-
 </sect1>

documentation/manual/en/module_specs/Zend_Session-GlobalSessionManagement.xml

@@ -1,47 +1,50 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- Reviewed: no -->
 <sect1 id="zend.session.global_session_management">
-
     <title>Global Session Management</title>
 
     <para>
-        The default behavior of sessions can be modified using the static methods of <classname>Zend_Session</classname>. All management and
-        manipulation of global session management occurs using <classname>Zend_Session</classname>, including configuration of the
-        <ulink url="http://www.php.net/session#session.configuration">usual options provided by ext/session</ulink>,
-        using <methodname>Zend_Session::setOptions()</methodname>. For example, failure to insure the use of a safe
-        <code>save_path</code> or a unique cookie name by ext/session using <methodname>Zend_Session::setOptions()</methodname> may
-        result in security issues.
+        The default behavior of sessions can be modified using the static methods of
+        <classname>Zend_Session</classname>. All management and manipulation of global session
+        management occurs using <classname>Zend_Session</classname>, including configuration of the
+        <ulink url="http://www.php.net/session#session.configuration">usual options provided by
+            ext/session</ulink>, using <methodname>Zend_Session::setOptions()</methodname>. For
+        example, failure to insure the use of a safe <code>save_path</code> or a unique cookie name
+        by ext/session using <methodname>Zend_Session::setOptions()</methodname> may result in
+        security issues.
     </para>
 
     <sect2 id="zend.session.global_session_management.configuration_options">
-
         <title>Configuration Options</title>
 
         <para>
-            When the first session namespace is requested, <classname>Zend_Session</classname> will automatically start the <acronym>PHP</acronym> session, unless
-            already started with
-            <link linkend="zend.session.advanced_usage.starting_a_session"><methodname>Zend_Session::start()</methodname></link>.
-            The underlying <acronym>PHP</acronym> session will use defaults from <classname>Zend_Session</classname>, unless modified first by
+            When the first session namespace is requested, <classname>Zend_Session</classname> will
+            automatically start the <acronym>PHP</acronym> session, unless already started with
+            <link
+                linkend="zend.session.advanced_usage.starting_a_session"><methodname>Zend_Session::start()</methodname></link>.
+            The underlying <acronym>PHP</acronym> session will use defaults from
+            <classname>Zend_Session</classname>, unless modified first by
             <methodname>Zend_Session::setOptions()</methodname>.
         </para>
 
         <para>
             To set a session configuration option, include the basename (the part of the name after
-            "<code>session.</code>") as a key of an array passed to <methodname>Zend_Session::setOptions()</methodname>. The
-            corresponding value in the array is used to set the session option value. If no options are set by the
-            developer, <classname>Zend_Session</classname> will utilize recommended default options first, then the default php.ini settings.
-            Community feedback about best practices for these options should be sent to
-            <ulink url="mailto:fw-auth@lists.zend.com">fw-auth@lists.zend.com</ulink>.
+            "<code>session.</code>") as a key of an array passed to
+            <methodname>Zend_Session::setOptions()</methodname>. The corresponding value in the
+            array is used to set the session option value. If no options are set by the developer,
+            <classname>Zend_Session</classname> will utilize recommended default options first, then
+            the default php.ini settings. Community feedback about best practices for these options
+            should be sent to <ulink
+                url="mailto:fw-auth@lists.zend.com">fw-auth@lists.zend.com</ulink>.
         </para>
 
         <example id="zend.session.global_session_management.setoptions.example">
-
             <title>Using Zend_Config to Configure Zend_Session</title>
 
             <para>
-                To configure this component using
-                <link linkend="zend.config.adapters.ini"><classname>Zend_Config_Ini</classname></link>, first add the
-                configuration options to the <acronym>INI</acronym> file:
+                To configure this component using <link
+                    linkend="zend.config.adapters.ini"><classname>Zend_Config_Ini</classname></link>,
+                first add the configuration options to the <acronym>INI</acronym> file:
             </para>
 
             <programlisting language="ini"><![CDATA[
@@ -97,262 +100,313 @@ $config = new Zend_Config_Ini('myapp.ini', 'development');
 
 Zend_Session::setOptions($config->toArray());
 ]]></programlisting>
-
         </example>
 
         <para>
-            Most options shown above need no explanation beyond that found in the standard <acronym>PHP</acronym> documentation, but those
-            of particular interest are noted below.
+            Most options shown above need no explanation beyond that found in the standard
+            <acronym>PHP</acronym> documentation, but those of particular interest are noted below.
+
             <itemizedlist mark="opencircle">
                 <listitem>
                     <para>
-                        boolean <code>strict</code> - disables automatic starting of <classname>Zend_Session</classname> when
-                        using <code>new Zend_Session_Namespace()</code>.
+                        boolean <code>strict</code> - disables automatic starting of
+                        <classname>Zend_Session</classname> when using
+                        <code>new Zend_Session_Namespace()</code>.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        integer <code>remember_me_seconds</code> - how long should session id cookie persist, after user
-                        agent has ended (e.g., browser application terminated).
+                        integer <code>remember_me_seconds</code> - how long should session id cookie
+                        persist, after user agent has ended (e.g., browser application terminated).
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        string <code>save_path</code> - The correct value is system dependent, and should be provided by
-                        the developer using an <emphasis>absolute path</emphasis> to a directory readable
-                        and writable by the <acronym>PHP</acronym> process. If a writable path is not supplied, then
-                        <classname>Zend_Session</classname> will throw an exception when started (i.e., when <methodname>start()</methodname>
-                        is called).
+                        string <code>save_path</code> - The correct value is system dependent, and
+                        should be provided by the developer using an
+                        <emphasis>absolute path</emphasis> to a directory readable and writable by
+                        the <acronym>PHP</acronym> process. If a writable path is not supplied, then
+                        <classname>Zend_Session</classname> will throw an exception when started
+                        (i.e., when <methodname>start()</methodname> is called).
                     </para>
+
                     <note>
                         <title>Security Risk</title>
+
                         <para>
-                            If the path is readable by other applications, then session hijacking might be possible. If
-                            the path is writable by other applications, then
-                            <ulink url="http://en.wikipedia.org/wiki/Session_poisoning">session poisoning</ulink>
-                            might be possible. If this path is shared with other users or other <acronym>PHP</acronym> applications,
-                            various security issues might occur, including theft of session content, hijacking of
-                            sessions, and collision of garbage collection (e.g., another user's application might cause
-                            <acronym>PHP</acronym> to delete your application's session files).
+                            If the path is readable by other applications, then session hijacking
+                            might be possible. if the path is writable by other applications, then
+                            <ulink url="http://en.wikipedia.org/wiki/Session_poisoning">session
+                                poisoning</ulink> might be possible. If this path is shared with
+                            other users or other <acronym>PHP</acronym> applications, various
+                            security issues might occur, including theft of session content,
+                            hijacking of sessions, and collision of garbage collection (e.g.,
+                            another user's application might cause <acronym>PHP</acronym> to delete
+                            your application's session files).
                         </para>
+
                         <para>
-                            For example, an attacker can visit the victim's website to obtain a session cookie. Then, he
-                            edits the cookie path to his own domain on the same server, before visiting his own website
-                            to execute <methodname>var_dump($_SESSION)</methodname>. Armed with detailed knowledge of the victim's
-                            use of data in their sessions, the attacker can then modify the session state (poisoning the
-                            session), alter the cookie path back to the victim's website, and then make requests from
-                            the victim's website using the poisoned session. Even if two applications on the same server
-                            do not have read/write access to the other application's <code>save_path</code>, if the
-                            <code>save_path</code> is guessable, and the attacker has control over one of these two
-                            websites, the attacker could alter their website's <code>save_path</code> to use the other's
-                            save_path, and thus accomplish session poisoning, under some common configurations of <acronym>PHP</acronym>.
-                            Thus, the value for <code>save_path</code> should not be made public knowledge and should be
-                            altered to a secure location unique to each application.
+                            For example, an attacker can visit the victim's website to obtain a
+                            session cookie. Then, he edits the cookie path to his own domain on the
+                            same server, before visiting his own website to execute
+                            <methodname>var_dump($_SESSION)</methodname>. Armed with detailed
+                            knowledge of the victim's use of data in their sessions, the attacker
+                            can then modify the session state (poisoning the session), alter the
+                            cookie path back to the victim's website, and then make requests from
+                            the victim's website using the poisoned session. Even if two
+                            applications on the same server do not have read/write access to the
+                            other application's <code>save_path</code>, if the
+                            <code>save_path</code> is guessable, and the attacker has control over
+                            one of these two websites, the attacker could alter their website's
+                            <code>save_path</code> to use the other's save_path, and thus accomplish
+                            session poisoning, under some common configurations of
+                            <acronym>PHP</acronym>. Thus, the value for <code>save_path</code>
+                            should not be made public knowledge and should be altered to a secure
+                            location unique to each application.
                         </para>
                     </note>
                 </listitem>
+
                 <listitem>
                     <para>
-                        string <code>name</code> - The correct value is system dependent and should be provided by the
-                        developer using a value <emphasis>unique</emphasis> to the application.
+                        string <code>name</code> - The correct value is system dependent and should
+                        be provided by the developer using a value <emphasis>unique</emphasis> to
+                        the application.
                     </para>
+
                     <note>
                         <title>Security Risk</title>
+
                         <para>
-                            If the <code>php.ini</code> setting for <code>session.name</code> is the same (e.g., the
-                            default "PHPSESSID"), and there are two or more <acronym>PHP</acronym> applications accessible through the same
-                            domain name then they will share the same session data for visitors to both websites.
-                            Additionally, possible corruption of session data may result.
+                            If the <code>php.ini</code> setting for <code>session.name</code> is the
+                            same (e.g., the default "PHPSESSID"), and there are two or more
+                            <acronym>PHP</acronym> applications accessible through the same domain
+                            name then they will share the same session data for visitors to both
+                            websites. Additionally, possible corruption of session data may result.
                         </para>
                     </note>
                 </listitem>
+
                 <listitem>
                     <para>
-                        boolean <code>use_only_cookies</code> - In order to avoid introducing additional security risks,
-                        do not alter the default value of this option.
+                        boolean <code>use_only_cookies</code> - In order to avoid introducing
+                        additional security risks, do not alter the default value of this option.
+
                         <note>
                             <title>Security Risk</title>
+
                             <para>
-                                If this setting is not enabled, an attacker can easily fix victim's session ids, using
-                                links on the attacker's website, such as
-                                <code>http://www.example.com/index.php?PHPSESSID=fixed_session_id</code>. The fixation
-                                works, if the victim does not already have a session id cookie for example.com. Once a
-                                victim is using a known session id, the attacker can then attempt to hijack the session
-                                by pretending to be the victim, and emulating the victim's user agent.
+                                If this setting is not enabled, an attacker can easily fix victim's
+                                session ids, using links on the attacker's website, such as
+                                <code>http://www.example.com/index.php?PHPSESSID=fixed_session_id</code>.
+                                The fixation works, if the victim does not already have a session id
+                                cookie for example.com. Once a victim is using a known session id,
+                                the attacker can then attempt to hijack the session by pretending to
+                                be the victim, and emulating the victim's user agent.
                             </para>
                         </note>
                     </para>
                 </listitem>
             </itemizedlist>
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.headers_sent">
-
         <title>Error: Headers Already Sent</title>
 
         <para>
-            If you see the error message, "Cannot modify header information - headers already sent", or, "You must call
-            ... before any output has been sent to the browser; output started in ...", then carefully examine the
-            immediate cause (function or method) associated with the message. Any actions that require sending <acronym>HTTP</acronym>
-            headers, such as sending a cookie, must be done before sending normal output (unbuffered output), except
+            If you see the error message, "Cannot modify header information - headers already sent",
+            or, "You must call ... before any output has been sent to the browser; output started in
+            ...", then carefully examine the immediate cause (function or method) associated with
+            the message. Any actions that require sending <acronym>HTTP</acronym> headers, such as
+            sending a cookie, must be done before sending normal output (unbuffered output), except
             when using <acronym>PHP</acronym>'s output buffering.
         </para>
 
         <itemizedlist mark="opencircle">
             <listitem>
                 <para>
-                    Using <ulink url="http://php.net/outcontrol">output buffering</ulink> often is sufficient to prevent
-                    this issue, and may help improve performance. For example, in <code>php.ini</code>,
-                    "<code>output_buffering = 65535</code>" enables output buffering with a 64K buffer. Even though
-                    output buffering might be a good tactic on production servers to increase performance, relying only
-                    on buffering to resolve the "headers already sent" problem is not sufficient. The application must
-                    not exceed the buffer size, or the problem will occur whenever the output sent (prior to the <acronym>HTTP</acronym>
-                    headers) exceeds the buffer size.
+                    Using <ulink url="http://php.net/outcontrol">output buffering</ulink> often is
+                    sufficient to prevent this issue, and may help improve performance. For example,
+                    in <code>php.ini</code>, "<code>output_buffering = 65535</code>" enables output
+                    buffering with a 64K buffer. Even though output buffering might be a good tactic
+                    on production servers to increase performance, relying only on buffering to
+                    resolve the "headers already sent" problem is not sufficient. The application
+                    must not exceed the buffer size, or the problem will occur whenever the output
+                    sent (prior to the <acronym>HTTP</acronym> headers) exceeds the buffer size.
                 </para>
             </listitem>
+
             <listitem>
                 <para>
-                    Alternatively, try rearranging the application logic so that actions manipulating headers are
-                    performed prior to sending any output whatsoever.
+                    Alternatively, try rearranging the application logic so that actions
+                    manipulating headers are performed prior to sending any output whatsoever.
                 </para>
             </listitem>
+
             <listitem>
                 <para>
-                    If a <classname>Zend_Session</classname> method is involved in causing the error message, examine the method carefully, and
-                    make sure its use really is needed in the application. For example, the default usage of
-                    <methodname>destroy()</methodname> also sends an <acronym>HTTP</acronym> header to expire the client-side session cookie. If this
-                    is not needed, then use <methodname>destroy(false)</methodname>, since the instructions to set cookies are sent
-                    with <acronym>HTTP</acronym> headers.
+                    If a <classname>Zend_Session</classname> method is involved in causing the error
+                    message, examine the method carefully, and make sure its use really is needed in
+                    the application. For example, the default usage of
+                    <methodname>destroy()</methodname> also sends an <acronym>HTTP</acronym> header
+                    to expire the client-side session cookie. If this is not needed, then use
+                    <methodname>destroy(false)</methodname>, since the instructions to set cookies
+                    are sent with <acronym>HTTP</acronym> headers.
                 </para>
             </listitem>
+
             <listitem>
                 <para>
-                    Alternatively, try rearranging the application logic so that all actions manipulating headers are
-                    performed prior to sending any output whatsoever.
+                    Alternatively, try rearranging the application logic so that all actions
+                    manipulating headers are performed prior to sending any output whatsoever.
                 </para>
             </listitem>
+
             <listitem>
                 <para>
-                    Remove any closing "<code>?&gt;</code>" tags, if they occur at the end of a <acronym>PHP</acronym> source file. They
-                    are not needed, and newlines and other nearly invisible whitespace following the closing tag can
-                    trigger output to the client.
+                    Remove any closing "<code>?&gt;</code>" tags, if they occur at the end of a
+                    <acronym>PHP</acronym> source file. They are not needed, and newlines and other
+                    nearly invisible whitespace following the closing tag can trigger output to the
+                    client.
                 </para>
             </listitem>
         </itemizedlist>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.session_identifiers">
-
         <title>Session Identifiers</title>
 
         <para>
-            Introduction: Best practice in relation to using sessions with Zend Framework calls for using a browser cookie (i.e.
-            a normal cookie stored in your web browser), instead of embedding a unique session identifier in <acronym>URL</acronym>s as
-            a means to track individual users. By default this component uses only cookies to maintain session
-            identifiers. The cookie's value is the unique identifier of your browser's session. <acronym>PHP</acronym>'s ext/session
-            uses this identifier to maintain a unique one-to-one relationship between website visitors, and
-            persistent session data storage unique to each visitor. <classname>Zend_Session</classname>* wraps this storage mechanism
-            (<varname>$_SESSION</varname>) with an object-oriented interface. Unfortunately, if an attacker gains access
-            to the value of the cookie (the session id), an attacker might be able to hijack a visitor's session.
-            This problem is not unique to <acronym>PHP</acronym>, or Zend Framework. The <methodname>regenerateId()</methodname> method allows
-            an application to change the session id (stored in the visitor's cookie) to a new, random, unpredictable
-            value. Note: Although not the same, to make this section easier to read, we use the terms "user agent"
-            and "web browser" interchangeably.
+            Introduction: Best practice in relation to using sessions with Zend Framework calls for
+            using a browser cookie (i.e. a normal cookie stored in your web browser), instead of
+            embedding a unique session identifier in <acronym>URL</acronym>s as a means to track
+            individual users. By default this component uses only cookies to maintain session
+            identifiers. The cookie's value is the unique identifier of your browser's session.
+            <acronym>PHP</acronym>'s ext/session uses this identifier to maintain a unique
+            one-to-one relationship between website visitors, and persistent session data storage
+            unique to each visitor. <classname>Zend_Session</classname>* wraps this storage
+            mechanism (<varname>$_SESSION</varname>) with an object-oriented interface.
+            Unfortunately, if an attacker gains access to the value of the cookie (the session id),
+            an attacker might be able to hijack a visitor's session. This problem is not unique to
+            <acronym>PHP</acronym>, or Zend Framework. The <methodname>regenerateId()</methodname>
+            method allows an application to change the session id (stored in the visitor's cookie)
+            to a new, random, unpredictable value. Note: Although not the same, to make this section
+            easier to read, we use the terms "user agent" and "web browser" interchangeably.
         </para>
 
         <para>
-            Why?: If an attacker obtains a valid session identifier, an attacker might be able to impersonate a
-            valid user (the victim), and then obtain access to confidential information or otherwise manipulate the
-            victim's data managed by your application. Changing session ids helps protect against session hijacking.
-            If the session id is changed, and an attacker does not know the new value, the attacker can not use the
-            new session id in their attempts to hijack the visitor's session. Even if an attacker gains access to an
-            old session id, <methodname>regenerateId()</methodname> also moves the session data from the old session id "handle"
-            to the new one, so no data remains accessible via the old session id.
+            Why?: If an attacker obtains a valid session identifier, an attacker might be able to
+            impersonate a valid user (the victim), and then obtain access to confidential
+            information or otherwise manipulate the victim's data managed by your application.
+            Changing session ids helps protect against session hijacking. If the session id is
+            changed, and an attacker does not know the new value, the attacker can not use the new
+            session id in their attempts to hijack the visitor's session. Even if an attacker gains
+            access to an old session id, <methodname>regenerateId()</methodname> also moves the
+            session data from the old session id "handle" to the new one, so no data remains
+            accessible via the old session id.
         </para>
 
         <para>
-            When to use regenerateId(): Adding <methodname>Zend_Session::regenerateId()</methodname> to your Zend Framework
-            bootstrap yields one of the safest and most secure ways to regenerate session id's in user agent
-            cookies. If there is no conditional logic to determine when to regenerate the session id, then there are
-            no flaws in that logic. Although regenerating on every request prevents several possible avenues of
-            attack, not everyone wants the associated small performance and bandwidth cost. Thus, applications
-            commonly try to dynamically determine situations of greater risk, and only regenerate the session ids in
-            those situations. Whenever a website visitor's session's privileges are "escalated" (e.g. a visitor
-            re-authenticates their identity before editing their personal "profile"), or whenever a security
-            "sensitive" session parameter change occurs, consider using <methodname>regenerateId()</methodname> to create a new
-            session id. If you call the <methodname>rememberMe()</methodname> function, then don't use
-            <methodname>regenerateId()</methodname>, since the former calls the latter. If a user has successfully logged into
-            your website, use <methodname>rememberMe()</methodname> instead of <methodname>regenerateId()</methodname>.
+            When to use regenerateId(): Adding <methodname>Zend_Session::regenerateId()</methodname>
+            to your Zend Framework bootstrap yields one of the safest and most secure ways to
+            regenerate session id's in user agent cookies. If there is no conditional logic to
+            determine when to regenerate the session id, then there are no flaws in that logic.
+            Although regenerating on every request prevents several possible avenues of attack, not
+            everyone wants the associated small performance and bandwidth cost. Thus, applications
+            commonly try to dynamically determine situations of greater risk, and only regenerate
+            the session ids in those situations. Whenever a website visitor's session's privileges
+            are "escalated" (e.g. a visitor re-authenticates their identity before editing their
+            personal "profile"), or whenever a security "sensitive" session parameter change occurs,
+            consider using <methodname>regenerateId()</methodname> to create a new session id. If
+            you call the <methodname>rememberMe()</methodname> function, then don't use
+            <methodname>regenerateId()</methodname>, since the former calls the latter. If a user
+            has successfully logged into your website, use <methodname>rememberMe()</methodname>
+            instead of <methodname>regenerateId()</methodname>.
         </para>
 
-        <sect3 id="zend.session.global_session_management.session_identifiers.hijacking_and_fixation">
-
+        <sect3
+            id="zend.session.global_session_management.session_identifiers.hijacking_and_fixation">
             <title>Session Hijacking and Fixation</title>
 
             <para>
-                Avoiding <ulink url="http://en.wikipedia.org/wiki/Cross_site_scripting">cross-site script (XSS)
-                vulnerabilities</ulink> helps preventing session hijacking. According to
-                <ulink url="http://secunia.com/">Secunia's</ulink> statistics XSS problems occur frequently, regardless
-                of the languages used to create web applications. Rather than expecting to never have a XSS problem with
-                an application, plan for it by following best practices to help minimize damage, if it occurs. With XSS,
-                an attacker does not need direct access to a victim's network traffic. If the victim already has a
-                session cookie, Javascript XSS might allow an attacker to read the cookie and steal the session. For
-                victims with no session cookies, using XSS to inject Javascript, an attacker could create a session id
-                cookie on the victim's browser with a known value, then set an identical cookie on the attacker's
-                system, in order to hijack the victim's session. If the victim visited an attacker's website, then the
-                attacker can also emulate most other identifiable characteristics of the victim's user agent. If your
-                website has an XSS vulnerability, the attacker might be able to insert an <acronym>AJAX</acronym> Javascript that secretly
-                "visits" the attacker's website, so that the attacker knows the victim's browser characteristics and
-                becomes aware of a compromised session at the victim website. However, the attacker can not arbitrarily
-                alter the server-side state of <acronym>PHP</acronym> sessions, provided the developer has correctly set the value for the
-                <code>save_path</code> option.
+                Avoiding <ulink url="http://en.wikipedia.org/wiki/Cross_site_scripting">cross-site
+                    script (XSS) vulnerabilities</ulink> helps preventing session hijacking.
+                According to <ulink url="http://secunia.com/">Secunia's</ulink> statistics XSS
+                    problems occur frequently, regardless of the languages used to create web
+                applications. Rather than expecting to never have a XSS problem with an application,
+                plan for it by following best practices to help minimize damage, if it occurs. With
+                XSS, an attacker does not need direct access to a victim's network traffic. If the
+                victim already has a session cookie, Javascript XSS might allow an attacker to read
+                the cookie and steal the session. for victims with no session cookies, using XSS to
+                inject Javascript, an attacker could create a session id cookie on the victim's
+                browser with a known value, then set an identical cookie on the attacker's system,
+                in order to hijack the victim's session. If the victim visited an attacker's
+                website, then the attacker can also emulate most other identifiable characteristics
+                of the victim's user agent. If your website has an XSS vulnerability, the attacker
+                might be able to insert an <acronym>AJAX</acronym> Javascript that secretly "visits"
+                the attacker's website, so that the attacker knows the victim's browser
+                characteristics and becomes aware of a compromised session at the victim website.
+                However, the attacker can not arbitrarily alter the server-side state of
+                <acronym>PHP</acronym> sessions, provided the developer has correctly set the value
+                for the <code>save_path</code> option.
             </para>
 
             <para>
-                By itself, calling <methodname>Zend_Session::regenerateId()</methodname> when the user's session is first used, does
-                not prevent session fixation attacks, unless you can distinguish between a session originated by an
-                attacker emulating the victim. At first, this might sound contradictory to the previous statement above,
-                until we consider an attacker who first initiates a real session on your website. The session is "first
-                used" by the attacker, who then knows the result of the initialization (<methodname>regenerateId()</methodname>).
-                The attacker then uses the new session id in combination with an XSS vulnerability, or injects the
-                session id via a link on the attacker's website (works if <code>use_only_cookies = off</code>).
+                By itself, calling <methodname>Zend_Session::regenerateId()</methodname> when the
+                user's session is first used, does not prevent session fixation attacks, unless you
+                can distinguish between a session originated by an attacker emulating the victim. At
+                first, this might sound contradictory to the previous statement above, until we
+                consider an attacker who first initiates a real session on your website. The session
+                is "first used" by the attacker, who then knows the result of the initialization
+                (<methodname>regenerateId()</methodname>). The attacker then uses the new session id
+                in combination with an XSS vulnerability, or injects the session id via a link on
+                the attacker's website (works if <code>use_only_cookies = off</code>).
             </para>
 
             <para>
-                If you can distinguish between an attacker and victim using the same session id, then session hijacking
-                can be dealt with directly. However, such distinctions usually involve some form of usability tradeoffs,
-                because the methods of distinction are often imprecise. For example, if a request is received from an IP
-                in a different country than the IP of the request when the session was created, then the new request
-                probably belongs to an attacker. Under the following conditions, there might not be any way for a
-                website application to distinguish between a victim and an attacker:
+                If you can distinguish between an attacker and victim using the same session id,
+                then session hijacking can be dealt with directly. However, such distinctions
+                usually involve some form of usability tradeoffs, because the methods of distinction
+                are often imprecise. For example, if a request is received from an IP in a different
+                country than the IP of the request when the session was created, then the new
+                request probably belongs to an attacker. Under the following conditions, there might
+                not be any way for a website application to distinguish between a victim and an
+                attacker:
+
                 <itemizedlist mark='opencircle'>
                     <listitem>
                         <para>
-                            attacker first initiates a session on your website to obtain a valid session id
+                            attacker first initiates a session on your website to obtain a valid
+                            session id
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
-                            attacker uses XSS vulnerability on your website to create a cookie on the victim's browser
-                            with the same, valid session id (i.e. session fixation)
+                            attacker uses XSS vulnerability on your website to create a cookie on
+                            the victim's browser with the same, valid session id (i.e. session
+                            fixation)
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
-                            both the victim and attacker originate from the same proxy farm (e.g. both are behind the
-                            same firewall at a large company, like AOL)
+                            both the victim and attacker originate from the same proxy farm (e.g.
+                            both are behind the same firewall at a large company, like AOL)
                         </para>
                     </listitem>
                 </itemizedlist>
-                The sample code below makes it much harder for an attacker to know the current victim's session id,
-                unless the attacker has already performed the first two steps above.
-            </para>
 
-            <example id="zend.session.global_session_management.session_identifiers.hijacking_and_fixation.example">
+                The sample code below makes it much harder for an attacker to know the current
+                victim's session id, unless the attacker has already performed the first two steps
+                above.
+            </para>
 
+            <example
+                id="zend.session.global_session_management.session_identifiers.hijacking_and_fixation.example">
                 <title>Session Fixation</title>
 
                 <programlisting language="php"><![CDATA[
@@ -363,225 +417,223 @@ if (!isset($defaultNamespace->initialized)) {
     $defaultNamespace->initialized = true;
 }
 ]]></programlisting>
-
             </example>
-
         </sect3>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.rememberme">
-
         <title>rememberMe(integer $seconds)</title>
 
         <para>
-            Ordinarily, sessions end when the user agent terminates, such as when an end user exits a web browser
-            program. However, your application may provide the ability to extend user sessions beyond the lifetime of
-            the client program through the use of persistent cookies. Use <methodname>Zend_Session::rememberMe()</methodname> before
-            a session is started to control the length of time before a persisted session cookie expires. If you do not
-            specify a number of seconds, then the session cookie lifetime defaults to <code>remember_me_seconds</code>,
-            which may be set using <methodname>Zend_Session::setOptions()</methodname>. To help thwart session fixation/hijacking,
-            use this function when a user successfully authenticates with your application (e.g., from a "login" form).
+            Ordinarily, sessions end when the user agent terminates, such as when an end user exits
+            a web browser program. However, your application may provide the ability to extend user
+            sessions beyond the lifetime of the client program through the use of persistent
+            cookies. Use <methodname>Zend_Session::rememberMe()</methodname> before a session is
+            started to control the length of time before a persisted session cookie expires. If you
+            do not specify a number of seconds, then the session cookie lifetime defaults to
+            <code>remember_me_seconds</code>, which may be set using
+            <methodname>Zend_Session::setOptions()</methodname>. To help thwart session
+            fixation/hijacking, use this function when a user successfully authenticates with your
+            application (e.g., from a "login" form).
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.forgetme">
-
         <title>forgetMe()</title>
 
         <para>
-            This function complements <methodname>rememberMe()</methodname> by writing a session cookie that has a lifetime ending
-            when the user agent terminates.
+            This function complements <methodname>rememberMe()</methodname> by writing a session
+            cookie that has a lifetime ending when the user agent terminates.
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.sessionexists">
-
         <title>sessionExists()</title>
 
         <para>
-            Use this method to determine if a session already exists for the current user agent/request. It may be used
-            before starting a session, and independently of all other <classname>Zend_Session</classname> and
-            <classname>Zend_Session_Namespace</classname> methods.
+            Use this method to determine if a session already exists for the current user
+            agent/request. It may be used before starting a session, and independently of all other
+            <classname>Zend_Session</classname> and <classname>Zend_Session_Namespace</classname>
+            methods.
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.destroy">
-
         <title>destroy(bool $remove_cookie = true, bool $readonly = true)</title>
 
         <para>
-            <methodname>Zend_Session::destroy()</methodname> destroys all of the persistent data associated with the current
-            session. However, no variables in <acronym>PHP</acronym> are affected, so your namespaced sessions (instances of
-            <classname>Zend_Session_Namespace</classname>) remain readable. To complete a "logout", set the optional parameter to
-            <constant>TRUE</constant> (the default) to also delete the user agent's session id cookie. The optional
-            <varname>$readonly</varname> parameter removes the ability to create new <classname>Zend_Session_Namespace</classname>
-            instances and for <classname>Zend_Session</classname> methods to write to the session data store.
+            <methodname>Zend_Session::destroy()</methodname> destroys all of the persistent data
+            associated with the current session. However, no variables in <acronym>PHP</acronym> are
+            affected, so your namespaced sessions (instances of
+            <classname>Zend_Session_Namespace</classname>) remain readable. To complete a "logout",
+            set the optional parameter to <constant>TRUE</constant> (the default) to also delete the
+            user agent's session id cookie. The optional <varname>$readonly</varname> parameter
+            removes the ability to create new <classname>Zend_Session_Namespace</classname>
+            instances and for <classname>Zend_Session</classname> methods to write to the session
+            data store.
         </para>
 
         <para>
-            If you see the error message, "Cannot modify header information - headers already sent", then either avoid
-            using <constant>TRUE</constant> as the value for the first argument (requesting removal of the session cookie), or
-            see <xref linkend="zend.session.global_session_management.headers_sent" />. Thus,
-            <methodname>Zend_Session::destroy(true)</methodname> must either be called before <acronym>PHP</acronym> has sent <acronym>HTTP</acronym> headers, or output
-            buffering must be enabled. Also, the total output sent must not exceed the set buffer size, in order to
-            prevent triggering sending the output before the call to <methodname>destroy()</methodname>.
+            If you see the error message, "Cannot modify header information - headers already sent",
+            then either avoid using <constant>TRUE</constant> as the value for the first argument
+            (requesting removal of the session cookie), or see <xref
+                linkend="zend.session.global_session_management.headers_sent" />. Thus,
+            <methodname>Zend_Session::destroy(true)</methodname> must either be called before
+            <acronym>PHP</acronym> has sent <acronym>HTTP</acronym> headers, or output buffering
+            must be enabled. Also, the total output sent must not exceed the set buffer size, in
+            order to prevent triggering sending the output before the call to
+            <methodname>destroy()</methodname>.
         </para>
 
         <note>
             <title>Throws</title>
+
             <para>
-                By default, <varname>$readonly</varname> is enabled and further actions involving writing to the session data
-                store will throw an exception.
+                By default, <varname>$readonly</varname> is enabled and further actions involving
+                writing to the session data store will throw an exception.
             </para>
         </note>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.stop">
-
         <title>stop()</title>
 
         <para>
-            This method does absolutely nothing more than toggle a flag in <classname>Zend_Session</classname> to prevent further writing to
-            the session data store. We are specifically requesting feedback on this feature. Potential uses/abuses might
-            include temporarily disabling the use of <classname>Zend_Session_Namespace</classname> instances or
-            <classname>Zend_Session</classname> methods to write to the session data store, while execution is transferred to view-
-            related code. Attempts to perform actions involving writes via these instances or methods will throw an
-            exception.
+            This method does absolutely nothing more than toggle a flag in
+            <classname>Zend_Session</classname> to prevent further writing to the session data
+            store. We are specifically requesting feedback on this feature. Potential uses/abuses
+            might include temporarily disabling the use of
+            <classname>Zend_Session_Namespace</classname> instances or
+            <classname>Zend_Session</classname> methods to write to the session data store, while
+            execution is transferred to view- related code. Attempts to perform actions involving
+            writes via these instances or methods will throw an exception.
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.writeclose">
-
         <title>writeClose($readonly = true)</title>
 
         <para>
-            Shutdown the session, close writing and detach <varname>$_SESSION</varname> from the back-end storage mechanism.
-            This will complete the internal data transformation on this request. The optional <varname>$readonly</varname>
-            boolean parameter can remove write access by throwing an exception upon any attempt to write to the session
-            via <classname>Zend_Session</classname> or <classname>Zend_Session_Namespace</classname>.
+            Shutdown the session, close writing and detach <varname>$_SESSION</varname> from the
+            back-end storage mechanism. This will complete the internal data transformation on this
+            request. The optional <varname>$readonly</varname> boolean parameter can remove write
+            access by throwing an exception upon any attempt to write to the session via
+            <classname>Zend_Session</classname> or <classname>Zend_Session_Namespace</classname>.
         </para>
 
         <note>
             <title>Throws</title>
+
             <para>
-                By default, <varname>$readonly</varname> is enabled and further actions involving writing to the session data
-                store will throw an exception. However, some legacy application might expect <varname>$_SESSION</varname> to
-                remain writable after ending the session via <methodname>session_write_close()</methodname>. Although not considered
-                "best practice", the <varname>$readonly</varname> option is available for those who need it.
+                By default, <varname>$readonly</varname> is enabled and further actions involving
+                writing to the session data store will throw an exception. However, some legacy
+                application might expect <varname>$_SESSION</varname> to remain writable after
+                ending the session via <methodname>session_write_close()</methodname>. Although not
+                considered "best practice", the <varname>$readonly</varname> option is available for
+                those who need it.
             </para>
         </note>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.expiresessioncookie">
-
         <title>expireSessionCookie()</title>
 
         <para>
-            This method sends an expired session id cookie, causing the client to delete the session cookie. Sometimes
-            this technique is used to perform a client-side logout.
+            This method sends an expired session id cookie, causing the client to delete the session
+            cookie. Sometimes this technique is used to perform a client-side logout.
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.savehandler">
-
         <title>setSaveHandler(Zend_Session_SaveHandler_Interface $interface)</title>
 
         <para>
-            Most developers will find the default save handler sufficient. This method provides an object-oriented
-            wrapper for
-            <ulink url="http://php.net/session_set_save_handler"><methodname>session_set_save_handler()</methodname></ulink>.
+            Most developers will find the default save handler sufficient. This method provides an
+            object-oriented wrapper for <ulink
+                url="http://php.net/session_set_save_handler"><methodname>session_set_save_handler()</methodname></ulink>.
         </para>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.namespaceisset">
-
         <title>namespaceIsset($namespace)</title>
 
         <para>
-            Use this method to determine if a session namespace exists, or if a particular index exists in a particular
-            namespace.
+            Use this method to determine if a session namespace exists, or if a particular index
+            exists in a particular namespace.
         </para>
 
         <note>
             <title>Throws</title>
+
             <para>
-                An exception will be thrown if <classname>Zend_Session</classname> is not marked as readable (e.g., before
-                <classname>Zend_Session</classname> has been started).
+                An exception will be thrown if <classname>Zend_Session</classname> is not marked as
+                readable (e.g., before <classname>Zend_Session</classname> has been started).
             </para>
         </note>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.namespaceunset">
-
         <title>namespaceUnset($namespace)</title>
 
         <para>
-            Use <methodname>Zend_Session::namespaceUnset($namespace)</methodname> to efficiently remove an entire namespace and its
-            contents. As with all arrays in <acronym>PHP</acronym>, if a variable containing an array is unset, and the array contains
-            other objects, those objects will remain available, if they were also stored by reference in other
-            array/objects that remain accessible via other variables. So <methodname>namespaceUnset()</methodname> does not perform
-            a "deep" unsetting/deleting of the contents of the entries in the namespace. For a more detailed
-            explanation, please see <ulink url="http://php.net/references">References Explained</ulink> in the <acronym>PHP</acronym>
-            manual.
+            Use <methodname>Zend_Session::namespaceUnset($namespace)</methodname> to efficiently
+            remove an entire namespace and its contents. As with all arrays in
+            <acronym>PHP</acronym>, if a variable containing an array is unset, and the array
+            contains other objects, those objects will remain available, if they were also stored by
+            reference in other array/objects that remain accessible via other variables. So
+            <methodname>namespaceUnset()</methodname> does not perform a "deep" unsetting/deleting
+            of the contents of the entries in the namespace. For a more detailed explanation, please
+            see <ulink url="http://php.net/references">References Explained</ulink> in the
+            <acronym>PHP</acronym> manual.
         </para>
 
         <note>
             <title>Throws</title>
+
             <para>
-                An exception will be thrown if the namespace is not writable (e.g., after <methodname>destroy()</methodname>).
+                An exception will be thrown if the namespace is not writable (e.g., after
+                <methodname>destroy()</methodname>).
             </para>
         </note>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.namespaceget">
-
         <title>namespaceGet($namespace)</title>
 
         <para>
-            DEPRECATED: Use <methodname>getIterator()</methodname> in <classname>Zend_Session_Namespace</classname>. This method returns an
-            array of the contents of <varname>$namespace</varname>. If you have logical reasons to keep this method publicly
-            accessible, please provide feedback to the
-            <ulink url="mailto:fw-auth@lists.zend.com">fw-auth@lists.zend.com</ulink> mail list. Actually, all
-            participation on any relevant topic is welcome :)
+            DEPRECATED: Use <methodname>getIterator()</methodname> in
+            <classname>Zend_Session_Namespace</classname>. This method returns an array of the
+            contents of <varname>$namespace</varname>. If you have logical reasons to keep this
+            method publicly accessible, please provide feedback to the <ulink
+                url="mailto:fw-auth@lists.zend.com">fw-auth@lists.zend.com</ulink> mail list.
+            Actually, all participation on any relevant topic is welcome :)
         </para>
 
         <note>
             <title>Throws</title>
+
             <para>
-                An exception will be thrown if <classname>Zend_Session</classname> is not marked as readable (e.g., before
-                <classname>Zend_Session</classname> has been started).
+                An exception will be thrown if <classname>Zend_Session</classname> is not marked as
+                readable (e.g., before <classname>Zend_Session</classname> has been started).
             </para>
         </note>
-
     </sect2>
 
     <sect2 id="zend.session.global_session_management.getiterator">
-
         <title>getIterator()</title>
 
         <para>
-            Use <methodname>getIterator()</methodname> to obtain an array containing the names of all namespaces.
+            Use <methodname>getIterator()</methodname> to obtain an array containing the names of
+            all namespaces.
         </para>
 
         <note>
             <title>Throws</title>
+
             <para>
-                An exception will be thrown if <classname>Zend_Session</classname> is not marked as readable (e.g., before
-                <classname>Zend_Session</classname> has been started).
+                An exception will be thrown if <classname>Zend_Session</classname> is not marked as
+                readable (e.g., before <classname>Zend_Session</classname> has been started).
             </para>
         </note>
-
     </sect2>
-
 </sect1>

documentation/manual/en/module_specs/Zend_Session-SaveHandler-DbTable.xml

@@ -2,6 +2,7 @@
 <!-- Reviewed: no -->
 <sect1 id="zend.session.savehandler.dbtable">
     <title>Zend_Session_SaveHandler_DbTable</title>
+
     <para>
         The basic setup for <classname>Zend_Session_SaveHandler_DbTable</classname> must at least
         have four columns, denoted in the config array or <classname>Zend_Config</classname> object:
@@ -12,8 +13,10 @@
         (<command>modified + lifetime > time();</command>);
         and data, which is the serialized data stored in the session
     </para>
+
     <example id="zend.session.savehandler.dbtable.basic">
             <title>Basic Setup</title>
+
             <programlisting language="SQL"><![CDATA[
 CREATE TABLE `session` (
   `id` char(32),
@@ -23,6 +26,7 @@ CREATE TABLE `session` (
   PRIMARY KEY (`id`)
 );
 ]]></programlisting>
+
         <programlisting language="php"><![CDATA[
 //get your database connection ready
 $db = Zend_Db::factory('Pdo_Mysql', array(
@@ -53,12 +57,15 @@ Zend_Session::start();
 //now you can use Zend_Session like any other time
 ]]></programlisting>
     </example>
+
     <para>
         You can also use Multiple Columns in your primary key for
         <classname>Zend_Session_SaveHandler_DbTable</classname>.
     </para>
+
     <example id="zend.session.savehandler.dbtable.multi-column-key">
         <title>Using a Multi-Column Primary Key</title>
+
         <programlisting language="SQL"><![CDATA[
 CREATE TABLE `session` (
     `session_id` char(32) NOT NULL,
@@ -70,6 +77,7 @@ CREATE TABLE `session` (
     PRIMARY KEY (`Session_ID`, `save_path`, `name`)
 );
 ]]></programlisting>
+
         <programlisting language="php"><![CDATA[
 //setup your DB connection like before
 //NOTE: this config is also passed to Zend_Db_Table so anything specific

documentation/manual/en/module_specs/Zend_Soap_AutoDiscovery.xml

@@ -5,57 +5,78 @@
 
     <sect2 id="zend.soap.autodiscovery.introduction">
         <title>AutoDiscovery Introduction</title>
+
         <para>
-            <acronym>SOAP</acronym> functionality implemented within Zend Framework is intended to make all steps
-            required for <acronym>SOAP</acronym> communications more simple.
+            <acronym>SOAP</acronym> functionality implemented within Zend Framework is intended to
+            make all steps required for <acronym>SOAP</acronym> communications more simple.
         </para>
 
         <para>
-            <acronym>SOAP</acronym> is language independent protocol. So it may be used not only for <acronym>PHP</acronym>-to-PHP communications.
+            <acronym>SOAP</acronym> is language independent protocol. So it may be used not only for
+            <acronym>PHP</acronym>-to-PHP communications.
         </para>
 
         <para>
-            There are three configurations for <acronym>SOAP</acronym> applications where Zend Framework may be utilized:
+            There are three configurations for <acronym>SOAP</acronym> applications where Zend
+            Framework may be utilized:
+
             <orderedlist>
                 <listitem>
-                    <simpara>SOAP server <acronym>PHP</acronym> application &lt;---&gt; <acronym>SOAP</acronym> client <acronym>PHP</acronym> application</simpara>
+                    <simpara>
+                        SOAP server <acronym>PHP</acronym> application &lt;---&gt;
+                        <acronym>SOAP</acronym> client <acronym>PHP</acronym> application
+                    </simpara>
                 </listitem>
+
                 <listitem>
-                    <simpara>SOAP server non-PHP application &lt;---&gt; <acronym>SOAP</acronym> client <acronym>PHP</acronym> application</simpara>
+                    <simpara>
+                        SOAP server non-PHP application &lt;---&gt; <acronym>SOAP</acronym>
+                        client <acronym>PHP</acronym> application
+                    </simpara>
                 </listitem>
+
                 <listitem>
-                    <simpara>SOAP server <acronym>PHP</acronym> application &lt;---&gt; <acronym>SOAP</acronym> client non-PHP application</simpara>
+                    <simpara>
+                        SOAP server <acronym>PHP</acronym> application &lt;---&gt;
+                        <acronym>SOAP</acronym> client non-PHP application
+                    </simpara>
                 </listitem>
             </orderedlist>
         </para>
 
         <para>
-            We always have to know, which functionality is provided by <acronym>SOAP</acronym> server to operate with it.
-            <ulink url="http://www.w3.org/TR/wsdl">WSDL</ulink> is used to describe network service <acronym>API</acronym>
-            in details.
+            We always have to know, which functionality is provided by <acronym>SOAP</acronym>
+            server to operate with it. <ulink url="http://www.w3.org/TR/wsdl">WSDL</ulink> is used
+            to describe network service <acronym>API</acronym> in details.
         </para>
 
         <para>
-            WSDL language is complex enough (see <ulink url="http://www.w3.org/TR/wsdl">http://www.w3.org/TR/wsdl</ulink>
+            WSDL language is complex enough (see <ulink
+                url="http://www.w3.org/TR/wsdl">http://www.w3.org/TR/wsdl</ulink>
             for the details). So it's difficult to prepare correct WSDL description.
         </para>
 
         <para>
-            Another problem is synchronizing changes in network service <acronym>API</acronym> with already existing WSDL.
+            Another problem is synchronizing changes in network service <acronym>API</acronym> with
+            already existing WSDL.
         </para>
 
         <para>
-            Both these problem may be solved by WSDL autogeneration. A prerequisite for this is a <acronym>SOAP</acronym> server autodiscovery.
-            It constructs object similar to object used in <acronym>SOAP</acronym> server application, extracts necessary information and generates
-            correct WSDL using this information.
+            Both these problem may be solved by WSDL autogeneration. A prerequisite for this is a
+            <acronym>SOAP</acronym> server autodiscovery. It constructs object similar to object
+            used in <acronym>SOAP</acronym> server application, extracts necessary information and
+            generates correct WSDL using this information.
         </para>
 
         <para>
-            There are two ways for using Zend Framework for <acronym>SOAP</acronym> server application:
+            There are two ways for using Zend Framework for <acronym>SOAP</acronym> server
+            application:
+
             <itemizedlist>
                 <listitem>
                     <para>Use separated class.</para>
                 </listitem>
+
                 <listitem>
                     <para>Use set of functions</para>
                 </listitem>
@@ -67,12 +88,15 @@
         </para>
 
         <para>
-            The<classname>Zend_Soap_AutoDiscover</classname> class also supports datatypes mapping from <acronym>PHP</acronym> to <ulink url="http://www.w3.org/TR/xmlschema-2/">XSD types</ulink>.
+            The<classname>Zend_Soap_AutoDiscover</classname> class also supports datatypes mapping
+            from <acronym>PHP</acronym> to <ulink
+                url="http://www.w3.org/TR/xmlschema-2/">XSD types</ulink>.
         </para>
 
         <para>
-            Here is an example of common usage of the autodiscovery functionality. The <methodname>handle()</methodname>
-            function generates the WSDL file and posts it to the browser.
+            Here is an example of common usage of the autodiscovery functionality. The
+            <methodname>handle()</methodname> function generates the WSDL file and posts it to the
+            browser.
 
             <programlisting language="php"><![CDATA[
 class My_SoapServer_Class {
@@ -86,26 +110,28 @@ $autodiscover->handle();
         </para>
 
         <para>
-            If you need access to the generated WSDL file either to save it to a file or
-            as an <acronym>XML</acronym> string you can use the <methodname>dump($filename)</methodname> or <methodname>toXml()</methodname>
-            functions the AutoDiscover class provides.
+            If you need access to the generated WSDL file either to save it to a file or as an
+            <acronym>XML</acronym> string you can use the <methodname>dump($filename)</methodname>
+            or <methodname>toXml()</methodname> functions the AutoDiscover class provides.
         </para>
 
         <note id="zend.soap.autodiscovery.introduction.noserver">
             <title>Zend_Soap_Autodiscover is not a Soap Server</title>
 
             <para>
-                It is very important to note, that the class <classname>Zend_Soap_AutoDiscover</classname> does not act
-                as a <acronym>SOAP</acronym> Server on its own. It only generates the WSDL and serves it to anyone accessing
-                the url it is listening on.
+                It is very important to note, that the class
+                <classname>Zend_Soap_AutoDiscover</classname> does not act as a
+                <acronym>SOAP</acronym> Server on its own. It only generates the WSDL and serves it
+                to anyone accessing the url it is listening on.
             </para>
 
             <para>
                 As the <acronym>SOAP</acronym> Endpoint Uri is uses the default
-                <code>'http://' .$_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']</code>,
-                but this can be changed with the <methodname>setUri()</methodname> function or the Constructor
-                parameter of <classname>Zend_Soap_AutoDiscover</classname> class. The endpoint has to provide
-                a <classname>Zend_Soap_Server</classname> that listens to requests.
+                <code>'http://' .$_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']</code>, but this
+                can be changed with the <methodname>setUri()</methodname> function or the
+                Constructor parameter of <classname>Zend_Soap_AutoDiscover</classname> class. The
+                endpoint has to provide a <classname>Zend_Soap_Server</classname> that listens to
+                requests.
             </para>
 
             <para>
@@ -129,8 +155,9 @@ if(isset($_GET['wsdl'])) {
         <title>Class autodiscovering</title>
 
         <para>
-            If class is used to provide SOAP server functionality, then the same class should be provided to
-            <classname>Zend_Soap_AutoDiscover</classname> for WSDL generation:
+            If class is used to provide SOAP server functionality, then the same class should be
+            provided to <classname>Zend_Soap_AutoDiscover</classname> for WSDL generation:
+
             <programlisting language="php"><![CDATA[
 $autodiscover = new Zend_Soap_AutoDiscover();
 $autodiscover->setClass('My_SoapServer_Class');
@@ -140,50 +167,69 @@ $autodiscover->handle();
 
         <para>
             The following rules are used while WSDL generation:
+
             <itemizedlist>
                 <listitem>
                     <para>Generated WSDL describes an RPC style Web Service.</para>
                 </listitem>
+
                 <listitem>
                     <para>Class name is used as a name of the Web Service being described.</para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        <code>'http://' .$_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']</code> is used
-                        as an <acronym>URI</acronym> where the WSDL is available by default but can be overwritten via <methodname>setUri()</methodname> method.
+                        <code>'http://' .$_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']</code> is
+                        used as an <acronym>URI</acronym> where the WSDL is available by default but
+                        can be overwritten via <methodname>setUri()</methodname> method.
                     </para>
+
                     <para>
-                         It's also used as a target namespace for all service related names (including
-                         described complex types).
+                         It's also used as a target namespace for all service related names
+                         (including described complex types).
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        Class methods are joined into one <ulink url="http://www.w3.org/TR/wsdl#_porttypes">Port Type</ulink>.
+                        Class methods are joined into one <ulink
+                            url="http://www.w3.org/TR/wsdl#_porttypes">Port Type</ulink>.
                     </para>
+
                     <para>
                         <code>$className . 'Port'</code> is used as Port Type name.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>Each class method is registered as a corresponding port operation.</para>
                 </listitem>
+
                 <listitem>
-                    <para>Each method prototype generates corresponding Request/Response messages.</para>
-                    <para>Method may have several prototypes if some method parameters are optional.</para>
+                    <para>
+                        Each method prototype generates corresponding Request/Response messages.
+                    </para>
+
+                    <para>
+                        Method may have several prototypes if some method parameters are optional.
+                    </para>
                 </listitem>
             </itemizedlist>
         </para>
 
         <note>
             <title>Important!</title>
+
             <para>
-                WSDL autodiscovery utilizes the <acronym>PHP</acronym> docblocks provided by the developer to determine the parameter and return types.
-                In fact, for scalar types, this is the only way to determine the parameter types, and for return types, this is the
-                only way to determine them.
+                WSDL autodiscovery utilizes the <acronym>PHP</acronym> docblocks provided by the
+                developer to determine the parameter and return types. In fact, for scalar types,
+                this is the only way to determine the parameter types, and for return types, this is
+                the only way to determine them.
             </para>
+
             <para>
-                That means, providing correct and fully detailed docblocks is not only best practice, but is required for discovered class.
+                That means, providing correct and fully detailed docblocks is not only best
+                practice, but is required for discovered class.
             </para>
         </note>
     </sect2>
@@ -192,8 +238,10 @@ $autodiscover->handle();
         <title>Functions autodiscovering</title>
 
         <para>
-            If set of functions are used to provide SOAP server functionality, then the same set should be provided to
-            <classname>Zend_Soap_AutoDiscovery</classname> for WSDL generation:
+            If set of functions are used to provide SOAP server functionality, then the same set
+            should be provided to <classname>Zend_Soap_AutoDiscovery</classname> for WSDL
+            generation:
+
             <programlisting language="php"><![CDATA[
 $autodiscover = new Zend_Soap_AutoDiscover();
 $autodiscover->addFunction('function1');
@@ -206,50 +254,70 @@ $autodiscover->handle();
 
         <para>
             The following rules are used while WSDL generation:
+
             <itemizedlist>
                 <listitem>
                     <para>Generated WSDL describes an RPC style Web Service.</para>
                 </listitem>
+
                 <listitem>
-                    <para>Current script name is used as a name of the Web Service being described.</para>
+                    <para>
+                        Current script name is used as a name of the Web Service being described.
+                    </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        <code>'http://' .$_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']</code> is used
-                        as an <acronym>URI</acronym> where the WSDL is available.
+                        <code>'http://' .$_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']</code> is
+                        used as an <acronym>URI</acronym> where the WSDL is available.
                     </para>
+
                     <para>
-                         It's also used as a target namespace for all service related names (including
-                         described complex types).
+                         It's also used as a target namespace for all service related names
+                         (including described complex types).
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        Functions are joined into one <ulink url="http://www.w3.org/TR/wsdl#_porttypes">Port Type</ulink>.
+                        Functions are joined into one <ulink
+                            url="http://www.w3.org/TR/wsdl#_porttypes">Port Type</ulink>.
                     </para>
+
                     <para>
                         <code>$functionName . 'Port'</code> is used as Port Type name.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>Each function is registered as a corresponding port operation.</para>
                 </listitem>
+
                 <listitem>
-                    <para>Each function prototype generates corresponding Request/Response messages.</para>
-                    <para>Function may have several prototypes if some method parameters are optional.</para>
+                    <para>
+                        Each function prototype generates corresponding Request/Response messages.
+                    </para>
+
+                    <para>
+                        Function may have several prototypes if some method parameters are optional.
+                    </para>
                 </listitem>
             </itemizedlist>
         </para>
 
         <note>
             <title>Important!</title>
+
             <para>
-                WSDL autodiscovery utilizes the <acronym>PHP</acronym> docblocks provided by the developer to determine the parameter and return types.
-                In fact, for scalar types, this is the only way to determine the parameter types, and for return types, this is the
-                only way to determine them.
+                WSDL autodiscovery utilizes the <acronym>PHP</acronym> docblocks provided by the
+                developer to determine the parameter and return types. In fact, for scalar types,
+                this is the only way to determine the parameter types, and for return types, this is
+                the only way to determine them.
             </para>
+
             <para>
-                That means, providing correct and fully detailed docblocks is not only best practice, but is required for discovered class.
+                That means, providing correct and fully detailed docblocks is not only best
+                practice, but is required for discovered class.
             </para>
         </note>
     </sect2>
@@ -258,50 +326,74 @@ $autodiscover->handle();
         <title>Autodiscovering Datatypes</title>
 
         <para>
-            Input/output datatypes are converted into network service types using the following mapping:
+            Input/output datatypes are converted into network service types using the following
+            mapping:
 
             <itemizedlist>
                 <listitem>
                     <para>PHP strings &lt;-&gt; <code>xsd:string</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP integers &lt;-&gt; <code>xsd:int</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP floats and doubles &lt;-&gt; <code>xsd:float</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP booleans &lt;-&gt; <code>xsd:boolean</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP arrays &lt;-&gt; <code>soap-enc:Array</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP object &lt;-&gt; <code>xsd:struct</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        <acronym>PHP</acronym> class &lt;-&gt; based on complex type strategy (See: <xref linkend="zend.soap.wsdl.types.add_complex" />)
+                        <acronym>PHP</acronym> class &lt;-&gt; based on complex type strategy (See:
+                        <xref linkend="zend.soap.wsdl.types.add_complex" />)
+
                         <footnote>
                             <para>
-                                <classname>Zend_Soap_AutoDiscover</classname> will be created with the <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname>
-                                class as detection algorithm for complex types. The first parameter of the AutoDiscover constructor takes
-                                any complex type strategy implementing <classname>Zend_Soap_Wsdl_Strategy_Interface</classname> or a string with the name
-                                of the class. For backwards compatibility with <varname>$extractComplexType</varname> boolean variables are parsed
-                                exactly like in <classname>Zend_Soap_Wsdl</classname>. See the <link linkend="zend.soap.wsdl.types.add_complex"><classname>Zend_Soap_Wsdl</classname> manual
-                                on adding complex</link> types for more information.
+                                <classname>Zend_Soap_AutoDiscover</classname> will be created with
+                                the
+                                <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname>
+                                class as detection algorithm for complex types. The first parameter
+                                of the AutoDiscover constructor takes any complex type strategy
+                                implementing
+                                <classname>Zend_Soap_Wsdl_Strategy_Interface</classname> or a string
+                                with the name of the class. For backwards compatibility with
+                                <varname>$extractComplexType</varname> boolean variables are parsed
+                                exactly like in <classname>Zend_Soap_Wsdl</classname>. See the
+                                <link
+                                    linkend="zend.soap.wsdl.types.add_complex"><classname>Zend_Soap_Wsdl</classname>
+                                    manual on adding complex</link> types for more information.
                             </para>
                         </footnote>.
                     </para>
                 </listitem>
+
                 <listitem>
-                    <para>type[] or object[] (ie. int[]) &lt;-&gt; based on complex type strategy</para>
+                    <para>
+                        type[] or object[] (ie. int[]) &lt;-&gt; based on complex type strategy
+                    </para>
                 </listitem>
+
                 <listitem>
                     <para>PHP void &lt;-&gt; empty type.</para>
                 </listitem>
+
                 <listitem>
-                    <para>If type is not matched to any of these types by some reason, then <code>xsd:anyType</code> is used.</para>
+                    <para>
+                        If type is not matched to any of these types by some reason, then
+                        <code>xsd:anyType</code> is used.
+                    </para>
                 </listitem>
             </itemizedlist>
 

documentation/manual/en/module_specs/Zend_Soap_Client.xml

@@ -4,7 +4,8 @@
     <title>Zend_Soap_Client</title>
 
     <para>
-        The <classname>Zend_Soap_Client</classname> class simplifies <acronym>SOAP</acronym> client development for <acronym>PHP</acronym> programmers.
+        The <classname>Zend_Soap_Client</classname> class simplifies <acronym>SOAP</acronym> client
+        development for <acronym>PHP</acronym> programmers.
     </para>
 
     <para>
@@ -12,115 +13,151 @@
     </para>
 
     <para>
-        Under the WSDL mode, the <classname>Zend_Soap_Client</classname> component uses a WSDL document to define transport
-        layer options.
+        Under the WSDL mode, the <classname>Zend_Soap_Client</classname> component uses a WSDL
+        document to define transport layer options.
     </para>
 
     <para>
-        The WSDL description is usually provided by the web service the client will access. If the WSDL description is not
-        made available, you may want to use <classname>Zend_Soap_Client</classname> in non-WSDL mode.
-        Under this mode, all <acronym>SOAP</acronym> protocol options have to be set explicitly on the <classname>Zend_Soap_Client</classname> class.
+        The WSDL description is usually provided by the web service the client will access. If the
+        WSDL description is not made available, you may want to use
+        <classname>Zend_Soap_Client</classname> in non-WSDL mode. Under this mode, all
+        <acronym>SOAP</acronym> protocol options have to be set explicitly on the
+        <classname>Zend_Soap_Client</classname> class.
     </para>
 
     <sect2 id="zend.soap.client.constructor">
         <title>Zend_Soap_Client Constructor</title>
+
         <para>
             The <classname>Zend_Soap_Client</classname> constructor takes two parameters:
+
             <itemizedlist>
                 <listitem>
                     <para>
                         <varname>$wsdl</varname> - the <acronym>URI</acronym> of a WSDL file.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        <varname>$options</varname> - options to create <acronym>SOAP</acronym> client object.
+                        <varname>$options</varname> - options to create <acronym>SOAP</acronym>
+                        client object.
                     </para>
                 </listitem>
             </itemizedlist>
 
-            Both of these parameters may be set later using <methodname>setWsdl($wsdl)</methodname> and
-            <methodname>setOptions($options)</methodname> methods respectively.
+            Both of these parameters may be set later using <methodname>setWsdl($wsdl)</methodname>
+            and <methodname>setOptions($options)</methodname> methods respectively.
         </para>
 
         <note>
             <title>Important!</title>
+
             <para>
-                If you use <classname>Zend_Soap_Client</classname> component in non-WSDL mode, you <emphasis>must</emphasis> set
-                the 'location' and 'uri' options.
+                If you use <classname>Zend_Soap_Client</classname> component in non-WSDL mode, you
+                <emphasis>must</emphasis> set the 'location' and 'uri' options.
             </para>
         </note>
 
         <para>
             The following options are recognized:
+
             <itemizedlist>
                 <listitem>
                     <para>
-                        'soap_version' ('soapVersion') - soap version to use (SOAP_1_1 or <acronym>SOAP</acronym>_1_2).
+                        'soap_version' ('soapVersion') - soap version to use (SOAP_1_1 or
+                        <acronym>SOAP</acronym>_1_2).
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'classmap' ('classMap') - can be used to map some WSDL types to <acronym>PHP</acronym> classes.
+                        'classmap' ('classMap') - can be used to map some WSDL types to
+                        <acronym>PHP</acronym> classes.
                     </para>
+
                     <para>
-                        The option must be an array with WSDL types as keys and names of <acronym>PHP</acronym> classes as values.
+                        The option must be an array with WSDL types as keys and names of
+                        <acronym>PHP</acronym> classes as values.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'encoding' - internal character encoding (UTF-8 is always used as an external encoding).
+                        'encoding' - internal character encoding (UTF-8 is always used as an
+                        external encoding).
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'wsdl' which is equivalent to <methodname>setWsdl($wsdlValue)</methodname> call.
+                        'wsdl' which is equivalent to <methodname>setWsdl($wsdlValue)</methodname>
+                        call.
                     </para>
+
                     <para>
-                        Changing this option may switch <classname>Zend_Soap_Client</classname> object to or from WSDL mode.
+                        Changing this option may switch <classname>Zend_Soap_Client</classname>
+                        object to or from WSDL mode.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'uri' - target namespace for the <acronym>SOAP</acronym> service (required for non-WSDL-mode, doesn't work for WSDL mode).
+                        'uri' - target namespace for the <acronym>SOAP</acronym> service (required
+                        for non-WSDL-mode, doesn't work for WSDL mode).
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'location' - the <acronym>URL</acronym> to request (required for non-WSDL-mode, doesn't work for WSDL mode).
+                        'location' - the <acronym>URL</acronym> to request (required for
+                        non-WSDL-mode, doesn't work for WSDL mode).
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'style' - request style (doesn't work for WSDL mode): <constant>SOAP_RPC</constant> or <constant>SOAP_DOCUMENT</constant>.
+                        'style' - request style (doesn't work for WSDL mode):
+                        <constant>SOAP_RPC</constant> or <constant>SOAP_DOCUMENT</constant>.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'use' - method to encode messages (doesn't work for WSDL mode): <constant>SOAP_ENCODED</constant> or
-                        <constant>SOAP_LITERAL</constant>.
+                        'use' - method to encode messages (doesn't work for WSDL mode):
+                        <constant>SOAP_ENCODED</constant> or <constant>SOAP_LITERAL</constant>.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'login' and 'password' - login and password for an <acronym>HTTP</acronym> authentication.
+                        'login' and 'password' - login and password for an <acronym>HTTP</acronym>
+                        authentication.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'proxy_host', 'proxy_port', 'proxy_login', and 'proxy_password' - an <acronym>HTTP</acronym> connection through a proxy server.
+                        'proxy_host', 'proxy_port', 'proxy_login', and 'proxy_password' - an
+                        <acronym>HTTP</acronym> connection through a proxy server.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'local_cert' and 'passphrase' - <acronym>HTTPS</acronym> client certificate authentication options.
+                        'local_cert' and 'passphrase' - <acronym>HTTPS</acronym> client certificate
+                        authentication options.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        'compression' - compression options; it's a combination of <constant>SOAP_COMPRESSION_ACCEPT</constant>,
-                        <constant>SOAP_COMPRESSION_GZIP</constant> and <constant>SOAP_COMPRESSION_DEFLATE</constant> options which
-                        may be used like this:
+                        'compression' - compression options; it's a combination of
+                        <constant>SOAP_COMPRESSION_ACCEPT</constant>,
+                        <constant>SOAP_COMPRESSION_GZIP</constant> and
+                        <constant>SOAP_COMPRESSION_DEFLATE</constant> options which may be used like
+                        this:
+
                         <programlisting language="php"><![CDATA[
 // Accept response compression
 $client = new Zend_Soap_Client("some.wsdl",
@@ -146,15 +183,18 @@ $client = new Zend_Soap_Client("some.wsdl",
         <title>Performing SOAP Requests</title>
 
         <para>
-            After we've created a <classname>Zend_Soap_Client</classname> object we are ready to perform <acronym>SOAP</acronym> requests.
+            After we've created a <classname>Zend_Soap_Client</classname> object we are ready to
+            perform <acronym>SOAP</acronym> requests.
         </para>
+
         <para>
-            Each web service method is mapped to the virtual <classname>Zend_Soap_Client</classname> object method which takes
-            parameters with common <acronym>PHP</acronym> types.
+            Each web service method is mapped to the virtual <classname>Zend_Soap_Client</classname>
+            object method which takes parameters with common <acronym>PHP</acronym> types.
         </para>
 
         <para>
             Use it like in the following example:
+
             <programlisting language="php"><![CDATA[
 //****************************************************************
 //                Server code

documentation/manual/en/module_specs/Zend_Soap_Server.xml

@@ -4,86 +4,115 @@
     <title>Zend_Soap_Server</title>
 
     <para>
-        <classname>Zend_Soap_Server</classname> class is intended to simplify Web Services server part development for <acronym>PHP</acronym> programmers.
+        <classname>Zend_Soap_Server</classname> class is intended to simplify Web Services server
+        part development for <acronym>PHP</acronym> programmers.
     </para>
 
     <para>
-        It may be used in WSDL or non-WSDL mode, and using classes or functions to define Web Service <acronym>API</acronym>.
+        It may be used in WSDL or non-WSDL mode, and using classes or functions to define Web
+        Service <acronym>API</acronym>.
     </para>
 
     <para>
-        When <classname>Zend_Soap_Server</classname> component works in the WSDL mode, it uses already prepared WSDL document to define
-        server object behavior and transport layer options.
+        When <classname>Zend_Soap_Server</classname> component works in the WSDL mode, it uses
+        already prepared WSDL document to define server object behavior and transport layer options.
     </para>
 
     <para>
-        WSDL document may be auto-generated with functionality provided by
-        <link linkend="zend.soap.autodiscovery.introduction">Zend_Soap_AutoDiscovery component</link> or should be constructed manually using
-        <link linkend="zend.soap.wsdl"><classname>Zend_Soap_Wsdl</classname> class</link> or any other <acronym>XML</acronym> generating tool.
+        WSDL document may be auto-generated with functionality provided by <link
+            linkend="zend.soap.autodiscovery.introduction">Zend_Soap_AutoDiscovery component</link>
+        or should be constructed manually using <link
+            linkend="zend.soap.wsdl"><classname>Zend_Soap_Wsdl</classname> class</link> or any other
+        <acronym>XML</acronym> generating tool.
     </para>
 
     <para>
-        If the non-WSDL mode is used, then all protocol options have to be set using options mechanism.
+        If the non-WSDL mode is used, then all protocol options have to be set using options
+        mechanism.
     </para>
 
     <sect2 id="zend.soap.server.constructor">
         <title>Zend_Soap_Server constructor</title>
+
         <para>
-            <classname>Zend_Soap_Server</classname> constructor should be used a bit differently for WSDL and non-WSDL modes.
+            <classname>Zend_Soap_Server</classname> constructor should be used a bit differently for
+            WSDL and non-WSDL modes.
         </para>
 
         <sect3 id="zend.soap.server.constructor.wsdl_mode">
             <title>Zend_Soap_Server constructor for the WSDL mode</title>
+
             <para>
-                <classname>Zend_Soap_Server</classname> constructor takes two optional parameters when it works in WSDL mode:
+                <classname>Zend_Soap_Server</classname> constructor takes two optional parameters
+                when it works in WSDL mode:
+
                 <orderedlist>
                     <listitem>
                         <para>
-                            <varname>$wsdl</varname>, which is an <acronym>URI</acronym> of a WSDL file<footnote>
-                                                                                  <para>
-                                                                                      May be set later using <methodname>setWsdl($wsdl)</methodname> method.
-                                                                                  </para>
-                                                                              </footnote>.
+                            <varname>$wsdl</varname>, which is an <acronym>URI</acronym> of a WSDL file
+
+                            <footnote>
+                                <para>
+                                    May be set later using <methodname>setWsdl($wsdl)</methodname>
+                                    method.
+                                </para>
+                            </footnote>.
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
-                            <varname>$options</varname> - options to create <acronym>SOAP</acronym> server object<footnote>
-                                                                                            <para>
-                                                                                                Options may be set later using
-                                                                                                <methodname>setOptions($options)</methodname> method.
-                                                                                            </para>
-                                                                                        </footnote>.
+                            <varname>$options</varname> - options to create <acronym>SOAP</acronym>
+                            server object
+
+                            <footnote>
+                                <para>
+                                    Options may be set later using
+                                    <methodname>setOptions($options)</methodname> method.
+                                </para>
+                            </footnote>.
                         </para>
+
                         <para>
                             The following options are recognized in the WSDL mode:
+
                             <itemizedlist>
                                 <listitem>
                                     <para>
-                                        'soap_version' ('soapVersion') - soap version to use (SOAP_1_1 or <acronym>SOAP</acronym>_1_2).
+                                        'soap_version' ('soapVersion') - soap version to use
+                                        (SOAP_1_1 or <acronym>SOAP</acronym>_1_2).
                                     </para>
                                 </listitem>
+
                                 <listitem>
                                     <para>
                                         'actor' - the actor <acronym>URI</acronym> for the server.
                                     </para>
                                 </listitem>
+
                                 <listitem>
                                     <para>
-                                        'classmap' ('classMap') which can be used to map some WSDL types to <acronym>PHP</acronym> classes.
+                                        'classmap' ('classMap') which can be used to map some WSDL
+                                        types to <acronym>PHP</acronym> classes.
                                     </para>
+
                                     <para>
-                                        The option must be an array with WSDL types as keys and names of <acronym>PHP</acronym> classes as values.
+                                        The option must be an array with WSDL types as keys and
+                                        names of <acronym>PHP</acronym> classes as values.
                                     </para>
                                 </listitem>
+
                                 <listitem>
                                     <para>
-                                        'encoding' - internal character encoding (UTF-8 is always used as an external encoding).
+                                        'encoding' - internal character encoding (UTF-8 is always
+                                        used as an external encoding).
                                     </para>
                                 </listitem>
+
                                 <listitem>
                                     <para>
-                                        'wsdl' which is equivalent to <methodname>setWsdl($wsdlValue)</methodname> call.
+                                        'wsdl' which is equivalent to
+                                        <methodname>setWsdl($wsdlValue)</methodname> call.
                                     </para>
                                 </listitem>
                             </itemizedlist>
@@ -95,51 +124,69 @@
 
         <sect3 id="zend.soap.server.wsdl_mode">
             <title>Zend_Soap_Server constructor for the non-WSDL mode</title>
+
             <para>
-                The first constructor parameter <emphasis>must</emphasis> be set to <constant>NULL</constant> if you
-                plan to use <classname>Zend_Soap_Server</classname> functionality in non-WSDL mode.
+                The first constructor parameter <emphasis>must</emphasis> be set to
+                <constant>NULL</constant> if you plan to use <classname>Zend_Soap_Server</classname>
+                functionality in non-WSDL mode.
             </para>
+
             <para>
                 You also have to set 'uri' option in this case (see below).
             </para>
 
             <para>
-                The second constructor parameter (<varname>$options</varname>) is an array with options to create
-                <acronym>SOAP</acronym> server object<footnote>
-                                      <para>
-                                          Options may be set later using <methodname>setOptions($options)</methodname> method.
-                                      </para>
-                                  </footnote>.
+                The second constructor parameter (<varname>$options</varname>) is an array with
+                options to create <acronym>SOAP</acronym> server object
+
+                <footnote>
+                    <para>
+                        Options may be set later using <methodname>setOptions($options)</methodname>
+                        method.
+                    </para>
+                </footnote>.
             </para>
+
             <para>
                 The following options are recognized in the non-WSDL mode:
+
                 <itemizedlist>
                     <listitem>
                         <para>
-                            'soap_version' ('soapVersion') - soap version to use (SOAP_1_1 or <acronym>SOAP</acronym>_1_2).
+                            'soap_version' ('soapVersion') - soap version to use (SOAP_1_1 or
+                            <acronym>SOAP</acronym>_1_2).
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
                             'actor' - the actor <acronym>URI</acronym> for the server.
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
-                            'classmap' ('classMap') which can be used to map some WSDL types to <acronym>PHP</acronym> classes.
+                            'classmap' ('classMap') which can be used to map some WSDL types to
+                            <acronym>PHP</acronym> classes.
                         </para>
+
                         <para>
-                            The option must be an array with WSDL types as keys and names of <acronym>PHP</acronym> classes as values.
+                            The option must be an array with WSDL types as keys and names of
+                            <acronym>PHP</acronym> classes as values.
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
-                            'encoding' - internal character encoding (UTF-8 is always used as an external encoding).
+                            'encoding' - internal character encoding (UTF-8 is always used as an
+                            external encoding).
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
-                            'uri' (required) - <acronym>URI</acronym> namespace for <acronym>SOAP</acronym> server.
+                            'uri' (required) - <acronym>URI</acronym> namespace for
+                            <acronym>SOAP</acronym> server.
                         </para>
                     </listitem>
                 </itemizedlist>
@@ -151,12 +198,14 @@
         <title>Methods to define Web Service API</title>
 
         <para>
-            There are two ways to define Web Service <acronym>API</acronym> when your want to give access to your <acronym>PHP</acronym> code through <acronym>SOAP</acronym>.
+            There are two ways to define Web Service <acronym>API</acronym> when your want to give
+            access to your <acronym>PHP</acronym> code through <acronym>SOAP</acronym>.
         </para>
 
         <para>
-            The first one is to attach some class to the <classname>Zend_Soap_Server</classname> object which has to completely describe
-            Web Service API:
+            The first one is to attach some class to the <classname>Zend_Soap_Server</classname>
+            object which has to completely describe Web Service API:
+
             <programlisting language="php"><![CDATA[
 ...
 class MyClass {
@@ -192,18 +241,22 @@ $server->setObject(new MyClass());
 ...
 $server->handle();
 ]]></programlisting>
+
             <note>
                 <title>Important!</title>
+
                 <para>
-                    You should completely describe each method using method docblock if you plan to use autodiscover functionality
-                    to prepare corresponding Web Service WSDL.
+                    You should completely describe each method using method docblock if you plan to
+                    use autodiscover functionality to prepare corresponding Web Service WSDL.
                 </para>
             </note>
         </para>
 
         <para>
-            The second method of defining Web Service API is using set of functions and <methodname>addFunction()</methodname> or
-            <methodname>loadFunctions()</methodname> methods:
+            The second method of defining Web Service API is using set of functions and
+            <methodname>addFunction()</methodname> or <methodname>loadFunctions()</methodname>
+            methods:
+
             <programlisting language="php"><![CDATA[
 ...
 /**
@@ -238,25 +291,30 @@ $server->handle();
 
     <sect2 id="zend.soap.server.request_response">
         <title>Request and response objects handling</title>
+
         <note>
             <title>Advanced</title>
+
             <para>
-                This section describes advanced request/response processing options and may be skipped.
+                This section describes advanced request/response processing options and may be
+                skipped.
             </para>
         </note>
 
         <para>
-            <classname>Zend_Soap_Server</classname> component performs request/response processing automatically,
-            but allows to catch it and do some pre- and post-processing.
+            <classname>Zend_Soap_Server</classname> component performs request/response processing
+            automatically, but allows to catch it and do some pre- and post-processing.
         </para>
 
         <sect3 id="zend.soap.server.request_response.request">
             <title>Request processing</title>
 
             <para>
-                <methodname>Zend_Soap_Server::handle()</methodname> method takes request from the standard input stream ('php://input').
-                It may be overridden either by supplying optional parameter to the <methodname>handle()</methodname> method or
-                by setting request using <methodname>setRequest()</methodname> method:
+                <methodname>Zend_Soap_Server::handle()</methodname> method takes request from the
+                standard input stream ('php://input'). It may be overridden either by supplying
+                optional parameter to the <methodname>handle()</methodname> method or by setting
+                request using <methodname>setRequest()</methodname> method:
+
                 <programlisting language="php"><![CDATA[
 ...
 $server = new Zend_Soap_Server(...);
@@ -272,27 +330,33 @@ $server->handle();
 
             <para>
                 Request object may be represented using any of the following:
+
                 <itemizedlist>
                     <listitem>
                         <para>
                             DOMDocument (casted to <acronym>XML</acronym>)
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
                             DOMNode (owner document is grabbed and casted to <acronym>XML</acronym>)
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
                             SimpleXMLElement (casted to <acronym>XML</acronym>)
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
-                            stdClass (__toString() is called and verified to be valid <acronym>XML</acronym>)
+                            stdClass (__toString() is called and verified to be valid
+                            <acronym>XML</acronym>)
                         </para>
                     </listitem>
+
                     <listitem>
                         <para>
                             string (verified to be valid <acronym>XML</acronym>)
@@ -302,7 +366,9 @@ $server->handle();
             </para>
 
             <para>
-                Last processed request may be retrieved using <methodname>getLastRequest()</methodname> method as an XML string:
+                Last processed request may be retrieved using
+                <methodname>getLastRequest()</methodname> method as an XML string:
+
                 <programlisting language="php"><![CDATA[
 ...
 $server = new Zend_Soap_Server(...);
@@ -310,7 +376,6 @@ $server = new Zend_Soap_Server(...);
 $server->handle();
 $request = $server->getLastRequest();
 ]]></programlisting>
-
             </para>
         </sect3>
 
@@ -318,15 +383,21 @@ $request = $server->getLastRequest();
             <title>Response pre-processing</title>
 
             <para>
-                <methodname>Zend_Soap_Server::handle()</methodname> method automatically emits generated response to the output stream.
-                It may be blocked using <methodname>setReturnResponse()</methodname> with <constant>TRUE</constant> or <constant>FALSE</constant>
-                as a parameter<footnote>
-                                <para>
-                                    Current state of the Return Response flag may be requested with
-                                    <methodname>setReturnResponse()</methodname> method.
-                                </para>
-                              </footnote>.
-                Generated response is returned by <methodname>handle()</methodname> method in this case.
+                <methodname>Zend_Soap_Server::handle()</methodname> method automatically emits
+                generated response to the output stream. It may be blocked using
+                <methodname>setReturnResponse()</methodname> with <constant>TRUE</constant> or
+                <constant>FALSE</constant> as a parameter
+
+                <footnote>
+                    <para>
+                        Current state of the Return Response flag may be requested with
+                        <methodname>setReturnResponse()</methodname> method.
+                    </para>
+                </footnote>.
+
+                Generated response is returned by <methodname>handle()</methodname> method in this
+                case.
+
                 <programlisting language="php"><![CDATA[
 ...
 $server = new Zend_Soap_Server(...);
@@ -341,7 +412,9 @@ $response = $server->handle();
             </para>
 
             <para>
-                Last response may be also retrieved by <methodname>getLastResponse()</methodname> method for some post-processing:
+                Last response may be also retrieved by <methodname>getLastResponse()</methodname>
+                method for some post-processing:
+
                 <programlisting language="php"><![CDATA[
 ...
 $server = new Zend_Soap_Server(...);

documentation/manual/en/module_specs/Zend_Soap_Wsdl.xml

@@ -5,10 +5,13 @@
 
     <note>
         <para>
-            <classname>Zend_Soap_Wsdl</classname> class is used by <classname>Zend_Soap_Server</classname> component internally to operate with WSDL
-            documents. Nevertheless, you could also use functionality provided by this class for your own needs.
-            The <classname>Zend_Soap_Wsdl</classname> package contains both a parser and a builder of WSDL documents.
+            <classname>Zend_Soap_Wsdl</classname> class is used by
+            <classname>Zend_Soap_Server</classname> component internally to operate with WSDL
+            documents. Nevertheless, you could also use functionality provided by this class for
+            your own needs. The <classname>Zend_Soap_Wsdl</classname> package contains both a parser
+            and a builder of WSDL documents.
         </para>
+
         <para>
             If you don't plan to do this, you can skip this documentation section.
         </para>
@@ -16,25 +19,32 @@
 
     <sect2 id="zend.soap.wsdl.constructor">
         <title>Zend_Soap_Wsdl constructor</title>
+
         <para>
             <classname>Zend_Soap_Wsdl</classname> constructor takes three parameters:
+
             <orderedlist>
                 <listitem>
-                    <simpara><varname>$name</varname> - name of the Web Service being described.</simpara>
+                    <simpara>
+                        <varname>$name</varname> - name of the Web Service being described.
+                    </simpara>
                 </listitem>
+
                 <listitem>
                     <simpara>
-                        <varname>$uri</varname> - <acronym>URI</acronym> where the WSDL will be available
-                        (could also be a reference to the file in the filesystem.)
+                        <varname>$uri</varname> - <acronym>URI</acronym> where the WSDL will be
+                        available (could also be a reference to the file in the filesystem.)
                     </simpara>
                 </listitem>
+
                 <listitem>
                     <simpara>
-                        <varname>$strategy</varname> - optional flag used to identify the strategy for complex types (objects)
-                        detection. This was a boolean <varname>$extractComplexTypes</varname> before version 1.7 and can
-                        still be set as a boolean for backwards compatibility. By default the 1.6 detection behaviour
-                        is set. To read more on complex type detection strategies go to the section:
-                        <xref linkend="zend.soap.wsdl.types.add_complex" />.
+                        <varname>$strategy</varname> - optional flag used to identify the strategy
+                        for complex types (objects) detection. This was a boolean
+                        <varname>$extractComplexTypes</varname> before version 1.7 and can still be
+                        set as a boolean for backwards compatibility. By default the 1.6 detection
+                        behaviour is set. To read more on complex type detection strategies go to
+                        the section: <xref linkend="zend.soap.wsdl.types.add_complex" />.
                     </simpara>
                 </listitem>
             </orderedlist>
@@ -43,57 +53,75 @@
 
     <sect2 id="zend.soap.wsdl.addmessage">
         <title>addMessage() method</title>
+
         <para>
-            <methodname>addMessage($name, $parts)</methodname> method adds new message description to the WSDL document
-            (/definitions/message element).
+            <methodname>addMessage($name, $parts)</methodname> method adds new message description
+            to the WSDL document (/definitions/message element).
         </para>
+
         <para>
-            Each message correspond to methods in terms of <classname>Zend_Soap_Server</classname> and
-            <classname>Zend_Soap_Client</classname> functionality.
+            Each message correspond to methods in terms of <classname>Zend_Soap_Server</classname>
+            and <classname>Zend_Soap_Client</classname> functionality.
         </para>
+
         <para>
            <varname>$name</varname> parameter represents message name.
         </para>
+
         <para>
-           <varname>$parts</varname> parameter is an array of message parts which describe <acronym>SOAP</acronym> call parameters.
-           It's an associative array: 'part name' (SOAP call parameter name) =&gt; 'part type'.
+           <varname>$parts</varname> parameter is an array of message parts which describe
+           <acronym>SOAP</acronym> call parameters. It's an associative array: 'part name' (SOAP
+           call parameter name) =&gt; 'part type'.
         </para>
+
         <para>
-            Type mapping management is performed using <methodname>addTypes()</methodname>, <methodname>addTypes()</methodname> and
-            <methodname>addComplexType()</methodname> methods (see below).
+            Type mapping management is performed using <methodname>addTypes()</methodname>,
+            <methodname>addTypes()</methodname> and <methodname>addComplexType()</methodname>
+            methods (see below).
         </para>
+
         <note>
             <para>
                 Messages parts can use either 'element' or 'type' attribute for typing
                 (see <ulink url="http://www.w3.org/TR/wsdl#_messages"/>).
             </para>
+
             <para>
-                'element' attribute must refer to a corresponding element of data type definition. 'type' attribute refers
-                to a corresponding complexType entry.
+                'element' attribute must refer to a corresponding element of data type definition.
+                'type' attribute refers to a corresponding complexType entry.
             </para>
+
             <para>
                 All standard XSD types have both 'element' and 'complexType' definitions
                 (see <ulink url="http://schemas.xmlsoap.org/soap/encoding/"/>).
             </para>
+
             <para>
-                All non-standard types, which may be added using <methodname>Zend_Soap_Wsdl::addComplexType()</methodname> method, are
-                described using 'complexType' node of '/definitions/types/schema/' section of WSDL document.
+                All non-standard types, which may be added using
+                <methodname>Zend_Soap_Wsdl::addComplexType()</methodname> method, are described
+                using 'complexType' node of '/definitions/types/schema/' section of WSDL document.
             </para>
+
             <para>
-                So <methodname>addMessage()</methodname> method always uses 'type' attribute to describe types.
+                So <methodname>addMessage()</methodname> method always uses 'type' attribute to
+                describe types.
             </para>
         </note>
     </sect2>
 
     <sect2 id="zend.soap.wsdl.add_port_type">
         <title>addPortType() method</title>
+
         <para>
-            <methodname>addPortType($name)</methodname> method adds new port type to the WSDL document
-            (/definitions/portType) with the specified port type name.
+            <methodname>addPortType($name)</methodname> method adds new port type to the WSDL
+            document (/definitions/portType) with the specified port type name.
         </para>
+
         <para>
-            It joins a set of Web Service methods defined in terms of <classname>Zend_Soap_Server</classname> implementation.
+            It joins a set of Web Service methods defined in terms of
+            <classname>Zend_Soap_Server</classname> implementation.
         </para>
+
         <para>
             See <ulink url="http://www.w3.org/TR/wsdl#_porttypes"/> for the details.
         </para>
@@ -101,29 +129,37 @@
 
     <sect2 id="zend.soap.wsdl.add_port_operation">
         <title>addPortOperation() method</title>
+
         <para>
-            <methodname>addPortOperation($portType, $name, $input = false, $output = false, $fault = false)</methodname> method
-            adds new port operation to the specified port type of the WSDL document
-            (/definitions/portType/operation).
+            <methodname>addPortOperation($portType, $name, $input = false, $output = false, $fault
+                = false)</methodname> method adds new port operation to the specified port type of
+            the WSDL document (/definitions/portType/operation).
         </para>
+
         <para>
-            Each port operation corresponds to a class method (if Web Service is based on a class) or function
-            (if Web Service is based on a set of methods) in terms of <classname>Zend_Soap_Server</classname> implementation.
+            Each port operation corresponds to a class method (if Web Service is based on a class)
+            or function (if Web Service is based on a set of methods) in terms of
+            <classname>Zend_Soap_Server</classname> implementation.
         </para>
+
         <para>
             It also adds corresponding port operation messages depending on specified
-            <varname>$input</varname>, <varname>$output</varname> and <varname>$fault</varname> parameters.
+            <varname>$input</varname>, <varname>$output</varname> and <varname>$fault</varname>
+            parameters.
 
             <note>
                 <para>
-                    <classname>Zend_Soap_Server</classname> component generates two messages for each port operation while describing service based on
+                    <classname>Zend_Soap_Server</classname> component generates two messages for
+                    each port operation while describing service based on
                     <classname>Zend_Soap_Server</classname> class:
+
                     <itemizedlist>
                         <listitem>
                             <para>
                                 input message with name <code>$methodName . 'Request'</code>.
                             </para>
                         </listitem>
+
                         <listitem>
                             <para>
                                 output message with name <code>$methodName . 'Response'</code>.
@@ -133,6 +169,7 @@
                 </para>
             </note>
         </para>
+
         <para>
             See <ulink url="http://www.w3.org/TR/wsdl#_request-response"/> for the details.
         </para>
@@ -140,38 +177,52 @@
 
     <sect2 id="zend.soap.wsdl.add_binding">
         <title>addBinding() method</title>
+
         <para>
-            <methodname>addBinding($name, $portType)</methodname> method adds new binding to the WSDL document (/definitions/binding).
+            <methodname>addBinding($name, $portType)</methodname> method adds new binding to the
+            WSDL document (/definitions/binding).
         </para>
+
         <para>
-            'binding' WSDL document node defines message format and protocol details for operations and messages
-            defined by a particular portType (see <ulink url="http://www.w3.org/TR/wsdl#_bindings"/>).
+            'binding' WSDL document node defines message format and protocol details for operations
+            and messages defined by a particular portType (see <ulink
+                url="http://www.w3.org/TR/wsdl#_bindings"/>).
         </para>
+
         <para>
-            The method creates binding node and returns it. Then it may be used to fill with actual data.
+            The method creates binding node and returns it. Then it may be used to fill with actual
+            data.
         </para>
 
         <para>
-            <classname>Zend_Soap_Server</classname> implementation uses <code>$serviceName . 'Binding'</code> name for 'binding' element of WSDL document.
+            <classname>Zend_Soap_Server</classname> implementation uses
+            <code>$serviceName . 'Binding'</code> name for 'binding' element of WSDL document.
         </para>
     </sect2>
 
     <sect2 id="zend.soap.wsdl.add_binding_operation">
         <title>addBindingOperation() method</title>
+
         <para>
-            <methodname>addBindingOperation($binding, $name, $input = false, $output = false, $fault = false)</methodname> method adds
-            an operation to a binding element (/definitions/binding/operation) with the specified name.
+            <methodname>addBindingOperation($binding, $name, $input = false, $output = false, $fault
+                = false)</methodname> method adds an operation to a binding element
+            (/definitions/binding/operation) with the specified name.
         </para>
+
         <para>
-            It takes <code>XML_Tree_Node</code> object returned by <methodname>addBinding()</methodname> as an input
-            (<varname>$binding</varname> parameter) to add 'operation' element with input/output/false entries depending on
+            It takes <code>XML_Tree_Node</code> object returned by
+            <methodname>addBinding()</methodname> as an input (<varname>$binding</varname>
+            parameter) to add 'operation' element with input/output/false entries depending on
             specified parameters
         </para>
+
         <para>
-            <classname>Zend_Soap_Server</classname> implementation adds corresponding binding entry for each Web Service method with input and output
-            entries defining 'soap:body' element as
-            '&lt;soap:body use="encoded" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/&gt;
+            <classname>Zend_Soap_Server</classname> implementation adds corresponding binding entry
+            for each Web Service method with input and output entries defining 'soap:body' element
+            as '&lt;soap:body use="encoded"
+                encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/&gt;
         </para>
+
         <para>
             See <ulink url="http://www.w3.org/TR/wsdl#_bindings"/> for the details.
         </para>
@@ -179,14 +230,20 @@
 
     <sect2 id="zend.soap.wsdl.add_soap_binding">
         <title>addSoapBinding() method</title>
+
         <para>
-            <methodname>addSoapBinding($binding, $style = 'document', $transport = 'http://schemas.xmlsoap.org/soap/http')</methodname>
-            method adds <acronym>SOAP</acronym> binding ('soap:binding') entry to the binding element (which is already linked to some port type)
-            with the specified style and transport (Zend_Soap_Server implementation uses RPC style over <acronym>HTTP</acronym>).
+            <methodname>addSoapBinding($binding, $style = 'document', $transport =
+                'http://schemas.xmlsoap.org/soap/http')</methodname> method adds
+            <acronym>SOAP</acronym> binding ('soap:binding') entry to the binding element (which is
+            already linked to some port type) with the specified style and transport
+            (Zend_Soap_Server implementation uses RPC style over <acronym>HTTP</acronym>).
         </para>
+
         <para>
-            '/definitions/binding/soap:binding' element is used to signify that the binding is bound to the <acronym>SOAP</acronym> protocol format.
+            '/definitions/binding/soap:binding' element is used to signify that the binding is bound
+            to the <acronym>SOAP</acronym> protocol format.
         </para>
+
         <para>
             See <ulink url="http://www.w3.org/TR/wsdl#_bindings"/> for the details.
         </para>
@@ -194,20 +251,28 @@
 
     <sect2 id="zend.soap.wsdl.add_soap_operation">
         <title>addSoapOperation() method</title>
+
         <para>
-            <methodname>addSoapOperation($binding, $soap_action)</methodname>
-            method adds <acronym>SOAP</acronym> operation ('soap:operation') entry to the binding element with the specified action.
-            'style' attribute of the 'soap:operation' element is not used since programming model (RPC-oriented or document-oriented)
-            may be using <methodname>addSoapBinding()</methodname> method
+            <methodname>addSoapOperation($binding, $soap_action)</methodname> method adds
+            <acronym>SOAP</acronym> operation ('soap:operation') entry to the binding element with
+            the specified action. 'style' attribute of the 'soap:operation' element is not used
+            since programming model (RPC-oriented or document-oriented) may be using
+            <methodname>addSoapBinding()</methodname> method
         </para>
+
         <para>
-            'soapAction' attribute of '/definitions/binding/soap:operation' element specifies the value of the <acronym>SOAP</acronym>Action header
-            for this operation. This attribute is required for <acronym>SOAP</acronym> over <acronym>HTTP</acronym> and <emphasis>must not</emphasis> be
-            specified for other transports.
+            'soapAction' attribute of '/definitions/binding/soap:operation' element specifies the
+            value of the <acronym>SOAP</acronym>Action header for this operation. This attribute is
+            required for <acronym>SOAP</acronym> over <acronym>HTTP</acronym> and
+            <emphasis>must not</emphasis> be specified for other transports.
         </para>
+
         <para>
-            <classname>Zend_Soap_Server</classname> implementation uses <code>$serviceUri . '#' . $methodName</code> for <acronym>SOAP</acronym> operation action name.
+            <classname>Zend_Soap_Server</classname> implementation uses
+            <code>$serviceUri . '#' . $methodName</code> for <acronym>SOAP</acronym> operation
+            action name.
         </para>
+
         <para>
             See <ulink url="http://www.w3.org/TR/wsdl#_soap:operation"/> for the details.
         </para>
@@ -215,49 +280,71 @@
 
     <sect2 id="zend.soap.wsdl.add_service">
         <title>addService() method</title>
+
         <para>
-            <methodname>addService($name, $port_name, $binding, $location)</methodname> method adds '/definitions/service' element to
-            the WSDL document with the specified Wed Service name, port name, binding, and location.
+            <methodname>addService($name, $port_name, $binding, $location)</methodname> method adds
+            '/definitions/service' element to the WSDL document with the specified Wed Service name,
+            port name, binding, and location.
         </para>
+
         <para>
-            WSDL 1.1 allows to have several port types (sets of operations) per service. This ability is not used by
-            <classname>Zend_Soap_Server</classname> implementation and not supported by <classname>Zend_Soap_Wsdl</classname> class.
+            WSDL 1.1 allows to have several port types (sets of operations) per service. This
+            ability is not used by <classname>Zend_Soap_Server</classname> implementation and not
+            supported by <classname>Zend_Soap_Wsdl</classname> class.
         </para>
+
         <para>
             <classname>Zend_Soap_Server</classname> implementation uses:
+
             <itemizedlist>
                 <listitem>
                     <para>
                         <code>$name . 'Service'</code> as a Web Service name,
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
                         <code>$name . 'Port'</code> as a port type name,
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
                         <code>'tns:' . $name . 'Binding'</code>
-                            <footnote>
-                                <para>
-                                    <code>'tns:' namespace</code> is defined as script <acronym>URI</acronym>
-                                    (<code>'http://' .$_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']</code>).
-                                </para>
-                            </footnote>
-                            as binding name,
+
+                        <footnote>
+                            <para>
+                                <code>'tns:' namespace</code> is defined as script
+                                <acronym>URI</acronym> (<code>'http://' .$_SERVER['HTTP_HOST']
+                                    . $_SERVER['SCRIPT_NAME']</code>).
+                            </para>
+                        </footnote>
+
+                        as binding name,
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        script <acronym>URI</acronym><footnote><para><code>'http://' .$_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']</code></para></footnote>
+                        script <acronym>URI</acronym>
+
+                        <footnote>
+                            <para>
+                                <code>'http://' .$_SERVER['HTTP_HOST'] .
+                                    $_SERVER['SCRIPT_NAME']</code>
+                            </para>
+                        </footnote>
+
                         as a service URI for Web Service definition using classes.
                     </para>
                 </listitem>
             </itemizedlist>
-            where <varname>$name</varname> is a class name for the Web Service definition mode using class and
-            script name for the Web Service definition mode using set of functions.
+
+            where <varname>$name</varname> is a class name for the Web Service definition mode using
+            class and script name for the Web Service definition mode using set of functions.
         </para>
+
         <para>
             See <ulink url="http://www.w3.org/TR/wsdl#_services"/> for the details.
         </para>
@@ -265,48 +352,70 @@
 
     <sect2 id="zend.soap.wsdl.types">
         <title>Type mapping</title>
+
         <para>
-            <classname>Zend_Soap</classname> WSDL accessor implementation uses the following type mapping between <acronym>PHP</acronym> and <acronym>SOAP</acronym> types:
+            <classname>Zend_Soap</classname> WSDL accessor implementation uses the following type
+            mapping between <acronym>PHP</acronym> and <acronym>SOAP</acronym> types:
 
             <itemizedlist>
                 <listitem>
                     <para>PHP strings &lt;-&gt; <code>xsd:string</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP integers &lt;-&gt; <code>xsd:int</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP floats and doubles &lt;-&gt; <code>xsd:float</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP booleans &lt;-&gt; <code>xsd:boolean</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP arrays &lt;-&gt; <code>soap-enc:Array</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>PHP object &lt;-&gt; <code>xsd:struct</code>.</para>
                 </listitem>
+
                 <listitem>
                     <para>
-                        <acronym>PHP</acronym> class &lt;-&gt; based on complex type strategy (See: <xref linkend="zend.soap.wsdl.types.add_complex" />)
+                        <acronym>PHP</acronym> class &lt;-&gt; based on complex type strategy (See:
+                        <xref linkend="zend.soap.wsdl.types.add_complex" />)
+
                         <footnote>
                             <para>
-                                By default <classname>Zend_Soap_Wsdl</classname> will be created with the <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname>
-                                class as detection algorithm for complex types. The first parameter of the AutoDiscover constructor takes
-                                any complex type strategy implementing <classname>Zend_Soap_Wsdl_Strategy_Interface</classname> or a string with the name
-                                of the class. For backwards compatibility with <varname>$extractComplexType</varname> boolean variables are parsed
-                                the following way: If <constant>TRUE</constant>, <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname>, if <constant>FALSE</constant>
+                                By default <classname>Zend_Soap_Wsdl</classname> will be created
+                                with the
+                                <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname>
+                                class as detection algorithm for complex types. The first parameter
+                                of the AutoDiscover constructor takes any complex type strategy
+                                implementing
+                                <classname>Zend_Soap_Wsdl_Strategy_Interface</classname> or a string
+                                with the name of the class. For backwards compatibility with
+                                <varname>$extractComplexType</varname> boolean variables are parsed
+                                the following way: If <constant>TRUE</constant>,
+                                <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname>,
+                                if <constant>FALSE</constant>
                                 <classname>Zend_Soap_Wsdl_Strategy_AnyType</classname>.
                             </para>
                         </footnote>.
                     </para>
                 </listitem>
+
                 <listitem>
                     <para>PHP void &lt;-&gt; empty type.</para>
                 </listitem>
+
                 <listitem>
-                    <para>If type is not matched to any of these types by some reason, then <code>xsd:anyType</code> is used.</para>
+                    <para>
+                        If type is not matched to any of these types by some reason, then
+                        <code>xsd:anyType</code> is used.
+                    </para>
                 </listitem>
             </itemizedlist>
 
@@ -317,10 +426,12 @@
 
         <sect3 id="zend.soap.wsdl.types.retrieve">
             <title>Retrieving type information</title>
+
             <para>
-                <methodname>getType($type)</methodname> method may be used to get mapping for a specified PHP type:
+                <methodname>getType($type)</methodname> method may be used to get mapping for a
+                specified PHP type:
 
-            <programlisting language="php"><![CDATA[
+               <programlisting language="php"><![CDATA[
 ...
 $wsdl = new Zend_Soap_Wsdl('My_Web_Service', $myWebServiceUri);
 
@@ -339,93 +450,122 @@ $soapMyClassType = $wsdl->getType('MyClass');
 
         <sect3 id="zend.soap.wsdl.types.add_complex">
             <title>Adding complex type information</title>
+
             <para>
-                <methodname>addComplexType($type)</methodname> method is used to add complex types (PHP classes) to a WSDL document.
+                <methodname>addComplexType($type)</methodname> method is used to add complex types
+                (PHP classes) to a WSDL document.
             </para>
 
             <para>
-                It's automatically used by <methodname>getType()</methodname> method to add corresponding complex types
-                of method parameters or return types.
+                It's automatically used by <methodname>getType()</methodname> method to add
+                corresponding complex types of method parameters or return types.
             </para>
 
             <para>
-                Its detection and building algorithm is based on the currently
-                active detection strategy for complex types. You can set the detection strategy either by
-                specifying the class name as string or instance of a <classname>Zend_Soap_Wsdl_Strategy_Interface</classname>
-                implementation as the third parameter of the constructor or using the <methodname>setComplexTypeStrategy($strategy)</methodname>
-                function of <classname>Zend_Soap_Wsdl</classname>. The following detection strategies currently exist:
+                Its detection and building algorithm is based on the currently active detection
+                strategy for complex types. You can set the detection strategy either by specifying
+                the class name as string or instance of a
+                <classname>Zend_Soap_Wsdl_Strategy_Interface</classname> implementation as the third
+                parameter of the constructor or using the
+                <methodname>setComplexTypeStrategy($strategy)</methodname> function of
+                <classname>Zend_Soap_Wsdl</classname>. The following detection strategies currently
+                exist:
             </para>
 
             <itemizedlist>
                 <listitem>
-                    <para>Class <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname>: Enabled by default (when no
-                    third constructor parameter is set). Iterates over the public attributes of a class type and
-                    registers them as subtypes of the complex object type.</para>
+                    <para>
+                        Class <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname>:
+                        Enabled by default (when no third constructor parameter is set). Iterates
+                        over the public attributes of a class type and registers them as subtypes of
+                        the complex object type.
+                    </para>
                 </listitem>
+
                 <listitem>
-                    <para>Class <classname>Zend_Soap_Wsdl_Strategy_AnyType</classname>: Casts all complex types into the
-                    simple XSD type xsd:anyType. Be careful this shortcut for complex type detection can probably only
-                    be handled successfully by weakly typed languages such as <acronym>PHP</acronym>.
+                    <para>
+                        Class <classname>Zend_Soap_Wsdl_Strategy_AnyType</classname>: Casts all
+                        complex types into the simple XSD type xsd:anyType. Be careful this shortcut
+                        for complex type detection can probably only be handled successfully by
+                        weakly typed languages such as <acronym>PHP</acronym>.
                     </para>
                 </listitem>
+
                 <listitem>
-                    <para>Class <classname>Zend_Soap_Wsdl_Strategy_ArrayOfTypeSequence</classname>: This strategy allows
-                    to specify return parameters of the type: <code>int[]</code> or <code>string[]</code>. As of
-                    Zend Framework version 1.9 it can handle both simple <acronym>PHP</acronym> types such as int, string, boolean, float
-                    aswell as objects and arrays of objects.</para>
+                    <para>
+                        Class <classname>Zend_Soap_Wsdl_Strategy_ArrayOfTypeSequence</classname>:
+                        This strategy allows to specify return parameters of the type:
+                        <code>int[]</code> or <code>string[]</code>. As of Zend Framework version
+                        1.9 it can handle both simple <acronym>PHP</acronym> types such as int,
+                        string, boolean, float aswell as objects and arrays of objects.
+                    </para>
                 </listitem>
+
                 <listitem>
-                    <para>Class <classname>Zend_Soap_Wsdl_Strategy_ArrayOfTypeComplex</classname>: This strategy allows
-                    to detect very complex arrays of objects. Objects types are detected based on the
-                    <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname> and an array is wrapped
-                    around that definition.</para>
+                    <para>
+                        Class <classname>Zend_Soap_Wsdl_Strategy_ArrayOfTypeComplex</classname>:
+                        This strategy allows to detect very complex arrays of objects. Objects types
+                        are detected based on the
+                        <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname> and an
+                        array is wrapped around that definition.
+                    </para>
                 </listitem>
+
                 <listitem>
-                    <para>Class <classname>Zend_Soap_Wsdl_Strategy_Composite</classname>: This strategy can
-                    combine all strategies by connecting <acronym>PHP</acronym> Complex types (Classnames) to the desired strategy
-                    via the <methodname>connectTypeToStrategy($type, $strategy)</methodname> method. A complete typemap can be
-                    given to the constructor as an array with <varname>$type</varname> -> <varname>$strategy</varname> pairs.
-                    The second parameter specifies the default strategy that will be used if an unknown type is
-                    requested for adding. This parameter defaults to the <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname>
-                    strategy.</para>
+                    <para>
+                        Class <classname>Zend_Soap_Wsdl_Strategy_Composite</classname>: This
+                        strategy can combine all strategies by connecting <acronym>PHP</acronym>
+                        Complex types (Classnames) to the desired strategy via the
+                        <methodname>connectTypeToStrategy($type, $strategy)</methodname> method. A
+                        complete typemap can be given to the constructor as an array with
+                        <varname>$type</varname> -> <varname>$strategy</varname> pairs. The second
+                        parameter specifies the default strategy that will be used if an unknown
+                        type is requested for adding. This parameter defaults to the
+                        <classname>Zend_Soap_Wsdl_Strategy_DefaultComplexType</classname> strategy.
+                    </para>
                 </listitem>
             </itemizedlist>
 
             <para>
-                <methodname>addComplexType()</methodname> method creates '/definitions/types/xsd:schema/xsd:complexType' element for
+                <methodname>addComplexType()</methodname> method creates
+                '/definitions/types/xsd:schema/xsd:complexType' element for
                 each described complex type with name of the specified <acronym>PHP</acronym> class.
             </para>
 
             <para>
-                Class property <emphasis>MUST</emphasis> have docblock section with the described <acronym>PHP</acronym> type to have property
-                included into WSDL description.
+                Class property <emphasis>MUST</emphasis> have docblock section with the described
+                <acronym>PHP</acronym> type to have property included into WSDL description.
             </para>
 
             <para>
-                <methodname>addComplexType()</methodname> checks if type is already described within types section of the WSDL document.
+                <methodname>addComplexType()</methodname> checks if type is already described within
+                types section of the WSDL document.
             </para>
 
             <para>
-                It prevents duplications if this method is called two or more times and recursion in the types definition
-                section.
+                It prevents duplications if this method is called two or more times and recursion in
+                the types definition section.
             </para>
 
             <para>
                 See <ulink url="http://www.w3.org/TR/wsdl#_types"/> for the details.
             </para>
-
         </sect3>
     </sect2>
 
     <sect2 id="zend.soap.wsdl.add_documentation">
         <title>addDocumentation() method</title>
+
         <para>
-            <methodname>addDocumentation($input_node, $documentation)</methodname> method adds human readable documentation using
-            optional 'wsdl:document' element.
+            <methodname>addDocumentation($input_node, $documentation)</methodname> method adds human
+            readable documentation using optional 'wsdl:document' element.
         </para>
+
         <para>
-            '/definitions/binding/soap:binding' element is used to signify that the binding is bound to the <acronym>SOAP</acronym> protocol format.
+            '/definitions/binding/soap:binding' element is used to signify that the binding is bound
+            to the <acronym>SOAP</acronym> protocol format.
         </para>
+
         <para>
             See <ulink url="http://www.w3.org/TR/wsdl#_documentation"/> for the details.
         </para>
@@ -433,10 +573,11 @@ $soapMyClassType = $wsdl->getType('MyClass');
 
     <sect2 id="zend.soap.wsdl.retrieve">
         <title>Get finalized WSDL document</title>
+
         <para>
-            <methodname>toXML()</methodname>, <methodname>toDomDocument()</methodname> and <methodname>dump($filename = false)</methodname> methods may be used to get
-            WSDL document as an <acronym>XML</acronym>, DOM structure or a file.
+            <methodname>toXML()</methodname>, <methodname>toDomDocument()</methodname> and
+            <methodname>dump($filename = false)</methodname> methods may be used to get WSDL
+            document as an <acronym>XML</acronym>, DOM structure or a file.
         </para>
     </sect2>
-
 </sect1>

documentation/manual/en/module_specs/Zend_Tag_Cloud.xml

@@ -83,6 +83,7 @@
             This example illustrates a basic example of how to create a tag
             cloud, add multiple tags to it and finally render it.
         </para>
+
         <programlisting language="php"><![CDATA[
 // Create the cloud and assign static tags to it
 $cloud = new Zend_Tag_Cloud(array(