Updates to 3rd party libraries

Add Dockerfile and specific docker-php.ini

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/AbstractFunctional.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\IOFactory;
+use PhpOffice\PhpSpreadsheet\Shared\File;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Base class for functional test to write and reload file on disk across different formats.
+ */
+abstract class AbstractFunctional extends TestCase
+{
+    /**
+     * Write spreadsheet to disk, reload and return it.
+     *
+     * @param Spreadsheet $spreadsheet
+     * @param string $format
+     * @param null|callable $readerCustomizer
+     *
+     * @return Spreadsheet
+     */
+    protected function writeAndReload(Spreadsheet $spreadsheet, $format, callable $readerCustomizer = null)
+    {
+        $filename = tempnam(File::sysGetTempDir(), 'phpspreadsheet-test');
+        $writer = IOFactory::createWriter($spreadsheet, $format);
+        $writer->save($filename);
+
+        $reader = IOFactory::createReader($format);
+        if ($readerCustomizer) {
+            $readerCustomizer($reader);
+        }
+        $reloadedSpreadsheet = $reader->load($filename);
+        unlink($filename);
+
+        return $reloadedSpreadsheet;
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/ColumnWidthTest.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class ColumnWidthTest extends AbstractFunctional
+{
+    public function providerFormats()
+    {
+        return [
+            ['Xlsx'],
+        ];
+    }
+
+    /**
+     * @dataProvider providerFormats
+     *
+     * @param $format
+     */
+    public function testReadColumnWidth($format)
+    {
+        // create new sheet with column width
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A1', 'Hello World !');
+        $sheet->getColumnDimension('A')->setWidth(20);
+        $this->assertColumn($spreadsheet);
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format);
+        $this->assertColumn($reloadedSpreadsheet);
+    }
+
+    private function assertColumn(Spreadsheet $spreadsheet)
+    {
+        $sheet = $spreadsheet->getActiveSheet();
+        $columnDimensions = $sheet->getColumnDimensions();
+
+        self::assertArrayHasKey('A', $columnDimensions);
+        $column = array_shift($columnDimensions);
+        self::assertEquals(20, $column->getWidth());
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/CommentsTest.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class CommentsTest extends AbstractFunctional
+{
+    public function providerFormats()
+    {
+        return [
+            ['Html'],
+            ['Xlsx'],
+            ['Ods'],
+        ];
+    }
+
+    /**
+     * Test load file with comment in sheet to load proper
+     * count of comments in correct coords.
+     *
+     * @dataProvider providerFormats
+     *
+     * @param $format
+     */
+    public function testComments($format)
+    {
+        $spreadsheet = new Spreadsheet();
+
+        $spreadsheet->getActiveSheet()->getCell('E10')->setValue('Comment');
+        $spreadsheet->getActiveSheet()
+            ->getComment('E10')
+            ->getText()
+            ->createText('Comment to test');
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format);
+
+        $commentsLoaded = $reloadedSpreadsheet->getSheet(0)->getComments();
+        self::assertCount(1, $commentsLoaded);
+
+        $commentCoordinate = key($commentsLoaded);
+        self::assertSame('E10', $commentCoordinate);
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/ConditionalStopIfTrueTest.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class ConditionalStopIfTrueTest extends AbstractFunctional
+{
+    const COLOR_GREEN = 'FF99FF66';
+    const COLOR_RED = 'FFFF5050';
+
+    public function providerFormats()
+    {
+        return [
+            ['Xlsx'],
+        ];
+    }
+
+    /**
+     * @dataProvider providerFormats
+     *
+     * @param string $format
+     */
+    public function testConditionalStopIfTrue($format)
+    {
+        $pCoordinate = 'A1:A3';
+
+        // if blank cell -> no styling
+        $condition0 = new \PhpOffice\PhpSpreadsheet\Style\Conditional();
+        $condition0->setConditionType(\PhpOffice\PhpSpreadsheet\Style\Conditional::CONDITION_EXPRESSION);
+        $condition0->addCondition('LEN(TRIM(A1))=0');
+        $condition0->setStopIfTrue(true); // ! stop here
+
+        // if value below 0.6 (matches also blank cells!) -> red background
+        $condition1 = new \PhpOffice\PhpSpreadsheet\Style\Conditional();
+        $condition1->setConditionType(\PhpOffice\PhpSpreadsheet\Style\Conditional::CONDITION_CELLIS);
+        $condition1->setOperatorType(\PhpOffice\PhpSpreadsheet\Style\Conditional::OPERATOR_LESSTHAN);
+        $condition1->addCondition(0.6);
+        $condition1->getStyle()->getFill()
+            ->setFillType(\PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID)
+            ->getEndColor()->setARGB(self::COLOR_RED);
+
+        // if value above 0.6 -> green background
+        $condition2 = new \PhpOffice\PhpSpreadsheet\Style\Conditional();
+        $condition2->setConditionType(\PhpOffice\PhpSpreadsheet\Style\Conditional::CONDITION_CELLIS);
+        $condition2->setOperatorType(\PhpOffice\PhpSpreadsheet\Style\Conditional::OPERATOR_GREATERTHAN);
+        $condition2->addCondition(0.6);
+        $condition2->getStyle()->getFill()
+            ->setFillType(\PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID)
+            ->getEndColor()->setARGB(self::COLOR_GREEN);
+
+        $spreadsheet = new Spreadsheet();
+        $spreadsheet->getActiveSheet()->getCell('A1')->setValue(0.7);
+        $spreadsheet->getActiveSheet()->getCell('A2')->setValue('');
+        $spreadsheet->getActiveSheet()->getCell('A3')->setValue(0.4);
+
+        // put all three conditions in sheet
+        $conditionalStyles = [];
+        array_push($conditionalStyles, $condition0);
+        array_push($conditionalStyles, $condition1);
+        array_push($conditionalStyles, $condition2);
+        $spreadsheet->getActiveSheet()->setConditionalStyles($pCoordinate, $conditionalStyles);
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format);
+
+        // see if we successfully written "StopIfTrue"
+        $newConditionalStyles = $reloadedSpreadsheet->getActiveSheet()->getConditionalStyles($pCoordinate);
+        self::assertTrue($newConditionalStyles[0]->getStopIfTrue(), 'StopIfTrue should be set (=true) on first condition');
+        self::assertFalse($newConditionalStyles[1]->getStopIfTrue(), 'StopIfTrue should not be set (=false) on second condition');
+        self::assertFalse($newConditionalStyles[2]->getStopIfTrue(), 'StopIfTrue should not be set (=false) on third condition');
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/DrawingImageHyperlinkTest.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Cell\Hyperlink;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Worksheet\MemoryDrawing;
+
+class DrawingImageHyperlinkTest extends AbstractFunctional
+{
+    public function testDrawingImageHyperlinkTest()
+    {
+        $baseUrl = 'https://github.com/PHPOffice/PhpSpreadsheet';
+        $spreadsheet = new Spreadsheet();
+
+        $aSheet = $spreadsheet->getActiveSheet();
+
+        $gdImage = @imagecreatetruecolor(120, 20);
+        $textColor = imagecolorallocate($gdImage, 255, 255, 255);
+        imagestring($gdImage, 1, 5, 5, 'Created with PhpSpreadsheet', $textColor);
+
+        $drawing = new MemoryDrawing();
+        $drawing->setName('In-Memory image 1');
+        $drawing->setDescription('In-Memory image 1');
+        $drawing->setCoordinates('A1');
+        $drawing->setImageResource($gdImage);
+        $drawing->setRenderingFunction(
+            MemoryDrawing::RENDERING_JPEG
+        );
+        $drawing->setMimeType(MemoryDrawing::MIMETYPE_DEFAULT);
+        $drawing->setHeight(36);
+        $hyperLink = new Hyperlink($baseUrl, 'test image');
+        $drawing->setHyperlink($hyperLink);
+        $drawing->setWorksheet($aSheet);
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, 'Xlsx');
+
+        foreach ($reloadedSpreadsheet->getActiveSheet()->getDrawingCollection() as $pDrawing) {
+            self::assertEquals('https://github.com/PHPOffice/PhpSpreadsheet', $pDrawing->getHyperlink()->getUrl(), 'functional test drawing hyperlink');
+        }
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/EnclosureTest.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class EnclosureTest extends AbstractFunctional
+{
+    public function providerFormats()
+    {
+        return [
+            ['Html'],
+            ['Xls'],
+            ['Xlsx'],
+            ['Ods'],
+            ['Csv'],
+        ];
+    }
+
+    /**
+     * @dataProvider providerFormats
+     *
+     * @param string $format
+     */
+    public function testEnclosure($format)
+    {
+        $value = '<img alt="" src="http://example.com/image.jpg" />';
+
+        $spreadsheet = new Spreadsheet();
+        $spreadsheet->getActiveSheet()->getCell('A1')->setValue($value);
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format);
+
+        $actual = $reloadedSpreadsheet->getActiveSheet()->getCell('A1')->getCalculatedValue();
+        self::assertSame($value, $actual, 'should be able to write and read strings with multiples quotes');
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/FreezePaneTest.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class FreezePaneTest extends AbstractFunctional
+{
+    public function providerFormats()
+    {
+        return [
+            ['Xls'],
+            ['Xlsx'],
+        ];
+    }
+
+    /**
+     * @dataProvider providerFormats
+     *
+     * @param string $format
+     */
+    public function testFreezePane($format)
+    {
+        $cellSplit = 'B4';
+        $topLeftCell = 'E7';
+
+        $spreadsheet = new Spreadsheet();
+        $spreadsheet->getActiveSheet()->freezePane($cellSplit, $topLeftCell);
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format);
+
+        // Read written file
+        $reloadedActive = $reloadedSpreadsheet->getActiveSheet();
+        $actualCellSplit = $reloadedActive->getFreezePane();
+        $actualTopLeftCell = $reloadedActive->getTopLeftCell();
+
+        self::assertSame($cellSplit, $actualCellSplit, 'should be able to set freeze pane');
+        self::assertSame($topLeftCell, $actualTopLeftCell, 'should be able to set the top left cell');
+    }
+
+    public function providerFormatsInvalidSelectedCells()
+    {
+        return [
+            ['Xlsx'],
+        ];
+    }
+
+    /**
+     * @dataProvider providerFormatsInvalidSelectedCells
+     *
+     * @param string $format
+     */
+    public function testFreezePaneWithInvalidSelectedCells($format)
+    {
+        $cellSplit = 'A7';
+        $topLeftCell = 'A24';
+
+        $spreadsheet = new Spreadsheet();
+        $worksheet = $spreadsheet->getActiveSheet();
+
+        $worksheet->freezePane('A7', 'A24');
+        $worksheet->setSelectedCells('F5');
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format);
+
+        // Read written file
+        $reloadedActive = $reloadedSpreadsheet->getActiveSheet();
+        $actualCellSplit = $reloadedActive->getFreezePane();
+        $actualTopLeftCell = $reloadedActive->getTopLeftCell();
+
+        self::assertSame($cellSplit, $actualCellSplit, 'should be able to set freeze pane');
+        self::assertSame($topLeftCell, $actualTopLeftCell, 'should be able to set the top left cell');
+        self::assertSame('A24', $reloadedActive->getSelectedCells(), 'selected cell should default to be first cell after the freeze pane');
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/HtmlCommentsTest.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\RichText\RichText;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class HtmlCommentsTest extends AbstractFunctional
+{
+    private $spreadsheet;
+
+    public function providerCommentRichText()
+    {
+        $valueSingle = 'I am comment.';
+        $valueMulti = 'I am ' . PHP_EOL . 'multi-line' . PHP_EOL . 'comment.';
+
+        $plainSingle = new RichText();
+        $plainSingle->createText($valueSingle);
+
+        $plainMulti = new RichText();
+        $plainMulti->createText($valueMulti);
+
+        $richSingle = new RichText();
+        $richSingle->createTextRun($valueSingle)->getFont()->setBold(true);
+
+        $richMultiSimple = new RichText();
+        $richMultiSimple->createTextRun($valueMulti)->getFont()->setBold(true);
+
+        $richMultiMixed = new RichText();
+        $richMultiMixed->createText('I am' . PHP_EOL);
+        $richMultiMixed->createTextRun('multi-line')->getFont()->setBold(true);
+        $richMultiMixed->createText(PHP_EOL . 'comment!');
+
+        return [
+            'single line plain text' => [$plainSingle],
+            'multi-line plain text' => [$plainMulti],
+            'single line simple rich text' => [$richSingle],
+            'multi-line simple rich text' => [$richMultiSimple],
+            'multi-line mixed rich text' => [$richMultiMixed],
+        ];
+    }
+
+    /**
+     * @dataProvider providerCommentRichText
+     *
+     * @param mixed $richText
+     */
+    public function testComments($richText)
+    {
+        $this->spreadsheet = new Spreadsheet();
+
+        $this->spreadsheet->getActiveSheet()->getCell('A1')->setValue('Comment');
+
+        $this->spreadsheet->getActiveSheet()
+            ->getComment('A1')
+            ->setText($richText);
+
+        $reloadedSpreadsheet = $this->writeAndReload($this->spreadsheet, 'Html');
+
+        $actual = $reloadedSpreadsheet->getActiveSheet()->getComment('A1')->getText()->getPlainText();
+        self::assertSame($richText->getPlainText(), $actual);
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/MergedCellsTest.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class MergedCellsTest extends AbstractFunctional
+{
+    public function providerFormats()
+    {
+        return [
+            ['Html'],
+            ['Xls'],
+            ['Xlsx'],
+            ['Ods'],
+        ];
+    }
+
+    /**
+     * @dataProvider providerFormats
+     *
+     * @param string $format
+     */
+    public function testMergedCells($format)
+    {
+        $spreadsheet = new Spreadsheet();
+        $spreadsheet->setActiveSheetIndex(0);
+        $spreadsheet->getActiveSheet()->setCellValue('A1', '1');
+        $spreadsheet->getActiveSheet()->setCellValue('B1', '2');
+        $spreadsheet->getActiveSheet()->setCellValue('A2', '33');
+        $spreadsheet->getActiveSheet()->mergeCells('A2:B2');
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format);
+
+        $actual = 0;
+        foreach ($reloadedSpreadsheet->getWorksheetIterator() as $worksheet) {
+            $actual += count($worksheet->getMergeCells());
+        }
+
+        self::assertSame(1, $actual, "Format $format failed, could not read 1 merged cell");
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/PrintAreaTest.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Reader\BaseReader;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class PrintAreaTest extends AbstractFunctional
+{
+    public function providerFormats()
+    {
+        return [
+            ['Xls'],
+            ['Xlsx'],
+        ];
+    }
+
+    /**
+     * @dataProvider providerFormats
+     *
+     * @param string $format
+     */
+    public function testPageSetup($format)
+    {
+        // Create new workbook with 3 sheets and different print areas
+        $spreadsheet = new Spreadsheet();
+        $worksheet1 = $spreadsheet->getActiveSheet()->setTitle('Sheet 1');
+        $worksheet1->getPageSetup()->setPrintArea('A1:B1');
+
+        for ($i = 2; $i < 4; ++$i) {
+            $sheet = $spreadsheet->createSheet()->setTitle("Sheet $i");
+            $sheet->getPageSetup()->setPrintArea("A$i:B$i");
+        }
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format, function (BaseReader $reader) {
+            $reader->setLoadSheetsOnly(['Sheet 1', 'Sheet 3']);
+        });
+
+        $actual1 = $reloadedSpreadsheet->getSheetByName('Sheet 1')->getPageSetup()->getPrintArea();
+        $actual3 = $reloadedSpreadsheet->getSheetByName('Sheet 3')->getPageSetup()->getPrintArea();
+        self::assertSame('A1:B1', $actual1, 'should be able to write and read normal page setup');
+        self::assertSame('A3:B3', $actual3, 'should be able to write and read page setup even when skipping sheets');
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/ReadFilterTest.php

@@ -0,0 +1,124 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Reader\IReadFilter;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class ReadFilterTest extends AbstractFunctional
+{
+    public function providerCellsValues()
+    {
+        $cellValues = [
+            // one argument as a multidimensional array
+            [1, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+            [2, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+            [3, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+            [4, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+            [5, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+            [6, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+            [7, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+            [8, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+            [9, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+            [10, 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
+        ];
+
+        return [
+            ['Xlsx', $cellValues],
+            ['Ods', $cellValues],
+        ];
+    }
+
+    /**
+     * Test load Xlsx file with many empty cells with no filter used.
+     *
+     * @dataProvider providerCellsValues
+     *
+     * @param  array $arrayData
+     * @param mixed $format
+     */
+    public function testXlsxLoadWithoutReadFilter($format, array $arrayData)
+    {
+        $spreadsheet = new Spreadsheet();
+
+        $spreadsheet->getActiveSheet()->fromArray($arrayData, null, 'A1');
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format);
+        $sheet = $reloadedSpreadsheet->getSheet(0);
+        // test highest column (very specific num of columns because of some 3rd party software)
+        self::assertSame('J', $sheet->getHighestColumn());
+
+        // test highest row (very specific num of rows because of some 3rd party software)
+        self::assertEquals(10, $sheet->getHighestRow());
+
+        // test top left coordinate
+        $sortedCoordinates = $sheet->getCellCollection()->getSortedCoordinates();
+        $coordinateTopLeft = reset($sortedCoordinates);
+        self::assertSame('A1', $coordinateTopLeft);
+    }
+
+    /**
+     * Test load Xlsx file with many empty cells (and big max row number) with readfilter.
+     *
+     * @dataProvider providerCellsValues
+     *
+     * @param array $arrayData
+     * @param mixed $format
+     */
+    public function testXlsxLoadWithReadFilter($format, array $arrayData)
+    {
+        $spreadsheet = new Spreadsheet();
+        $spreadsheet->getActiveSheet()->fromArray($arrayData, null, 'A1');
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format, function ($reader) {
+            // Create a stub for the readFilter class.
+            $readFilterStub = $this->createMock(IReadFilter::class);
+            $readFilterStub->method('readCell')
+                ->will($this->returnCallback([$this, 'readFilterReadCell']));
+            // apply filter
+            $reader->setReadFilter($readFilterStub);
+        });
+        $sheet = $reloadedSpreadsheet->getSheet(0);
+        // test highest column (very specific num of columns because of some 3rd party software)
+        self::assertSame('D', $sheet->getHighestColumn());
+
+        // test highest row (very specific num of rows because of some 3rd party software)
+        self::assertEquals(6, $sheet->getHighestRow());
+
+        // test top left coordinate
+        $sortedCoordinates = $sheet->getCellCollection()->getSortedCoordinates();
+        $coordinateTopLeft = reset($sortedCoordinates);
+        self::assertSame('B2', $coordinateTopLeft);
+    }
+
+    /**
+     * @see \PhpOffice\PhpSpreadsheet\Reader\IReadFilter::readCell()
+     *
+     * @param string $column Column address (as a string value like "A", or "IV")
+     * @param int $row Row number
+     * @param string $worksheetName Optional worksheet name
+     *
+     * @return bool
+     */
+    public function readFilterReadCell($column, $row, $worksheetName = '')
+    {
+        // define filter range
+        $rowMin = 2;
+        $rowMax = 6;
+        $columnMin = 'B';
+        $columnMax = 'D';
+
+        $r = (int) $row;
+        if ($r > $rowMax || $r < $rowMin) {
+            return false;
+        }
+
+        $col = sprintf('%04s', $column);
+        if ($col > sprintf('%04s', $columnMax) ||
+            $col < sprintf('%04s', $columnMin)) {
+            return false;
+        }
+
+        return true;
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/TypeAttributePreservationTest.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class TypeAttributePreservationTest extends AbstractFunctional
+{
+    public function providerFormulae()
+    {
+        $formats = ['Xlsx'];
+        $data = require 'data/Functional/TypeAttributePreservation/Formula.php';
+
+        $result = [];
+        foreach ($formats as $f) {
+            foreach ($data as $d) {
+                $result[] = [$f, $d];
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Ensure saved spreadsheets maintain the correct data type.
+     *
+     * @dataProvider providerFormulae
+     *
+     * @param string $format
+     * @param array $values
+     */
+    public function testFormulae($format, array $values)
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->fromArray($values);
+
+        $reloadedSpreadsheet = $this->writeAndReload($spreadsheet, $format);
+        $reloadedSheet = $reloadedSpreadsheet->getActiveSheet();
+
+        $expected = $sheet->getCell('A1')->getCalculatedValue();
+
+        if ($sheet->getCell('A1')->getDataType() === 'f') {
+            $actual = $reloadedSheet->getCell('A1')->getOldCalculatedValue();
+        } else {
+            $actual = $reloadedSheet->getCell('A1')->getValue();
+        }
+
+        self::assertSame($expected, $actual);
+    }
+}

inc/vendor/phpoffice/phpspreadsheet/tests/PhpSpreadsheetTests/Functional/WorkbookViewAttributesTest.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Functional;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class WorkbookViewAttributesTest extends AbstractFunctional
+{
+    public function providerFormats()
+    {
+        return [
+            ['Xlsx'],
+        ];
+    }
+
+    /**
+     * Test that workbook bookview attributes such as 'showSheetTabs',
+     * (the attribute controlling worksheet tabs visibility,)
+     * are preserved when xlsx documents are read and written.
+     *
+     * @see https://github.com/PHPOffice/PhpSpreadsheet/issues/523
+     *
+     * @dataProvider providerFormats
+     *
+     * @param string $format
+     */
+    public function testPreserveWorkbookViewAttributes($format)
+    {
+        // Create a dummy workbook with two worksheets
+        $workbook = new Spreadsheet();
+        $worksheet1 = $workbook->getActiveSheet();
+        $worksheet1->setTitle('Tweedledee');
+        $worksheet1->setCellValue('A1', 1);
+        $worksheet2 = $workbook->createSheet();
+        $worksheet2->setTitle('Tweeldedum');
+        $worksheet2->setCellValue('A1', 2);
+
+        // Check that the bookview attributes return default values
+        $this->assertTrue($workbook->getShowHorizontalScroll());
+        $this->assertTrue($workbook->getShowVerticalScroll());
+        $this->assertTrue($workbook->getShowSheetTabs());
+        $this->assertTrue($workbook->getAutoFilterDateGrouping());
+        $this->assertFalse($workbook->getMinimized());
+        $this->assertSame(0, $workbook->getFirstSheetIndex());
+        $this->assertSame(600, $workbook->getTabRatio());
+        $this->assertSame(Spreadsheet::VISIBILITY_VISIBLE, $workbook->getVisibility());
+
+        // Set the bookview attributes to non-default values
+        $workbook->setShowHorizontalScroll(false);
+        $workbook->setShowVerticalScroll(false);
+        $workbook->setShowSheetTabs(false);
+        $workbook->setAutoFilterDateGrouping(false);
+        $workbook->setMinimized(true);
+        $workbook->setFirstSheetIndex(1);
+        $workbook->setTabRatio(700);
+        $workbook->setVisibility(Spreadsheet::VISIBILITY_HIDDEN);
+
+        // Check that bookview attributes were set properly
+        $this->assertFalse($workbook->getShowHorizontalScroll());
+        $this->assertFalse($workbook->getShowVerticalScroll());
+        $this->assertFalse($workbook->getShowSheetTabs());
+        $this->assertFalse($workbook->getAutoFilterDateGrouping());
+        $this->assertTrue($workbook->getMinimized());
+        $this->assertSame(1, $workbook->getFirstSheetIndex());
+        $this->assertSame(700, $workbook->getTabRatio());
+        $this->assertSame(Spreadsheet::VISIBILITY_HIDDEN, $workbook->getVisibility());
+
+        $workbook2 = $this->writeAndReload($workbook, $format);
+
+        // Check that the read spreadsheet has the right bookview attributes
+        $this->assertFalse($workbook2->getShowHorizontalScroll());
+        $this->assertFalse($workbook2->getShowVerticalScroll());
+        $this->assertFalse($workbook2->getShowSheetTabs());
+        $this->assertFalse($workbook2->getAutoFilterDateGrouping());
+        $this->assertTrue($workbook2->getMinimized());
+        $this->assertSame(1, $workbook2->getFirstSheetIndex());
+        $this->assertSame(700, $workbook2->getTabRatio());
+        $this->assertSame(Spreadsheet::VISIBILITY_HIDDEN, $workbook2->getVisibility());
+    }
+}