hhxsv5 / laravel-s

src/Swoole/Inotify.php

<?php

Missing file doc comment

namespace Hhxsv5\LaravelS\Swoole;

use Swoole\Event;
use Swoole\Timer;

class Inotify

Missing doc comment for class Inotify

{
    private $fd;

Private member variable "fd" must be prefixed with an underscore

    private $watchPath;

Private member variable "watchPath" must be prefixed with an underscore

    private $watchMask;

Private member variable "watchMask" must be prefixed with an underscore

    private $watchHandler;

Private member variable "watchHandler" must be prefixed with an underscore

    private $doing        = false;

Private member variable "doing" must be prefixed with an underscore

    private $fileTypes    = [];

Private member variable "fileTypes" must be prefixed with an underscore

    private $excludedDirs = [];

Private member variable "excludedDirs" must be prefixed with an underscore

    private $wdPath       = [];

Private member variable "wdPath" must be prefixed with an underscore

    private $pathWd       = [];

Private member variable "pathWd" must be prefixed with an underscore

    public function __construct($watchPath, $watchMask, callable $watchHandler)

Missing doc comment for function __construct()

    {
        $this->fd = inotify_init();
        $this->watchPath = $watchPath;
        $this->watchMask = $watchMask;
        $this->watchHandler = $watchHandler;
    }

    public function addFileType($type)

Missing doc comment for function addFileType()

    {
        $type = '.' . trim($type, '.');
        $this->fileTypes[$type] = true;
    }

    public function addFileTypes(array $types)

Missing doc comment for function addFileTypes()

    {
        foreach ($types as $type) {
            $this->addFileType($type);
        }
    }

    public function addExcludedDir($dir)

Missing doc comment for function addExcludedDir()

    {
        $dir = realpath($dir);
        $this->excludedDirs[$dir] = $dir;
    }

    public function addExcludedDirs(array $dirs)

Missing doc comment for function addExcludedDirs()

    {
        foreach ($dirs as $dir) {
            $this->addExcludedDir($dir);
        }
    }

    public function isExcluded($path)

Missing doc comment for function isExcluded()

    {
        foreach ($this->excludedDirs as $excludedDir) {
            if ($excludedDir === $path || strpos($path, $excludedDir . '/') === 0) {
                return true;
            }
        }
        return false;
    }

    public function watch()

Missing doc comment for function watch()

    {
        $this->_watch($this->watchPath);
    }

    protected function _watch($path)

Protected method name "Inotify::_watch" must not be prefixed with an underscore

Missing doc comment for function _watch()

    {
        if ($this->isExcluded($path)) {
            return false;
        }
        $wd = inotify_add_watch($this->fd, $path, $this->watchMask);
        if ($wd === false) {
            return false;
        }
        $this->bind($wd, $path);

        if (is_dir($path)) {
            $wd = inotify_add_watch($this->fd, $path, $this->watchMask);
            if ($wd === false) {
                return false;
            }
            $this->bind($wd, $path);
            $files = scandir($path);
            foreach ($files as $file) {
                if ($file === '.' || $file === '..' || $this->isExcluded($file)) {
                    continue;
                }
                $file = $path . DIRECTORY_SEPARATOR . $file;
                if (is_dir($file)) {
                    $this->_watch($file);
                }
            }
        }
        return true;
    }

    protected function clearWatch()

Missing doc comment for function clearWatch()

    {
        foreach ($this->wdPath as $wd => $path) {
            @inotify_rm_watch($this->fd, $wd);

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

        }
        $this->wdPath = [];
        $this->pathWd = [];
    }

    protected function bind($wd, $path)

Missing doc comment for function bind()

    {
        $this->pathWd[$path] = $wd;
        $this->wdPath[$wd] = $path;
    }

    protected function unbind($wd, $path = null)

Missing doc comment for function unbind()

    {
        unset($this->wdPath[$wd]);
        if ($path !== null) {
            unset($this->pathWd[$path]);
        }
    }

    public function start()

Missing doc comment for function start()

    {
        Event::add($this->fd, function ($fp) {

The opening parenthesis of a multi-line function call should be the last content on the line.

            $events = inotify_read($fp);
            foreach ($events as $event) {
                if ($event['mask'] == IN_IGNORED) {
                    continue;
                }

                $fileType = strchr($event['name'], '.');
                if (!isset($this->fileTypes[$fileType])) {
                    continue;
                }

                if ($this->doing) {
                    continue;
                }

                Timer::after(100, function () use ($event) {

The opening parenthesis of a multi-line function call should be the last content on the line.

                    call_user_func_array($this->watchHandler, [$event]);
                    $this->doing = false;
                });

For multi-line function calls, the closing parenthesis should be on a new line.

                $this->doing = true;
                break;
            }
        });

For multi-line function calls, the closing parenthesis should be on a new line.

        Event::wait();
    }

    public function stop()

Missing doc comment for function stop()

    {
        Event::del($this->fd);
        fclose($this->fd);
    }

    public function getWatchedFileCount()

Missing doc comment for function getWatchedFileCount()

    {
        return count($this->wdPath);
    }

    public function __destruct()

Missing doc comment for function __destruct()

    {
        $this->stop();
    }
}