TextformatterHannaCode.module

<?php

/**
 * ProcessWire Hanna Code Textformatter
 *
 * Based loosely on the WordPress Hana Code Insert module at: http://wordpress.org/plugins/hana-code-insert/
 *
 * Copyright (C) 2016 by Ryan Cramer 
 * Licensed under MPL 2.0
 * https://processwire.com
 *
 */

class TextformatterHannaCode extends Textformatter implements ConfigurableModule {

	public static function getModuleInfo() {
		return array(
			'title' => __('Hanna Code Text Formatter', __FILE__), 
			'version' => 20, 
			'summary' => __('Easily insert any complex HTML, Javascript or PHP output in your ProcessWire content by creating your own Hanna code tags.', __FILE__),
			'installs' => 'ProcessHannaCode',
			'icon' => 'sun-o', 
			); 
	}

	/**
	 * Hanna code types
	 *
	 */
	const TYPE_HTML = 0;
	const TYPE_JS = 1; 
	const TYPE_PHP = 2; 

	/**
	 * Flag that indicates Hanna code should not consume surrounding <p> tags
	 *
	 */
	const TYPE_NOT_CONSUMING = 4; 

	/**
	 * Defaults for configuration
	 *
	 */
	const DEFAULT_OPEN_TAG = '[[';
	const DEFAULT_CLOSE_TAG = ']]';

	/**
	 * Path where we cache PHP Hanna code files
	 * 
	 * @var string
	 *
	 */
	protected $cachePath = '';

	/**
	 * Open tag setting
	 *
	 */
	protected $openTag = '';
	
	/**
	 * Close tag setting
	 *
	 */
	protected $closeTag = '';

	/**
	 * Page object passed to the Textformatter's formatValue() function
	 * 
	 * @var Page
	 *
	 */
	protected $page;

	/**
	 * Field object passed to the Textformatter's formatValue() function
	 * 
	 * @var Field
	 *
	 */
	protected $field;

	/**
	 * $value passed to the Textformatter's formatValue() function
	 * 
	 * @var string
	 *
	 */
	protected $value; 

	/**
	 * $name of the current Hanna code
	 * 
	 * @var string
	 *
	 */
	protected $name; 

	/**
	 * Initialize defaults
	 *
	 */
	public function __construct() {
		$this->openTag = self::DEFAULT_OPEN_TAG;
		$this->closeTag = self::DEFAULT_CLOSE_TAG; 
		$this->cachePath = $this->wire('config')->paths->cache . 'HannaCode/';
	}

	/**
	 * For the ConfigurableModule interface
	 * 
	 * @param string $key
	 * @param mixed $value
	 * @return void
	 *
	 */
	public function __set($key, $value) {
		// so that Hanna code can modify the original full value
		if($key == 'value') {
			$this->value = $value; 
		} else if($key == 'openTag' || $key == 'closeTag') {
			$this->$key = $value; 
		} else {
			parent::set($key, $value);
		}
	}

	/**
	 * Values that can be retrieved from the $hanna variable passed to all Hanna codes
	 * 
	 * @param string $key
	 * @return mixed
	 *
	 */
	public function __get($key) {
		if($key == 'field') return $this->field;
			else if($key == 'value') return $this->value; 
			else if($key == 'name') return $this->name; 
			else if($key == 'openTag') return $this->openTag; 
			else if($key == 'closeTag') return $this->closeTag; 
		return parent::__get($key); 
	}

