JsonEncoder::encode() - Code Metrics - Inspection of "Updated dev-master branch alias" - webmozart/json - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 56530a...3afa74 )

by Bernhard

created 2015-12-31 07:06 UTC

JsonEncoder::encode() F

↳ Parent: JsonEncoder

Complexity

Conditions	19
Paths	> 20000

Size

Total Lines	86
Code Lines	42

Duplication

Lines	7
Ratio	8.14 %

Code Coverage

Tests	38
CRAP Score	19.0451

Importance

Changes	6
Bugs	2	Features	0

Metric	Value
c	6
b	2
f	0
dl	7
loc	86
ccs	38
cts	40
cp	0.95
rs	2
cc	19
eloc	42
nc	20737
nop	2
crap	19.0451

How to fix Long Method Complexity

<?php

/*
 * This file is part of the Webmozart JSON package.
 *
 * (c) Bernhard Schussek <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Webmozart\Json;

/**
 * Encodes data as JSON.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <[email protected]>
 */
class JsonEncoder
{
    /**
     * Encode a value as JSON array.
     */
    const JSON_ARRAY = 1;

    /**
     * Encode a value as JSON object.
     */
    const JSON_OBJECT = 2;

    /**
     * Encode a value as JSON string.
     */
    const JSON_STRING = 3;

    /**
     * Encode a value as JSON integer or float.
     */
    const JSON_NUMBER = 4;

    /**
     * @var JsonValidator
     */
    private $validator;

    /**
     * @var int
     */
    private $arrayEncoding = self::JSON_ARRAY;

    /**
     * @var int
     */
    private $numericEncoding = self::JSON_STRING;

    /**
     * @var bool
     */
    private $gtLtEscaped = false;

    /**
     * @var bool
     */
    private $ampersandEscaped = false;

    /**
     * @var bool
     */
    private $singleQuoteEscaped = false;

    /**
     * @var bool
     */
    private $doubleQuoteEscaped = false;

    /**
     * @var bool
     */
    private $slashEscaped = true;

    /**
     * @var bool
     */
    private $unicodeEscaped = true;

    /**
     * @var bool
     */
    private $prettyPrinting = false;

    /**
     * @var bool
     */
    private $terminatedWithLineFeed = false;

    /**
     * @var int
     */
    private $maxDepth = 512;

    /**
     * Creates a new encoder.
     *
     * @param null|JsonValidator $validator
     */
    public function __construct(JsonValidator $validator = null)
    {
        $this->validator = $validator ?: new JsonValidator();
    }

    /**
     * Encodes data as JSON.
     *
     * If a schema is passed, the value is validated against that schema before
     * encoding. The schema may be passed as file path or as object returned
     * from `JsonDecoder::decodeFile($schemaFile)`.
     *
     * You can adjust the decoding with the various setters in this class.
     *
     * @param mixed         $data   The data to encode.
     * @param string|object $schema The schema file or object.

     *
     * @return string The JSON string.
     *
     * @throws EncodingFailedException   If the data could not be encoded.
     * @throws ValidationFailedException If the data fails schema validation.
     * @throws InvalidSchemaException    If the schema is invalid.
     */
    public function encode($data, $schema = null)
    {
        if (null !== $schema) {

            $errors = $this->validator->validate($data, $schema);

            if (count($errors) > 0) {
                throw ValidationFailedException::fromErrors($errors);
            }
        }

        $options = 0;

        if (self::JSON_OBJECT === $this->arrayEncoding) {
            $options |= JSON_FORCE_OBJECT;
        }

        if (self::JSON_NUMBER === $this->numericEncoding) {
            $options |= JSON_NUMERIC_CHECK;
        }

        if ($this->gtLtEscaped) {
            $options |= JSON_HEX_TAG;
        }

        if ($this->ampersandEscaped) {
            $options |= JSON_HEX_AMP;
        }

        if ($this->singleQuoteEscaped) {
            $options |= JSON_HEX_APOS;
        }

        if ($this->doubleQuoteEscaped) {
            $options |= JSON_HEX_QUOT;
        }

        if (PHP_VERSION_ID >= 50400) {
            if (!$this->slashEscaped) {
                $options |= JSON_UNESCAPED_SLASHES;
            }

            if (!$this->unicodeEscaped) {
                $options |= JSON_UNESCAPED_UNICODE;
            }

            if ($this->prettyPrinting) {
                $options |= JSON_PRETTY_PRINT;
            }
        }

        if (PHP_VERSION_ID >= 50500) {
            $maxDepth = $this->maxDepth;

            // We subtract 1 from the max depth to make JsonDecoder and
            // JsonEncoder consistent. json_encode() and json_decode() behave
            // differently for their depth values. See the test cases for
            // examples.
            // HHVM does not have this inconsistency.
            if (!defined('HHVM_VERSION')) {
                --$maxDepth;
            }

            $encoded = json_encode($data, $options, $maxDepth);
        } else {
            $encoded = json_encode($data, $options);
        }

        if (PHP_VERSION_ID < 50400 && !$this->slashEscaped) {
            // PHP below 5.4 does not allow to turn off slash escaping. Let's
            // unescape slashes manually.
            $encoded = str_replace('\\/', '/', $encoded);
        }

        if (JSON_ERROR_NONE !== json_last_error()) {
            throw new EncodingFailedException(sprintf(
                'The data could not be encoded as JSON: %s',
                JsonError::getLastErrorMessage()
            ), json_last_error());
        }

        if ($this->terminatedWithLineFeed) {
            $encoded .= "\n";
        }

        return $encoded;
    }

