package.xml 0000644 0001750 0000144 00000021330 11722231646 012547 0 ustar cweiske users
MIME_Type
pear.php.net
Utility class for dealing with MIME types
Provide functionality for dealing with MIME types.
* Parse MIME type.
* Supports full RFC2045 specification.
* Many utility functions for working with and determining info about types.
* Most functions can be called statically.
* Autodetect a file's mime-type, either with fileinfo extension,
mime_magic extension, the 'file' command or an in-built mapping list
Ian Eure
ieure
ieure@php.net
no
Christian Weiske
cweiske
cweiske@php.net
yes
2012-02-25
1.3.1
1.3.0
stable
stable
LGPL
- Change license from PHP to LGPL
4.3.0
1.4.0
PEAR
pear.php.net
1.4.0
System_Command
pear.php.net
1.0.0beta1
1.0.0beta1
beta
beta
2004-04-16
PHP License 3.0
Initial PEARification
* Split most functionality off from MIME_ContentType
1.0.0beta2
1.0.0beta2
beta
beta
2004-06-16
PHP License 3.0
* Make changes as requested during the proposal/vote process.
1.0.0beta3
1.0.0beta3
beta
beta
2004-08-07
PHP License 3.0
* Add $parameters class var. (Fixes #2083)
* Quote filenames in _fileAutoDetect() (Fixes #2078)
1.0.0
1.0.0
stable
stable
2005-01-26
PHP License 3.0
- No changes since 1.0.0beta3.
1.1.0
1.1.0
stable
stable
2007-03-25
PHP License 3.0
- Implementing request #3719: Use several methods when detecting mime type
- Fixing bug #6095: Parameters and comments parsing buggy
- Fixing bug #8603: function _fileAutoDetect() uses System_Command incorrectly
- Make example.php check for errors when detecting.
- Adding unit tests
1.1.1
1.1.0
stable
stable
2008-07-24
PHP License 3.0
- Fix #14150, notices due to use of =& new.
1.1.2
1.1.2
stable
stable
2008-08-01
PHP License 3.0
- Fix bug #14417: Remove "&$comments = null" since that's not supported
in PHP4.
1.1.3
1.1.2
stable
stable
2008-08-03
PHP License 3.0
- Coding Standards cleanup
- parameters are cleared when parsing again
- more tests
1.2.0
1.2.0
stable
stable
2009-01-16
PHP License 3.0
* Extension-to-MIMEType mapper by Christian Schmidt, bug #13646
1.2.1
1.2.0
stable
stable
2010-10-25
PHP License 3.0
Automatically built QA release
Req #13646 Default to Mime Type based on Extension - cweiske
1.3.0
1.3.0
stable
stable
2011-09-05
PHP License 3.0
- Implement request #17969: Configurable magic database file
- Fix bug #17969: Fall back to next method after file command error
- Single detection methods may be disabled
1.3.1
1.3.0
stable
stable
2012-02-25
LGPL
- Change license from PHP to LGPL
MIME_Type-1.3.1/docs/examples/example.php 0000644 0001750 0000144 00000001332 11722231646 017532 0 ustar cweiske users getMessage() . "\n";
} else {
print $type . "\n";
}
?>
MIME_Type-1.3.1/docs/examples/custom-magic.php 0000644 0001750 0000144 00000000642 11722231646 020472 0 ustar cweiske users magicFile = dirname(__FILE__) . '/custom-magic.magic';
$type = $mt->autoDetect(dirname(__FILE__) . '/custom-magic.php');
echo 'Type: ' . $type . "\n";
echo 'Media: ' . $mt->media . "\n";
echo 'Subtype: ' . $mt->subType . "\n";
?> MIME_Type-1.3.1/docs/examples/custom-magic.magic 0000644 0001750 0000144 00000000137 11722231646 020762 0 ustar cweiske users 0 search/1/c =
* @license http://www.gnu.org/copyleft/lesser.html LGPL
* @link http://pear.php.net/package/MIME_Type
*/
require_once 'PEAR.php';
$_fileCmd = &PEAR::getStaticProperty('MIME_Type', 'fileCmd');
$_fileCmd = 'file';
/**
* Class for working with MIME types
*
* @category MIME
* @package MIME_Type
* @author Ian Eure
* @license http://www.gnu.org/copyleft/lesser.html LGPL
* @version Release: @version@
* @link http://pear.php.net/package/MIME_Type
*/
class MIME_Type
{
/**
* The MIME media type
*
* @var string
*/
var $media = '';
/**
* The MIME media sub-type
*
* @var string
*/
var $subType = '';
/**
* Optional MIME parameters
*
* @var array
*/
var $parameters = array();
/**
* List of valid media types.
* A media type is the string in front of the slash.
* The media type of "text/xml" would be "text".
*
* @var array
*/
var $validMediaTypes = array(
'text',
'image',
'audio',
'video',
'application',
'multipart',
'message'
);
/**
* If the finfo functions shall be used when they are available
*
* @var boolean
*/
var $useFinfo = true;
/**
* If mime_content_type shall be used when available
*
* @var boolean
*/
var $useMimeContentType = true;
/**
* If the file command shall be used when available
*
* @var boolean
*/
var $useFileCmd = true;
/**
* If the in-built file extension detection shall be used
*
* @var boolean
*/
var $useExtension = true;
/**
* Path to the "magic" file database.
* If NULL, the default one is used
*
* @var string
*/
var $magicFile = null;
/**
* Constructor.
*
* If $type is set, if will be parsed and the appropriate class vars set.
* If not, you get an empty class.
* This is useful, but not quite as useful as parsing a type.
*
* @param string $type MIME type
*
* @return void
*/
function MIME_Type($type = false)
{
if ($type) {
$this->parse($type);
}
}
/**
* Parse a mime-type and set the class variables.
*
* @param string $type MIME type to parse
*
* @return boolean True if the type has been parsed, false if not
*/
function parse($type)
{
if ($type instanceof PEAR_Error) {
return false;
}
$this->media = $this->getMedia($type);
$this->subType = $this->getSubType($type);
$this->parameters = array();
if (MIME_Type::hasParameters($type)) {
include_once 'MIME/Type/Parameter.php';
foreach (MIME_Type::getParameters($type) as $param) {
$param = new MIME_Type_Parameter($param);
$this->parameters[$param->name] = $param;
}
}
return true;
}
/**
* Does this type have any parameters?
*
* @param string $type MIME type to check
*
* @return boolean true if $type has parameters, false otherwise
* @static
*/
function hasParameters($type)
{
if (strstr($type, ';')) {
return true;
}
return false;
}
/**
* Get a MIME type's parameters
*
* @param string $type MIME type to get parameters of
*
* @return array $type's parameters
* @static
*/
function getParameters($type)
{
$params = array();
$tmp = explode(';', $type);
for ($i = 1; $i < count($tmp); $i++) {
$params[] = trim($tmp[$i]);
}
return $params;
}
/**
* Strip parameters from a MIME type string.
*
* @param string $type MIME type string
*
* @return string MIME type with parameters removed
* @static
*/
function stripParameters($type)
{
if (strstr($type, ';')) {
return substr($type, 0, strpos($type, ';'));
}
return $type;
}
/**
* Removes comments from a media type, subtype or parameter.
*
* @param string $string String to strip comments from
* @param string &$comment Comment is stored in there.
* Do not set it to NULL if you want the comment.
*
* @return string String without comments
* @static
*/
function stripComments($string, &$comment)
{
if (strpos($string, '(') === false) {
return $string;
}
$inquote = false;
$escaped = false;
$incomment = 0;
$newstring = '';
for ($n = 0; $n < strlen($string); $n++) {
if ($escaped) {
if ($incomment == 0) {
$newstring .= $string[$n];
} else if ($comment !== null) {
$comment .= $string[$n];
}
$escaped = false;
} else if ($string[$n] == '\\') {
$escaped = true;
} else if (!$inquote && $incomment > 0 && $string[$n] == ')') {
$incomment--;
if ($incomment == 0 && $comment !== null) {
$comment .= ' ';
}
} else if (!$inquote && $string[$n] == '(') {
$incomment++;
} else if ($string[$n] == '"') {
if ($inquote) {
$inquote = false;
} else {
$inquote = true;
}
} else if ($incomment == 0) {
$newstring .= $string[$n];
} else if ($comment !== null) {
$comment .= $string[$n];
}
}
if ($comment !== null) {
$comment = trim($comment);
}
return $newstring;
}
/**
* Get a MIME type's media
* Note: 'media' refers to the portion before the first slash
*
* @param string $type MIME type to get media of
*
* @return string $type's media
* @static
*/
function getMedia($type)
{
$tmp = explode('/', $type);
return strtolower(trim(MIME_Type::stripComments($tmp[0], $null)));
}
/**
* Get a MIME type's subtype
*
* @param string $type MIME type to get subtype of
*
* @return string $type's subtype, null if invalid mime type
* @static
*/
function getSubType($type)
{
$tmp = explode('/', $type);
if (!isset($tmp[1])) {
return null;
}
$tmp = explode(';', $tmp[1]);
return strtolower(trim(MIME_Type::stripComments($tmp[0], $null)));
}
/**
* Create a textual MIME type from object values
*
* This function performs the opposite function of parse().
*
* @return string MIME type string
*/
function get()
{
$type = strtolower($this->media . '/' . $this->subType);
if (count($this->parameters)) {
foreach ($this->parameters as $key => $null) {
$type .= '; ' . $this->parameters[$key]->get();
}
}
return $type;
}
/**
* Is this type experimental?
*
* Note: Experimental types are denoted by a leading 'x-' in the media or
* subtype, e.g. text/x-vcard or x-world/x-vrml.
*
* @param string $type MIME type to check
*
* @return boolean true if $type is experimental, false otherwise
* @static
*/
function isExperimental($type)
{
if (substr(MIME_Type::getMedia($type), 0, 2) == 'x-'
|| substr(MIME_Type::getSubType($type), 0, 2) == 'x-'
) {
return true;
}
return false;
}
/**
* Is this a vendor MIME type?
*
* Note: Vendor types are denoted with a leading 'vnd. in the subtype.
*
* @param string $type MIME type to check
*
* @return boolean true if $type is a vendor type, false otherwise
* @static
*/
function isVendor($type)
{
if (substr(MIME_Type::getSubType($type), 0, 4) == 'vnd.') {
return true;
}
return false;
}
/**
* Is this a wildcard type?
*
* @param string $type MIME type to check
*
* @return boolean true if $type is a wildcard, false otherwise
* @static
*/
function isWildcard($type)
{
if ($type == '*/*' || MIME_Type::getSubtype($type) == '*') {
return true;
}
return false;
}
/**
* Perform a wildcard match on a MIME type
*
* Example:
* MIME_Type::wildcardMatch('image/*', 'image/png')
*
* @param string $card Wildcard to check against
* @param string $type MIME type to check
*
* @return boolean true if there was a match, false otherwise
* @static
*/
function wildcardMatch($card, $type)
{
if (!MIME_Type::isWildcard($card)) {
return false;
}
if ($card == '*/*') {
return true;
}
if (MIME_Type::getMedia($card) == MIME_Type::getMedia($type)) {
return true;
}
return false;
}
/**
* Add a parameter to this type
*
* @param string $name Attribute name
* @param string $value Attribute value
* @param string $comment Comment for this parameter
*
* @return void
*/
function addParameter($name, $value, $comment = false)
{
$tmp = new MIME_Type_Parameter();
$tmp->name = $name;
$tmp->value = $value;
$tmp->comment = $comment;
$this->parameters[$name] = $tmp;
}
/**
* Remove a parameter from this type
*
* @param string $name Parameter name
*
* @return void
*/
function removeParameter($name)
{
unset($this->parameters[$name]);
}
/**
* Autodetect a file's MIME-type
*
* This function may be called staticly.
*
* @param string $file Path to the file to get the type of
* @param bool $params Append MIME parameters if true
*
* @return string $file's MIME-type on success, PEAR_Error otherwise
*
* @since 1.0.0beta1
* @static
*/
function autoDetect($file, $params = false)
{
$isStatic = !(isset($this) && get_class($this) == __CLASS__);
if ($isStatic) {
$t = new MIME_Type();
return $t->_autoDetect($file, $params);
} else {
$type = $this->_autoDetect($file, $params);
if (!$type instanceof PEAR_Error) {
$this->parse($type);
}
return $type;
}
}
/**
* Autodetect a file's MIME-type
*
* @param string $file Path to the file to get the type of
* @param bool $params Append MIME parameters if true
*
* @return string $file's MIME-type on success, PEAR_Error otherwise
*
* @since 1.3.0
*
* @internal Tries to use fileinfo extension at first. If that
* does not work, mime_magic is used. If this is also not available
* or does not succeed, "file" command is tried to be executed with
* System_Command. When that fails, too, then we use our in-built
* extension-to-mimetype-mapping list.
*/
function _autoDetect($file, $params = false)
{
// Sanity checks
if (!file_exists($file)) {
return PEAR::raiseError("File \"$file\" doesn't exist");
}
if (!is_readable($file)) {
return PEAR::raiseError("File \"$file\" is not readable");
}
if ($this->useFinfo && function_exists('finfo_file')) {
$finfo = finfo_open(FILEINFO_MIME, $this->magicFile);
if ($finfo) {
$type = finfo_file($finfo, $file);
finfo_close($finfo);
if ($type !== false && $type !== '') {
return MIME_Type::_handleDetection($type, $params);
}
}
}
if ($this->useMimeContentType && function_exists('mime_content_type')) {
$type = mime_content_type($file);
if ($type !== false && $type !== '') {
return MIME_Type::_handleDetection($type, $params);
}
}
if ($this->useFileCmd) {
@include_once 'System/Command.php';
if (class_exists('System_Command')) {
$type = MIME_Type::_fileAutoDetect($file);
if ($type !== false && $type !== '') {
return MIME_Type::_handleDetection($type, $params);
}
}
}
if ($this->useExtension) {
include_once 'MIME/Type/Extension.php';
$mte = new MIME_Type_Extension();
return $mte->getMIMEType($file);
}
return PEAR::raiseError("Sorry, couldn't determine file type.");
}
/**
* Handles a detected MIME type and modifies it if necessary.
*
* @param string $type MIME Type of a file
* @param bool $params Append MIME parameters if true
*
* @return string $file's MIME-type on success, PEAR_Error otherwise
* @static
*/
function _handleDetection($type, $params)
{
// _fileAutoDetect() may have returned an error.
if (PEAR::isError($type)) {
return $type;
}
// Don't return an empty string
if (!$type || !strlen($type)) {
return PEAR::raiseError("Sorry, couldn't determine file type.");
}
// Strip parameters if present & requested
if (MIME_Type::hasParameters($type) && !$params) {
$type = MIME_Type::stripParameters($type);
}
return $type;
}
/**
* Autodetect a file's MIME-type with 'file' and System_Command
*
* This function may be called staticly.
*
* @param string $file Path to the file to get the type of
*
* @return string $file's MIME-type
*
* @since 1.0.0beta1
* @static
*/
function _fileAutoDetect($file)
{
$cmd = new System_Command();
$magic = '';
// Make sure we have the 'file' command.
$fileCmd = PEAR::getStaticProperty('MIME_Type', 'fileCmd');
if (!$cmd->which($fileCmd)) {
unset($cmd);
return PEAR::raiseError("Can't find file command \"{$fileCmd}\"");
}
if (strlen($this->magicFile)) {
$magic = '--magic-file ' . escapeshellarg($this->magicFile);
}
$cmd->pushCommand($fileCmd, $magic, "-bi " . escapeshellarg($file));
$res = $cmd->execute();
unset($cmd);
return $res;
}
} MIME_Type-1.3.1/MIME/Type/Extension.php 0000644 0001750 0000144 00000030247 11722231646 016764 0 ustar cweiske users
* @license http://www.gnu.org/copyleft/lesser.html LGPL
* @link http://pear.php.net/package/MIME_Type
*/
require_once 'PEAR.php';
/**
* Class for mapping file extensions to MIME types.
*
* @category MIME
* @package MIME_Type
* @author Christian Schmidt
* @license http://www.gnu.org/copyleft/lesser.html LGPL
* @version Release: @version@
* @link http://pear.php.net/package/MIME_Type
*/
class MIME_Type_Extension
{
/**
* Mapping between file extension and MIME type.
*
* @internal The array is sorted alphabetically by value and with primary
* extension first. Be careful about not adding duplicate keys - PHP
* silently ignores duplicates. The following command can be used for
* checking for duplicates:
* grep "=> '" Extension.php | cut -d\' -f2 | sort | uniq -d
* application/octet-stream is generally used as fallback when no other
* MIME-type can be found, but the array does not contain a lot of such
* unknown extension. One entry exists, though, to allow detection of
* file extension for this MIME-type.
*
* @var array
*/
var $extensionToType = array (
'ez' => 'application/andrew-inset',
'atom' => 'application/atom+xml',
'jar' => 'application/java-archive',
'hqx' => 'application/mac-binhex40',
'cpt' => 'application/mac-compactpro',
'mathml' => 'application/mathml+xml',
'doc' => 'application/msword',
'dat' => 'application/octet-stream',
'oda' => 'application/oda',
'ogg' => 'application/ogg',
'pdf' => 'application/pdf',
'ai' => 'application/postscript',
'eps' => 'application/postscript',
'ps' => 'application/postscript',
'rdf' => 'application/rdf+xml',
'rss' => 'application/rss+xml',
'smi' => 'application/smil',
'smil' => 'application/smil',
'gram' => 'application/srgs',
'grxml' => 'application/srgs+xml',
'kml' => 'application/vnd.google-earth.kml+xml',
'kmz' => 'application/vnd.google-earth.kmz',
'mif' => 'application/vnd.mif',
'xul' => 'application/vnd.mozilla.xul+xml',
'xls' => 'application/vnd.ms-excel',
'xlb' => 'application/vnd.ms-excel',
'xlt' => 'application/vnd.ms-excel',
'xlam' => 'application/vnd.ms-excel.addin.macroEnabled.12',
'xlsb' => 'application/vnd.ms-excel.sheet.binary.macroEnabled.12',
'xlsm' => 'application/vnd.ms-excel.sheet.macroEnabled.12',
'xltm' => 'application/vnd.ms-excel.template.macroEnabled.12',
'docm' => 'application/vnd.ms-word.document.macroEnabled.12',
'dotm' => 'application/vnd.ms-word.template.macroEnabled.12',
'ppam' => 'application/vnd.ms-powerpoint.addin.macroEnabled.12',
'pptm' => 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
'ppsm' => 'application/vnd.ms-powerpoint.slideshow.macroEnabled.12',
'potm' => 'application/vnd.ms-powerpoint.template.macroEnabled.12',
'ppt' => 'application/vnd.ms-powerpoint',
'pps' => 'application/vnd.ms-powerpoint',
'odc' => 'application/vnd.oasis.opendocument.chart',
'odb' => 'application/vnd.oasis.opendocument.database',
'odf' => 'application/vnd.oasis.opendocument.formula',
'odg' => 'application/vnd.oasis.opendocument.graphics',
'otg' => 'application/vnd.oasis.opendocument.graphics-template',
'odi' => 'application/vnd.oasis.opendocument.image',
'odp' => 'application/vnd.oasis.opendocument.presentation',
'otp' => 'application/vnd.oasis.opendocument.presentation-template',
'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
'ots' => 'application/vnd.oasis.opendocument.spreadsheet-template',
'odt' => 'application/vnd.oasis.opendocument.text',
'odm' => 'application/vnd.oasis.opendocument.text-master',
'ott' => 'application/vnd.oasis.opendocument.text-template',
'oth' => 'application/vnd.oasis.opendocument.text-web',
'potx' => 'application/vnd.openxmlformats-officedocument.presentationml.template',
'ppsx' => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
'xltx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
'dotx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
'vsd' => 'application/vnd.visio',
'wbxml' => 'application/vnd.wap.wbxml',
'wmlc' => 'application/vnd.wap.wmlc',
'wmlsc' => 'application/vnd.wap.wmlscriptc',
'vxml' => 'application/voicexml+xml',
'bcpio' => 'application/x-bcpio',
'vcd' => 'application/x-cdlink',
'pgn' => 'application/x-chess-pgn',
'cpio' => 'application/x-cpio',
'csh' => 'application/x-csh',
'dcr' => 'application/x-director',
'dir' => 'application/x-director',
'dxr' => 'application/x-director',
'dvi' => 'application/x-dvi',
'spl' => 'application/x-futuresplash',
'tgz' => 'application/x-gtar',
'gtar' => 'application/x-gtar',
'hdf' => 'application/x-hdf',
'js' => 'application/x-javascript',
'skp' => 'application/x-koan',
'skd' => 'application/x-koan',
'skt' => 'application/x-koan',
'skm' => 'application/x-koan',
'latex' => 'application/x-latex',
'nc' => 'application/x-netcdf',
'cdf' => 'application/x-netcdf',
'sh' => 'application/x-sh',
'shar' => 'application/x-shar',
'swf' => 'application/x-shockwave-flash',
'sit' => 'application/x-stuffit',
'sv4cpio' => 'application/x-sv4cpio',
'sv4crc' => 'application/x-sv4crc',
'tar' => 'application/x-tar',
'tcl' => 'application/x-tcl',
'tex' => 'application/x-tex',
'texinfo' => 'application/x-texinfo',
'texi' => 'application/x-texinfo',
't' => 'application/x-troff',
'tr' => 'application/x-troff',
'roff' => 'application/x-troff',
'man' => 'application/x-troff-man',
'me' => 'application/x-troff-me',
'ms' => 'application/x-troff-ms',
'ustar' => 'application/x-ustar',
'src' => 'application/x-wais-source',
'xhtml' => 'application/xhtml+xml',
'xht' => 'application/xhtml+xml',
'xslt' => 'application/xslt+xml',
'xml' => 'application/xml',
'xsl' => 'application/xml',
'dtd' => 'application/xml-dtd',
'zip' => 'application/zip',
'au' => 'audio/basic',
'snd' => 'audio/basic',
'mid' => 'audio/midi',
'midi' => 'audio/midi',
'kar' => 'audio/midi',
'mpga' => 'audio/mpeg',
'mp2' => 'audio/mpeg',
'mp3' => 'audio/mpeg',
'aif' => 'audio/x-aiff',
'aiff' => 'audio/x-aiff',
'aifc' => 'audio/x-aiff',
'm3u' => 'audio/x-mpegurl',
'wma' => 'audio/x-ms-wma',
'wax' => 'audio/x-ms-wax',
'ram' => 'audio/x-pn-realaudio',
'ra' => 'audio/x-pn-realaudio',
'rm' => 'application/vnd.rn-realmedia',
'wav' => 'audio/x-wav',
'pdb' => 'chemical/x-pdb',
'xyz' => 'chemical/x-xyz',
'bmp' => 'image/bmp',
'cgm' => 'image/cgm',
'gif' => 'image/gif',
'ief' => 'image/ief',
'jpeg' => 'image/jpeg',
'jpg' => 'image/jpeg',
'jpe' => 'image/jpeg',
'png' => 'image/png',
'svg' => 'image/svg+xml',
'tiff' => 'image/tiff',
'tif' => 'image/tiff',
'djvu' => 'image/vnd.djvu',
'djv' => 'image/vnd.djvu',
'wbmp' => 'image/vnd.wap.wbmp',
'ras' => 'image/x-cmu-raster',
'ico' => 'image/x-icon',
'pnm' => 'image/x-portable-anymap',
'pbm' => 'image/x-portable-bitmap',
'pgm' => 'image/x-portable-graymap',
'ppm' => 'image/x-portable-pixmap',
'rgb' => 'image/x-rgb',
'xbm' => 'image/x-xbitmap',
'psd' => 'image/x-photoshop',
'xpm' => 'image/x-xpixmap',
'xwd' => 'image/x-xwindowdump',
'eml' => 'message/rfc822',
'igs' => 'model/iges',
'iges' => 'model/iges',
'msh' => 'model/mesh',
'mesh' => 'model/mesh',
'silo' => 'model/mesh',
'wrl' => 'model/vrml',
'vrml' => 'model/vrml',
'ics' => 'text/calendar',
'ifb' => 'text/calendar',
'css' => 'text/css',
'csv' => 'text/csv',
'html' => 'text/html',
'htm' => 'text/html',
'txt' => 'text/plain',
'asc' => 'text/plain',
'rtx' => 'text/richtext',
'rtf' => 'text/rtf',
'sgml' => 'text/sgml',
'sgm' => 'text/sgml',
'tsv' => 'text/tab-separated-values',
'wml' => 'text/vnd.wap.wml',
'wmls' => 'text/vnd.wap.wmlscript',
'etx' => 'text/x-setext',
'mpeg' => 'video/mpeg',
'mpg' => 'video/mpeg',
'mpe' => 'video/mpeg',
'qt' => 'video/quicktime',
'mov' => 'video/quicktime',
'mxu' => 'video/vnd.mpegurl',
'm4u' => 'video/vnd.mpegurl',
'flv' => 'video/x-flv',
'asf' => 'video/x-ms-asf',
'asx' => 'video/x-ms-asf',
'wmv' => 'video/x-ms-wmv',
'wm' => 'video/x-ms-wm',
'wmx' => 'video/x-ms-wmx',
'avi' => 'video/x-msvideo',
'ogv' => 'video/ogg',
'movie' => 'video/x-sgi-movie',
'ice' => 'x-conference/x-cooltalk',
);
/**
* Autodetect a file's MIME-type.
*
* @param string $file Path to the file to get the type of
*
* @return string $file's MIME-type on success, PEAR_Error otherwise
*/
function getMIMEType($file)
{
$extension = substr(strrchr($file, '.'), 1);
if ($extension === false) {
return PEAR::raiseError("File has no extension.");
}
if (!isset($this->extensionToType[$extension])) {
return PEAR::raiseError("Sorry, couldn't determine file type.");
}
return $this->extensionToType[$extension];
}
/**
* Return default MIME-type for the specified extension.
*
* @param string $type MIME-type
*
* @return string A file extension without leading period.
*/
function getExtension($type)
{
include_once 'MIME/Type.php';
// Strip parameters and comments.
$type = MIME_Type::getMedia($type) . '/' . MIME_Type::getSubType($type);
$extension = array_search($type, $this->extensionToType);
if ($extension === false) {
return PEAR::raiseError("Sorry, couldn't determine extension.");
}
return $extension;
}
}
?> MIME_Type-1.3.1/MIME/Type/Parameter.php 0000644 0001750 0000144 00000006653 11722231646 016734 0 ustar cweiske users
* @license http://www.gnu.org/copyleft/lesser.html LGPL
* @link http://pear.php.net/package/MIME_Type
*/
/**
* Class for working with MIME type parameters
*
* @category File
* @package MIME_Type
* @author Ian Eure
* @license http://www.gnu.org/copyleft/lesser.html LGPL
* @version Release: @version@
* @link http://pear.php.net/package/MIME_Type
*/
class MIME_Type_Parameter
{
/**
* Parameter name
*
* @var string
*/
var $name;
/**
* Parameter value
*
* @var string
*/
var $value;
/**
* Parameter comment
*
* @var string
*/
var $comment;
/**
* Constructor.
*
* @param string $param MIME parameter to parse, if set.
*
* @return void
*/
function MIME_Type_Parameter($param = false)
{
if ($param) {
$this->parse($param);
}
}
/**
* Parse a MIME type parameter and set object fields
*
* @param string $param MIME type parameter to parse
*
* @return void
*/
function parse($param)
{
$comment = '';
$param = MIME_Type::stripComments($param, $comment);
$this->name = $this->getAttribute($param);
$this->value = $this->getValue($param);
$this->comment = $comment;
}
/**
* Get a parameter attribute (e.g. name)
*
* @param string $param MIME type parameter
*
* @return string Attribute name
* @static
*/
function getAttribute($param)
{
$tmp = explode('=', $param);
return trim($tmp[0]);
}
/**
* Get a parameter value
*
* @param string $param MIME type parameter
*
* @return string Value
* @static
*/
function getValue($param)
{
$tmp = explode('=', $param, 2);
$value = $tmp[1];
$value = trim($value);
if ($value[0] == '"' && $value[strlen($value)-1] == '"') {
$value = substr($value, 1, -1);
}
$value = str_replace('\\"', '"', $value);
return $value;
}
/**
* Get a parameter comment
*
* @param string $param MIME type parameter
*
* @return string Parameter comment
* @see hasComment()
* @static
*/
function getComment($param)
{
$cs = strpos($param, '(');
if ($cs === false) {
return null;
}
$comment = substr($param, $cs);
return trim($comment, '() ');
}
/**
* Does this parameter have a comment?
*
* @param string $param MIME type parameter
*
* @return boolean true if $param has a comment, false otherwise
* @static
*/
function hasComment($param)
{
if (strstr($param, '(')) {
return true;
}
return false;
}
/**
* Get a string representation of this parameter
*
* This function performs the oppsite of parse()
*
* @return string String representation of parameter
*/
function get()
{
$val = $this->name . '="' . str_replace('"', '\\"', $this->value) . '"';
if ($this->comment) {
$val .= ' (' . $this->comment . ')';
}
return $val;
}
}
?> MIME_Type-1.3.1/tests/files/example.bmp 0000644 0001750 0000144 00000000072 11722231646 017217 0 ustar cweiske users BM: 6 ( MIME_Type-1.3.1/tests/files/example.gif 0000644 0001750 0000144 00000000053 11722231646 017205 0 ustar cweiske users GIF89a !
, D ; MIME_Type-1.3.1/tests/files/example.jpg 0000644 0001750 0000144 00000000517 11722231646 017225 0 ustar cweiske users JFIF Exif MM * by Christian Weiske C ! "$" $ C " ? ; MIME_Type-1.3.1/tests/files/example.php 0000644 0001750 0000144 00000000037 11722231646 017231 0 ustar cweiske users MIME_Type-1.3.1/tests/files/example.png 0000644 0001750 0000144 00000000172 11722231646 017226 0 ustar cweiske users PNG
IHDR ĉ sRGB bKGD pHYs
IDATc It IENDB` MIME_Type-1.3.1/tests/files/example.txt 0000644 0001750 0000144 00000000034 11722231646 017256 0 ustar cweiske users This is an exemplarily text. MIME_Type-1.3.1/tests/files/example.txt.bz2 0000644 0001750 0000144 00000000100 11722231646 017744 0 ustar cweiske users BZh91AY&SYB @ "g\` 1L B&h0T)s * t"(HHJi MIME_Type-1.3.1/tests/files/example.txt.gz 0000644 0001750 0000144 00000000072 11722231646 017677 0 ustar cweiske users kaH example.txt ,V <Ԋ܂Ģ̜JԊ= - MIME_Type-1.3.1/tests/bootstrap.php 0000644 0001750 0000144 00000000053 11722231646 016507 0 ustar cweiske users MIME_Type-1.3.1/tests/AllTests.php 0000644 0001750 0000144 00000001214 11722231646 016225 0 ustar cweiske users addTestFiles(
glob(__DIR__ . '/*Test.php', GLOB_BRACE)
);
return $suite;
}
}
if (PHPUnit_MAIN_METHOD == 'MIME_Type_AllTests::main') {
MIME_Type_AllTests::main();
}
?> MIME_Type-1.3.1/tests/MIME_Type_ExtensionTest.php 0000644 0001750 0000144 00000005052 11722231646 021122 0 ustar cweiske users mte = new MIME_Type_Extension;
}
public function testGetMIMEType()
{
$this->assertEquals('text/plain',
$this->mte->getMIMEType('a.txt'));
$this->assertEquals('text/plain',
$this->mte->getMIMEType('/path/to/a.txt'));
$this->assertEquals('image/png',
$this->mte->getMIMEType('a.png'));
$this->assertEquals('application/vnd.oasis.opendocument.text',
$this->mte->getMIMEType('a.odt'));
}
public function testGetMIMETypeFullPath()
{
$this->assertEquals('text/plain',
$this->mte->getMIMEType('/path/to/a.txt'));
$this->assertEquals('text/plain',
$this->mte->getMIMEType('C:\\Programs\\blubbr.txt'));
}
public function testGetMIMETypeNoExtension()
{
$this->assertInstanceOf('PEAR_Error',
$this->mte->getMIMEType('file'));
$this->assertInstanceOf('PEAR_Error',
$this->mte->getMIMEType('blubbr'));
}
public function testGetMIMETypeFullPathNoExtension()
{
$this->assertInstanceOf('PEAR_Error',
$this->mte->getMIMEType('/path/to/file'));
$this->assertInstanceOf('PEAR_Error',
$this->mte->getMIMEType('C:\\Programs\\blubbr'));
}
public function testGetMIMETypeUnknownExtension()
{
$this->assertInstanceOf('PEAR_Error',
$this->mte->getMIMEType('file.ohmygodthatisnoextension'));
}
public function testGetExtension()
{
$this->assertEquals('txt',
$this->mte->getExtension('text/plain'));
$this->assertEquals('csv',
$this->mte->getExtension('text/csv'));
}
public function testGetExtensionFail()
{
$this->assertInstanceOf('PEAR_Error', $this->mte->getExtension(null));
$this->assertInstanceOf('PEAR_Error', $this->mte->getExtension(''));
$this->assertInstanceOf('PEAR_Error', $this->mte->getExtension('n'));
$this->assertInstanceOf('PEAR_Error', $this->mte->getExtension('n/n'));
}
}
?>
MIME_Type-1.3.1/tests/MIME_Type_ParameterTest.php 0000644 0001750 0000144 00000002254 11722231646 021067 0 ustar cweiske users assertTrue(
MIME_Type_Parameter::hasComment(
'a="parameter" (with a comment)'
)
);
$this->assertTrue(
MIME_Type_Parameter::hasComment(
'param=foo(with a comment)'
)
);
}
public function testHasCommentNegative()
{
$this->assertFalse(
MIME_Type_Parameter::hasComment(
'a="parameter"'
)
);
$this->assertFalse(
MIME_Type_Parameter::hasComment(
'foo=bar'
)
);
}
public function testGetComment()
{
$this->assertEquals(
'with a comment',
MIME_Type_Parameter::getComment(
'a="parameter" (with a comment)'
)
);
}
public function testGetCommentNone()
{
$this->assertEquals(
'',
MIME_Type_Parameter::getComment(
'a="parameter"'
)
);
}
}
?> MIME_Type-1.3.1/tests/phpunit.xml 0000644 0001750 0000144 00000000336 11722231646 016176 0 ustar cweiske users
../MIME/
MIME_Type-1.3.1/tests/TypeTest.php 0000644 0001750 0000144 00000032774 11722231646 016272 0 ustar cweiske users parse(new PEAR_Error('this is an error'));
$this->assertEquals('', $mt->media);
}
public function testParse()
{
$mt = new MIME_Type();
$mt->parse('application/ogg;description=Hello there!;asd=fgh');
$this->assertEquals('application', $mt->media);
$this->assertEquals('ogg' , $mt->subType);
$params = array(
'description' => array('Hello there!', ''),
'asd' => array('fgh', '')
);
$this->assertEquals(2, count($mt->parameters));
foreach ($params as $name => $param) {
$this->assertTrue(isset($mt->parameters[$name]));
$this->assertInstanceOf('MIME_Type_Parameter', $mt->parameters[$name]);
$this->assertEquals($name, $mt->parameters[$name]->name);
$this->assertEquals($param[0], $mt->parameters[$name]->value);
$this->assertEquals($param[1], $mt->parameters[$name]->comment);
}
}
public function testParseAgain()
{
$mt = new MIME_Type();
$mt->parse('application/ogg;description=Hello there!;asd=fgh');
$this->assertEquals(2, count($mt->parameters));
$mt->parse('text/plain;hello=there!');
$this->assertEquals(1, count($mt->parameters));
}
public function testHasParameters()
{
$this->assertFalse(MIME_Type::hasParameters('text/plain'));
$this->assertFalse(MIME_Type::hasParameters('text/*'));
$this->assertFalse(MIME_Type::hasParameters('*/*'));
$this->assertTrue(MIME_Type::hasParameters('text/xml;description=test'));
$this->assertTrue(MIME_Type::hasParameters('text/xml;one=test;two=three'));
}
public function testGetParameters()
{
$this->assertEquals(
array(),
MIME_Type::getParameters('text/plain')
);
//rest is tested in testParse()
}
public function testStripParameters()
{
$this->assertEquals(
'text/plain',
MIME_Type::stripParameters('text/plain')
);
$this->assertEquals(
'text/plain',
MIME_Type::stripParameters('text/plain;asd=def')
);
$this->assertEquals(
'text/plain',
MIME_Type::stripParameters('text/plain;asd=def;ghj=jkl')
);
}
public function testStripComments()
{
$this->assertEquals('def', MIME_Type::stripComments('(abc)def(ghi)', $null));
$this->assertEquals('def', MIME_Type::stripComments('(abc)def', $null));
$this->assertEquals('def', MIME_Type::stripComments('def(ghi)', $null));
}
public function testStripCommentsEscaped()
{
$comment = '';
$this->assertEquals(
'def', MIME_Type::stripComments('(\)abc)def(\))', $comment)
);
$this->assertEquals(')abc )', $comment);
}
public function testStripCommentsEscapedString()
{
$comment = false;
$this->assertEquals(
'foo', MIME_Type::stripComments('\\foo(abc)', $comment)
);
$this->assertEquals('abc', $comment);
}
public function testStripCommentsQuoted()
{
$this->assertEquals('def', MIME_Type::stripComments('(a"bc)def")def', $null));
$this->assertEquals('(abc)def', MIME_Type::stripComments('"(abc)def"', $null));
}
public function testStripCommentsParameterComment()
{
$comment = '';
$this->assertEquals(
'def',
MIME_Type::stripComments('(abc)def(ghi)', $comment)
);
$this->assertEquals('abc ghi', $comment);
}
public function testGetMedia()
{
$this->assertEquals('text', MIME_Type::getMedia('text/plain'));
$this->assertEquals('application', MIME_Type::getMedia('application/ogg'));
$this->assertEquals('*', MIME_Type::getMedia('*/*'));
}
public function testGetSubType()
{
$this->assertEquals('plain', MIME_Type::getSubType('text/plain'));
$this->assertEquals('ogg', MIME_Type::getSubType('application/ogg'));
$this->assertEquals('*', MIME_Type::getSubType('*/*'));
$this->assertEquals('plain', MIME_Type::getSubType('text/plain;a=b'));
}
public function testGet()
{
$mt = new MIME_Type('text/xml');
$this->assertEquals('text/xml', $mt->get());
$mt = new MIME_Type('text/xml; this="is"; a="parameter" (with a comment)');
$this->assertEquals(
'text/xml; this="is"; a="parameter" (with a comment)',
$mt->get()
);
}
public function testIsExperimental()
{
$this->assertTrue(MIME_Type::isExperimental('text/x-test'));
$this->assertTrue(MIME_Type::isExperimental('image/X-test'));
$this->assertFalse(MIME_Type::isExperimental('text/plain'));
}
public function testIsVendor()
{
$this->assertTrue(MIME_Type::isVendor('application/vnd.openoffice'));
$this->assertFalse(MIME_Type::isVendor('application/vendor.openoffice'));
$this->assertFalse(MIME_Type::isVendor('vnd/fsck'));
}
public function testIsWildcard()
{
$this->assertTrue(MIME_Type::isWildcard('*/*'));
$this->assertTrue(MIME_Type::isWildcard('image/*'));
$this->assertFalse(MIME_Type::isWildcard('text/plain'));
}
public function testWildcardMatch() {
$this->assertTrue(MIME_Type::wildcardMatch('*/*', 'image/png'));
$this->assertTrue(MIME_Type::wildcardMatch('image/*', 'image/png'));
$this->assertFalse(MIME_Type::wildcardMatch('image/*', 'text/plain'));
}
public function testWildcardMatchNoWildcard()
{
$this->assertFalse(MIME_Type::wildcardMatch('image/foo', 'image/png'));
}
public function testAddParameter()
{
$mt = new MIME_Type('image/png; foo=bar');
$mt->addParameter('baz', 'val', 'this is a comment');
$res = $mt->get();
$this->assertContains('foo=', $res);
$this->assertContains('bar', $res);
$this->assertContains('baz=', $res);
$this->assertContains('val', $res);
$this->assertContains('(this is a comment)', $res);
}
public function testRemoveParameter()
{
$mt = new MIME_Type('image/png; foo=bar');
$mt->addParameter('baz', 'val', 'this is a comment');
$mt->removeParameter('foo');
$res = $mt->get();
$this->assertNotContains('foo=', $res);
$this->assertNotContains('bar', $res);
$this->assertContains('baz=', $res);
}
public function testAutoDetect()
{
$dir = dirname(__FILE__) . '/files/';
$mt = new MIME_Type(
MIME_Type::autoDetect($dir . 'example.png')
);
$this->assertInstanceOf('MIME_Type', $mt);
$this->assertEquals('image', $mt->media);
$this->assertEquals('png', $mt->subType);
$mt = new MIME_Type(
MIME_Type::autoDetect($dir . 'example.jpg')
);
$this->assertInstanceOf('MIME_Type', $mt);
$this->assertEquals('image', $mt->media);
$this->assertEquals('jpeg', $mt->subType);
}
public function testAutoDetectNonexistingFile()
{
$res = MIME_Type::autoDetect('/this/file/does/not/exist');
$this->assertInstanceOf('PEAR_Error', $res);
$this->assertContains('doesn\'t exist', $res->getMessage());
}
public function testAutoDetectFinfo()
{
$mt = new MIME_Type();
$mt->useMimeContentType = false;
$mt->useFileCmd = false;
$mt->useExtension = false;
$type = $mt->autoDetect(dirname(__FILE__) . '/files/example.jpg');
$this->assertNotInstanceOf('PEAR_Error', $type);
$this->assertEquals('image', $mt->media);
$this->assertEquals('jpeg', $mt->subType);
}
public function testAutoDetectFinfoMagic()
{
$mt = new MIME_Type();
$mt->magicFile = dirname(__FILE__) . '/TypeTest.magic';
$mt->useMimeContentType = false;
$mt->useFileCmd = false;
$mt->useExtension = false;
$type = $mt->autoDetect(dirname(__FILE__) . '/files/example.php');
$this->assertNotInstanceOf('PEAR_Error', $type);
$this->assertEquals('text', $mt->media);
$this->assertEquals('x-unittest', $mt->subType);
}
public function testAutoDetectFinfoNonExistingMagic()
{
$mt = new MIME_Type();
$mt->magicFile = dirname(__FILE__) . '/magicdoesnotexist';
$mt->useMimeContentType = false;
$mt->useFileCmd = false;
$mt->useExtension = false;
$type = $mt->autoDetect(dirname(__FILE__) . '/files/example.php');
$this->assertInstanceOf('PEAR_Error', $type);
}
public function testAutoDetectMimeContentType()
{
$mt = new MIME_Type();
$mt->useFinfo = false;
$mt->useFileCmd = false;
$mt->useExtension = false;
$type = $mt->autoDetect(dirname(__FILE__) . '/files/example.jpg');
$this->assertEquals('image', $mt->media);
$this->assertEquals('jpeg', $mt->subType);
}
public function testAutoDetectFileCommand()
{
$mt = new MIME_Type();
$mt->useFinfo = false;
$mt->useMimeContentType = false;
$mt->useExtension = false;
$type = $mt->autoDetect(dirname(__FILE__) . '/files/example.jpg');
$this->assertEquals('image', $mt->media);
$this->assertEquals('jpeg', $mt->subType);
}
public function testAutoDetectFileCommandMagic()
{
$mt = new MIME_Type();
$mt->magicFile = dirname(__FILE__) . '/TypeTest.magic';
$mt->useFinfo = false;
$mt->useMimeContentType = false;
$mt->useExtension = false;
$type = $mt->autoDetect(dirname(__FILE__) . '/files/example.php');
$this->assertEquals('text', $mt->media);
$this->assertEquals('x-unittest', $mt->subType);
}
public function testAutoDetectExtension()
{
$mt = new MIME_Type();
$mt->useFinfo = false;
$mt->useMimeContentType = false;
$mt->useFileCmd = false;
$type = $mt->autoDetect(dirname(__FILE__) . '/files/example.jpg');
$this->assertEquals('image', $mt->media);
$this->assertEquals('jpeg', $mt->subType);
}
public function testAutoDetectError()
{
$mt = new MIME_Type();
$mt->useFinfo = false;
$mt->useMimeContentType = false;
$mt->useFileCmd = false;
$mt->useExtension = false;
$res = $mt->autoDetect(dirname(__FILE__) . '/files/example.jpg');
$this->assertInstanceOf('PEAR_Error', $res);
$this->assertEquals('', $mt->media);
$this->assertEquals('', $mt->subType);
}
public function test_fileAutoDetectNoFileCommand()
{
$cmd = &PEAR::getStaticProperty('MIME_Type', 'fileCmd');
$cmd = 'thiscommanddoesnotexist';
require_once 'System/Command.php';
$res = MIME_Type::_fileAutoDetect(dirname(__FILE__) . '/files/example.jpg');
$this->assertInstanceOf('PEAR_Error', $res);
$this->assertContains('thiscommanddoesnotexist', $res->getMessage());
}
public function testComments()
{
$type = new MIME_Type('(UTF-8 Plain Text) text / plain ; charset = utf-8');
$this->assertEquals(
'text/plain; charset="utf-8"', $type->get()
);
$type = new MIME_Type('text (Text) / plain ; charset = utf-8');
$this->assertEquals(
'text/plain; charset="utf-8"', $type->get()
);
$type = new MIME_Type('text / (Plain) plain ; charset = utf-8');
$this->assertEquals(
'text/plain; charset="utf-8"', $type->get()
);
$type = new MIME_Type('text / plain (Plain Text) ; charset = utf-8');
$this->assertEquals(
'text/plain; charset="utf-8"', $type->get()
);
$type = new MIME_Type('text / plain ; (Charset=utf-8) charset = utf-8');
$this->assertEquals(
'text/plain; charset="utf-8" (Charset=utf-8)', $type->get()
);
$type = new MIME_Type('text / plain ; charset (Charset) = utf-8');
$this->assertEquals(
'text/plain; charset="utf-8" (Charset)', $type->get()
);
$type = new MIME_Type('text / plain ; charset = (UTF8) utf-8');
$this->assertEquals(
'text/plain; charset="utf-8" (UTF8)', $type->get()
);
$type = new MIME_Type('text / plain ; charset = utf-8 (UTF-8 Plain Text)');
$this->assertEquals(
'text/plain; charset="utf-8" (UTF-8 Plain Text)', $type->get()
);
$type = new MIME_Type('application/x-foobar;description="bbgh(kdur"');
$this->assertEquals(
'application/x-foobar; description="bbgh(kdur"', $type->get()
);
$type = new MIME_Type('application/x-foobar;description="a \"quoted string\""');
$this->assertEquals(
'application/x-foobar; description="a \"quoted string\""', $type->get()
);
}
public function test_handleDetectionParamPearError()
{
$err = new PEAR_Error('test');
$ret = MIME_Type::_handleDetection($err, false);
$this->assertInstanceOf('PEAR_Error', $ret);
}
public function test_handleDetectionEmptyType()
{
$ret = MIME_Type::_handleDetection('', false);
$this->assertInstanceOf('PEAR_Error', $ret);
$ret = MIME_Type::_handleDetection(false, false);
$this->assertInstanceOf('PEAR_Error', $ret);
}
}
?>
MIME_Type-1.3.1/tests/TypeTest.magic 0000644 0001750 0000144 00000000130 11722231646 016540 0 ustar cweiske users 0 search/1/c =