	/**
	 * For the Textformatter interface
	 * 
	 * @param Page $page
	 * @param Field $field
	 * @param string $value
	 *
	 */
	public function formatValue(Page $page, Field $field, &$value) {
		
		$openTag = $this->openTag; 
		$closeTag = $this->closeTag; 
		// exit early when possible
		if(strpos($value, $openTag) === false) return;
		if(strpos($value, $closeTag) === false) return;

		$regx =	'!' . 
			'(?:<([a-zA-Z]+)' .		    // 1=optional HTML open tag 
			'[^>]*>[\s\r\n]*)?' . 		// HTML open tag attributes and whitespace, if present	
			preg_quote($openTag, '!') . // Hanna Code open tag	
			'(.+?)' . 			        // 2=tag contents
			preg_quote($closeTag, '!') .// Hanna Code close tag
			'(?:[\s\r\n]*</(\1)>)?' . 	// 3=optional close HTML tag
			'!';	

		if(!preg_match_all($regx, $value, $matches)) return;

		$prevPage = $this->page;
		$prevField = $this->field;
		$prevValue = $this->value;
		$this->page = $page;
		$this->field = $field;
		$this->value = $value;

		// save output formatting state and then ensure it is ON
		$of = $this->page->of();
		if(!$of) $this->page->of(true);

		foreach($matches[2] as $key => $expression) {
			
			if(strpos($expression, '=')) {
				// expression with attrs
				$attrs = $this->getAttributes($expression); 
				if(!isset($attrs['name'])) continue; 
			} else {	
				// no attribute expression
				$attrs = array('name' => $expression); 
			}

			$name = $this->wire('sanitizer')->name($attrs['name']); 
			$this->name = $name; 
			unset($attrs['name']);

			$consume = true; 
			$replacement = $this->getReplacement($name, $attrs, $consume); 
			if($replacement === false) continue; 

			$openHTML = $matches[1][$key]; 
			$closeHTML = $matches[3][$key]; 

			if($consume && $openHTML == $closeHTML) {
				$this->value = str_replace($matches[0][$key], $replacement, $this->value); 
			} else {
				$this->value = str_replace("$openTag$expression$closeTag", $replacement, $this->value); 
			}
		}

		// restore output formatting state
		if(!$of) $this->page->of(false);

		$value = $this->value; 	
		
		$this->value = $prevValue;
		$this->page = $prevPage;
		$this->field = $prevField;
	}

	/**
	 * Process $value to render any Hanna tags within it (for API use)
	 *
	 * @param string $value
	 * @param Page|null $page
	 * @param field|null $field
	 * @return string
	 *
	 */
	public function render($value, Page $page = null, Field $field = null) {
		if(is_null($page)) $page = $this->wire('page');
		if(is_null($field)) $field = new Field(); 
		$this->formatValue($page, $field, $value);
		return $value; 
	}

	/**
	 * Find an return an array of all attributes in string $expression
	 *
	 * @param string $expression
	 * @return array
	 *
	 */
	protected function getAttributes($expression) {

		$attrs = array();

		$regx = 
			'!(?:^|\b)' .		    // beginning or boundary 
			'([-_a-z0-9]+)' .	    // 1. attribute name 
			'\s*=\s*' . 		    // Equals
			'(' .				    // 2. attribute value, possibly with quotes
				'(["\']|&quot;)' .	// 3. open quote 
				'.*?' . 		    // attribute value unquoted
				'\3' .			    // close quote	
			'|' .				    // OR 
				'[^\'",\s]*' .		// unquoted value...
			'),?' . 			    // optional comma, per PW selector style
			'!i'; 

		if(!preg_match_all($regx, $expression, $matches)) {
			return $attrs; 
		}

		foreach($matches[1] as $key => $name) {
			$attrs[$name] = trim($matches[2][$key], "'\"");
		}

		if(empty($attrs['name'])) {
			// allow for optional [[name_here attrs]] expression
			// where the 'name' isn't specifically called out as an attribute
			// but is the first symbol in the expression
			if(preg_match('!^([-_a-z0-9]+)([\s,]|$)!i', $expression, $matches)) {
				$attrs['name'] = $matches[1]; 
			}
		}

		return $attrs; 
	}

