EMTTret - Code Metrics - it-blaster/typograph-bundle - Measure and Improve Code Quality continuously with Scrutinizer

EMTTret D
last analyzed 2016-10-17 04:34 UTC

↳ Parent: Project

Complexity

Total Complexity

106

Size/Duplication

Total Lines	513
Duplicated Lines	11.31 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes

Metric	Value
wmc	106
lcom	2
cbo	1
dl	58
loc	513
rs	4.8717
c	0
b	0
f	0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	log()	0	5	2
A	error()	0	5	1
A	debug()	0	8	2
A	set_tag_layout_ifnotset()	0	5	2
A	set_tag_layout()	0	5	1
A	set_class_layout_prefix()	0	4	1
A	debug_on()	0	4	1
A	log_on()	0	4	1
A	getmethod()	0	6	3
A	_pre_parse()	11	11	4
A	_post_parse()	11	11	4
A	rule_order_sort()	0	6	3
F	apply_rule()	36	123	38
A	preg_replace_e()	0	10	2
A	thereplcallback()	0	6	2
B	_apply()	0	25	4
D	tag()	0	27	9
A	put_rule()	0	5	1
A	disable_rule()	0	5	1
A	enable_rule()	0	5	1
A	set()	0	4	1
B	is_on()	0	6	5
A	ss()	0	5	2
A	set_rule()	0	4	1
B	activate()	0	18	8
A	set_text()	0	6	1
A	apply()	0	8	3
A	pre_parse()	0	3	1
A	post_parse()	0	3	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like EMTTret 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. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

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 EMTTret, and based on these observations, apply Extract Interface, too.

<?php

/**
* Evgeny Muravjev Typograph, http://mdash.ru
* Version: 3.4 Gold Master
* Release Date: September 20, 2014
* Authors: Evgeny Muravjev & Alexander Drutsa  
*/

namespace Fenrizbes\TypographBundle\EMT;

/**
 * Базовый класс для группы правил обработки текста
 * Класс группы должен наследовать, данный класс и задавать
 * в нём EMTTret::rules и EMTTret::$name
 * 
 */
class EMTTret {
	
	/**
	 * Набор правил в данной группе, который задан изначально
	 * Его можно менять динамически добавляя туда правила с помощью put_rule
	 *
	 * @var unknown_type
	 */
	public    $rules;
	public    $title;
	
	
	private   $disabled = array();
	private   $enabled  = array();
	protected $_text= '';
	public $logging = false;
	public $logs    = false;
	public $errors  = false;	
	public $debug_enabled  = false;
	public $debug_info     = array();
	
	
	private $use_layout = false;
	private $use_layout_set = false;
	private $class_layout_prefix = false;
	
	public $class_names     = array();
	public $classes         = array();
	public $settings        = array();
	
	/**
	 * Защищенные теги
	 * 
	 * @todo привязать к методам из Jare_Typograph_Tool
	 */
	const BASE64_PARAGRAPH_TAG = 'cA==='; // p
	const BASE64_BREAKLINE_TAG = 'YnIgLw==='; // br / (с пробелом и слэшем)
	const BASE64_NOBR_OTAG = 'bm9icg==='; // nobr
	const BASE64_NOBR_CTAG = 'L25vYnI=='; // /nobr
	
	/**
	 * Типы кавычек
	 */
	const QUOTE_FIRS_OPEN = '&laquo;';
    const QUOTE_FIRS_CLOSE = '&raquo;';
    const QUOTE_CRAWSE_OPEN = '&bdquo;';
    const QUOTE_CRAWSE_CLOSE = '&ldquo;';
	
	
	private function log($str, $data = null)
	{
		if(!$this->logging) return;
		$this->logs[] = array('info' => $str, 'data' => $data);
	}

	private function error($info, $data = null)
	{
		$this->errors[] = array('info' => $info, 'data' => $data);
		$this->log('ERROR: '. $info , $data);
	}
	
	public function debug($place, &$after_text)
	{
		if(!$this->debug_enabled) return;
		$this->debug_info[] = array(
				'place' => $place,
				'text'  => $after_text,
			);
	}
	
	
	/**
	 * Установить режим разметки для данного Трэта если не было раньше установлено,
	 *   EMTLib::LAYOUT_STYLE - с помощью стилей
	 *   EMTLib::LAYOUT_CLASS - с помощью классов
	 *
	 * @param int $kind
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 */
	public function set_tag_layout_ifnotset($layout)
	{
		if($this->use_layout_set) return;
		$this->use_layout = $layout;
	}
	
