MultipartStreamBuilder::basename() - Code Metrics - Inspection of "Adding tests on appveyor (#20)" - php-http/multipart-stream-builder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 968b64...1f5822 )

by Tobias

created 2016-12-22 14:16 UTC

MultipartStreamBuilder::basename() A

↳ Parent: MultipartStreamBuilder

Complexity

Conditions	3
Paths	4

Size

Total Lines	15
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	15
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	7
nc	4
nop	1

<?php

namespace Http\Message\MultipartStream;

use Http\Discovery\StreamFactoryDiscovery;
use Http\Message\StreamFactory;
use Psr\Http\Message\StreamInterface;

/**
 * Build your own Multipart stream. A Multipart stream is a collection of streams separated with a $bounary. This
 * class helps you to create a Multipart stream with stream implementations from any PSR7 library.
 *
 * @author Michael Dowling and contributors to guzzlehttp/psr7
 * @author Tobias Nyholm <[email protected]>
 */
class MultipartStreamBuilder
{
    /**
     * @var StreamFactory
     */
    private $streamFactory;

    /**
     * @var MimetypeHelper
     */
    private $mimetypeHelper;

    /**
     * @var string
     */
    private $boundary;

    /**
     * @var array Element where each Element is an array with keys ['contents', 'headers', 'filename']
     */
    private $data = [];

    /**
     * @param StreamFactory|null $streamFactory
     */
    public function __construct(StreamFactory $streamFactory = null)
    {
        $this->streamFactory = $streamFactory ?: StreamFactoryDiscovery::find();
    }

    /**
     * Add a resource to the Multipart Stream. If the same $name is used twice the first resource will
     * be overwritten.
     *
     * @param string                          $name     the formpost name
     * @param string|resource|StreamInterface $resource
     * @param array                           $options  {
     *
     *     @var array $headers additional headers ['header-name' => 'header-value']
     *     @var string $filename
     * }
     *
     * @return MultipartStreamBuilder
     */
    public function addResource($name, $resource, array $options = [])
    {
        $stream = $this->streamFactory->createStream($resource);

        // validate options['headers'] exists
        if (!isset($options['headers'])) {
            $options['headers'] = [];
        }

        // Try to add filename if it is missing
        if (empty($options['filename'])) {
            $options['filename'] = null;
            $uri = $stream->getMetadata('uri');
            if (substr($uri, 0, 6) !== 'php://') {
                $options['filename'] = $uri;
            }
        }

        $this->prepareHeaders($name, $stream, $options['filename'], $options['headers']);
        $this->data[$name] = ['contents' => $stream, 'headers' => $options['headers'], 'filename' => $options['filename']];

        return $this;
    }

    /**
     * Build the stream.
     *
     * @return StreamInterface
     */
    public function build()
    {
        $streams = '';
        foreach ($this->data as $data) {
            // Add start and headers
            $streams .= "--{$this->getBoundary()}\r\n".
                $this->getHeaders($data['headers'])."\r\n";

            // Convert the stream to string
            $streams .= (string) $data['contents'];
            $streams .= "\r\n";
        }

        // Append end
        $streams .= "--{$this->getBoundary()}--\r\n";

        return $this->streamFactory->createStream($streams);
    }

    /**
     * Add extra headers if they are missing.
     *
     * @param string          $name
     * @param StreamInterface $stream
     * @param string          $filename
     * @param array           &$headers
     */
    private function prepareHeaders($name, StreamInterface $stream, $filename, array &$headers)
    {
        $hasFilename = $filename === '0' || $filename;

        // Set a default content-disposition header if one was not provided
        if (!$this->hasHeader($headers, 'content-disposition')) {
            $headers['Content-Disposition'] = sprintf('form-data; name="%s"', $name);
            if ($hasFilename) {
                $headers['Content-Disposition'] .= sprintf('; filename="%s"', $this->basename($filename));
            }
        }

        // Set a default content-length header if one was not provided
        if (!$this->hasHeader($headers, 'content-length')) {
            if ($length = $stream->getSize()) {
                $headers['Content-Length'] = (string) $length;
            }
        }

        // Set a default Content-Type if one was not provided
        if (!$this->hasHeader($headers, 'content-type') && $hasFilename) {
            if ($type = $this->getMimetypeHelper()->getMimetypeFromFilename($filename)) {
                $headers['Content-Type'] = $type;
            }
        }
    }

    /**
     * Get the headers formatted for the HTTP message.
     *
     * @param array $headers
     *
     * @return string
     */
    private function getHeaders(array $headers)
    {
        $str = '';
        foreach ($headers as $key => $value) {
            $str .= sprintf("%s: %s\r\n", $key, $value);
        }

        return $str;
    }

