ThemeSetEmailHandler::handleCharacterData()   A
last analyzed

Complexity

Conditions 2
Paths 2

Size

Total Lines 8
Code Lines 6

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
eloc 6
dl 0
loc 8
rs 10
c 0
b 0
f 0
cc 2
nc 2
nop 2
1
<?php
2
/**
3
 * XOOPS Utilities
4
 *
5
 * You may not change or alter any portion of this comment or credits
6
 * of supporting developers from this source code or any supporting source code
7
 * which is considered copyrighted (c) material of the original comment or credit authors.
8
 * This program is distributed in the hope that it will be useful,
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11
 *
12
 * @copyright       (c) 2000-2016 XOOPS Project (www.xoops.org)
13
 * @license             GNU GPL 2 (https://www.gnu.org/licenses/gpl-2.0.html)
14
 * @package             class
15
 * @subpackage          utility
16
 * @since               1.0.0
17
 * @author              Author: Kazumi Ono (AKA onokazu)
18
 */
19
defined('XOOPS_ROOT_PATH') || exit('Restricted access');
20
21
include_once XOOPS_ROOT_PATH . '/class/xml/saxparser.php';
22
include_once XOOPS_ROOT_PATH . '/class/xml/xmltaghandler.php';
23
24
/**
25
 * Class XoopsThemeSetParser
26
 */
27
class XoopsThemeSetParser extends SaxParser
28
{
29
    public $tempArr       = array();
30
    public $themeSetData  = array();
31
    public $imagesData    = array();
32
    public $templatesData = array();
33
34
    /**
35
     * @param $input
36
     */
37
    public function __construct(&$input)
38
    {
39
        parent::__construct($input);
40
        $this->addTagHandler(new ThemeSetThemeNameHandler());
0 ignored issues
show
Bug introduced by
The type ThemeSetThemeNameHandler was not found. Maybe you did not declare it correctly or list all dependencies?

The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. excluded_paths: ["lib/*"], you can move it to the dependency path list as follows:

filter:
    dependency_paths: ["lib/*"]

For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths

Loading history...
41
        $this->addTagHandler(new ThemeSetDateCreatedHandler());
42
        $this->addTagHandler(new ThemeSetAuthorHandler());
43
        $this->addTagHandler(new ThemeSetDescriptionHandler());
44
        $this->addTagHandler(new ThemeSetGeneratorHandler());
45
        $this->addTagHandler(new ThemeSetNameHandler());
46
        $this->addTagHandler(new ThemeSetEmailHandler());
47
        $this->addTagHandler(new ThemeSetLinkHandler());
48
        $this->addTagHandler(new ThemeSetTemplateHandler());
49
        $this->addTagHandler(new ThemeSetImageHandler());
50
        $this->addTagHandler(new ThemeSetModuleHandler());
51
        $this->addTagHandler(new ThemeSetFileTypeHandler());
52
        $this->addTagHandler(new ThemeSetTagHandler());
53
    }
54
55
    /**
56
     * @param $name
57
     * @param $value
58
     */
59
    public function setThemeSetData($name, &$value)
60
    {
61
        $this->themeSetData[$name] = &$value;
62
    }
63
64
    /**
65
     * @param null $name
0 ignored issues
show
Documentation Bug introduced by
Are you sure the doc-type for parameter $name is correct as it would always require null to be passed?
Loading history...
66
     *
67
     * @return array|bool
68
     */
69
    public function &getThemeSetData($name = null)
70
    {
71
        if (isset($name)) {
72
            if (isset($this->themeSetData[$name])) {
73
                return $this->themeSetData[$name];
74
            }
75
76
            return false;
77
        }
78
79
        return $this->themeSetData;
80
    }
81
82
    /**
83
     * @param $imagearr
84
     */
85
    public function setImagesData(&$imagearr)
86
    {
87
        $this->imagesData[] = &$imagearr;
88
    }
89
90
    /**
91
     * @return array
92
     */
93
    public function &getImagesData()
94
    {
95
        return $this->imagesData;
96
    }
97
98
    /**
99
     * @param $tplarr
100
     */
101
    public function setTemplatesData(&$tplarr)
102
    {
103
        $this->templatesData[] = &$tplarr;
104
    }
105
106
    /**
107
     * @return array
108
     */
109
    public function &getTemplatesData()
110
    {
111
        return $this->templatesData;
112
    }
113
114
    /**
115
     * @param        $name
116
     * @param        $value
117
     * @param string $delim
118
     */
119
    public function setTempArr($name, &$value, $delim = '')
120
    {
121
        if (!isset($this->tempArr[$name])) {
122
            $this->tempArr[$name] = &$value;
123
        } else {
124
            $this->tempArr[$name] .= $delim . $value;
125
        }
126
    }
127
128
    /**
129
     * @return array
130
     */
131
    public function getTempArr()
132
    {
133
        return $this->tempArr;
134
    }
135
136
    public function resetTempArr()
137
    {
138
        unset($this->tempArr);
139
        $this->tempArr = array();
140
    }
141
}
142
143
/**
144
 * Class ThemeSetDateCreatedHandler
145
 */
