MVar\LogParser\LogIterator

Complexity

Total Complexity

17

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	__destruct()	0	4	1
A	getFileHandler()	0	14	3
A	readLine()	0	19	4
A	current()	0	14	3
A	next()	0	4	1
A	key()	0	4	1
A	valid()	0	4	2
A	rewind()	0	4	1

<?php

/*
 * (c) Mantas Varatiejus <var.mantas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace MVar\LogParser;

use MVar\LogParser\Exception\MatchException;
use MVar\LogParser\Exception\ParserException;

/**
 * This is the class that helps to iterate through log file.
 */
class LogIterator implements \Iterator
{
    /**
     * @var LineParserInterface
     */
    private $parser;

    /**
     * @var string
     */
    private $logFile;

    /**
     * @var resource
     */
    private $fileHandler;

    /**
     * @var string
     */
    private $currentLine;

    /**
     * @var bool
     */
    private $skipEmptyLines;

    /**
     * Constructor.
     *
     * @param string              $logFile
     * @param LineParserInterface $parser
     * @param bool                $skipEmptyLines
     */
    public function __construct($logFile, $parser, $skipEmptyLines = true)
    {
        $this->logFile = $logFile;
        $this->parser = $parser;
        $this->skipEmptyLines = $skipEmptyLines;
    }

    /**
     * Destructor.
     */
    public function __destruct()
    {
        @fclose($this->fileHandler);

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

    }

    /**
     * Returns file handler.
     *
     * @return resource
     * @throws ParserException
     */
    protected function getFileHandler()
    {
        if ($this->fileHandler === null) {
            $fileHandler = @fopen($this->logFile, 'r');

            if ($fileHandler === false) {
                throw new ParserException('Can not open log file.');
            }

            $this->fileHandler = $fileHandler;
        }

        return $this->fileHandler;
    }

    /**
     * Reads single line from file.
     *
     * @throws ParserException
     */
    protected function readLine()
    {
        $buffer = '';

        while ($buffer === '') {
            if (($buffer = fgets($this->getFileHandler())) === false) {
                $this->currentLine = null;

                return;
            }
            $buffer = trim($buffer, "\n\r\0");

            if (!$this->skipEmptyLines) {
                break;
            }
        }

        $this->currentLine = $buffer;
    }

    /**
     * Returns parsed current line.
     *
     * @return array|null
     */
    public function current()
    {
        if ($this->currentLine === null) {
            $this->readLine();
        }

        try {
            $data = $this->parser->parseLine($this->currentLine);
        } catch (MatchException $exception) {
            $data = null;
        }

        return $data;
    }

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        $this->readLine();
    }

    /**
     * Returns current line
     *
     * @return string
     */
    public function key()
    {
        return $this->currentLine;
    }

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        return !feof($this->getFileHandler()) || $this->currentLine;
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        rewind($this->getFileHandler());
    }
}