Change object encoding decision

Author: Riimu

.php_cs

@@ -8,22 +8,30 @@ return \PhpCsFixer\Config::create()
     ->setRules([
         '@PSR2' => true,
 
-        'array_syntax' => ['syntax' => 'short'],
+        'array_syntax' => [
+            'syntax' => 'short'
+        ],
         'binary_operator_spaces' => [
-            'align_equals' => false,
             'align_double_arrow' => null,
+            'align_equals' => false,
         ],
         'blank_line_after_opening_tag' => true,
         'cast_spaces' => true,
-        'concat_space' => ['spacing' => 'one'],
+        'combine_consecutive_unsets' => true,
+        'concat_space' => [
+            'spacing' => 'one'
+        ],
         'declare_equal_normalize' => true,
         'dir_constant' => true,
         'ereg_to_preg' => true,
+        'function_to_constant' => true,
         'function_typehint_space' => true,
         'hash_to_slash_comment' => true,
         'heredoc_to_nowdoc' => true,
         'include' => true,
+        'is_null' => true,
         'lowercase_cast' => true,
+        'magic_constant_casing' => true,
         'method_separation' => true,
         'modernize_types_casting' => true,
         'native_function_casing' => true,
@@ -39,6 +47,7 @@ return \PhpCsFixer\Config::create()
         'no_leading_namespace_whitespace' => true,
         'no_mixed_echo_print' => true,
         'no_multiline_whitespace_around_double_arrow' => true,
+        'no_multiline_whitespace_before_semicolons' => true,
         'no_php4_constructor' => true,
         'no_short_bool_cast' => true,
         'no_singleline_whitespace_before_semicolons' => true,
@@ -50,8 +59,12 @@ return \PhpCsFixer\Config::create()
         'no_useless_return' => true,
         'no_whitespace_before_comma_in_array' => true,
         'no_whitespace_in_blank_line' => true,
+        'non_printable_character' => true,
         'normalize_index_brace' => true,
         'object_operator_without_whitespace' => true,
+        'ordered_class_elements' => [
+            'order' => ['use_trait', 'constant', 'property', 'construct', 'method'],
+        ],
         'ordered_imports' => true,
         'php_unit_construct' => true,
         'php_unit_dedicate_assert' => true,

CHANGES.md

@@ -1,5 +1,20 @@
 # Changelog #
 
+## v1.1.0 (2017-06-18) ##
+
+ * Empty objects and objects that don't implement `Traversable` are now always
+   encoded as JSON objects (for `json_encode()` compatibility).
+ * Associative array testing now returns faster and more memory efficiently
+ * JSON encoding errors now contain the error constant
+ * The visibility for `write()` method in `StreamJsonEncoder` and
+   `BufferJsonEncoder` has been changed to protected (as originally intended)
+ * A protected method `getValueStack()` has been added to `AbstractJsonEncoder`
+   that returns current unresolved value stack (for special write method
+   implementations). 
+ * An overridable protected method `resolveValue()` has been added to
+   `AbstractJsonEncoder` which is used to resolve closures and objects
+   implementing `JsonSerializable`.
+
 ## v1.0.0 (2017-02-26) ##
 
   * Initial release

examples/benchmark.php

@@ -0,0 +1,57 @@
+<?php
+
+require __DIR__ . '/../vendor/autoload.php';
+
+ini_set('memory_limit', '2048M');
+
+$payload = [];
+$longString = str_repeat('Lorem ipsum ', 1000);
+$node = [
+    'boolean' => true,
+    'integer' => 1879234,
+    'float' => 1.234900,
+    'string' => 'stringy thingy',
+    'array' => [
+        'value 1',
+        'value 2',
+        'value 3',
+    ],
+    'very_long' => $longString,
+];
+
+for ($i = 0; $i < 10000; $i++) {
+    $payload[] = $node;
+}
+
+function benchmark(Closure $callback)
+{
+    $timer = microtime(true);
+
+    ob_start(function () {
+        return '';
+    }, 1024 * 8);
+
+    $bytes = $callback();
+
+    ob_end_flush();
+    printf(
+        'Output: %s kb, %d ms, Mem %d mb',
+        number_format($bytes / 1024),
+        (microtime(true) - $timer) * 1000,
+        memory_get_peak_usage(true) / 1024 / 1024
+    );
+}
+
+echo 'Streaming: ';
+benchmark(function () use ($payload) {
+    $encoder = new \Violet\StreamingJsonEncoder\StreamJsonEncoder($payload);
+    $encoder->setOptions(JSON_PRETTY_PRINT);
+    return $encoder->encode();
+});
+
+echo "\nDirect:    ";
+benchmark(function () use ($payload) {
+    $output = json_encode($payload, JSON_PRETTY_PRINT);
+    echo $output;
+    return strlen($output);
+});

src/AbstractJsonEncoder.php

@@ -17,6 +17,9 @@ abstract class AbstractJsonEncoder implements \Iterator
     /** @var bool[] True for every object in the stack, false for an array */
     private $stackType;
 
+    /** @var array Stack of values being encoded */
+    private $valueStack;
+
     /** @var bool Whether the next value is the first value in an array or an object */
     private $first;
 
@@ -97,12 +100,21 @@ public function getErrors()
         return $this->errors;
     }
 
+    /**
+     * Returns the current encoding value stack.
+     * @return array The current encoding value stack
+     */
+    protected function getValueStack()
+    {
+        return $this->valueStack;
+    }
+
     /**
      * Initializes the iterator if it has not been initialized yet.
      */
     private function initialize()
     {
-        if ($this->stack === null) {
+        if (!isset($this->stack)) {
             $this->rewind();
         }
     }
@@ -146,6 +158,7 @@ public function rewind()
 
         $this->stack = [];
         $this->stackType = [];
+        $this->valueStack = [];
         $this->errors = [];
         $this->newLine = false;
         $this->first = true;
@@ -229,12 +242,14 @@ private function processKey($key)
      */
     private function processValue($value)
     {
+        $this->valueStack[] = $value;
         $value = $this->resolveValue($value);
 
         if (is_array($value) || is_object($value)) {
             $this->pushStack($value);
         } else {
             $this->outputJson($value, JsonToken::T_VALUE);
+            array_pop($this->valueStack);
         }
     }
 
@@ -251,11 +266,9 @@ protected function resolveValue($value)
             } elseif ($value instanceof \Closure) {
                 $value = $value();
             } else {
-                break;
+                return $value;
             }
         } while (true);