    /**
     * Encodes data into a JSON file.
     *
     * @param mixed         $data   The data to encode.
     * @param string        $path   The path where the JSON file will be stored.
     * @param string|object $schema The schema file or object.

     *
     * @throws EncodingFailedException   If the data could not be encoded.
     * @throws ValidationFailedException If the data fails schema validation.
     * @throws InvalidSchemaException    If the schema is invalid.
     *
     * @see encode
     */
    public function encodeFile($data, $path, $schema = null)
    {
        if (!file_exists($dir = dirname($path))) {
            mkdir($dir, 0777, true);
        }

        try {
            // Right now, it's sufficient to just write the file. In the future,
            // this will diff existing files with the given data and only do
            // in-place modifications where necessary.
            $content = $this->encode($data, $schema);
        } catch (EncodingFailedException $e) {
            // Add the file name to the exception
            throw new EncodingFailedException(sprintf(
                'An error happened while encoding %s: %s',
                $path,
                $e->getMessage()
            ), $e->getCode(), $e);
        } catch (ValidationFailedException $e) {
            // Add the file name to the exception
            throw new ValidationFailedException(sprintf(
                "Validation failed while encoding %s:\n%s",
                $path,
                $e->getErrorsAsString()
            ), $e->getErrors(), $e->getCode(), $e);
        } catch (InvalidSchemaException $e) {
            // Add the file name to the exception
            throw new InvalidSchemaException(sprintf(
                'An error happened while encoding %s: %s',
                $path,
                $e->getMessage()
            ), $e->getCode(), $e);
        }

        $errorMessage = null;
        $errorCode = 0;

        set_error_handler(function ($errno, $errstr) use (&$errorMessage, &$errorCode) {
            $errorMessage = $errstr;
            $errorCode = $errno;
        });

        file_put_contents($path, $content);

        restore_error_handler();

        if (null !== $errorMessage) {

            if (false !== $pos = strpos($errorMessage, '): ')) {
                // cut "file_put_contents(%path%):" to make message more readable
                $errorMessage = substr($errorMessage, $pos + 3);
            }

            throw new IOException(sprintf(
                'Could not write %s: %s (%s)',
                $path,
                $errorMessage,
                $errorCode
            ), $errorCode);
        }
    }

    /**
     * Returns the encoding of non-associative arrays.
     *
     * @return int One of the constants {@link JSON_OBJECT} and {@link JSON_ARRAY}.
     */
    public function getArrayEncoding()
    {
        return $this->arrayEncoding;
    }

    /**
     * Sets the encoding of non-associative arrays.
     *
     * By default, non-associative arrays are decoded as JSON arrays.
     *
     * @param int $encoding One of the constants {@link JSON_OBJECT} and {@link JSON_ARRAY}.
     *
     * @throws \InvalidArgumentException If the passed encoding is invalid.
     */
    public function setArrayEncoding($encoding)

    {
        if (self::JSON_ARRAY !== $encoding && self::JSON_OBJECT !== $encoding) {
            throw new \InvalidArgumentException(sprintf(
                'Expected JsonEncoder::JSON_ARRAY or JsonEncoder::JSON_OBJECT. '.
                'Got: %s',
                $encoding
            ));
        }

        $this->arrayEncoding = $encoding;
    }

    /**
     * Returns the encoding of numeric strings.
     *
     * @return int One of the constants {@link JSON_STRING} and {@link JSON_NUMBER}.
     */
    public function getNumericEncoding()
    {
        return $this->numericEncoding;
    }

