Swift_Transport_StreamBuffer - Code Metrics - Inspection of "[+]: re-add init-values" - voku/swiftmailer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 5.x ( 2cf8fe...f77ff9 )

by Lars

created 2016-03-14 00:45 UTC

Swift_Transport_StreamBuffer B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	342
Duplicated Lines	10.53 %

Coupling/Cohesion

Components	2
Dependencies	4

Test Coverage

Coverage

43.28%

Metric	Value
wmc	52
lcom	2
cbo	4
dl	36
loc	342
ccs	58
cts	134
cp	0.4328
rs	7.9487

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	startTLS()	0	4	1
A	setReadPointer()	0	3	1
A	_getReadConnectionDescription()	3	19	4
A	initialize()	0	13	3
B	setParam()	0	19	6
B	readLine()	14	14	5
B	read()	16	16	5
C	_establishSocketConnection()	3	41	7
A	_establishProcessConnection()	0	20	2
A	terminate()	0	19	4
B	setWriteTranslations()	0	19	5
A	_flush()	0	6	2
B	_commit()	0	22	6

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Swift_Transport_StreamBuffer often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Swift_Transport_StreamBuffer, and based on these observations, apply Extract Interface, too.

<?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 generic IoBuffer implementation supporting remote sockets and local processes.
 *
 * @author Chris Corbyn
 */
class Swift_Transport_StreamBuffer extends Swift_ByteStream_AbstractFilterableInputStream implements Swift_Transport_IoBuffer
namespace YourVendor;

class YourClass { }
{
    /**
     * A primary socket
     *
     * @var resource
     */
    private $_stream;

    /**
     * The input stream
     */
    private $_in;

    /**
     * The output stream
     */
    private $_out;

    /**
     * Buffer initialization parameters
     */
    private $_params = array();

    /**
     * The ReplacementFilterFactory
     *
     * @var Swift_ReplacementFilterFactory
     */
    private $_replacementFactory;

    /**
     * Translations performed on data being streamed into the buffer
     *
     * @var array
     */
    private $_translations = array();

    /**
     * Create a new StreamBuffer using $replacementFactory for transformations.
     *
     * @param Swift_ReplacementFilterFactory $replacementFactory
     */
    public function __construct(Swift_ReplacementFilterFactory $replacementFactory)
    {
        $this->_replacementFactory = $replacementFactory;
    }

    /**
     * Perform any initialization needed, using the given $params.
     *
     * Parameters will vary depending upon the type of IoBuffer used.
     *
     * @param array $params
     */
    public function initialize(array $params)
    {
        $this->_params = $params;
        switch ($params['type']) {
            case self::TYPE_PROCESS:
                $this->_establishProcessConnection();
                break;
            case self::TYPE_SOCKET:
            default:
                $this->_establishSocketConnection();
                break;
        }
    }

    /**
     * Set an individual param on the buffer (e.g. switching to SSL).
     *
     * @param string $param
     * @param integer  $value
     */
    public function setParam($param, $value)
    {
        if (isset($this->_stream)) {
            switch ($param) {
                case 'timeout':
                    if ($this->_stream) {
                        stream_set_timeout($this->_stream, $value);
                    }
                    break;

                case 'blocking':
                    if ($this->_stream) {
                        stream_set_blocking($this->_stream, 1);
                    }

            }
        }
        $this->_params[$param] = $value;
    }

    public function startTLS()
    {
        return stream_socket_enable_crypto($this->_stream, true, STREAM_CRYPTO_METHOD_TLS_CLIENT);
    }

    /**
     * Perform any shutdown logic needed.
     */
    public function terminate()
    {
        if (isset($this->_stream)) {
            switch ($this->_params['type']) {
                case self::TYPE_PROCESS:
                    fclose($this->_in);
                    fclose($this->_out);
                    proc_close($this->_stream);
                    break;
                case self::TYPE_SOCKET:
                default:
                    fclose($this->_stream);
                    break;
            }
        }
        $this->_stream = null;
        $this->_out = null;
        $this->_in = null;
    }

