Subversion-Projekte lars-tiefland.laravel_shop

<?php

/**

 * Hoa

 *

 *

 * @license

 *

 * New BSD License

 *

 * Copyright © 2007-2017, Hoa community. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in the

 *       documentation and/or other materials provided with the distribution.

 *     * Neither the name of the Hoa nor the names of its contributors may be

 *       used to endorse or promote products derived from this software without

 *       specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

namespace Psy\Readline\Hoa;

/**

 * Stream wrapper for the `hoa://` protocol.

 */

class ProtocolWrapper

{

    /**

     * Opened stream as a resource.

     */

    private $_stream = null;

    /**

     * Stream name (filename).

     */

    private $_streamName = null;

    /**

     * Stream context (given by the streamWrapper class) as a resource.

     */

    public $context = null;

    /**

     * Get the real path of the given URL.

     * Could return false if the path cannot be reached.

     */

    public static function realPath(string $path, bool $exists = true)

    {

        return ProtocolNode::getRoot()->resolve($path, $exists);

    }

    /**

     * Retrieve the underlying resource.

     *

     * `$castAs` can be `STREAM_CAST_FOR_SELECT` when `stream_select` is

     * calling `stream_cast` or `STREAM_CAST_AS_STREAM` when `stream_cast` is

     * called for other uses.

     */

    public function stream_cast(int $castAs)

    {

        return null;

    }

    /**

     * Closes a resource.

     * This method is called in response to `fclose`.

     * All resources that were locked, or allocated, by the wrapper should be

     * released.

     */

    public function stream_close()

    {

        if (true === @\fclose($this->getStream())) {

            $this->_stream = null;

            $this->_streamName = null;

        }

    }

    /**

     * Tests for end-of-file on a file pointer.

     * This method is called in response to feof().

     */

    public function stream_eof(): bool

    {

        return \feof($this->getStream());

    }

    /**

     * Flush the output.

     * This method is called in respond to fflush().

     * If we have cached data in our stream but not yet stored it into the

     * underlying storage, we should do so now.

     */

    public function stream_flush(): bool

    {

        return \fflush($this->getStream());

    }

    /**

     * Advisory file locking.

     * This method is called in response to flock(), when file_put_contents()

     * (when flags contains LOCK_EX), stream_set_blocking() and when closing the

     * stream (LOCK_UN).

     *

     * Operation is one the following:

     *   * LOCK_SH to acquire a shared lock (reader) ;

     *   * LOCK_EX to acquire an exclusive lock (writer) ;

     *   * LOCK_UN to release a lock (shared or exclusive) ;

     *   * LOCK_NB if we don't want flock() to

     *     block while locking (not supported on

     *     Windows).

     */

    public function stream_lock(int $operation): bool

    {

        return \flock($this->getStream(), $operation);

    }

    /**

     * Change stream options.

     * This method is called to set metadata on the stream. It is called when

     * one of the following functions is called on a stream URL: touch, chmod,

     * chown or chgrp.

     *

     * Option must be one of the following constant:

     *   * STREAM_META_TOUCH,

     *   * STREAM_META_OWNER_NAME,

     *   * STREAM_META_OWNER,

     *   * STREAM_META_GROUP_NAME,

     *   * STREAM_META_GROUP,

     *   * STREAM_META_ACCESS.

     *

     * Values are arguments of `touch`, `chmod`, `chown`, and `chgrp`.

     */

    public function stream_metadata(string $path, int $option, $values): bool

    {

        $path = static::realPath($path, false);

        switch ($option) {

            case \STREAM_META_TOUCH:

                $arity = \count($values);

                if (0 === $arity) {

                    $out = \touch($path);

                } elseif (1 === $arity) {

                    $out = \touch($path, $values[0]);

                } else {

                    $out = \touch($path, $values[0], $values[1]);

                }

                break;

            case \STREAM_META_OWNER_NAME:

            case \STREAM_META_OWNER:

                $out = \chown($path, $values);

                break;

            case \STREAM_META_GROUP_NAME:

            case \STREAM_META_GROUP:

                $out = \chgrp($path, $values);

                break;

            case \STREAM_META_ACCESS:

                $out = \chmod($path, $values);

                break;

            default:

                $out = false;

        }

        return $out;

    }

    /**

     * Open file or URL.

     * This method is called immediately after the wrapper is initialized (f.e.

     * by fopen() and file_get_contents()).

     */

    public function stream_open(string $path, string $mode, int $options, &$openedPath): bool

    {

        $path = static::realPath($path, 'r' === $mode[0]);

        if (Protocol::NO_RESOLUTION === $path) {

            return false;

        }

        if (null === $this->context) {

            $openedPath = \fopen($path, $mode, $options & \STREAM_USE_PATH);

        } else {

            $openedPath = \fopen(

                $path,

                $mode,

                (bool) ($options & \STREAM_USE_PATH),

                $this->context

            );

        }

        if (false === \is_resource($openedPath)) {

            return false;

        }

        $this->_stream = $openedPath;

        $this->_streamName = $path;

        return true;

    }

    /**

     * Read from stream.

     * This method is called in response to fread() and fgets().

     */

    public function stream_read(int $size): string

    {

        return \fread($this->getStream(), $size);

    }

    /**

     * Seek to specific location in a stream.

     * This method is called in response to fseek().

     * The read/write position of the stream should be updated according to the

     * $offset and $whence.

     *

     * The possible values for `$whence` are:

     *   * SEEK_SET to set position equal to $offset bytes,

     *   * SEEK_CUR to set position to current location plus `$offset`,

     *   * SEEK_END to set position to end-of-file plus `$offset`.

     */

