Przeglądaj źródła

[DOCUMENTATION] English:

- manual fixes (only line length)

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@15848 44c647ce-9c0f-0410-b52a-842ac1e357ba
thomas 16 lat temu
rodzic
commit
36878999bc

+ 60 - 48
documentation/manual/en/module_specs/Zend_Cache-Backends.xml

@@ -3,8 +3,8 @@
 <sect1 id="zend.cache.backends">
     <title>Zend_Cache Backends</title>
     <para>
-        There are two kinds of backends: standard ones and extended ones. Of course, extended backends
-        offer more features.
+        There are two kinds of backends: standard ones and extended ones. Of course, extended
+        backends offer more features.
     </para>
     <sect2 id="zend.cache.backends.file">
         <title>Zend_Cache_Backend_File</title>
@@ -59,9 +59,9 @@
                           <entry><type>String</type></entry>
                           <entry>'crc32'</entry>
                           <entry>
-                            Type of read control (only if read control is enabled). Available values are :
-                            'md5' (best but slowest), 'crc32' (lightly less safe but faster, better choice),
-                            'adler32' (new choice, faster than crc32),
+                            Type of read control (only if read control is enabled). Available values
+                            are : 'md5' (best but slowest), 'crc32' (lightly less safe but faster,
+                            better choice), 'adler32' (new choice, faster than crc32),
                             'strlen' for a length only test (fastest).
                         </entry>
                       </row>
@@ -108,8 +108,8 @@
                           <entry><type>Integer</type></entry>
                           <entry>100</entry>
                           <entry>
-                              internal max size for the metadatas array (don't change this value unless you
-                              know what you are doing)
+                              internal max size for the metadatas array (don't change this value
+                              unless you know what you are doing)
                           </entry>
                       </row>
                   </tbody>
@@ -149,12 +149,12 @@
                           <entry><type>Integer</type></entry>
                           <entry>10</entry>
                           <entry>
-                              Disable / Tune the automatic vacuum process.
-                              The automatic vacuum process defragment the database file (and make it smaller)
-                              when a clean() or delete() is called :
-                              0 means no automatic vacuum ;
-                              1 means systematic vacuum (when delete() or clean() methods are called) ;
-                              x (integer) > 1 => automatic vacuum randomly 1 times on x clean() or delete().
+                              Disable / Tune the automatic vacuum process. The automatic vacuum
+                              process defragment the database file (and make it smaller) when a
+                              clean() or delete() is called: 0 means no automatic vacuum ;
+                              1 means systematic vacuum (when delete() or clean() methods are
+                              called) ; x (integer) > 1 => automatic vacuum randomly 1 times on x
+                              clean() or delete().
                           </entry>
                       </row>
                   </tbody>
@@ -164,9 +164,11 @@
     <sect2 id="zend.cache.backends.memcached">
         <title>Zend_Cache_Backend_Memcached</title>
         <para>
-            This (extended) backends stores cache records into a memcached server. <ulink url="http://www.danga.com/memcached/">memcached</ulink>
-            is a high-performance, distributed memory object caching system. To use this backend,
-            you need a memcached daemon and <ulink url="http://pecl.php.net/package/memcache">the memcache PECL extension</ulink>.
+            This (extended) backends stores cache records into a memcached server. <ulink
+                url="http://www.danga.com/memcached/">memcached</ulink> is a high-performance,
+            distributed memory object caching system. To use this backend, you need a memcached
+            daemon and <ulink url="http://pecl.php.net/package/memcache">the memcache PECL
+                extension</ulink>.
         </para>
         <para>
             Be careful : with this backend, "tags" are not supported for the moment as
@@ -191,19 +193,21 @@
                           <entry><emphasis>servers</emphasis></entry>
                           <entry><type>Array</type></entry>
                           <entry>
-                              array(array('host' => 'localhost', 'port' => 11211, 'persistent' => true, 'weight' => 1,
-                              'timeout' => 5, 'retry_interval' => 15, 'status' => true, 'failure_callback' => '' ))
+                              array(array('host' => 'localhost', 'port' => 11211, 'persistent' =>
+                                  true, 'weight' => 1, 'timeout' => 5, 'retry_interval' => 15,
+                                  'status' => true, 'failure_callback' => '' ))
                           </entry>
                           <entry>
-                              An array of memcached servers ; each memcached server is described by an associative array :
-                              'host' => (string) : the name of the memcached server,
-                              'port' => (int) : the port of the memcached server,
-                              'persistent' => (bool) : use or not persistent connections to this memcached server
-                              'weight' => (int) :the weight of the memcached server,
-                              'timeout' => (int) :the time out of the memcached server,
+                              An array of memcached servers ; each memcached server is described by
+                              an associative array : 'host' => (string) : the name of the memcached
+                              server, 'port' => (int) : the port of the memcached server,
+                              'persistent' => (bool) : use or not persistent connections to this
+                              memcached server 'weight' => (int) :the weight of the memcached
+                              server, 'timeout' => (int) :the time out of the memcached server,
                               'retry_interval' => (int) :the retry interval of the memcached server,
                               'status' => (bool) :the status of the memcached server,
-                              'failure_callback' => (callback) : the failure_callback of the memcached server
+                              'failure_callback' => (callback) : the failure_callback of the
+                              memcached server
                           </entry>
                       </row>
                       <row>
@@ -219,7 +223,8 @@
                           <entry><type>Boolean</type></entry>
                           <entry><constant>FALSE</constant></entry>
                           <entry>
-                             true if you want to use this compatibility mode with old memcache servers/extensions
+                             true if you want to use this compatibility mode with old memcache
+                             servers/extensions
                           </entry>
                       </row>
                   </tbody>
@@ -230,8 +235,8 @@
         <title>Zend_Cache_Backend_Apc</title>
         <para>
             This (extended) backends stores cache records in shared memory through
-            the <ulink url="http://pecl.php.net/package/APC">APC</ulink> (Alternative PHP Cache) extension
-            (which is of course need for using this backend).
+            the <ulink url="http://pecl.php.net/package/APC">APC</ulink> (Alternative PHP Cache)
+            extension (which is of course need for using this backend).
         </para>
         <para>
             Be careful : with this backend, "tags" are not supported for the moment as
@@ -280,7 +285,8 @@
                           <entry><type>String</type></entry>
                           <entry><constant>NULL</constant></entry>
                           <entry>
-                              xcache.admin.pass (in clear form, not MD5), necessary for the clean() method
+                              xcache.admin.pass (in clear form, not MD5), necessary for the clean()
+                              method
                           </entry>
                       </row>
                   </tbody>
@@ -290,10 +296,13 @@
     <sect2 id="zend.cache.backends.platform">
         <title>Zend_Cache_Backend_ZendPlatform</title>
         <para>
-            This backend uses content caching API of the <ulink url="http://www.zend.com/products/platform">Zend Platform</ulink> product. Naturally, to use this backend you need to have Zend Platform installed.
+            This backend uses content caching API of the <ulink
+                url="http://www.zend.com/products/platform">Zend Platform</ulink> product.
+            Naturally, to use this backend you need to have Zend Platform installed.
         </para>
         <para>
-    This backend supports tags, but does not support <constant>CLEANING_MODE_NOT_MATCHING_TAG</constant> cleaning mode.
+            This backend supports tags, but does not support
+            <constant>CLEANING_MODE_NOT_MATCHING_TAG</constant> cleaning mode.
         </para>
         <para>
             Specify this backend using a word separator -- '-', '.', ' ', or '_'
@@ -310,12 +319,13 @@ $cache = Zend_Cache::factory('Core', 'Zend Platform');
     <sect2 id="zend.cache.backends.twolevels">
         <title>Zend_Cache_Backend_TwoLevels</title>
         <para>
