erdiko\core\datasource\File

Complexity

Total Complexity

27

Size/Duplication

Total Lines	190
Duplicated Lines	24.21 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	3
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	3
A	createDir()	0	9	3
A	write()	0	14	2
A	read()	11	11	3
A	delete()	11	11	3
A	move()	12	12	3
A	rename()	12	12	3
A	copy()	0	14	4
A	fileExists()	0	7	2
A	__destruct()	0	3	1

<?php
/**
 * Wrapper for php file commmands
 *
 * @package     erdiko/core
 * @copyright   2012-2017 Arroyo Labs, Inc. http://www.arroyolabs.com
 * @author      Varun Brahme
 * @author      Coleman Tung
 * @author      John Arroyo <john@arroyolabs.com>
 */
namespace erdiko\core\datasource;


class File
{
    /**
     * Default Path
     */
    protected $_filePath = null;
    
    /**
    * Contructor
    *
    * @param string $defaultPath
    */
    public function __construct($defaultPath = null)
    {
        if (isset($defaultPath)) {
            $this->_filePath=$defaultPath;
        } else {
            $rootFolder=dirname(dirname(dirname(__DIR__)));
            $this->_filePath=$rootFolder."/var";
        }
        if (!is_dir($this->_filePath)) {
            mkdir($this->_filePath, 0775, true);
        }
    }

    /**
     * Create Directory
     * If path doesn't exist, create it
     */
    private function createDir($path)
    {
        if (!is_dir($path)) {
            $success = mkdir($path, 0775, true);
            if (!$success) {
                throw new \Exception("Cannot create folder {$path}. Check file system permissions.");
            }
        }
    }
    
    /**
     * Write string to file
     *
     * @param string $content
     * @param string $filename
     * @param string $pathToFile
     * @param string $mode - Default mode: w
     * @return int - bytes written to file
     */
    public function write($content, $filename, $pathToFile = null, $mode = "w")
    {
        if ($pathToFile == null) {

It seems like you are loosely comparing $pathToFile of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $pathToFile = $this->_filePath;
        }

        $this->createDir($pathToFile);

        $fileHandle = fopen($pathToFile."/".$filename, $mode);
        $success = fwrite($fileHandle, $content);
        fclose($fileHandle);

        return $success;
    }
    
    /**
     * Read string to file
     *
     * @param string $filename
     * @param string $pathToFile
     * @return string
     */
    public function read($filename, $pathToFile = null)

This method seems to be duplicated in your project.

    {
        if(!$this->fileExists($filename, $pathToFile))
            throw new \Exception("File, '{$filename}', does not exist.");

        if ($pathToFile==null) {

It seems like you are loosely comparing $pathToFile of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            return file_get_contents($this->_filePath."/".$filename);
        } else {
            return file_get_contents($pathToFile."/".$filename);
        }
    }
    
    /**
     * Delete a file
     *
     * @param string $filename
     * @param string $pathToFile
     * @return bool
     */
    public function delete($filename, $pathToFile = null)

This method seems to be duplicated in your project.

    {
        if ($pathToFile==null) {

It seems like you are loosely comparing $pathToFile of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $pathToFile=$this->_filePath;
        }
        if (file_exists($pathToFile."/".$filename)) {
            return unlink($pathToFile."/".$filename);
        } else {
            return false;
        }
    }

    /**
     * Move a file
     *
     * @param string $filename
     * @param string $pathTo
     * @param string $pathToFrom

There is no parameter named $pathToFrom. Did you maybe mean $pathTo?

     * @return bool
     */
    public function move($filename, $pathTo, $pathFrom = null)

This method seems to be duplicated in your project.

    {
        if ($pathFrom==null) {
            $pathFrom=$this->_filePath;
        }
        if (file_exists($pathFrom."/".$filename)) {
            $this->createDir($pathTo);
            return rename($pathFrom."/".$filename, $pathTo."/".$filename);
        } else {
            return null;
        }
    }
    
    /**
     * Rename a file
     *
     * @param string $oldName
     * @param string $pathTo

There is no parameter named $pathTo. Did you maybe mean $pathToFile?

     * @param string $pathToFrom

There is no parameter named $pathToFrom. Was it maybe removed?

     * @return bool
     * @todo consider merging rename() and move() into one method
     */
    public function rename($oldName, $newName, $pathToFile = null)

This method seems to be duplicated in your project.

    {
        if ($pathToFile==null) {
            $pathToFile=$this->_filePath;
        }
        if (file_exists($pathToFile."/".$oldName)) {
            $this->createDir($pathToFile);
            return rename($pathToFile."/".$oldName, $pathToFile."/".$newName);
        } else {
            return false;
        }
    }
    
    /**
     * Copy a file
     *
     * @param string $filename
     * @param string $newFilePath
     * @param string $newFileName
     * @param string $pathToFile
     * @return bool
     */
    public function copy($filename, $newFilePath, $newFileName = null, $pathToFile = null)
    {
        if ($pathToFile==null) {

It seems like you are loosely comparing $pathToFile of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $pathToFile=$this->_filePath;
        }
        if ($newFileName==null) {

It seems like you are loosely comparing $newFileName of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $newFileName=$filename;
        }
        if (file_exists($pathToFile."/".$filename)) {
            return copy($pathToFile."/".$filename, $newFilePath."/".$newFileName);
        } else {
            return false;
        }
    }
    
    /**
     * Check if a file exists
     *
     * @param string $filename
     * @param string $pathToFile
     * @return bool
     */
    public function fileExists($filename, $pathToFile = null)
    {
        if ($pathToFile==null) {

It seems like you are loosely comparing $pathToFile of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $pathToFile=$this->_filePath;
        }
        return file_exists($pathToFile."/".$filename);
    }
    
    /**
     * Destructor
     */
    public function __destruct()
    {
    }
}