	/**
	 * Установить режим разметки для данного Трэта,
	 *   EMTLib::LAYOUT_STYLE - с помощью стилей
	 *   EMTLib::LAYOUT_CLASS - с помощью классов
	 *   EMTLib::LAYOUT_STYLE|EMTLib::LAYOUT_CLASS - оба метода
	 *
	 * @param int $kind
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 */
	public function set_tag_layout($layout = EMTLib::LAYOUT_STYLE)
	{
		$this->use_layout = $layout;
		$this->use_layout_set = true;
	}
	
	public function set_class_layout_prefix($prefix)
	{
		$this->class_layout_prefix = $prefix;
	}
	
	
	public function debug_on()
	{
		$this->debug_enabled = true;
	}
	
	public function log_on()
	{
		$this->debug_enabled = true;
	}
	
	
	private function getmethod($name)
	{
		if(!$name) return false;
		if(!method_exists($this, $name)) return false;
		return array($this, $name);
	}
	
	private function _pre_parse()

	{
		$this->pre_parse();
		foreach($this->rules as $rule)
		{
			if(!isset($rule['init'])) continue;
			$m = $this->getmethod($rule['init']);
			if(!$m) continue;
			call_user_func($m);
		}
	}
	private function _post_parse()

	{
		foreach($this->rules as $rule)
		{
			if(!isset($rule['deinit'])) continue;
			$m = $this->getmethod($rule['deinit']);
			if(!$m) continue;
			call_user_func($m);
		}
		$this->post_parse();
	}
	
	private function rule_order_sort($a, $b)
	{
		if($a['order'] == $b['order']) return 0;
		if($a['order'] < $b['order']) return -1;
		return 1;
	}
	
