ProcessHannaCode.module

<?php namespace ProcessWire;

require_once(__DIR__ . '/HannaCodes.php');

/**
 * Process Hanna Code
 *
 * Copyright (C) 2021 by Ryan Cramer 
 * Licensed under MPL 2.0
 * https://processwire.com
 * 
 * @property array $typeLabels
 * @property TextformatterHannaCode $hanna
 *
 */

class ProcessHannaCode extends Process implements ConfigurableModule {

	/**
	 * Return information about this module (required)
	 *
	 */
	public static function getModuleInfo() {
		return array(
			'title' => 'Hanna Code', 
			'summary' => 'Easily insert any complex HTML, Javascript or PHP output in your ProcessWire content by creating your own Hanna code tags.',
			'version' => 32, 
			'permission' => 'hanna-code', 
			'permissions' => array(
				'hanna-code' => 'List and view Hanna Codes',
				'hanna-code-edit' => 'Add/edit/delete Hanna Codes (text/html, javascript only)',
				'hanna-code-php' => 'Add/edit/delete Hanna Codes (text/html, javascript and PHP)'
			),
			'useNavJSON' => true,
			'icon' => 'sun-o', 
			'requires' => 'TextformatterHannaCode, ProcessWire>=3.0.133'
		); 
	}

	/**
	 * The name that will be used for the page this module creates
	 *
	 */
	const pageName = 'hanna-code';

	/**
	 * Default theme for the Ace Editor
	 *
	 */
	const defaultAceTheme = 'monokai';

	/**
	 * Default keybinding for the Ace Editor
	 *
	 */
	const defaultAceKeybinding = 'none';

	/**
	 * Default height (in pixels) for the Ace Editor
	 *
	 */
	const defaultAceHeight = '400';

	/**
	 * Default ace behavior bitmask
	 *
	 */
	const defaultAceBehaviors = 0;

	/**
	 * Ace editor version
	 *
	 */
	const aceVersion = '1.10.1';

	/**
	 * Ace behavior pairing 
	 *
	 */
	const aceBehaviorPair = 2; 

	/**
	 * Ace behavior 
	 *
	 */
	const aceBehaviorWrap = 4; 

	/**
	 * Instance of TextformatterHannaCode
	 * 
	 * @var TextformatterHannaCode|null
	 *
	 */
	protected $textformatter = null;

	/**
	 * Allow HannaCodes to be edited and saved?
	 * 
	 * @var bool|null 
	 * 
	 */
	protected $allowSave = null;

	/**
	 * @var string 
	 * 
	 */
	protected $saveInfo = '';

	/**
	 * Construct
	 * 
	 */
	public function __construct() {
		$this->set('aceTheme', self::defaultAceTheme); 
		$this->set('aceKeybinding', self::defaultAceKeybinding); 
		$this->set('aceHeight', self::defaultAceHeight); 
		$this->set('aceBehaviors', self::defaultAceBehaviors); 
		parent::__construct();
	}

	/**
	 * This is an optional initialization function called before any execute functions.
	 *
	 */
	public function init() {
		parent::init(); // required
		
		$this->set('typeLabels', array(
			HannaCode::typeHTML => $this->_('Text/HTML'),
			HannaCode::typeJS => $this->_('Javascript code'),
			HannaCode::typePHP => $this->_('PHP code'),
		));
		
		$config = $this->wire()->config;
		$hannaEdit = $config->get('HannaCodeEdit');
		$recommended = $this->_('This is recommended for security on live/production sites.');
		
		if(is_bool($hannaEdit)) {
			$this->allowSave = $hannaEdit;
		} else {
			$this->allowSave = $config->debug;
		}
		
		if($this->allowSave) {
			if($hannaEdit === true) {
				$suggestion = '$config-&gt;HannaCodeEdit = false;';
			} else {
				$suggestion = '$config-&gt;debug = false;';
			}
			$this->saveInfo = sprintf(
				$this->_('Please set %s in your {file} file when finished editing Hanna Codes.') . " $recommended", 
				"<code>$suggestion</code>"
			);
		} else {
			$this->saveInfo = 
				'<strong>' . $this->_('“Edit” and “Add” features are currently disabled.') . '</strong> ' . 
				$recommended . ' ' . 
				sprintf(
					$this->_('To enable, edit {file} and temporarily set %s or %s'),
					'<code>$config-&gt;debug = true;</code>', 
					'<code>$config-&gt;HannaCodeEdit = true;</code>'
				) . ' ' . 
				$this->_('(Remember to reverse this change when you are done editing/adding Hanna Codes, especially on live sites).'); 
		} 
		
		$this->saveInfo = str_replace('{file}', '<u>/site/config.php</u>', $this->saveInfo);
	}
	