-            This (extend) backend is an hybrid one. It stores cache records in two other backends : a fast
-            one (but limited) like Apc, Memcache... and a "slow" one like File, Sqlite...
+            This (extend) backend is an hybrid one. It stores cache records in two other backends :
+            a fast one (but limited) like Apc, Memcache... and a "slow" one like File, Sqlite...
         </para>
         <para>
-            This backend will use the priority parameter (given at the frontend level when storing a record)
-            and the remaining space in the fast backend to optimize the usage of these two backends.
+            This backend will use the priority parameter (given at the frontend level when storing a
+            record) and the remaining space in the fast backend to optimize the usage of these two
+            backends.
             FIXME
         </para>
         <para>
@@ -370,9 +380,9 @@ $cache = Zend_Cache::factory('Core', 'Zend Platform');
                           <entry><type>Boolean</type></entry>
                           <entry><constant>FALSE</constant></entry>
                           <entry>
-                              if true, the slow_backend argument is used as a complete class name ; if false,
-                              the frontend argument is used as the end of "Zend_Cache_Backend_[...]"
-                              class name
+                              if true, the slow_backend argument is used as a complete class name ;
+                              if false, the frontend argument is used as the end of
+                              "Zend_Cache_Backend_[...]" class name
                           </entry>
                       </row>
                       <row>
@@ -380,9 +390,9 @@ $cache = Zend_Cache::factory('Core', 'Zend Platform');
                           <entry><type>Boolean</type></entry>
                           <entry><constant>FALSE</constant></entry>
                           <entry>
-                              if true, the fast_backend argument is used as a complete class name ; if false,
-                              the frontend argument is used as the end of "Zend_Cache_Backend_[...]"
-                              class name
+                              if true, the fast_backend argument is used as a complete class name ;
+                              if false, the frontend argument is used as the end of
+                              "Zend_Cache_Backend_[...]" class name
                           </entry>
                       </row>
                       <row>
@@ -417,8 +427,8 @@ $cache = Zend_Cache::factory('Core', 'Zend Platform');
                           <entry>10</entry>
                           <entry>
                               disable / tune the computation of the fast backend filling percentage
-                              (when saving a record into cache, computation of the fast backend filling percentage
-                              randomly 1 times on x cache writes)
+                              (when saving a record into cache, computation of the fast backend
+                              filling percentage randomly 1 times on x cache writes)
                           </entry>
                       </row>
                   </tbody>
@@ -428,15 +438,17 @@ $cache = Zend_Cache::factory('Core', 'Zend Platform');
     <sect2 id="zend.cache.backends.zendserver">
         <title>Zend_Cache_Backend_ZendServer_Disk and Zend_Cache_Backend_ZendServer_ShMem</title>
         <para>
-            These backends store cache records using
-            <ulink url="http://www.zend.com/en/products/server/downloads-all?zfs=zf_download">Zend Server</ulink> caching functionality.
+            These backends store cache records using <ulink
+                url="http://www.zend.com/en/products/server/downloads-all?zfs=zf_download">Zend
+                Server</ulink> caching functionality.
         </para>
         <para>
-             Be careful: with these backends, "tags" are not supported for the moment as the "doNotTestCacheValidity=true" argument.
+             Be careful: with these backends, "tags" are not supported for the moment as the
+             "doNotTestCacheValidity=true" argument.
         </para>
         <para>
-             These backend work only withing Zend Server environment for pages requested through HTTP(S) and
-             don't work for command line script execution
+             These backend work only withing Zend Server environment for pages requested through
+             HTTP(S) and don't work for command line script execution
         </para>
         <para>
             There is no option for this backend.

+ 121 - 92
documentation/manual/en/module_specs/Zend_Cache-Frontends.xml

@@ -12,9 +12,9 @@
                 of the module. It is a generic cache frontend and is extended by other classes.
             </para>
             <note><para>
-                All frontends inherit from <classname>Zend_Cache_Core</classname> so that its methods and options
-                (described below) would also be available in other frontends, therefore they won't be
-                documented there.
+                All frontends inherit from <classname>Zend_Cache_Core</classname> so that its
+                methods and options (described below) would also be available in other frontends,
+                therefore they won't be documented there.
             </para></note>
         </sect3>
         <sect3 id="zend.cache.frontends.core.options">
@@ -49,10 +49,11 @@
                               <entry><constant>NULL</constant></entry>
                               <entry>
                                 A prefix for all cache ids, if set to <constant>null</constant>, no
-                                cache id prefix will be used. The cache id prefix essentially creates
-                                a namespace in the cache, allowing multiple applications or websites
-                                to use a shared cache. Each application or website can use a different
-                                cache id prefix so specific cache ids can be used more than once.
+                                cache id prefix will be used. The cache id prefix essentially
+                                creates a namespace in the cache, allowing multiple applications or
+                                websites to use a shared cache. Each application or website can use
+                                a different cache id prefix so specific cache ids can be used more
+                                than once.
                               </entry>
                           </row>
                           <row>
@@ -60,8 +61,8 @@
                               <entry><type>Integer</type></entry>
                               <entry>3600</entry>
                               <entry>
-                                cache lifetime (in seconds), if set to <constant>NULL</constant>, the
-                                cache is valid forever.
+                                cache lifetime (in seconds), if set to <constant>NULL</constant>,
+                                the cache is valid forever.
                               </entry>
                           </row>
                           <row>
@@ -69,8 +70,8 @@
                               <entry><type>Boolean</type></entry>
                               <entry><constant>FALSE</constant></entry>
                               <entry>
-                                if set to true, logging through <classname>Zend_Log</classname> is activated
-                                (but the system is slower)
+                                if set to true, logging through <classname>Zend_Log</classname> is
+                                activated (but the system is slower)
                               </entry>
                           </row>
                           <row>
@@ -78,8 +79,8 @@
                               <entry><type>Boolean</type></entry>
                               <entry><constant>TRUE</constant></entry>
                               <entry>
-                                Enable / disable write control (the cache is read
-                                just after writing to detect corrupt entries), enabling write_control
+                                Enable / disable write control (the cache is read just
+                                after writing to detect corrupt entries), enabling write_control
                                 will lightly slow the cache writing but not the cache reading (it
                                 can detect some corrupt cache files but it's not a perfect control)
                               </entry>
@@ -89,8 +90,8 @@
                               <entry><type>Boolean</type></entry>
                               <entry><constant>FALSE</constant></entry>
                               <entry>
-                                Enable / disable automatic serialization, it can be used to save directly datas
-                                which aren't strings (but it's slower)
+                                Enable / disable automatic serialization, it can be used to save
+                                directly datas which aren't strings (but it's slower)
                               </entry>
                           </row>
                           <row>
@@ -99,8 +100,9 @@
                               <entry>10</entry>
                               <entry>
                                 Disable / Tune the automatic cleaning process (garbage collector):
-                                0 means no automatic cache cleaning, 1 means systematic cache cleaning
-                                and x &gt; 1 means automatic random cleaning 1 times in x write operations.
+                                0 means no automatic cache cleaning, 1 means systematic cache
+                                cleaning and x &gt; 1 means automatic random cleaning 1 times in x
+                                write operations.
                               </entry>
                           </row>
                           <row>
@@ -108,8 +110,8 @@
                               <entry><type>Boolean</type></entry>
                               <entry><constant>FALSE</constant></entry>
                               <entry>
-                                if set to true, the core will set the ignore_user_abort PHP flag inside the
-                                save() method to avoid cache corruptions in some cases
+                                if set to true, the core will set the ignore_user_abort PHP flag
+                                inside the save() method to avoid cache corruptions in some cases
                               </entry>
                           </row>
                       </tbody>
@@ -123,8 +125,8 @@
                 An example is given in the manual at the very beginning.
             </para>
             <para>