    /**
     * Sets the encoding of numeric strings.
     *
     * By default, non-associative arrays are decoded as JSON strings.
     *
     * @param int $encoding One of the constants {@link JSON_STRING} and {@link JSON_NUMBER}.
     *
     * @throws \InvalidArgumentException If the passed encoding is invalid.
     */
    public function setNumericEncoding($encoding)

    {
        if (self::JSON_NUMBER !== $encoding && self::JSON_STRING !== $encoding) {
            throw new \InvalidArgumentException(sprintf(
                'Expected JsonEncoder::JSON_NUMBER or JsonEncoder::JSON_STRING. '.
                'Got: %s',
                $encoding
            ));
        }

        $this->numericEncoding = $encoding;
    }

    /**
     * Returns whether ampersands (&) are escaped.
     *
     * If `true`, ampersands will be escaped as "\u0026".
     *
     * By default, ampersands are not escaped.
     *
     * @return bool Whether ampersands are escaped.
     */
    public function isAmpersandEscaped()
    {
        return $this->ampersandEscaped;
    }

    /**
     * Sets whether ampersands (&) should be escaped.
     *
     * If `true`, ampersands will be escaped as "\u0026".
     *
     * By default, ampersands are not escaped.
     *
     * @param bool $enabled Whether ampersands should be escaped.
     */
    public function setEscapeAmpersand($enabled)
    {
        $this->ampersandEscaped = $enabled;
    }

    /**
     * Returns whether double quotes (") are escaped.
     *
     * If `true`, double quotes will be escaped as "\u0022".
     *
     * By default, double quotes are not escaped.
     *
     * @return bool Whether double quotes are escaped.
     */
    public function isDoubleQuoteEscaped()
    {
        return $this->doubleQuoteEscaped;
    }

    /**
     * Sets whether double quotes (") should be escaped.
     *
     * If `true`, double quotes will be escaped as "\u0022".
     *
     * By default, double quotes are not escaped.
     *
     * @param bool $enabled Whether double quotes should be escaped.
     */
    public function setEscapeDoubleQuote($enabled)
    {
        $this->doubleQuoteEscaped = $enabled;
    }

    /**
     * Returns whether single quotes (') are escaped.
     *
     * If `true`, single quotes will be escaped as "\u0027".
     *
     * By default, single quotes are not escaped.
     *
     * @return bool Whether single quotes are escaped.
     */
    public function isSingleQuoteEscaped()
    {
        return $this->singleQuoteEscaped;
    }

    /**
     * Sets whether single quotes (") should be escaped.
     *
     * If `true`, single quotes will be escaped as "\u0027".
     *
     * By default, single quotes are not escaped.
     *
     * @param bool $enabled Whether single quotes should be escaped.
     */
    public function setEscapeSingleQuote($enabled)
    {
        $this->singleQuoteEscaped = $enabled;
    }

    /**
     * Returns whether forward slashes (/) are escaped.
     *
     * If `true`, forward slashes will be escaped as "\/".
     *
     * By default, forward slashes are not escaped.
     *
     * @return bool Whether forward slashes are escaped.
     */
    public function isSlashEscaped()
    {
        return $this->slashEscaped;
    }

    /**
     * Sets whether forward slashes (") should be escaped.
     *
     * If `true`, forward slashes will be escaped as "\/".
     *
     * By default, forward slashes are not escaped.
     *
     * @param bool $enabled Whether forward slashes should be escaped.
     */
    public function setEscapeSlash($enabled)
    {
        $this->slashEscaped = $enabled;
    }

    /**
     * Returns whether greater than/less than symbols (>, <) are escaped.
     *
     * If `true`, greater than will be escaped as "\u003E" and less than as
     * "\u003C".
     *
     * By default, greater than/less than symbols are not escaped.
     *
     * @return bool Whether greater than/less than symbols are escaped.
     */
    public function isGtLtEscaped()
    {
        return $this->gtLtEscaped;
    }

    /**
     * Sets whether greater than/less than symbols (>, <) should be escaped.
     *
     * If `true`, greater than will be escaped as "\u003E" and less than as
     * "\u003C".
     *
     * By default, greater than/less than symbols are not escaped.
     *
     * @param bool $enabled Whether greater than/less than should be escaped.
     */
    public function setEscapeGtLt($enabled)
    {
        $this->gtLtEscaped = $enabled;
    }

    /**
     * Returns whether unicode characters are escaped.
     *
     * If `true`, unicode characters will be escaped as hexadecimals strings.
     * For example, "ü" will be escaped as "\u00fc".
     *
     * By default, unicode characters are escaped.
     *
     * @return bool Whether unicode characters are escaped.
     */
    public function isUnicodeEscaped()
    {
        return $this->unicodeEscaped;
    }

