first commit

modules/x13import/tools/Spout/Common/Escaper/CSV.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Box\Spout\Common\Escaper;
+
+/**
+ * Class CSV
+ * Provides functions to escape and unescape data for CSV files
+ *
+ * @package Box\Spout\Common\Escaper
+ */
+class CSV implements EscaperInterface
+{
+    /**
+     * Escapes the given string to make it compatible with CSV
+     *
+     * @codeCoverageIgnore
+     *
+     * @param string $string The string to escape
+     * @return string The escaped string
+     */
+    public function escape($string)
+    {
+        return $string;
+    }
+
+    /**
+     * Unescapes the given string to make it compatible with CSV
+     *
+     * @codeCoverageIgnore
+     *
+     * @param string $string The string to unescape
+     * @return string The unescaped string
+     */
+    public function unescape($string)
+    {
+        return $string;
+    }
+}

modules/x13import/tools/Spout/Common/Escaper/EscaperInterface.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Box\Spout\Common\Escaper;
+
+/**
+ * Interface EscaperInterface
+ *
+ * @package Box\Spout\Common\Escaper
+ */
+interface EscaperInterface
+{
+    /**
+     * Escapes the given string to make it compatible with PHP
+     *
+     * @param string $string The string to escape
+     * @return string The escaped string
+     */
+    public function escape($string);
+
+    /**
+     * Unescapes the given string to make it compatible with PHP
+     *
+     * @param string $string The string to unescape
+     * @return string The unescaped string
+     */
+    public function unescape($string);
+}

modules/x13import/tools/Spout/Common/Escaper/ODS.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Box\Spout\Common\Escaper;
+
+use Box\Spout\Common\Singleton;
+
+/**
+ * Class ODS
+ * Provides functions to escape and unescape data for ODS files
+ *
+ * @package Box\Spout\Common\Escaper
+ */
+class ODS implements EscaperInterface
+{
+    use Singleton;
+
+    /**
+     * Escapes the given string to make it compatible with XLSX
+     *
+     * @param string $string The string to escape
+     * @return string The escaped string
+     */
+    public function escape($string)
+    {
+        if (defined('ENT_DISALLOWED')) {
+            // 'ENT_DISALLOWED' ensures that invalid characters in the given document type are replaced.
+            // Otherwise control characters like a vertical tab "\v" will make the XML document unreadable by the XML processor
+            // @link https://github.com/box/spout/issues/329
+            $replacedString = htmlspecialchars($string, ENT_NOQUOTES | ENT_DISALLOWED);
+        } else {
+            // We are on hhvm or any other engine that does not support ENT_DISALLOWED.
+            //
+            // @NOTE: Using ENT_NOQUOTES as only XML entities ('<', '>', '&') need to be encoded.
+            //        Single and double quotes can be left as is.
+            $escapedString =  htmlspecialchars($string, ENT_NOQUOTES);
+
+            // control characters values are from 0 to 1F (hex values) in the ASCII table
+            // some characters should not be escaped though: "\t", "\r" and "\n".
+            $regexPattern = '[\x00-\x08' .
+                            // skipping "\t" (0x9) and "\n" (0xA)
+                            '\x0B-\x0C' .
+                            // skipping "\r" (0xD)
+                            '\x0E-\x1F]';
+            $replacedString = preg_replace("/$regexPattern/", '<27>', $escapedString);
+        }
+
+        return $replacedString;
+    }
+
+    /**
+     * Unescapes the given string to make it compatible with XLSX
+     *
+     * @param string $string The string to unescape
+     * @return string The unescaped string
+     */
+    public function unescape($string)
+    {
+        // ==============
+        // =   WARNING  =
+        // ==============
+        // It is assumed that the given string has already had its XML entities decoded.
+        // This is true if the string is coming from a DOMNode (as DOMNode already decode XML entities on creation).
+        // Therefore there is no need to call "htmlspecialchars_decode()".
+        return $string;
+    }
+}

modules/x13import/tools/Spout/Common/Escaper/XLSX.php