	/**
	 * @param array $options
	 * @return string|array
	 *
	 */
	public function ___executeNavJSON(array $options = array()) {
		$options['add'] = 'edit/';
		$options['edit'] = 'edit/?id={id}';
		$options['items'] = $this->hannaCodes()->getAll();
		$options['itemLabel'] = 'name';
		return parent::___executeNavJSON($options);
	}

	/**
	 * @return TextformatterHannaCode
	 * 
	 */
	public function textformatter() {
		if($this->textformatter === null) {
			$this->textformatter = $this->wire()->modules->get('TextformatterHannaCode'); 
		}
		return $this->textformatter;
	}

	/**
	 * @return HannaCodes
	 * 
	 */
	public function hannaCodes() {
		return $this->textformatter()->hannaCodes();
	}

	/**
	 * Set property
	 * 
	 * @param string $key
	 * @param mixed $value
	 * @return self|Process
	 * 
	 */
	public function set($key, $value) {
		if($key == 'aceBehaviors' && is_array($value)) {
			$bitmask = 0; 
			foreach($value as $v) $bitmask = $bitmask | $v; 
			$value = $bitmask;
		}
		return parent::set($key, $value); 
	}

	/**
	 * Does user have permission?
	 * 
	 * @param string $name
	 * @return bool
	 * 
	 */
	protected function hasPermission($name) {

		$user = $this->wire()->user; 
		if($user->isSuperuser()) return true; 

		if($name === 'hanna-code-edit' || $name === 'hanna-code-php') {
			$permission = $this->permissions->get($name); 
			// before new permissions, there was just hanna-code which assigned all access
			// so if new permissions aren't installed, we fallback to old behavior
			if(!$permission->id) $name = 'hanna-code'; 
		}
		
		$has = $user->hasPermission($name); 

		if(!$has && $name === 'hanna-code-edit') {
			// if user has hanna-code-php permission, then hanna-code-edit is assumed
			$has = $user->hasPermission('hanna-code-php');
		}

		return $has; 
	}

	/**
	 * Is given HannaCode or type editable?
	 * 
	 * @param HannaCode|int $h
	 * @return bool
	 * 
	 */
	protected function editable($h) {
		if($h instanceof HannaCode) {
			$isPHP = $h->isPHP();
		} else {
			$type = (int) $h;
			$isPHP = $type === HannaCode::typePHP || $type & HannaCode::typePHP; 
		}
		if($isPHP) return $this->hasPermission('hanna-code-php');
		return $this->hasPermission('hanna-code-edit'); 
	}

