Merge pull request #4 from Riimu/next

Riimu · web-flow · commit aab8555c16dd · 2017-07-15T12:02:39.000+03:00
Implement changes for v2.3.0
diff --git a/CHANGES.md b/CHANGES.md
@@ -1,5 +1,20 @@
 # Changelog #
 
+## v2.3.0 (2017-07-15) ##
+
+  * Added `string.utf8` option which causes the string encoder to escape all
+    valid multibyte UTF-8 characters using the PHP7 unicode code point syntax.
+  * Added `string.binary` option which causes the string encoder to encode all
+    non UTF-8 strings using a `base64_encode()`.
+  * Added `integer.type` option that accepts values `binary`, `octal`, `decimal`
+    or `hexadecimal` which can be used to change the output syntax of integers.
+  * Added `hex.capitalize` option that causes all hexadecimal character in
+    output to appear in upper case
+  * Added `float.export` option that forces float encoder to use `var_export`
+    for encoding floating point numbers
+  * Float encoder now delegates integer encoding to the integer encoder (to
+    allow different integer types).
+
 ## v2.2.0 (2017-07-08) ##
 
   * Increase the minimum PHP version requirement to 5.6
diff --git a/README.md b/README.md
@@ -147,6 +147,10 @@ apply to following calls.
     When set to `false`, generation of all extra whitespace is disabled and all
     other settings that affect whitespace are ignored.
 
+  * **hex.capitalize** : &lt;boolean&gt; (false)<br>
+    When set to `true` all hexadecimal characters in the output are written
+    using upper case instead of lower case.
+
   * **null.capitalize** : &lt;boolean&gt; (false)<br>
     When set to `true`, all `null` values are written in upper case instead of
     lower case.
@@ -155,25 +159,45 @@ apply to following calls.
     When set to `true`, all `true` and `false` values are written in upper case
     instead of lower case.
 
+  * **integer.type** : &lt;"binary"|"octal"|"decimal"|"hexadecimal"&gt; ("decimal")<br>
+    Change the output syntax of integers. For example, using the type `"hexadecimal"`
+    would output the number `15` as `0xf`.
+
   * **float.integers** : &lt;boolean|"all"&gt; (false)<br>
     When set to `true`, any float that represents an integer and has a value
     that is accurately represented by the floating point number will be encoded
     as an integer instead of a float. (e.g. the value `2.0` will be encoded as
     `2`). To include the values that are not accurately represented, you may set
     option to `"all"`.
 
+  * **float.export** : &lt;boolean&gt; (false)<br>
+    When set to `true` floats are encoded using `var_export()`, which causes a
+    slightly different output on non integer floating point numbers compared to
+    the standard implemented method. In some cases, this may produce more
+    accurate numbers but with less cleaner representation.
+
   * **float.precision** : &lt;integer|false&gt; (17)<br>
     The maximum precision of encoded floating point values, which usually also
     means the maximum number of digits in encoded floats. If the value is set to
     `false`, the PHP ini setting `serialize_precision` will be used instead.
     Note that due to the way floating point values work, a value greater than 17
     does not provide any additional precision.
 
+  * **string.binary** : &lt;boolean&gt; (false)<br>
+    When set to `true` any string that is not valid UTF-8 will be encoded in
+    base 64 and wrapped with `base64_decode()` call.
+
   * **string.escape** : &lt;boolean&gt; (true)<br>
     When set to `true`, all strings containing bytes outside the 32-126 ASCII
     range will be written with double quotes and the characters outside the
     range will be escaped.
 
+  * **string.utf8** : &lt;boolean&gt; (false)<br>
+    When both this option and `string.escape` are set to `true`, all valid
+    multibyte UTF-8 characters in strings are encoded using the PHP7 unicode
+    code point syntax. Note that this syntax does not work in PHP versions
+    earlier than 7.0.
+
   * **array.short** : &lt;boolean&gt; (true)<br>
     When set to `true`, arrays are enclosed using square brackets `[]` instead
     using of the long array notation `array()`.