@@ -0,0 +1,185 @@
+<?php
+
+namespace Box\Spout\Common\Escaper;
+
+use Box\Spout\Common\Singleton;
+
+/**
+ * Class XLSX
+ * Provides functions to escape and unescape data for XLSX files
+ *
+ * @package Box\Spout\Common\Escaper
+ */
+class XLSX implements EscaperInterface
+{
+    use Singleton;
+
+    /** @var string Regex pattern to detect control characters that need to be escaped */
+    protected $escapableControlCharactersPattern;
+
+    /** @var string[] Map containing control characters to be escaped (key) and their escaped value (value) */
+    protected $controlCharactersEscapingMap;
+
+    /** @var string[] Map containing control characters to be escaped (value) and their escaped value (key) */
+    protected $controlCharactersEscapingReverseMap;
+
+    /**
+     * Initializes the singleton instance
+     */
+    protected function init()
+    {
+        $this->escapableControlCharactersPattern = $this->getEscapableControlCharactersPattern();
+        $this->controlCharactersEscapingMap = $this->getControlCharactersEscapingMap();
+        $this->controlCharactersEscapingReverseMap = array_flip($this->controlCharactersEscapingMap);
+    }
+
+    /**
+     * Escapes the given string to make it compatible with XLSX
+     *
+     * @param string $string The string to escape
+     * @return string The escaped string
+     */
+    public function escape($string)
+    {
+        $escapedString = $this->escapeControlCharacters($string);
+        // @NOTE: Using ENT_NOQUOTES as only XML entities ('<', '>', '&') need to be encoded.
+        //        Single and double quotes can be left as is.
+        $escapedString = htmlspecialchars($escapedString, ENT_NOQUOTES);
+
+        return $escapedString;
+    }
+
+    /**
+     * Unescapes the given string to make it compatible with XLSX
+     *
+     * @param string $string The string to unescape
+     * @return string The unescaped string
+     */
+    public function unescape($string)
+    {
+        // ==============
+        // =   WARNING  =
+        // ==============
+        // It is assumed that the given string has already had its XML entities decoded.
+        // This is true if the string is coming from a DOMNode (as DOMNode already decode XML entities on creation).
+        // Therefore there is no need to call "htmlspecialchars_decode()".
+        $unescapedString = $this->unescapeControlCharacters($string);
+
+        return $unescapedString;
+    }
+
+    /**
+     * @return string Regex pattern containing all escapable control characters
+     */
+    protected function getEscapableControlCharactersPattern()
+    {
+        // control characters values are from 0 to 1F (hex values) in the ASCII table
+        // some characters should not be escaped though: "\t", "\r" and "\n".
+        return '[\x00-\x08' .
+                // skipping "\t" (0x9) and "\n" (0xA)
+                '\x0B-\x0C' .
+                // skipping "\r" (0xD)
+                '\x0E-\x1F]';
+    }
+
+    /**
+     * Builds the map containing control characters to be escaped
+     * mapped to their escaped values.
+     * "\t", "\r" and "\n" don't need to be escaped.
+     *
+     * NOTE: the logic has been adapted from the XlsxWriter library (BSD License)
+     * @link https://github.com/jmcnamara/XlsxWriter/blob/f1e610f29/xlsxwriter/sharedstrings.py#L89
+     *
+     * @return string[]
+     */
+    protected function getControlCharactersEscapingMap()
+    {
+        $controlCharactersEscapingMap = [];
+
+        // control characters values are from 0 to 1F (hex values) in the ASCII table
+        for ($charValue = 0x00; $charValue <= 0x1F; $charValue++) {
+            $character = chr($charValue);
+            if (preg_match("/{$this->escapableControlCharactersPattern}/", $character)) {
+                $charHexValue = dechex($charValue);
+                $escapedChar = '_x' . sprintf('%04s' , strtoupper($charHexValue)) . '_';
+                $controlCharactersEscapingMap[$escapedChar] = $character;
+            }
+        }
+
+        return $controlCharactersEscapingMap;
+    }
+
+    /**
+     * Converts PHP control characters from the given string to OpenXML escaped control characters
+     *
+     * Excel escapes control characters with _xHHHH_ and also escapes any
+     * literal strings of that type by encoding the leading underscore.
+     * So "\0" -> _x0000_ and "_x0000_" -> _x005F_x0000_.
+     *
+     * NOTE: the logic has been adapted from the XlsxWriter library (BSD License)
+     * @link https://github.com/jmcnamara/XlsxWriter/blob/f1e610f29/xlsxwriter/sharedstrings.py#L89
+     *
+     * @param string $string String to escape
+     * @return string
+     */
+    protected function escapeControlCharacters($string)
+    {
+        $escapedString = $this->escapeEscapeCharacter($string);
+
+        // if no control characters
+        if (!preg_match("/{$this->escapableControlCharactersPattern}/", $escapedString)) {
+            return $escapedString;
+        }
+
+        return preg_replace_callback("/({$this->escapableControlCharactersPattern})/", function($matches) {
+            return $this->controlCharactersEscapingReverseMap[$matches[0]];
+        }, $escapedString);
+    }
+
+    /**
+     * Escapes the escape character: "_x0000_" -> "_x005F_x0000_"
+     *
+     * @param string $string String to escape
+     * @return string The escaped string
+     */
+    protected function escapeEscapeCharacter($string)
+    {
+        return preg_replace('/_(x[\dA-F]{4})_/', '_x005F_$1_', $string);
+    }
+
+    /**
+     * Converts OpenXML escaped control characters from the given string to PHP control characters
+     *
+     * Excel escapes control characters with _xHHHH_ and also escapes any
+     * literal strings of that type by encoding the leading underscore.
+     * So "_x0000_" -> "\0" and "_x005F_x0000_" -> "_x0000_"
+     *
+     * NOTE: the logic has been adapted from the XlsxWriter library (BSD License)
+     * @link https://github.com/jmcnamara/XlsxWriter/blob/f1e610f29/xlsxwriter/sharedstrings.py#L89
+     *
+     * @param string $string String to unescape
+     * @return string
+     */
+    protected function unescapeControlCharacters($string)
+    {
+        $unescapedString = $string;
+
+        foreach ($this->controlCharactersEscapingMap as $escapedCharValue => $charValue) {
+            // only unescape characters that don't contain the escaped escape character for now
+            $unescapedString = preg_replace("/(?<!_x005F)($escapedCharValue)/", $charValue, $unescapedString);
+        }
+
+        return $this->unescapeEscapeCharacter($unescapedString);
+    }
+
+    /**
+     * Unecapes the escape character: "_x005F_x0000_" => "_x0000_"
+     *
+     * @param string $string String to unescape
+     * @return string The unescaped string
+     */
+    protected function unescapeEscapeCharacter($string)
+    {
+        return preg_replace('/_x005F(_x[\dA-F]{4}_)/', '$1', $string);
+    }
+}

