Purifier::addCustomAttributes() - Code Metrics - Inspection of "Add support for HTML5 and custom definitions" - mewebstudio/Purifier - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#52)

unknown

created 2017-01-12 17:40 UTC

Purifier::addCustomAttributes() A

↳ Parent: Purifier

Complexity

Conditions	4
Paths	5

Size

Total Lines	14
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	4

Importance

Changes

Metric	Value
cc	4
eloc	8
nc	5
nop	2
dl	0
loc	14
ccs	2
cts	2
cp	1
crap	4
rs	9.2
c	0
b	0
f	0

<?php

namespace Mews\Purifier;

/**
 * Laravel 5 HTMLPurifier package
 *
 * @copyright Copyright (c) 2015 MeWebStudio
 * @version   2.0.0
 * @author    Muharrem ERİN
 * @contact [email protected]
 * @web http://www.mewebstudio.com
 * @date      2014-04-02
 * @license   MIT
 */

use Exception;
use HTMLPurifier;
use HTMLPurifier_Config;
use Illuminate\Config\Repository;
use Illuminate\Filesystem\Filesystem;

class Purifier
{

    /**
     * @var Filesystem
     */
    protected $files;

    /**
     * @var Repository
     */
    protected $config;

    /**
     * @var HTMLPurifier
     */
    protected $purifier;

    /**
     * Constructor
     *
     * @param Filesystem $files
     * @param Repository $config
     * @throws Exception
     */
    public function __construct(Filesystem $files, Repository $config)
    {
        $this->files = $files;
        $this->config = $config;

        $this->setUp();
    }