    public function stream_seek(int $offset, int $whence = \SEEK_SET): bool

    {

        return 0 === \fseek($this->getStream(), $offset, $whence);

    }

    /**

     * Retrieve information about a file resource.

     * This method is called in response to fstat().

     */

    public function stream_stat(): array

    {

        return \fstat($this->getStream());

    }

    /**

     * Retrieve the current position of a stream.

     * This method is called in response to ftell().

     */

    public function stream_tell(): int

    {

        return \ftell($this->getStream());

    }

    /**

     * Truncate a stream to a given length.

     */

    public function stream_truncate(int $size): bool

    {

        return \ftruncate($this->getStream(), $size);

    }

    /**

     * Write to stream.

     * This method is called in response to fwrite().

     */

    public function stream_write(string $data): int

    {

        return \fwrite($this->getStream(), $data);

    }

    /**

     * Close directory handle.

     * This method is called in to closedir().

     * Any resources which were locked, or allocated, during opening and use of

     * the directory stream should be released.

     */

    public function dir_closedir()

    {

        \closedir($this->getStream());

        $this->_stream = null;

        $this->_streamName = null;

    }

    /**

     * Open directory handle.

     * This method is called in response to opendir().

     *

     * The `$options` input represents whether or not to enforce safe_mode

     * (0x04). It is not used here.

     */

    public function dir_opendir(string $path, int $options): bool

    {

        $path = static::realPath($path);

        $handle = null;

        if (null === $this->context) {

            $handle = @\opendir($path);

        } else {

            $handle = @\opendir($path, $this->context);

        }

        if (false === $handle) {

            return false;

        }

        $this->_stream = $handle;

        $this->_streamName = $path;

        return true;

    }

    /**

     * Read entry from directory handle.

     * This method is called in response to readdir().

     *

     * @return mixed

     */

    public function dir_readdir()

    {

        return \readdir($this->getStream());

    }

    /**

     * Rewind directory handle.

     * This method is called in response to rewinddir().

     * Should reset the output generated by self::dir_readdir, i.e. the next

     * call to self::dir_readdir should return the first entry in the location

     * returned by self::dir_opendir.

     */

    public function dir_rewinddir()

    {

        \rewinddir($this->getStream());

    }

    /**

     * Create a directory.

     * This method is called in response to mkdir().

     */

    public function mkdir(string $path, int $mode, int $options): bool

    {

        if (null === $this->context) {

            return \mkdir(

                static::realPath($path, false),

                $mode,

                $options | \STREAM_MKDIR_RECURSIVE

            );

        }

        return \mkdir(

            static::realPath($path, false),

            $mode,

            (bool) ($options | \STREAM_MKDIR_RECURSIVE),

            $this->context

        );

    }

    /**

     * Rename a file or directory.

     * This method is called in response to rename().

     * Should attempt to rename $from to $to.

     */

    public function rename(string $from, string $to): bool

    {

        if (null === $this->context) {

            return \rename(static::realPath($from), static::realPath($to, false));

        }

        return \rename(

            static::realPath($from),

            static::realPath($to, false),

            $this->context

        );

    }

    /**

     * Remove a directory.

     * This method is called in response to rmdir().

     * The `$options` input is a bitwise mask of values. It is not used here.

     */

    public function rmdir(string $path, int $options): bool

    {

        if (null === $this->context) {

            return \rmdir(static::realPath($path));

        }

        return \rmdir(static::realPath($path), $this->context);

    }

    /**

     * Delete a file.

     * This method is called in response to unlink().

     */

    public function unlink(string $path): bool

    {

        if (null === $this->context) {

            return \unlink(static::realPath($path));

        }

        return \unlink(static::realPath($path), $this->context);

    }

    /**

     * Retrieve information about a file.

     * This method is called in response to all stat() related functions.

     * The `$flags` input holds additional flags set by the streams API.  It

     * can hold one or more of the following values OR'd together.

     * STREAM_URL_STAT_LINK: for resource with the ability to link to other

     * resource (such as an HTTP location: forward, or a filesystem

     * symlink). This flag specified that only information about the link

     * itself should be returned, not the resource pointed to by the

     * link. This flag is set in response to calls to lstat(), is_link(), or

     * filetype().  STREAM_URL_STAT_QUIET: if this flag is set, our wrapper

     * should not raise any errors. If this flag is not set, we are

     * responsible for reporting errors using the trigger_error() function

     * during stating of the path.

     */

    public function url_stat(string $path, int $flags)

    {

        $path = static::realPath($path);

        if (Protocol::NO_RESOLUTION === $path) {

            if ($flags & \STREAM_URL_STAT_QUIET) {

                return 0;

            } else {

                return \trigger_error(

                    'Path '.$path.' cannot be resolved.',

                    \E_WARNING

                );

            }

        }

        if ($flags & \STREAM_URL_STAT_LINK) {

            return @\lstat($path);

        }

        return @\stat($path);

    }

    /**

     * Get stream resource.

     */

    public function getStream()

    {

        return $this->_stream;

    }

    /**

     * Get stream name.

     */

    public function getStreamName()

    {

        return $this->_streamName;

    }

}

/*

 * Register the `hoa://` protocol.

 */

\stream_wrapper_register('hoa', ProtocolWrapper::class);