Swift_CharacterStream_ArrayCharacterStream::setCharReaderForCurrentCharset() - Code Metrics - Inspection of "[!]: try to fix bug #644 | https://github.com/swif..." - voku/swiftmailer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 5.x ( 546220...bd8586 )

by Lars

created 2016-05-28 10:09 UTC

setCharReaderForCurrentCharset() A

↳ Parent: Swift_CharacterStream_ArrayCharacterStream

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	2
eloc	3
c	1
b	1
f	0
nc	2
nop	0
dl	0
loc	6
ccs	4
cts	4
cp	1
crap	2
rs	9.4285

<?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.
 */

/**
 * A CharacterStream implementation which stores characters in an internal array.
 *
 * @author Chris Corbyn
 */
class Swift_CharacterStream_ArrayCharacterStream implements Swift_CharacterStream
namespace YourVendor;

class YourClass { }
{
    /**
     * A map of byte values and their respective characters
     *
     * @var array
     */
    private static $_charMap;

    /**
     * A map of characters and their derivative byte values
     *
     * @var array
     */
    private static $_byteMap;

    /**
     * The char reader (lazy-loaded) for the current charset
     *
     * @var Swift_CharacterReader
     */
    private $_charReader;

    /**
     * A factory for creating CharacterReader instance
     *
     * @var Swift_CharacterReaderFactory
     */
    private $_charReaderFactory;

    /**
     * The character set this stream is using
     *
     * @var string
     */
    private $_charset;

    /**
     * Array of characters
     *
     * @var array
     */
    private $_array = array();

    /**
     * Size of the array of character
     *
     * @var int
     */
    private $_array_size = 0;

    /**
     * The current character offset in the stream
     *
     * @var int
     */
    private $_offset = 0;

    /**
     * Create a new CharacterStream with the given $chars, if set.
     *
     * @param Swift_CharacterReaderFactory $factory for loading validators
     * @param string                       $charset used in the stream
     */
    public function __construct(Swift_CharacterReaderFactory $factory, $charset)
    {
        self::_initializeMaps();
        $this->setCharacterReaderFactory($factory);
        $this->setCharacterSet($charset);
    }

    /**
     * Set the character set used in this CharacterStream.
     *
     * @param string $charset
     */
    public function setCharacterSet($charset)
    {
        if ($charset) {
            $this->_charset = $charset;

            $this->_charReader = null;
            $this->setCharReaderForCurrentCharset();
        }
    }

    /**
     * Set the CharacterReaderFactory for multi charset support.
     *
     * @param Swift_CharacterReaderFactory $factory
     */
    public function setCharacterReaderFactory(Swift_CharacterReaderFactory $factory)
    {
        $this->_charReaderFactory = $factory;
    }

    /**
     * Set the char-reader for the current charset.
     */
    private function setCharReaderForCurrentCharset()
    {
        if (null === $this->_charReader) {
            $this->_charReader = $this->_charReaderFactory->getReaderFor($this->_charset);
        }
    }

    /**
     * Overwrite this character stream using the byte sequence in the byte stream.
     *
     * @param Swift_OutputByteStream $os output stream to read from
     */
    public function importByteStream(Swift_OutputByteStream $os)
    {
        $this->setCharReaderForCurrentCharset();

        $startLength = $this->_charReader->getInitialByteSize();
        while (false !== $bytes = $os->read($startLength)) {

            $c = array();
            $len = strlen($bytes);
            for ($i = 0; $i < $len; ++$i) {
                $c[] = self::$_byteMap[$bytes[$i]];
            }

            $size = count($c);
            $need = $this->_charReader->validateByteSequence($c, $size);

            if (
                $need > 0
                &&
                false !== $bytes = $os->read($need)
            ) {

                $len = strlen($bytes);
                for ($i = 0; $i < $len; ++$i) {
                    $c[] = self::$_byteMap[$bytes[$i]];
                }

            }

            $this->_array[] = $c;
            ++$this->_array_size;
        }
    }