	/**
	 * List Hanna Codes
 	 *
	 */
	public function ___execute() {
		
		$sanitizer = $this->wire()->sanitizer;
		$modules = $this->wire()->modules;
		$typeLabels = $this->typeLabels;
		$sort = $this->wire()->input->get->text('sort');
		$editable = $this->hasPermission('hanna-code-edit');
		$welcome = '';
		$out = '';
		
		if(empty($sort)) $sort = 'name';
		$hannaCodes = $this->hannaCodes()->getAll($sort); 

		if(count($hannaCodes)) {
			/** @var MarkupAdminDataTable $table */
			$table = $modules->get('MarkupAdminDataTable');
			$table->setEncodeEntities(false);
			$table->headerRow(array(
				$this->_x('Name', 'list-table'),
				$this->_x('Tag', 'list-table'),
				$this->_x('Type', 'list-table'),
				$this->_x('Modified', 'list-table'),
				$this->_x('Accessed', 'list-table')
			));
			foreach($hannaCodes as $h) {
				$type = $h->isNotConsuming() ? $h->type - HannaCode::typeNotConsuming : $h->type;
				$table->row(array(
					$sanitizer->entities($h->name) => "edit/?id=$h->id",
					"<code>" . $sanitizer->entities($this->tagExample($h)) . "</code>",
					$typeLabels[$type],
					wireRelativeTimeStr($h->modified),
					wireRelativeTimeStr($h->accessed)
				));
			}
			$out .= $table->render();
			
		} else if($editable) {
			// no Hanna codes
			if($this->allowSave) {
				$welcome = $this->_('No Hanna Codes yet, go ahead and add one!');
			} else {
				$welcome = 
					$this->_('There are no Hanna Codes yet! Please follow the instructions below to start using Hanna Code.') . 
					'<br /><br />' . 
					$this->saveInfo;
			}
		} else {
			$welcome = $this->_('There are no Hanna Codes to display.');
		}
	
		if($welcome) $out .= "<p>$welcome</p>";

		if($editable) {
			if($this->allowSave) {
				/** @var InputfieldButton $button1 */
				$button1 = $modules->get('InputfieldButton');
				$button1->attr('id', 'button_add');
				$button1->attr('value', $this->_('Add New'));
				$button1->attr('href', './edit/');
				$button1->showInHeader(true);

				/** @var InputfieldButton $button2 */
				$button2 = $modules->get('InputfieldButton');
				$button2->attr('id', 'button_import');
				$button2->attr('value', $this->_('Import'));
				$button2->attr('href', './import/');
				$button2->setSecondary(true);

				$out .= $button1->render() . $button2->render();
			}
		
			if(count($hannaCodes) || $this->allowSave) {
				$out .= "<p class='description'>$this->saveInfo</p>";
			}
		}
	

		return $out;
	}

	/**
	 * Execute import of Hanna code
	 * 
	 * @return string
	 * @throws WireException
	 * @throws WirePermissionException
	 * 
	 */
	public function ___executeImport() {
		
		$modules = $this->wire()->modules;
		$input = $this->wire()->input;
		$session = $this->wire()->session;

		if(!$this->hasPermission('hanna-code-edit')) throw new WireException("No permission"); 
		if(!$this->allowSave) throw new WireException("Save disabled");
		
		/** @var InputfieldForm $form */
		$form = $modules->get('InputfieldForm'); 

		/** @var InputfieldTextarea $f */
		$f = $modules->get('InputfieldTextarea');
		$f->attr('id+name', 'hc_import'); 
		$f->label = $this->_("Paste in Import Data"); 
		$form->add($f); 

		/** @var InputfieldSubmit $f */
		$f = $modules->get('InputfieldSubmit');
		$f->attr('name', 'submit_import'); 
		$form->add($f); 

		$this->headline($this->_("Import Hanna Code")); 

		if(!$input->post('submit_import')) return $form->render();

		$form->processInput($input->post); 
		$data = $form->get('hc_import')->value; 
		
		if(!preg_match('{!HannaCode:([^:]+):(.*?)/!HannaCode}s', $data, $matches)) {
			throw new WireException("Unrecognized Hanna Code format");
		}
		
		$name = $matches[1]; 
		$data = $matches[2]; 
		$data = base64_decode($data); 
		if($data === false) {
			throw new WireException("Failed to base64 decode import data");
		}
		
		$data = json_decode($data, true); 
		if($data === false) {
			throw new WireException("Failed to json decode import data");
		}
		
		if(empty($data['name']) || empty($data['code'])) {
			throw new WireException("Import data does not contain all required fields");
		}
		
		$h = $this->hannaCodes()->get($name);
		if($h->id) {
			$this->error($this->_('Hanna Code with that name already exists')); 
			$session->redirect('../'); 
			return '';
		}

		$data['type'] = (int) $data['type']; 
		if($data['type'] & HannaCode::typePHP && !$this->hasPermission('hanna-code-php')) {
			throw new WireException("You don't have permission to add/edit PHP Hanna Codes"); 
		}
		
		$h = new HannaCode();
		$this->wire($h);
		$h->name = $name;
		$h->type = $data['type'];
		$h->code = $data['code'];
		$h->modified = time();
		
		if($this->hannaCodes()->save($h)) {
			$this->message($this->_('Imported Hanna Code:') . " $name"); 
			$session->redirect("../edit/?id=$h->id"); 
		} else {
			throw new WireException("Error importing Hanna code"); 
		}
		
		return '';
	}