modules/x13import/tools/Spout/Common/Exception/EncodingConversionException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Common\Exception;
+
+/**
+ * Class EncodingConversionException
+ *
+ * @api
+ * @package Box\Spout\Common\Exception
+ */
+class EncodingConversionException extends SpoutException
+{
+}

modules/x13import/tools/Spout/Common/Exception/IOException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Common\Exception;
+
+/**
+ * Class IOException
+ *
+ * @api
+ * @package Box\Spout\Common\Exception
+ */
+class IOException extends SpoutException
+{
+}

modules/x13import/tools/Spout/Common/Exception/InvalidArgumentException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Common\Exception;
+
+/**
+ * Class InvalidArgumentException
+ *
+ * @api
+ * @package Box\Spout\Common\Exception
+ */
+class InvalidArgumentException extends SpoutException
+{
+}

modules/x13import/tools/Spout/Common/Exception/SpoutException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Common\Exception;
+
+/**
+ * Class SpoutException
+ *
+ * @package Box\Spout\Common\Exception
+ * @abstract
+ */
+abstract class SpoutException extends \Exception
+{
+}

modules/x13import/tools/Spout/Common/Exception/UnsupportedTypeException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Common\Exception;
+
+/**
+ * Class UnsupportedTypeException
+ *
+ * @api
+ * @package Box\Spout\Common\Exception
+ */
+class UnsupportedTypeException extends SpoutException
+{
+}

modules/x13import/tools/Spout/Common/Helper/EncodingHelper.php

