Clientbase
/
PhpSpreadsheet
mirror of https://github.com/basemaster/PhpSpreadsheet.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into Issue-2551-Array-Ready-Function-Financial

This commit is contained in:
Mark Baker 2022-02-11 19:07:33 +01:00 committed by GitHub
parent c41dd0afae ad5532e2f4
commit d2473441c3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 318 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/PhpSpreadsheet/Reader/Xlsx.php
View File

@ -539,16 +539,14 @@ class Xlsx extends BaseReader
if ($xpath === null) {
$xmlStyles = self::testSimpleXml(null);
} else {
// I think Nonamespace is okay because I'm using xpath.
$xmlStyles = $this->loadZipNonamespace("$dir/$xpath[Target]", $mainNS);
$xmlStyles = $this->loadZip("$dir/$xpath[Target]", $mainNS);
}
$xmlStyles->registerXPathNamespace('smm', Namespaces::MAIN);
$fills = self::xpathNoFalse($xmlStyles, 'smm:fills/smm:fill');
$fonts = self::xpathNoFalse($xmlStyles, 'smm:fonts/smm:font');
$borders = self::xpathNoFalse($xmlStyles, 'smm:borders/smm:border');
$xfTags = self::xpathNoFalse($xmlStyles, 'smm:cellXfs/smm:xf');
$cellXfTags = self::xpathNoFalse($xmlStyles, 'smm:cellStyleXfs/smm:xf');
$fills = self::extractStyles($xmlStyles, 'fills', 'fill');
$fonts = self::extractStyles($xmlStyles, 'fonts', 'font');
$borders = self::extractStyles($xmlStyles, 'borders', 'border');
$xfTags = self::extractStyles($xmlStyles, 'cellXfs', 'xf');
$cellXfTags = self::extractStyles($xmlStyles, 'cellStyleXfs', 'xf');
$styles = [];
$cellStyles = [];
@ -559,6 +557,7 @@ class Xlsx extends BaseReader
if (isset($numFmts) && ($numFmts !== null)) {
$numFmts->registerXPathNamespace('sml', $mainNS);
}
$this->styleReader->setNamespace($mainNS);
if (!$this->readDataOnly/* && $xmlStyles*/) {
foreach ($xfTags as $xfTag) {
$xf = self::getAttributes($xfTag);
@ -643,6 +642,7 @@ class Xlsx extends BaseReader
}
}
$this->styleReader->setStyleXml($xmlStyles);
$this->styleReader->setNamespace($mainNS);
$this->styleReader->setStyleBaseData($theme, $styles, $cellStyles);
$dxfs = $this->styleReader->dxfs($this->readDataOnly);
$styles = $this->styleReader->styles();
@ -2088,4 +2088,16 @@ class Xlsx extends BaseReader
}
}
}
private static function extractStyles(?SimpleXMLElement $sxml, string $node1, string $node2): array
{
$array = [];
if ($sxml && $sxml->{$node1}->{$node2}) {
foreach ($sxml->{$node1}->{$node2} as $node) {
$array[] = $node;
}
}
return $array;
}
}

224
src/PhpSpreadsheet/Reader/Xlsx/Styles.php
View File

