FileHandlerDefinition.php

<?php

namespace AC\Transcoding;

/**
 * FileHandlerDefinition's define valid input/output file type properties for a preset and/or adapter. The FileHandlerDefinition is checked by the Transcoder before executing.
 *
 * @package Transcoding
 * @author Evan Villemez
 */
class FileHandlerDefinition implements \Serializable
{
 //input type restrictions
 protected $allowedExtensions = false;
 protected $rejectedExtensions = false;
 protected $allowedMimes = false;
 protected $rejectedMimes = false;
 protected $allowedMimeTypes = false;
 protected $rejectedMimeTypes = false;
 protected $allowedMimeEncodings = false;
 protected $rejectedMimeEncodings = false;

 //general i/o type
 protected $allowDirectory = true;
 protected $inheritOutputPathExtension = true;
 protected $requiredExtension = false;
 protected $inheritInputExtension = false;
 protected $requiredType = false;

 /**
 * Optionally set any properties via a hash in the constructor instead of using setter methods
 *
 * @param array $ops - optional key/val hash
 */
 public function __construct($ops = array())
 {
 $this->setOptions($ops);
 }

 /**
 * Return boolean for whether or not the FileHandlerDefinition will accept a given file.
 *
 * @param File $file
 * @return boolean
 */
 public function acceptsFile(File $file)
 {
 try {
 return $this->validateFile($file);
 } catch (\Exception $e) {
 return false;
 }
 }

 /**
 * Return true if FileHandlerDefinition accepts a given file, otherwise throw an exception on failure.
 *
 * @param File $file
 * @return boolean
 */
 public function validateFile(File $file)
 {
 if (!$this->acceptsExtension($file->getExtension())) {
 throw new Exception\InvalidFileException(sprintf("This definition does not accept files with extension %s", $file->getExtension()));
 }

 if (!$this->acceptsMime($file->getMime())) {
 throw new Exception\InvalidFileException(sprintf("This definition does not accept files with mime of %s", $file->getMime()));
 }

 if (!$this->acceptsMimeType($file->getMimeType())) {
 throw new Exception\InvalidFileException(sprintf("This definition does not accept files with mime type of %s", $file->getMimeType()));
 }

 if (!$this->acceptsMimeEncoding($file->getMimeEncoding())) {
 throw new Exception\InvalidFileException(sprintf("This definition does not accept files with mime encoding of %s", $file->getMimeEncoding()));
 }

 if ($this->getRequiredType()) {
 if ($this->getRequiredType() !== $file->getType()) {
 throw new Exception\InvalidFileException(sprintf("This definition only accept files of type %s", $this->getRequiredType()));
 }
 }

 if (!$this->getAllowDirectory() && $file->isDir()) {
 throw new Exception\InvalidFileException("This definition cannot accept a directory as input");
 }

 return true;
 }

 /**
 * Return true/false for whether or not the handler accepts a given extension.
 *
 * @param string $ext - string extension, if a preceeding "." is provided, it's automatically stripped
 * @return boolean
 */
 public function acceptsExtension($ext)
 {
 $ext = trim(strtolower($ext), ".");

 if ($this->getRequiredExtension() && $ext !== $this->getRequiredExtension()) {
 return false;
 }

 if ($this->getAllowedExtensions() && !in_array($ext, $this->getAllowedExtensions())) {
 return false;
 }

 if ($this->getRejectedExtensions() && in_array($ext, $this->getRejectedExtensions())) {
 return false;
 }

 return true;
 }

 /**
 * Return true/false for whether or not the handler accepts a given mime.
 *
 * @return boolean
 */
 public function acceptsMime($ext)
 {
 if ($this->getAllowedMimes() && !in_array($ext, $this->getAllowedMimes())) {
 return false;
 }

 if ($this->getRejectedMimes() && in_array($ext, $this->getRejectedMimes())) {
 return false;
 }

 return true;
 }

 /**
 * Return true/false for whether or not the handler accepts a given mime type.
 *
 * @return boolean
 */
 public function acceptsMimeType($ext)
 {
 if ($this->getAllowedMimeTypes() && !in_array($ext, $this->getAllowedMimeTypes())) {
 return false;
 }

 if ($this->getRejectedMimeTypes() && in_array($ext, $this->getRejectedMimeTypes())) {
 return false;
 }

 return true;
 }

 /**
 * Return true/false for whether or not the handler accepts a given mime encoding.
 *
 * @return boolean
 */
 public function acceptsMimeEncoding($ext)
 {
 if ($this->getAllowedMimeEncodings() && !in_array($ext, $this->getAllowedMimeEncodings())) {
 return false;
 }

 if ($this->getRejectedMimeEncodings() && in_array($ext, $this->getRejectedMimeEncodings())) {
 return false;
 }

 return true;
 }