@@ -0,0 +1,175 @@
+<?php
+
+namespace Box\Spout\Common\Helper;
+
+use Box\Spout\Common\Exception\EncodingConversionException;
+
+/**
+ * Class EncodingHelper
+ * This class provides helper functions to work with encodings.
+ *
+ * @package Box\Spout\Common\Helper
+ */
+class EncodingHelper
+{
+    /** Definition of the encodings that can have a BOM */
+    const ENCODING_UTF8     = 'UTF-8';
+    const ENCODING_UTF16_LE = 'UTF-16LE';
+    const ENCODING_UTF16_BE = 'UTF-16BE';
+    const ENCODING_UTF32_LE = 'UTF-32LE';
+    const ENCODING_UTF32_BE = 'UTF-32BE';
+
+    /** Definition of the BOMs for the different encodings */
+    const BOM_UTF8     = "\xEF\xBB\xBF";
+    const BOM_UTF16_LE = "\xFF\xFE";
+    const BOM_UTF16_BE = "\xFE\xFF";
+    const BOM_UTF32_LE = "\xFF\xFE\x00\x00";
+    const BOM_UTF32_BE = "\x00\x00\xFE\xFF";
+
+    /** @var \Box\Spout\Common\Helper\GlobalFunctionsHelper Helper to work with global functions */
+    protected $globalFunctionsHelper;
+
+    /** @var array Map representing the encodings supporting BOMs (key) and their associated BOM (value) */
+    protected $supportedEncodingsWithBom;
+
+    /**
+     * @param \Box\Spout\Common\Helper\GlobalFunctionsHelper $globalFunctionsHelper
+     */
+    public function __construct($globalFunctionsHelper)
+    {
+        $this->globalFunctionsHelper = $globalFunctionsHelper;
+
+        $this->supportedEncodingsWithBom = [
+            self::ENCODING_UTF8     => self::BOM_UTF8,
+            self::ENCODING_UTF16_LE => self::BOM_UTF16_LE,
+            self::ENCODING_UTF16_BE => self::BOM_UTF16_BE,
+            self::ENCODING_UTF32_LE => self::BOM_UTF32_LE,
+            self::ENCODING_UTF32_BE => self::BOM_UTF32_BE,
+        ];
+    }
+
+    /**
+     * Returns the number of bytes to use as offset in order to skip the BOM.
+     *
+     * @param resource $filePointer Pointer to the file to check
+     * @param string $encoding Encoding of the file to check
+     * @return int Bytes offset to apply to skip the BOM (0 means no BOM)
+     */
+    public function getBytesOffsetToSkipBOM($filePointer, $encoding)
+    {
+        $byteOffsetToSkipBom = 0;
+
+        if ($this->hasBOM($filePointer, $encoding)) {
+            $bomUsed = $this->supportedEncodingsWithBom[$encoding];
+
+            // we skip the N first bytes
+            $byteOffsetToSkipBom = strlen($bomUsed);
+        }
+
+        return $byteOffsetToSkipBom;
+    }
+
+    /**
+     * Returns whether the file identified by the given pointer has a BOM.
+     *
+     * @param resource $filePointer Pointer to the file to check
+     * @param string $encoding Encoding of the file to check
+     * @return bool TRUE if the file has a BOM, FALSE otherwise
+     */
+    protected function hasBOM($filePointer, $encoding)
+    {
+        $hasBOM = false;
+
+        $this->globalFunctionsHelper->rewind($filePointer);
+
+        if (array_key_exists($encoding, $this->supportedEncodingsWithBom)) {
+            $potentialBom = $this->supportedEncodingsWithBom[$encoding];
+            $numBytesInBom = strlen($potentialBom);
+
+            $hasBOM = ($this->globalFunctionsHelper->fgets($filePointer, $numBytesInBom + 1) === $potentialBom);
+        }
+
+        return $hasBOM;
+    }
+
+    /**
+     * Attempts to convert a non UTF-8 string into UTF-8.
+     *
+     * @param string $string Non UTF-8 string to be converted
+     * @param string $sourceEncoding The encoding used to encode the source string
+     * @return string The converted, UTF-8 string
+     * @throws \Box\Spout\Common\Exception\EncodingConversionException If conversion is not supported or if the conversion failed
+     */
+    public function attemptConversionToUTF8($string, $sourceEncoding)
+    {
+        return $this->attemptConversion($string, $sourceEncoding, self::ENCODING_UTF8);
+    }
+
+    /**
+     * Attempts to convert a UTF-8 string into the given encoding.
+     *
+     * @param string $string UTF-8 string to be converted
+     * @param string $targetEncoding The encoding the string should be re-encoded into
+     * @return string The converted string, encoded with the given encoding
+     * @throws \Box\Spout\Common\Exception\EncodingConversionException If conversion is not supported or if the conversion failed
+     */
+    public function attemptConversionFromUTF8($string, $targetEncoding)
+    {
+        return $this->attemptConversion($string, self::ENCODING_UTF8, $targetEncoding);
+    }
+
+    /**
+     * Attempts to convert the given string to the given encoding.
+     * Depending on what is installed on the server, we will try to iconv or mbstring.
+     *
+     * @param string $string string to be converted
+     * @param string $sourceEncoding The encoding used to encode the source string
+     * @param string $targetEncoding The encoding the string should be re-encoded into
+     * @return string The converted string, encoded with the given encoding
+     * @throws \Box\Spout\Common\Exception\EncodingConversionException If conversion is not supported or if the conversion failed
+     */
+    protected function attemptConversion($string, $sourceEncoding, $targetEncoding)
+    {
+        // if source and target encodings are the same, it's a no-op
+        if ($sourceEncoding === $targetEncoding) {
+            return $string;
+        }
+
+        $convertedString = null;
+
+        if ($this->canUseIconv()) {
+            $convertedString = $this->globalFunctionsHelper->iconv($string, $sourceEncoding, $targetEncoding);
+        } else if ($this->canUseMbString()) {
+            $convertedString = $this->globalFunctionsHelper->mb_convert_encoding($string, $sourceEncoding, $targetEncoding);
+        } else {
+            throw new EncodingConversionException("The conversion from $sourceEncoding to $targetEncoding is not supported. Please install \"iconv\" or \"PHP Intl\".");
+        }
+
+        if ($convertedString === false) {
+            throw new EncodingConversionException("The conversion from $sourceEncoding to $targetEncoding failed.");
+        }
+
+        return $convertedString;
+    }
+
+    /**
+     * Returns whether "iconv" can be used.
+     *
+     * @return bool TRUE if "iconv" is available and can be used, FALSE otherwise
+     */
+    protected function canUseIconv()
+    {
+        return $this->globalFunctionsHelper->function_exists('iconv');
+    }
+
+    /**
+     * Returns whether "mb_string" functions can be used.
+     * These functions come with the PHP Intl package.
+     *
+     * @return bool TRUE if "mb_string" functions are available and can be used, FALSE otherwise
+     */
+    protected function canUseMbString()
+    {
+        return $this->globalFunctionsHelper->function_exists('mb_convert_encoding');
+    }
+}