	/**
	 * Execute test of Hanna code
	 * 
	 * @throws WireException
	 * 
	 */
	public function ___executeTest() {
		$name = $this->wire()->sanitizer->pageName($this->wire()->input->get('name')); 
		if(empty($name)) throw new WireException('Nothing provided to test'); 
		$tag = $this->textformatter()->openTag . $name . $this->textformatter()->closeTag; 
		$t = new TemplateFile();
		$this->wire($t);
		$t->setFilename(__DIR__ . '/test-results.php'); 
		$t->set('textformatter', $this->textformatter());
		$t->set('tag', $tag);
		echo $t->render();
		exit; 
	}

	/**
	 * Execute edit of Hanna code
	 * 
	 * Called when the URL is this module's page URL + "/something/"
	 * 
	 * @return string
	 *
	 */
	public function ___executeEdit() {
		
		$input = $this->wire()->input;
		$modules = $this->wire()->modules;
		$config = $this->wire()->config;
		$user = $this->wire()->user;

		// add a breadcrumb that returns to our main page 
		$this->breadcrumb('../', $this->page->title); 
		$modules->get('JqueryWireTabs'); 
		

		$id = (int) $input->get('id');
		$h = $id ? $this->hannaCodes()->get($id) : $this->hannaCodes()->getNew();
		
		if($h->id) {
			if($h->id !== $id) throw new WireException('Unknown HannaCode');
			$exportData = array(
				'name' => $h->name, 
				'type' => $h->type, 
				'code' => $this->hannaCodes()->packCode($h->code, $h->attrs), 
			); 
			$attr = '';
			foreach($h->attrs as $attrName => $attrValue) {
				$attr .= strlen($attrValue) ? "$attrName=$attrValue\n" : "$attrName\n";
			}

			$this->headline($this->_("Edit Hanna Code:") . " $h->name");
		} else {
			$attr = '';
			$exportData = null;
			$this->headline($this->_("Adding New Hanna Code")); 
			if(!$this->editable($h)) throw new WireException("You don't have permission to add new Hanna Codes"); 
			if(!$this->allowSave) {
				$this->warning($this->saveInfo, Notice::allowMarkup);
				$this->wire()->session->redirect('../');
			}
		}

		$editable = $this->editable($h); 
		if(!$editable) $this->message($this->_('This Hanna Code is read-only')); 

		/** @var InputfieldForm $form */
		$form = $modules->get('InputfieldForm'); 
		$form->attr('id', 'HannaCodeEdit'); 
		$form->attr('action', './');
		$form->attr('method', 'post');

		$tab = $this->newTab(array('title' => $this->_('Basics')));
	
		/** @var InputfieldName $nameField */
		$nameField = $modules->get('InputfieldName'); 
		$nameField->attr('name', 'hc_name'); 
		$nameField->attr('value', $h->name); 
		$nameField->description = $this->_('Any combination of these characters: -_.a-zA-Z0-9 (i.e. letters, numbers, hyphens, underscores, periods, no spaces)');
		$nameField->icon = 'id-badge';
		$tab->add($nameField); 

		/** @var InputfieldRadios $typeField */
		$typeField = $modules->get('InputfieldRadios'); 
		$typeField->attr('name', 'hc_type'); 
		foreach($this->typeLabels as $key => $label) {
			if($key === HannaCode::typePHP && !$this->editable($key) && $h->codeType() != HannaCode::typePHP) continue; 
			$typeField->addOption($key, $label); 
		}
		$typeField->attr('value', $h->codeType()); 
		$typeField->label = $this->_('Code type'); 
		$typeField->icon = 'code';
		$typeField->optionColumns = 1; 
		$tab->add($typeField); 

		$yes = $this->_('Yes');
		$no = $this->_('No'); 
		$value = $h->isNotConsuming() ? 1 : 0;
		/** @var InputfieldRadios $f */
		$f = $modules->get('InputfieldRadios'); 
		$f->attr('name', 'hc_not_consuming'); 
		$f->addOption(0, $yes);
		$f->addOption(1, $no);
		$f->attr('value', $value); 
		$f->label = $this->_('Replace surrounding HTML tag?') . ' [' . ($value ? $no : $yes) . ']';
		$f->icon = 'scissors';
		$f->description = $this->_('Should the output of this Hanna Code replace the immediate surrounding HTML tag if it is the only thing in the tag? If your Hanna Code outputs block-level HTML (like `<ul>` or `<p>` tags), this should probably be yes.'); 
		$f->collapsed = Inputfield::collapsedYes; 
		$f->optionColumns = 1;
		$tab->add($f);

		/** @var InputfieldTextarea $f */
		$f = $modules->get('InputfieldTextarea'); 
		$f->attr('id+name', 'hc_attr'); 
		$f->attr('value', trim($attr)); 
		$f->label = $this->_('Attributes'); 
		$f->icon = 'map-signs';
		$f->description = $this->_('Optional but recommended if using attributes with PHP or Javascript: Enter one attribute name per line that your Hanna code uses. To specify a default value, enter it as `attr=value`. If no default specified, value defaults to a blank string.');
		$f->notes = $this->_('Examples:') . 
			"\n`" . $this->_('some_attribute') . '`' . 
			"\n`" . $this->_('attribute_with_default=The Default Value') . '`';
		$f->collapsed = Inputfield::collapsedBlank;
		$tab->add($f); 

		$form->add($tab); 

		$tab = $this->newTab(array('title' => $this->_('Code')));
		
		$userData = $user->meta('HannaCode'); 
		if(!is_array($userData)) $userData = array();

		$userDefaults = array(
			'aceTheme' => self::defaultAceTheme, 
			'aceKeybinding' => self::defaultAceKeybinding, 
			'aceHeight' => self::defaultAceHeight, 
			'aceBehaviors' => self::defaultAceBehaviors
		);
		
		$userData = array_merge($userDefaults, $userData); 
		
		if($userData['aceHeight'] < 100) $userData['aceHeight'] = self::defaultAceHeight; 
		if($userData['aceHeight'] > 2000) $userData['aceHeight'] = 2000;
		
		$code = $h->code; 
		$openPHP = '<' . '?php';
		if((empty($code) || trim($code) === $openPHP) && $h->isPHP()) {
			$code = "$openPHP namespace ProcessWire;\n";
		}
		
		/** @var InputfieldTextarea $f */
		$f = $modules->get('InputfieldTextarea');
		$f->attr('id+name', 'hc_code');
		$f->attr('value', $code);
		$f->label = $this->_('Code editor');
		$f->icon = 'code';
		$f->attr('rows', 20);
		$f->attr('data-theme', $userData['aceTheme']);
		$f->attr('data-keybinding', $userData['aceKeybinding']);
		$f->attr('data-height', $userData['aceHeight']);
		$f->attr('data-behaviors', (int) $userData['aceBehaviors']);
		$tab->add($f);

		/** @var InputfieldFieldset $fs */
		$fs = $modules->get('InputfieldFieldset');
		$fs->label = $this->_('Code editor options'); 
		$fs->icon = 'sliders';
		$fs->description = $this->_('Settings selected here will be remembered with your user account when you “Save” this Hanna Code.'); 
		$fs->collapsed = true; 
		$tab->add($fs);

		foreach($this->getModuleConfigInputfields($userData) as $f) {
			$f->notes = '';
			$fs->add($f); 
		}

		/** @var InputfieldMarkup $f */
		$f = $modules->get('InputfieldMarkup'); 
		$f->label = $this->_('PHP and Javascript Usage Notes'); 
		$f->value = file_get_contents(dirname(__FILE__) . '/usage-notes.php'); 
		$f->collapsed = Inputfield::collapsedYes; 
		$f->icon = 'info-circle';
		$tab->add($f); 

		$form->add($tab); 

		if($exportData) {
			$tab = $this->newTab(array('title' => $this->_('Export')));
			/** @var InputfieldTextarea $f */
			$f = $modules->get('InputfieldTextarea');
			$f->attr('id+name', 'hc_export'); 
			$f->attr('value', "!HannaCode:$h->name:" . base64_encode(json_encode($exportData)) . "/!HannaCode"); 
			$f->label = $tab->attr('title');
			$f->description = $this->_('To export this Hanna code and import somewhere else, copy the contents of this field and paste into the import box somewhere else.'); 
			$f->notes = $this->_('If you have made any changes in other tabs, make sure to save before copying the export data here.');
			$f->icon = 'paper-plane';
			$tab->add($f); 
			$form->add($tab); 
		}

		if($id && $editable) {
			$tab = $this->newTab(array('title' => $this->_('Delete'), 'id' => 'HannaCodeDelete'));
			/** @var InputfieldCheckbox $f */
			$f = $modules->get('InputfieldCheckbox'); 
			$f->attr('name', 'hc_delete'); 
			$f->attr('value', $id); 
			$f->label = $tab->attr('title');
			$f->label2 = $this->_('Delete this Hanna Code'); 
			$f->icon = 'trash-o';
			$f->description = $this->_('Check the box and click “Save” to permanently delete this Hanna Code.'); 
			$tab->add($f); 
			$form->add($tab); 
		}

		if($this->input->get('test')) {
			$label = $this->_('Test results');
			$tab = $this->newTab(array('title' => $label, 'id' => 'HannaCodeTestResults'));
			/** @var InputfieldMarkup $f */
			$f = $modules->get('InputfieldMarkup');
			$f->label = $label;
			$f->description = 
				$this->_('This test is here primarily to check for parse errors. Blank output indicates that there were no parse errors.') . ' ' . 
				$this->_('You should still test in a real-world context before assuming it works. Output is in the box below.');
			$f->icon = 'flask';
			list($ifr, $scr) = array('iframe', 'script');
			$f->value = 
				"<$ifr frameborder='0' id='HannaCodeTestPort' src='../test/?name=$h->name&modal=1'></$ifr>" . 
				"<$scr>$(document).ready(function() { setTimeout(function() { $('#_HannaCodeTestResults').click(); }, 500); });</$scr>";
			$tab->add($f); 
			$form->add($tab); 
		} 

		/** @var InputfieldHidden $f */
		$f = $modules->get('InputfieldHidden'); 
		$f->attr('name', 'hc_id'); 
		$f->attr('value', $id); 
		$form->add($f); 

		if($editable && $this->allowSave) { 
			/** @var InputfieldSubmit $f */
			$f = $modules->get('InputfieldSubmit'); 
			$f->showInHeader(true);
			$f->attr('id+name', 'hc_save'); 
			$f->attr('value', $this->_('Save')); 
			$form->add($f); 

			if($id) { 
				/** @var InputfieldSubmit $f */
				$f = $modules->get('InputfieldSubmit'); 
				$f->attr('id+name', 'hc_save_test'); 
				$f->attr('value', $this->_('Save & Test')); 
				$f->setSecondary(true);
				$form->add($f); 
			}

			/** @var InputfieldSubmit $f */
			$f = $modules->get('InputfieldSubmit'); 
			$f->attr('id+name', 'hc_save_exit'); 
			$f->setSecondary(true);
			$f->attr('value', $this->_('Save & Exit')); 
			$form->add($f);
			
			if($input->post('hc_save') || $input->post('hc_save_exit') || $input->post('hc_save_test')) {
				$this->save($form);
			}
		
			$icon = wireIconMarkup('warning');
			$form->appendMarkup .= "<p class='description'>$icon $this->saveInfo</p>";
			
		} else if($editable) {
			$notice = new NoticeMessage($this->saveInfo, Notice::allowMarkup);
			$notice->icon = 'sun-o fa-spin';
			$notice->class = 'HannaCode';
			$this->wire()->notices->add($notice);
		}

		$config->scripts->add($config->urls('ProcessHannaCode') . "ace-" . self::aceVersion . "/src-min/ace.js"); 
	
		return $form->render();
	}