    /**
     * Set an array of string replacements which should be made on data written
     * to the buffer.
     *
     * This could replace LF with CRLF for example.
     *
     * @param string[] $replacements
     */
    public function setWriteTranslations(array $replacements)
    {
        foreach ($this->_translations as $search => $replace) {
            if (!isset($replacements[$search])) {
                $this->removeFilter($search);
                unset($this->_translations[$search]);
            }
        }

        foreach ($replacements as $search => $replace) {
            if (!isset($this->_translations[$search])) {
                $this->addFilter(
                    $this->_replacementFactory->createFilter($search, $replace),
                    $search
                );
                $this->_translations[$search] = true;
            }
        }
    }

    /**
     * Get a line of output (including any CRLF).
     *
     * The $sequence number comes from any writes and may or may not be used
     * depending upon the implementation.
     *
     * @param int $sequence of last write to scan from
     *
     * @throws Swift_IoException
     *
     * @return string
     */
    public function readLine($sequence)

    {
        if (isset($this->_out) && !feof($this->_out)) {
            $line = fgets($this->_out);
            if (!$line) {
                $metas = stream_get_meta_data($this->_out);
                if ($metas['timed_out']) {
                    throw new Swift_IoException('Connection to ' . $this->_getReadConnectionDescription() . ' Timed Out');
                }
            }

            return $line;
        }
    }

    /**
     * Reads $length bytes from the stream into a string and moves the pointer
     * through the stream by $length.
     *
     * If less bytes exist than are requested the remaining bytes are given instead.
     * If no bytes are remaining at all, boolean false is returned.
     *
     * @param int $length
     *
     * @throws Swift_IoException
     *
     * @return string|null
     */
    public function read($length)

    {
        if (isset($this->_out) && !feof($this->_out)) {
            $ret = fread($this->_out, $length);
            if (!$ret) {
                $metas = stream_get_meta_data($this->_out);
                if ($metas['timed_out']) {
                    throw new Swift_IoException(
                        'Connection to ' . $this->_getReadConnectionDescription() . ' Timed Out'
                    );
                }
            }

            return $ret;
        }
    }

    /** Not implemented */
    public function setReadPointer($byteOffset)
    {
    }

    /** Flush the stream contents */
    protected function _flush()
    {
        if (isset($this->_in)) {
            fflush($this->_in);
        }
    }

    /**
     * Write this bytes to the stream
     *
     * @param string $bytes
     *
     * @return int
     *
     * @throws Swift_IoException
     */
    protected function _commit($bytes)
    {
        if (isset($this->_in)) {
            $bytesToWrite = strlen($bytes);
            $totalBytesWritten = 0;

            while ($totalBytesWritten < $bytesToWrite) {
                $bytesWritten = fwrite($this->_in, substr($bytes, $totalBytesWritten));
                if (false === $bytesWritten || 0 === $bytesWritten) {
                    throw new Swift_IoException(
                        'Connection to ' . $this->_getReadConnectionDescription() . ' has gone away'
                    );
                }

                $totalBytesWritten += $bytesWritten;
            }

            if ($totalBytesWritten > 0) {
                return ++$this->_sequence;
            }
        }
    }

    /**
     * Establishes a connection to a remote server.
     */
    private function _establishSocketConnection()
    {
        // set default "php"-options for "stream_context_create"
        // and overwrite it with the "user"-options
        $options = stream_context_get_options(stream_context_get_default());

        $host = $this->_params['host'];
        if (!empty($this->_params['protocol'])) {

            $host = $this->_params['protocol'] . '://' . $host;
        }

        $timeout = 15;
        if (!empty($this->_params['timeout'])) {
            $timeout = $this->_params['timeout'];
        }

        if (!empty($this->_params['sourceIp'])) {
            $options['socket']['bindto'] = $this->_params['sourceIp'] . ':0';
        }

        if (isset($this->_params['stream_context_options'])) {
            $options = array_merge($options, $this->_params['stream_context_options']);
        }

        $streamContext = stream_context_create($options);
        $this->_stream = @stream_socket_client($host . ':' . $this->_params['port'], $errno, $errstr, $timeout, STREAM_CLIENT_CONNECT, $streamContext);

        if (false === $this->_stream) {
            throw new Swift_TransportException('Connection could not be established with host ' . $this->_params['host'] . ' [' . $errstr . ' #' . $errno . ']');
        }

        if (!empty($this->_params['blocking'])) {
            stream_set_blocking($this->_stream, 1);
        } else {
            stream_set_blocking($this->_stream, 0);
        }

        stream_set_timeout($this->_stream, $timeout);
        $this->_in = &$this->_stream;
        $this->_out = &$this->_stream;
    }