modules/x13import/tools/Spout/Common/Helper/FileSystemHelper.php

@@ -0,0 +1,133 @@
+<?php
+
+namespace Box\Spout\Common\Helper;
+
+use Box\Spout\Common\Exception\IOException;
+
+/**
+ * Class FileSystemHelper
+ * This class provides helper functions to help with the file system operations
+ * like files/folders creation & deletion
+ *
+ * @package Box\Spout\Common\Helper
+ */
+class FileSystemHelper
+{
+    /** @var string Real path of the base folder where all the I/O can occur */
+    protected $baseFolderRealPath;
+
+    /**
+     * @param string $baseFolderPath The path of the base folder where all the I/O can occur
+     */
+    public function __construct($baseFolderPath)
+    {
+        $this->baseFolderRealPath = realpath($baseFolderPath);
+    }
+
+    /**
+     * Creates an empty folder with the given name under the given parent folder.
+     *
+     * @param string $parentFolderPath The parent folder path under which the folder is going to be created
+     * @param string $folderName The name of the folder to create
+     * @return string Path of the created folder
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder or if the folder path is not inside of the base folder
+     */
+    public function createFolder($parentFolderPath, $folderName)
+    {
+        $this->throwIfOperationNotInBaseFolder($parentFolderPath);
+
+        $folderPath = $parentFolderPath . '/' . $folderName;
+
+        $wasCreationSuccessful = mkdir($folderPath, 0777, true);
+        if (!$wasCreationSuccessful) {
+            throw new IOException("Unable to create folder: $folderPath");
+        }
+
+        return $folderPath;
+    }
+
+    /**
+     * Creates a file with the given name and content in the given folder.
+     * The parent folder must exist.
+     *
+     * @param string $parentFolderPath The parent folder path where the file is going to be created
+     * @param string $fileName The name of the file to create
+     * @param string $fileContents The contents of the file to create
+     * @return string Path of the created file
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the file or if the file path is not inside of the base folder
+     */
+    public function createFileWithContents($parentFolderPath, $fileName, $fileContents)
+    {
+        $this->throwIfOperationNotInBaseFolder($parentFolderPath);
+
+        $filePath = $parentFolderPath . '/' . $fileName;
+
+        $wasCreationSuccessful = file_put_contents($filePath, $fileContents);
+        if ($wasCreationSuccessful === false) {
+            throw new IOException("Unable to create file: $filePath");
+        }
+
+        return $filePath;
+    }
+
+    /**
+     * Delete the file at the given path
+     *
+     * @param string $filePath Path of the file to delete
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the file path is not inside of the base folder
+     */
+    public function deleteFile($filePath)
+    {
+        $this->throwIfOperationNotInBaseFolder($filePath);
+
+        if (file_exists($filePath) && is_file($filePath)) {
+            unlink($filePath);
+        }
+    }
+
+    /**
+     * Delete the folder at the given path as well as all its contents
+     *
+     * @param string $folderPath Path of the folder to delete
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the folder path is not inside of the base folder
+     */
+    public function deleteFolderRecursively($folderPath)
+    {
+        $this->throwIfOperationNotInBaseFolder($folderPath);
+
+        $itemIterator = new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($folderPath, \RecursiveDirectoryIterator::SKIP_DOTS),
+            \RecursiveIteratorIterator::CHILD_FIRST
+        );
+
+        foreach ($itemIterator as $item) {
+            if ($item->isDir()) {
+                rmdir($item->getPathname());
+            } else {
+                unlink($item->getPathname());
+            }
+        }
+
+        rmdir($folderPath);
+    }
+
+    /**
+     * All I/O operations must occur inside the base folder, for security reasons.
+     * This function will throw an exception if the folder where the I/O operation
+     * should occur is not inside the base folder.
+     *
+     * @param string $operationFolderPath The path of the folder where the I/O operation should occur
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the folder where the I/O operation should occur is not inside the base folder
+     */
+    protected function throwIfOperationNotInBaseFolder($operationFolderPath)
+    {
+        $operationFolderRealPath = realpath($operationFolderPath);
+        $isInBaseFolder = (strpos($operationFolderRealPath, $this->baseFolderRealPath) === 0);
+        if (!$isInBaseFolder) {
+            throw new IOException("Cannot perform I/O operation outside of the base folder: {$this->baseFolderRealPath}");
+        }
+    }
+}