	/**
	 * Save Hanna code
	 * 
	 * @param InputfieldForm $form
	 * @return bool
	 * @throws WireException
	 *
	 */
	protected function save($form) {
		
		$input = $this->wire()->input;
		$session = $this->wire()->session;
		$permissionError = $this->_('You do not have permission to save this'); 
		
		if(!$this->hasPermission('hanna-code-edit')) throw new WireException($permissionError); 

		$id = (int) $input->post('hc_id'); 
		$type = (int) $input->post('hc_type'); 
		$delete = (int) $input->post('hc_delete'); 
		$exitAfterSave = $input->post('hc_save_exit'); 
		$testAfterSave = $input->post('hc_save_test'); 
		$prevType = 0;
		$phpType = HannaCode::typePHP; 
		
		if($id) {
			$h = $this->hannaCodes()->get($id); 
			$prevType = $h->id ? $h->type : 0;
		} else {
			$h = $this->hannaCodes()->getNew();
		}

		if(($type === $phpType || $prevType === $phpType) && !$this->hasPermission('hanna-code-php')) {
			throw new WireException($permissionError); 
		}
		if($type !== $phpType && $type !== HannaCode::typeJS && $type !== HannaCode::typeHTML) {
			throw new WireException('Unknown HannaCode type'); 
		}
		
		$form->processInput($input->post);

		if($delete && $delete === $id) {
			$this->hannaCodes()->delete($h);
			$this->message($this->_('Deleted Hanna Code')); 
			$this->session->redirect('../'); 
		}

		// session specific
		$userData = array(
			'aceTheme' => $form->getChildByName('aceTheme')->val(),
			'aceKeybinding' => $form->getChildByName('aceKeybinding')->val(),
			'aceHeight' => $form->getChildByName('aceHeight')->val(),
		);
		$value = 0;	
		foreach($form->getChildByName('aceBehaviors')->val() as $behavior) {
			$value = $value | (int) $behavior;	
		}
		$userData['aceBehaviors'] = $value; 
		$this->wire()->user->meta('HannaCode', $userData); 

		// specific to this hanna code
		$name = $form->getChildByName('hc_name')->val(); 
		$type = (int) $form->getChildByName('hc_type')->val(); 
		$code = $form->getChildByName('hc_code')->val(); 
		$notc = $form->getChildByName('hc_not_consuming')->val(); 	
		$attr = $form->getChildByName('hc_attr')->val();

		if($notc) {
			$type = $type | HannaCode::typeNotConsuming; 
		}

		if(empty($name)) {
			$form->getChildByName('hc_name')->error('Name is required'); 
			return false;
		}

		if(empty($code)) $code = '';
		
		$h->name = $name;
		$h->type = $type;
		$h->code = $code;
		$h->attrs = $attr; 
		$h->modified = time();
		
		$result = $this->hannaCodes()->save($h);

		if($result) {
			if(!$id) $id = $h->id;
			$this->message($this->_("Saved Hanna Code") . " - $h->name"); 				
			if($exitAfterSave) {
				$session->redirect("../?sort=-modified");
			} else if($testAfterSave) {
				$session->redirect("./?id=$id&test=1");
			} else {
				$session->redirect("./?id=$id");
			}
		} else {
			$this->error("Error saving"); 
		}
		
		return $result;
	}