	private function apply_rule($rule)
	{
		$name = $rule['id'];
		//$this->log("Правило $name", "Применяем правило");

		$disabled = (isset($this->disabled[$rule['id']]) && $this->disabled[$rule['id']]) || ((isset($rule['disabled']) && $rule['disabled']) && !(isset($this->enabled[$rule['id']]) && $this->enabled[$rule['id']]));
		if($disabled)
		{
			$this->log("Правило $name", "Правило отключено" . ((isset($rule['disabled']) && $rule['disabled'])? " (по умолчанию)" : ""));
			return;
		}
		if(isset($rule['function']) && $rule['function'])
		{
			if(!(isset($rule['pattern']) &&  $rule['pattern']))
			{
				if(method_exists($this, $rule['function']))

				{
					$this->log("Правило $name", "Используется метод ".$rule['function']." в правиле");
					
					call_user_func(array($this, $rule['function']));
					return;
				} 
				if(function_exists($rule['function']))

				{
					$this->log("Правило $name", "Используется функция ".$rule['function']." в правиле");
					
					call_user_func($rule['function']);
					return;
				}
				
				$this->error('Функция '.$rule['function'].' из правила '.$rule['id']. " не найдена");
				return ;
			} else {
				if(preg_match("/^[a-z_0-9]+$/i", $rule['function']))
				{
					if(method_exists($this, $rule['function']))

					{
						$this->log("Правило $name", "Замена с использованием preg_replace_callback с методом ".$rule['function']."");
						
						$this->_text = preg_replace_callback($rule['pattern'], array($this, $rule['function']), $this->_text);
						return;
					} 
					if(function_exists($rule['function']))

					{
						$this->log("Правило $name", "Замена с использованием preg_replace_callback с функцией ".$rule['function']."");
						
						$this->_text = preg_replace_callback($rule['pattern'], $rule['function'], $this->_text);
						return;
					}
					$this->error('Функция '.$rule['function'].' из правила '.$rule['id']. " не найдена");
				} else {
					$this->_text = preg_replace_callback($rule['pattern'],  create_function('$m', $rule['function']), $this->_text);
// Instead of
$function = create_function('$a, $b', 'return $a + $b');

// Better use
$function = function($a, $b) { return $a + $b; }
					$this->log('Замена с использованием preg_replace_callback с инлайн функцией из правила '.$rule['id']);
					return;
				}
				return ;
			}
		}
		
		if(isset($rule['simple_replace']) && $rule['simple_replace'])
		{
			if(isset($rule['case_sensitive']) && $rule['case_sensitive'])
			{
				$this->log("Правило $name", "Простая замена с использованием str_replace");
				$this->_text = str_replace($rule['pattern'], $rule['replacement'], $this->_text);
				return;
			}
			$this->log("Правило $name", "Простая замена с использованием str_ireplace");		
			$this->_text = str_ireplace($rule['pattern'], $rule['replacement'], $this->_text);
			return;
		}
		
		$pattern = $rule['pattern'];
		if(is_string($pattern)) $pattern = array($pattern);
		$eval = false;
		foreach($pattern as $patt)
		{
			$chr = substr($patt,0,1);
			$preg_arr = explode($chr, $patt);		
			if(strpos($preg_arr[count($preg_arr)-1], "e")!==false)
			{
				$eval = true;
				break;
			}
		}
		if(!$eval)
		{
			$this->log("Правило $name", "Замена с использованием preg_replace");		
			
			do {
				$this->_text = preg_replace($rule['pattern'], $rule['replacement'], $this->_text);
				if(!(isset($rule['cycled']) && $rule['cycled'])) break;
			} while(preg_match($rule['pattern'], $this->_text));
			
			return;
		}
		
		$this->log("Правило $name", "Замена с использованием preg_replace_callback вместо eval");		
		$k = 0;
		foreach($pattern as $patt)
		{
			$repl = is_string($rule['replacement']) ? $rule['replacement'] : $rule['replacement'][$k];
			
			$chr = substr($patt,0,1);
			$preg_arr = explode($chr, $patt);		
			if(strpos($preg_arr[count($preg_arr)-1], "e")!==false) // eval система
			{
				$preg_arr[count($preg_arr)-1] = str_replace("e","",$preg_arr[count($preg_arr)-1]);
				$patt = implode($chr, $preg_arr);
				$this->thereplacement = $repl;
				do {

					$this->_text = preg_replace_callback($patt, array($this, "thereplcallback"), $this->_text);
					if(!(isset($rule['cycled']) && $rule['cycled'])) break;
				} while(preg_match($patt, $this->_text));
				
			} else {
				do {

					$this->_text = preg_replace($patt, $repl, $this->_text);
					if(!(isset($rule['cycled']) && $rule['cycled'])) break;
				} while(preg_match($patt, $this->_text));
			}
			$k++;
		}
	}
	
	
	protected function preg_replace_e($pattern, $replacement, $text)
	{
		$chr = substr($pattern,0,1);
		$preg_arr = explode($chr, $pattern);				
		if(strpos($preg_arr[count($preg_arr)-1], "e")===false) return preg_replace($pattern, $replacement, $text);
		$preg_arr[count($preg_arr)-1] = str_replace("e","",$preg_arr[count($preg_arr)-1]);
		$patt = implode($chr, $preg_arr);
		$this->thereplacement = $replacement;
		return preg_replace_callback($patt, array($this, "thereplcallback"), $text);
	}
	
	private $thereplacement = "";
	private function thereplcallback($m)

	{
		$x = "";
		eval('$x = '.($this->thereplacement?$this->thereplacement:'""').';');

		return $x;
	}
	