modules/x13import/tools/Spout/Common/Helper/GlobalFunctionsHelper.php

@@ -0,0 +1,318 @@
+<?php
+
+namespace Box\Spout\Common\Helper;
+
+/**
+ * Class GlobalFunctionsHelper
+ * This class wraps global functions to facilitate testing
+ *
+ * @codeCoverageIgnore
+ *
+ * @package Box\Spout\Common\Helper
+ */
+class GlobalFunctionsHelper
+{
+    /**
+     * Wrapper around global function fopen()
+     * @see fopen()
+     *
+     * @param string $fileName
+     * @param string $mode
+     * @return resource|bool
+     */
+    public function fopen($fileName, $mode)
+    {
+        return fopen($fileName, $mode);
+    }
+
+    /**
+     * Wrapper around global function fgets()
+     * @see fgets()
+     *
+     * @param resource $handle
+     * @param int|void $length
+     * @return string
+     */
+    public function fgets($handle, $length = null)
+    {
+        return fgets($handle, $length);
+    }
+
+    /**
+     * Wrapper around global function fputs()
+     * @see fputs()
+     *
+     * @param resource $handle
+     * @param string $string
+     * @return int
+     */
+    public function fputs($handle, $string)
+    {
+        return fputs($handle, $string);
+    }
+
+    /**
+     * Wrapper around global function fflush()
+     * @see fflush()
+     *
+     * @param resource $handle
+     * @return bool
+     */
+    public function fflush($handle)
+    {
+        return fflush($handle);
+    }
+
+    /**
+     * Wrapper around global function fseek()
+     * @see fseek()
+     *
+     * @param resource $handle
+     * @param int $offset
+     * @return int
+     */
+    public function fseek($handle, $offset)
+    {
+        return fseek($handle, $offset);
+    }
+
+    /**
+     * Wrapper around global function fgetcsv()
+     * @see fgetcsv()
+     *
+     * @param resource $handle
+     * @param int|void $length
+     * @param string|void $delimiter
+     * @param string|void $enclosure
+     * @return array
+     */
+    public function fgetcsv($handle, $length = null, $delimiter = null, $enclosure = null)
+    {
+        return fgetcsv($handle, $length, $delimiter, $enclosure);
+    }
+
+    /**
+     * Wrapper around global function fputcsv()
+     * @see fputcsv()
+     *
+     * @param resource $handle
+     * @param array $fields
+     * @param string|void $delimiter
+     * @param string|void $enclosure
+     * @return int
+     */
+    public function fputcsv($handle, array $fields, $delimiter = null, $enclosure = null)
+    {
+        return fputcsv($handle, $fields, $delimiter, $enclosure);
+    }
+
+    /**
+     * Wrapper around global function fwrite()
+     * @see fwrite()
+     *
+     * @param resource $handle
+     * @param string $string
+     * @return int
+     */
+    public function fwrite($handle, $string)
+    {
+        return fwrite($handle, $string);
+    }
+
+    /**
+     * Wrapper around global function fclose()
+     * @see fclose()
+     *
+     * @param resource $handle
+     * @return bool
+     */
+    public function fclose($handle)
+    {
+        return fclose($handle);
+    }
+
+    /**
+     * Wrapper around global function rewind()
+     * @see rewind()
+     *
+     * @param resource $handle
+     * @return bool
+     */
+    public function rewind($handle)
+    {
+        return rewind($handle);
+    }
+
+    /**
+     * Wrapper around global function file_exists()
+     * @see file_exists()
+     *
+     * @param string $fileName
+     * @return bool
+     */
+    public function file_exists($fileName)
+    {
+        return file_exists($fileName);
+    }
+
+    /**
+     * Wrapper around global function file_get_contents()
+     * @see file_get_contents()
+     *
+     * @param string $filePath
+     * @return string
+     */
+    public function file_get_contents($filePath)
+    {
+        $realFilePath = $this->convertToUseRealPath($filePath);
+        return file_get_contents($realFilePath);
+    }
+
+    /**
+     * Updates the given file path to use a real path.
+     * This is to avoid issues on some Windows setup.
+     *
+     * @param string $filePath File path
+     * @return string The file path using a real path
+     */
+    protected function convertToUseRealPath($filePath)
+    {
+        $realFilePath = $filePath;
+
+        if ($this->isZipStream($filePath)) {
+            if (preg_match('/zip:\/\/(.*)#(.*)/', $filePath, $matches)) {
+                $documentPath = $matches[1];
+                $documentInsideZipPath = $matches[2];
+                $realFilePath = 'zip://' . realpath($documentPath) . '#' . $documentInsideZipPath;
+            }
+        } else {
+            $realFilePath = realpath($filePath);
+        }
+
+        return $realFilePath;
+    }
+
+    /**
+     * Returns whether the given path is a zip stream.
+     *
+     * @param string $path Path pointing to a document
+     * @return bool TRUE if path is a zip stream, FALSE otherwise
+     */
+    protected function isZipStream($path)
+    {
+        return (strpos($path, 'zip://') === 0);
+    }
+
+    /**
+     * Wrapper around global function feof()
+     * @see feof()
+     *
+     * @param resource
+     * @return bool
+     */
+    public function feof($handle)
+    {
+        return feof($handle);
+    }
+
+    /**
+     * Wrapper around global function is_readable()
+     * @see is_readable()
+     *
+     * @param string $fileName
+     * @return bool
+     */
+    public function is_readable($fileName)
+    {
+        return is_readable($fileName);
+    }
+
+    /**
+     * Wrapper around global function basename()
+     * @see basename()
+     *
+     * @param string $path
+     * @param string|void $suffix
+     * @return string
+     */
+    public function basename($path, $suffix = null)
+    {
+        return basename($path, $suffix);
+    }
+
+    /**
+     * Wrapper around global function header()
+     * @see header()
+     *
+     * @param string $string
+     * @return void
+     */
+    public function header($string)
+    {
+        header($string);
+    }
+
+    /**
+     * Wrapper around global function ob_end_clean()
+     * @see ob_end_clean()
+     *
+     * @return void
+     */
+    public function ob_end_clean()
+    {
+        if (ob_get_length() > 0) {
+            ob_end_clean();
+        }
+    }
+
+    /**
+     * Wrapper around global function iconv()
+     * @see iconv()
+     *
+     * @param string $string The string to be converted
+     * @param string $sourceEncoding The encoding of the source string
+     * @param string $targetEncoding The encoding the source string should be converted to
+     * @return string|bool the converted string or FALSE on failure.
+     */
+    public function iconv($string, $sourceEncoding, $targetEncoding)
+    {
+        return iconv($sourceEncoding, $targetEncoding, $string);
+    }
+
+    /**
+     * Wrapper around global function mb_convert_encoding()
+     * @see mb_convert_encoding()
+     *
+     * @param string $string The string to be converted
+     * @param string $sourceEncoding The encoding of the source string
+     * @param string $targetEncoding The encoding the source string should be converted to
+     * @return string|bool the converted string or FALSE on failure.
+     */
+    public function mb_convert_encoding($string, $sourceEncoding, $targetEncoding)
+    {
+        return mb_convert_encoding($string, $targetEncoding, $sourceEncoding);
+    }
+
+    /**
+     * Wrapper around global function stream_get_wrappers()
+     * @see stream_get_wrappers()
+     *
+     * @return array
+     */
+    public function stream_get_wrappers()
+    {
+        return stream_get_wrappers();
+    }
+
+    /**
+     * Wrapper around global function function_exists()
+     * @see function_exists()
+     *
+     * @param string $functionName
+     * @return bool
+     */
+    public function function_exists($functionName)
+    {
+        return function_exists($functionName);
+    }
+}