    /**
     * Opens a process for input/output.
     */
    private function _establishProcessConnection()
    {
        $command = $this->_params['command'];
        $descriptorSpec = array(
            0 => array('pipe', 'r'),
            1 => array('pipe', 'w'),
            2 => array('pipe', 'w'),
        );

        $this->_stream = proc_open($command, $descriptorSpec, $pipes);
        stream_set_blocking($pipes[2], 0);

        $err = stream_get_contents($pipes[2]);
        if ($err) {
            throw new Swift_TransportException('Process could not be started [' . $err . ']');
        }

        $this->_in = &$pipes[0];
        $this->_out = &$pipes[1];
    }

    private function _getReadConnectionDescription()
    {
        switch ($this->_params['type']) {
            case self::TYPE_PROCESS:
                return 'Process ' . $this->_params['command'];
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case self::TYPE_SOCKET:
            default:
                $host = $this->_params['host'];
                if (!empty($this->_params['protocol'])) {

                    $host = $this->_params['protocol'] . '://' . $host;
                }
                $host .= ':' . $this->_params['port'];

                return $host;
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
        }
    }
}


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 generic IoBuffer implementation supporting remote sockets and local processes.
13			*
14			* @author Chris Corbyn
15			*/
16			class Swift_Transport_StreamBuffer extends Swift_ByteStream_AbstractFilterableInputStream implements Swift_Transport_IoBuffer
			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 primary socket
