.github/workflows/build.yml 0000644 00000001213 15073164573 0011773 0 ustar 00 name: Tests
on: [push]
jobs:
run:
runs-on: ubuntu-latest
strategy:
matrix:
php: ['7.4', '8.0', '8.1']
name: Testing on PHP ${{ matrix.php }}
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Setup PHP
uses: shivammathur/setup-php@v2
with:
php-version: ${{ matrix.php }}
extensions: mbstring,bcmath
tools: composer
- name: Install PHP dependencies
run: composer install -q
- name: Run phpunit
run: vendor/bin/phpunit
- name: Run phpstan
run: vendor/bin/phpstan analyze --no-progress --level=5 src/
.gitignore 0000644 00000000102 15073164573 0006540 0 ustar 00 .DS_Store
composer.lock
vendor/
dev/
.idea/
.phpunit.result.cache
Dockerfile 0000644 00000000216 15073164573 0006550 0 ustar 00 FROM php:8-cli
# install composer
#
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
LICENSE 0000644 00000002066 15073164573 0005570 0 ustar 00 The MIT License (MIT)
Copyright (c) 2019 Oliver Vogel
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. README.md 0000755 00000007530 15073164573 0006046 0 ustar 00 # PHP Media type (MIME) detector
Detecting MIME Content-type in PHP is easy with [mime_content_type](https://www.php.net/manual/en/function.mime-content-type.php) or [Fileinfo](https://www.php.net/manual/en/book.fileinfo.php). But Fileinfo as an extension is sometimes not available on the server. The function `mime_content_type` wants a path to the filesystem as argument and doesn't process if we only have a string value. This package makes it easy to detect the mime types of the content of a given file or string, without any extension dependencies.
## Installation
Install the package easily via composer:
```bash
composer require intervention/mimesniffer
```
## Usage
Here are some code samples, to show how the library is handled.
```php
use Intervention\MimeSniffer\MimeSniffer;
use Intervention\MimeSniffer\Types\ImageJpeg;
// detect given string
$sniffer = MimeSniffer::createFromString($content);
// or detect given file
$sniffer = MimeSniffer::createFromFilename('image.jpg');
// returns object of detected type
$type = $sniffer->getType();
$bool = $type->isBinary(); // check if we have binary data
$bool = $type->isImage(); // check if we are dealing with an image
$bool = $type->isVideo(); // check video data was detected
$bool = $type->isAudio(); // check if we have detected audio data
$bool = $type->isArchive(); // check if an archive was detected
$type = (string) $type; // cast type to string (e.g. "image/jpeg")
// you can also check, if the content matches a specific type
$bool = $sniffer->matches(new ImageJpeg);
// or check, if the content matches an array of types
$bool = $sniffer->matches([ImageJpeg::class, ImageGif::class]);
// or check, if the content matches an array of type objects
$bool = $sniffer->matches([new ImageJpeg, $type]);
```
If your prefer non-static initialization:
```php
use Intervention\MimeSniffer\MimeSniffer;
// create instance with constructor
$sniffer = new MimeSniffer($content);
// with setter for given content
$type = $sniffer->setFromString($other_content)->getType();
// or with setter for filename
$type = $sniffer->setFromFilename('images/image.jpg')->getType();
```
**Currently only the following file types can be detected. More will be added in a next release.**
### Images
- Image encoded as JPEG raw or in the JFIF or Exif file format
- Image file encoded in the Graphics Interchange Format (GIF)
- Image encoded in the Portable Network Graphics format (PNG)
- Image encoded as BMP file, a bitmap format
- Image encoded in High Efficiency Image File Format (HEIC/HEIF)
- Icon encoded in ICO file format
- Image in Google WebP image format
- Scalable Vector Graphics (SVG)
- Tagged Image File Format (TIFF)
- Image encoded Photoshop Document file format (PSD)
- AV1 Image File Format (AVIF)
### Archives
- GZIP compressed
- ZIP file
- RAR archive
- TAR file
### Videos
- AVI
- MPEG-1 and MPEG-2 video
- MKV media container
### Audio
- MP3 file
- FLAC file
### Other
- PDF document
- OGG media container
- SQLite Database
- application/octet-stream (default binary)
- text/plain (default)
## Contributing
Contributions are welcome. Please note the following guidelines before submiting your pull request.
- Follow [PSR-2](http://www.php-fig.org/psr/psr-2/) coding standards.
- Write tests for new functions and added features
## Development & Testing
With this package comes a Docker image to build a test suite and analysis container. To build this container you have to have Docker installed on your system. You can run all tests with this command.
```bash
docker-compose run --rm --build tests
```
Run the static analyzer on the code base.
```bash
docker-compose run --rm --build analysis
```
## License
Licensed under the [MIT License](http://opensource.org/licenses/MIT).
Copyright 2019 [Oliver Vogel](https://olivervogel.com/)
composer.json 0000644 00000001422 15073164573 0007300 0 ustar 00 {
"name": "intervention/mimesniffer",
"description": "PHP MIME Type Sniffer",
"homepage": "http://intervention.io/",
"keywords": ["mime", "type", "sniffer", "detector"],
"license": "MIT",
"authors": [
{
"name": "Oliver Vogel",
"email": "oliver@intervention.io",
"homepage": "https://intervention.io/"
}
],
"require": {
"php": "^7.3|^8.0"
},
"require-dev": {
"phpunit/phpunit": "^9.0",
"phpstan/phpstan": "^1"
},
"autoload": {
"psr-4": {
"Intervention\\MimeSniffer\\": "src"
}
},
"autoload-dev": {
"psr-4": {
"Intervention\\MimeSniffer\\Test\\": "tests"
}
},
"minimum-stability": "stable"
}
docker-compose.yml 0000644 00000000535 15073164573 0010217 0 ustar 00 version: '3'
services:
tests:
build: ./
working_dir: /project
command: bash -c "composer install && ./vendor/bin/phpunit -vvv"
volumes:
- ./:/project
analysis:
build: ./
working_dir: /project
command: bash -c "composer install && ./vendor/bin/phpstan analyze --level=4 ./src"
volumes:
- ./:/project
phpunit.xml 0000644 00000001035 15073164573 0006767 0 ustar 00
./tests/
src/AbstractBinaryType.php 0000644 00000001024 15073164573 0011626 0 ustar 00 pattern, $this->prepareContent($content)) === 1;
}
/**
* Determine if the detected type is an image
*
* @return boolean
*/
public function isImage(): bool
{
return substr($this->name, 0, 5) === 'image';
}
/**
* Determine if the detected type is an video
*
* @return boolean
*/
public function isVideo(): bool
{
return substr($this->name, 0, 5) === 'video';
}
/**
* Determine if the detected type is an audio file
*
* @return boolean
*/
public function isAudio(): bool
{
return substr($this->name, 0, 5) === 'audio';
}
/**
* Determine if the detected type is an archive
*
* @return boolean
*/
public function isArchive(): bool
{
return in_array($this->name, [
'application/zip',
'application/x-rar-compressed',
'application/x-tar',
'application/gzip',
]);
}
/**
* Prepare content (can be extended by child classes)
*
* @param string $content
* @return string
*/
public function prepareContent(string $content): string
{
return substr($content, 0, 1024);
}
/**
* Determine of current type is binary
*
* @return boolean
*/
public function isBinary(): bool
{
return false;
}
/**
* Cast type to string
*
* @return string
*/
public function __toString(): string
{
return $this->name;
}
}
src/Exceptions/NotMatchingException.php 0000644 00000000240 15073164573 0014266 0 ustar 00 setFromString($content);
}
/**
* Create new instance from given string
*
* @param string $content
*
* @return MimeSniffer
*/
public static function createFromString(string $content): MimeSniffer
{
return new self($content);
}
/**
* Load contents of given string into instance
*
* @param string $content
*
* @return MimeSniffer
*/
public function setFromString(string $content): MimeSniffer
{
$this->content = strval($content);
return $this;
}
/**
* Create a new instance and load contents of given filename
*
* @param string $filename
*
* @return MimeSniffer
*/
public static function createFromFilename(string $filename): MimeSniffer
{
return (new self())->setFromFilename($filename);
}
/**
* Load contents of given filename in current instance
*
* @param string $filename
*
* @return MimeSniffer
*/
public function setFromFilename(string $filename): MimeSniffer
{
$fp = fopen($filename, 'r');
$this->setFromString(fread($fp, 1024));
fclose($fp);
return $this;
}
/**
* Return detected type
*
* @return AbstractType
*/
public function getType(): AbstractType
{
foreach ($this->getTypeClassnames() as $classname) {
$type = new $classname();
if ($type->matches($this->content)) {
return $type;
}
}
$binaryType = new Types\ApplicationOctetStream();
if ($this->matches($binaryType)) {
return $binaryType;
}
return new Types\TextPlain();
}
/**
* Determine if content matches the given type
* or any if the given types in array
*
* @param AbstractType|array $types AbstractType or array of AbstractTypes
* @return boolean
*/
public function matches($types): bool
{
if (! is_array($types)) {
$types = [$types];
}
$types = array_map(function ($value) {
if (is_a($value, AbstractType::class)) {
return $value;
}
if (!is_null($value) && class_exists($value)) {
return new $value();
}
}, $types);
$types = array_filter($types, function ($type) {
return is_a($type, AbstractType::class);
});
foreach ($types as $type) {
if ($type->matches($this->content)) {
return true;
}
}
return false;
}
/**
* Return array of type classnames
*
* @return array
*/
private function getTypeClassnames(): array
{
$files = array_diff(scandir(__DIR__ . '/Types'), ['.', '..']);
$classnames = array_map(function ($filename) {
return "Intervention\\MimeSniffer\\Types\\" . substr($filename, 0, -4);
}, $files);
return array_filter($classnames, function ($classname) {
return ! in_array($classname, [
Types\ApplicationOctetStream::class,
Types\TextPlain::class,
]);
});
}
}
src/Types/ApplicationGzip.php 0000644 00000000556 15073164573 0012266 0 ustar 00 ]*\?>.*)?]*>/is";
}
src/Types/ImageTiff.php 0000644 00000000561 15073164573 0011020 0 ustar 00 getMockForAbstractClass(AbstractBinaryType::class);
$this->assertEquals(1024, strlen($type->prepareContent($content)));
$this->assertEquals('78787878', substr($type->prepareContent($content), 0, 8));
}
public function testIsBinary()
{
$type = $this->getMockForAbstractClass(AbstractBinaryType::class);
$this->assertTrue($type->isBinary());
}
}
tests/AbstractTypeTest.php 0000644 00000002141 15073164573 0011675 0 ustar 00 getMockForAbstractClass(AbstractType::class);
$this->assertEquals('', $type);
}
public function testMatches()
{
$type = $this->getMockForAbstractClass(AbstractType::class);
$this->assertFalse($type->matches('test'));
}
public function testIsImage()
{
$type = $this->getMockForAbstractClass(AbstractType::class);
$this->assertFalse($type->isImage());
}
public function testPrepareContent()
{
$content = '';
for ($i = 0; $i < 2048; $i++) {
$content .= 'x';
}
$type = $this->getMockForAbstractClass(AbstractType::class);
$this->assertEquals(1024, strlen($type->prepareContent($content)));
}
public function testIsBinary()
{
$type = $this->getMockForAbstractClass(AbstractType::class);
$this->assertFalse($type->isBinary());
}
}
tests/ApplicationGzipTest.php 0000644 00000001232 15073164573 0012365 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/gzip');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationGzip::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
}
tests/ApplicationOggTest.php 0000644 00000001226 15073164573 0012173 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/ogg');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationOgg::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
}
tests/ApplicationPdfTest.php 0000644 00000001226 15073164573 0012170 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/pdf');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationPdf::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
}
tests/ApplicationRarTest.php 0000644 00000001231 15073164573 0012177 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/rar');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationRar::class, $this->type);
}
public function testIsArchive()
{
$this->assertTrue($this->type->isArchive());
}
}
tests/ApplicationSqliteTest.php 0000644 00000001104 15073164573 0012713 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.sqlite');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationSqlite::class, $this->type);
}
}
tests/ApplicationTarTest.php 0000644 00000001236 15073164573 0012206 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.tar');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationTar::class, $this->type);
}
public function testIsArchive()
{
$this->assertTrue($this->type->isArchive());
}
}
tests/ApplicationZipTest.php 0000644 00000001231 15073164573 0012215 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/zip');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationZip::class, $this->type);
}
public function testIsArchive()
{
$this->assertTrue($this->type->isArchive());
}
}
tests/AudioFlacTest.php 0000644 00000001210 15073164573 0011113 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/flac');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(AudioFlac::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
}
tests/AudioMpegId3v2Test.php 0000644 00000001221 15073164573 0011750 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/mp3_id3v2');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(AudioMpeg::class, $this->type);
}
public function testIsAudio()
{
$this->assertTrue($this->type->isAudio());
}
}
tests/AudioMpegTest.php 0000644 00000001214 15073164573 0011142 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/mp3_id3v1');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(AudioMpeg::class, $this->type);
}
public function testIsAudio()
{
$this->assertTrue($this->type->isAudio());
}
}
tests/ImageAvifTest.php 0000644 00000001214 15073164573 0011120 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.avif');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageAvif::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageBmpTest.php 0000644 00000001210 15073164573 0010745 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.bmp');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageBmp::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageGifTest.php 0000644 00000001210 15073164573 0010734 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.gif');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageGif::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageHeicTest.php 0000644 00000001207 15073164573 0011105 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/heic');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageHeic::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageHeifTest.php 0000644 00000001207 15073164573 0011110 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/heif');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageHeif::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageIcoTest.php 0000644 00000001210 15073164573 0010741 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.ico');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageIco::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageJpegTest.php 0000644 00000001213 15073164573 0011117 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.jpg');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageJpeg::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImagePngTest.php 0000644 00000001210 15073164573 0010753 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.png');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImagePng::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImagePsdTest.php 0000644 00000001203 15073164573 0010757 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/psd');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImagePsd::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageSvgTest.php 0000644 00000002242 15073164573 0010774 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.svg');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageSvg::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
public function testPlainXmlIsNotSvg()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.xml');
$this->assertInstanceOf(TextPlain::class, $sniffer->getType());
}
public function testSvgWithoutXmlTag()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/svg');
$this->assertInstanceOf(ImageSvg::class, $sniffer->getType());
}
}
tests/ImageTiffTest.php 0000644 00000001207 15073164573 0011125 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/tiff');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageTiff::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageWebpTest.php 0000644 00000001214 15073164573 0011130 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.webp');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageWebp::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/MimeSnifferTest.php 0000644 00000005303 15073164573 0011477 0 ustar 00 assertInstanceOf(MimeSniffer::class, $sniffer);
$sniffer = new MimeSniffer();
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testCreateFromString()
{
$sniffer = MimeSniffer::createFromString('foo');
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testCreateFromFilename()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.jpg');
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testSetFromString()
{
$sniffer = new MimeSniffer();
$sniffer = $sniffer->setFromString('foo');
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testSetFromFilename()
{
$sniffer = new MimeSniffer();
$sniffer = $sniffer->setFromFilename(__DIR__ . '/../tests/stubs/zip');
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testMatchesType()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.gif');
$this->assertTrue($sniffer->matches(new ImageGif()));
$this->assertFalse($sniffer->matches(new ImageJpeg()));
}
public function testMatchesArray()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.gif');
$this->assertTrue($sniffer->matches([new ImageJpeg(), new ImagePng(), new ImageGif()]));
$this->assertFalse($sniffer->matches([new ImageJpeg(), new ImagePng()]));
$this->assertTrue($sniffer->matches([ImageJpeg::class, ImagePng::class, ImageGif::class]));
$this->assertFalse($sniffer->matches([ImageJpeg::class, ImagePng::class]));
}
public function testMatchesBogus()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/zip');
$this->assertFalse($sniffer->matches('foo'));
$this->assertFalse($sniffer->matches(['foo', 'bar']));
$this->assertFalse($sniffer->matches([]));
$this->assertFalse($sniffer->matches(null));
$this->assertTrue($sniffer->matches(['foo', ApplicationZip::class]));
}
}
tests/VideoMpegTest.php 0000644 00000001360 15073164573 0011151 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/mpeg-video');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(VideoMpeg::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
public function testIsVideo()
{
$this->assertTrue($this->type->isVideo());
}
}
tests/VideoXmatroskaTest.php 0000644 00000001370 15073164573 0012233 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/mkv');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(VideoXmatroska::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
public function testIsVideo()
{
$this->assertTrue($this->type->isVideo());
}
}
tests/VideoXmsvideoTest.php 0000644 00000001365 15073164573 0012064 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/avi');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(VideoXmsvideo::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
public function testIsVideo()
{
$this->assertTrue($this->type->isVideo());
}
}
tests/files/test.avif 0000644 00000000754 15073164573 0010657 0 ustar 00 ftypavif avifmif1miaf meta !hdlr pict pitm 4iloc D@ 8iinf infe av01 infe av01 iprp ipco colrnclx av1C ispe pixi 8auxC urn:mpeg:mpegB:cicp:systems:auxiliary:alpha av1C ispe pixi ipma iref auxl 8mdat
62
( !`
6 2
( V_@ tests/files/test.bin 0000644 00000000400 15073164573 0010466 0 ustar 00
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ tests/files/test.bmp 0000644 00000001070 15073164573 0010500 0 ustar 00 BM8 6 ( pppppppppppppppppppppppppppppppppppp`< <`ppppppp T$ $ Tppppp`$ $`pppp< <pppp pppp pppp pppp pppp< <pppp`$ $`ppppp T$ $ Tppppppp`< <`pppppppppppppppppppppppppppppppppppp tests/files/test.gif 0000644 00000001120 15073164573 0010463 0 ustar 00 GIF89a 9KcBO_EQ]mcI
jaK$6zefxj쬺,YwYxoܽx|mUx*VUUU˫ʼ~|o⮯^̫]ef^x*Yvfxͫ,eYvWnzz^2 x۫ugf |=gۼxUfՖVfmm5yw6[UxU^j.ʲʺYfg ju^UVٕufxmm[^Ϳzmm^>u32ڳ3*2ʫYffWu~Wwz[wUe[W 2+nfݟwV궶m]UW_{xx+͵Vm]6kŕgoVykuvy̪l̪ 7m+2+.YVfYefxlw^o^lǯ_ ͪuUUVx33,g|lٵ*k,|6[m^o[un=+*kUU]xʺ˲̳jϭ [|<|ݖ][eUVmejUU[Wyzm}/*˼]Ul*fVfkloyvתe^3UeY/Umx˺7 Y^2˺.jmʪ6ݗx˶uUmYzY[~ |ŵVx˳NjʺʪfYuv|o7
=g*NjǏzm˼_/7o7UՙoegNJʬ̻6y
lͪ*ʬeUUeue]m]ǯ 7Uz+e]UW2[v]ךʭ{,۳*ykj ? jg tests/files/test.png 0000644 00000000577 15073164573 0010521 0 ustar 00 PNG
IHDR 2 2 ? FIDATx=P*
- *+=,*or?w>|3zDF K5rĈ`
M
RpG%[[Ɉ5H6"Y `;~
OB<`x'L
v0B>젲 vpɜ{ H=S > .?
r Y
z -
1
Y j; !57% tests/files/test.svg 0000644 00000016243 15073164573 0010531 0 ustar 00
tests/files/test.tar 0000644 00000024000 15073164573 0010506 0 ustar 00 foo.json 0000644 0001750 0001750 00000000076 13513647427 012135 0 ustar oliver oliver {
"require": {
"intervention/image": "^1"
}
}
tests/files/test.txt 0000644 00000000004 15073164573 0010535 0 ustar 00 test tests/files/test.webp 0000644 00000000314 15073164573 0010657 0 ustar 00 RIFF WEBPVP8 * %tN
ҿ n6[@ t7U'~L,6h{\` Wi+P\);
ahј 0x*l }!q>PPSDٞ\vC . Z[
B% ¼2 tests/files/test.xml 0000644 00000000536 15073164573 0010530 0 ustar 00
http://intervention.io/
tests/stubs/avi 0000644 00000000020 15073164573 0007553 0 ustar 00 RIFFAVI tests/stubs/flac 0000644 00000000010 15073164573 0007700 0 ustar 00 fLaC tests/stubs/gzip 0000644 00000000003 15073164573 0007746 0 ustar 00 tests/stubs/heic 0000644 00000000170 15073164573 0007712 0 ustar 00 ftypheic mif1miafMiHBheic
meta "hdlr pict $dinf dref url pi tests/stubs/heif 0000644 00000000100 15073164573 0007706 0 ustar 00 ftypmif1 mif1heic meta !hdlr pict tests/stubs/mkv 0000644 00000000010 15073164573 0007570 0 ustar 00 Eߣ tests/stubs/mp3_id3v1 0000644 00000000004 15073164573 0010503 0 ustar 00 tests/stubs/mp3_id3v2 0000644 00000000006 15073164573 0010506 0 ustar 00 ID3 tests/stubs/mpeg-video 0000644 00000000010 15073164573 0011027 0 ustar 00 tests/stubs/ogg 0000644 00000000010 15073164573 0007547 0 ustar 00 OggS tests/stubs/pdf 0000644 00000000006 15073164573 0007551 0 ustar 00 %PDF- tests/stubs/psd 0000644 00000000005 15073164573 0007565 0 ustar 00 8BPS tests/stubs/rar 0000644 00000000007 15073164573 0007565 0 ustar 00 Rar! tests/stubs/svg 0000644 00000000227 15073164573 0007604 0 ustar 00
tests/stubs/tiff 0000644 00000000004 15073164573 0007726 0 ustar 00 II* tests/stubs/zip 0000644 00000000004 15073164573 0007600 0 ustar 00 PK