	/**
	 * @param array $attrs
	 * @return InputfieldWrapper
	 * 
	 */
	protected function newTab(array $attrs = array()) {
		$tab = new InputfieldWrapper();
		$this->wire($tab);
		$tab->addClass('WireTab');
		foreach($attrs as $name => $value) {
			$tab->attr($name, $value);
		}
		return $tab;
	}

	/**
	 * Render a tag example for given HannaCode
	 * 
	 * @param HannaCode $h
	 * @return string
	 * 
	 */
	protected function tagExample(HannaCode $h) {
		$textformatter = $this->textformatter();
		$openTag = $textformatter->openTag;
		$closeTag = $textformatter->closeTag;
		$name = $h->name;
		$attrs = '';
		foreach($h->attrs() as $attrName => $attrValue) {
			$attrs .= " $attrName=\"$attrValue\"";
		}
		if(preg_match('/[a-zA-Z0-9]$/', $openTag)) $name = " name=\"$name\"";
		return $openTag . $name . $attrs . $closeTag;
	}

	/**
	 * Called only when your module is installed
	 *
	 * This version creates a new page with this Process module assigned. 
	 *
	 */
	public function ___install() {

		// create the page our module will be assigned to
		$page = new Page();
		$page->template = 'admin';
		$page->name = self::pageName; 

		// installs to the admin "Setup" menu ... change as you see fit
		$page->parent = $this->pages->get($this->config->adminRootPageID)->child('name=setup');
		$page->process = $this; 

		// we will make the page title the same as our module title
		// but you can make it whatever you want
		$info = self::getModuleInfo();
		$page->title = $info['title'];

		// save the page
		$page->save();

		// tell the user we created this page
		$this->message("Created Page: $page->path"); 
	}

