Sirius\Upload\Container\Local

Complexity

Total Complexity

16

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

94.44%

Importance

Changes	8
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	isWritable()	0	4	1
A	has()	0	4	2
A	__construct()	0	5	1
A	normalizePath()	0	6	1
A	ensureDirectory()	0	8	3
A	save()	0	10	2
A	delete()	0	9	2
A	moveUploadedFile()	0	17	4

<?php

namespace Sirius\Upload\Container;

class Local implements ContainerInterface
{

    protected $baseDirectory;

    public function __construct($baseDirectory)
    {
        $this->baseDirectory = $this->normalizePath($baseDirectory) . DIRECTORY_SEPARATOR;
        $this->ensureDirectory($this->baseDirectory);
    }

    protected function normalizePath($path)
    {
        $path = dirname(rtrim($path, '\\/') . DIRECTORY_SEPARATOR . 'xxx');

        return rtrim($path, DIRECTORY_SEPARATOR);
    }

    protected function ensureDirectory($directory)
    {
        if (!is_dir($directory)) {
            mkdir($directory, 0766, true);
        }

        return is_dir($directory) && $this->isWritable();
    }

    /**
     * Check if the container is writable
     */
    public function isWritable()
    {
        return is_writable($this->baseDirectory);
    }

    /**
     * This will check if a file is in the container
     *
     * @param  string $file
     * @return bool
     */
    public function has($file)
    {
        return $file && file_exists($this->baseDirectory . $file);
    }

    /**
     * Saves the $content string as a file
     *
     * @param  string $file
     * @param  string $content
     * @return bool
     */
    public function save($file, $content)
    {
        $file = $this->normalizePath($file);
        $dir = dirname($this->baseDirectory . $file);
        if ($this->ensureDirectory($dir)) {
            return (bool) file_put_contents($this->baseDirectory . $file, $content);
        }

        return false;
    }

    /**
     * Delete the file from the container
     *
     * @param  string $file
     * @return bool
     */
    public function delete($file)
    {
        $file = $this->normalizePath($file);
        if (file_exists($this->baseDirectory . $file)) {
            return unlink($this->baseDirectory . $file);
        }

        return true;
    }

    /**
     * Moves a temporary uploaded file to a destination in the container
     *
     * @param  string $localFile   local path
     * @param  string $destination
     * @return bool
     */
    public function moveUploadedFile($localFile, $destination)
    {
        $dir = dirname($this->baseDirectory . $destination);
        if (file_exists($localFile) && $this->ensureDirectory($dir)) {
            /**
             * we could use is_uploaded_file() and move_uploaded_file()
             * but in case of ajax uploads that would fail
             */
            if (is_readable($localFile)) {
                // rename() would be good but this is better because $localFile may become 'unwritable'
                $result = copy($localFile, $this->baseDirectory . $destination);
                @unlink($localFile);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

                return $result;
            }
        }
        return false;
    }

}