-
-        return $value;
     }
 
     /**
@@ -322,11 +335,11 @@ private function isObject($iterable, \Iterator $iterator)
             return true;
         }
 
-        if (is_array($iterable)) {
-            return $this->isAssociative($iterable);
+        if ($iterable instanceof \Traversable) {
+            return $iterator->valid() && $iterator->key() !== 0;
         }
 
-        return $iterator->valid() ? $iterator->key() !== 0 : !$iterable instanceof \Traversable;
+        return is_object($iterable) || $this->isAssociative($iterable);
     }
 
     /**
@@ -368,6 +381,8 @@ private function popStack()
         } else {
             $this->output(']', JsonToken::T_RIGHT_BRACKET);
         }
+
+        array_pop($this->valueStack);
     }
 
     /**
@@ -381,7 +396,7 @@ private function outputJson($value, $token)
         $error = json_last_error();
 
         if ($error !== JSON_ERROR_NONE) {
-            $this->addError(sprintf('%s (%s)', json_last_error_msg(), $this->getJsonErrorName($error));
+            $this->addError(sprintf('%s (%s)', json_last_error_msg(), $this->getJsonErrorName($error)));
         }
 
         $this->output($encoded, $token);
@@ -403,8 +418,6 @@ private function getJsonErrorName($error)
                 return $match;
             }
         }
-
-        return 'UNKNOWN';
     }
 
     /**

src/BufferJsonEncoder.php

@@ -59,7 +59,7 @@ public function current()
      * @param string $string The JSON string to write
      * @param int $token The type of the token
      */