    /**
     * Import a string a bytes into this CharacterStream, overwriting any existing
     * data in the stream.
     *
     * @param string $string
     */
    public function importString($string)
    {
        $this->flushContents();
        $this->write($string);
    }

    /**
     * Read $length characters from the stream and move the internal pointer
     * $length further into the stream.
     *
     * @param int $length
     *
     * @return false|string false on error
     */
    public function read($length)
    {
        if ($this->_offset === $this->_array_size) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        // Don't use array slice
        $arrays = array();
        $end = $length + $this->_offset;
        for ($i = $this->_offset; $i < $end; ++$i) {

            if (!isset($this->_array[$i])) {
                break;
            }
            $arrays[] = $this->_array[$i];
        }

        $this->_offset += $i - $this->_offset; // Limit function calls

        $chars = false;

        foreach ($arrays as $array) {
            $chars .= implode('', array_map('chr', $array));
        }

        return $chars;
    }

    /**
     * Read $length characters from the stream and return a 1-dimensional array
     * containing there octet values.
     *
     * @param int $length
     *
     * @return integer[]
     */
    public function readBytes($length)
    {
        if ($this->_offset === $this->_array_size) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $arrays = array();
        $end = $length + $this->_offset;
        for ($i = $this->_offset; $i < $end; ++$i) {

            if (!isset($this->_array[$i])) {
                break;
            }
            $arrays[] = $this->_array[$i];
        }

        $this->_offset += ($i - $this->_offset); // Limit function calls

        return call_user_func_array('array_merge', $arrays);
    }

    /**
     * Write $chars to the end of the stream.
     *
     * @param string $chars
     */
    public function write($chars)
    {
        $this->setCharReaderForCurrentCharset();

        $startLength = $this->_charReader->getInitialByteSize();

        $fp = fopen('php://memory', 'w+b');
        fwrite($fp, $chars);
        unset($chars);
        fseek($fp, 0, SEEK_SET);

        $buffer = array(0);
        $buf_pos = 1;
        $buf_len = 1;
        $has_data = true;
        do {
            $bytes = array();

            // Buffer Filing
            if ($buf_len - $buf_pos < $startLength) {
                $buf = array_splice($buffer, $buf_pos);
                $new = $this->_reloadBuffer($fp, 100);

                if ($new) {
                    $buffer = array_merge($buf, $new);
                    $buf_len = count($buffer);
                    $buf_pos = 0;
                } else {
                    $has_data = false;
                }
            }

            if ($buf_len - $buf_pos > 0) {

                $size = 0;
                for ($i = 0; $i < $startLength && isset($buffer[$buf_pos]); ++$i) {

                    ++$size;
                    $bytes[] = $buffer[$buf_pos++];
                }
                $need = $this->_charReader->validateByteSequence($bytes, $size);

                if ($need > 0) {
                    if ($buf_len - $buf_pos < $need) {
                        $new = $this->_reloadBuffer($fp, $need);

                        if ($new) {
                            $buffer = array_merge($buffer, $new);
                            $buf_len = count($buffer);
                        }
                    }

                    for ($i = 0; $i < $need && isset($buffer[$buf_pos]); ++$i) {

                        $bytes[] = $buffer[$buf_pos++];
                    }
                }

                $this->_array[] = $bytes;
                ++$this->_array_size;
            }
        } while ($has_data);

        fclose($fp);
    }

    /**
     * Move the internal pointer to $charOffset in the stream.
     *
     * @param int $charOffset
     */
    public function setPointer($charOffset)
    {
        if ($charOffset > $this->_array_size) {
            $charOffset = $this->_array_size;
        } elseif ($charOffset < 0) {
            $charOffset = 0;
        }

        $this->_offset = $charOffset;
    }

    /**
     * Empty the stream and reset the internal pointer.
     */
    public function flushContents()
    {
        $this->_offset = 0;
        $this->_array = array();
        $this->_array_size = 0;
    }