20			*
21			* @var resource
22			*/
23			private $_stream;
24
25			/**
26			* The input stream
27			*/
28			private $_in;
29
30			/**
31			* The output stream
32			*/
33			private $_out;
34
35			/**
36			* Buffer initialization parameters
37			*/
38			private $_params = array();
39
40			/**
41			* The ReplacementFilterFactory
42			*
43			* @var Swift_ReplacementFilterFactory
44			*/
45			private $_replacementFactory;
46
47			/**
48			* Translations performed on data being streamed into the buffer
49			*
50			* @var array
51			*/
52			private $_translations = array();
53
54			/**
55			* Create a new StreamBuffer using $replacementFactory for transformations.
56			*
57			* @param Swift_ReplacementFilterFactory $replacementFactory
58			*/
59	8		public function __construct(Swift_ReplacementFilterFactory $replacementFactory)
60			{
61	8		$this->_replacementFactory = $replacementFactory;
62	8		}
63
64			/**
65			* Perform any initialization needed, using the given $params.
66			*
67			* Parameters will vary depending upon the type of IoBuffer used.
68			*
69			* @param array $params
70			*/
71	5		public function initialize(array $params)
72			{
73	5		$this->_params = $params;
74	5		switch ($params['type']) {
75	5		case self::TYPE_PROCESS:
76			$this->_establishProcessConnection();
77			break;
78	5		case self::TYPE_SOCKET:
79			default:
80	5		$this->_establishSocketConnection();
81	5		break;
82			}
83	5		}
84
85			/**
86			* Set an individual param on the buffer (e.g. switching to SSL).
87			*
88			* @param string $param
89			* @param integer $value
90			*/
91			public function setParam($param, $value)
92			{
93			if (isset($this->_stream)) {
94			switch ($param) {
95			case 'timeout':
96			if ($this->_stream) {
97			stream_set_timeout($this->_stream, $value);
98			}
99			break;
100
101			case 'blocking':
102			if ($this->_stream) {
103			stream_set_blocking($this->_stream, 1);
104			}
105
106			}
107			}
108			$this->_params[$param] = $value;
109			}
110
111			public function startTLS()
112			{
113			return stream_socket_enable_crypto($this->_stream, true, STREAM_CRYPTO_METHOD_TLS_CLIENT);
114			}
115
116			/**
117			* Perform any shutdown logic needed.
118			*/
119			public function terminate()
120			{
121			if (isset($this->_stream)) {
122			switch ($this->_params['type']) {
123			case self::TYPE_PROCESS:
124			fclose($this->_in);
125			fclose($this->_out);
126			proc_close($this->_stream);
127			break;
128			case self::TYPE_SOCKET:
129			default:
130			fclose($this->_stream);
131			break;
132			}
133			}
134			$this->_stream = null;
135			$this->_out = null;
136			$this->_in = null;
137			}
138
139			/**
140			* Set an array of string replacements which should be made on data written
141			* to the buffer.
142			*
143			* This could replace LF with CRLF for example.
144			*
145			* @param string[] $replacements
146			*/
147	2		public function setWriteTranslations(array $replacements)
148			{
149	2		foreach ($this->_translations as $search => $replace) {
150	1		if (!isset($replacements[$search])) {
151			$this->removeFilter($search);
152	1		unset($this->_translations[$search]);
153			}
154			}
155
156	2		foreach ($replacements as $search => $replace) {
157	2		if (!isset($this->_translations[$search])) {
158	2		$this->addFilter(
159	2		$this->_replacementFactory->createFilter($search, $replace),
160			$search
161			);
162	2		$this->_translations[$search] = true;
163			}
164			}
165	2		}
166
167			/**
168			* Get a line of output (including any CRLF).
169			*
170			* The $sequence number comes from any writes and may or may not be used
171			* depending upon the implementation.
172			*
173			* @param int $sequence of last write to scan from
174			*
175			* @throws Swift_IoException
176			*
177			* @return string
178			*/
179	5	View Code Duplication	public function readLine($sequence)
			0 ignored issues – show Duplication introduced 2015-11-22 11:38 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...
180			{
181	5		if (isset($this->_out) && !feof($this->_out)) {
182	5		$line = fgets($this->_out);
183	5		if (!$line) {
184	1		$metas = stream_get_meta_data($this->_out);
185	1		if ($metas['timed_out']) {
186	1		throw new Swift_IoException('Connection to ' . $this->_getReadConnectionDescription() . ' Timed Out');
187			}
188			}
189
190	4		return $line;
191			}
192			}
193
194			/**
195			* Reads $length bytes from the stream into a string and moves the pointer
196			* through the stream by $length.
197			*
198			* If less bytes exist than are requested the remaining bytes are given instead.
199			* If no bytes are remaining at all, boolean false is returned.
200			*
201			* @param int $length
202			*
203			* @throws Swift_IoException
204			*
205			* @return string\|null
206			*/
207		View Code Duplication	public function read($length)
			0 ignored issues – show Duplication introduced 2015-11-22 11:38 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...