146
class ThemeSetDateCreatedHandler extends XmlTagHandler
147
{
148
    /**
149
     * ThemeSetDateCreatedHandler constructor.
150
     */
151
    public function __construct()
152
    {
153
    }
154
155
    /**
156
     * @return string
157
     */
158
    public function getName()
159
    {
160
        return 'dateCreated';
161
    }
162
163
    /**
164
     * @param $parser
165
     * @param $data
166
     */
167
    public function handleCharacterData($parser, &$data)
168
    {
169
        switch ($parser->getParentTag()) {
170
            case 'themeset':
171
                $parser->setThemeSetData('date', $data);
172
                break;
173
            default:
174
                break;
175
        }
176
    }
177
}
178
179
/**
180
 * Class ThemeSetAuthorHandler
181
 */
182
class ThemeSetAuthorHandler extends XmlTagHandler
183
{
184
    /**
185
     * ThemeSetAuthorHandler constructor.
186
     */
187
    public function __construct()
188
    {
189
    }
190
191
    /**
192
     * @return string
193
     */
194
    public function getName()
195
    {
196
        return 'author';
197
    }
198
199
    /**
200
     * @param $parser
201
     * @param $attributes
202
     */
203
    public function handleBeginElement($parser, &$attributes)
204
    {
205
        $parser->resetTempArr();
206
    }
207
208
    /**
209
     * @param $parser
210
     */
211
    public function handleEndElement($parser)
212
    {
213
        $parser->setCreditsData($parser->getTempArr());
214
    }
215
}
216
217
/**
218
 * Class ThemeSetDescriptionHandler
219
 */
220
class ThemeSetDescriptionHandler extends XmlTagHandler
221
{
222
    /**
223
     * ThemeSetDescriptionHandler constructor.
224
     */
225
    public function __construct()
226
    {
227
    }
228
229
    /**
230
     * @return string
231
     */
232
    public function getName()
233
    {
234
        return 'description';
235
    }
236
237
    /**
238
     * @param $parser
239
     * @param $data
240
     */
241
    public function handleCharacterData($parser, &$data)
242
    {
243
        switch ($parser->getParentTag()) {
244
            case 'template':
245
                $parser->setTempArr('description', $data);
246
                break;
247
            case 'image':
248
                $parser->setTempArr('description', $data);
249
                break;
250
            default:
251
                break;
252
        }
253
    }
254
}
255
256
/**
257
 * Class ThemeSetGeneratorHandler
258
 */
259
class ThemeSetGeneratorHandler extends XmlTagHandler
260
{
261
    /**
262
     * ThemeSetGeneratorHandler constructor.
263
     */
264
    public function __construct()
265
    {
266
    }
267
268
    /**
269
     * @return string
270
     */
271
    public function getName()
272
    {
273
        return 'generator';
274
    }
275
276
    /**
277
     * @param $parser
278
     * @param $data
279
     */
280
    public function handleCharacterData($parser, &$data)
281
    {
282
        switch ($parser->getParentTag()) {
283
            case 'themeset':
284
                $parser->setThemeSetData('generator', $data);
285
                break;
286
            default:
287
                break;
288
        }
289
    }
290
}
291
292
/**
293
 * Class ThemeSetNameHandler
294
 */
295
class ThemeSetNameHandler extends XmlTagHandler
296
{
297
    /**
298
     * ThemeSetNameHandler constructor.
299
     */
300
    public function __construct()
301
    {
302
    }
303
304
    /**
305
     * @return string
306
     */
307
    public function getName()
308
    {
309
        return 'name';
310
    }
311
312
    /**
313
     * @param $parser
314
     * @param $data
315
     */
316
    public function handleCharacterData($parser, &$data)
317
    {
318
        switch ($parser->getParentTag()) {
319
            case 'themeset':
320
                $parser->setThemeSetData('name', $data);
321
                break;
322
            case 'author':
323
                $parser->setTempArr('name', $data);
324
                break;
325
            default:
326
                break;
327
        }
328
    }
329
}
330
331
/**
332
 * Class ThemeSetEmailHandler
333
 */
334
class ThemeSetEmailHandler extends XmlTagHandler
335
{
336
    /**
337
     * ThemeSetEmailHandler constructor.
338
     */
339
    public function __construct()
340
    {
341
    }
342
343
    /**
344
     * @return string
345
     */
346
    public function getName()
347
    {
348
        return 'email';
349
    }
350
351
    /**
352
     * @param $parser
353
     * @param $data
354
     */
355
    public function handleCharacterData($parser, &$data)
356
    {
357
        switch ($parser->getParentTag()) {
358
            case 'author':
359
                $parser->setTempArr('email', $data);
360
                break;
361
            default:
362
                break;
363
        }
364
    }
365
}
366
367
/**
368
 * Class ThemeSetLinkHandler
369
 */
