AtomicTempFileObject::compare() - Code Metrics - gielfeldt/iterators - Measure and Improve Code Quality continuously with Scrutinizer

AtomicTempFileObject::compare() A
last analyzed 2018-11-04 00:57 UTC

↳ Parent: AtomicTempFileObject

Complexity

Conditions	5
Paths	5

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	5

Importance

Changes

Metric	Value
dl	0
loc	30
rs	9.1288
c	0
b	0
f	0
ccs	16
cts	16
cp	1
cc	5
nc	5
nop	1
crap	5

<?php

namespace Gielfeldt\Iterators;

class AtomicTempFileObject extends \SplFileObject
{
    const DISCARD = 1;
    const PERSIST = 2;
    const PERSIST_UNCHANGED = 3;

    protected $destinationRealPath;
    protected $persist = 0;
    protected $onPersistCallback;
    protected $onDiscardCallback;
    protected $onCompareCallback;

    /**
     * Constructor.
     */
    public function __construct(string $filename, $mode = 0755)
    {
        $tempDir = dirname($filename);
        if (!file_exists($tempDir)) {
            if (!@mkdir($tempDir, $mode, true)) {
                // @codeCoverageIgnoreStart
                $lastError = error_get_last();
                throw new \RuntimeException(
                    sprintf(
                        "Could create directory %s - message: %s",
                        $tempDir,
                        $lastError['message']
                    )
                );
                // @codeCoverageIgnoreEnd
            }
        }
        $tempPrefix = basename($filename) . '.AtomicTempFileObject.';
        $this->destinationRealPath = $filename;
        parent::__construct(tempnam($tempDir, $tempPrefix), "w+");
        $this->onCompare([self::class, 'compare']);
    }

    /**
     * Get the destination real path.
     *
     * @return string
     *   The real path of the destination.
     */
    public function getDestinationRealPath(): string
    {
        return $this->destinationRealPath;
    }

    /**
     * Move temp file into the destination upon object desctruction.
     */
    public function persistOnClose($persist = self::PERSIST): AtomicTempFileObject
    {
        $this->persist = $persist;
        return $this;
    }

    public function onPersist(callable $callback)
    {
        $this->onPersistCallback = \Closure::fromCallable($callback);
    }

    public function onDiscard(callable $callback)
    {
        $this->onDiscardCallback = \Closure::fromCallable($callback);
    }

    public function onCompare(callable $callback)
    {
        $this->onCompareCallback = \Closure::fromCallable($callback);
    }

    private function doPersist()
    {
        if (!@rename($this->getRealPath(), $this->destinationRealPath)) {
            // @codeCoverageIgnoreStart
            $lastError = error_get_last();
            throw new \RuntimeException(
                sprintf(
                    "Could not move %s to %s - message: %s",
                    $this->getRealPath(),
                    $this->destinationRealPath,
                    $lastError['message']
                )
            );
            // @codeCoverageIgnoreEnd
        }
        if ($this->onPersistCallback) {
            ($this->onPersistCallback)($this);
        }
    }

    private function doDiscard()
    {
        if (!@unlink($this->getRealPath())) {
            // @codeCoverageIgnoreStart
            $lastError = error_get_last();
            throw new \RuntimeException(
                sprintf(
                    "Could not remove %s - message: %s",
                    $this->getRealPath(),
                    $lastError['message']
                )
            );
            // @codeCoverageIgnoreEnd
        }
        if ($this->onDiscardCallback) {
            ($this->onDiscardCallback)($this);
        }
    }

    private function doCompare()
    {
        return ($this->onCompareCallback)($this);
    }

    /**
     * Move temp file into the destination if applicable.
     */
    public function __destruct()
    {
        $this->fflush();
        if ($this->persist == self::PERSIST || $this->persist == self::PERSIST_UNCHANGED) {
            if ($this->persist == self::PERSIST_UNCHANGED || !$this->doCompare()) {
                $this->doPersist();
            } else {
                $this->doDiscard();
            }
        } elseif ($this->persist & self::DISCARD) {
            $this->doDiscard();
        } else {
            // @codeCoverageIgnoreStart
            trigger_error("Temp file left on device: " . $this->getRealPath(), E_USER_WARNING);
            // @codeCoverageIgnoreEnd
        }
    }

    /**
     * Easy access iterator apply for processing an entire file.
     *
     * @param \Iterator $input    [description]
     * @param callable  $callback [description]
     */
    public function process(\Iterator $input, callable $callback)