modules/x13import/tools/Spout/Common/Helper/StringHelper.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace Box\Spout\Common\Helper;
+
+/**
+ * Class StringHelper
+ * This class provides helper functions to work with strings and multibyte strings.
+ *
+ * @codeCoverageIgnore
+ *
+ * @package Box\Spout\Common\Helper
+ */
+class StringHelper
+{
+    /** @var bool Whether the mbstring extension is loaded */
+    protected $hasMbstringSupport;
+
+    /**
+     *
+     */
+    public function __construct()
+    {
+        $this->hasMbstringSupport = extension_loaded('mbstring');
+    }
+
+    /**
+     * Returns the length of the given string.
+     * It uses the multi-bytes function is available.
+     * @see strlen
+     * @see mb_strlen
+     *
+     * @param string $string
+     * @return int
+     */
+    public function getStringLength($string)
+    {
+        return $this->hasMbstringSupport ? mb_strlen($string) : strlen($string);
+    }
+
+    /**
+     * Returns the position of the first occurrence of the given character/substring within the given string.
+     * It uses the multi-bytes function is available.
+     * @see strpos
+     * @see mb_strpos
+     *
+     * @param string $char Needle
+     * @param string $string Haystack
+     * @return int Char/substring's first occurrence position within the string if found (starts at 0) or -1 if not found
+     */
+    public function getCharFirstOccurrencePosition($char, $string)
+    {
+        $position = $this->hasMbstringSupport ? mb_strpos($string, $char) : strpos($string, $char);
+        return ($position !== false) ? $position : -1;
+    }
+
+    /**
+     * Returns the position of the last occurrence of the given character/substring within the given string.
+     * It uses the multi-bytes function is available.
+     * @see strrpos
+     * @see mb_strrpos
+     *
+     * @param string $char Needle
+     * @param string $string Haystack
+     * @return int Char/substring's last occurrence position within the string if found (starts at 0) or -1 if not found
+     */
+    public function getCharLastOccurrencePosition($char, $string)
+    {
+        $position = $this->hasMbstringSupport ? mb_strrpos($string, $char) : strrpos($string, $char);
+        return ($position !== false) ? $position : -1;
+    }
+}

modules/x13import/tools/Spout/Common/Singleton.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Box\Spout\Common;
+
+/**
+ * Class Singleton
+ * Defines a class as a singleton.
+ *
+ * @package Box\Spout\Common
+ */
+trait Singleton
+{
+    protected static $instance;
+
+    /**
+     * @return static
+     */
+    final public static function getInstance()
+    {
+        return isset(static::$instance)
+            ? static::$instance
+            : static::$instance = new static;
+    }
+
+    /**
+     * Singleton constructor.
+     */
+    final private function __construct()
+    {
+        $this->init();
+    }
+
+    /**
+     * Initializes the singleton
+     * @return void
+     */
+    protected function init() {}
+
+    final private function __wakeup() {}
+    final private function __clone() {}
+}

modules/x13import/tools/Spout/Common/Type.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Box\Spout\Common;
+
+/**
+ * Class Type
+ * This class references the supported types
+ *
+ * @api
+ */
+abstract class Type
+{
+    const CSV = 'csv';
+    const XLSX = 'xlsx';
+    const ODS = 'ods';
+}