	/**
	 * Given the Hanna code name and attributes, retrieve the replacement
	 *
	 * @param string $name
	 * @param array $attrs
	 * @param bool $consume Whether it should consume surrounding tags or not
	 * @return string
	 *
	 */
	protected function getReplacement($name, array $attrs, &$consume) {

		$database = $this->wire('database');

		$sql = 'SELECT `id`, `type`, `code` FROM hanna_code WHERE `name`=:name';
		$query = $database->prepare($sql); 
		$query->bindValue(':name', $name, PDO::PARAM_STR); 
		$query->execute();
		if(!$query->rowCount()) return false;
		list($id, $type, $code) = $query->fetch(PDO::FETCH_NUM); 
		$query->closeCursor();

		$query = $database->prepare("UPDATE hanna_code SET accessed=:time WHERE id=:id"); 
		$query->bindValue(":time", time()); 
		$query->bindValue(":id", $id); 
		$query->execute();

		unset($attrs['name']);

		// set default attributes, that haven't already been set by user
		$defaultAttrs = $this->extractDefaultCodeAttrs($code); 
		foreach($defaultAttrs as $key => $value) {
			if(!array_key_exists($key, $attrs)) $attrs[$key] = $value; 
		}

		if($type & self::TYPE_JS) $value = $this->getJS($name, $code, $attrs); 
			else if($type & self::TYPE_PHP) $value = $this->getPHP($name, $code, $attrs); 
			else $value = $code; 

		// Populate whether or not the surrounding tags should be consumed
		$consume = !($type & self::TYPE_NOT_CONSUMING);

		return $value; 
	}

	/**
	 * Create the output for a JS-based Hanna code
	 *
	 * @param string $name Hanna code name
	 * @param string $code Code to insert
	 * @param array $attrs Attributes to include as variables
	 * @return string
	 *
	 */
	protected function getJS($name, $code, array $attrs) {

		if($name) {}
		$vars = '';
		$attr = 'var attr = { ';

		// build a series of $js var statements to represent the attribute name=values
		foreach($attrs as $key => $value) {
			$value = str_replace('"', '\\"', $value); 
			$attr .= "$key: \"$value\", ";
			$vars .= "\nvar $key=attr.$key;";
		}

		$attr = rtrim($attr, ", ") . " }; ";
		$vars = $attr . $vars;

		if(strpos(ltrim($code), '<script') !== 0) {
			// if script tag not already present, add it
			$js = "<scr" . "ipt type='text/javascript'>$vars\n$code\n</script>";

		} else if(strlen($vars)) {
			// script tag is already present
			// if we have vars to insert, put them after the opening script, but before the code
			preg_match('/\s*(<script[^>]*>)(.*)/si', $code, $matches); 
			$js = $matches[1] . $vars . $matches[2]; 
		} else {
			// script tag already present and no vars to insert
			$js = $code; 
		}
		
		return $js;
	}

	/**
	 * Create the output for a PHP-based Hanna code
	 *
	 * @param string $name Hanna code name
	 * @param string $code Code to insert
	 * @param array $attrs Attributes to include as variables
	 * @return string
	 * @throws WireException
	 *
	 */
	protected function getPHP($name, $code, array $attrs) {

		if(!is_dir($this->cachePath)) if(!wireMkdir($this->cachePath)) {
			throw new WireException("Unable to create cache path: $this->cachePath"); 
		}

		$file = $this->cachePath . $name . '.php';
		$code = trim($code);
		$openPHP = '<' . '?php'; 
		$firstLine = 'if(!defined("PROCESSWIRE")) die("no direct access");';

		if(substr($code, 0, strlen($openPHP)) !== $openPHP) {
			// prepend open PHP tag to code if not already present
			$code = "$openPHP\n$firstLine\n$code"; 
		} else {
			// otherwise insert our $firstLine security check
			$code = str_replace($openPHP, "$openPHP\n$firstLine\n", $code); 
		}

		if(is_file($file) && file_get_contents($file) === $code) {
			// file already there and same as what's in the DB
		} else {
			// write new file or overwrite existing
			if(!file_put_contents($file, $code, LOCK_EX)) throw new WireException("Unable to write file: $file"); 
			if($this->wire('config')->chmodFile) chmod($file, octdec($this->wire('config')->chmodFile));	
		}

		$t = new TemplateFile($file); 

		// populate user specified attrs
		foreach($attrs as $key => $value) $t->set($key, $value); 

		// also populate them all into an $attrs array, if preferred
		$t->set('attr', $attrs); 

		// populate API variables
		foreach($this->wire('all') as $key => $value) {
			if($key != 'page') $t->set($key, $value); 
		}

		// populate $page and $hanna variables that are context specific
		// note $page may be different from wire('page')
		$t->set('page', $this->page);
		$t->set('hanna', $this); 

		return $t->render();
	}