    /**
     * Check if header exist.
     *
     * @param array  $headers
     * @param string $key     case insensitive
     *
     * @return bool
     */
    private function hasHeader(array $headers, $key)
    {
        $lowercaseHeader = strtolower($key);
        foreach ($headers as $k => $v) {
            if (strtolower($k) === $lowercaseHeader) {
                return true;
            }
        }

        return false;
    }

    /**
     * Get the boundary that separates the streams.
     *
     * @return string
     */
    public function getBoundary()
    {
        if ($this->boundary === null) {
            $this->boundary = uniqid();
        }

        return $this->boundary;
    }

    /**
     * @param string $boundary
     *
     * @return MultipartStreamBuilder
     */
    public function setBoundary($boundary)
    {
        $this->boundary = $boundary;

        return $this;
    }

    /**
     * @return MimetypeHelper
     */
    private function getMimetypeHelper()
    {
        if ($this->mimetypeHelper === null) {
            $this->mimetypeHelper = new ApacheMimetypeHelper();
        }

        return $this->mimetypeHelper;
    }

    /**
     * If you have custom file extension you may overwrite the default MimetypeHelper with your own.
     *
     * @param MimetypeHelper $mimetypeHelper
     *
     * @return MultipartStreamBuilder
     */
    public function setMimetypeHelper(MimetypeHelper $mimetypeHelper)
    {
        $this->mimetypeHelper = $mimetypeHelper;

        return $this;
    }

    /**
     * Gets the filename from a given path.
     *
     * PHP's basename() does not properly support streams or filenames beginning with a non-US-ASCII character.
     *
     * @author Drupal 8.2
     *
     * @param string $path
     *
     * @return string
     */
    private function basename($path)
    {
        $separators = '/';
        if (DIRECTORY_SEPARATOR != '/') {
            // For Windows OS add special separator.
            $separators .= DIRECTORY_SEPARATOR;
        }
        // Remove right-most slashes when $uri points to directory.
        $path = rtrim($path, $separators);
        // Returns the trailing part of the $uri starting after one of the directory
        // separators.
        $filename = preg_match('@[^'.preg_quote($separators, '@').']+$@', $path, $matches) ? $matches[0] : '';

        return $filename;
    }
}