diff --git a/examples/export_difference.php b/examples/export_difference.php
@@ -0,0 +1,35 @@
+<?php
+
+require __DIR__ . '/../vendor/autoload.php';
+
+$precision = 17;
+$normalEncoder = new \Riimu\Kit\PHPEncoder\PHPEncoder(['float.precision' => $precision]);
+$exportEncoder = new \Riimu\Kit\PHPEncoder\PHPEncoder(['float.export' => true]);
+
+ini_set('serialize_precision', $precision);
+
+$count = 0;
+$mindiff = 1;
+$maxdiff = 0;
+$total = 0;
+
+for ($i = 0; $i <= 2 ** 53; $i++) {
+    $normal = $normalEncoder->encode($i / 2 ** 53); // $i / 2 ** 53
+    $export = $exportEncoder->encode($i / 2 ** 53); // $i / 2 ** 53
+
+    $normalResult = eval("return $normal;");
+    $exportResult = eval("return $export;");
+
+    if ($normalResult !== $exportResult) {
+        $diff = abs($normalResult - $exportResult);
+
+        $count++;
+        $mindiff = min($diff, $mindiff);
+        $maxdiff = max($diff, $maxdiff);
+        $total += $diff;
+        $avgdiff = $total / $count;
+        $pct = round($count / $i * 100, 2);
+
+        echo "Different ($count / $i, $pct%): $normal, $export, Diff: $mindiff / $avgdiff / $maxdiff\n";
+    }
+}
diff --git a/src/Encoder/FloatEncoder.php b/src/Encoder/FloatEncoder.php
@@ -17,6 +17,7 @@ class FloatEncoder implements Encoder
     private static $defaultOptions = [
         'float.integers'  => false,
         'float.precision' => 17,
+        'float.export' => false,
     ];
 
     public function getDefaultOptions()
@@ -37,30 +38,27 @@ public function encode($value, $depth, array $options, callable $encode)
             return $value < 0 ? '-INF' : 'INF';
         }
 
-        return $this->encodeNumber($value, $options);
+        return $this->encodeNumber($value, $options, $encode);
     }
 
     /**
      * Encodes the number as a PHP number representation.
      * @param float $float The number to encode
      * @param array $options The float encoding options
+     * @param callable $encode Callback used to encode values
      * @return string The PHP code representation for the number
      */