-    public function write($string, $token)
+    protected function write($string, $token)
     {
         $this->buffer .= $string;
     }

src/StreamJsonEncoder.php

@@ -82,7 +82,7 @@ public function current()
      * @param string $string The string to output
      * @param int $token The type of the string
      */
-    public function write($string, $token)
+    protected function write($string, $token)
     {
         if ($this->stream === null) {
             echo $string;

tests/classes/DateEncoder.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Violet\StreamingJsonEncoder\Test;
+
+use Violet\StreamingJsonEncoder\BufferJsonEncoder;
+use Violet\StreamingJsonEncoder\JsonToken;
+
+class DateEncoder extends BufferJsonEncoder
+{
+    protected function resolveValue($value)
+    {
+        $value = parent::resolveValue($value);
+
+        if ($value instanceof \DateTimeInterface) {
+            $value = $value->format('r');
+        }
+
+        return $value;
+    }
+
+    protected function write($string, $token)
+    {
+        if ($token === JsonToken::T_VALUE) {
+            $stack = $this->getValueStack();
+            $value = end($stack);
+
+            if ($value instanceof \DateTimeInterface) {
+                $string = sprintf('"<time datetime="%s">%s</time>"', $value->format('c'), substr($string, 1, -1));
+            }
+        }
+
+        parent::write($string, $token);
+    }
+}

tests/tests/JsonEncoderTest.php

@@ -3,6 +3,7 @@
 namespace Violet\StreamingJsonEncoder;
 
 use PHPUnit\Framework\TestCase;
+use Violet\StreamingJsonEncoder\Test\DateEncoder;
 use Violet\StreamingJsonEncoder\Test\SerializableData;
 
 /**
@@ -14,6 +15,26 @@
  */
 class JsonEncoderTest extends TestCase
 {
+    public function testEmptyEncoding()
+    {
+        $this->assertEncodingResult('[]', [], []);
+        $this->assertEncodingResult('[]', [], new \ArrayObject([]));
+        $this->assertEncodingResult('{}', [], (object) []);
+    }
+
+    public function testObjectTyping()
+    {
+        $this->assertEncodingResult('["foo"]', ['foo'], ['foo']);
+        $this->assertEncodingResult('{"0":"foo"}', ['foo'], (object) ['foo']);
+        $this->assertEncodingResult('{"1":"foo"}', [1 => 'foo'], [1 => 'foo']);
+
+        $this->assertEncodingResult('["foo"]', ['foo'], new \ArrayObject(['foo']));
+        $this->assertEncodingResult('{"1":"foo"}', [1 => 'foo'], new \ArrayObject([1 => 'foo']));
+        $this->assertEncodingResult('{"0":"foo"}', ['foo'], function () {
+            yield '0' => 'foo';
+        });
+    }
+
     public function testPrettyPrint()
     {
         $expectedJson = <<<'JSON'
@@ -138,7 +159,7 @@ public function testNullOnInvalid()
 
         $encoder = $this->assertEncodingResult($expectedJson, $result, $array, JSON_PARTIAL_OUTPUT_ON_ERROR);
         $this->assertSame([
-            'Line 1, column 10: Type is not supported',
+            'Line 1, column 10: Type is not supported (JSON_ERROR_UNSUPPORTED_TYPE)',
             'Line 1, column 35: Only string or integer keys are supported',
         ], $encoder->getErrors());
     }
@@ -313,6 +334,17 @@ public function testClosureResolving()
         $this->assertSame('[0,1,2,3,4,5,6,7,8,9]', $encoder->encode());
     }
 
+    public function testValueStackResolving()
+    {
+        $date = new \DateTime();
+        $encoder = new DateEncoder([$date]);
+
+        $this->assertSame(
+            sprintf('["<time datetime="%s">%s</time>"]', $date->format('c'), $date->format('r')),
+            $encoder->encode()
+        );
+    }
+
     public function assertEncodingResult($expectedJson, $expectedData, $initialData, $options = 0)
     {
         $encoder = new BufferJsonEncoder($initialData);