    {
        $callback = \Closure::fromCallable($callback);
        $input->rewind();
        iterator_apply(
            $input,
            function (\Iterator $iterator) use ($callback) {
                $callback($iterator->current(), $iterator->key(), $iterator, $this);
                return true;
            },
            [$input]
        );
        return $this;
    }

    /**
     * Atomic file_put_contents().
     *
     * @see file_put_contents()
     */
    public static function file_put_contents($filename, $data, $flags = 0)
    {
        if ($flags & FILE_USE_INCLUDE_PATH) {
            $file = (new \SplFileInfo($filename))->openFile('r', true);
            if ($file) {
                $filename = $file->getRealPath();
            }
        }
        $tempFile = new static($filename);
        $tempFile->fwrite($data);
        $tempFile->persistOnClose();
        unset($tempFile);
    }

    /**
     * File comparison
     *
     * @return bool
     *   True if the contents of this file matches the contents of $filename.
     */
    private static function compare(AtomicTempFileObject $tempFile): bool
    {
        $filename = $tempFile->getDestinationRealPath();
        if (!file_exists($filename)) {
            return false;
        }

        // This is a temp file opened for writing and truncated to begin with,
        // so we assume that the current position is the size of the new file.
        $pos = $tempFile->ftell();

        $file = new \SplFileObject($filename, 'r');
        if ($pos <> $file->getSize()) {
            return false;
        }

        // Rewind this temp file and compare it with the specified file.
        $identical = true;
        $tempFile->fseek(0);
        while (!$file->eof()) {
            if ($file->fread(8192) != $tempFile->fread(8192)) {
                $identical = false;
                break;
            }
        }

        // Reset file pointer to end of file.
        $tempFile->fseek($pos);
        return $identical;
    }
}