    /**
     * Sets whether unicode characters should be escaped.
     *
     * If `true`, unicode characters will be escaped as hexadecimals strings.
     * For example, "ü" will be escaped as "\u00fc".
     *
     * By default, unicode characters are escaped.
     *
     * @param bool $enabled Whether unicode characters should be escaped.
     */
    public function setEscapeUnicode($enabled)
    {
        $this->unicodeEscaped = $enabled;
    }

    /**
     * Returns whether JSON strings are formatted for better readability.
     *
     * If `true`, line breaks will be added after object properties and array
     * entries. Each new nesting level will be indented by four spaces.
     *
     * By default, pretty printing is not enabled.
     *
     * @return bool Whether JSON strings are formatted.
     */
    public function isPrettyPrinting()
    {
        return $this->prettyPrinting;
    }

    /**
     * Sets whether JSON strings should be formatted for better readability.
     *
     * If `true`, line breaks will be added after object properties and array
     * entries. Each new nesting level will be indented by four spaces.
     *
     * By default, pretty printing is not enabled.
     *
     * @param bool $prettyPrinting Whether JSON strings should be formatted.
     */
    public function setPrettyPrinting($prettyPrinting)
    {
        $this->prettyPrinting = $prettyPrinting;
    }

    /**
     * Returns whether JSON strings are terminated with a line feed.
     *
     * By default, JSON strings are not terminated with a line feed.
     *
     * @return bool Whether JSON strings are terminated with a line feed.
     */
    public function isTerminatedWithLineFeed()
    {
        return $this->terminatedWithLineFeed;
    }

    /**
     * Sets whether JSON strings should be terminated with a line feed.
     *
     * By default, JSON strings are not terminated with a line feed.
     *
     * @param bool $enabled Whether JSON strings should be terminated with a
     *                      line feed.
     */
    public function setTerminateWithLineFeed($enabled)
    {
        $this->terminatedWithLineFeed = $enabled;
    }

    /**
     * Returns the maximum recursion depth.
     *
     * A depth of zero means that objects are not allowed. A depth of one means
     * only one level of objects or arrays is allowed.
     *
     * @return int The maximum recursion depth.
     */
    public function getMaxDepth()
    {
        return $this->maxDepth;
    }

    /**
     * Sets the maximum recursion depth.
     *
     * If the depth is exceeded during encoding, an {@link EncodingFailedException}
     * will be thrown.
     *
     * A depth of zero means that objects are not allowed. A depth of one means
     * only one level of objects or arrays is allowed.
     *
     * @param int $maxDepth The maximum recursion depth.
     *
     * @throws \InvalidArgumentException If the depth is not an integer greater
     *                                   than or equal to zero.
     */
    public function setMaxDepth($maxDepth)

    {
        if (!is_int($maxDepth)) {
            throw new \InvalidArgumentException(sprintf(
                'The maximum depth should be an integer. Got: %s',
                is_object($maxDepth) ? get_class($maxDepth) : gettype($maxDepth)
            ));
        }

        if ($maxDepth < 1) {
            throw new \InvalidArgumentException(sprintf(
                'The maximum depth should 1 or greater. Got: %s',
                $maxDepth
            ));
        }

        $this->maxDepth = $maxDepth;
    }
}