	/**
	 * Called only when your module is uninstalled
	 *
	 * This should return the site to the same state it was in before the module was installed. 
	 *
	 */
	public function ___uninstall() {

		// find the page we installed, locating it by the process field (which has the module ID)
		// it would probably be sufficient just to locate by name, but this is just to be extra sure.
		$moduleID = $this->modules->getModuleID($this); 
		$page = $this->pages->get("template=admin, process=$moduleID, name=" . self::pageName); 

		if($page->id) {
			// if we found the page, let the user know and delete it
			$this->message("Deleting Page: $page->path"); 
			$page->delete();
		}
	}

	/**
	 * Get Ace Editor file options for themes and keybindings
	 * 
	 * @return array
	 *
	 */ 
	protected static function getAceOptions() {

		$options = array(
			'themes' => array(),
			'keybindings' => array(),
		);

		$dir = new \DirectoryIterator(dirname(__FILE__) . '/ace-' . self::aceVersion . '/src-min/'); 

		foreach($dir as $file) {
			$name = $file->getBasename();
			if(preg_match('/^(theme|keybinding)-([^.]+)\.js$/', $name, $matches)) {
				if($matches[1] == 'theme') {
					$options['themes'][] = $matches[2]; 
				} else if($matches[1] == 'keybinding') {
					$options['keybindings'][] = $matches[2]; 
				}
			}
		}
		
		sort($options['themes']); 
		sort($options['keybindings']); 

		return $options;
	}

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

