Total Complexity | 158 |
Total Lines | 908 |
Duplicated Lines | 0 % |
Coverage | 72.66% |
Changes | 0 |
Complex classes like Html often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Html, and based on these observations, apply Extract Interface, too.
1 | <?php |
||
21 | class Html extends BaseReader |
||
22 | { |
||
23 | /** |
||
24 | * Sample size to read to determine if it's HTML or not. |
||
25 | */ |
||
26 | const TEST_SAMPLE_SIZE = 2048; |
||
27 | |||
28 | /** |
||
29 | * Input encoding. |
||
30 | * |
||
31 | * @var string |
||
32 | */ |
||
33 | protected $inputEncoding = 'ANSI'; |
||
34 | |||
35 | /** |
||
36 | * Sheet index to read. |
||
37 | * |
||
38 | * @var int |
||
39 | */ |
||
40 | protected $sheetIndex = 0; |
||
41 | |||
42 | /** |
||
43 | * Formats. |
||
44 | * |
||
45 | * @var array |
||
46 | */ |
||
47 | protected $formats = [ |
||
48 | 'h1' => [ |
||
49 | 'font' => [ |
||
50 | 'bold' => true, |
||
51 | 'size' => 24, |
||
52 | ], |
||
53 | ], // Bold, 24pt |
||
54 | 'h2' => [ |
||
55 | 'font' => [ |
||
56 | 'bold' => true, |
||
57 | 'size' => 18, |
||
58 | ], |
||
59 | ], // Bold, 18pt |
||
60 | 'h3' => [ |
||
61 | 'font' => [ |
||
62 | 'bold' => true, |
||
63 | 'size' => 13.5, |
||
64 | ], |
||
65 | ], // Bold, 13.5pt |
||
66 | 'h4' => [ |
||
67 | 'font' => [ |
||
68 | 'bold' => true, |
||
69 | 'size' => 12, |
||
70 | ], |
||
71 | ], // Bold, 12pt |
||
72 | 'h5' => [ |
||
73 | 'font' => [ |
||
74 | 'bold' => true, |
||
75 | 'size' => 10, |
||
76 | ], |
||
77 | ], // Bold, 10pt |
||
78 | 'h6' => [ |
||
79 | 'font' => [ |
||
80 | 'bold' => true, |
||
81 | 'size' => 7.5, |
||
82 | ], |
||
83 | ], // Bold, 7.5pt |
||
84 | 'a' => [ |
||
85 | 'font' => [ |
||
86 | 'underline' => true, |
||
87 | 'color' => [ |
||
88 | 'argb' => Color::COLOR_BLUE, |
||
89 | ], |
||
90 | ], |
||
91 | ], // Blue underlined |
||
92 | 'hr' => [ |
||
93 | 'borders' => [ |
||
94 | 'bottom' => [ |
||
95 | 'borderStyle' => Border::BORDER_THIN, |
||
96 | 'color' => [ |
||
97 | Color::COLOR_BLACK, |
||
98 | ], |
||
99 | ], |
||
100 | ], |
||
101 | ], // Bottom border |
||
102 | 'strong' => [ |
||
103 | 'font' => [ |
||
104 | 'bold' => true, |
||
105 | ], |
||
106 | ], // Bold |
||
107 | 'b' => [ |
||
108 | 'font' => [ |
||
109 | 'bold' => true, |
||
110 | ], |
||
111 | ], // Bold |
||
112 | 'i' => [ |
||
113 | 'font' => [ |
||
114 | 'italic' => true, |
||
115 | ], |
||
116 | ], // Italic |
||
117 | 'em' => [ |
||
118 | 'font' => [ |
||
119 | 'italic' => true, |
||
120 | ], |
||
121 | ], // Italic |
||
122 | ]; |
||
123 | |||
124 | protected $rowspan = []; |
||
125 | |||
126 | /** |
||
127 | * Create a new HTML Reader instance. |
||
128 | */ |
||
129 | 26 | public function __construct() |
|
133 | 26 | } |
|
134 | |||
135 | /** |
||
136 | * Validate that the current file is an HTML file. |
||
137 | * |
||
138 | * @param string $pFilename |
||
139 | * |
||
140 | * @return bool |
||
141 | */ |
||
142 | 24 | public function canRead($pFilename) |
|
143 | { |
||
144 | // Check if file exists |
||
145 | try { |
||
146 | 24 | $this->openFile($pFilename); |
|
147 | } catch (Exception $e) { |
||
148 | return false; |
||
149 | } |
||
150 | |||
151 | 24 | $beginning = $this->readBeginning(); |
|
152 | 24 | $startWithTag = self::startsWithTag($beginning); |
|
153 | 24 | $containsTags = self::containsTags($beginning); |
|
154 | 24 | $endsWithTag = self::endsWithTag($this->readEnding()); |
|
155 | |||
156 | 24 | fclose($this->fileHandle); |
|
1 ignored issue
–
show
|
|||
157 | |||
158 | 24 | return $startWithTag && $containsTags && $endsWithTag; |
|
159 | } |
||
160 | |||
161 | 24 | private function readBeginning() |
|
162 | { |
||
163 | 24 | fseek($this->fileHandle, 0); |
|
164 | |||
165 | 24 | return fread($this->fileHandle, self::TEST_SAMPLE_SIZE); |
|
166 | } |
||
167 | |||
168 | 24 | private function readEnding() |
|
169 | { |
||
170 | 24 | $meta = stream_get_meta_data($this->fileHandle); |
|
171 | 24 | $filename = $meta['uri']; |
|
172 | |||
173 | 24 | $size = filesize($filename); |
|
174 | 24 | if ($size === 0) { |
|
175 | 1 | return ''; |
|
176 | } |
||
177 | |||
178 | 23 | $blockSize = self::TEST_SAMPLE_SIZE; |
|
179 | 23 | if ($size < $blockSize) { |
|
180 | 10 | $blockSize = $size; |
|
181 | } |
||
182 | |||
183 | 23 | fseek($this->fileHandle, $size - $blockSize); |
|
184 | |||
185 | 23 | return fread($this->fileHandle, $blockSize); |
|
186 | } |
||
187 | |||
188 | 24 | private static function startsWithTag($data) |
|
189 | { |
||
190 | 24 | return '<' === substr(trim($data), 0, 1); |
|
191 | } |
||
192 | |||
193 | 24 | private static function endsWithTag($data) |
|
194 | { |
||
195 | 24 | return '>' === substr(trim($data), -1, 1); |
|
196 | } |
||
197 | |||
198 | 24 | private static function containsTags($data) |
|
199 | { |
||
200 | 24 | return strlen($data) !== strlen(strip_tags($data)); |
|
201 | } |
||
202 | |||
203 | /** |
||
204 | * Loads Spreadsheet from file. |
||
205 | * |
||
206 | * @param string $pFilename |
||
207 | * |
||
208 | * @throws Exception |
||
209 | * |
||
210 | * @return Spreadsheet |
||
211 | */ |
||
212 | 17 | public function load($pFilename) |
|
213 | { |
||
214 | // Create new Spreadsheet |
||
215 | 17 | $spreadsheet = new Spreadsheet(); |
|
216 | |||
217 | // Load into this instance |
||
218 | 17 | return $this->loadIntoExisting($pFilename, $spreadsheet); |
|
219 | } |
||
220 | |||
221 | /** |
||
222 | * Set input encoding. |
||
223 | * |
||
224 | * @param string $pValue Input encoding, eg: 'ANSI' |
||
225 | * |
||
226 | * @return Html |
||
227 | */ |
||
228 | 1 | public function setInputEncoding($pValue) |
|
233 | } |
||
234 | |||
235 | /** |
||
236 | * Get input encoding. |
||
237 | * |
||
238 | * @return string |
||
239 | */ |
||
240 | public function getInputEncoding() |
||
241 | { |
||
242 | return $this->inputEncoding; |
||
243 | } |
||
244 | |||
245 | // Data Array used for testing only, should write to Spreadsheet object on completion of tests |
||
246 | protected $dataArray = []; |
||
247 | |||
248 | protected $tableLevel = 0; |
||
249 | |||
250 | protected $nestedColumn = ['A']; |
||
251 | |||
252 | 17 | protected function setTableStartColumn($column) |
|
253 | { |
||
254 | 17 | if ($this->tableLevel == 0) { |
|
255 | 17 | $column = 'A'; |
|
256 | } |
||
257 | 17 | ++$this->tableLevel; |
|
258 | 17 | $this->nestedColumn[$this->tableLevel] = $column; |
|
259 | |||
260 | 17 | return $this->nestedColumn[$this->tableLevel]; |
|
261 | } |
||
262 | |||
263 | 17 | protected function getTableStartColumn() |
|
264 | { |
||
265 | 17 | return $this->nestedColumn[$this->tableLevel]; |
|
266 | } |
||
267 | |||
268 | 17 | protected function releaseTableStartColumn() |
|
269 | { |
||
270 | 17 | --$this->tableLevel; |
|
271 | |||
272 | 17 | return array_pop($this->nestedColumn); |
|
273 | } |
||
274 | |||
275 | 17 | protected function flushCell(Worksheet $sheet, $column, $row, &$cellContent) |
|
276 | { |
||
277 | 17 | if (is_string($cellContent)) { |
|
278 | // Simple String content |
||
279 | 17 | if (trim($cellContent) > '') { |
|
280 | // Only actually write it if there's content in the string |
||
281 | // Write to worksheet to be done here... |
||
282 | // ... we return the cell so we can mess about with styles more easily |
||
283 | 16 | $sheet->setCellValue($column . $row, $cellContent); |
|
284 | 17 | $this->dataArray[$row][$column] = $cellContent; |
|
285 | } |
||
286 | } else { |
||
287 | // We have a Rich Text run |
||
288 | // TODO |
||
289 | $this->dataArray[$row][$column] = 'RICH TEXT: ' . $cellContent; |
||
290 | } |
||
291 | 17 | $cellContent = (string) ''; |
|
292 | 17 | } |
|
293 | |||
294 | /** |
||
295 | * @param DOMNode $element |
||
296 | * @param Worksheet $sheet |
||
297 | * @param int $row |
||
298 | * @param string $column |
||
299 | * @param string $cellContent |
||
300 | */ |
||
301 | 17 | protected function processDomElement(DOMNode $element, Worksheet $sheet, &$row, &$column, &$cellContent) |
|
302 | { |
||
303 | 17 | foreach ($element->childNodes as $child) { |
|
304 | 17 | if ($child instanceof DOMText) { |
|
305 | 17 | $domText = preg_replace('/\s+/u', ' ', trim($child->nodeValue)); |
|
306 | 17 | if (is_string($cellContent)) { |
|
307 | // simply append the text if the cell content is a plain text string |
||
308 | 17 | $cellContent .= $domText; |
|
309 | } |
||
310 | // but if we have a rich text run instead, we need to append it correctly |
||
311 | // TODO |
||
312 | 17 | } elseif ($child instanceof DOMElement) { |
|
313 | 17 | $attributeArray = []; |
|
314 | 17 | foreach ($child->attributes as $attribute) { |
|
315 | 17 | $attributeArray[$attribute->name] = $attribute->value; |
|
316 | } |
||
317 | |||
318 | 17 | switch ($child->nodeName) { |
|
319 | 17 | case 'meta': |
|
320 | 9 | foreach ($attributeArray as $attributeName => $attributeValue) { |
|
321 | // Extract character set, so we can convert to UTF-8 if required |
||
322 | 9 | if ($attributeName === 'charset') { |
|
323 | 1 | $this->setInputEncoding($attributeValue); |
|
324 | } |
||
325 | } |
||
326 | 9 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
|
327 | |||
328 | 9 | break; |
|
329 | 17 | case 'title': |
|
330 | 9 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
|
331 | 9 | $sheet->setTitle($cellContent, true, false); |
|
332 | 9 | $cellContent = ''; |
|
333 | |||
334 | 9 | break; |
|
335 | 17 | case 'span': |
|
336 | 17 | case 'div': |
|
337 | 17 | case 'font': |
|
338 | 17 | case 'i': |
|
339 | 17 | case 'em': |
|
340 | 17 | case 'strong': |
|
341 | 17 | case 'b': |
|
342 | 6 | if (isset($attributeArray['class']) && $attributeArray['class'] === 'comment') { |
|
343 | 6 | $sheet->getComment($column . $row) |
|
344 | 6 | ->getText() |
|
345 | 6 | ->createTextRun($child->textContent); |
|
346 | |||
347 | 6 | break; |
|
348 | } |
||
349 | |||
350 | if ($cellContent > '') { |
||
351 | $cellContent .= ' '; |
||
352 | } |
||
353 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
||
354 | if ($cellContent > '') { |
||
355 | $cellContent .= ' '; |
||
356 | } |
||
357 | |||
358 | if (isset($this->formats[$child->nodeName])) { |
||
359 | $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]); |
||
360 | } |
||
361 | |||
362 | break; |
||
363 | 17 | case 'hr': |
|
364 | $this->flushCell($sheet, $column, $row, $cellContent); |
||
365 | ++$row; |
||
366 | if (isset($this->formats[$child->nodeName])) { |
||
367 | $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]); |
||
368 | } else { |
||
369 | $cellContent = '----------'; |
||
370 | $this->flushCell($sheet, $column, $row, $cellContent); |
||
371 | } |
||
372 | ++$row; |
||
373 | // Add a break after a horizontal rule, simply by allowing the code to dropthru |
||
374 | // no break |
||
375 | 17 | case 'br': |
|
376 | if ($this->tableLevel > 0) { |
||
377 | // If we're inside a table, replace with a \n |
||
378 | $cellContent .= "\n"; |
||
379 | } else { |
||
380 | // Otherwise flush our existing content and move the row cursor on |
||
381 | $this->flushCell($sheet, $column, $row, $cellContent); |
||
382 | ++$row; |
||
383 | } |
||
384 | |||
385 | break; |
||
386 | 17 | case 'a': |
|
387 | 6 | foreach ($attributeArray as $attributeName => $attributeValue) { |
|
388 | 6 | switch ($attributeName) { |
|
389 | 6 | case 'href': |
|
390 | $sheet->getCell($column . $row)->getHyperlink()->setUrl($attributeValue); |
||
391 | if (isset($this->formats[$child->nodeName])) { |
||
392 | $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]); |
||
393 | } |
||
394 | |||
395 | break; |
||
396 | 6 | case 'class': |
|
397 | 6 | if ($attributeValue === 'comment-indicator') { |
|
398 | 6 | break; // Ignore - it's just a red square. |
|
399 | } |
||
400 | } |
||
401 | } |
||
402 | 6 | $cellContent .= ' '; |
|
403 | 6 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
|
404 | |||
405 | 6 | break; |
|
406 | 17 | case 'h1': |
|
407 | 17 | case 'h2': |
|
408 | 17 | case 'h3': |
|
409 | 17 | case 'h4': |
|
410 | 17 | case 'h5': |
|
411 | 17 | case 'h6': |
|
412 | 17 | case 'ol': |
|
413 | 17 | case 'ul': |
|
414 | 17 | case 'p': |
|
415 | if ($this->tableLevel > 0) { |
||
416 | // If we're inside a table, replace with a \n |
||
417 | $cellContent .= "\n"; |
||
418 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
||
419 | } else { |
||
420 | if ($cellContent > '') { |
||
421 | $this->flushCell($sheet, $column, $row, $cellContent); |
||
422 | ++$row; |
||
423 | } |
||
424 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
||
425 | $this->flushCell($sheet, $column, $row, $cellContent); |
||
426 | |||
427 | if (isset($this->formats[$child->nodeName])) { |
||
428 | $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]); |
||
429 | } |
||
430 | |||
431 | ++$row; |
||
432 | $column = 'A'; |
||
433 | } |
||
434 | |||
435 | break; |
||
436 | 17 | case 'li': |
|
437 | if ($this->tableLevel > 0) { |
||
438 | // If we're inside a table, replace with a \n |
||
439 | $cellContent .= "\n"; |
||
440 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
||
441 | } else { |
||
442 | if ($cellContent > '') { |
||
443 | $this->flushCell($sheet, $column, $row, $cellContent); |
||
444 | } |
||
445 | ++$row; |
||
446 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
||
447 | $this->flushCell($sheet, $column, $row, $cellContent); |
||
448 | $column = 'A'; |
||
449 | } |
||
450 | |||
451 | break; |
||
452 | 17 | case 'img': |
|
453 | 1 | $this->insertImage($sheet, $column, $row, $attributeArray); |
|
454 | |||
455 | 1 | break; |
|
456 | 17 | case 'table': |
|
457 | 17 | $this->flushCell($sheet, $column, $row, $cellContent); |
|
458 | 17 | $column = $this->setTableStartColumn($column); |
|
459 | 17 | if ($this->tableLevel > 1) { |
|
460 | --$row; |
||
461 | } |
||
462 | 17 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
|
463 | 17 | $column = $this->releaseTableStartColumn(); |
|
464 | 17 | if ($this->tableLevel > 1) { |
|
465 | ++$column; |
||
466 | } else { |
||
467 | 17 | ++$row; |
|
468 | } |
||
469 | |||
470 | 17 | break; |
|
471 | 17 | case 'thead': |
|
472 | 17 | case 'tbody': |
|
473 | 8 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
|
474 | |||
475 | 8 | break; |
|
476 | 17 | case 'tr': |
|
477 | 17 | $column = $this->getTableStartColumn(); |
|
478 | 17 | $cellContent = ''; |
|
479 | 17 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
|
480 | |||
481 | 17 | if (isset($attributeArray['height'])) { |
|
482 | $sheet->getRowDimension($row)->setRowHeight($attributeArray['height']); |
||
483 | } |
||
484 | |||
485 | 17 | ++$row; |
|
486 | |||
487 | 17 | break; |
|
488 | 17 | case 'th': |
|
489 | 17 | case 'td': |
|
490 | 17 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
|
491 | |||
492 | // apply inline style |
||
493 | 17 | $this->applyInlineStyle($sheet, $row, $column, $attributeArray); |
|
494 | |||
495 | 17 | while (isset($this->rowspan[$column . $row])) { |
|
496 | ++$column; |
||
497 | } |
||
498 | |||
499 | 17 | $this->flushCell($sheet, $column, $row, $cellContent); |
|
500 | |||
501 | 17 | if (isset($attributeArray['rowspan'], $attributeArray['colspan'])) { |
|
502 | //create merging rowspan and colspan |
||
503 | $columnTo = $column; |
||
504 | for ($i = 0; $i < $attributeArray['colspan'] - 1; ++$i) { |
||
505 | ++$columnTo; |
||
506 | } |
||
507 | $range = $column . $row . ':' . $columnTo . ($row + $attributeArray['rowspan'] - 1); |
||
508 | foreach (Coordinate::extractAllCellReferencesInRange($range) as $value) { |
||
509 | $this->rowspan[$value] = true; |
||
510 | } |
||
511 | $sheet->mergeCells($range); |
||
512 | $column = $columnTo; |
||
513 | 17 | } elseif (isset($attributeArray['rowspan'])) { |
|
514 | //create merging rowspan |
||
515 | $range = $column . $row . ':' . $column . ($row + $attributeArray['rowspan'] - 1); |
||
516 | foreach (Coordinate::extractAllCellReferencesInRange($range) as $value) { |
||
517 | $this->rowspan[$value] = true; |
||
518 | } |
||
519 | $sheet->mergeCells($range); |
||
520 | 17 | } elseif (isset($attributeArray['colspan'])) { |
|
521 | //create merging colspan |
||
522 | 1 | $columnTo = $column; |
|
523 | 1 | for ($i = 0; $i < $attributeArray['colspan'] - 1; ++$i) { |
|
524 | 1 | ++$columnTo; |
|
525 | } |
||
526 | 1 | $sheet->mergeCells($column . $row . ':' . $columnTo . $row); |
|
527 | 1 | $column = $columnTo; |
|
528 | 17 | } elseif (isset($attributeArray['bgcolor'])) { |
|
529 | $sheet->getStyle($column . $row)->applyFromArray( |
||
530 | [ |
||
531 | 'fill' => [ |
||
532 | 'fillType' => Fill::FILL_SOLID, |
||
533 | 'color' => ['rgb' => $attributeArray['bgcolor']], |
||
534 | ], |
||
535 | ] |
||
536 | ); |
||
537 | } |
||
538 | |||
539 | 17 | if (isset($attributeArray['width'])) { |
|
540 | 1 | $sheet->getColumnDimension($column)->setWidth($attributeArray['width']); |
|
541 | } |
||
542 | |||
543 | 17 | if (isset($attributeArray['height'])) { |
|
544 | 1 | $sheet->getRowDimension($row)->setRowHeight($attributeArray['height']); |
|
545 | } |
||
546 | |||
547 | 17 | if (isset($attributeArray['align'])) { |
|
548 | 1 | $sheet->getStyle($column . $row)->getAlignment()->setHorizontal($attributeArray['align']); |
|
549 | } |
||
550 | |||
551 | 17 | if (isset($attributeArray['valign'])) { |
|
552 | 1 | $sheet->getStyle($column . $row)->getAlignment()->setVertical($attributeArray['valign']); |
|
553 | } |
||
554 | |||
555 | 17 | if (isset($attributeArray['data-format'])) { |
|
556 | 1 | $sheet->getStyle($column . $row)->getNumberFormat()->setFormatCode($attributeArray['data-format']); |
|
557 | } |
||
558 | |||
559 | 17 | ++$column; |
|
560 | |||
561 | 17 | break; |
|
562 | 17 | case 'body': |
|
563 | 17 | $row = 1; |
|
564 | 17 | $column = 'A'; |
|
565 | 17 | $cellContent = ''; |
|
566 | 17 | $this->tableLevel = 0; |
|
567 | 17 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
|
568 | |||
569 | 17 | break; |
|
570 | default: |
||
571 | 17 | $this->processDomElement($child, $sheet, $row, $column, $cellContent); |
|
572 | } |
||
573 | } |
||
574 | } |
||
575 | 17 | } |
|
576 | |||
577 | /** |
||
578 | * Loads PhpSpreadsheet from file into PhpSpreadsheet instance. |
||
579 | * |
||
580 | * @param string $pFilename |
||
581 | * @param Spreadsheet $spreadsheet |
||
582 | * |
||
583 | * @throws Exception |
||
584 | * |
||
585 | * @return Spreadsheet |
||
586 | */ |
||
587 | 17 | public function loadIntoExisting($pFilename, Spreadsheet $spreadsheet) |
|
588 | { |
||
589 | // Validate |
||
590 | 17 | if (!$this->canRead($pFilename)) { |
|
591 | throw new Exception($pFilename . ' is an Invalid HTML file.'); |
||
592 | } |
||
593 | |||
594 | // Create new sheet |
||
595 | 17 | while ($spreadsheet->getSheetCount() <= $this->sheetIndex) { |
|
596 | $spreadsheet->createSheet(); |
||
597 | } |
||
598 | 17 | $spreadsheet->setActiveSheetIndex($this->sheetIndex); |
|
599 | |||
600 | // Create a new DOM object |
||
601 | 17 | $dom = new DOMDocument(); |
|
602 | // Reload the HTML file into the DOM object |
||
603 | 17 | $loaded = $dom->loadHTML(mb_convert_encoding($this->securityScanner->scanFile($pFilename), 'HTML-ENTITIES', 'UTF-8')); |
|
604 | 17 | if ($loaded === false) { |
|
605 | throw new Exception('Failed to load ' . $pFilename . ' as a DOM Document'); |
||
606 | } |
||
607 | |||
608 | // Discard white space |
||
609 | 17 | $dom->preserveWhiteSpace = false; |
|
610 | |||
611 | 17 | $row = 0; |
|
612 | 17 | $column = 'A'; |
|
613 | 17 | $content = ''; |
|
614 | 17 | $this->rowspan = []; |
|
615 | 17 | $this->processDomElement($dom, $spreadsheet->getActiveSheet(), $row, $column, $content); |
|
616 | |||
617 | // Return |
||
618 | 17 | return $spreadsheet; |
|
619 | } |
||
620 | |||
621 | /** |
||
622 | * Get sheet index. |
||
623 | * |
||
624 | * @return int |
||
625 | */ |
||
626 | public function getSheetIndex() |
||
627 | { |
||
628 | return $this->sheetIndex; |
||
629 | } |
||
630 | |||
631 | /** |
||
632 | * Set sheet index. |
||
633 | * |
||
634 | * @param int $pValue Sheet index |
||
635 | * |
||
636 | * @return HTML |
||
637 | */ |
||
638 | public function setSheetIndex($pValue) |
||
639 | { |
||
640 | $this->sheetIndex = $pValue; |
||
641 | |||
642 | return $this; |
||
643 | } |
||
644 | |||
645 | /** |
||
646 | * Apply inline css inline style. |
||
647 | * |
||
648 | * NOTES : |
||
649 | * Currently only intended for td & th element, |
||
650 | * and only takes 'background-color' and 'color'; property with HEX color |
||
651 | * |
||
652 | * TODO : |
||
653 | * - Implement to other propertie, such as border |
||
654 | * |
||
655 | * @param Worksheet $sheet |
||
656 | * @param int $row |
||
657 | * @param string $column |
||
658 | * @param array $attributeArray |
||
659 | */ |
||
660 | 17 | private function applyInlineStyle(&$sheet, $row, $column, $attributeArray) |
|
661 | { |
||
662 | 17 | if (!isset($attributeArray['style'])) { |
|
663 | 14 | return; |
|
664 | } |
||
665 | |||
666 | 7 | $cellStyle = $sheet->getStyle($column . $row); |
|
667 | |||
668 | // add color styles (background & text) from dom element,currently support : td & th, using ONLY inline css style with RGB color |
||
669 | 7 | $styles = explode(';', $attributeArray['style']); |
|
670 | 7 | foreach ($styles as $st) { |
|
671 | 7 | $value = explode(':', $st); |
|
672 | 7 | $styleName = isset($value[0]) ? trim($value[0]) : null; |
|
673 | 7 | $styleValue = isset($value[1]) ? trim($value[1]) : null; |
|
674 | |||
675 | 7 | if (!$styleName) { |
|
676 | 5 | continue; |
|
677 | } |
||
678 | |||
679 | 7 | switch ($styleName) { |
|
680 | 7 | case 'background': |
|
681 | 7 | case 'background-color': |
|
682 | 2 | $styleColor = $this->getStyleColor($styleValue); |
|
683 | |||
684 | 2 | if (!$styleColor) { |
|
685 | continue 2; |
||
686 | } |
||
687 | |||
688 | 2 | $cellStyle->applyFromArray(['fill' => ['fillType' => Fill::FILL_SOLID, 'color' => ['rgb' => $styleColor]]]); |
|
689 | |||
690 | 2 | break; |
|
691 | 7 | case 'color': |
|
692 | 2 | $styleColor = $this->getStyleColor($styleValue); |
|
693 | |||
694 | 2 | if (!$styleColor) { |
|
695 | continue 2; |
||
696 | } |
||
697 | |||
698 | 2 | $cellStyle->applyFromArray(['font' => ['color' => ['rgb' => $styleColor]]]); |
|
699 | |||
700 | 2 | break; |
|
701 | |||
702 | 5 | case 'border': |
|
703 | 1 | $this->setBorderStyle($cellStyle, $styleValue, 'allBorders'); |
|
704 | |||
705 | 1 | break; |
|
706 | |||
707 | 5 | case 'border-top': |
|
708 | 1 | $this->setBorderStyle($cellStyle, $styleValue, 'top'); |
|
709 | |||
710 | 1 | break; |
|
711 | |||
712 | 5 | case 'border-bottom': |
|
713 | 1 | $this->setBorderStyle($cellStyle, $styleValue, 'bottom'); |
|
714 | |||
715 | 1 | break; |
|
716 | |||
717 | 5 | case 'border-left': |
|
718 | 1 | $this->setBorderStyle($cellStyle, $styleValue, 'left'); |
|
719 | |||
720 | 1 | break; |
|
721 | |||
722 | 5 | case 'border-right': |
|
723 | 1 | $this->setBorderStyle($cellStyle, $styleValue, 'right'); |
|
724 | |||
725 | 1 | break; |
|
726 | |||
727 | 4 | case 'font-size': |
|
728 | 1 | $cellStyle->getFont()->setSize( |
|
729 | 1 | (float) $styleValue |
|
730 | ); |
||
731 | |||
732 | 1 | break; |
|
733 | |||
734 | 4 | case 'font-weight': |
|
735 | 1 | if ($styleValue === 'bold' || $styleValue >= 500) { |
|
736 | 1 | $cellStyle->getFont()->setBold(true); |
|
737 | } |
||
738 | |||
739 | 1 | break; |
|
740 | |||
741 | 4 | case 'font-style': |
|
742 | 1 | if ($styleValue === 'italic') { |
|
743 | 1 | $cellStyle->getFont()->setItalic(true); |
|
744 | } |
||
745 | |||
746 | 1 | break; |
|
747 | |||
748 | 4 | case 'font-family': |
|
749 | 1 | $cellStyle->getFont()->setName(str_replace('\'', '', $styleValue)); |
|
750 | |||
751 | 1 | break; |
|
752 | |||
753 | 4 | case 'text-decoration': |
|
754 | 1 | switch ($styleValue) { |
|
755 | 1 | case 'underline': |
|
756 | 1 | $cellStyle->getFont()->setUnderline(Font::UNDERLINE_SINGLE); |
|
757 | |||
758 | 1 | break; |
|
759 | 1 | case 'line-through': |
|
760 | 1 | $cellStyle->getFont()->setStrikethrough(true); |
|
761 | |||
762 | 1 | break; |
|
763 | } |
||
764 | |||
765 | 1 | break; |
|
766 | |||
767 | 3 | case 'text-align': |
|
768 | 1 | $cellStyle->getAlignment()->setHorizontal($styleValue); |
|
769 | |||
770 | 1 | break; |
|
771 | |||
772 | 3 | case 'vertical-align': |
|
773 | 1 | $cellStyle->getAlignment()->setVertical($styleValue); |
|
774 | |||
775 | 1 | break; |
|
776 | |||
777 | 3 | case 'width': |
|
778 | 1 | $sheet->getColumnDimension($column)->setWidth( |
|
779 | 1 | str_replace('px', '', $styleValue) |
|
780 | ); |
||
781 | |||
782 | 1 | break; |
|
783 | |||
784 | 2 | case 'height': |
|
785 | 1 | $sheet->getRowDimension($row)->setRowHeight( |
|
786 | 1 | str_replace('px', '', $styleValue) |
|
787 | ); |
||
788 | |||
789 | 1 | break; |
|
790 | |||
791 | 1 | case 'word-wrap': |
|
792 | 1 | $cellStyle->getAlignment()->setWrapText( |
|
793 | 1 | $styleValue === 'break-word' |
|
794 | ); |
||
795 | |||
796 | 1 | break; |
|
797 | |||
798 | 1 | case 'text-indent': |
|
799 | 1 | $cellStyle->getAlignment()->setIndent( |
|
800 | 1 | (int) str_replace(['px'], '', $styleValue) |
|
801 | ); |
||
802 | |||
803 | 1 | break; |
|
804 | } |
||
805 | } |
||
806 | 7 | } |
|
807 | |||
808 | /** |
||
809 | * Check if has #, so we can get clean hex. |
||
810 | * |
||
811 | * @param $value |
||
812 | * |
||
813 | * @return null|string |
||
814 | */ |
||
815 | 3 | public function getStyleColor($value) |
|
816 | { |
||
817 | 3 | if (strpos($value, '#') === 0) { |
|
818 | 3 | return substr($value, 1); |
|
819 | } |
||
820 | |||
821 | return null; |
||
822 | } |
||
823 | |||
824 | /** |
||
825 | * @param Worksheet $sheet |
||
826 | * @param string $column |
||
827 | * @param int $row |
||
828 | * @param array $attributes |
||
829 | * |
||
830 | * @throws \PhpOffice\PhpSpreadsheet\Exception |
||
831 | */ |
||
832 | 1 | private function insertImage(Worksheet $sheet, $column, $row, array $attributes) |
|
869 | ); |
||
870 | 1 | } |
|
871 | |||
872 | /** |
||
873 | * Map html border style to PhpSpreadsheet border style. |
||
874 | * |
||
875 | * @param string $style |
||
876 | * |
||
877 | * @return null|string |
||
878 | */ |
||
879 | 1 | public function getBorderStyle($style) |
|
880 | { |
||
881 | 1 | switch ($style) { |
|
882 | 1 | case 'solid': |
|
883 | 1 | return Border::BORDER_THIN; |
|
884 | case 'dashed': |
||
885 | return Border::BORDER_DASHED; |
||
886 | case 'dotted': |
||
887 | return Border::BORDER_DOTTED; |
||
888 | case 'medium': |
||
889 | return Border::BORDER_MEDIUM; |
||
890 | case 'thick': |
||
891 | return Border::BORDER_THICK; |
||
892 | case 'none': |
||
893 | return Border::BORDER_NONE; |
||
894 | case 'dash-dot': |
||
895 | return Border::BORDER_DASHDOT; |
||
896 | case 'dash-dot-dot': |
||
897 | return Border::BORDER_DASHDOTDOT; |
||
898 | case 'double': |
||
899 | return Border::BORDER_DOUBLE; |
||
900 | case 'hair': |
||
901 | return Border::BORDER_HAIR; |
||
902 | case 'medium-dash-dot': |
||
903 | return Border::BORDER_MEDIUMDASHDOT; |
||
904 | case 'medium-dash-dot-dot': |
||
905 | return Border::BORDER_MEDIUMDASHDOTDOT; |
||
906 | case 'medium-dashed': |
||
907 | return Border::BORDER_MEDIUMDASHED; |
||
908 | case 'slant-dash-dot': |
||
909 | return Border::BORDER_SLANTDASHDOT; |
||
910 | } |
||
911 | |||
912 | return null; |
||
913 | } |
||
914 | |||
915 | /** |
||
916 | * @param Style $cellStyle |
||
917 | * @param string $styleValue |
||
918 | * @param string $type |
||
919 | */ |
||
920 | 1 | private function setBorderStyle(Style $cellStyle, $styleValue, $type) |
|
929 | ], |
||
930 | ], |
||
931 | ]); |
||
932 | 1 | } |
|
933 | } |
||
934 |