	private function _apply($list)
	{
		$this->errors = array();

		$this->_pre_parse();
		
		$this->log("Применяется набор правил", implode(",",$list));
		
		$rulelist = array();
		foreach($list as $k)
		{			
			$rule = $this->rules[$k];
			$rule['id']    = $k;
			$rule['order'] = isset($rule['order'])? $rule['order'] : 5 ;
			$rulelist[] = $rule;
		}
		//usort($rulelist, array($this, "rule_order_sort"));

		
		foreach($rulelist as $rule)
		{
			$this->apply_rule($rule);			
			$this->debug($rule['id'], $this->_text);
		}
		
		$this->_post_parse();
	}
	
	
	/**
	 * Создание защищенного тега с содержимым
	 *
	 * @see 	EMTLib::build_safe_tag
	 * @param 	string $content
	 * @param 	string $tag
	 * @param 	array $attribute
	 * @return 	string
	 */
	protected function tag($content, $tag = 'span', $attribute = array())
	{
		if(isset($attribute['class']))
		{
			$classname = $attribute['class'];
			if($classname == "nowrap")
			{
				if(!$this->is_on('nowrap'))
				{
					$tag = "nobr";
					$attribute = array();
					$classname = "";
				}
			}
			if(isset($this->classes[$classname]))
			{
				$style_inline = $this->classes[$classname];
				if($style_inline) $attribute['__style'] = $style_inline;
			}
			$classname = (isset($this->class_names[$classname]) ? $this->class_names[$classname] :$classname);
			$classname = ($this->class_layout_prefix ? $this->class_layout_prefix : "" ).$classname;
			$attribute['class'] = $classname;
		}
		
		return EMTLib::build_safe_tag($content, $tag, $attribute,
				$this->use_layout === false? EMTLib::LAYOUT_STYLE  : $this->use_layout );
	}
	
	
	/**
	 * Добавить правило в группу
	 *
	 * @param string $name
	 * @param array $params
	 */
	public function put_rule($name, $params)
	{
		$this->rules[$name] = $params; 
		return $this;
	}

	/**
	 * Отключить правило, в обработке
	 *
	 * @param string $name
	 */
	public function disable_rule($name)
	{
		$this->disabled[$name] = true;
		unset($this->enabled[$name]);
	}
	
	/**
	 * Включить правило
	 *
	 * @param string $name
	 */
	public function enable_rule($name)
	{
		$this->enabled[$name] = true;
		unset($this->disabled[$name]);
	}
	
	/**
	 * Добавить настройку в трет
	 *
	 * @param string $key ключ
	 * @param mixed $value значение
	 */
	public function set($key, $value)
	{
		$this->settings[$key] = $value;
	}
	
	/**
	 * Установлена ли настройка
	 *
	 * @param string $key
	 */
	public function is_on($key)
	{
		if(!isset($this->settings[$key])) return false;
		$kk = $this->settings[$key];
		return ((strtolower($kk)=="on") || ($kk === "1") || ($kk === true) || ($kk === 1));
	}
	
	/**
	 * Получить строковое значение настройки
	 *
	 * @param unknown_type $key
	 * @return unknown
	 */
	public function ss($key)
	{
		if(!isset($this->settings[$key])) return "";
		return strval($this->settings[$key]);
	}
	
	/**
	 * Добавить настройку в правило
	 *
	 * @param string $rulename идентификатор правила 
	 * @param string $key ключ
	 * @param mixed $value значение
	 */
	public function set_rule($rulename, $key, $value)
	{
		$this->rules[$rulename][$key] = $value;
	}
	
	/**
	 * Включить правила, согласно списку
	 *
	 * @param array $list список правил
	 * @param boolean $disable выкллючить их или включить
	 * @param boolean $strict строго, т.е. те которые не в списку будут тоже обработаны
	 */
	public function activate($list,$disable =false, $strict = true)
	{
		if(!is_array($list)) return ;
		
		foreach($list as $rulename)
		{
			if($disable) $this->disable_rule($rulename); else $this->enable_rule($rulename);
		}
		
		if($strict)
		{
			foreach($this->rules as $rulename => $v)
			{
				if(in_array($rulename, $list)) continue;
				if(!$disable) $this->disable_rule($rulename); else $this->enable_rule($rulename);
			}
		}
	}
	
	public function set_text(&$text)
	{
		$this->_text = &$text;
		$this->debug_info = array();
		$this->logs = array();

	}
	

	/**
	 * Применить к тексту
	 *
	 * @param string $text - текст к которому применить
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 * @param mixed $list - список правил, null - все правила
	 * @return string
	 */
	public function apply($list = null)
	{
		if(is_string($list)) $rlist = array($list);
		elseif(is_array($list)) $rlist = $list;
		else $rlist = array_keys($this->rules);
		$this->_apply($rlist);
		return $this->_text;
	}
	
	
	
	
	/**
	 * Код, выполняем до того, как применить правила
	 *
	 */
	public function pre_parse()
	{
	}
	
	/**
	 * После выполнения всех правил, выполняется этот метод
	 *
	 */
	public function post_parse()
	{
	}
	
	
}

it-blaster / typograph-bundle

EMTTret D last analyzed 2016-10-17 04:34 UTC