	/**
	 * Extract default attributes stored in the code block
	 *
	 * Extracts hc_attr\nkey=value\nkey2=value2\nhc_attr to array('key' => $value, 'key2' => 'value2'); 
	 * and removes the section from $code
	 *
	 * @param string $code
	 * @return array
	 *
	 */
	public function extractDefaultCodeAttrs(&$code) {

		$pos = strpos($code, 'hc_attr*/'); 
		if($pos === false) return array();

		$attrStr = trim(substr($code, 9, $pos-9)); 
		$code = trim(substr($code, $pos+10)); 
		$lines = explode("\n", $attrStr); 
		$attrs = array();

		foreach($lines as $line) {
			$pos = strpos($line, '='); 
			$name = substr($line, 0, $pos); 
			$value = substr($line, $pos); 
			$name = trim($name, "\r\n="); 
			// filter out API variable names and reserved words
			if(empty($name)) continue; 
			if(!is_null($this->wire($name)) || in_array($name, array('name', 'hanna', 'attr'))) $name = "_$name";
			$value = trim($value, "\r\n=\""); 
			$attrs[$name] = $value; 
		}

		return $attrs;
	}


	/**
	 * Install this module
	 *
	 */
	public function ___install() {

		$sql = 	
			"CREATE TABLE hanna_code (" . 
			"`id` int unsigned NOT NULL AUTO_INCREMENT PRIMARY KEY, " . 
			"`name` varchar(128) NOT NULL, " . 
			"`type` tinyint NOT NULL DEFAULT 0, " . 
			"`code` text, " . 
			"`modified` int unsigned NOT NULL default 0, " . 
			"`accessed` int unsigned NOT NULL default 0, " . 
			"UNIQUE `name`(`name`)"  . 
			")";
		try {
			$this->wire('database')->exec($sql); 
		} catch(Exception $e) {
			$this->error($e->getMessage()); 
		}
	}

	/**
	 * Uninstall this module
	 *
	 */
	public function ___uninstall() {
		parent::___uninstall(); 

		$sql = "DROP TABLE hanna_code"; 

		try {
			$this->wire('database')->exec($sql);
		} catch(Exception $e) {
			$this->error($e->getMessage()); 
		}

		if($this->cachePath && is_dir($this->cachePath)) {
			$this->message("Removing cache path: $this->cachePath"); 
			wireRmdir($this->cachePath, true); 
		}
	}

	/**
	 * Module configuration screen
	 * 
	 * @param array $data
	 * @return InputfieldWrapper
	 *
	 */
	public static function getModuleConfigInputfields(array $data) {

		$inputfields = new InputfieldWrapper();

		/** @var InputfieldText $f */
		$f = wire('modules')->get('InputfieldText'); 
		$f->attr('name', 'openTag'); 
		$f->attr('value', empty($data['openTag']) ? self::DEFAULT_OPEN_TAG : $data['openTag']); 
		$f->label = __('Open Tag'); 
		$f->columnWidth = 50;
		$inputfields->add($f); 

		$f = wire('modules')->get('InputfieldText'); 
		$f->attr('name', 'closeTag'); 
		$f->attr('value', empty($data['closeTag']) ? self::DEFAULT_CLOSE_TAG : $data['closeTag']); 
		$f->label = __('Close Tag'); 
		$f->columnWidth = 50;
		$inputfields->add($f); 

		return $inputfields;
	}

}