-    private function encodeNumber($float, array $options)
+    private function encodeNumber($float, array $options, callable $encode)
     {
         if ($this->isInteger($float, $options['float.integers'])) {
-            return number_format($float, 0, '.', '');
+            return $this->encodeInteger($float, $encode);
         } elseif ($float === 0.0) {
             return '0.0';
+        } elseif ($options['float.export']) {
+            return var_export((float) $float, true);
         }
 
-        $precision = $options['float.precision'];
-
-        if ($precision === false) {
-            $precision = ini_get('serialize_precision');
-        }
-
-        return $this->encodeFloat($float, $precision);
+        return $this->encodeFloat($float, $this->determinePrecision($options));
     }
 
     /**
@@ -80,6 +78,39 @@ private function isInteger($float, $allowIntegers)
         return $allowIntegers === 'all';
     }
 
+    /**
+     * Encodes the given float as an integer.
+     * @param float $float The number to encode
+     * @param callable $encode Callback used to encode values
+     * @return string The PHP code representation for the number
+     */
+    private function encodeInteger($float, callable $encode)
+    {
+        $minimum = defined('PHP_INT_MIN') ? PHP_INT_MIN : ~PHP_INT_MAX;
+
+        if ($float >= $minimum && $float <= PHP_INT_MAX) {
+            return $encode((int) $float);
+        }
+
+        return number_format($float, 0, '.', '');
+    }
+
+    /**
+     * Determines the float precision based on the options.
+     * @param array $options The float encoding options
+     * @return int The precision used to encode floats
+     */
+    private function determinePrecision($options)
+    {
+        $precision = $options['float.precision'];
+
+        if ($precision === false) {
+            $precision = defined('HHVM_VERSION') ? 17 : ini_get('serialize_precision');
+        }
+
+        return max(1, (int) $precision);
+    }
+
     /**
      * Encodes the number using a floating point representation.
      * @param float $float The number to encode
@@ -88,10 +119,9 @@ private function isInteger($float, $allowIntegers)
      */
     private function encodeFloat($float, $precision)
     {
-        $precision = max(1, (int) $precision);
         $log = (int) floor(log(abs($float), 10));
 
-        if (abs($float) < self::FLOAT_MAX && $log > -5 && abs($log) < $precision) {
+        if ($log > -5 && abs($float) < self::FLOAT_MAX && abs($log) < $precision) {
             return $this->formatFloat($float, $precision - $log - 1);
         }
 
diff --git a/src/Encoder/IntegerEncoder.php b/src/Encoder/IntegerEncoder.php
@@ -10,9 +10,38 @@
  */
 class IntegerEncoder implements Encoder
 {
+    /** @var array Default values for options in the encoder */
+    private static $defaultOptions = [
+        'integer.type' => 'decimal',
+    ];
+
+    /** @var \Closure[] Encoders for different types of integers */
+    private $encoders;
+
+    /**
+     * IntegerEncoder constructor.
+     */
+    public function __construct()
+    {
+        $this->encoders = [
+            'binary' => function ($value) {
+                return $this->encodeBinary($value);
+            },
+            'octal' => function ($value) {
+                return $this->encodeOctal($value);
+            },
+            'decimal' => function ($value, $options) {
+                return $this->encodeDecimal($value, $options);
+            },
+            'hexadecimal' => function ($value, $options) {
+                return $this->encodeHexadecimal($value, $options);
+            },
+        ];
+    }
+
     public function getDefaultOptions()
     {
-        return [];
+        return self::$defaultOptions;
     }
 
     public function supports($value)
@@ -22,12 +51,76 @@ public function supports($value)
 
     public function encode($value, $depth, array $options, callable $encode)
     {
-        $string = (string) $value;
+        if (!isset($this->encoders[$options['integer.type']])) {
+            throw new \InvalidArgumentException('Invalid integer encoding type');
+        }
+
+        $callback = $this->encoders[$options['integer.type']];
+
+        return $callback((int) $value, $options);
+    }
+
+    /**
+     * Encodes an integer into binary representation.
+     * @param int $integer The integer to encode
+     * @return string The PHP code representation for the integer
+     */
+    public function encodeBinary($integer)
+    {
+        return sprintf('%s0b%b', $this->sign($integer), abs($integer));
+    }
+
+    /**
+     * Encodes an integer into octal representation.
+     * @param int $integer The integer to encode
+     * @return string The PHP code representation for the integer
+     */
+    public function encodeOctal($integer)
+    {
+        return sprintf('%s0%o', $this->sign($integer), abs($integer));
+    }
+
+    /**
+     * Encodes an integer into decimal representation.
+     * @param int $integer The integer to encode
+     * @param array $options The integer encoding options
+     * @return string The PHP code representation for the integer
+     */
+    public function encodeDecimal($integer, $options)
+    {
+        if ($integer === 1 << (PHP_INT_SIZE * 8 - 1)) {
+            return sprintf('(int)%s%d', $options['whitespace'] ? ' ' : '', $integer);
+        }
+
+        return var_export($integer, true);
+    }
 
-        if ($value === 1 << (PHP_INT_SIZE * 8 - 1)) {
-            $string = sprintf('(int)%s%s', $options['whitespace'] ? ' ' : '', $string);
+    /**
+     * Encodes an integer into hexadecimal representation.
+     * @param int $integer The integer to encode
+     * @param array $options The integer encoding options
+     * @return string The PHP code representation for the integer
+     */
+    public function encodeHexadecimal($integer, $options)
+    {
+        if ($options['hex.capitalize']) {
+            return sprintf('%s0x%X', $this->sign($integer), abs($integer));
+        }
+
+        return sprintf('%s0x%x', $this->sign($integer), abs($integer));
+    }
+
+    /**
+     * Returns the negative sign for negative numbers.
+     * @param int $integer The number to test for negativity
+     * @return string The minus sign for negative numbers and empty string for positive numbers
+     */
+    private function sign($integer)
+    {
+        if ($integer < 0) {
+            return '-';
         }
 
-        return $string;
+        return '';
     }
 }
diff --git a/src/Encoder/ObjectEncoder.php b/src/Encoder/ObjectEncoder.php
@@ -66,6 +66,7 @@ private function encodeObject($object, array $options, callable $encode)
      * @param array $options List of encoder options
      * @param callable $encode Callback used to encode values
      * @return string The object encoded as string
+     * @throws \RuntimeException If the object format is invalid
      */
     private function encodeObjectArray($object, array $options, callable $encode)
     {
diff --git a/src/Encoder/StringEncoder.php b/src/Encoder/StringEncoder.php
diff --git a/src/PHPEncoder.php b/src/PHPEncoder.php
diff --git a/tests/tests/EncodingTest.php b/tests/tests/EncodingTest.php

Original file line number	Diff line number	Diff line change
`@@ -66,6 +66,7 @@ private function encodeObject($object, array $options, callable $encode)`
`66`	`66`	`* @param array $options List of encoder options`
`67`	`67`	`* @param callable $encode Callback used to encode values`
`68`	`68`	`* @return string The object encoded as string`
	`69`	`+ * @throws \RuntimeException If the object format is invalid`
`69`	`70`	`*/`
`70`	`71`	`private function encodeObjectArray($object, array $options, callable $encode)`
`71`	`72`	`{`