		$form = new InputfieldWrapper();
		$this->wire($form);
		$aceOptions = self::getAceOptions();
		$modules = $this->wire()->modules;

		if(!isset($data['aceKeybinding'])) $data['aceKeybinding'] = self::defaultAceKeybinding;
		if(!isset($data['aceBehaviors'])) $data['aceBehaviors'] = self::defaultAceBehaviors;

		/** @var InputfieldSelect $f */
		$f = $modules->get('InputfieldSelect'); 
		$f->label = $this->_('Theme'); 
		$f->attr('id+name', 'aceTheme');
		foreach($aceOptions['themes'] as $theme) $f->addOption($theme); 
		$f->attr('value', !empty($data['aceTheme']) ? $data['aceTheme'] : self::defaultAceTheme); 
		$f->notes = $this->_('See the [Ace Editor demo](https://ace.c9.io/build/kitchen-sink.html) to preview what the different themes look like.'); 
		$f->columnWidth = 34;
		$form->add($f); 

		/** @var InputfieldSelect $f */
		$f = $modules->get('InputfieldSelect'); 
		$f->label = $this->_('Keyboard'); 
		$f->attr('id+name', 'aceKeybinding');
		$f->addOption(self::defaultAceKeybinding, __('Normal')); 
		foreach($aceOptions['keybindings'] as $keybinding) $f->addOption($keybinding); 
		$f->attr('value', !empty($data['aceKeybinding']) ? $data['aceKeybinding'] : self::defaultAceKeybinding); 
		$f->columnWidth = 33;
		$f->required = true;
		$form->add($f); 

		/** @var InputfieldInteger $f */
		$f = $modules->get('InputfieldInteger'); 
		$f->label = $this->_('Editor Height (in pixels)'); 
		$f->attr('id+name', 'aceHeight'); 
		$f->inputType = 'number';
		$f->attr('value', isset($data['aceHeight']) ? $data['aceHeight'] : self::defaultAceHeight); 
		$f->columnWidth = 33;
		$form->add($f); 

		/** @var InputfieldCheckboxes $f */
		$f = $modules->get('InputfieldCheckboxes'); 
		$f->attr('id+name', 'aceBehaviors'); 
		$f->label = $this->_('Behaviors');
		$f->addOption(self::aceBehaviorPair, $this->_('Pair: auto-pairing of special characters, like quotation marks, parenthesis, or brackets.')); 
		$f->addOption(self::aceBehaviorWrap, $this->_('Wrap: wrapping the selection with characters such as brackets when such a character is typed in.')); 
		$value = array();
		
		if(is_array($data['aceBehaviors'])) {
			$value = $data['aceBehaviors'];
		} else {
			if($data['aceBehaviors'] & self::aceBehaviorPair) $value[] = self::aceBehaviorPair; 
			if($data['aceBehaviors'] & self::aceBehaviorWrap) $value[] = self::aceBehaviorWrap; 
		}
		$f->attr('value', $value); 
		$form->add($f);

		return $form;
		
	}

	
}