Swift_ByteStream_FileByteStream

Complexity

Total Complexity

40

Size/Duplication

Total Lines	284
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

51.52%

12 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	13	5
A	getPath()	0	4	1
C	read()	0	46	9
A	setReadPointer()	0	7	2
A	_commit()	0	5	1
A	_flush()	0	3	1
A	_getReadHandle()	0	21	4
A	_getWriteHandle()	0	16	3
A	_resetReadHandle()	0	7	2
A	_getReadStreamSeekableStatus()	0	5	1
A	_seekReadStreamToPosition()	0	17	4
C	_copyReadStream()	0	29	7

<?php

/*
 * This file is part of SwiftMailer.
 * (c) 2004-2009 Chris Corbyn
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

/**
 * Allows reading and writing of bytes to and from a file.
 *
 * @author Chris Corbyn
 */
class Swift_ByteStream_FileByteStream extends Swift_ByteStream_AbstractFilterableInputStream implements Swift_FileStream

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    /**
     * The internal pointer offset
     *
     * @var int
     */
    private $_offset = 0;

    /**
     * The path to the file
     *
     * @var string
     */
    private $_path;

    /**
     * The mode this file is opened in for writing
     *
     * @var string
     */
    private $_mode;

    /**
     * A lazy-loaded resource handle for reading the file
     *
     * @var resource
     */
    private $_reader;

    /**
     * A lazy-loaded resource handle for writing the file
     *
     * @var resource
     */
    private $_writer;

    /**
     * If magic_quotes_runtime is on, this will be true
     *
     * @var bool
     */
    private $_quotes = false;

    /**
     * If stream is seekable true/false, or null if not known
     *
     * @var null|boolean
     */
    private $_seekable = null;

    /**
     * Create a new FileByteStream for $path.
     *
     * @param string     $path
     * @param bool|false $writable
     *
     * @throws Swift_IoException
     */
    public function __construct($path, $writable = false)
    {
        if (empty($path)) {
            throw new Swift_IoException('The path cannot be empty');
        }

        $this->_path = $path;
        $this->_mode = $writable ? 'w+b' : 'rb';

        if (function_exists('get_magic_quotes_runtime') && @get_magic_quotes_runtime() == 1) {
            $this->_quotes = true;
        }
    }

    /**
     * Get the complete path to the file.
     *
     * @return string
     */
    public function getPath()
    {
        return $this->_path;
    }

    /**
     * Reads $length bytes from the stream into a string and moves the pointer
     * through the stream by $length.
     *
     * If less bytes exist than are requested the
     * remaining bytes are given instead. If no bytes are remaining at all, boolean
     * false is returned.
     *
     * @param int $length
     *
     * @throws Swift_IoException
     *
     * @return string|bool
     */
    public function read($length)
    {
        $fp = $this->_getReadHandle();
        if ($fp && !feof($fp)) {

            if ($this->_quotes) {
                ini_set('magic_quotes_runtime', 0);
            }

            // checking for errors v1
            if (ord(fread($fp, 1)) != 0) {
                $this->_resetReadHandle();

                return false;
            }

            $bytes = fread($fp, $length);

            // checking for errors v2
            if ($bytes === false) {
                $this->_resetReadHandle();

                return false;
            }

            if ($this->_quotes) {
                ini_set('magic_quotes_runtime', 1);
            }

            $this->_offset = ftell($fp);

            // If we read one byte after reaching the end of the file
            // feof() will return false and an empty string is returned.
            if ($bytes === '' && feof($fp)) {
                $this->_resetReadHandle();

                return false;
            }

            return $bytes;
        }

        $this->_resetReadHandle();

        return false;
    }

    /**
     * Move the internal read pointer to $byteOffset in the stream.
     *
     * @param int $byteOffset
     *
     * @return bool
     */
    public function setReadPointer($byteOffset)
    {
        if (isset($this->_reader)) {
            $this->_seekReadStreamToPosition($byteOffset);
        }
        $this->_offset = $byteOffset;
    }

    /** Just write the bytes to the file */
    protected function _commit($bytes)
    {
        fwrite($this->_getWriteHandle(), $bytes);
        $this->_resetReadHandle();
    }

    /** Not used */
    protected function _flush()
    {
    }

    /** Get the resource for reading */
    private function _getReadHandle()
    {
        if (!isset($this->_reader)) {
            $pointer = fopen($this->_path, 'rb');

            if (!$pointer) {
                throw new Swift_IoException(
                    'Unable to open file for reading [' . $this->_path . ']'
                );
            }

            $this->_reader = $pointer;

            if ($this->_offset != 0) {
                $this->_getReadStreamSeekableStatus();
                $this->_seekReadStreamToPosition($this->_offset);
            }
        }

        return $this->_reader;
    }

    /** Get the resource for writing */
    private function _getWriteHandle()
    {
        if (!isset($this->_writer)) {
            $pointer = fopen($this->_path, $this->_mode);

            if (!$pointer) {
                throw new Swift_IoException(
                    'Unable to open file for writing [' . $this->_path . ']'
                );
            }

            $this->_writer = $pointer;
        }

        return $this->_writer;
    }

    /** Force a reload of the resource for reading */
    private function _resetReadHandle()
    {
        if (isset($this->_reader)) {
            fclose($this->_reader);
            $this->_reader = null;
        }
    }

    /** Check if ReadOnly Stream is seekable */
    private function _getReadStreamSeekableStatus()
    {
        $metas = stream_get_meta_data($this->_reader);
        $this->_seekable = $metas['seekable'];
    }

    /**
     * Streams in a readOnly stream ensuring copy if needed
     *
     * @param $offset
     *
     * @throws Swift_IoException
     */
    private function _seekReadStreamToPosition($offset)
    {
        if ($this->_seekable === null) {
            $this->_getReadStreamSeekableStatus();
        }
        if ($this->_seekable === false) {
            $currentPos = ftell($this->_reader);
            if ($currentPos < $offset) {
                $toDiscard = $offset - $currentPos;
                fread($this->_reader, $toDiscard);

                return;
            }
            $this->_copyReadStream();
        }
        fseek($this->_reader, $offset, SEEK_SET);
    }

    /** Copy a readOnly Stream to ensure seekability */
    private function _copyReadStream()
    {
        $tmpFile = fopen('php://temp/maxmemory:4096', 'w+b');
        if ($tmpFile) {

This if statement is empty and can be removed.

            /* We have opened a php:// Stream Should work without problem */
        } elseif (function_exists('sys_get_temp_dir') && is_writable(sys_get_temp_dir()) && ($tmpFile = tmpfile())) {

This elseif statement is empty, and could be removed.

            /* We have opened a tmpfile */
        } else {
            throw new Swift_IoException('Unable to copy the file to make it seekable, sys_temp_dir is not writable, php://memory not available');
        }

        $currentPos = ftell($this->_reader);

        fclose($this->_reader);

        $source = fopen($this->_path, 'rb');
        if (!$source) {
            throw new Swift_IoException('Unable to open file for copying [' . $this->_path . ']');
        }

        fseek($tmpFile, 0, SEEK_SET);
        while (!feof($source)) {
            fwrite($tmpFile, fread($source, 4096));
        }
        fseek($tmpFile, $currentPos, SEEK_SET);
        fclose($source);

        $this->_reader = $tmpFile;
    }
}