1			<?php
2
3			namespace Gielfeldt\Iterators;
4
5			class AtomicTempFileObject extends \SplFileObject
6			{
7			const DISCARD = 1;
8			const PERSIST = 2;
9			const PERSIST_UNCHANGED = 3;
10
11			protected $destinationRealPath;
12			protected $persist = 0;
13			protected $onPersistCallback;
14			protected $onDiscardCallback;
15			protected $onCompareCallback;
16
17			/**
18			* Constructor.
19			*/
20	21		public function __construct(string $filename, $mode = 0755)
21			{
22	21		$tempDir = dirname($filename);
23	21		if (!file_exists($tempDir)) {
24	4		if (!@mkdir($tempDir, $mode, true)) {
25			// @codeCoverageIgnoreStart
26			$lastError = error_get_last();
27			throw new \RuntimeException(
28			sprintf(
29			"Could create directory %s - message: %s",
30			$tempDir,
31			$lastError['message']
32			)
33			);
34			// @codeCoverageIgnoreEnd
35			}
36			}
37	21		$tempPrefix = basename($filename) . '.AtomicTempFileObject.';
38	21		$this->destinationRealPath = $filename;
39	21		parent::__construct(tempnam($tempDir, $tempPrefix), "w+");
40	21		$this->onCompare([self::class, 'compare']);
41	21		}
42
43			/**
44			* Get the destination real path.
45			*
46			* @return string
47			* The real path of the destination.
48			*/
49	15		public function getDestinationRealPath(): string
50			{
51	15		return $this->destinationRealPath;
52			}
53
54			/**
55			* Move temp file into the destination upon object desctruction.
56			*/
57	20		public function persistOnClose($persist = self::PERSIST): AtomicTempFileObject
58			{
59	20		$this->persist = $persist;
60	20		return $this;
61			}
62
63	1		public function onPersist(callable $callback)
64			{
65	1		$this->onPersistCallback = \Closure::fromCallable($callback);
66	1		}
67
68	1		public function onDiscard(callable $callback)
69			{
70	1		$this->onDiscardCallback = \Closure::fromCallable($callback);
71	1		}
72
73	21		public function onCompare(callable $callback)
74			{
75	21		$this->onCompareCallback = \Closure::fromCallable($callback);
76	21		}
77
78	12		private function doPersist()
79			{
80	12	View Code Duplication	if (!@rename($this->getRealPath(), $this->destinationRealPath)) {
81			// @codeCoverageIgnoreStart
82			$lastError = error_get_last();
83			throw new \RuntimeException(
84			sprintf(
85			"Could not move %s to %s - message: %s",
86			$this->getRealPath(),
87			$this->destinationRealPath,
88			$lastError['message']
89			)
90			);
91			// @codeCoverageIgnoreEnd
92			}
93	12		if ($this->onPersistCallback) {
94	1		($this->onPersistCallback)($this);
95			}
96	12		}
97
98	12		private function doDiscard()
99			{
100	12	View Code Duplication	if (!@unlink($this->getRealPath())) {
101			// @codeCoverageIgnoreStart
102			$lastError = error_get_last();
103			throw new \RuntimeException(
104			sprintf(
105			"Could not remove %s - message: %s",
106			$this->getRealPath(),
107			$lastError['message']
108			)
109			);
110			// @codeCoverageIgnoreEnd
111			}
112	12		if ($this->onDiscardCallback) {
113	1		($this->onDiscardCallback)($this);
114			}
115	12		}
116
117	12		private function doCompare()
118			{
119	12		return ($this->onCompareCallback)($this);
120			}
121
122			/**
123			* Move temp file into the destination if applicable.
124			*/
125	21		public function __destruct()
126			{
127	21		$this->fflush();
128	21		if ($this->persist == self::PERSIST \|\| $this->persist == self::PERSIST_UNCHANGED) {
129	12		if ($this->persist == self::PERSIST_UNCHANGED \|\| !$this->doCompare()) {
130	12		$this->doPersist();
131			} else {
132	2		$this->doDiscard();
133			}
134	11		} elseif ($this->persist & self::DISCARD) {
135	10		$this->doDiscard();
136			} else {
137			// @codeCoverageIgnoreStart
138			trigger_error("Temp file left on device: " . $this->getRealPath(), E_USER_WARNING);
139			// @codeCoverageIgnoreEnd
140			}
141	20		}
142
143			/**
144			* Easy access iterator apply for processing an entire file.
145			*
146			* @param \Iterator $input [description]
147			* @param callable $callback [description]
148			*/
149	1	View Code Duplication	public function process(\Iterator $input, callable $callback)
			0 ignored issues – show Duplication introduced 2018-11-04 00:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
150			{
151	1		$callback = \Closure::fromCallable($callback);
152	1		$input->rewind();
153	1		iterator_apply(
154			$input,
155	1		function (\Iterator $iterator) use ($callback) {
156	1		$callback($iterator->current(), $iterator->key(), $iterator, $this);
157	1		return true;
158	1		},
159	1		[$input]
160			);
161	1		return $this;
162			}
163
164			/**
165			* Atomic file_put_contents().
166			*
167			* @see file_put_contents()
168			*/
169	1		public static function file_put_contents($filename, $data, $flags = 0)
170			{
171	1		if ($flags & FILE_USE_INCLUDE_PATH) {
172	1		$file = (new \SplFileInfo($filename))->openFile('r', true);
173	1		if ($file) {
174	1		$filename = $file->getRealPath();
175			}
176			}
177	1		$tempFile = new static($filename);
178	1		$tempFile->fwrite($data);
179	1		$tempFile->persistOnClose();
180	1		unset($tempFile);
181	1		}
182
183			/**
184			* File comparison
185			*
186			* @return bool
187			* True if the contents of this file matches the contents of $filename.
188			*/
189	12		private static function compare(AtomicTempFileObject $tempFile): bool
190			{
191	12		$filename = $tempFile->getDestinationRealPath();
192	12		if (!file_exists($filename)) {
193	12		return false;
194			}
195
196			// This is a temp file opened for writing and truncated to begin with,
197			// so we assume that the current position is the size of the new file.
198	4		$pos = $tempFile->ftell();
199
200	4		$file = new \SplFileObject($filename, 'r');
201	4		if ($pos <> $file->getSize()) {
202	1		return false;
203			}
204
205			// Rewind this temp file and compare it with the specified file.
206	4		$identical = true;
207	4		$tempFile->fseek(0);
208	4		while (!$file->eof()) {
209	4		if ($file->fread(8192) != $tempFile->fread(8192)) {
210	3		$identical = false;
211	3		break;
212			}
213			}
214
215			// Reset file pointer to end of file.
216	4		$tempFile->fseek($pos);
217	4		return $identical;
218			}
219			}
220

gielfeldt / iterators

GitHub Access Token became invalid

AtomicTempFileObject::compare() A last analyzed 2018-11-04 00:57 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AtomicTempFileObject::compare() A
last analyzed 2018-11-04 00:57 UTC