-                If you store only strings into cache (because with "automatic_serialization" option, it's possible
-                to store some booleans), you can use a more compact construction like:
+                If you store only strings into cache (because with "automatic_serialization" option,
+                it's possible to store some booleans), you can use a more compact construction like:
             </para>
             <programlisting language="php"><![CDATA[
 // we assume you already have $cache
@@ -185,9 +187,9 @@ if (!($data = $cache->load($id2))) {
 echo($data);
 ]]></programlisting>
             <para>
-                If you want to cache special values (boolean with "automatic_serialization" option) or empty
-                strings you can't use the compact construction given above. You have to test formally the
-                cache record.
+                If you want to cache special values (boolean with "automatic_serialization" option)
+                or empty strings you can't use the compact construction given above. You have to
+                test formally the cache record.
             </para>
             <programlisting language="php"><![CDATA[
 // the compact construction
@@ -233,9 +235,9 @@ if (!($cache->test($id))) {
         <sect3 id="zend.cache.frontends.output.introduction">
             <title>Introduction</title>
             <para>
-                <classname>Zend_Cache_Frontend_Output</classname> is an output-capturing frontend. It utilizes
-                output buffering in PHP to capture everything between its <methodname>start()</methodname> and
-                <methodname>end()</methodname> methods.
+                <classname>Zend_Cache_Frontend_Output</classname> is an output-capturing frontend.
+                It utilizes output buffering in PHP to capture everything between its
+                <methodname>start()</methodname> and <methodname>end()</methodname> methods.
             </para>
         </sect3>
         <sect3 id="zend.cache.frontends.output.options">
@@ -249,7 +251,8 @@ if (!($cache->test($id))) {
         <sect3 id="zend.cache.frontends.output.examples">
             <title>Examples</title>
             <para>
-                An example is given in the manual at the very beginning. Here it is with minor changes:
+                An example is given in the manual at the very beginning. Here it is with minor
+                changes:
             </para>
             <programlisting language="php"><![CDATA[
 // if it is a cache miss, output buffering is triggered
@@ -266,8 +269,8 @@ if (!($cache->start('mypage'))) {
 echo 'This is never cached ('.time().').';
 ]]></programlisting>
             <para>
-                Using this form it is fairly easy to set up output caching in your already working project
-                with little or no code refactoring.
+                Using this form it is fairly easy to set up output caching in your already working
+                project with little or no code refactoring.
             </para>
         </sect3>
     </sect2>
@@ -277,9 +280,9 @@ echo 'This is never cached ('.time().').';
         <sect3 id="zend.cache.frontends.function.introduction">
             <title>Introduction</title>
             <para>
-                <classname>Zend_Cache_Frontend_Function</classname> caches the results of function calls. It has
-                a single main method named <methodname>call()</methodname> which takes a function name and parameters
-                for the call in an array.
+                <classname>Zend_Cache_Frontend_Function</classname> caches the results of function
+                calls. It has a single main method named <methodname>call()</methodname> which takes
+                a function name and parameters for the call in an array.
             </para>
         </sect3>
         <sect3 id="zend.cache.frontends.function.options">
@@ -345,9 +348,11 @@ $cache->call('veryExpensiveFunc', $params);
             </para>
             <note><para>
                 You can pass any built in or user defined function with the exception of
-                <methodname>array()</methodname>, <methodname>echo()</methodname>, <methodname>empty()</methodname>, <methodname>eval()</methodname>,
-                <methodname>exit()</methodname>, <methodname>isset()</methodname>, <methodname>list()</methodname>, <methodname>print()</methodname>
-                and <methodname>unset()</methodname>.
+                <methodname>array()</methodname>, <methodname>echo()</methodname>,
+                <methodname>empty()</methodname>, <methodname>eval()</methodname>,
+                <methodname>exit()</methodname>, <methodname>isset()</methodname>,
+                <methodname>list()</methodname>, <methodname>print()</methodname> and
+                <methodname>unset()</methodname>.
             </para></note>
         </sect3>
     </sect2>
@@ -357,8 +362,9 @@ $cache->call('veryExpensiveFunc', $params);
         <sect3 id="zend.cache.frontends.class.introduction">
             <title>Introduction</title>
             <para>
-                <classname>Zend_Cache_Frontend_Class</classname> is different from <classname>Zend_Cache_Frontend_Function</classname>
-                because it allows caching of object and static method calls.
+                <classname>Zend_Cache_Frontend_Class</classname> is different from
+                <classname>Zend_Cache_Frontend_Function</classname> because it allows caching of
+                object and static method calls.
             </para>
         </sect3>
         <sect3 id="zend.cache.frontends.class.options">
@@ -380,8 +386,9 @@ $cache->call('veryExpensiveFunc', $params);
                               <entry><type>Mixed</type></entry>
                               <entry></entry>
                               <entry>
-                                  if set to a class name, we will cache an abstract class and will use
-                                  only static calls; if set to an object, we will cache this object methods
+                                  if set to a class name, we will cache an abstract class and will
+                                  use only static calls; if set to an object, we will cache this
+                                  object methods
                               </entry>
                          </row>
                          <row>
@@ -479,8 +486,8 @@ $result = $cache->foobar2('1', '2');
             <para>
                 For instance, you have an XML configuration file which is parsed by a function
                 which returns a "config object" (like with <classname>Zend_Config</classname>). With
-                <classname>Zend_Cache_Frontend_File</classname>, you can store the "config object" into
-                cache (to avoid the parsing of the XML config file at each time) but with a
+                <classname>Zend_Cache_Frontend_File</classname>, you can store the "config object"
+                into cache (to avoid the parsing of the XML config file at each time) but with a
                 sort of strong dependency on the "master file". So, if the XML config file
                 is modified, the cache is immediately invalidated.
             </para>
@@ -518,11 +525,16 @@ $result = $cache->foobar2('1', '2');
                          <row>
                               <entry><emphasis>master_files_mode</emphasis></entry>
                               <entry><type>String</type></entry>
-                              <entry><classname>Zend_Cache_Frontend_File::MODE_OR</classname></entry>
                               <entry>
-                                  <classname>Zend_Cache_Frontend_File::MODE_AND</classname> or <classname>Zend_Cache_Frontend_File::MODE_OR</classname> ;
-                                  if <constant>MODE_AND</constant>, then all master files have to be touched to get a cache invalidation
-                                  if <constant>MODE_OR</constant>, then a single touched master file is enough to get a cache invalidation
+                                  <classname>Zend_Cache_Frontend_File::MODE_OR</classname>
+                              </entry>
+                              <entry>
+                                  <classname>Zend_Cache_Frontend_File::MODE_AND</classname> or
+                                  <classname>Zend_Cache_Frontend_File::MODE_OR</classname> ; if
+                                  <constant>MODE_AND</constant>, then all master files have to be
+                                  touched to get a cache invalidation if
+                                  <constant>MODE_OR</constant>, then a single touched master file is
+                                  enough to get a cache invalidation
                               </entry>
                          </row>
                          <row>
@@ -530,7 +542,8 @@ $result = $cache->foobar2('1', '2');
                               <entry><type>Boolean</type></entry>
                               <entry><constant>FALSE</constant></entry>
                               <entry>
-                                  if true, missing master files are ignored silently (an exception is raised else)
+                                  if true, missing master files are ignored silently (an exception
+                                  is raised else)
                               </entry>
                          </row>
                       </tbody>
@@ -540,8 +553,8 @@ $result = $cache->foobar2('1', '2');
         <sect3 id="zend.cache.frontends.file.examples">
             <title>Examples</title>
             <para>
-                Use of this frontend is the same than of <classname>Zend_Cache_Core</classname>. There
-                is no need of a specific example - the only thing to do is to
+                Use of this frontend is the same than of <classname>Zend_Cache_Core</classname>.
+                There is no need of a specific example - the only thing to do is to
                 define the <emphasis>master_file</emphasis> when using the factory.
             </para>
         </sect3>
@@ -552,15 +565,17 @@ $result = $cache->foobar2('1', '2');
         <sect3 id="zend.cache.frontends.page.introduction">
             <title>Introduction</title>
             <para>
-                <classname>Zend_Cache_Frontend_Page</classname> is like <classname>Zend_Cache_Frontend_Output</classname>
-                but designed for a complete page. It's impossible to use <classname>Zend_Cache_Frontend_Page</classname>
-                for caching only a single block.
+                <classname>Zend_Cache_Frontend_Page</classname> is like
+                <classname>Zend_Cache_Frontend_Output</classname> but designed for a complete page.
+                It's impossible to use <classname>Zend_Cache_Frontend_Page</classname> for caching
+                only a single block.
             </para>
             <para>
                 On the other hand, the "cache id" is calculated automatically with
                 <varname>$_SERVER['REQUEST_URI']</varname> and (depending on options)
-                <varname>$_GET</varname>, <varname>$_POST</varname>, <varname>$_SESSION</varname>, <varname>$_COOKIE</varname>, <varname>$_FILES</varname>.
-                More over, you have only one method to call (<methodname>start()</methodname>) because the
+                <varname>$_GET</varname>, <varname>$_POST</varname>, <varname>$_SESSION</varname>,
+                <varname>$_COOKIE</varname>, <varname>$_FILES</varname>. More over, you have only
+                one method to call (<methodname>start()</methodname>) because the
                 <methodname>end()</methodname> call is fully automatic when the page is ended.
             </para>
             <para>
@@ -608,90 +623,101 @@ $result = $cache->foobar2('1', '2');
                                   <itemizedlist>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, true by default) cache</emphasis> :
-                                              cache is on if true
+                                              <emphasis>(boolean, true by default) cache</emphasis>
+                                              : cache is on if true
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, false by default) cache_with_get_variables</emphasis> :
-                                              if true, cache is still on even if there are some variables in
+                                              <emphasis>(boolean, false by default)
+                                                  cache_with_get_variables</emphasis> : if true,
+                                              cache is still on even if there are some variables in
                                               <varname>$_GET</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, false by default) cache_with_post_variables</emphasis> :
-                                              if true, cache is still on even if there are some variables in
+                                              <emphasis>(boolean, false by default)
+                                                  cache_with_post_variables</emphasis> : if true,
+                                              cache is still on even if there are some variables in
                                               <varname>$_POST</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, false by default) cache_with_session_variables</emphasis> :
-                                              if true, cache is still on even if there are some variables in
+                                              <emphasis>(boolean, false by default)
+                                                  cache_with_session_variables</emphasis> : if true,
+                                              cache is still on even if there are some variables in
                                               <varname>$_SESSION</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, false by default) cache_with_files_variables</emphasis> :
-                                              if true, cache is still on even if there are some variables in
+                                              <emphasis>(boolean, false by default)
+                                                  cache_with_files_variables</emphasis> : if true,
+                                              cache is still on even if there are some variables in
                                               <varname>$_FILES</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, false by default) cache_with_cookie_variables</emphasis> :
-                                              if true, cache is still on even if there are some variables in
+                                              <emphasis>(boolean, false by default)
+                                                  cache_with_cookie_variables</emphasis> : if true,
+                                              cache is still on even if there are some variables in
                                               <varname>$_COOKIE</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, true by default) make_id_with_get_variables</emphasis> :