1			<?php
2
3			/*
4			* This file is part of the Webmozart JSON package.
5			*
6			* (c) Bernhard Schussek <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Webmozart\Json;
13
14			/**
15			* Encodes data as JSON.
16			*
17			* @since 1.0
18			*
19			* @author Bernhard Schussek <[email protected]>
20			*/
21			class JsonEncoder
22			{
23			/**
24			* Encode a value as JSON array.
25			*/
26			const JSON_ARRAY = 1;
27
28			/**
29			* Encode a value as JSON object.
30			*/
31			const JSON_OBJECT = 2;
32
33			/**
34			* Encode a value as JSON string.
35			*/
36			const JSON_STRING = 3;
37
38			/**
39			* Encode a value as JSON integer or float.
40			*/
41			const JSON_NUMBER = 4;
42
43			/**
44			* @var JsonValidator
45			*/
46			private $validator;
47
48			/**
49			* @var int
50			*/
51			private $arrayEncoding = self::JSON_ARRAY;
52
53			/**
54			* @var int
55			*/
56			private $numericEncoding = self::JSON_STRING;
57
58			/**
59			* @var bool
60			*/
61			private $gtLtEscaped = false;
62
63			/**
64			* @var bool
65			*/
66			private $ampersandEscaped = false;
67
68			/**
69			* @var bool
70			*/
71			private $singleQuoteEscaped = false;
72
73			/**
74			* @var bool
75			*/
76			private $doubleQuoteEscaped = false;
77
78			/**
79			* @var bool
80			*/
81			private $slashEscaped = true;
82
83			/**
84			* @var bool
85			*/
86			private $unicodeEscaped = true;
87
88			/**
89			* @var bool
90			*/
91			private $prettyPrinting = false;
92
93			/**
94			* @var bool
95			*/
96			private $terminatedWithLineFeed = false;
97
98			/**
99			* @var int
100			*/
101			private $maxDepth = 512;
102
103			/**
104			* Creates a new encoder.
105			*
106			* @param null\|JsonValidator $validator
107			*/
108	59		public function __construct(JsonValidator $validator = null)
109			{
110	59		$this->validator = $validator ?: new JsonValidator();
111	59		}
112
113			/**
114			* Encodes data as JSON.
115			*
116			* If a schema is passed, the value is validated against that schema before
117			* encoding. The schema may be passed as file path or as object returned
118			* from `JsonDecoder::decodeFile($schemaFile)`.
119			*
120			* You can adjust the decoding with the various setters in this class.
121			*
122			* @param mixed $data The data to encode.
123			* @param string\|object $schema The schema file or object.
			0 ignored issues – show Documentation introduced 2015-12-11 17:38 UTC by Report Bug Copy Issue Report Should the type for parameter `$schema` not be `string\|object\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
124			*
125			* @return string The JSON string.
126			*
127			* @throws EncodingFailedException If the data could not be encoded.
128			* @throws ValidationFailedException If the data fails schema validation.
129			* @throws InvalidSchemaException If the schema is invalid.
130			*/
131	51		public function encode($data, $schema = null)
132			{
133	51	View Code Duplication	if (null !== $schema) {
			0 ignored issues – show Duplication introduced 2015-12-11 17: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...
134	6		$errors = $this->validator->validate($data, $schema);
135
136	6		if (count($errors) > 0) {
137	4		throw ValidationFailedException::fromErrors($errors);
138			}
139			}
140
141	47		$options = 0;
142
143	47		if (self::JSON_OBJECT === $this->arrayEncoding) {
144	1		$options \|= JSON_FORCE_OBJECT;
145			}
146
147	47		if (self::JSON_NUMBER === $this->numericEncoding) {
148	2		$options \|= JSON_NUMERIC_CHECK;
149			}
150
151	47		if ($this->gtLtEscaped) {
152	1		$options \|= JSON_HEX_TAG;
153			}
154
155	47		if ($this->ampersandEscaped) {
156	1		$options \|= JSON_HEX_AMP;
157			}
158
159	47		if ($this->singleQuoteEscaped) {
160	1		$options \|= JSON_HEX_APOS;
161			}
162
163	47		if ($this->doubleQuoteEscaped) {
164	1		$options \|= JSON_HEX_QUOT;
165			}
166
167	47		if (PHP_VERSION_ID >= 50400) {
168	47		if (!$this->slashEscaped) {
169	1		$options \|= JSON_UNESCAPED_SLASHES;
170			}
171
172	47		if (!$this->unicodeEscaped) {
173	1		$options \|= JSON_UNESCAPED_UNICODE;
174			}
175
176	47		if ($this->prettyPrinting) {
177	1		$options \|= JSON_PRETTY_PRINT;
178			}
179			}
180
181	47		if (PHP_VERSION_ID >= 50500) {
182	47		$maxDepth = $this->maxDepth;
183
184			// We subtract 1 from the max depth to make JsonDecoder and
185			// JsonEncoder consistent. json_encode() and json_decode() behave
186			// differently for their depth values. See the test cases for
187			// examples.
188			// HHVM does not have this inconsistency.
189	47		if (!defined('HHVM_VERSION')) {
190	47		--$maxDepth;
191			}
192
193	47		$encoded = json_encode($data, $options, $maxDepth);
194			} else {
195			$encoded = json_encode($data, $options);
196			}
197
198	47		if (PHP_VERSION_ID < 50400 && !$this->slashEscaped) {
199			// PHP below 5.4 does not allow to turn off slash escaping. Let's
200			// unescape slashes manually.
201			$encoded = str_replace('\\/', '/', $encoded);
202			}
203
204	47		if (JSON_ERROR_NONE !== json_last_error()) {
205	5		throw new EncodingFailedException(sprintf(
206	5		'The data could not be encoded as JSON: %s',
207	5		JsonError::getLastErrorMessage()
208			), json_last_error());
209			}
210
211	42		if ($this->terminatedWithLineFeed) {
212	1		$encoded .= "\n";
213			}
214
215	42		return $encoded;
216			}
217
218			/**
219			* Encodes data into a JSON file.
220			*
221			* @param mixed $data The data to encode.
222			* @param string $path The path where the JSON file will be stored.
223			* @param string\|object $schema The schema file or object.
			0 ignored issues – show Documentation introduced 2015-12-11 17:38 UTC by Report Bug Copy Issue Report Should the type for parameter `$schema` not be `string\|object\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
224			*
225			* @throws EncodingFailedException If the data could not be encoded.
226			* @throws ValidationFailedException If the data fails schema validation.
227			* @throws InvalidSchemaException If the schema is invalid.
228			*
229			* @see encode
230			*/
231	6		public function encodeFile($data, $path, $schema = null)
232			{
233	6		if (!file_exists($dir = dirname($path))) {
234	1		mkdir($dir, 0777, true);
235			}
236
237			try {
238			// Right now, it's sufficient to just write the file. In the future,
239			// this will diff existing files with the given data and only do
240			// in-place modifications where necessary.
241	6		$content = $this->encode($data, $schema);
242	3		} catch (EncodingFailedException $e) {
243			// Add the file name to the exception
244	1		throw new EncodingFailedException(sprintf(
245	1		'An error happened while encoding %s: %s',
246			$path,
247	1		$e->getMessage()
248	1		), $e->getCode(), $e);
249	2		} catch (ValidationFailedException $e) {
250			// Add the file name to the exception
251	2		throw new ValidationFailedException(sprintf(
252	2		"Validation failed while encoding %s:\n%s",
253			$path,
254	2		$e->getErrorsAsString()
255	2		), $e->getErrors(), $e->getCode(), $e);
256			} catch (InvalidSchemaException $e) {
257			// Add the file name to the exception
258			throw new InvalidSchemaException(sprintf(
259			'An error happened while encoding %s: %s',
260			$path,
261			$e->getMessage()
262			), $e->getCode(), $e);
263			}
264
265	3		$errorMessage = null;
266	3		$errorCode = 0;
267
268	3		set_error_handler(function ($errno, $errstr) use (&$errorMessage, &$errorCode) {
269	1		$errorMessage = $errstr;
270	1		$errorCode = $errno;
271	3		});
272
273	3		file_put_contents($path, $content);
274
275	3		restore_error_handler();
276
277	3	View Code Duplication	if (null !== $errorMessage) {
			0 ignored issues – show Duplication introduced 2015-12-11 17: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...
278	1		if (false !== $pos = strpos($errorMessage, '): ')) {
279			// cut "file_put_contents(%path%):" to make message more readable
280	1		$errorMessage = substr($errorMessage, $pos + 3);
281			}
282
283	1		throw new IOException(sprintf(
284	1		'Could not write %s: %s (%s)',
285			$path,
286			$errorMessage,
287			$errorCode
288			), $errorCode);
289			}
290	2		}
291
292			/**
293			* Returns the encoding of non-associative arrays.
294			*
295			* @return int One of the constants {@link JSON_OBJECT} and {@link JSON_ARRAY}.
296			*/
297			public function getArrayEncoding()
298			{
299			return $this->arrayEncoding;
300			}
301
302			/**
303			* Sets the encoding of non-associative arrays.
304			*
305			* By default, non-associative arrays are decoded as JSON arrays.
306			*
307			* @param int $encoding One of the constants {@link JSON_OBJECT} and {@link JSON_ARRAY}.
308			*
309			* @throws \InvalidArgumentException If the passed encoding is invalid.
310			*/
311	5	View Code Duplication	public function setArrayEncoding($encoding)
			0 ignored issues – show Duplication introduced 2015-12-11 17: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...
312			{
313	5		if (self::JSON_ARRAY !== $encoding && self::JSON_OBJECT !== $encoding) {
314	3		throw new \InvalidArgumentException(sprintf(
315			'Expected JsonEncoder::JSON_ARRAY or JsonEncoder::JSON_OBJECT. '.
316	3		'Got: %s',
317			$encoding
318			));
319			}
320
321	2		$this->arrayEncoding = $encoding;
322	2		}
323
324			/**
325			* Returns the encoding of numeric strings.
326			*
327			* @return int One of the constants {@link JSON_STRING} and {@link JSON_NUMBER}.
328			*/
329			public function getNumericEncoding()
330			{
331			return $this->numericEncoding;
332			}
333
334			/**
335			* Sets the encoding of numeric strings.
336			*
337			* By default, non-associative arrays are decoded as JSON strings.
338			*
339			* @param int $encoding One of the constants {@link JSON_STRING} and {@link JSON_NUMBER}.
340			*
341			* @throws \InvalidArgumentException If the passed encoding is invalid.
342			*/
343	6	View Code Duplication	public function setNumericEncoding($encoding)
			0 ignored issues – show Duplication introduced 2015-12-11 17: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...
344			{
345	6		if (self::JSON_NUMBER !== $encoding && self::JSON_STRING !== $encoding) {
346	3		throw new \InvalidArgumentException(sprintf(
347			'Expected JsonEncoder::JSON_NUMBER or JsonEncoder::JSON_STRING. '.
348	3		'Got: %s',
349			$encoding
350			));
351			}
352
353	3		$this->numericEncoding = $encoding;
354	3		}
355
356			/**
357			* Returns whether ampersands (&) are escaped.
358			*
359			* If `true`, ampersands will be escaped as "\u0026".
360			*
361			* By default, ampersands are not escaped.
362			*
363			* @return bool Whether ampersands are escaped.
364			*/
365			public function isAmpersandEscaped()
366			{
367			return $this->ampersandEscaped;
368			}
369
370			/**
371			* Sets whether ampersands (&) should be escaped.
372			*
373			* If `true`, ampersands will be escaped as "\u0026".
374			*
375			* By default, ampersands are not escaped.
376			*
377			* @param bool $enabled Whether ampersands should be escaped.
378			*/
379	2		public function setEscapeAmpersand($enabled)
380			{
381	2		$this->ampersandEscaped = $enabled;
382	2		}
383
384			/**
385			* Returns whether double quotes (") are escaped.
386			*
387			* If `true`, double quotes will be escaped as "\u0022".
388			*
389			* By default, double quotes are not escaped.
390			*
391			* @return bool Whether double quotes are escaped.
392			*/
393			public function isDoubleQuoteEscaped()
394			{
395			return $this->doubleQuoteEscaped;
396			}
397
398			/**
399			* Sets whether double quotes (") should be escaped.
400			*
401			* If `true`, double quotes will be escaped as "\u0022".
402			*
403			* By default, double quotes are not escaped.
404			*
405			* @param bool $enabled Whether double quotes should be escaped.
406			*/
407	2		public function setEscapeDoubleQuote($enabled)
408			{
409	2		$this->doubleQuoteEscaped = $enabled;
410	2		}
411
412			/**
413			* Returns whether single quotes (') are escaped.
414			*
415			* If `true`, single quotes will be escaped as "\u0027".
416			*
417			* By default, single quotes are not escaped.
418			*
419			* @return bool Whether single quotes are escaped.
420			*/
421			public function isSingleQuoteEscaped()
422			{
423			return $this->singleQuoteEscaped;
424			}
425
426			/**
427			* Sets whether single quotes (") should be escaped.
428			*
429			* If `true`, single quotes will be escaped as "\u0027".
430			*
431			* By default, single quotes are not escaped.
432			*
433			* @param bool $enabled Whether single quotes should be escaped.
434			*/
435	2		public function setEscapeSingleQuote($enabled)
436			{
437	2		$this->singleQuoteEscaped = $enabled;
438	2		}
439
440			/**
441			* Returns whether forward slashes (/) are escaped.
442			*
443			* If `true`, forward slashes will be escaped as "\/".
444			*
445			* By default, forward slashes are not escaped.
446			*
447			* @return bool Whether forward slashes are escaped.
448			*/
449			public function isSlashEscaped()
450			{
451			return $this->slashEscaped;
452			}
453
454			/**
455			* Sets whether forward slashes (") should be escaped.
456			*
457			* If `true`, forward slashes will be escaped as "\/".
458			*
459			* By default, forward slashes are not escaped.
460			*
461			* @param bool $enabled Whether forward slashes should be escaped.
462			*/
463	2		public function setEscapeSlash($enabled)
464			{
465	2		$this->slashEscaped = $enabled;
466	2		}
467
468			/**
469			* Returns whether greater than/less than symbols (>, <) are escaped.
470			*
471			* If `true`, greater than will be escaped as "\u003E" and less than as
472			* "\u003C".
473			*
474			* By default, greater than/less than symbols are not escaped.
475			*
476			* @return bool Whether greater than/less than symbols are escaped.
477			*/
478			public function isGtLtEscaped()
479			{
480			return $this->gtLtEscaped;
481			}
482
483			/**
484			* Sets whether greater than/less than symbols (>, <) should be escaped.
485			*
486			* If `true`, greater than will be escaped as "\u003E" and less than as
487			* "\u003C".
488			*
489			* By default, greater than/less than symbols are not escaped.
490			*
491			* @param bool $enabled Whether greater than/less than should be escaped.
492			*/
493	2		public function setEscapeGtLt($enabled)
494			{
495	2		$this->gtLtEscaped = $enabled;
496	2		}
497
498			/**
499			* Returns whether unicode characters are escaped.
500			*
501			* If `true`, unicode characters will be escaped as hexadecimals strings.
502			* For example, "ü" will be escaped as "\u00fc".
503			*
504			* By default, unicode characters are escaped.
505			*
506			* @return bool Whether unicode characters are escaped.
507			*/
508			public function isUnicodeEscaped()
509			{
510			return $this->unicodeEscaped;
511			}
512
513			/**
514			* Sets whether unicode characters should be escaped.
515			*
516			* If `true`, unicode characters will be escaped as hexadecimals strings.
517			* For example, "ü" will be escaped as "\u00fc".
518			*
519			* By default, unicode characters are escaped.
520			*
521			* @param bool $enabled Whether unicode characters should be escaped.
522			*/
523	2		public function setEscapeUnicode($enabled)
524			{
525	2		$this->unicodeEscaped = $enabled;
526	2		}
527
528			/**
529			* Returns whether JSON strings are formatted for better readability.
530			*
531			* If `true`, line breaks will be added after object properties and array
532			* entries. Each new nesting level will be indented by four spaces.
533			*
534			* By default, pretty printing is not enabled.
535			*
536			* @return bool Whether JSON strings are formatted.
537			*/
538			public function isPrettyPrinting()
539			{
540			return $this->prettyPrinting;
541			}
542
543			/**
544			* Sets whether JSON strings should be formatted for better readability.
545			*
546			* If `true`, line breaks will be added after object properties and array
547			* entries. Each new nesting level will be indented by four spaces.
548			*
549			* By default, pretty printing is not enabled.
550			*
551			* @param bool $prettyPrinting Whether JSON strings should be formatted.
552			*/
553	2		public function setPrettyPrinting($prettyPrinting)
554			{
555	2		$this->prettyPrinting = $prettyPrinting;
556	2		}
557
558			/**
559			* Returns whether JSON strings are terminated with a line feed.
560			*
561			* By default, JSON strings are not terminated with a line feed.
562			*
563			* @return bool Whether JSON strings are terminated with a line feed.
564			*/
565			public function isTerminatedWithLineFeed()
566			{
567			return $this->terminatedWithLineFeed;
568			}
569
570			/**
571			* Sets whether JSON strings should be terminated with a line feed.
572			*
573			* By default, JSON strings are not terminated with a line feed.
574			*
575			* @param bool $enabled Whether JSON strings should be terminated with a
576			* line feed.
577			*/
578	2		public function setTerminateWithLineFeed($enabled)
579			{
580	2		$this->terminatedWithLineFeed = $enabled;
581	2		}
582
583			/**
584			* Returns the maximum recursion depth.
585			*
586			* A depth of zero means that objects are not allowed. A depth of one means
587			* only one level of objects or arrays is allowed.
588			*
589			* @return int The maximum recursion depth.
590			*/
591			public function getMaxDepth()
592			{
593			return $this->maxDepth;
594			}
595
596			/**
597			* Sets the maximum recursion depth.
598			*
599			* If the depth is exceeded during encoding, an {@link EncodingFailedException}
600			* will be thrown.
601			*
602			* A depth of zero means that objects are not allowed. A depth of one means
603			* only one level of objects or arrays is allowed.
604			*
605			* @param int $maxDepth The maximum recursion depth.
606			*
607			* @throws \InvalidArgumentException If the depth is not an integer greater
608			* than or equal to zero.
609			*/
610	6	View Code Duplication	public function setMaxDepth($maxDepth)
			0 ignored issues – show Duplication introduced 2015-12-11 17: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...
611			{
612	6		if (!is_int($maxDepth)) {
613	1		throw new \InvalidArgumentException(sprintf(
614	1		'The maximum depth should be an integer. Got: %s',
615	1		is_object($maxDepth) ? get_class($maxDepth) : gettype($maxDepth)
616			));
617			}
618
619	5		if ($maxDepth < 1) {
620	1		throw new \InvalidArgumentException(sprintf(
621	1		'The maximum depth should 1 or greater. Got: %s',
622			$maxDepth
623			));
624			}
625
626	4		$this->maxDepth = $maxDepth;
627	4		}
628			}
629

webmozart / json

Push — master ( 56530a...3afa74 )

JsonEncoder::encode() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like