    /**
     * Setup
     *
     * @throws Exception
     */
    private function setUp()
    {
        if (!$this->config->has('purifier')) {
            throw new Exception('Configuration parameters not loaded!');
        }

        $this->checkCacheDirectory();

        // Create a new configuration object
        $config = HTMLPurifier_Config::createDefault();

        // Allow configuration to be modified
        if (!$this->config->get('purifier.finalize')) {
            $config->autoFinalize = false;
        }

        $config->loadArray($this->getConfig());
        
        // Load custom definition if set
        if ($definitionConfig = $this->config->get('purifier.settings.custom_definition')) {
	        $this->addCustomDefinition($definitionConfig, $config);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        
        // Load custom elements if set
        if ($elements = $this->config->get('purifier.settings.custom_elements')) {
	        if ($def = $config->maybeGetRawHTMLDefinition()) {
		        $this->addCustomElements($elements, $def);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	        }
        }
        
        // Load custom attributes if set
        if ($attributes = $this->config->get('purifier.settings.custom_attributes')) {
	        if ($def = $config->maybeGetRawHTMLDefinition()) {
		        $this->addCustomAttributes($attributes, $def);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	        }
        }

        // Create HTMLPurifier object
        $this->purifier = new HTMLPurifier($this->configure($config));
    }
    
    /**
	 * Add a custom definition
	 *
	 * @see http://htmlpurifier.org/docs/enduser-customize.html
	 * @param array $definitionConfig
	 * @param HTML_Purifier_Config $configObject Defaults to using default config
	 * 
	 * @return HTML_Purifier_Config $configObject
	 */
	private function addCustomDefinition(array $definitionConfig, $configObject = null)
	{
		if (!$configObject) {
			$configObject = HTMLPurifier_Config::createDefault();
			$configObject->loadArray($this->getConfig());
		}
		
		// Setup the custom definition
		$configObject->set('HTML.DefinitionID', $definitionConfig['id']);
		$configObject->set('HTML.DefinitionRev', $definitionConfig['rev']);
		
		// Enable debug mode
		if (!isset($definitionConfig['debug']) || $definitionConfig['debug']) {
			$configObject->set('Cache.DefinitionImpl', null);
		}
		
		// Start configuring the definition
		if ($def = $configObject->maybeGetRawHTMLDefinition()) {
			// Create the definition attributes
			if (!empty($definitionConfig['attributes'])) {
				$this->addCustomAttributes($definitionConfig['attributes'], $def);
			}
			
			// Create the definition elements
			if (!empty($definitionConfig['elements'])) {
				$this->addCustomElements($definitionConfig['elements'], $def);
			}
		}
		
		return $configObject;
	}
	
	/**
	 * Add provided attributes to the provided definition
	 *
	 * @param array $attributes
	 * @param HTMLPurifier_HTMLDefinition $definition
	 * 
	 * @return HTMLPurifier_HTMLDefinition $definition
	 */
	private function addCustomAttributes(array $attributes, $definition)
	{
		foreach ($attributes as $attribute) {
			// Get configuration of attribute
			$required = !empty($attribute[3]) ? true : false;
			$onElement = $attribute[0];
			$attrName = $required ? $attribute[1] . '*' : $attribute[1];
			$validValues = $attribute[2];
			
			$definition->addAttribute($onElement, $attrName, $validValues);
		}
		
		return $definition;
	}
	
	/**
	 * Add provided elements to the provided definition
	 *
	 * @param array $elements
	 * @param HTMLPurifier_HTMLDefinition $definition
	 * 
	 * @return HTMLPurifier_HTMLDefinition $definition
	 */
	private function addCustomElements(array $elements, $definition)
	{
		foreach ($elements as $element) {
			// Get configuration of element
			$name = $element[0];
			$contentSet = $element[1];
			$allowedChildren = $element[2];
			$attributeCollection = $element[3];
			$attributes = isset($element[4]) ? $element[4] : null;
			
			if (!empty($attributes)) {
				$definition->addElement($name, $contentSet, $allowedChildren, $attributeCollection, $attributes);
			} else {
				$definition->addElement($name, $contentSet, $allowedChildren, $attributeCollection);
			}
		}
	}

    /**
     * Check/Create cache directory
     */
    private function checkCacheDirectory()
    {
        $cachePath = $this->config->get('purifier.cachePath');

        if ($cachePath) {
            if (!$this->files->isDirectory($cachePath)) {
                $this->files->makeDirectory($cachePath, $this->config->get('purifier.cacheFileMode', 0755));
            }
        }
    }

    /**
     * @param HTMLPurifier_Config $config
     * 
     * @return HTMLPurifier_Config
     */
    protected function configure(HTMLPurifier_Config $config)
    {
        return HTMLPurifier_Config::inherit($config);
    }

    /**
     * @param null $config
     * 
     * @return mixed|null
     */
    protected function getConfig($config = null)
    {
        $default_config = [];
        $default_config['Core.Encoding'] = $this->config->get('purifier.encoding');
        $default_config['Cache.SerializerPath'] = $this->config->get('purifier.cachePath');
        $default_config['Cache.SerializerPermissions'] = $this->config->get('purifier.cacheFileMode', 0755);

        if (!$config) {
            $config = $this->config->get('purifier.settings.default');
        } elseif (is_string($config)) {
            $config = $this->config->get('purifier.settings.'.$config);
        }

        if (!is_array($config)) {
            $config = [];
        }

        $config = $default_config + $config;

        return $config;
    }

    /**
     * @param      $dirty
     * @param null $config
     * 
     * @return mixed
     */
    public function clean($dirty, $config = null)
    {
        if (is_array($dirty)) {
            return array_map(function ($item) use ($config) {
                return $this->clean($item, $config);
            }, $dirty);
        }

        return $this->purifier->purify($dirty, $this->getConfig($config));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Get HTMLPurifier instance.
     *
     * @return \HTMLPurifier
     */
    public function getInstance()
    {
        return $this->purifier;
    }
}


1		<?php
2
3		namespace Mews\Purifier;
4
5		/**
6		* Laravel 5 HTMLPurifier package
7		*
8		* @copyright Copyright (c) 2015 MeWebStudio
9		* @version 2.0.0
10		* @author Muharrem ERİN
11		* @contact [email protected]
12		* @web http://www.mewebstudio.com
13		* @date 2014-04-02
14		* @license MIT
15		*/
16
17		use Exception;
18		use HTMLPurifier;
19		use HTMLPurifier_Config;
20		use Illuminate\Config\Repository;
21		use Illuminate\Filesystem\Filesystem;
22
23		class Purifier
24		{
25
26		/**
27		* @var Filesystem
28		*/
29		protected $files;
30
31		/**
32		* @var Repository
33		*/
34		protected $config;
35
36		/**
37		* @var HTMLPurifier
38		*/
39		protected $purifier;
40
41		/**
42		* Constructor
43		*
44		* @param Filesystem $files
45		* @param Repository $config
46		* @throws Exception
47		*/
48	24	public function __construct(Filesystem $files, Repository $config)
49		{
50	24	$this->files = $files;
51	24	$this->config = $config;
52
53	24	$this->setUp();
54	18	}
55
56		/**
57		* Setup
58		*
59		* @throws Exception
60		*/
61	24	private function setUp()
62		{
63	24	if (!$this->config->has('purifier')) {
64	6	throw new Exception('Configuration parameters not loaded!');
65		}
66
67	18	$this->checkCacheDirectory();
68
69		// Create a new configuration object
70	18	$config = HTMLPurifier_Config::createDefault();
71
72		// Allow configuration to be modified
73	18	if (!$this->config->get('purifier.finalize')) {
74		$config->autoFinalize = false;
75		}
76
77	18	$config->loadArray($this->getConfig());
78
79		// Load custom definition if set
80	18	if ($definitionConfig = $this->config->get('purifier.settings.custom_definition')) {
81	18	$this->addCustomDefinition($definitionConfig, $config);
		0 ignored issues – show Documentation introduced 2017-01-12 17:43 UTC by Report Bug Copy Issue Report `$config` is of type `object<HTMLPurifier_Config>`, but the function expects a `object<Mews\Purifier\HTML_Purifier_Config>\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
82		}
83
84		// Load custom elements if set
85		if ($elements = $this->config->get('purifier.settings.custom_elements')) {
86	18	if ($def = $config->maybeGetRawHTMLDefinition()) {
87		$this->addCustomElements($elements, $def);
		0 ignored issues – show Documentation introduced 2017-01-12 17:43 UTC by Report Bug Copy Issue Report `$def` is of type `object<HTMLPurifier_HTMLDefinition>`, but the function expects a `object<Mews\Purifier\HTMLPurifier_HTMLDefinition>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
88	18	}
89		}
90	18
91	18	// Load custom attributes if set
92	3	if ($attributes = $this->config->get('purifier.settings.custom_attributes')) {
93	3	if ($def = $config->maybeGetRawHTMLDefinition()) {
94	18	$this->addCustomAttributes($attributes, $def);
		0 ignored issues – show Documentation introduced 2017-01-12 17:43 UTC by Report Bug Copy Issue Report `$def` is of type `object<HTMLPurifier_HTMLDefinition>`, but the function expects a `object<Mews\Purifier\HTMLPurifier_HTMLDefinition>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
95	18	}
96		}
97
98		// Create HTMLPurifier object
99		$this->purifier = new HTMLPurifier($this->configure($config));
100		}
101
102	18	/**
103		* Add a custom definition
104	18	*
105		* @see http://htmlpurifier.org/docs/enduser-customize.html
106		* @param array $definitionConfig
107		* @param HTML_Purifier_Config $configObject Defaults to using default config
108		*
109		* @return HTML_Purifier_Config $configObject
110		*/
111		private function addCustomDefinition(array $definitionConfig, $configObject = null)
112	18	{
113		if (!$configObject) {
114	18	$configObject = HTMLPurifier_Config::createDefault();
115	18	$configObject->loadArray($this->getConfig());
116	18	}
117	18
118		// Setup the custom definition
119	18	$configObject->set('HTML.DefinitionID', $definitionConfig['id']);
120	18	$configObject->set('HTML.DefinitionRev', $definitionConfig['rev']);
121	18
122	3	// Enable debug mode
123	3	if (!isset($definitionConfig['debug']) \|\| $definitionConfig['debug']) {
124		$configObject->set('Cache.DefinitionImpl', null);
125	18	}
126	3
127	3	// Start configuring the definition
128		if ($def = $configObject->maybeGetRawHTMLDefinition()) {
129	18	// Create the definition attributes
130		if (!empty($definitionConfig['attributes'])) {
131	18	$this->addCustomAttributes($definitionConfig['attributes'], $def);
132		}
133
134		// Create the definition elements
135		if (!empty($definitionConfig['elements'])) {
136		$this->addCustomElements($definitionConfig['elements'], $def);
137		}
138		}
139
140	3	return $configObject;
141		}
142	3
143	3	/**
144	3	* Add provided attributes to the provided definition
145	3	*
146		* @param array $attributes
147		* @param HTMLPurifier_HTMLDefinition $definition
148	3	*
149		* @return HTMLPurifier_HTMLDefinition $definition
150		*/
151		private function addCustomAttributes(array $attributes, $definition)
152		{
153		foreach ($attributes as $attribute) {
154		// Get configuration of attribute
155		$required = !empty($attribute[3]) ? true : false;
156	6	$onElement = $attribute[0];
157		$attrName = $required ? $attribute[1] . '*' : $attribute[1];
158	6	$validValues = $attribute[2];
159
160		$definition->addAttribute($onElement, $attrName, $validValues);
161		}
162
163		return $definition;
164		}
165
166		/**
167		* Add provided elements to the provided definition
168		*
169		* @param array $elements
170		* @param HTMLPurifier_HTMLDefinition $definition
171		*
172		* @return HTMLPurifier_HTMLDefinition $definition
173		*/
174		private function addCustomElements(array $elements, $definition)
175		{
176		foreach ($elements as $element) {
177		// Get configuration of element
178		$name = $element[0];
179		$contentSet = $element[1];
180		$allowedChildren = $element[2];
181		$attributeCollection = $element[3];
182		$attributes = isset($element[4]) ? $element[4] : null;
183
184		if (!empty($attributes)) {
185		$definition->addElement($name, $contentSet, $allowedChildren, $attributeCollection, $attributes);
186		} else {
187		$definition->addElement($name, $contentSet, $allowedChildren, $attributeCollection);
188		}
189		}
190		}
191
192		/**
193		* Check/Create cache directory
194		*/
195		private function checkCacheDirectory()
196		{
197		$cachePath = $this->config->get('purifier.cachePath');
198
199		if ($cachePath) {
200		if (!$this->files->isDirectory($cachePath)) {
201		$this->files->makeDirectory($cachePath, $this->config->get('purifier.cacheFileMode', 0755));
202		}
203		}
204		}
205
206		/**
207		* @param HTMLPurifier_Config $config
208		*
209		* @return HTMLPurifier_Config
210		*/
211		protected function configure(HTMLPurifier_Config $config)
212		{
213		return HTMLPurifier_Config::inherit($config);
214		}
215
216		/**
217		* @param null $config
218		*
219		* @return mixed\|null
220		*/
221		protected function getConfig($config = null)
222		{
223		$default_config = [];
224		$default_config['Core.Encoding'] = $this->config->get('purifier.encoding');
225		$default_config['Cache.SerializerPath'] = $this->config->get('purifier.cachePath');
226		$default_config['Cache.SerializerPermissions'] = $this->config->get('purifier.cacheFileMode', 0755);
227
228		if (!$config) {
229		$config = $this->config->get('purifier.settings.default');
230		} elseif (is_string($config)) {
231		$config = $this->config->get('purifier.settings.'.$config);
232		}
233
234		if (!is_array($config)) {
235		$config = [];
236		}
237
238		$config = $default_config + $config;
239
240		return $config;
241		}
242
243		/**
244		* @param $dirty
245		* @param null $config
246		*
247		* @return mixed
248		*/
249		public function clean($dirty, $config = null)
250		{
251		if (is_array($dirty)) {
252		return array_map(function ($item) use ($config) {
253		return $this->clean($item, $config);
254		}, $dirty);
255		}
256
257		return $this->purifier->purify($dirty, $this->getConfig($config));
		0 ignored issues – show Documentation introduced 2016-01-28 18:15 UTC by Report Bug Copy Issue Report `$this->getConfig($config)` is of type `array`, but the function expects a `object<HTMLPurifier_Config>\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
258		}
259
260		/**
261		* Get HTMLPurifier instance.
262		*
263		* @return \HTMLPurifier
264		*/
265		public function getInstance()
266		{
267		return $this->purifier;
268		}
269		}
270

mewebstudio / Purifier

Pull Request — master (#52)

Purifier::addCustomAttributes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like