@ -33,6 +33,37 @@ class Styles extends BaseParserClass
/** @var SimpleXMLElement */
private $styleXml;
/** @var string */
private $namespace = '';
public function setNamespace(string $namespace): void
{
$this->namespace = $namespace;
}
/**
* Cast SimpleXMLElement to bool to overcome Scrutinizer problem.
*
* @param mixed $value
*/
private static function castBool($value): bool
{
return (bool) $value;
}
private function getStyleAttributes(SimpleXMLElement $value): SimpleXMLElement
{
$attr = null;
if (self::castBool($value)) {
$attr = $value->attributes('');
if ($attr === null || count($attr) === 0) {
$attr = $value->attributes($this->namespace);
}
}
return Xlsx::testSimpleXml($attr);
}
public function setStyleXml(SimpleXmlElement $styleXml): void
{
$this->styleXml = $styleXml;
@ -52,48 +83,62 @@ class Styles extends BaseParserClass
public function readFontStyle(Font $fontStyle, SimpleXMLElement $fontStyleXml): void
{
if (isset($fontStyleXml->name, $fontStyleXml->name['val'])) {
$fontStyle->setName((string) $fontStyleXml->name['val']);
if (isset($fontStyleXml->name)) {
$attr = $this->getStyleAttributes($fontStyleXml->name);
if (isset($attr['val'])) {
$fontStyle->setName((string) $attr['val']);
}
}
if (isset($fontStyleXml->sz, $fontStyleXml->sz['val'])) {
$fontStyle->setSize((float) $fontStyleXml->sz['val']);
if (isset($fontStyleXml->sz)) {
$attr = $this->getStyleAttributes($fontStyleXml->sz);
if (isset($attr['val'])) {
$fontStyle->setSize((float) $attr['val']);
}
}
if (isset($fontStyleXml->b)) {
$fontStyle->setBold(!isset($fontStyleXml->b['val']) || self::boolean((string) $fontStyleXml->b['val']));
$attr = $this->getStyleAttributes($fontStyleXml->b);
$fontStyle->setBold(!isset($attr['val']) || self::boolean((string) $attr['val']));
}
if (isset($fontStyleXml->i)) {
$fontStyle->setItalic(!isset($fontStyleXml->i['val']) || self::boolean((string) $fontStyleXml->i['val']));
$attr = $this->getStyleAttributes($fontStyleXml->i);
$fontStyle->setItalic(!isset($attr['val']) || self::boolean((string) $attr['val']));
}
if (isset($fontStyleXml->strike)) {
$fontStyle->setStrikethrough(
!isset($fontStyleXml->strike['val']) || self::boolean((string) $fontStyleXml->strike['val'])
);
$attr = $this->getStyleAttributes($fontStyleXml->strike);
$fontStyle->setStrikethrough(!isset($attr['val']) || self::boolean((string) $attr['val']));
}
$fontStyle->getColor()->setARGB($this->readColor($fontStyleXml->color));
if (isset($fontStyleXml->u) && !isset($fontStyleXml->u['val'])) {
$fontStyle->setUnderline(Font::UNDERLINE_SINGLE);
} elseif (isset($fontStyleXml->u, $fontStyleXml->u['val'])) {
$fontStyle->setUnderline((string) $fontStyleXml->u['val']);
if (isset($fontStyleXml->u)) {
$attr = $this->getStyleAttributes($fontStyleXml->u);
if (!isset($attr['val'])) {
$fontStyle->setUnderline(Font::UNDERLINE_SINGLE);
} else {
$fontStyle->setUnderline((string) $attr['val']);
}
}
if (isset($fontStyleXml->vertAlign, $fontStyleXml->vertAlign['val'])) {
$verticalAlign = strtolower((string) $fontStyleXml->vertAlign['val']);
if ($verticalAlign === 'superscript') {
$fontStyle->setSuperscript(true);
} elseif ($verticalAlign === 'subscript') {
$fontStyle->setSubscript(true);
if (isset($fontStyleXml->vertAlign)) {
$attr = $this->getStyleAttributes($fontStyleXml->vertAlign);
if (!isset($attr['val'])) {
$verticalAlign = strtolower((string) $attr['val']);
if ($verticalAlign === 'superscript') {
$fontStyle->setSuperscript(true);
} elseif ($verticalAlign === 'subscript') {
$fontStyle->setSubscript(true);
}
}
}
}
private function readNumberFormat(NumberFormat $numfmtStyle, SimpleXMLElement $numfmtStyleXml): void
{
if ($numfmtStyleXml->count() === 0) {
if ((string) $numfmtStyleXml['formatCode'] !== '') {
$numfmtStyle->setFormatCode(self::formatGeneral((string) $numfmtStyleXml['formatCode']));
return;
}
$numfmt = Xlsx::getAttributes($numfmtStyleXml);
if ($numfmt->count() > 0 && isset($numfmt['formatCode'])) {
$numfmt = $this->getStyleAttributes($numfmtStyleXml);
if (isset($numfmt['formatCode'])) {
$numfmtStyle->setFormatCode(self::formatGeneral((string) $numfmt['formatCode']));
}
}
@ -103,10 +148,11 @@ class Styles extends BaseParserClass
if ($fillStyleXml->gradientFill) {
/** @var SimpleXMLElement $gradientFill */
$gradientFill = $fillStyleXml->gradientFill[0];
if (!empty($gradientFill['type'])) {
$fillStyle->setFillType((string) $gradientFill['type']);
$attr = $this->getStyleAttributes($gradientFill);
if (!empty($attr['type'])) {
$fillStyle->setFillType((string) $attr['type']);
}
$fillStyle->setRotation((float) ($gradientFill['degree']));
$fillStyle->setRotation((float) ($attr['degree']));
$gradientFill->registerXPathNamespace('sml', Namespaces::MAIN);
$fillStyle->getStartColor()->setARGB($this->readColor(self::getArrayItem($gradientFill->xpath('sml:stop[@position=0]'))->color));
$fillStyle->getEndColor()->setARGB($this->readColor(self::getArrayItem($gradientFill->xpath('sml:stop[@position=1]'))->color));
@ -121,9 +167,14 @@ class Styles extends BaseParserClass
$defaultFillStyle = Fill::FILL_SOLID;
}
$patternType = (string) $fillStyleXml->patternFill['patternType'] != ''
? (string) $fillStyleXml->patternFill['patternType']
: $defaultFillStyle;
$type = '';
if ((string) $fillStyleXml->patternFill['patternType'] !== '') {
$type = (string) $fillStyleXml->patternFill['patternType'];
} else {
$attr = $this->getStyleAttributes($fillStyleXml->patternFill);
$type = (string) $attr['patternType'];
}
$patternType = ($type === '') ? $defaultFillStyle : $type;
$fillStyle->setFillType($patternType);
}
@ -131,8 +182,10 @@ class Styles extends BaseParserClass
public function readBorderStyle(Borders $borderStyle, SimpleXMLElement $borderStyleXml): void
{
$diagonalUp = self::boolean((string) $borderStyleXml['diagonalUp']);
$diagonalDown = self::boolean((string) $borderStyleXml['diagonalDown']);
$diagonalUp = $this->getAttribute($borderStyleXml, 'diagonalUp');
$diagonalUp = self::boolean($diagonalUp);
$diagonalDown = $this->getAttribute($borderStyleXml, 'diagonalDown');
$diagonalDown = self::boolean($diagonalDown);
if (!$diagonalUp && !$diagonalDown) {
$borderStyle->setDiagonalDirection(Borders::DIAGONAL_NONE);
} elseif ($diagonalUp && !$diagonalDown) {
@ -150,10 +203,26 @@ class Styles extends BaseParserClass
$this->readBorder($borderStyle->getDiagonal(), $borderStyleXml->diagonal);
}
private function getAttribute(SimpleXMLElement $xml, string $attribute): string
{
$style = '';
if ((string) $xml[$attribute] !== '') {
$style = (string) $xml[$attribute];
} else {
$attr = $this->getStyleAttributes($xml);
if (isset($attr[$attribute])) {
$style = (string) $attr[$attribute];
}
}
return $style;
}
private function readBorder(Border $border, SimpleXMLElement $borderXml): void
{
if (isset($borderXml['style'])) {
$border->setBorderStyle((string) $borderXml['style']);
$style = $this->getAttribute($borderXml, 'style');
if ($style !== '') {
$border->setBorderStyle((string) $style);
}
if (isset($borderXml->color)) {
$border->getColor()->setARGB($this->readColor($borderXml->color));
@ -162,25 +231,25 @@ class Styles extends BaseParserClass
public function readAlignmentStyle(Alignment $alignment, SimpleXMLElement $alignmentXml): void
{
$alignment->setHorizontal((string) $alignmentXml['horizontal']);
$alignment->setVertical((string) $alignmentXml['vertical']);
$horizontal = $this->getAttribute($alignmentXml, 'horizontal');
$alignment->setHorizontal($horizontal);
$vertical = $this->getAttribute($alignmentXml, 'vertical');
$alignment->setVertical((string) $vertical);
$textRotation = 0;
if ((int) $alignmentXml['textRotation'] <= 90) {
$textRotation = (int) $alignmentXml['textRotation'];
} elseif ((int) $alignmentXml['textRotation'] > 90) {
$textRotation = 90 - (int) $alignmentXml['textRotation'];
$textRotation = (int) $this->getAttribute($alignmentXml, 'textRotation');
if ($textRotation > 90) {
$textRotation = 90 - $textRotation;
}
$alignment->setTextRotation($textRotation);
$alignment->setTextRotation((int) $textRotation);
$alignment->setWrapText(self::boolean((string) $alignmentXml['wrapText']));
$alignment->setShrinkToFit(self::boolean((string) $alignmentXml['shrinkToFit']));
$alignment->setIndent(
(int) ((string) $alignmentXml['indent']) > 0 ? (int) ((string) $alignmentXml['indent']) : 0
);
$alignment->setReadOrder(
(int) ((string) $alignmentXml['readingOrder']) > 0 ? (int) ((string) $alignmentXml['readingOrder']) : 0
);
$wrapText = $this->getAttribute($alignmentXml, 'wrapText');
$alignment->setWrapText(self::boolean((string) $wrapText));
$shrinkToFit = $this->getAttribute($alignmentXml, 'shrinkToFit');
$alignment->setShrinkToFit(self::boolean((string) $shrinkToFit));
$indent = (int) $this->getAttribute($alignmentXml, 'indent');
$alignment->setIndent(max($indent, 0));
$readingOrder = (int) $this->getAttribute($alignmentXml, 'readingOrder');
$alignment->setReadOrder(max($readingOrder, 0));
}
private static function formatGeneral(string $formatString): string
@ -223,8 +292,8 @@ class Styles extends BaseParserClass
// protection
if (isset($style->protection)) {
$this->readProtectionLocked($docStyle, $style);
$this->readProtectionHidden($docStyle, $style);
$this->readProtectionLocked($docStyle, $style->protection);
$this->readProtectionHidden($docStyle, $style->protection);
}
// top-level style settings
@ -235,13 +304,20 @@ class Styles extends BaseParserClass
/**
* Read protection locked attribute.
*
* @param SimpleXMLElement|stdClass $style
*/
public function readProtectionLocked(Style $docStyle, $style): void
public function readProtectionLocked(Style $docStyle, SimpleXMLElement $style): void
{
if (isset($style->protection['locked'])) {
if (self::boolean((string) $style->protection['locked'])) {
$locked = '';
if ((string) $style['locked'] !== '') {
$locked = (string) $style['locked'];
} else {
$attr = $this->getStyleAttributes($style);
if (isset($attr['locked'])) {
$locked = (string) $attr['locked'];
}
}
if ($locked !== '') {
if (self::boolean($locked)) {
$docStyle->getProtection()->setLocked(Protection::PROTECTION_PROTECTED);
} else {
$docStyle->getProtection()->setLocked(Protection::PROTECTION_UNPROTECTED);
@ -251,13 +327,20 @@ class Styles extends BaseParserClass
/**
* Read protection hidden attribute.
*
* @param SimpleXMLElement|stdClass $style
*/
public function readProtectionHidden(Style $docStyle, $style): void
public function readProtectionHidden(Style $docStyle, SimpleXMLElement $style): void
{
if (isset($style->protection['hidden'])) {
if (self::boolean((string) $style->protection['hidden'])) {
$hidden = '';
if ((string) $style['hidden'] !== '') {
$hidden = (string) $style['hidden'];
} else {
$attr = $this->getStyleAttributes($style);
if (isset($attr['hidden'])) {
$hidden = (string) $attr['hidden'];
}
}
if ($hidden !== '') {
if (self::boolean((string) $hidden)) {
$docStyle->getProtection()->setHidden(Protection::PROTECTION_PROTECTED);
} else {
$docStyle->getProtection()->setHidden(Protection::PROTECTION_UNPROTECTED);
@ -267,15 +350,18 @@ class Styles extends BaseParserClass
public function readColor(SimpleXMLElement $color, bool $background = false): string
{
if (isset($color['rgb'])) {
return (string) $color['rgb'];
} elseif (isset($color['indexed'])) {
return Color::indexedColor((int) ($color['indexed'] - 7), $background)->getARGB() ?? '';
} elseif (isset($color['theme'])) {
$attr = $this->getStyleAttributes($color);
if (isset($attr['rgb'])) {
return (string) $attr['rgb'];
}
if (isset($attr['indexed'])) {
return Color::indexedColor((int) ($attr['indexed'] - 7), $background)->getARGB() ?? '';
}
if (isset($attr['theme'])) {
if ($this->theme !== null) {
$returnColour = $this->theme->getColourByIndex((int) $color['theme']);
if (isset($color['tint'])) {
$tintAdjust = (float) $color['tint'];
$returnColour = $this->theme->getColourByIndex((int) $attr['theme']);
if (isset($attr['tint'])) {
$tintAdjust = (float) $attr['tint'];
$returnColour = Color::changeBrightness($returnColour ?? '', $tintAdjust);
}

58
src/PhpSpreadsheet/Style/Color.php
View File

@ -26,10 +26,24 @@ class Color extends Supervisor
const COLOR_DARKGREEN = 'FF008000';
const COLOR_YELLOW = 'FFFFFF00';
const COLOR_DARKYELLOW = 'FF808000';
const COLOR_MAGENTA = 'FFFF00FF';
const COLOR_CYAN = 'FF00FFFF';
const NAMED_COLOR_TRANSLATIONS = [
'Black' => self::COLOR_BLACK,
'White' => self::COLOR_WHITE,
'Red' => self::COLOR_RED,
'Green' => self::COLOR_GREEN,
'Blue' => self::COLOR_BLUE,
'Yellow' => self::COLOR_YELLOW,
'Magenta' => self::COLOR_MAGENTA,
'Cyan' => self::COLOR_CYAN,
];
const VALIDATE_ARGB_SIZE = 8;
const VALIDATE_RGB_SIZE = 6;
const VALIDATE_COLOR_VALUE = '/^[A-F0-9]{%d}$/i';
const VALIDATE_COLOR_6 = '/^[A-F0-9]{6}$/i';
const VALIDATE_COLOR_8 = '/^[A-F0-9]{8}$/i';
/**
* Indexed colors array.
@ -66,7 +80,7 @@ class Color extends Supervisor
// Initialise values
if (!$isConditional) {
$this->argb = $this->validateColor($colorValue, self::VALIDATE_ARGB_SIZE) ? $colorValue : self::COLOR_BLACK;
$this->argb = $this->validateColor($colorValue) ?: self::COLOR_BLACK;
}
}
@ -135,10 +149,23 @@ class Color extends Supervisor
return $this;
}
private function validateColor(string $colorValue, int $size): bool
private function validateColor(?string $colorValue): string
{
return in_array(ucfirst(strtolower($colorValue)), self::NAMED_COLORS) ||
preg_match(sprintf(self::VALIDATE_COLOR_VALUE, $size), $colorValue);
if ($colorValue === null || $colorValue === '') {
return self::COLOR_BLACK;
}
$named = ucfirst(strtolower($colorValue));
if (array_key_exists($named, self::NAMED_COLOR_TRANSLATIONS)) {
return self::NAMED_COLOR_TRANSLATIONS[$named];
}
if (preg_match(self::VALIDATE_COLOR_8, $colorValue) === 1) {
return $colorValue;
}
if (preg_match(self::VALIDATE_COLOR_6, $colorValue) === 1) {
return 'FF' . $colorValue;
}
return '';
}
/**
@ -163,9 +190,8 @@ class Color extends Supervisor
public function setARGB(?string $colorValue = self::COLOR_BLACK)
{
$this->hasChanged = true;
if ($colorValue === '' || $colorValue === null) {
$colorValue = self::COLOR_BLACK;
} elseif (!$this->validateColor($colorValue, self::VALIDATE_ARGB_SIZE)) {
$colorValue = $this->validateColor($colorValue);
if ($colorValue === '') {
return $this;
}
@ -200,21 +226,7 @@ class Color extends Supervisor
*/
public function setRGB(?string $colorValue = self::COLOR_BLACK)
{
$this->hasChanged = true;
if ($colorValue === '' || $colorValue === null) {
$colorValue = '000000';
} elseif (!$this->validateColor($colorValue, self::VALIDATE_RGB_SIZE)) {
return $this;
}
if ($this->isSupervisor) {
$styleArray = $this->getStyleArray(['argb' => 'FF' . $colorValue]);
$this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray);
} else {
$this->argb = 'FF' . $colorValue;
}
return $this;
return $this->setARGB($colorValue);
}
/**

2
tests/PhpSpreadsheetTests/CommentTest.php
View File

@ -65,7 +65,7 @@ class CommentTest extends TestCase
{
$comment = new Comment();
$comment->setFillColor(new Color('RED'));
self::assertEquals('RED', $comment->getFillColor()->getARGB());
self::assertEquals(Color::COLOR_RED, $comment->getFillColor()->getARGB());
}
public function testSetAlignment(): void

21
tests/PhpSpreadsheetTests/Reader/Xlsx/Issue2494Test.php Normal file
View File

@ -0,0 +1,21 @@
<?php
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PHPUnit\Framework\TestCase;
class Issue2494Test extends TestCase
{
public function testIssue2494(): void
{
// Fill style incorrect.
$filename = 'tests/data/Reader/XLSX/issue.2494.xlsx';
$reader = IOFactory::createReader('Xlsx');
$spreadsheet = $reader->load($filename);
$sheet = $spreadsheet->getActiveSheet();
self::assertTrue($sheet->getCell('C3')->getStyle()->getFont()->getBold());
self::assertSame('FFBFBFBF', $sheet->getCell('D8')->getStyle()->getFill()->getStartColor()->getArgb());
$spreadsheet->disconnectWorksheets();
}
}

12
tests/PhpSpreadsheetTests/Reader/Xlsx/NamespaceNonStdTest.php
View File

@ -77,9 +77,9 @@ class NamespaceNonStdTest extends \PHPUnit\Framework\TestCase
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getSheet(0);
self::assertEquals('SylkTest', $sheet->getTitle());
if (strpos(__FILE__, 'NonStd') !== false) {
self::markTestIncomplete('Not yet ready');
}
//if (strpos(__FILE__, 'NonStd') !== false) {
// self::markTestIncomplete('Not yet ready');
//}
self::assertEquals('FFFF0000', $sheet->getCell('A1')->getStyle()->getFont()->getColor()->getARGB());
self::assertEquals(Fill::FILL_PATTERN_GRAY125, $sheet->getCell('A2')->getStyle()->getFill()->getFillType());
@ -168,9 +168,9 @@ class NamespaceNonStdTest extends \PHPUnit\Framework\TestCase
$spreadsheet = $reader->load(self::$testbook);
$sheet = $spreadsheet->getSheet(1);
self::assertEquals('Second', $sheet->getTitle());
if (strpos(__FILE__, 'NonStd') !== false) {
self::markTestIncomplete('Not yet ready');
}
//if (strpos(__FILE__, 'NonStd') !== false) {
// self::markTestIncomplete('Not yet ready');
//}
self::assertEquals('center', $sheet->getCell('A2')->getStyle()->getAlignment()->getHorizontal());
self::assertSame('inherit', $sheet->getCell('A2')->getStyle()->getProtection()->getLocked());
self::assertEquals('top', $sheet->getCell('A3')->getStyle()->getAlignment()->getVertical());

53
tests/PhpSpreadsheetTests/Reader/Xlsx/RichTextTest.php Normal file
View File

@ -0,0 +1,53 @@
<?php
namespace PhpOffice\PhpSpreadsheetTests\Reader\Xlsx;
use PhpOffice\PhpSpreadsheet\RichText\RichText;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheetTests\Functional\AbstractFunctional;
class RichTextTest extends AbstractFunctional
{
public function testRichTextColors(): void
{
$spreadsheetOld = new Spreadsheet();
$sheet = $spreadsheetOld->getActiveSheet();
$richText = new RichText();
$part1 = $richText->createTextRun('Red');
$font1 = $part1->getFont();
if ($font1 !== null) {
$font1->setName('Courier New');
$font1->getColor()->setArgb('FFFF0000');
}
$part2 = $richText->createTextRun('Blue');
$font2 = $part2->getFont();
if ($font2 !== null) {
$font2->setName('Times New Roman');
$font2->setItalic(true);
$font2->getColor()->setArgb('FF0000FF');
}
$sheet->setCellValue('A1', $richText);
$spreadsheet = $this->writeAndReload($spreadsheetOld, 'Xlsx');
$spreadsheetOld->disconnectWorksheets();
$rsheet = $spreadsheet->getActiveSheet();
$value = $rsheet->getCell('A1')->getValue();
if ($value instanceof RichText) {
$elements = $value->getRichTextElements();
self::assertCount(2, $elements);
$font1a = $elements[0]->getFont();
$font2a = $elements[1]->getFont();
self::assertNotNull($font1a);
self::assertNotNull($font2a);
self::assertSame('Courier New', $font1a->getName());
self::assertSame('FFFF0000', $font1a->getColor()->getArgb());
self::assertFalse($font1a->getItalic());
self::assertSame('Times New Roman', $font2a->getName());
self::assertSame('FF0000FF', $font2a->getColor()->getArgb());
self::assertTrue($font2a->getItalic());
} else {
self::fail('Did not see expected RichText');
}
$spreadsheet->disconnectWorksheets();
}
}

27
tests/PhpSpreadsheetTests/Style/ColorTest.php
View File

@ -157,4 +157,31 @@ class ColorTest extends TestCase
self::assertEquals(Color::COLOR_BLACK, $color->getARGB());
self::assertEquals('000000', $color->getRGB());
}
public function testNamedColors(): void
{
$color = new Color();
$color->setARGB('Blue');
self::assertEquals(Color::COLOR_BLUE, $color->getARGB());
$color->setARGB('black');
self::assertEquals(Color::COLOR_BLACK, $color->getARGB());
$color->setARGB('wHite');
self::assertEquals(Color::COLOR_WHITE, $color->getARGB());
$color->setRGB('reD');
self::assertEquals(Color::COLOR_RED, $color->getARGB());
$color->setRGB('GREEN');
self::assertEquals(Color::COLOR_GREEN, $color->getARGB());
$color->setRGB('magenta');
self::assertEquals(Color::COLOR_MAGENTA, $color->getARGB());
$color->setRGB('YeLlOw');
self::assertEquals(Color::COLOR_YELLOW, $color->getARGB());
$color->setRGB('CYAN');
self::assertEquals(Color::COLOR_CYAN, $color->getARGB());
$color->setRGB('123456ab');
self::assertEquals('123456ab', $color->getARGB());
self::assertEquals('3456ab', $color->getRGB());
$color->setARGB('3456cd');
self::assertEquals('FF3456cd', $color->getARGB());
self::assertEquals('3456cd', $color->getRGB());
}
}

BIN
tests/data/Reader/XLSX/issue.2494.xlsx Normal file
View File

Binary file not shown.