-                                              if true, the cache id will be dependent of the content of the
+                                              <emphasis>(boolean, true by default)
+                                                   make_id_with_get_variables</emphasis> : if true,
+                                              the cache id will be dependent of the content of the
                                               <varname>$_GET</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, true by default) make_id_with_post_variables</emphasis> :
-                                              if true, the cache id will be dependent of the content of the
+                                              <emphasis>(boolean, true by default)
+                                                  make_id_with_post_variables</emphasis> : if true,
+                                              the cache id will be dependent of the content of the
                                               <varname>$_POST</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, true by default) make_id_with_session_variables</emphasis> :
-                                              if true, the cache id will be dependent of the content of the
-                                              <varname>$_SESSION</varname> array
+                                              <emphasis>(boolean, true by default)
+                                                  make_id_with_session_variables</emphasis> : if
+                                              true, the cache id will be dependent of the content of
+                                              the <varname>$_SESSION</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, true by default) make_id_with_files_variables</emphasis> :
-                                              if true, the cache id will be dependent of the content of the
+                                              <emphasis>(boolean, true by default)
+                                                  make_id_with_files_variables</emphasis> : if true,
+                                              the cache id will be dependent of the content of the
                                               <varname>$_FILES</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(boolean, true by default) make_id_with_cookie_variables</emphasis> :
-                                              if true, the cache id will be dependent of the content of the
-                                              <varname>$_COOKIE</varname> array
+                                              <emphasis>(boolean, true by default)
+                                                  make_id_with_cookie_variables</emphasis> : if
+                                              true, the cache id will be dependent of the content of
+                                              the <varname>$_COOKIE</varname> array
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(int, false by default) specific_lifetime</emphasis> :
-                                              if not false, the given lifetime will be used for the choosen regexp
+                                              <emphasis>(int, false by default)
+                                                  specific_lifetime</emphasis> : if not false, the
+                                              given lifetime will be used for the choosen regexp
                                           </para>
                                       </listitem>
                                       <listitem>
                                           <para>
-                                              <emphasis>(array, array() by default) tags</emphasis> :
-                                              tags for the cache record
+                                              <emphasis>(array, array() by default) tags</emphasis>
+                                              : tags for the cache record
                                           </para>
                                       </listitem>
                                       <listitem>
@@ -708,10 +734,12 @@ $result = $cache->foobar2('1', '2');
                               <entry><type>Array</type></entry>
                               <entry><methodname>array()</methodname></entry>
                               <entry>
-                                    an associative array to set options only for some REQUEST_URI, keys are (PCRE) regexps, values are
-                                    associative arrays with specific options to set if the regexp matchs on $_SERVER['REQUEST_URI']
-                                  (see default_options for the list of available options) ; if several regexps match the $_SERVER['REQUEST_URI'],
-                                  only the last one will be used
+                                  an associative array to set options only for some REQUEST_URI,
+                                  keys are (PCRE) regexps, values are associative arrays with
+                                  specific options to set if the regexp matchs on
+                                  $_SERVER['REQUEST_URI'] (see default_options for the list of
+                                  available options) ; if several regexps match the
+                                  $_SERVER['REQUEST_URI'], only the last one will be used
                               </entry>
                          </row>
                          <row>
@@ -719,8 +747,9 @@ $result = $cache->foobar2('1', '2');
                               <entry><type>Array</type></entry>
                               <entry><methodname>array()</methodname></entry>
                               <entry>
-                                   an array of strings corresponding to some HTTP headers name. Listed headers
-                                   will be stored with cache datas and "replayed" when the cache is hit
+                                   an array of strings corresponding to some HTTP headers name.
+                                   Listed headers will be stored with cache datas and "replayed"
+                                   when the cache is hit
                               </entry>
                          </row>
                       </tbody>
@@ -742,8 +771,8 @@ $cache->start();
 // rest of the page ...
 ]]></programlisting>
             <para>