 /**
 * Set a specific required extension
 *
 * @param string $ext
 * @return self
 */
 public function setRequiredExtension($ext)
 {
 $this->requiredExtension = ltrim(strtolower($ext), ".");

 return $this;
 }

 /**
 * Get required file extension
 *
 * @return string or false
 */
 public function getRequiredExtension()
 {
 return $this->requiredExtension;
 }

 /**
 * Return true/false for whether or not the handler shoud inhert a file extension from another file. Generally this is only used when checking
 * output file definitions and generating valid output file paths
 *
 * @return boolean
 */
 public function getInheritInputExtension()
 {
 return $this->inheritInputExtension;
 }

 /**
 * Set true/false whether or not to inherit an output extension, only used for output definitions to help in generating a valid output path
 *
 * @param bool $bool
 * @return self
 */
 public function setInheritInputExtension($bool)
 {
 $this->inheritInputExtension = (bool) $bool;

 return $this;
 }

 /**
 * Get whether or not the output extension should be inherited from the specified outgoing filepath
 *
 * @return bool
 */
 public function getInheritOutputPathExtension()
 {
 return $this->inheritOutputPathExtension;
 }

 /**
 * Set whether or not the output extension should be inherited from a specified output file path
 *
 * @param bool $bool
 * @return self
 */
 public function setInheritOutputPathExtension($bool)
 {
 $this->inheritOutputPathExtension = (bool) $bool;

 return $this;
 }

 /**
 * Return boolean for whether or not directories count as valid input
 *
 * @return boolean
 */
 public function getAllowDirectory()
 {
 return $this->allowDirectory;
 }

 /**
 * Set true/false whether or not to allow directories as input
 *
 * @param bool $bool
 * @return self
 */
 public function setAllowDirectory($bool)
 {
 $this->allowDirectory = (bool) $bool;

 return $this;
 }

 /**
 * Get required input file type, can be either 'file' or 'directory'
 *
 * @return string
 */
 public function getRequiredType()
 {
 return $this->requiredType;
 }

 /**
 * Set required file input type, must be either 'file' or 'directory'
 *
 * @param string $type
 * @return self
 */
 public function setRequiredType($type)
 {
 if (!in_array($type, array('file', 'directory'))) {
 throw new \InvalidArgumentException("Input type must be either 'file' or 'directory'.");
 }

 if ($type === 'directory') {
 $this->setAllowDirectory(true);
 } else {
 $this->setAllowDirectory(false);
 }

 $this->requiredType = $type;

 return $this;
 }

 /**
 * type restriction getter/setter methods below
 */

 public function getAllowedExtensions()
 {
 return $this->allowedExtensions;
 }

 public function setAllowedExtensions(array $arr)
 {
 $this->allowedExtensions = $arr;

 return $this;
 }

 public function getAllowedMimes()
 {
 return $this->allowedMimes;
 }

 public function setAllowedMimes(array $arr)
 {
 $this->allowedMimes = $arr;

 return $this;
 }

 public function getAllowedMimeTypes()
 {
 return $this->allowedMimeTypes;
 }

 public function setAllowedMimeTypes(array $arr)
 {
 $this->allowedMimeTypes = $arr;

 return $this;
 }

 public function getAllowedMimeEncodings()
 {
 return $this->allowedMimeEncodings;
 }

 public function setAllowedMimeEncodings(array $arr)
 {
 $this->allowedMimeEncodings = $arr;

 return $this;
 }

 public function getRejectedExtensions()
 {
 return $this->rejectedExtensions;
 }

 public function setRejectedExtensions(array $arr)
 {
 $this->rejectedExtensions = $arr;

 return $this;
 }

 public function getRejectedMimes()
 {
 return $this->rejectedMimes;
 }

 public function setRejectedMimes(array $arr)
 {
 $this->rejectedMimes = $arr;

 return $this;
 }

 public function getRejectedMimeTypes()
 {
 return $this->rejectedMimeTypes;
 }

 public function setRejectedMimeTypes(array $arr)
 {
 $this->rejectedMimeTypes = $arr;

 return $this;
 }

 public function getRejectedMimeEncodings()
 {
 return $this->rejectedMimeEncodings;
 }

 public function setRejectedMimeEncodings(array $arr)
 {
 $this->rejectedMimeEncodings = $arr;

 return $this;
 }

 /**
 * Set multiple properties as a key/val hash in one operation.
 *
 * @param array $ops
 * @return self
 */
 public function setOptions(array $ops)
 {
 foreach ($ops as $key => $val) {
 $this->$key = $val;
 }

 return $this;
 }

 public function serialize()
 {
 $data = array();
 foreach ($this as $key => $val) {
 $data[$key] = $val;
 }

 return serialize($data);
 }

 public function unserialize($string)
 {
 $data = unserialize($string);
 $this->setOptions($data);
 }
}