interface/modules/zend_modules/library/Zend/Filter/Compress/Tar.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Filter\Compress;
  11
  12 use Archive_Tar;
  13 use RecursiveDirectoryIterator;
  14 use RecursiveIteratorIterator;
  15 use Zend\Filter\Exception;
  16
  17 /**
  18  * Compression adapter for Tar
  19  */
  20 class Tar extends AbstractCompressionAlgorithm
  21 {
  22     /**
  23      * Compression Options
  24      * array(
  25      *     'archive'  => Archive to use
  26      *     'target'   => Target to write the files to
  27      * )
  28      *
  29      * @var array
  30      */
  31     protected $options = array(
  32         'archive'  => null,
  33         'target'   => '.',
  34         'mode'     => null,
  35     );
  36
  37     /**
  38      * Class constructor
  39      *
  40      * @param array $options (Optional) Options to set
  41      * @throws Exception\ExtensionNotLoadedException if Archive_Tar component not available
  42      */
  43     public function __construct($options = null)
  44     {
  45         if (!class_exists('Archive_Tar')) {
  46             throw new Exception\ExtensionNotLoadedException(
  47                 'This filter needs PEAR\'s Archive_Tar component. '
  48                 . 'Ensure loading Archive_Tar (registering autoload or require_once)');
  49         }
  50
  51         parent::__construct($options);
  52     }
  53
  54     /**
  55      * Returns the set archive
  56      *
  57      * @return string
  58      */
  59     public function getArchive()
  60     {
  61         return $this->options['archive'];
  62     }
  63
  64     /**
  65      * Sets the archive to use for de-/compression
  66      *
  67      * @param  string $archive Archive to use
  68      * @return self
  69      */
  70     public function setArchive($archive)
  71     {
  72         $archive = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, (string) $archive);
  73         $this->options['archive'] = $archive;
  74
  75         return $this;
  76     }
  77
  78     /**
  79      * Returns the set target path
  80      *
  81      * @return string
  82      */
  83     public function getTarget()
  84     {
  85         return $this->options['target'];
  86     }
  87
  88     /**
  89      * Sets the target path to use
  90      *
  91      * @param  string $target
  92      * @return self
  93      * @throws Exception\InvalidArgumentException if target path does not exist
  94      */
  95     public function setTarget($target)
  96     {
  97         if (!file_exists(dirname($target))) {
  98             throw new Exception\InvalidArgumentException("The directory '$target' does not exist");
  99         }
 100
 101         $target = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, (string) $target);
 102         $this->options['target'] = $target;
 103         return $this;
 104     }
 105
 106     /**
 107      * Returns the set compression mode
 108      *
 109      * @return string
 110      */
 111     public function getMode()
 112     {
 113         return $this->options['mode'];
 114     }
 115
 116     /**
 117      * Compression mode to use
 118      *
 119      * Either Gz or Bz2.
 120      *
 121      * @param string $mode
 122      * @return self
 123      * @throws Exception\InvalidArgumentException for invalid $mode values
 124      * @throws Exception\ExtensionNotLoadedException if bz2 mode selected but extension not loaded
 125      * @throws Exception\ExtensionNotLoadedException if gz mode selected but extension not loaded
 126      */
 127     public function setMode($mode)
 128     {
 129         $mode = ucfirst(strtolower($mode));
 130         if (($mode != 'Bz2') && ($mode != 'Gz')) {
 131             throw new Exception\InvalidArgumentException("The mode '$mode' is unknown");
 132         }
 133
 134         if (($mode == 'Bz2') && (!extension_loaded('bz2'))) {
 135             throw new Exception\ExtensionNotLoadedException('This mode needs the bz2 extension');
 136         }
 137
 138         if (($mode == 'Gz') && (!extension_loaded('zlib'))) {
 139             throw new Exception\ExtensionNotLoadedException('This mode needs the zlib extension');
 140         }
 141
 142         $this->options['mode'] = $mode;
 143         return $this;
 144     }
 145
 146     /**
 147      * Compresses the given content
 148      *
 149      * @param  string $content
 150      * @return string
 151      * @throws Exception\RuntimeException if unable to create temporary file
 152      * @throws Exception\RuntimeException if unable to create archive
 153      */
 154     public function compress($content)
 155     {
 156         $archive = new Archive_Tar($this->getArchive(), $this->getMode());
 157         if (!file_exists($content)) {
 158             $file = $this->getTarget();
 159             if (is_dir($file)) {
 160                 $file .= DIRECTORY_SEPARATOR . "tar.tmp";
 161             }
 162
 163             $result = file_put_contents($file, $content);
 164             if ($result === false) {
 165                 throw new Exception\RuntimeException('Error creating the temporary file');
 166             }
 167
 168             $content = $file;
 169         }
 170
 171         if (is_dir($content)) {
 172             // collect all file infos
 173             foreach (new RecursiveIteratorIterator(
 174                         new RecursiveDirectoryIterator($content, RecursiveDirectoryIterator::KEY_AS_PATHNAME),
 175                         RecursiveIteratorIterator::SELF_FIRST
 176                     ) as $directory => $info
 177             ) {
 178                 if ($info->isFile()) {
 179                     $file[] = $directory;
 180                 }
 181             }
 182
 183             $content = $file;
 184         }
 185
 186         $result  = $archive->create($content);
 187         if ($result === false) {
 188             throw new Exception\RuntimeException('Error creating the Tar archive');
 189         }
 190
 191         return $this->getArchive();
 192     }
 193
 194     /**
 195      * Decompresses the given content
 196      *
 197      * @param  string $content
 198      * @return string
 199      * @throws Exception\RuntimeException if unable to find archive
 200      * @throws Exception\RuntimeException if error occurs decompressing archive
 201      */
 202     public function decompress($content)
 203     {
 204         $archive = $this->getArchive();
 205         if (empty($archive) || !file_exists($archive)) {
 206             throw new Exception\RuntimeException('Tar Archive not found');
 207         }
 208
 209         $archive = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, realpath($content));
 210         $archive = new Archive_Tar($archive, $this->getMode());
 211         $target  = $this->getTarget();
 212         if (!is_dir($target)) {
 213             $target = dirname($target) . DIRECTORY_SEPARATOR;
 214         }
 215
 216         $result = $archive->extract($target);
 217         if ($result === false) {
 218             throw new Exception\RuntimeException('Error while extracting the Tar archive');
 219         }
 220
 221         return $target;
 222     }
 223
 224     /**
 225      * Returns the adapter name
 226      *
 227      * @return string
 228      */
 229     public function toString()
 230     {
 231         return 'Tar';
 232     }
 233 }