208			{
209			if (isset($this->_out) && !feof($this->_out)) {
210			$ret = fread($this->_out, $length);
211			if (!$ret) {
212			$metas = stream_get_meta_data($this->_out);
213			if ($metas['timed_out']) {
214			throw new Swift_IoException(
215			'Connection to ' . $this->_getReadConnectionDescription() . ' Timed Out'
216			);
217			}
218			}
219
220			return $ret;
221			}
222			}
223
224			/** Not implemented */
225			public function setReadPointer($byteOffset)
226			{
227			}
228
229			/** Flush the stream contents */
230			protected function _flush()
231			{
232			if (isset($this->_in)) {
233			fflush($this->_in);
234			}
235			}
236
237			/**
238			* Write this bytes to the stream
239			*
240			* @param string $bytes
241			*
242			* @return int
243			*
244			* @throws Swift_IoException
245			*/
246			protected function _commit($bytes)
247			{
248			if (isset($this->_in)) {
249			$bytesToWrite = strlen($bytes);
250			$totalBytesWritten = 0;
251
252			while ($totalBytesWritten < $bytesToWrite) {
253			$bytesWritten = fwrite($this->_in, substr($bytes, $totalBytesWritten));
254			if (false === $bytesWritten \|\| 0 === $bytesWritten) {
255			throw new Swift_IoException(
256			'Connection to ' . $this->_getReadConnectionDescription() . ' has gone away'
257			);
258			}
259
260			$totalBytesWritten += $bytesWritten;
261			}
262
263			if ($totalBytesWritten > 0) {
264			return ++$this->_sequence;
265			}
266			}
267			}
268
269			/**
270			* Establishes a connection to a remote server.
271			*/
272	5		private function _establishSocketConnection()
273			{
274			// set default "php"-options for "stream_context_create"
275			// and overwrite it with the "user"-options
276	5		$options = stream_context_get_options(stream_context_get_default());
277
278	5		$host = $this->_params['host'];
279	5	View Code Duplication	if (!empty($this->_params['protocol'])) {
			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...
280	1		$host = $this->_params['protocol'] . '://' . $host;
281			}
282
283	5		$timeout = 15;
284	5		if (!empty($this->_params['timeout'])) {
285	5		$timeout = $this->_params['timeout'];
286			}
287
288	5		if (!empty($this->_params['sourceIp'])) {
289			$options['socket']['bindto'] = $this->_params['sourceIp'] . ':0';
290			}
291
292	5		if (isset($this->_params['stream_context_options'])) {
293	4		$options = array_merge($options, $this->_params['stream_context_options']);
294			}
295
296	5		$streamContext = stream_context_create($options);
297	5		$this->_stream = @stream_socket_client($host . ':' . $this->_params['port'], $errno, $errstr, $timeout, STREAM_CLIENT_CONNECT, $streamContext);
298
299	5		if (false === $this->_stream) {
300			throw new Swift_TransportException('Connection could not be established with host ' . $this->_params['host'] . ' [' . $errstr . ' #' . $errno . ']');
301			}
302
303	5		if (!empty($this->_params['blocking'])) {
304	5		stream_set_blocking($this->_stream, 1);
305			} else {
306			stream_set_blocking($this->_stream, 0);
307			}
308
309	5		stream_set_timeout($this->_stream, $timeout);
310	5		$this->_in = &$this->_stream;
311	5		$this->_out = &$this->_stream;
312	5		}
313
314			/**
315			* Opens a process for input/output.
316			*/
317			private function _establishProcessConnection()
318			{
319			$command = $this->_params['command'];
320			$descriptorSpec = array(
321			0 => array('pipe', 'r'),
322			1 => array('pipe', 'w'),
323			2 => array('pipe', 'w'),
324			);
325
326			$this->_stream = proc_open($command, $descriptorSpec, $pipes);
327			stream_set_blocking($pipes[2], 0);
328
329			$err = stream_get_contents($pipes[2]);
330			if ($err) {
331			throw new Swift_TransportException('Process could not be started [' . $err . ']');
332			}
333
334			$this->_in = &$pipes[0];
335			$this->_out = &$pipes[1];
336			}
337
338	1		private function _getReadConnectionDescription()
339			{
340	1		switch ($this->_params['type']) {
341	1		case self::TYPE_PROCESS:
342			return 'Process ' . $this->_params['command'];
343			break;
			0 ignored issues – show Unused Code introduced 2015-11-22 11:38 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
344
345	1		case self::TYPE_SOCKET:
346			default:
347	1		$host = $this->_params['host'];
348	1	View Code Duplication	if (!empty($this->_params['protocol'])) {
			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...
349	1		$host = $this->_params['protocol'] . '://' . $host;
350			}
351	1		$host .= ':' . $this->_params['port'];
352
353	1		return $host;
354			break;
			0 ignored issues – show Unused Code introduced 2015-11-22 11:38 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
355			}
356			}
357			}
358

voku / swiftmailer