370
class ThemeSetLinkHandler extends XmlTagHandler
371
{
372
    /**
373
     * ThemeSetLinkHandler constructor.
374
     */
375
    public function __construct()
376
    {
377
    }
378
379
    /**
380
     * @return string
381
     */
382
    public function getName()
383
    {
384
        return 'link';
385
    }
386
387
    /**
388
     * @param $parser
389
     * @param $data
390
     */
391
    public function handleCharacterData($parser, &$data)
392
    {
393
        switch ($parser->getParentTag()) {
394
            case 'author':
395
                $parser->setTempArr('link', $data);
396
                break;
397
            default:
398
                break;
399
        }
400
    }
401
}
402
403
/**
404
 * Class ThemeSetTemplateHandler
405
 */
406
class ThemeSetTemplateHandler extends XmlTagHandler
407
{
408
    /**
409
     * ThemeSetTemplateHandler constructor.
410
     */
411
    public function __construct()
412
    {
413
    }
414
415
    /**
416
     * @return string
417
     */
418
    public function getName()
419
    {
420
        return 'template';
421
    }
422
423
    /**
424
     * @param $parser
425
     * @param $attributes
426
     */
427
    public function handleBeginElement($parser, &$attributes)
428
    {
429
        $parser->resetTempArr();
430
        $parser->setTempArr('name', $attributes['name']);
431
    }
432
433
    /**
434
     * @param $parser
435
     */
436
    public function handleEndElement($parser)
437
    {
438
        $parser->setTemplatesData($parser->getTempArr());
439
    }
440
}
441
442
/**
443
 * Class ThemeSetImageHandler
444
 */
445
class ThemeSetImageHandler extends XmlTagHandler
446
{
447
    /**
448
     * ThemeSetImageHandler constructor.
449
     */
450
    public function __construct()
451
    {
452
    }
453
454
    /**
455
     * @return string
456
     */
457
    public function getName()
458
    {
459
        return 'image';
460
    }
461
462
    /**
463
     * @param $parser
464
     * @param $attributes
465
     */
466
    public function handleBeginElement($parser, &$attributes)
467
    {
468
        $parser->resetTempArr();
469
        $parser->setTempArr('name', $attributes[0]);
470
    }
471
472
    /**
473
     * @param $parser
474
     */
475
    public function handleEndElement($parser)
476
    {
477
        $parser->setImagesData($parser->getTempArr());
478
    }
479
}
480
481
/**
482
 * Class ThemeSetModuleHandler
483
 */
484
class ThemeSetModuleHandler extends XmlTagHandler
485
{
486
    /**
487
     * ThemeSetModuleHandler constructor.
488
     */
489
    public function __construct()
490
    {
491
    }
492
493
    /**
494
     * @return string
495
     */
496
    public function getName()
497
    {
498
        return 'module';
499
    }
500
501
    /**
502
     * @param $parser
503
     * @param $data
504
     */
505
    public function handleCharacterData($parser, &$data)
506
    {
507
        switch ($parser->getParentTag()) {
508
            case 'template':
509
            case 'image':
510
                $parser->setTempArr('module', $data);
511
                break;
512
            default:
513
                break;
514
        }
515
    }
516
}
517
518
/**
519
 * Class ThemeSetFileTypeHandler
520
 */
521
class ThemeSetFileTypeHandler extends XmlTagHandler
522
{
523
    /**
524
     * ThemeSetFileTypeHandler constructor.
525
     */
526
    public function __construct()
527
    {
528
    }
529
530
    /**
531
     * @return string
532
     */
533
    public function getName()
534
    {
535
        return 'fileType';
536
    }
537
538
    /**
539
     * @param $parser
540
     * @param $data
541
     */
542
    public function handleCharacterData($parser, &$data)
543
    {
544
        switch ($parser->getParentTag()) {
545
            case 'template':
546
                $parser->setTempArr('type', $data);
547
                break;
548
            default:
549
                break;
550
        }
551
    }
552
}
553
554
/**
555
 * Class ThemeSetTagHandler
556
 */
557
class ThemeSetTagHandler extends XmlTagHandler
558
{
559
    /**
560
     * ThemeSetTagHandler constructor.
561
     */
562
    public function __construct()
563
    {
564
    }
565
566
    /**
567
     * @return string
568
     */
569
    public function getName()
570
    {
571
        return 'tag';
572
    }
573
574
    /**
575
     * @param $parser
576
     * @param $data
577
     */
578
    public function handleCharacterData($parser, &$data)
579
    {
580
        switch ($parser->getParentTag()) {
581
            case 'image':
582
                $parser->setTempArr('tag', $data);
583
                break;
584
            default:
585
                break;
586
        }
587
    }
588
}
589