Works only in Safari and Chrome:

CSS for variations 2 and 3:

.jqm-spin-demo .spin.var2 {
  -webkit-animation-name: spin_var2;
	-webkit-animation-duration: 12s;
}

@-webkit-keyframes spin_var2 {
	from {-webkit-transform: rotate(0deg);}
  	to {-webkit-transform: rotate(3600deg);}
}

.jqm-spin-demo .spin.var3 {
  -webkit-animation-timing-function: linear;
}

However, there is an easy solution (this one requires jQuery but can be easily adapted):

$(document).bind("orientationchange", function(event){
  $(window).trigger(event);
});

• jfCacheHeadersFilter: sets the HTTP headers required to server pages from client side (or proxy) cache
• jfCacheInvalidateStaticSourceUrlsFilter: append a cache key to the URLs of referenced Javascript and CSS files so that you can configure a very long cache expire time for those files

Installation Instructions

Check out the source code

$ svn co http://jfcacheplugin.googlecode.com/svn/branches/1.4.0 plugins/jfCachePlugin

Publish assets

$ ./symfony plugin:publish-assets

Enable filters in your filters.yml

jfCacheHeadersFilter

This filter automatically sets the correct cache headers so that web browsers and proxy servers can cache your pages.
The corresponding cache headers will only be set if
a) you call jfCacheHeadersFilter::enable() or
b) you have enabled the symfony file cache with the “with_layout” option for the pages you want to cache (see http://www.symfony-project.org/gentle-introduction/1_4/en/12-Caching)

In either case you can avoid the cache headers if you call jfCacheHeadersFilter::disable()

Put these settings in your filters.yml file:

jfCacheHeaders:
  class: jfCacheHeadersFilter
  param:
    cacheableEnvironments: [prod]
    cacheableHttpStatusCodes: [200]
    expireTime: 300

jfCacheHeadersFilter

This filter automatically appends a cache=TIMESTAMP_OF_LAST_CLEAR_CACHE parameter to referenced .css and .js files.
Therefore you can cache your css/js files for a very long time without worrying that your users might use old versions of your files.
Clearing the symfony cache will automatically “clear” all js/css files cached in Browsers or Proxys.

Put these settings in your filters.yml file:

jfCacheInvalidateStaticSourceUrls:
  class: jfCacheInvalidateStaticSourceUrlsFilter
  param:
    cacheKeyName: cache #name of the url parameter the gets appended to each css/js URL

optional: modify vhost/.htaccess settings to server js/css files from cache

Here is a sample vhost/.htaccess config to make sure that js and css files get cached properly (for 30 days in this example):

<ifmodule mod_expires.c>
  ExpiresActive On
  ExpiresByType application/x-javascript A2592000
  ExpiresByType application/javascript A2592000
  ExpiresByType text/javascript A2592000
  ExpiresByType text/css A2592000
</ifmodule>

<ifmodule mod_headers.c>
  <filesmatch "\.(css|js)$">
    Header set Cache-Control "max-age=2592000, public"
  </filesmatch>
</ifmodule>

If you wish to see the plugin in action you can visit the mobile version of my web page http://www.jonasfischer.net/m.

If you are visiting my website using one of the supported operating systems (e.g. iOs or Android) then you will be prompted if you wish to view the mobile-enhanced version or the regular version: http://www.jonasfischer.net/.

Features

• jQuery Mobile integration
• jfPortableDevicePlugin is bundled with a standard template and theme to get your app up and running within minutes
• automatically “hijacks” links and appends some parameters to the URLs so that you can apply special logic in your symfony actions/templates if needed
• flexible and extendable using symfony standards: The templates are organized in a very fine-grained manner so that you can override the parts that don’t fit your needs.
• Comes with a phonegap build-mode option to prepare your app for deployment using phonegap.

Installation instructions

Checkout the Source Code:

$ svn co http://jfportabledevice.googlecode.com/svn/trunk plugins/jfPortableDevicePlugin

Be aware that you are checking out the trunk. As this plugin is still under heavy development (in fact, the jQuery Mobile library itself is still in alpha state) there is no stable tag/branch, yet.

Enable plugin jfPortableDevicePlugin in your ProjectConfiguration.php

As Victor points out in the comments, if you have not enabled all plugins by default, you need to enabled jfPortableDevicePlugin manually:

$this->enablePlugins(’jfPortableDevicePlugin’);

Enable module jfPortableDevice in your settings.yml

enabled_modules: [..., jfPortableDevice]

Publish plugin assets

$ php symfony plugin:publish-assets

Enabled filters in your filters.yml

required: jfPortableDeviceFilter

This filter automatically sets the correct layout for portable device requests.

jfPortableDevice:
class:  jfPortableDeviceFilter
param:
layout: jfPortableDeviceLayout

Additionally, you need to ensure that the specified layout file exists in your app’s layout folder.
To get up and running you can use the bundled jfPortableDeviceLayout.php file. Simply symlink or copy it into your app’s layout folder:

$ ln -s ../../../plugins/jfPortableDevicePlugin/templates/jfPortableDeviceLayout.php apps/frontend/templates/jfPortableDeviceLayout.php

or

$ cp plugins/jfPortableDevicePlugin/templates/jfPortableDeviceLayout.php apps/frontend/templates/

optional: redirectByUserAgentPortableDevice

This filter redirects to the portable device controller if a request was made from one of the specified user agents

redirectByUserAgentPortableDevice:
  class:  redirectByUserAgentPortableDeviceFilter
  param:
    redirectUrl: /m/#%s?jfPD_device=portable
    noHeaderRedirect: true
    javascriptConfirm: true
    stopParameters:
      - noMobileRedirect
    stopModules:
      - jfPortableDevice
    userAgents:
      - iphone #really bad example string because it might easily be miss-matched. Choose whichever regular expressions fit your needs
      - ipod #really bad example string because it might easily be miss-matched. Choose whichever regular expressions fit your needs
      - ipad #really bad example string because it might easily be miss-matched. Choose whichever regular expressions fit your needs
      - android #really bad example string because it might easily be miss-matched. Choose whichever regular expressions fit your needs

Clear the symfony cache

$ php symfony cc

Here is a simple way to allow users to unlink relations by selecting the empty value of a sfWidgetFormDoctrineChoice select list. Simply add these lines to your form’s configure()-method:

$this->widgetSchema['rdr_images_list']->setOption('add_empty', true);
$valuesRaw = sfContext::getInstance()->getRequest()->getParameter($this->getName());
if (1 === count($valuesRaw['images_list']) && '' === $valuesRaw['images_list'][0]) {
  $this->validatorSchema['images_list'] = new sfValidatorPass();
}

Usage

Simply insert the following code directly after the opening <form>-Tag:

< ?php $formId = 'myFormId' ?>
<form id="<?php echo $formId ?>">
< ?php
use_helper('jQueryValidator');
echo jquery_validate_form($form, $formId);
?>

This will add some css classes to the form widgets based on the validators configured in your form.

Then you can add more complex validation afterwards:

<script>
//Certificate name field is only required if a certificate is requested
$('#rdr_donation_cert_name').rules('add', {
  required: '#rdr_donation_certificate_1:checked'
});
</script>

In some cases you might want to access the jQuery-validate object itself:

<script>
 if (typeof < ?php echo $form->getName() ?>Validator !== 'undefined') {
  var donationCertificateValidator = < ?php echo $form->getName() ?>Validator; //jQuery.validate validator (instantiated in jquery_validate_form() helper)
  donationCertificateValidator.element($('#rdr_donation_cert_name'));
}
</script>

Source Code

jQueryValidatorHelper.php:

< ?php
/**
 * Enable the jQuery.validate plugin validation for the given {@param $form}
 *
 * @param sfForm $form [the sfForm object]
 * @param String $formId [the DOM Id of the rendered form]
 * @param String  $jQueryValidatePlugin [the script name of the jquery.validate plugin]
 */
function jquery_validate_form(sfForm $form, $formId, $jQueryValidatePlugin = 'jquery/plugins/validate/jquery.validate.js') {
  sfContext::getInstance()->getConfiguration()->loadHelpers(array('Asset', 'JavascriptBase'));

  if ($jQueryValidatePlugin) {
		use_javascript($jQueryValidatePlugin);
  }

  _jquery_validate_form_extend_form_fields($form->getValidatorSchema()->getFields(), $form->getWidgetSchema()->getFields());
  return javascript_tag("var {$form->getName()}Validator = jQuery('#$formId').validate();");
}

/**
 * Internal helper-helper that adds css and title meta information to the form fields.
 * This information is used by jQuery.validate to build up the validation rules and error messages
 *
 * @param array $validators
 * @param array $widgets
 */
function _jquery_validate_form_extend_form_fields(array $validators, array $widgets)
{
  foreach ($validators as $fieldName => $validator) {
  	$widget = $widgets[$fieldName];
  	if ($validator instanceof sfValidatorSchema || $validator instanceof sfWidgetFormSchemaDecorator) {
  		_jquery_validate_form_extend_form_fields($validator->getFields(), $widget->getFields());
  	}
  	else {
  		$options = $validator->getOptions();
  		$messages = $validator->getMessages();
  		$class = $widget->getAttribute('class');
  		$title = $widget->getAttribute('title');
  		if ($options['required']) {
  			$class .= ' required';
  			$title .= $messages['required'];
  		}

  		switch (get_class($validator)) {
  			case 'sfValidatorEmail':
  			  $class .= ' email';
  			  break;
  		}

  		$widget->setAttribute('class', $class);
  		$widget->setAttribute('title', $title);

  	}
  }

}

• Documentation and Download: http://bassistance.de/jquery-plugins/jquery-plugin-validation/
• Demo: http://jquery.bassistance.de/validate/demo/

I wrote this little helper method to extract the validation rules from forms defined with the symfon form framework and to automatically create the jquery.validate code to validate those forms on the client side. Of course, server side validation will still work, too.

In order to use the helper, you first need to include jQuery and the jQuery.validate plugin. Then you should download

jQueryValidatorHelper (and remove the .txt suffix from its filename).

Usage examples

1. completely automatically:

< ?php
use_helper('jQueryValidator');
echo jquery_validate_form($form, array('id' => 'signupForm'));
?>
<form id="signupForm" method="post">

1. specify additional fields or rules for validation:

use_helper('jQueryValidator');
$attributes = array('id' => 'profileEditForm');
echo jquery_validate_form($form, $attributes, array('aupair[baseData][first_name]' => array('options' => array('required' => true), 'messages' => array('required' => 'Required'))));
?>
< ?php echo form_tag_for($form, '@aupairs', $attributes); ?>

The third parameter of jquery_validate_form gives you the possibility to add more fields to validation or to override the automatically created validation rules with the ones fitting your needs better.

Limitations:

• No support for embedded forms (forms in forms won’t get validated)
• Only required, min length, max length and email validation is supported by now. However, you can add other jquery.validate validation options easily if you need them.

If the requesting user agent matches the redirect rules then the redirect is issued using HTTP Headers. As a fallback for cached pages, the redirect is issued again using javascript (the filter inserts some lines of javascript code in the -section of your document).

The first one, redirectUserAgentFilter, is a generic approach to redirects depending on the user agent string. You can activate it in your filters.yml using these lines:

redirectUserAgent:
  class:  redirectUserAgentFilter
  enabled: on
  param:
    redirectUrl: http://mobile.yourdomain.com
    userAgents:
      - android
      - iphone
      - ipod

In this case, the filter would redirect all requests coming from user agents containing “android”, “iphone” oder “ipod” in their names to http://mobile.yourdomain.com.

redirectUserAgentFilter.class.php:

/**
 * Redirect request if it was issued by one of the configured user agents
 * params:
 *  - array userAgents
 *  - string redirectUrl (may contain a %s sprintf placeholder)
 *
 * Example filters.yml integration:
 *
 * <pre>
redirectUserAgent:
  class:  redirectUserAgentFilter
  enabled: on
  param:
    redirectUrl: http://mobile.yourdomain.com
    userAgents:
      - android
      - iphone
      - ipod
</pre>
 *
 */
class redirectUserAgentFilter extends sfFilter
{
  public function execute($filterChain)
  {

  	// Execute this filter only once
    if ($this->isFirstCall())
    {
	    $context  = $this->getContext();
	    $request  = $context->getRequest();

	    foreach ($this->getStopParameters() as $stopParameter) {
	    	if ($request->hasParameter($stopParameter)) {
	    		$filterChain->execute();
	    		$content = $this->context->getResponse()->getContent();
	    		$content = self::addStopParameterToLinks($content, $stopParameter);
	    		$this->context->getResponse()->setContent($content);
	    		return;
	    	}
	    }

	    $redirectUrl = $this->getRedirectUrl();
	    $userAgent = strtolower($request->getHttpHeader('User-Agent'));
	    $userAgents = $this->getUserAgents();
	    foreach ($userAgents as $checkAgent) {
	    	if (false !== strpos($userAgent, $checkAgent)) {
		    	if (sfConfig::get('sf_logging_enabled'))
					{
					  $context->getLogger()->info("Mobile user agent '$checkAgent' detected. Redirecting to '$redirectUrl'");
					}
	    		$context->getController()->redirect($redirectUrl, 0, 302);
	    		throw new sfStopException();
	    	}
	    }
    }

    $filterChain->execute();

    $content = $this->context->getResponse()->getContent();
    $content = $this->addJavascriptRedirect($content, $userAgents, $redirectUrl);
    $this->context->getResponse()->setContent($content);

  }

  protected function addJavascriptRedirect($content, $userAgents, $redirectUrl)
  {
  	$script = '
  	<script type="text/javascript">
  		var userAgents = '.json_encode($userAgents).';
  		var userAgent = navigator.userAgent
  		if (userAgent) {
				for(var i=0; i<useragents .length; i++) {
					var regex = new RegExp(userAgents[i], "i");
					if (regex.exec(userAgent)) {
						document.location.href=decodeURIComponent("'.urlencode($redirectUrl).'");
					}
				}
  		}
  	</script>';

  	return str_replace('<head>', '</head><head>'.$script, $content);
  }

  /**
   * We want to preserve the stopParemetrs so we have to append it to all links
   *
   * @param unknown_type $stopParameter
   * @return unknown_type
   */
  public static function addStopParameterToLinks($content, $stopParameter)
  {
    //search and replace URLs
    $pattern = '/(<a .+href|action)="([^"]+)"/i';
    $replacement = '$1="$2?'.$stopParameter.'=1"';
    $content = preg_replace($pattern, $replacement, $content);

    //search and replace urls that already had an querystring parameter and thus now have two questionmarks in url
    $pattern = '/(<a.+href|action)="([^?]+)\?(.*)\?'.$stopParameter.'=1"/i';
    $replacement = '$1="$2?$3&'.$stopParameter.'=1"';
    $content = preg_replace($pattern, $replacement, $content);
    return $content;
  }

  /**
   * Returns a list of user agents that should get redirected.
   *
   * Uses userAgents parameter configured in filters.yml but may be overwritten
   *
   * @return array
   */
  protected function getUserAgents()
  {
    return $this->getParameter('userAgents', array());
  }

  /**
   * Returns the url to which the matching user agents should get redirected.
   *
   * Uses redirectUrl parameter configured in filters.yml but may be overwritten
   *
   * @return string
   */
  protected function getRedirectUrl()
  {
  	return $this->getParameter('redirectUrl');
  }

  /**
   * Returns a list of request parameter names that should stop/suppress redirection
   *
   * Uses stopParameters parameter configured in filters.yml but may be overwritten
   *
   * @return array
   */
  protected function getStopParameters()
  {
  	return $this->getParameter('stopParameters', array());
  }
}

Then I created a more specialized filter called redirectUserAgentMobileFilter which extends redirectUserAgenFilter and contains a ready-to-use pre-configured list of known mobile user agent strings.

Additionally it can be customized to convey additional information to the redirect target url. In my case it “translates” the requested url into an id and appends ?id=[ID] to the configured redirectUrl.

Integration into your application vai filters.yml:

redirectUserAgentMobile:
  class:  redirectUserAgentMobileFilter
  enabled: on
  param:
    redirectUrl: http://mobile.yourdomain.com?id=%s
    #    userAgents:
    #     - additional
    #     - user agent
    #     - strings

redirectUserAgentMobileFilter.class.php

< ?php
/**
 * Redirect request if it was issued by one of the configured user agents
 * params:
 *  - array userAgents
 *  - string redirectUrl (may contain a %s sprintf placeholder)
 *
  * Example filters.yml integration:
 *
 * <pre>
redirectUserAgentMobile:
  class:  redirectUserAgentMobileFilter
  enabled: on
  param:
    redirectUrl: http://mobile.yourdomain.com?id=%s
    userAgents:
     - additional
     - user agent
     - strings

 *
 */
class redirectUserAgentMobileFilter extends redirectUserAgentFilter
{

	/**
	 * Pre-configured list of mobile user agents.
	 * May be extend using userAgents option in filters.yml
	 *
	 * @var array
	 */
	protected $userAgents = array("240x320","android","benq","blackberry","configuration/cldc","ipod","iphone","midp","mda","mmp/","mot-","netfront","nokia","opera mini","palmos","palmsource","panasonic","philips","phone","pocket pc","portable","portalmmm","sagem","samsung","sda","sgh-","sharp","sie-","sonyericsson","symbian","up.browser","vodafone","web'n'walk","windows ce","xda");

  /**
   * Get the id of the requested content to include it in the redirectUrl
   *
   * @return int | null
   */
  protected function getContentId()
  {
    $contentAsset = $this->getContext()->getRequest()->getSelectedContentAsset();
    if ($contentAsset instanceof contentAsset && $contentAsset->isVisible()) {
      return $contentAsset->remote_id;
    }

    return null;
  }

  /**
   * Get the id of the rubric (first level navigation node) belonging to the requested content to include it in the redirectUrl
   *
   * @return int | null
   */
  protected function getRubricId()
  {
    $contentAsset = $this->getContext()->getRequest()->getSelectedContentAsset();
    if ($contentAsset instanceof contentAsset) {
      $node = $contentAsset->getNode();
      if ($node) {
      	$rubric = $node->getRubricNode();
      	if ($rubric) {
      		$rubricContentAsset = $rubric->getCorrespondingContentAsset();
      		if ($rubricContentAsset) {
      			return $rubricContentAsset->remote_id;
      		}
      	}
      }
    }

    return null;
  }

  /**
   * Get the status code for the current request
   * Possible return values [and explanations]:
   * - 302 [Found]
   * - 404 [Not Found]
   * - 406 [Not Acceptable - not visible in mobile version]
   *
   * @return int
   */
  protected function getStatusCode()
  {
    $contentAsset = $this->getContext()->getRequest()->getSelectedContentAsset();
    if (!$contentAsset instanceof contentAsset ||
        !$contentAsset->isVisible()) {
    	return 404; //Not Found
    }
    elseif (!$contentAsset->getCMSMeta('mobile', true)) {
      return 406; //Not Acceptable
    }

    return 302; //found
  }

	/**
   * Override method
   * @see filter/redirectUserAgentFilter#getRedirectUrl()
   *
   * - include target ID in redirectUrl
   *
   * @return string | null
   */
  protected function getRedirectUrl()
  {
  	$contentId = $this->getContentId();
  	$rubricId = $this->getRubricId();
  	$statusCode = $this->getStatusCode();
		return sprintf(parent::getRedirectUrl(), $contentId, $rubricId, $statusCode);
  }

  /**
   * Override method
   * @see filter/redirectUserAgentFilter#getUserAgents()
   *
   * - merge pre-configuerd mobile user agents {@see $this->userAgents} with those configured using
   *   userAgents option in filters.yml
   */
  protected function getUserAgents()
  {
  	return array_merge(parent::getUserAgents(), $this->userAgents);
  }
}

Unfortunately (or fortunately, because I had not invested too much time in developing the feature, yet), as a digged through the facebook api documentation, I read that this is no longer true:
“For example, we clarified that user data you get from the API is always subject to the restrictions on storage (so you shouldn’t pre-fill data in a form for users to submit to your application if you plan to store that data; users should enter that information directly)” (see http://developers.facebook.com/news.php?blog=1&story=234 or http://www.facebook.com/help/?page=431#!/help.php?page=888)

Then I tested the same with the ZipArchiveImproved Class proposed by Farzad Ghanei (http://de.php.net/manual/de/function.ziparchive-addfile.php#88266) without problems.
I stopped testing after 5000 files without problems.

I tested this on two different machines both running PHP 5.2.6-3ubuntu4.2 with Suhosin-Patch 0.9.6.2

If you need to create a zip file and let the user stream its content while your script is still creating the archive, you should have a look at http://pablotron.org/software/zipstream-php/.

ZipArchiveTest.php:

< ?php
ini_set('memory_limit', '64M');
set_time_limit(0);
require_once 'ZipArchiveImproved.class.php';

$zipFileNamePostfix = empty($_REQUEST['zipFileNamePostfix']) ? 0 : intval($_REQUEST['zipFileNamePostfix']);
$zipFileName = "ZipArchiveTest$zipFileNamePostfix.zip";

$allowedTestFileNames = array('image.jpg', 'image_big.jpg');
$testFileName = empty($_REQUEST['testFileName']) ? $allowedTestFileNames[0] : $_REQUEST['testFileName'];
if (!in_array($testFileName, $allowedTestFileNames)) {
$testFileName = $allowedTestFileNames[0];
}
$limit = empty($_REQUEST['limit']) ? 1 : intval($_REQUEST['limit']);
$limit = min(10000, $limit);

$allowedZipArchiveClassNames = array('ZipArchive', 'ZipArchiveImproved');
$zipArchiveClassName = empty($_REQUEST['zipArchiveClassName']) ? $allowedZipArchiveClassNames[0] : $_REQUEST['zipArchiveClassName'];
if (!in_array($zipArchiveClassName, $allowedZipArchiveClassNames)) {
$zipArchiveClassName = $allowedZipArchiveClassNames[0];
}
?>
Test adding < ?php echo $limit; ?> times < ?php echo $testFileName; ?> to <a href="<?php echo $zipFileName; ?>">< ?php echo $zipFileName; ?></a><br />
Test Filesize: < ?php echo filesize($testFileName); ?> Bytes<br />
ZipArchiveClassName: < ?php echo $zipArchiveClassName; ?><br />

< ?php
@unlink($zipFileName);
$zip = new $zipArchiveClassName;
$res = $zip->open($zipFileName, ZipArchive::CREATE);
if ($res === TRUE) {
for ($i=0; $i< $limit; $i++) {
if (!$zip->addFile($testFileName, "$i.$testFileName")) {
echo "Failed to add {$i}th $testFileName<br />\n";
break;
};
}
if ($zip->close()) {
echo "Successfully closed zip resource<br />\n";
echo "Zip Filesize after test: ".filesize($zipFileName)."<br />\n";
} else {
echo "Failed to close zip resource<br />\n";
};
}

ZipArchiveImproved.class.php

< ?php
/**
* ZipArchiveImproved extends ZipArchive to add some information about the zip file and some functionality.
* See http://de.php.net/manual/de/function.ziparchive-addfile.php#88266
*
*
* @author Farzad Ghanei
* @uses ZipArchive
* @version 1.0.0 2009-01-18
*/

class ZipArchiveImproved extends ZipArchive {
protected $_archiveFileName = null;
protected $_newAddedFilesCounter = 0;
protected $_newAddedFilesSize = 100;

/**
* returns the name of the archive file.
*
* @return string
*/
public function getArchiveFileName() {
return $this->_archiveFileName;
}

/**
* returns the number of files that are going to be added to ZIP
* without reopenning the stream to file.
*
* @return int
*/
public function getNewAddedFilesSize() {
return $this->_newAddedFilesSize;
}

/**
* sets the number of files that are going to be added to ZIP
* without reopenning the stream to file. if no size is specified, default is 100.
*
* @param int
* @return ZipArchiveImproved self reference
*/
public function setNewlAddedFilesSize($size=100) {
if ( empty($size) || !is_int($size) || $size < 1) {
$size = 100;
}
$this->_newAddedFilesSize = $size;
return $this;
}

/**
* opens a stream to a ZIP archive file. calls the ZipArchive::open() internally.
* overwrites ZipArchive::open() to add the archiveFileName functionality.
*
* @param string $fileName
* @param int $flags
* return mixed
*/
public function open($fileName, $flags) {
$this->_archiveFileName = $fileName;
$this->_newAddedFilesCounter = 0;
return parent::open($fileName,$flags);
}

/**
* closes the stream to ZIP archive file. calls the ZipArchive::close() internally.
* overwrites ZipArchive::close() to add the archiveFileName functionality.
*
* @return bool
*/
public function close() {
$this->_archiveFileName = null;
$this->_newAddedFilesCounter = 0;
return parent::close();
}

/**
* closes the connection to ZIP file and openes the connection again.
*
* @return bool
*/
public function reopen() {
$archiveFileName = $this->_archiveFileName;
if ( !$this->close() ) {
return false;
}
return $this->open($archiveFileName,self::CREATE);
}

/**
* adds a file to a ZIP archive from the given path. calls the ZipArchive::addFile() internally.
* overwrites ZipArchive::addFile() to handle maximum file connections in operating systems.
*
* @param string $fileName the path to file to be added to archive
* @param string [optional] $localname the name of the file in the ZIP archive
* @return bool
*/
public function addFile( $fileName ) {
if ($this->_newAddedFilesCounter >= $this->_newAddedFilesSize) {
$this->reopen();
}
if ( func_num_args() > 1 ) {
$flags = func_get_arg(1);
$added = parent::addFile($fileName,$flags);
if ($added) {
$this->_newAddedFilesCounter++;
}
return $added;
}
$added = parent::addFile($fileName);
if ($added) {
$this->_newAddedFilesCounter++;
}
return $added;
} // public function addFile()
}

Detailed Test Report:

ZipArchive Class Tests

image.jpg Tests

ZipArchiveTest.php?limit=1012&testFileName=image.jpg
Test adding 1012 times image.jpg to ZipArchiveTest0.zip
Test Filesize: 4370 Bytes
ZipArchiveClassName: ZipArchive
Successfully closed zip resource
Zip Filesize after test: 4376726
—
ZipArchiveTest.php?limit=1013&testFileName=image.jpg
Test adding 1013 times image.jpg to ZipArchiveTest0.zip
Test Filesize: 4370 Bytes
ZipArchiveClassName: ZipArchive
Failed to close zip resource

image_big.jpg Tests

ZipArchiveTest.php?limit=1012&testFileName=image_big.jpg
Test adding 1012 times image_big.jpg to ZipArchiveTest0.zip
Test Filesize: 27673 Bytes
ZipArchiveClassName: ZipArchive
Successfully closed zip resource
Zip Filesize after test: 27837922
—
ZipArchiveTest.php?limit=1013&testFileName=image_big.jpg
Test adding 1013 times image_big.jpg to ZipArchiveTest0.zip
Test Filesize: 27673 Bytes
ZipArchiveClassName: ZipArchive
Failed to close zip resource

ZipArchiveImproved Class Tests

ZipArchiveTest.php?limit=1014&testFileName=image_big.jpg&zipArchiveClassName=ZipArchiveImproved
Test adding 1014 times image_big.jpg to ZipArchiveTest0.zip
Test Filesize: 27673 Bytes
ZipArchiveClassName: ZipArchiveImproved
Successfully closed zip resource
Zip Filesize after test: 27892942