    /**
     * @param resource $fp
     * @param int      $len
     *
     * @return array|false false on error
     */
    private function _reloadBuffer($fp, $len)
    {
        if (!feof($fp)) {
            $bytes = fread($fp, $len);

            if ($bytes !== false) {
                $buf = array();
                $len = strlen($bytes);

                for ($i = 0; $i < $len; ++$i) {
                    $buf[] = self::$_byteMap[$bytes[$i]];
                }

                return $buf;
            }
        }

        return false;
    }

    private static function _initializeMaps()
    {
        if (!isset(self::$_charMap)) {
            self::$_charMap = array();

            for ($byte = 0; $byte < 256; ++$byte) {
                self::$_charMap[$byte] = chr($byte);
            }

            self::$_byteMap = array_flip(self::$_charMap);
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of SwiftMailer.
5			* (c) 2004-2009 Chris Corbyn
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			/**
12			* A CharacterStream implementation which stores characters in an internal array.
13			*
14			* @author Chris Corbyn
15			*/
16			class Swift_CharacterStream_ArrayCharacterStream implements Swift_CharacterStream
			0 ignored issues – show Coding Style Compatibility introduced 2015-11-22 11:38 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
17			{
18			/**
19			* A map of byte values and their respective characters
20			*
21			* @var array
22			*/
23			private static $_charMap;
24
25			/**
26			* A map of characters and their derivative byte values
27			*
28			* @var array
29			*/
30			private static $_byteMap;
31
32			/**
33			* The char reader (lazy-loaded) for the current charset
34			*
35			* @var Swift_CharacterReader
36			*/
37			private $_charReader;
38
39			/**
40			* A factory for creating CharacterReader instance
41			*
42			* @var Swift_CharacterReaderFactory
43			*/
44			private $_charReaderFactory;
45
46			/**
47			* The character set this stream is using
48			*
49			* @var string
50			*/
51			private $_charset;
52
53			/**
54			* Array of characters
55			*
56			* @var array
57			*/
58			private $_array = array();
59
60			/**
61			* Size of the array of character
62			*
63			* @var int
64			*/
65			private $_array_size = 0;
66
67			/**
68			* The current character offset in the stream
69			*
70			* @var int
71			*/
72			private $_offset = 0;
73
74			/**
75			* Create a new CharacterStream with the given $chars, if set.
76			*
77			* @param Swift_CharacterReaderFactory $factory for loading validators
78			* @param string $charset used in the stream
79			*/
80	54		public function __construct(Swift_CharacterReaderFactory $factory, $charset)
81			{
82	54		self::_initializeMaps();
83	54		$this->setCharacterReaderFactory($factory);
84	54		$this->setCharacterSet($charset);
85	54		}
86
87			/**
88			* Set the character set used in this CharacterStream.
89			*
90			* @param string $charset
91			*/
92	54		public function setCharacterSet($charset)
93			{
94	54		if ($charset) {
95	54		$this->_charset = $charset;
96	54
97			$this->_charReader = null;
98			$this->setCharReaderForCurrentCharset();
99			}
100			}
101
102			/**
103	54		* Set the CharacterReaderFactory for multi charset support.
104			*
105	54		* @param Swift_CharacterReaderFactory $factory
106	54		*/
107			public function setCharacterReaderFactory(Swift_CharacterReaderFactory $factory)
108			{
109			$this->_charReaderFactory = $factory;
110			}
111
112			/**
113	2		* Set the char-reader for the current charset.
114			*/
115	2		private function setCharReaderForCurrentCharset()
116	2		{
117			if (null === $this->_charReader) {
118			$this->_charReader = $this->_charReaderFactory->getReaderFor($this->_charset);
119	2		}
120	2		}
121
122	2		/**
123	2		* Overwrite this character stream using the byte sequence in the byte stream.
124	2		*
125	2		* @param Swift_OutputByteStream $os output stream to read from
126			*/
127			public function importByteStream(Swift_OutputByteStream $os)
128	2		{
129	2		$this->setCharReaderForCurrentCharset();
130	2
131	2		$startLength = $this->_charReader->getInitialByteSize();
132	2		while (false !== $bytes = $os->read($startLength)) {
133	2
134	2		$c = array();
135	2		$len = strlen($bytes);
136			for ($i = 0; $i < $len; ++$i) {
137			$c[] = self::$_byteMap[$bytes[$i]];
138			}
139
140	2		$size = count($c);
141	2		$need = $this->_charReader->validateByteSequence($c, $size);
142
143	2		if (
144			$need > 0
145			&&
146			false !== $bytes = $os->read($need)
147			) {
148
149			$len = strlen($bytes);
150			for ($i = 0; $i < $len; ++$i) {
151	17		$c[] = self::$_byteMap[$bytes[$i]];
152			}
153	17
154	17		}
155	17
156			$this->_array[] = $c;
157			++$this->_array_size;
158			}
159			}
160
161			/**
162			* Import a string a bytes into this CharacterStream, overwriting any existing
163			* data in the stream.
164			*
165	7		* @param string $string
166			*/
167	7		public function importString($string)
168	6		{
169			$this->flushContents();
170			$this->write($string);
171			}
172	6
173	6		/**
174	6		* Read $length characters from the stream and move the internal pointer
175	6		* $length further into the stream.
176	2		*
177			* @param int $length
178	6		*
179			* @return false\|string false on error
180			*/
181	6		public function read($length)
182			{
183	6		if ($this->_offset === $this->_array_size) {
184	6		return false;
			0 ignored issues – show Bug Best Practice introduced 2015-11-22 11:38 UTC by Report Bug Copy Issue Report The return type of `return false;` (`false`) is incompatible with the return type declared by the interface `Swift_CharacterStream::read` of type `string`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
185	6		}
186
187			// Don't use array slice
188	6		$arrays = array();
189			$end = $length + $this->_offset;
190		View Code Duplication	for ($i = $this->_offset; $i < $end; ++$i) {
			0 ignored issues – show Duplication introduced 2015-11-22 11:38 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
191			if (!isset($this->_array[$i])) {
192			break;
193			}
194			$arrays[] = $this->_array[$i];
195			}
196
197			$this->_offset += $i - $this->_offset; // Limit function calls
198
199	9		$chars = false;
			0 ignored issues – show Comprehensibility Best Practice introduced 2016-02-10 17:04 UTC by Report Bug Copy Issue Report The expression `false;` of type `false` adds `false` to the return on line 204 which is incompatible with the return type declared by the interface `Swift_CharacterStream::read` of type `string`. It seems like you forgot to handle an error condition. Loading history...
200			foreach ($arrays as $array) {
201	9		$chars .= implode('', array_map('chr', $array));
202	9		}
203
204			return $chars;
205	9		}
206	9
207	9		/**
208	9		* Read $length characters from the stream and return a 1-dimensional array
209	8		* containing there octet values.
210			*
211	9		* @param int $length
212			*
213			* @return integer[]
214	9		*/
215			public function readBytes($length)
216	9		{
217			if ($this->_offset === $this->_array_size) {
218			return false;
			0 ignored issues – show Bug Best Practice introduced 2015-11-22 11:38 UTC by Report Bug Copy Issue Report The return type of `return false;` (`false`) is incompatible with the return type declared by the interface `Swift_CharacterStream::readBytes` of type `integer[]`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
219			}
220
221			$arrays = array();
222			$end = $length + $this->_offset;
223		View Code Duplication	for ($i = $this->_offset; $i < $end; ++$i) {
			0 ignored issues – show Duplication introduced 2015-11-22 11:38 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
224	17		if (!isset($this->_array[$i])) {
225			break;
226	17		}
227	17		$arrays[] = $this->_array[$i];
228			}
229
230	17		$this->_offset += ($i - $this->_offset); // Limit function calls
231
232	17		return call_user_func_array('array_merge', $arrays);
233	17		}
234	17
235	17		/**
236			* Write $chars to the end of the stream.
237	17		*
238	17		* @param string $chars
239	17		*/
240	17		public function write($chars)
241			{
242	17		$this->setCharReaderForCurrentCharset();
243
244	17		$startLength = $this->_charReader->getInitialByteSize();
245	17
246	17		$fp = fopen('php://memory', 'w+b');
247	17		fwrite($fp, $chars);
248	17		unset($chars);
249	17		fseek($fp, 0, SEEK_SET);
250	17
251			$buffer = array(0);
252	17		$buf_pos = 1;
253			$buf_len = 1;
254			$has_data = true;
255	17		do {
256	17		$bytes = array();
257	17
258	17		// Buffer Filing
259	17		if ($buf_len - $buf_pos < $startLength) {
260			$buf = array_splice($buffer, $buf_pos);
261	17		$new = $this->_reloadBuffer($fp, 100);
262
263			if ($new) {
264	17		$buffer = array_merge($buf, $new);
265	11		$buf_len = count($buffer);
266	2		$buf_pos = 0;
267			} else {
268	2		$has_data = false;
269	2		}
270	2		}
271
272			if ($buf_len - $buf_pos > 0) {
273	11
274	11		$size = 0;
275		View Code Duplication	for ($i = 0; $i < $startLength && isset($buffer[$buf_pos]); ++$i) {
			0 ignored issues – show Duplication introduced 2015-11-22 11:38 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
276			++$size;
277	17		$bytes[] = $buffer[$buf_pos++];
278	17		}
279			$need = $this->_charReader->validateByteSequence($bytes, $size);
280	17
281			if ($need > 0) {
282	17		if ($buf_len - $buf_pos < $need) {
283	17		$new = $this->_reloadBuffer($fp, $need);
284
285			if ($new) {
286			$buffer = array_merge($buffer, $new);
287			$buf_len = count($buffer);
288			}
289			}
290	1
291		View Code Duplication	for ($i = 0; $i < $need && isset($buffer[$buf_pos]); ++$i) {
			0 ignored issues – show Duplication introduced 2015-11-22 11:38 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
292	1		$bytes[] = $buffer[$buf_pos++];
293			}
294	1		}
295
296			$this->_array[] = $bytes;
297	1		++$this->_array_size;
298	1		}
299			} while ($has_data);
300
301			fclose($fp);
302			}
303	17
304			/**
305	17		* Move the internal pointer to $charOffset in the stream.
306	17		*
307	17		* @param int $charOffset
308	17		*/
309			public function setPointer($charOffset)
310			{
311			if ($charOffset > $this->_array_size) {
312			$charOffset = $this->_array_size;
313			} elseif ($charOffset < 0) {
314			$charOffset = 0;
315			}
316	17
317			$this->_offset = $charOffset;
318	17		}
319	17
320	17		/**
321	17		* Empty the stream and reset the internal pointer.
322	17		*/
323	17		public function flushContents()
324	17		{
325			$this->_offset = 0;
326			$this->_array = array();
327	17		$this->_array_size = 0;
328			}
329
330			/**
331			* @param resource $fp
332			* @param int $len
333			*
334	54		* @return array\|false false on error
335			*/
336	54		private function _reloadBuffer($fp, $len)
337	1		{
338	1		if (!feof($fp)) {
339	1		$bytes = fread($fp, $len);
340
341	1		if ($bytes !== false) {
342			$buf = array();
343	54		$len = strlen($bytes);
344
345			for ($i = 0; $i < $len; ++$i) {
346			$buf[] = self::$_byteMap[$bytes[$i]];
347			}
348
349			return $buf;
350			}
351			}
352
353			return false;
354			}
355
356			private static function _initializeMaps()
357			{
358			if (!isset(self::$_charMap)) {
359			self::$_charMap = array();
360
361			for ($byte = 0; $byte < 256; ++$byte) {
362			self::$_charMap[$byte] = chr($byte);
363			}
364
365			self::$_byteMap = array_flip(self::$_charMap);
366			}
367			}
368			}
369

voku / swiftmailer

Push — 5.x ( 546220...bd8586 )

setCharReaderForCurrentCharset() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like