1			<?php
2
3			namespace Http\Message\MultipartStream;
4
5			use Http\Discovery\StreamFactoryDiscovery;
6			use Http\Message\StreamFactory;
7			use Psr\Http\Message\StreamInterface;
8
9			/**
10			* Build your own Multipart stream. A Multipart stream is a collection of streams separated with a $bounary. This
11			* class helps you to create a Multipart stream with stream implementations from any PSR7 library.
12			*
13			* @author Michael Dowling and contributors to guzzlehttp/psr7
14			* @author Tobias Nyholm <[email protected]>
15			*/
16			class MultipartStreamBuilder
17			{
18			/**
19			* @var StreamFactory
20			*/
21			private $streamFactory;
22
23			/**
24			* @var MimetypeHelper
25			*/
26			private $mimetypeHelper;
27
28			/**
29			* @var string
30			*/
31			private $boundary;
32
33			/**
34			* @var array Element where each Element is an array with keys ['contents', 'headers', 'filename']
35			*/
36			private $data = [];
37
38			/**
39			* @param StreamFactory\|null $streamFactory
40			*/
41			public function __construct(StreamFactory $streamFactory = null)
42			{
43			$this->streamFactory = $streamFactory ?: StreamFactoryDiscovery::find();
44			}
45
46			/**
47			* Add a resource to the Multipart Stream. If the same $name is used twice the first resource will
48			* be overwritten.
49			*
50			* @param string $name the formpost name
51			* @param string\|resource\|StreamInterface $resource
52			* @param array $options {
53			*
54			* @var array $headers additional headers ['header-name' => 'header-value']
55			* @var string $filename
56			* }
57			*
58			* @return MultipartStreamBuilder
59			*/
60			public function addResource($name, $resource, array $options = [])
61			{
62			$stream = $this->streamFactory->createStream($resource);
63
64			// validate options['headers'] exists
65			if (!isset($options['headers'])) {
66			$options['headers'] = [];
67			}
68
69			// Try to add filename if it is missing
70			if (empty($options['filename'])) {
71			$options['filename'] = null;
72			$uri = $stream->getMetadata('uri');
73			if (substr($uri, 0, 6) !== 'php://') {
74			$options['filename'] = $uri;
75			}
76			}
77
78			$this->prepareHeaders($name, $stream, $options['filename'], $options['headers']);
79			$this->data[$name] = ['contents' => $stream, 'headers' => $options['headers'], 'filename' => $options['filename']];
80
81			return $this;
82			}
83
84			/**
85			* Build the stream.
86			*
87			* @return StreamInterface
88			*/
89			public function build()
90			{
91			$streams = '';
92			foreach ($this->data as $data) {
93			// Add start and headers
94			$streams .= "--{$this->getBoundary()}\r\n".
95			$this->getHeaders($data['headers'])."\r\n";
96
97			// Convert the stream to string
98			$streams .= (string) $data['contents'];
99			$streams .= "\r\n";
100			}
101
102			// Append end
103			$streams .= "--{$this->getBoundary()}--\r\n";
104
105			return $this->streamFactory->createStream($streams);
106			}
107
108			/**
109			* Add extra headers if they are missing.
110			*
111			* @param string $name
112			* @param StreamInterface $stream
113			* @param string $filename
114			* @param array &$headers
115			*/
116			private function prepareHeaders($name, StreamInterface $stream, $filename, array &$headers)
117			{
118			$hasFilename = $filename === '0' \|\| $filename;
119
120			// Set a default content-disposition header if one was not provided
121			if (!$this->hasHeader($headers, 'content-disposition')) {
122			$headers['Content-Disposition'] = sprintf('form-data; name="%s"', $name);
123			if ($hasFilename) {
124			$headers['Content-Disposition'] .= sprintf('; filename="%s"', $this->basename($filename));
125			}
126			}
127
128			// Set a default content-length header if one was not provided
129			if (!$this->hasHeader($headers, 'content-length')) {
130			if ($length = $stream->getSize()) {
131			$headers['Content-Length'] = (string) $length;
132			}
133			}
134
135			// Set a default Content-Type if one was not provided
136			if (!$this->hasHeader($headers, 'content-type') && $hasFilename) {
137			if ($type = $this->getMimetypeHelper()->getMimetypeFromFilename($filename)) {
138			$headers['Content-Type'] = $type;
139			}
140			}
141			}
142
143			/**
144			* Get the headers formatted for the HTTP message.
145			*
146			* @param array $headers
147			*
148			* @return string
149			*/
150			private function getHeaders(array $headers)
151			{
152			$str = '';
153			foreach ($headers as $key => $value) {
154			$str .= sprintf("%s: %s\r\n", $key, $value);
155			}
156
157			return $str;
158			}
159
160			/**
161			* Check if header exist.
162			*
163			* @param array $headers
164			* @param string $key case insensitive
165			*
166			* @return bool
167			*/
168			private function hasHeader(array $headers, $key)
169			{
170			$lowercaseHeader = strtolower($key);
171			foreach ($headers as $k => $v) {
172			if (strtolower($k) === $lowercaseHeader) {
173			return true;
174			}
175			}
176
177			return false;
178			}
179
180			/**
181			* Get the boundary that separates the streams.
182			*
183			* @return string
184			*/
185			public function getBoundary()
186			{
187			if ($this->boundary === null) {
188			$this->boundary = uniqid();
189			}
190
191			return $this->boundary;
192			}
193
194			/**
195			* @param string $boundary
196			*
197			* @return MultipartStreamBuilder
198			*/
199			public function setBoundary($boundary)
200			{
201			$this->boundary = $boundary;
202
203			return $this;
204			}
205
206			/**
207			* @return MimetypeHelper
208			*/
209			private function getMimetypeHelper()
210			{
211			if ($this->mimetypeHelper === null) {
212			$this->mimetypeHelper = new ApacheMimetypeHelper();
213			}
214
215			return $this->mimetypeHelper;
216			}
217
218			/**
219			* If you have custom file extension you may overwrite the default MimetypeHelper with your own.
220			*
221			* @param MimetypeHelper $mimetypeHelper
222			*
223			* @return MultipartStreamBuilder
224			*/
225			public function setMimetypeHelper(MimetypeHelper $mimetypeHelper)
226			{
227			$this->mimetypeHelper = $mimetypeHelper;
228
229			return $this;
230			}
231
232			/**
233			* Gets the filename from a given path.
234			*
235			* PHP's basename() does not properly support streams or filenames beginning with a non-US-ASCII character.
236			*
237			* @author Drupal 8.2
238			*
239			* @param string $path
240			*
241			* @return string
242			*/
243			private function basename($path)
244			{
245			$separators = '/';
246			if (DIRECTORY_SEPARATOR != '/') {
247			// For Windows OS add special separator.
248			$separators .= DIRECTORY_SEPARATOR;
249			}
250			// Remove right-most slashes when $uri points to directory.
251			$path = rtrim($path, $separators);
252			// Returns the trailing part of the $uri starting after one of the directory
253			// separators.
254			$filename = preg_match('@[^'.preg_quote($separators, '@').']+$@', $path, $matches) ? $matches[0] : '';
255
256			return $filename;
257			}
258			}
259

php-http / multipart-stream-builder

Push — master ( 968b64...1f5822 )

MultipartStreamBuilder::basename() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like