-                a more complex example which shows a way to get a centralized cache management in a bootstrap file
-                (for using with <classname>Zend_Controller</classname> for example)
+                a more complex example which shows a way to get a centralized cache management in a
+                bootstrap file (for using with <classname>Zend_Controller</classname> for example)
             </para>
             <programlisting language="php"><![CDATA[
 /*
@@ -799,8 +828,8 @@ $cache->start();
         <sect3 id="zend.cache.frontends.page.cancel">
             <title>The Specific Cancel Method</title>
             <para>
-                Because of design issues, in some cases (for example when using non HTTP/200 return codes),
-                you could need to cancel the current cache process. So we introduce for this
+                Because of design issues, in some cases (for example when using non HTTP/200 return
+                codes), you could need to cancel the current cache process. So we introduce for this
                 particular frontend, the cancel() method.
             </para>
             <programlisting language="php"><![CDATA[

+ 33 - 28
documentation/manual/en/module_specs/Zend_Cache-Introduction.xml

@@ -6,22 +6,24 @@
         <classname>Zend_Cache</classname> provides a generic way to cache any data.
     </para>
     <para>
-      Caching in Zend Framework is operated by frontends while cache records are stored through backend adapters
-      (<emphasis>File</emphasis>, <emphasis>Sqlite</emphasis>, <emphasis>Memcache</emphasis>...) through a flexible
-      system of IDs and tags. Using those, it is easy to delete specific types of records afterwards
-      (for example: "delete all cache records marked with a given tag").
+      Caching in Zend Framework is operated by frontends while cache records are stored through
+      backend adapters (<emphasis>File</emphasis>, <emphasis>Sqlite</emphasis>,
+      <emphasis>Memcache</emphasis>...) through a flexible system of IDs and tags. Using those, it
+      is easy to delete specific types of records afterwards (for example: "delete all cache records
+      marked with a given tag").
     </para>
     <para>
-        The core of the module (<classname>Zend_Cache_Core</classname>) is generic, flexible and configurable.
-        Yet, for your specific needs there are cache frontends that extend <classname>Zend_Cache_Core</classname>
-        for convenience: <emphasis>Output</emphasis>, <emphasis>File</emphasis>, <emphasis>Function</emphasis> and <emphasis>Class</emphasis>.
+        The core of the module (<classname>Zend_Cache_Core</classname>) is generic, flexible and
+        configurable. Yet, for your specific needs there are cache frontends that extend
+        <classname>Zend_Cache_Core</classname> for convenience: <emphasis>Output</emphasis>,
+        <emphasis>File</emphasis>, <emphasis>Function</emphasis> and <emphasis>Class</emphasis>.
     </para>
     <example id="zend.cache.introduction.example-1">
         <title>Getting a Frontend with Zend_Cache::factory()</title>
         <para>
-            <classname>Zend_Cache::factory()</classname> instantiates correct objects and ties them together.
-            In this first example, we will use <emphasis>Core</emphasis> frontend together with <emphasis>File</emphasis>
-            backend.
+            <classname>Zend_Cache::factory()</classname> instantiates correct objects and ties them
+            together. In this first example, we will use <emphasis>Core</emphasis> frontend together
+            with <emphasis>File</emphasis> backend.
         </para>
 
         <programlisting language="php"><![CDATA[
@@ -56,9 +58,10 @@ $cache = Zend_Cache::factory('Core',
         <title>Caching a Database Query Result</title>
 
         <para>
-            Now that we have a frontend, we can cache any type of data (we turned on serialization). For
-            example, we can cache a result from a very expensive database query. After it is cached, there
-            is no need to even connect to the database; records are fetched from cache and unserialized.
+            Now that we have a frontend, we can cache any type of data (we turned on serialization).
+            for example, we can cache a result from a very expensive database query. After it is
+            cached, there is no need to even connect to the database; records are fetched from cache
+            and unserialized.
         </para>
 
         <programlisting language="php"><![CDATA[
@@ -90,12 +93,13 @@ print_r($result);
         <title>Caching Output with Zend_Cache Output Frontend</title>
         <para>
             We 'mark up' sections in which we want to cache output by adding some conditional logic,
-            encapsulating the section within <methodname>start()</methodname> and <methodname>end()</methodname> methods (this
-            resembles the first example and is the core strategy for caching).
+            encapsulating the section within <methodname>start()</methodname> and
+            <methodname>end()</methodname> methods (this resembles the first example and is the core
+            strategy for caching).
         </para><para>
-            Inside, output your data as usual - all output will be cached when execution hits the <methodname>end()</methodname>
-            method. On the next run, the whole section will be skipped in favor of fetching data from cache
-            (as long as the cache record is valid).
+            Inside, output your data as usual - all output will be cached when execution hits the
+            <methodname>end()</methodname> method. On the next run, the whole section will be
+            skipped in favor of fetching data from cache (as long as the cache record is valid).
         </para>
         <programlisting language="php"><![CDATA[
 $frontendOptions = array(
@@ -123,19 +127,20 @@ if(!$cache->start('mypage')) {
 echo 'This is never cached ('.time().').';
 ]]></programlisting>
        <para>
-           Notice that we output the result of <methodname>time()</methodname> twice; this is something dynamic
-           for demonstration purposes. Try running this and then refreshing several times; you will notice
-           that the first number doesn't change while second changes as time passes. That is because the first
-           number was output in the cached section and is saved among other output.
-           After half a minute (we've set lifetime to 30 seconds) the
-           numbers should match again because the cache record expired -- only to be cached again. You
-           should try this in your browser or console.
+           Notice that we output the result of <methodname>time()</methodname> twice; this is
+           something dynamic for demonstration purposes. Try running this and then refreshing
+           several times; you will notice that the first number doesn't change while second changes
+           as time passes. That is because the first number was output in the cached section and is
+           saved among other output. After half a minute (we've set lifetime to 30 seconds) the
+           numbers should match again because the cache record expired -- only to be cached again.
+           You should try this in your browser or console.
        </para>
     </example>
     <note><para>
-        When using <classname>Zend_Cache</classname>, pay attention to the important cache identifier (passed to <methodname>save()</methodname>
-        and <methodname>start()</methodname>). It must be unique for every resource you cache, otherwise unrelated
-        cache records may wipe each other or, even worse, be displayed in place of the other.
+        When using <classname>Zend_Cache</classname>, pay attention to the important cache
+        identifier (passed to <methodname>save()</methodname> and <methodname>start()</methodname>).
+        It must be unique for every resource you cache, otherwise unrelated cache records may wipe
+        each other or, even worse, be displayed in place of the other.
     </para></note>
 </sect1>
 <!--

+ 41 - 34
documentation/manual/en/module_specs/Zend_Cache-Theory.xml

@@ -3,31 +3,35 @@
 <sect1 id="zend.cache.theory">
     <title>The Theory of Caching</title>
     <para>
-        There are three key concepts in <classname>Zend_Cache</classname>. One is the unique identifier (a string) that is used
-        to identify cache records. The second one is the <emphasis>'lifetime'</emphasis> directive as seen in the
-        examples; it defines for how long the cached resource is considered 'fresh'. The third key concept
-        is conditional execution so that parts of your code can be skipped entirely, boosting performance.
-        The main frontend function (eg. <classname>Zend_Cache_Core::get()</classname>) is always designed to return
-        false for a cache miss if that makes sense for the nature of a frontend. That enables end-users to
-        wrap parts of the code they would like to cache (and skip) in <emphasis>if(){ ... }</emphasis> statements where
-        the condition is a <classname>Zend_Cache</classname> method itself. On the end if these blocks you must save what you've
-        generated, however (eg. <classname>Zend_Cache_Core::save()</classname>).
+        There are three key concepts in <classname>Zend_Cache</classname>. One is the unique
+        identifier (a string) that is used to identify cache records. The second one is the
+        <emphasis>'lifetime'</emphasis> directive as seen in the examples; it defines for how long
+        the cached resource is considered 'fresh'. The third key concept is conditional execution so
+        that parts of your code can be skipped entirely, boosting performance. The main frontend
+        function (eg. <classname>Zend_Cache_Core::get()</classname>) is always designed to return
+        false for a cache miss if that makes sense for the nature of a frontend. That enables
+        end-users to wrap parts of the code they would like to cache (and skip) in
+        <emphasis>if(){ ... }</emphasis> statements where the condition is a
+        <classname>Zend_Cache</classname> method itself. On the end if these blocks you must save
+        what you've generated, however (eg. <classname>Zend_Cache_Core::save()</classname>).
     </para>
     <note><para>
         The conditional execution design of your generating code is not necessary in some frontends
-        (<emphasis>Function</emphasis>, for an example) when the whole logic is implemented inside the frontend.
+        (<emphasis>Function</emphasis>, for an example) when the whole logic is implemented inside
+        the frontend.
     </para></note>
     <note><para>
-        'Cache hit' is a term for a condition when a cache record is found, is valid and is 'fresh' (in other
-        words hasn't expired yet). 'Cache miss' is everything else. When a cache miss happens, you must
-        generate your data (as you would normally do) and have it cached. When you have a cache hit, on the
-        other hand, the backend automatically fetches the record from cache transparently.
+        'Cache hit' is a term for a condition when a cache record is found, is valid and is 'fresh'
+        (in other words hasn't expired yet). 'Cache miss' is everything else. When a cache miss
+        happens, you must generate your data (as you would normally do) and have it cached. When you
+        have a cache hit, on the other hand, the backend automatically fetches the record from cache
+        transparently.
     </para></note>
     <sect2 id="zend.cache.factory">
         <title>The Zend_Cache Factory Method</title>
         <para>
-            A good way to build a usable instance of a <classname>Zend_Cache</classname> Frontend is given
-            in the following example :
+            A good way to build a usable instance of a <classname>Zend_Cache</classname> Frontend is
+            given in the following example :
         </para>
         <programlisting language="php"><![CDATA[
 // We choose a backend (for example 'File' or 'Sqlite'...)
@@ -50,43 +54,45 @@ $cache = Zend_Cache::factory($frontendName,
                              $backendOptions);
 ]]></programlisting>
         <para>
-            In the following examples we will assume that the <varname>$cache</varname> variable holds a
-            valid, instantiated frontend as shown and that you understand how to pass parameters
-            to your chosen backends.
+            In the following examples we will assume that the <varname>$cache</varname> variable
+            holds a valid, instantiated frontend as shown and that you understand how to pass
+            parameters to your chosen backends.
         </para>
         <note><para>
-            Always use <classname>Zend_Cache::factory()</classname> to get frontend instances. Instantiating
-            frontends and backends yourself will not work as expected.
+            Always use <classname>Zend_Cache::factory()</classname> to get frontend instances.
+            Instantiating frontends and backends yourself will not work as expected.
         </para></note>
     </sect2>
 
     <sect2 id="zend.cache.tags">
         <title>Tagging Records</title>
         <para>
-            Tags are a way to categorize cache records. When you save a cache with the <methodname>save()</methodname>
-            method, you can set an array of tags to apply for this record. Then you will be
-            able to clean all cache records tagged with a given tag (or tags):
+            Tags are a way to categorize cache records. When you save a cache with the
+            <methodname>save()</methodname> method, you can set an array of tags to apply for this
+            record. Then you will be able to clean all cache records tagged with a given tag (or
+            tags):
         </para>
         <programlisting language="php"><![CDATA[
 $cache->save($huge_data, 'myUniqueID', array('tagA', 'tagB', 'tagC'));
 ]]></programlisting>
         <note><para>
-            note than the <methodname>save()</methodname> method accepts an optional fourth argument : <varname>$specificLifetime</varname>
-            (if != false, it sets a specific lifetime for this particular cache record)
+            note than the <methodname>save()</methodname> method accepts an optional fourth argument
+            : <varname>$specificLifetime</varname> (if != false, it sets a specific lifetime for
+            this particular cache record)
         </para></note>
     </sect2>
     <sect2 id="zend.cache.clean">
         <title>Cleaning the Cache</title>
         <para>
-            To remove/invalidate in particular cache id, you can use the <methodname>remove()</methodname>
-            method :
+            To remove/invalidate in particular cache id, you can use the
+            <methodname>remove()</methodname> method :
         </para>
         <programlisting language="php"><![CDATA[
 $cache->remove('idToRemove');
 ]]></programlisting>
         <para>
-            To remove/invalidate several cache ids in one operation, you can use the <methodname>clean()</methodname>
-            method. For example to remove all cache records :
+            To remove/invalidate several cache ids in one operation, you can use the
+            <methodname>clean()</methodname> method. For example to remove all cache records :
         </para>
         <programlisting language="php"><![CDATA[
 // clean all records
@@ -123,10 +129,11 @@ $cache->clean(
 );
 ]]></programlisting>
         <para>
-            Available cleaning modes are: <constant>CLEANING_MODE_ALL</constant>, <constant>CLEANING_MODE_OLD</constant>,
-            <constant>CLEANING_MODE_MATCHING_TAG</constant>, <constant>CLEANING_MODE_NOT_MATCHING_TAG</constant> and
-            <constant>CLEANING_MODE_MATCHING_ANY_TAG</constant>.
-            The latter are, as their names suggest, combined with an array of tags in cleaning operations.
+            Available cleaning modes are: <constant>CLEANING_MODE_ALL</constant>,
+            <constant>CLEANING_MODE_OLD</constant>, <constant>CLEANING_MODE_MATCHING_TAG</constant>,
+            <constant>CLEANING_MODE_NOT_MATCHING_TAG</constant> and
+            <constant>CLEANING_MODE_MATCHING_ANY_TAG</constant>. The latter are, as their names
+            suggest, combined with an array of tags in cleaning operations.
         </para>
     </sect2>
 </sect1>

+ 21 - 20
documentation/manual/en/module_specs/Zend_Captcha-Adapters.xml

@@ -11,12 +11,12 @@
         <title>Zend_Captcha_Word</title>
 
         <para>
-            <classname>Zend_Captcha_Word</classname> is an abstract adapter that serves as the base class
-            for most other CAPTCHA adapters. It provides mutators for
+            <classname>Zend_Captcha_Word</classname> is an abstract adapter that serves as the base
+            class for most other CAPTCHA adapters. It provides mutators for
             specifying word length, session TTL, the session namespace object
             to use, and the session namespace class to use for persistence if
-            you do not wish to use <classname>Zend_Session_Namespace</classname>. <classname>Zend_Captcha_Word</classname>
-            encapsulates validation logic.
+            you do not wish to use <classname>Zend_Session_Namespace</classname>.
+            <classname>Zend_Captcha_Word</classname> encapsulates validation logic.
         </para>
 
         <para>
@@ -33,9 +33,9 @@
 
         <itemizedlist>
             <listitem><para>
-                <methodname>setWordLen($length)</methodname> and <methodname>getWordLen()</methodname>
-                allow you to specify the length of the generated "word" in
-                characters, and to retrieve the current value.
+                <methodname>setWordLen($length)</methodname> and
+                <methodname>getWordLen()</methodname> allow you to specify the length of the
+                generated "word" in characters, and to retrieve the current value.
             </para></listitem>
 
             <listitem><para>
@@ -75,9 +75,9 @@
         <para>
             All word CAPTCHAs allow you to pass an array of options to the
             constructor, or, alternately, pass them to
-            <methodname>setOptions()</methodname>. You can also pass a <classname>Zend_Config</classname>
-            object to <methodname>setConfig()</methodname>. By default, the
-            <emphasis>wordLen</emphasis>, <emphasis>timeout</emphasis>, and
+            <methodname>setOptions()</methodname>. You can also pass a
+            <classname>Zend_Config</classname> object to <methodname>setConfig()</methodname>. By
+            default, the <emphasis>wordLen</emphasis>, <emphasis>timeout</emphasis>, and
             <emphasis>sessionClass</emphasis> keys may all be used. Each concrete
             implementation may define additional keys or utilize the options in
             other ways.
@@ -85,7 +85,8 @@
 
         <note>
         <para>
-            <classname>Zend_Captcha_Word</classname> is an abstract class and may not be instantiated directly.
+            <classname>Zend_Captcha_Word</classname> is an abstract class and may not be
+            instantiated directly.
         </para>
         </note>
     </sect2>
@@ -94,8 +95,8 @@
         <title>Zend_Captcha_Dumb</title>
 
         <para>
-            The <classname>Zend_Captch_Dumb</classname> adapter is mostly self-descriptive. It provides a random
-            string that must be typed in reverse to validate. As such, it's
+            The <classname>Zend_Captch_Dumb</classname> adapter is mostly self-descriptive. It
+            provides a random string that must be typed in reverse to validate. As such, it's
             not a good CAPTCHA solution and should only be used for
             testing. It extends <classname>Zend_Captcha_Word</classname>.
         </para>
@@ -106,15 +107,15 @@
 
         <para>
             The <classname>Zend_Captcha_Figlet</classname> adapter utilizes <link
-                linkend="zend.text.figlet"><classname>Zend_Text_Figlet</classname></link> to present a
-                figlet to the user.
+                linkend="zend.text.figlet"><classname>Zend_Text_Figlet</classname></link> to present
+            a figlet to the user.
         </para>
 
         <para>
             Options passed to the constructor will also be passed to the <link
                 linkend="zend.text.figlet">Zend_Text_Figlet</link> object. See
-                the <link linkend="zend.text.figlet">Zend_Text_Figlet</link>documentation for details on what
-                configuration options are available.
+                the <link linkend="zend.text.figlet">Zend_Text_Figlet</link>documentation for
+            details on what configuration options are available.
         </para>
     </sect2>
 
@@ -163,9 +164,9 @@
             </para></listitem>
 
             <listitem><para>
-                <methodname>setFontSize($fsize)</methodname> and <methodname>getFontSize()</methodname>
-                allow you to specify the font size in pixels for
-                generating the CAPTCHA. The default is 24px.
+                <methodname>setFontSize($fsize)</methodname> and
+                <methodname>getFontSize()</methodname> allow you to specify the font size in pixels
+                for generating the CAPTCHA. The default is 24px.
             </para></listitem>
 
             <listitem><para>

+ 38 - 32
documentation/manual/en/module_specs/Zend_Config-TheoryOfOperation.xml

@@ -7,46 +7,51 @@
         through an associative array, which may be multi-dimensional, in order to support
         organizing the data from general to specific. Concrete adapter classes
         adapt configuration data from storage to produce the associative array for the
-        <classname>Zend_Config</classname> constructor. User scripts may provide such arrays directly
-        to the <classname>Zend_Config</classname> constructor, without using an adapter class, since
-        it may be appropriate to do so in certain situations.
+        <classname>Zend_Config</classname> constructor. User scripts may provide such arrays
+        directly to the <classname>Zend_Config</classname> constructor, without using an adapter
+        class, since it may be appropriate to do so in certain situations.
     </para>
     <para>
-        Each configuration data array value becomes a property of the <classname>Zend_Config</classname> object. The key is used
-        as the property name. If a value is itself an array, then the resulting object property is created as a new
-        <classname>Zend_Config</classname> object, loaded with the array data. This occurs recursively, such that a hierarchy of
-        configuration data may be created with any number of levels.
+        Each configuration data array value becomes a property of the
+        <classname>Zend_Config</classname> object. The key is used as the property name. If a value
+        is itself an array, then the resulting object property is created as a new
+        <classname>Zend_Config</classname> object, loaded with the array data. This occurs
+        recursively, such that a hierarchy of configuration data may be created with any number of
+        levels.
     </para>
     <para>
-        <classname>Zend_Config</classname> implements the <code>Countable</code> and <code>Iterator</code>
-        interfaces in order to facilitate simple access to configuration data.
+        <classname>Zend_Config</classname> implements the <code>Countable</code> and
+        <code>Iterator</code> interfaces in order to facilitate simple access to configuration data.
         Thus, one may use the <ulink url="http://php.net/count"><code>count()</code></ulink>
         function and PHP constructs such as
         <ulink url="http://php.net/foreach"><code>foreach</code></ulink> with
         <classname>Zend_Config</classname> objects.
     </para>
     <para>
-        By default, configuration data made available through <classname>Zend_Config</classname>
-        are read-only, and an assignment (e.g.,
-        <code>$config->database->host = 'example.com'</code>)
-        results in a thrown exception. This default behavior may be overridden through the constructor,
-        however, to allow modification of data values. Also, when modifications are allowed, <classname>Zend_Config</classname>
-        supports unsetting of values (i.e. <code>unset($config->database->host);</code>). The
-        <code>readOnly()</code> method can be used to determine if modifications to a given <classname>Zend_Config</classname>
-        object are allowed and the <code>setReadOnly()</code> method can be used to stop any further
-        modifications to a <classname>Zend_Config</classname> object that was created allowing modifications.
+        By default, configuration data made available through <classname>Zend_Config</classname> are
+        read-only, and an assignment (e.g., <code>$config->database->host = 'example.com'</code>)
+        results in a thrown exception. This default behavior may be overridden through the
+        constructor, however, to allow modification of data values. Also, when modifications are
+        allowed, <classname>Zend_Config</classname> supports unsetting of values (i.e.
+        <code>unset($config->database->host);</code>). The <code>readOnly()</code> method can be
+        used to determine if modifications to a given <classname>Zend_Config</classname> object are
+        allowed and the <code>setReadOnly()</code> method can be used to stop any further
+        modifications to a <classname>Zend_Config</classname> object that was created allowing
+        modifications.
         <note>
             <para>
-                It is important not to confuse such in-memory modifications with saving configuration
-                data out to specific storage media. Tools for creating and modifying configuration
-                data for various storage media are out of scope with respect to <classname>Zend_Config</classname>.
-                Third-party open source solutions are readily available for the purpose of creating and
-                modifying configuration data for various storage media.
+                It is important not to confuse such in-memory modifications with saving
+                configuration data out to specific storage media. Tools for creating and modifying
+                configuration data for various storage media are out of scope with respect to
+                <classname>Zend_Config</classname>. Third-party open source solutions are readily
+                available for the purpose of creating and modifying configuration data for various
+                storage media.
             </para>
         </note>
     </para>
     <para>
-        Adapter classes inherit from the <classname>Zend_Config</classname> class since they utilize its functionality.
+        Adapter classes inherit from the <classname>Zend_Config</classname> class since they utilize
+        its functionality.
     </para>
     <para>
         The <classname>Zend_Config</classname> family of classes enables configuration data to be
@@ -66,16 +71,17 @@
     </para>
     <para>
         If you have two <classname>Zend_Config</classname> objects, you can merge them into a single
-        object using the <code>merge()</code> function. For example, given <varname>$config</varname> and
-        <varname>$localConfig</varname>, you can merge data from <varname>$localConfig</varname> to <varname>$config</varname> using
-        <code>$config->merge($localConfig);</code>. The items in <varname>$localConfig</varname> will override
-        any items with the same name in <varname>$config</varname>.
+        object using the <code>merge()</code> function. For example, given
+        <varname>$config</varname> and <varname>$localConfig</varname>, you can merge data from
+        <varname>$localConfig</varname> to <varname>$config</varname> using
+        <code>$config->merge($localConfig);</code>. The items in <varname>$localConfig</varname>
+        will override any items with the same name in <varname>$config</varname>.
         <note>
             <para>
-                The <classname>Zend_Config</classname> object that is performing the merge must have been constructed
-                to allow modifications, by passing <constant>TRUE</constant> as the second parameter of the constructor.
-                The <code>setReadOnly()</code> method can then be used to prevent any further modifications
-                after the merge is complete.
+                The <classname>Zend_Config</classname> object that is performing the merge must have
+                been constructed to allow modifications, by passing <constant>TRUE</constant> as the
+                second parameter of the constructor. The <code>setReadOnly()</code> method can then
+                be used to prevent any further modifications after the merge is complete.
             </para>
         </note>
     </para>

+ 39 - 23
documentation/manual/en/module_specs/Zend_Config_Ini.xml

@@ -3,30 +3,33 @@
 <sect1 id="zend.config.adapters.ini">
     <title>Zend_Config_Ini</title>
     <para>
-        <classname>Zend_Config_Ini</classname> enables developers to store configuration data in a familiar INI format and read
-        them in the application by using nested object property syntax. The INI format is specialized to provide both
-        the ability to have a hierarchy of configuration data keys and inheritance between configuration data sections.
-        Configuration data hierarchies are supported by separating the keys with the dot or period character
-        ("<emphasis>.</emphasis>"). A section may extend or inherit from another section by following the section name with a
-        colon character ("<emphasis>:</emphasis>) and the name of the section from which data are to be inherited.
+        <classname>Zend_Config_Ini</classname> enables developers to store configuration data in a
+        familiar INI format and read them in the application by using nested object property syntax.
+        The INI format is specialized to provide both the ability to have a hierarchy of
+        configuration data keys and inheritance between configuration data sections. Configuration
+        data hierarchies are supported by separating the keys with the dot or period character
+        ("<emphasis>.</emphasis>"). A section may extend or inherit from another section by
+        following the section name with a colon character ("<emphasis>:</emphasis>) and the name of
+        the section from which data are to be inherited.
     </para>
     <note>
         <title>Parsing the INI File</title>
         <para>
-            <classname>Zend_Config_Ini</classname> utilizes the
-            <ulink url="http://php.net/parse_ini_file"><methodname>parse_ini_file()</methodname></ulink>
+            <classname>Zend_Config_Ini</classname> utilizes the <ulink
+                url="http://php.net/parse_ini_file"><methodname>parse_ini_file()</methodname></ulink>
             PHP function. Please review this documentation to be aware of its specific behaviors,
-            which propagate to <classname>Zend_Config_Ini</classname>, such as how the special values of
-            "<constant>TRUE</constant>", "<constant>FALSE</constant>", "yes", "no",
+            which propagate to <classname>Zend_Config_Ini</classname>, such as how the special
+            values of "<constant>TRUE</constant>", "<constant>FALSE</constant>", "yes", "no",
             and "<constant>NULL</constant>" are handled.
         </para>
     </note>
     <note>
         <title>Key Separator</title>
         <para>
-            By default, the key separator character is the period character ("<emphasis>.</emphasis>"). This can be changed,
-            however, by changing the <varname>$options</varname> key <emphasis>'nestSeparator'</emphasis> when constructing the
-            <classname>Zend_Config_Ini</classname> object. For example:
+            By default, the key separator character is the period character
+            ("<emphasis>.</emphasis>"). This can be changed, however, by changing the
+            <varname>$options</varname> key <emphasis>'nestSeparator'</emphasis> when constructing
+            the <classname>Zend_Config_Ini</classname> object. For example:
             <programlisting language="php"><![CDATA[
 $options['nestSeparator'] = ':';
 $config = new Zend_Config_Ini('/path/to/config.ini',
@@ -38,12 +41,14 @@ $config = new Zend_Config_Ini('/path/to/config.ini',
     <example id="zend.config.adapters.ini.example.using">
         <title>Using Zend_Config_Ini</title>
         <para>
-            This example illustrates a basic use of <classname>Zend_Config_Ini</classname> for loading configuration data from an
-            INI file. In this example there are configuration data for both a production system and for a staging
-            system. Because the staging system configuration data are very similar to those for production, the staging
-            section inherits from the production section. In this case, the decision is arbitrary and could have been
-            written conversely, with the production section inheriting from the staging section, though this may not be
-            the case for more complex situations. Suppose, then, that the following configuration data are contained in
+            This example illustrates a basic use of <classname>Zend_Config_Ini</classname> for
+            loading configuration data from an INI file. In this example there are configuration
+            data for both a production system and for a staging system. Because the staging system
+            configuration data are very similar to those for production, the staging section
+            inherits from the production section. In this case, the decision is arbitrary and could
+            have been written conversely, with the production section inheriting from the staging
+            section, though this may not be the case for more complex situations. Suppose, then,
+            that the following configuration data are contained in
             <filename>/path/to/config.ini</filename>:
         </para>
         <programlisting language="ini"><![CDATA[
@@ -64,8 +69,9 @@ database.params.username = devuser
 database.params.password = devsecret
 ]]></programlisting>
         <para>
-            Next, assume that the application developer needs the staging configuration data from the INI file. It is a
-            simple matter to load these data by specifying the INI file and the staging section:
+            Next, assume that the application developer needs the staging configuration data from
+            the INI file. It is a simple matter to load these data by specifying the INI file and
+            the staging section:
         </para>
         <programlisting language="php"><![CDATA[
 $config = new Zend_Config_Ini('/path/to/config.ini', 'staging');
@@ -99,8 +105,18 @@ echo $config->database->params->dbname; // prints "dbname"
                     <entry><varname>$options = false</varname></entry>
                     <entry>Options array. The following keys are supported:
                         <itemizedlist>
-                            <listitem><para><emphasis>allowModifications</emphasis>: Set to true to allow subsequent modification of loaded file. Defaults to false</para></listitem>
-                            <listitem><para><emphasis>nestSeparator</emphasis>: Set to the character to be used as the nest separator. Defaults to "."</para></listitem>
+                            <listitem>
+                                <para>
+                                    <emphasis>allowModifications</emphasis>: Set to true to allow
+                                    subsequent modification of loaded file. Defaults to false
+                                </para>
+                            </listitem>
+                            <listitem>
+                                <para>
+                                    <emphasis>nestSeparator</emphasis>: Set to the character to be
+                                    used as the nest separator. Defaults to "."
+                                </para>
+                            </listitem>
                         </itemizedlist>
                     </entry>
                 </row>

+ 8 - 8
documentation/manual/en/module_specs/Zend_Console_Getopt-Configuration.xml

@@ -188,14 +188,14 @@ $opts->setArguments(array('-a', '-p', 'p_parameter', 'non_option_arg'));
             <listitem>
                 <para>
                     <classname>Zend_Console_Getopt::CONFIG_RULEMODE</classname>
-                    ("ruleMode") may have values <classname>Zend_Console_Getopt::MODE_ZEND</classname>
-                    ("zend") and <classname>Zend_Console_Getopt::MODE_GNU</classname>
-                    ("gnu"). It should not be necessary to use this option
-                    unless you extend the class with additional syntax forms.
-                    The two modes supported in the base <classname>Zend_Console_Getopt</classname>
-                    class are unambiguous. If the specifier is a string, the
-                    class assumes <code>MODE_GNU</code>, otherwise it assumes
-                    <code>MODE_ZEND</code>. But if you extend the class and
+                    ("ruleMode") may have values
+                    <classname>Zend_Console_Getopt::MODE_ZEND</classname> ("zend") and
+                    <classname>Zend_Console_Getopt::MODE_GNU</classname> ("gnu"). It should not be
+                    necessary to use this option unless you extend the class with additional syntax
+                    forms. The two modes supported in the base
+                    <classname>Zend_Console_Getopt</classname> class are unambiguous. If the
+                    specifier is a string, the class assumes <code>MODE_GNU</code>, otherwise it
+                    assumes <code>MODE_ZEND</code>. But if you extend the class and
                     add more syntax forms, you may need to specify the mode
                     using this option.
                 </para>

+ 2 - 2
documentation/manual/en/module_specs/Zend_Console_Getopt-Rules.xml

@@ -26,8 +26,8 @@
         <title>Declaring Options with the Short Syntax</title>
         <para>
             <classname>Zend_Console_Getopt</classname> supports a compact syntax similar
-            to that used by GNU Getopt (see
-            <ulink url="http://www.gnu.org/software/libc/manual/html_node/Getopt.html">http://www.gnu.org/software/libc/manual/html_node/Getopt.html</ulink>.
+            to that used by GNU Getopt (see <ulink
+                url="http://www.gnu.org/software/libc/manual/html_node/Getopt.html">http://www.gnu.org/software/libc/manual/html_node/Getopt.html</ulink>.
             This syntax supports only single-character flags. In a single
             string, you type each of the letters that correspond to flags
             supported by your application. A letter followed by a colon