Difference between revisions of "Xmlwiki.php"

From Organic Design wiki
m
 
(234 intermediate revisions by 6 users not shown)
Line 1: Line 1:
−
<php>
+
{{legacy}}
−
<?php
+
<source lang="php">
 
# xmlWiki - MediaWiki XML Hack
 
# xmlWiki - MediaWiki XML Hack
−
# Nad - 2005-05-18
+
# Nad - Started: 2005-05-18
  
−
# CSS STYLES
+
# Exit if not included from index.php
−
# the are accessed via http, so their article url can be referred to locally in the html
+
defined('MEDIAWIKI') or die('xmlwiki.php must be included from MediaWiki\'s index.php!');
−
# - maybe make the default request 'raw' and must specifically request 'view'
+
if (php(3)) die('xmlWiki cannot run on less than PHP4!');
  
−
# LATER:
+
# Add the rest of the hooks
−
# allow XIncludes to build large docs from others
+
$wgHooks['PreParser'][] = 'xwPreParserHook';
−
# allow docBook and DSSSL content
+
$wgHooks['ParserBeforeStrip'][] = 'xwPreParserHook';
 +
$wgHooks['ArticleSaveComplete'][] = 'xwPostParserHook';
 +
$wgHooks['ParserAfterTidy'][] = 'xwPostParserHook';
 +
$wgHooks['Input'][] = 'xwInputHook';
 +
$wgHooks['Output'][] = 'xwOutputHook';
 +
$wgHooks['ParserFunctions'][] = 'xwTransclusionSecurity';
 +
function xwTransclusionSecurity(&$title,&$text,$args,$argc) {
 +
$title = ereg_replace('^:','',$title);
 +
if ($title && !xwArticleAccess($title)) { $text = 'Sorry, article not readable!'; $title = false; }
 +
return true;
 +
}
 +
 
 +
# System globals
 +
$xwDebug = false;
 +
$xwMessages = array();
 +
$xwArticleCache = array();
 +
$xwStyleSheets = array();
 +
$xwTemplate = null;
 +
$xwParserHookCalled = false;
 +
$xwSkinHookCalled = false;
 +
$xwMsgToken = '<!--xwMsg-->';
 +
$xwCssToken = '<!--xwCss-->';
 +
$xwScript = $wgScript;
 +
$xwTransformID = 1;
 +
 
 +
# User globals
 +
$xwUserName = ucwords( $wgUser->mName );
 +
$xwAnonymous = ereg( "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+", $xwUserName );
 +
$xwUserSYS = null;
 +
$xwUserGroups = array($xwUserName, 'anyone');
 +
$xwEdit = isset($_REQUEST['action']) && ($_REQUEST['action'] == 'edit');
 +
$xwView = (!isset($_REQUEST['action']) || (isset($_REQUEST['action']) && ($_REQUEST['action'] == 'view')));
 +
$xwRaw = isset($_REQUEST['action']) && ($_REQUEST['action'] == 'raw');
 +
$xwPreview = isset($_REQUEST['wpPreview']);
 +
$xwSave = isset($_REQUEST['wpSave']);
 +
 
 +
# Article globals
 +
$xwArticleTitle = $wgTitle->getPrefixedText();
 +
$xwArticle = $xwPreview ? $wgRequest->gettext('wpTextbox1') : $wgArticle->getContent(false);
 +
$xwArticleProperties = null;
 +
$xwIsProperties = preg_match('/^xml:.+$/i', $xwArticleTitle);
 +
$xwIsSystem = preg_match('/^sys:.+$/i', $xwArticleTitle);
 +
$xwIsUser = preg_match('/^user:.+$/i', $xwArticleTitle);
 +
$xwIsSpecial = preg_match('/^special:.+$/i', $xwArticleTitle);
 +
$xwIsAdmin = false;
 +
$xwArticleReadableBy = null;
 +
$xwArticleWritableBy = null;
  
−
# ---------------------------------------------------------------------------------------------------------------------- #
+
# Get default properties article
−
# SCRIPT CONTENTS
+
$xwDefaultProperties = $xwDefaultPropertiesXML = xwArticleContent( 'default-properties.xml', false );
 +
xwDomificateArticle( $xwDefaultProperties, 'defaults' );
  
−
# INIT
+
# Get user-system-article and extract users' groups from it if any
−
# - do admin and exit if running directly
+
$xwUserSYS = xwArticleContent( "sys:$xwUserName" );
−
# - get wiki/request env
+
xwDomificateArticle( $xwUserSYS, "sys:$xwUserName" );
−
# - get article
+
$xwUserGroups = array_merge( $xwUserGroups, xwGetListByTagname( $xwUserSYS, 'groups' ) );
−
# - permissions
 
−
# - build env (if action=raw, env is empty but a header is added)
 
−
# INPUT
 
−
# - validate xml and report error or,
 
−
# - process form-input (backslashes etc if necessary)
 
−
# OUTPUT
 
−
# - trap MediaWiki output
 
−
# - extract content and links
 
−
# - if view/preview/raw, do transform:
 
−
#  - replace view/preview with transformed article
 
−
# - render output
 
−
# - if saving, foreach in publish-list,
 
−
#  - do transform but with specified env
 
−
#  - publish
 
−
# TRANSFORM
 
−
# - process dom-article (pass PT,XSLT list and DOM-article, returns DOM-result)
 
−
# - if docType is an xwArticle, see above
 
−
# TRANSFORMS
 
−
# - document transforms
 
−
# - image transforms
 
−
# - layout transforms
 
−
# - database table transforms
 
−
# FUNCTIONS
 
−
# - get article
 
−
# - etxract hrefs from text
 
−
# - message/log
 
−
# ADMIN
 
−
# - enable/disable patch
 
  
−
# ---------------------------------------------------------------------------------------------------------------------- #
+
# Read user-prefs
−
# INIT
+
xwGetProperty( $xwUserSYS, 'xpath:/user/debug', $xwDebug );
  
−
# If xmlwiki.php requested directly, return admin page
+
# Get article-meta-file and extract article-perms
−
if (eregi("xmlwiki\\.php", $_SERVER['SCRIPT_NAME'])) xwAdminPage();
+
if ( $xwIsSystem ) $xwArticleReadableBy = $xwArticleWritableBy = array('admin');
 
else {
 
else {
  
−
# Otherwise set up xmlWiki global environment ready for input and output processing
+
# Get xml:article (self if already xml:*)
−
$xwArticleTitle = $wgTitle->mTextform;
+
if ( $p = $xwIsProperties ? xwDomificateArticle( $xwArticle ) : xwArticleProperties( $xwArticleTitle ) )
−
$xwArticle = xwGetArticle($xwArticleTitle);
+
 
−
$xwDocType = null;
+
# Start with default-properties and merge article props (so new transforms on top)
−
$xwRoot = null;
+
$xwArticleProperties =
 +
'<?xml version="1.0" standalone="yes"?>
 +
<!DOCTYPE xmlwiki:properties SYSTEM "xmlwiki-properties.dtd">
 +
<properties/>';
 +
xwDomificateArticle( $xwArticleProperties, 'CreateProperties' );
 +
xwMergeDOM( $xwArticleProperties, $xwDefaultProperties );
 +
xwMergeDOM( $xwArticleProperties, $p );
  
−
$xwEdit = isset($_REQUEST['action'])&&($_REQUEST['action'] == 'edit');
+
$xwArticleReadableBy = xwGetListByTagname( $xwArticleProperties, 'read' );
−
$xwView = isset($_REQUEST['action'])&&($_REQUEST['action'] == 'view');
+
$xwArticleWritableBy = xwGetListByTagname( $xwArticleProperties, 'write' );
−
$xwRaw = isset($_REQUEST['action'])&&($_REQUEST['action'] == 'raw');
+
if ( $xwIsProperties ) $xwArticleProperties = false;
−
$xwPreview = isset($_REQUEST['wpPreview']);
+
}
−
$xwSave = isset($_REQUEST['wpSave']);
+
if ( !is_object( $xwArticleProperties ) ) $xwArticleProperties = $xwDefaultProperties;
 +
if ( $xwIsSpecial || !count( $xwArticleReadableBy ) ) $xwArticleReadableBy = array('anyone');
 +
if ( !count($xwArticleWritableBy) ) $xwArticleWritableBy = array('anyone');
  
−
$xwUserName = $wgUser->mName;
+
# If no language specified in properties, guess from name and content
−
$xwUserArticle = xwGetArticle("User:$xwUserName");
+
if ( !xwGetProperty( $xwArticleProperties, 'language', $xwLanguage ) )
−
$xwReadable = true;
+
xwSetProperty( $xwArticleProperties, 'language', xwArticleType( $xwArticleTitle, $xwArticle ) );
−
$xwWritable = true;
 
  
−
$xwMessages = array();
+
# Set perms for this request
−
$xwArticleCache = array();
+
if ($xwDebug) xwMessage('PERMISSIONS:','green');
−
$xwEnv = array();
+
if (in_array('admin', $xwUserGroups)) $xwIsAdmin = $xwReadable = $xwWritable = true;
 +
else {
 +
$xwReadable = 0 < count(array_intersect($xwArticleReadableBy, $xwUserGroups));
 +
$xwWritable = 0 < count(array_intersect($xwArticleWritableBy, $xwUserGroups));
 +
}
 +
if ($xwDebug) {
 +
xwMessage('Groups: '.join(', ', $xwUserGroups));
 +
xwMessage('Readable ('.($xwReadable?'yes':'no').'): '.join(', ', $xwArticleReadableBy));
 +
xwMessage('Writable ('.($xwWritable?'yes':'no').'): '.join(', ', $xwArticleWritableBy));
 +
}
  
−
# If article is an object,
+
# Divert to access-denied article if not readable
−
if (is_object($xwArticle)) {
+
if (!$xwReadable) {
−
# Get doc info
+
$action = 'view';
−
$xwDocType = $xwArticle->doctype->name;
+
$xwSave = $xwEdit = false;
−
$xwRoot = $xwArticle->document_element();  
+
}
−
# Get perms
 
−
$xwUserGroups[] = $xwUserName; // This allows users to be specified in permissions-lists in addition to groups
 
−
$xwReadable = null; # True if this article is readable by this user
 
−
$xwWritable = null; # True if this article is writeable by this user
 
−
}
 
  
−
# Build default transform environment (later from prefs, site etc)
+
# Handle security for Move
−
if ($xwRaw) {
+
if (!$xwIsAdmin and ($target = $_REQUEST['target']) ) {
−
# Raw article is requested, so env is empty
+
if ($xwArticleProperties = new Article(Title::newFromText("xml:$target")))
−
}
+
$xwArticleProperties = $xwArticleProperties->getContentWithoutUsingSoManyDamnGlobals();
−
else {
+
$writableBy = xwGetListByTagname(xwDomificateArticle($xwArticleProperties), 'write');
−
# Create default environment (the name of another article)
+
if (!count($writableBy)) $writableBy = array('anyone');
−
# - this does default transforms depending on type (eg highlighting for *.php)
+
if (!count(array_intersect($writableBy, $xwUserGroups))) {
−
$xwEnv[] = '';
+
$xwArticleTitle = $target;
 +
xwMessage("Sorry article \"$xwArticleTitle\" not movable!",'red');
 +
$wgArticle = new Article($wgTitle = Title::newFromText($target));
 +
$xwArticle = $wgArticle->getContent(false);
 
}
 
}
−
 
 
}
 
}
 +
 +
# Apply init transforms
 +
xwReduceTransformStack( $xwArticle, $xwArticleProperties, $xwArticleTitle, 'init', 'INIT-HOOK' );
 +
  
 
# ---------------------------------------------------------------------------------------------------------------------- #
 
# ---------------------------------------------------------------------------------------------------------------------- #
−
# INPUT
+
# INPUT HOOK
−
 
 
−
# No input processing for now
 
  
 
# Parse and process input from forms
 
# Parse and process input from forms
−
function xwProcessInput() {
+
function xwInputHook() {
  
−
global $xwArticle;
+
global $xwArticle, $xwArticleProperties, $xwArticleTitle, $xwWritable, $_REQUEST;
−
global $xwArticleTitle;
+
global $xwDebug, $xwSave, $xwEdit, $action, $xwUserName, $wgArticle, $wgTitle;
−
global $xwRoot;
+
global $xwUserGroups, $xwIsProperties, $xwIsSystem, $xwIsAdmin;
−
global $xwDocType;
+
if ($xwDebug) xwMessage('INPUT-HOOK:','green');
  
−
global $xwSave;
+
# If not writable, change action to view
 +
if ( !$xwWritable && !in_array($action, array('view','history','raw')) ) {
 +
xwMessage('Sorry, article not writable, action changed to "view".', 'red');
 +
$action = 'view';
 +
$xwSave = $xwEdit = false;
 +
}
  
−
global $xwReadable;
+
# Scan POST and apply any XPath inputs
−
global $xwWritable;
+
foreach ($_REQUEST as $query => $value) {
 +
if (ereg('^xpath.3A.+.3A', $query)) $query = urldecode( $query );
 +
if (ereg('^xpath:.+:', $query)) xwSetProperty($xwArticleProperties, $query, str_replace('&', '%26', $value));
 +
}
  
−
# If article is being updated,
+
# if saving a pseudo-namespace...
 
if ($xwSave) {
 
if ($xwSave) {
−
global $_POST;
+
if ( $xwIsProperties || $xwIsSystem ) {
−
if (!$xwReadable || !$xwWritable) die("I'm sorry Dave, I'm afraid I can't do that.");
+
# wpTextbox1 should be valid XML to be saved
 +
$tb = $_REQUEST['wpTextbox1'];
 +
xwDomificateArticle( $tb, 'POST-DATA' );
 +
if ( !is_object($tb) ) {
 +
xwMessage('A meta-article must be valid XML! article not saved.', 'red');
 +
$action = 'view';
 +
$xwSave = $xwEdit = false;
 +
}
 +
elseif ( $xwIsProperties && !$xwIsAdmin ) {
 +
foreach ( xwGetListByTagname($tb, 'write') as $perm ) {
 +
if ( !in_array( $perm, $xwUserGroups ) ) {
 +
xwMessage("Only members of \"$perm\" can set permissions for \"$perm\"! article not saved.", 'red');
 +
$action = 'view';
 +
$xwSave = $xwEdit = false;
 +
}
 +
}
 +
}
 +
}
 
}
 
}
  
 
}
 
}
 +
  
 
# ---------------------------------------------------------------------------------------------------------------------- #
 
# ---------------------------------------------------------------------------------------------------------------------- #
−
# OUTPUT
+
# OUTPUT HOOK
−
 
 
−
# Generate new output to send back to browser
 
−
function xwProcessOutput() {
 
−
 
 
−
global $wgOut;
 
−
 
−
global $xwArticle;
 
−
global $xwArticleTitle;
 
−
global $xwRoot;
 
−
global $xwDocType;
 
  
−
global $xwView;
+
# Post-process and output article
−
global $xwPreview;
+
function xwOutputHook() {
−
global $xwSave;
 
  
−
global $xwUserName;
+
global $wgUser, $xwUserName, $wgOut, $xwDebug, $xwIsProperties, $xwIsSystem, $xwIsAdmin;
−
global $xwUserArticle;
+
global $xwArticle, $xwArticleProperties, $xwArticleTitle, $xwEdit, $action;
−
global $xwReadable;
+
if ($action == 'raw') return;
−
global $xwWritable;
+
if ($xwDebug) xwMessage('OUTPUT-HOOK:','green');
  
−
# First trap Wiki output and extract content and links (should use $ver like Admin Page)
+
# Activate the skin-hook and generate wiki's output
−
ob_start();
+
$wgUser->setOption('skin', 'xwskin');
 
$wgOut->output();
 
$wgOut->output();
−
$xwWikiOutput = ob_get_clean();
 
−
 
−
# Extract links (not used currently)
 
−
$xwUserLinks = preg_match('/id="p-personal"(.+?)<\/div>/s', $xwWikiOutput, $xwMatch)
 
−
? xwExtractHrefs($xwMatch[1]) : array();
 
−
$xwArticleLinks = preg_match('/id="p-cactions"(.+?)<\/div>/s', $xwWikiOutput, $xwMatch)
 
−
? xwExtractHrefs($xwMatch[1]) : array();
 
  
−
# Security
+
# Editing article
−
if (!$xwReadable) {
+
if ($xwEdit && preg_match("/^(.*<textarea .+?>)\\s*(<\\/textarea>.*)$/s", $xwArticle, $m)) {
−
# change output to access denied message if !readable
+
# If editing an empty sys:article or xml:article, add default content
 +
if ($xwIsSystem) {
 +
$xwArticle = $m[1]."<?xml version=\"1.0\" standalone=\"yes\"?>\n";
 +
$xwArticle .= "<!DOCTYPE xmlwiki:user SYSTEM \"xmlwiki-user.dtd\">\n";
 +
$xwArticle .= "<user>\n\t<groups></groups>\n</user>\n".$m[2];
 +
xwMessage('Note: There is currently no content for this system article, default content has been generated','red');
 +
}
 +
elseif ($xwIsProperties) {
 +
$a = xwArticleContent( str_replace( 'Xml:', '', $xwArticleTitle ) );
 +
if ( preg_match("/\\[\\[Category:(.+?)]]/", $a, $n) && $xwArticle = xwArticleProperties('Category:'.$n[1]) ) {
 +
xwUndomificateArticle( $xwArticle );
 +
xwMessage('Note: This article has no properties, default content has been inherited from Xml:'.$n[1], 'red');
 +
}
 +
else {
 +
xwMessage('Note: This article has no properties, a general default has been generated', 'red');
 +
$xwArticle = "<?xml version=\"1.0\" standalone=\"yes\"?>\n";
 +
$xwArticle .= "<!DOCTYPE xmlwiki:properties SYSTEM \"xmlwiki-properties.dtd\">\n";
 +
$xwArticle .= "<properties>\n\t<read>anyone</read>\n\t<write>$xwUserName</write>\n";
 +
$xwArticle .= "\t<language></language>\n\t<category></category>\n\t<data></data>\n\t<view></view>\n\t<edit></edit>\n\t<save></save>\n</properties>\n";
 +
}
 +
$xwArticle = $m[1].$xwArticle.$m[2];
 +
}
 +
}
 +
elseif ( $xwEdit ) {
 +
# Editing normally, apply transforms in edit-list
 +
xwReduceTransformStack( $xwArticle, $xwArticleProperties, $xwArticleTitle, 'edit', 'OUTPUT-HOOK' );
 
}
 
}
−
if (!$xwWritable) {
+
 
−
# remove edit link
+
if ( $xwDebug ) {
 +
global $xwParserHookCalled, $xwSkinHookCalled;
 +
if ( !$xwParserHookCalled ) xwMessage( 'PARSER-HOOK was not called', 'green' );
 +
if ( !$xwSkinHookCalled ) xwMessage( 'SKIN-HOOK was not called', 'green' );
 
}
 
}
  
−
# Transform article for raw request (ignores wiki-output completely)
+
# Insert stylesheets and messages into output
−
if ($xwRaw) $xwOutput = xwTransformArticle();
+
xwReplaceTokens( $xwArticle );
 +
 
 +
# Permhack: remove private info if search result
 +
if ( isset($_REQUEST['search']) && !$xwIsAdmin ) $xwArticle = preg_replace(
 +
'/<li><a href.+?>(.+?)<\\/a>.+?<\\/li>/ise',
 +
'xwArticleAccess($1,"read")?$0:""',
 +
$xwArticle
 +
);
 +
 
 +
# Output final result
 +
print $xwArticle;
 +
}
 +
 
 +
 
 +
# ---------------------------------------------------------------------------------------------------------------------- #
 +
# PRE-PARSER HOOK
  
−
# Transform article for normal view
+
function xwPreParserHook( &$text ) {
−
if ($xwView) {
+
global $xwArticleTitle, $xwArticle, $xwArticleProperties, $xwSave;
−
if (preg_match('/^(.+<!-- start content -->).+(<!-- end content -->.+)$/m', $xwOutput, $xwMatch)) {
+
global $xwParserHookCalled, $xwDebug, $xwReadable, $xwScript;
−
$xwOutput = xwTransformArticle();
+
if ( $xwDebug ) xwMessage( 'PREPARSER-HOOK:', 'green' );
−
$xwOutput = $xwMatch[1].$xwOutput.$xwMatch[2];
+
$xwParserHookCalled = true;
−
} else xwMessage('xmlWiki couldn\'t match view-output!', 'red');
 
−
}
 
  
−
# Transform article for preview
+
# Save clears all output, but we need to parse it for save-transforms
−
if ($xwPreview) {
+
if ( $xwSave ) $text = $_REQUEST['wpTextbox1'];
−
if (preg_match('/^(.+<!-- start content -->.+Remember.+saved!.+?<\\/p>).+(<script.+?<\\/script>.?<form id="editform".+<!-- end content -->.+)$/m', $xwOutput, $xwMatch)) {
 
−
$xwOutput = xwTransformArticle();
 
−
$xwOutput = $xwMatch[1].$xwOutput.$xwMatch[2];
 
−
} else xwMessage('xmlWiki couldn\'t match preview-output!', 'red');
 
−
}
 
  
−
# Transform article for publishing
+
# If this text-fragment is our article, apply transforms
−
if ($xwSave && is_object($xwArticle)) {
+
if ( $xwSave or is_object($xwArticle) or strncmp( $text, $xwArticle, 100 ) == 0 or strncmp( $text, xwArticleContent( $xwArticleTitle, false ), 100 ) == 0 ) {
−
# Get publish list
+
if ( $xwDebug ) xwMessage( "Matching text-fragment intercepted." );
−
$xwPublishList = $xwRoot->get_elements_by_tagname('publish');
+
if ( !$xwReadable ) {
−
if (count($xwPublishList)) $xwPublishList = $xwPublishList[0]->dump_mem(true);
+
xwMessage( 'Sorry, article not readable!', 'red' );
−
$xwPublishList = split(',', $xwPublishList);
+
$text = $xwArticle = "<a href=\"$xwScript?title=Special:Userlogin\">Please Login</a>";
−
$xwOutput = xwTransformArticle();
+
return false;
−
# Publish each item
 
−
foreach ($xwPublishList as $xwDestination) {
 
−
if ($xwHandle = fopen($xwDestination, 'a')) {
 
−
fwrite($xwHandle, $xwTransformedArticle);
 
−
fclose($xwHandle);
 
−
xwMessage("Article published to $cmDestination", 'green');
 
−
} else xwMessage("Failed to publish to $cmDestination", 'red');
 
 
}
 
}
 +
# Apply data-transforms
 +
# - domificate first if xml
 +
# - undomificate after if still an object
 +
if ( !is_object($xwArticle) and preg_match("/^<\\?xml/i", $text) ) xwDomificateArticle( $text, 'PreParserHook/text' );
 +
xwReduceTransformStack( $text, $xwArticleProperties, $xwArticleTitle, 'data', 'PREPARSER-HOOK' );
 +
xwUndomificateArticle( $text, $xwArticleTitle );
 
}
 
}
 +
elseif ( $xwDebug ) xwMessage( 'Parsing other content' );
 +
# Get language and return true back to parser if lang wasn't ours
 +
xwGetProperty( $xwArticleProperties, 'language', $language );
 +
if ($xwDebug) xwMessage( 'Content language determined as '.($language ? strtoupper($language) : 'WIKI') );
 +
return $language == '';
 +
}
 +
 +
 +
# ---------------------------------------------------------------------------------------------------------------------- #
 +
# POST-PARSER HOOK
 +
# - this hook was not implemented or had been removed,
 +
#  I've put in on the official ArticleSaveComplete hook for now
 +
#  - was function xwPostParserHook( &$text )
 +
function xwPostParserHook( &$article, &$user, &$text, &$summary, &$minoredit, &$watchthis, &$sectionanchor ) {
 +
 +
global $xwArticleTitle, $xwArticleProperties, $xwSave, $xwDebug;
 +
#if ( !$xwSave ) return;
 +
if ( $xwDebug ) xwMessage( 'POSTPARSER-HOOK:','green' );
 +
 +
# Apply view transforms first
 +
#xwReduceTransformStack( $text, $xwArticleProperties, $xwArticleTitle, 'view', 'POSTPARSER-HOOK' );
 +
 +
# Now apply the save-stack
 +
$dummy = "";
 +
xwReduceTransformStack( $dummy, $xwArticleProperties, $xwArticleTitle, 'save', 'POSTPARSER-HOOK' );
  
−
# Render final output and messages
+
# Output should be empty for save
−
# - not good if content isn't plain-text anymore!
+
#$text = '';
−
foreach ($xwMessages as $msg) $xwOutput .= $msg;
 
−
print $xwOutput;
 
 
}
 
}
 +
  
 
# ---------------------------------------------------------------------------------------------------------------------- #
 
# ---------------------------------------------------------------------------------------------------------------------- #
−
# TRANSFORM
+
# SKIN HOOK
 +
 
 +
# If attempted xml encountered, try to domificate and transform
 +
# - Raw requests don't get here
 +
function xwSkinHook( &$tmpl ) {
 +
 
 +
global $xwArticle, $xwArticleTitle, $xwArticleProperties, $xwRaw;
 +
global $xwTemplate, $xwDebug, $xwSkinHookCalled, $xwReadable, $xwRaw;
 +
 
 +
# Extract article from existing template structure
 +
if ( $xwDebug ) xwMessage( 'SKIN-HOOK:', 'green' );
 +
$xwSkinHookCalled = true;
 +
$xwTemplate = $tmpl;
 +
if ( $xwReadable ) $xwArticle = $xwTemplate->data['bodytext'];
 +
 
 +
# Apply view-transforms
 +
# - "default-skin.php" builds XML output structure
 +
# - "default-skin.xslt" transforms XML to HTML with table-layout
 +
# - "default-skin.css" transforms HTML with design
 +
xwReduceTransformStack( $xwArticle, $xwArticleProperties, $xwArticleTitle, 'view', 'SKIN-HOOK' );
 +
}
  
−
function xwTransformArticle() {
+
 +
# ---------------------------------------------------------------------------------------------------------------------- #
 +
# ARTICLE FUNCTIONS
 +
# - these all use super-globals since they can be called from within evals
  
−
global $xwArticle;
+
# Return true if passed title readable/writable by current user
−
global $xwArticleTitle;
+
function xwArticleAccess( $title, $perm = 'read' ) {
−
global $xwDocType;
+
global $xwIsAdmin, $xwUserGroups, $xwDefaultProperties;
 +
if ( !$access = $xwIsAdmin ) {
 +
$properties = xwArticleProperties( $title );
 +
xwMergeDOM( $properties, $xwDefaultProperties );
 +
$access = xwGetListByTagname( $properties, $perm ) + array( 'anyone' );
 +
$access = count( array_intersect( $access, $xwUserGroups ) );
 +
}
 +
return $access > 0;
 +
}
  
−
# If content is object,
+
# Retreive wiki-article as raw text
−
if (is_object($xwArticle)) {
+
function xwArticleContent( $articleTitle, $secure = true ) {
−
# we should check DTD's here for document, image, table, layout
+
global $xwArticleCache, $xwDebug, $xwIsAdmin, $xwUserGroups;
−
# eg. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
if ($xwDebug) xwMessage("xwArticleContent(\"$articleTitle\")",'blue');
−
#    <!DOCTYPE greeting SYSTEM "hello.dtd">
 
−
if ($xwDocType == 'xmlwiki') {
 
−
# Get the documents transforms
 
−
# - the first transforms adjust the document while its still a DOM object
 
−
# - but at some point it would normally transform to text,
 
−
# - it may then have some further text-based transforms
 
−
$xwTransforms = $root->get_elements_by_tagname('transform');
 
  
−
#   - add php-transform-articles,CSS's & XSLT's to $xwEnv
+
# Temp: quick fix for slack security model :-(
−
#  - $xwEnv transforms first!
+
# - should combine article and properties into getContent()
 +
if ($secure and !$xwIsAdmin) {
 +
if ($properties = new Article(Title::newFromText('xml:'.ucwords($articleTitle))))
 +
$properties = $properties->getContentWithoutUsingSoManyDamnGlobals();
 +
$readableBy = xwGetListByTagname(xwDomificateArticle($properties), 'read') + array('anyone');
 +
if (!count(array_intersect($readableBy, $xwUserGroups))) {
 +
xwMessage("Sorry article \"$articleTitle\" not readable!",'red');
 +
return "[[Special:Userlogin|Please Login]]";
 
}
 
}
 +
}
 +
 +
# Return with results if already cached
 +
if (isset($xwArticleCache[$articleTitle])) return $xwArticleCache[$articleTitle];
 +
# Get wiki article content (or use global if no article passed)
 +
# - using getContentWithoutUsingSoManyDamnGlobals() because getContent() fucks up nested-article-reads
 +
if ($article = new Article(Title::newFromText($articleTitle)))
 +
$article = $article->getContentWithoutUsingSoManyDamnGlobals();
 +
if ($article == '') {
 +
if ($xwDebug) xwMessage("Article \"$articleTitle\" not found.");
 +
return false;
 +
}
 +
elseif ($article == '(There is currently no text in this page)') {
 +
if ($xwDebug) xwMessage("Article \"$articleTitle\" not found.");
 +
return false;
 +
}
 +
if ($articleTitle) $xwArticleCache[$articleTitle] = $article;
 +
return $article;
 +
}
 +
 +
# Return properties object from title
 +
# - returns self if already a properties article
 +
function xwArticleProperties( $articleTitle, $xmlself = true ) {
 +
global $xwDebug;
 +
if ($xwDebug) xwMessage("xwArticleProperties(\"$articleTitle\")",'blue');
 +
$id = ( $xmlself && eregi( '^xml:', $articleTitle ) ) ? $articleTitle : 'xml:'.ucfirst($articleTitle);
 +
if ( !$properties = xwArticleContent( $id, false ) ) $properties =
 +
'<?xml version="1.0" standalone="yes"?>
 +
<!DOCTYPE xmlwiki:properties SYSTEM "xmlwiki-properties.dtd">
 +
<properties/>';
 +
return xwDomificateArticle( $properties, $id );
 +
}
 +
 +
# Decide kind of article from content and title
 +
function xwArticleType( $title, $article ) {
 +
if ( is_object($article) ) return 'xml';
 +
if ( eregi('\\.php$', $title) ) return 'php';
 +
if ( eregi('\\.css$', $title) ) return 'css';
 +
if ( eregi('^talk:', $title) ) return '';
 +
if ( preg_match("/^<\\?xml.+?\\?>.*<xsl:stylesheet/is", $article) ) return 'xslt';
 +
if ( eregi('^(sys|xml):.+$', $title) || ereg('^<\\?xml', $article) ) return 'xml';
 +
if ( eregi('^<\\?html', $article ) || eregi('\\.html$', $title)) return 'html4strict';
 +
if ( eregi('\\.p[lm]$', $title) ) return 'perl';
 +
if ( ereg('^#![/a-zA-Z0-9]+\\/perl', $article) ) return 'perl';
 +
if ( eregi('\\.as$', $title) ) return 'actionscript';
 +
if ( eregi('\\.dtd$', $title) ) return 'xml';
 +
if ( eregi('\\.tex$', $title) ) return 'tex';
 +
        if ( eregi('\\.nt$', $title) ) return 'dna';
 +
if ( eregi('\\.r$', $title) ) return 'r';
 +
if ( eregi('\\.py$', $title) ) return 'python';
 +
if ( eregi('\\.java$', $title) ) return 'java';
 +
if ( eregi('\\.(c\\+\\+|cpp)$', $title)) return 'cpp';
 +
if ( eregi('\\.[ch]$', $title) ) return 'c';
 +
if ( eregi('\\.js$', $title) ) return 'javascript';
 +
if ( ereg('^#![/a-zA-Z0-9]+sh', $article) ) return 'bash';
 +
return '';
 +
}
  
−
# If object wasn't one of ours, or didn't get transformed to a string...
+
# Convert passed article to a DOM object
−
if (!is_string($xwArticle)) {
+
# - Article is unchanged if not valid XML
−
# validate, report errors
+
function xwDomificateArticle(&$article, $id = '') {
−
+
global $xwDebug;
−
# apply stylesheet/XSLT if xml asks for one,
+
if ($xwDebug) xwMessage("xwDomificateArticle(\"$id\")",'blue');
 +
ob_start();
 +
if ($article) {
 +
if (php(4)) $dom = domxml_open_mem($article);
 +
else $dom = DOMDocument::loadXML($article);
 +
}
 +
if (isset($dom) && is_object($dom)) $article = $dom;
 +
else {
 +
# Could not convert, extract error messages from output
 +
if ($xwDebug) xwMessage("Failed :-(", 'red');
 +
xwExtractMessages();
 +
}
 +
ob_end_clean();
 +
return $article;
 +
}
  
−
# Convert DOM back to XML
+
# Reduce article to a string if it's a DOM object
−
$xwArticle = $xwArticle->dump_mem(true);
+
# - ie if all xslt's had xml-output-method
 +
function xwUndomificateArticle(&$article, $id = '') {
 +
if (!is_object($article)) return false;
 +
global $xwDebug;
 +
if ($xwDebug) xwMessage("xwUndomificate(\"$id\")",'blue');
 +
# TODO:
 +
# Validate, report errors
 +
# xwApplyXSLT($article, $xslt) if xml referrs one
 +
# Convert DOM back to XML if still an object
 +
if (php(4)) {
 +
# Attempt to fix PHP4's crap dump
 +
$xml = "<?xml version=\"1.0\" standalone=\"yes\"?>\n";
 +
$children = $article->child_nodes();
 +
$xml .= trim($article->dump_node($children[0]))."\n";
 +
for ($i = 1; $i < count($children); $i++) {
 +
$top = $children[$i];
 +
$name = $top->node_name();
 +
$xml .= "<$name>\n";
 +
foreach ($top->child_nodes() as $child) {
 +
$line = trim($article->dump_node($child));
 +
if ($line) $xml .= "\t$line\n";
 +
}
 +
$xml .= "</$name>\n";
 
}
 
}
 +
$article = $xml;
 
}
 
}
 +
else $article = $article->saveXML();
 +
return true;
 +
}
 +
 +
 +
# ---------------------------------------------------------------------------------------------------------------------- #
 +
# TRANSFORM FUNCTIONS
  
−
# Apply syntax highlighting if string (even if article was an object, it will be a string now)
+
# Apply all transforms in passed stack
−
# - This isn't a transform because it also applies to non-object articles
+
function xwReduceTransformStack( &$article, &$properties, $title, $event, $id = '' ) {
−
if (is_string($xwArticle)) {
+
global $xwDebug;
−
# First check for entire article highlighting
+
$GLOBALS['xwTransformID']++;
−
if (ereg('\\.as$', $xwArticleTitle)) $xwLang = 'actionscript';
+
if ( $xwDebug ) xwMessage( "Applying \"$event\" transforms to \"$title\" from \"$id\".");
−
elseif (ereg('\\.py$', $xwArticleTitle)) $xwLang = 'python';
+
if ( is_object( $properties ) ) {
−
elseif (ereg('\\.java$', $xwArticleTitle)) $xwLang = 'java';
+
if (php(4)) {
−
elseif (ereg('\\.(cpp)|(h)$', $xwArticleTitle)) $xwLang = 'cpp';
+
$docType = $properties->doctype();
−
elseif (ereg('\\.js$', $xwArticleTitle)) $xwLang = 'javascript';
+
$root = $properties->document_element();
−
elseif (ereg('\\.css$', $xwArticleTitle)) $xwLang = 'css';
+
}
−
elseif (ereg('^#![/a-zA-Z0-9]+\\/perl', $xwArticle)) $xwLang = 'perl';
 
−
elseif (ereg('^#![/a-zA-Z0-9]+sh', $xwArticle)) $xwLang = 'bash';
 
−
elseif (ereg('^<?xml', $xwArticle)) $xwLang = 'xml';
 
−
elseif (ereg('^<?html', $xwArticle)) $xwLang = 'html4strict';
 
 
else {
 
else {
−
# Otherwise, parse article for internal highlights
+
$docType = $properties->doctype;
−
# <?,<% lang (default % is asp, default ? is php)
+
$root = $properties->documentElement;
−
# <script language= (default is javascript)
+
}
 +
if ( ereg( '^xmlwiki:properties', $docType->name ) ) {
 +
if (php(4)) {
 +
while (count($tNodes = $root->get_elements_by_tagname($event))) {
 +
$tName = $tNodes[0]->get_content();
 +
xwApplyTransform($tName, $article, $properties, $title, $event);
 +
$tNodes[0]->unlink_node();
 +
}
 +
}
 +
else {
 +
while (($tNodes = $root->getElementsByTagname($event)) && $tNodes->length) {
 +
$tNode = $tNodes->item(0);
 +
xwApplyTransform($tNode->nodeValue, $article, $properties, $title, $event);
 +
$tNode->parentNode->removeChild($tNode);
 +
}
 +
}
 +
}
 +
else xwMessage('Could not transform: article-properties must be xmlwiki:properties doctype!','red');
 +
}
 +
}
  
−
$xwLang = false;
+
# Apply a transform
 +
function xwApplyTransform($transform, &$article, &$properties, &$title, $event) {
 +
global $xwDebug;
 +
if ( $transform ) {
 +
if ( $tText = xwArticleContent($transform) ) {
 +
# Get transform language (take a guess if none specified)
 +
$tProperties = xwArticleProperties($transform);
 +
xwGetProperty( $tProperties, 'language', $tLang );
 +
if ( !$tLang ) $tLang = xwArticleType( $transform, $tText );
 +
if ( $tLang == 'xslt' ) xwApplyXSLT( $article, $title, $properties, $tText, $transform );
 +
elseif ( $tLang == 'php' ) xwApplyPHP( $article, $tText, $transform, $title, $properties, $tProperties, $event );
 +
elseif ( $tLang == 'css' ) xwApplyCSS( $title, $transform );
 +
elseif ( $tLang == 'xml' ) xwMergeDOM( $properties, xwDomificateArticle( $tText, $transform ), $title, $transform );
 
}
 
}
 +
else xwMessage( "Unknown transform \"$transform\" attached to \"$event\" event!", 'red' );
 +
}
 +
}
 +
 +
# Apply PHP-transform if article perms are only writable by admin or dev
 +
function xwApplyPHP( &$article, &$tCode, $tTitle, &$title, &$properties, &$tProperties, $event ) {
 +
global $xwDebug;
 +
if ( $xwDebug ) xwMessage( "xwApplyPHP( $title , $tTitle )", 'blue' );
 +
# Get transform perms
 +
if ( !count( preg_grep( '/^(admin)|(dev)$/i', xwGetListByTagname( $tProperties, 'write' ) ) ) ) {
 +
xwMessage( "Failed to execute \"$tTitle\", must be writable only by dev or admin!", 'red' );
 +
return;
 +
}
 +
# Permissions ok, execute the transform code and trap output
 +
$path = '/properties/'.preg_replace( "/\\.\\w+$/", '', $tTitle );
 +
$script = $GLOBALS['xwScript'];
 +
ob_start();
 +
eval( "?>$tCode<?" );
 +
xwExtractMessages( $tTitle );
 +
ob_end_clean();
 +
}
 +
 +
# Append CSS stylesheet link to output
 +
function xwApplyCSS($title, $tName) {
 +
global $xwDebug, $xwStyleSheets;
 +
if ($xwDebug) xwMessage("xwApplyCSS( $title , $tName )",'blue');
 +
$xwStyleSheets[] = $tName;
 +
}
  
−
# Highlight entire article if xwLang has been set
+
# Apply XSLT to article-dom
−
if ($xwLang)
+
# - if article is not and object, the XSLT will be appended to the stylesheet-ref list like a CSS
−
$xwGeshi = new GeSHi($xwArticle, $xwLang, "extensions/geshi/geshi");
+
# - if output-method is html, article will get stringified and language updated
−
$geshi->set_keywords_style(1, 'font-weight: 100;', true);
+
function xwApplyXSLT(&$article, $title, $properties, &$xslt, $tName) {
−
$geshi->set_comments_style
+
global $xwDebug, $xwStyleSheets;
−
$geshi->set_escape_char_style
+
if ($xwDebug) xwMessage("xwApplyXSLT( $title , $tName )",'blue');
−
$geshi->set_brackets_style
+
if (is_object($article)) {
−
$geshi->set_strings_style
+
ob_start();
−
$geshi->set_numbers_style
+
if ($tObject = domxml_xslt_stylesheet($xslt)) {
−
$geshi->set_methods_style
+
$tResult = $tObject->process($article);
−
$geshi->set_symbols_style
+
# If output-method is html, use XSLT's dump_mem to create an html-string
−
$geshi->set_regexps_style
+
if (preg_match('/<xsl:output +?method *= *"html"/i', $xslt)) {
−
$geshi->set_script_style
+
$tResult = $tObject->result_dump_mem($tResult);
−
$xwArticle = $xwGeshi->parse_code();
+
xwSetProperty($properties, 'language', '');
 +
}
 
}
 
}
 +
xwExtractMessages();
 +
ob_end_clean();
 +
if (isset($tResult)) $article = $tResult;
 
}
 
}
 +
else $xwStyleSheets[] = $tName;
 
}
 
}
 +
  
 
# ---------------------------------------------------------------------------------------------------------------------- #
 
# ---------------------------------------------------------------------------------------------------------------------- #
−
# TRANSFORMS
+
# DOM FUNCTIONS
−
# - we should use DTD's for each kind: document, image, layout, table
+
 
 +
# Return result set of an XPath query on passed DOM-object
 +
function xwXPathQuery(&$dom, $query) {
 +
$result = array();
 +
if (is_object($dom)) {
 +
global $xwDebug;
 +
if ($xwDebug) xwMessage("xwXPathQuery( $query )",'blue');
 +
ob_start();
 +
if (php(4)) {
 +
$context = $dom->xpath_new_context();
 +
if ($xpath = $context->xpath_eval($query)) $result = @$xpath->nodeset;
 +
elseif ($xwDebug) xwMessage("Query \"$query\" failed :-(", 'red');
 +
}
 +
else if ($xpath = new DOMXPath($dom)) $result = $xpath->query($query);
 +
xwExtractMessages();
 +
ob_end_clean();
 +
}
 +
if (php(4)) return is_array($result) ? $result : array();
 +
else {
 +
$tmp = array();
 +
foreach ($result as $node) $tmp[] = $node;
 +
return $tmp;
 +
}
 +
}
  
−
function xwTransform_document_xxx() {
+
function xwGetProperty(&$properties, $query, &$value) {
−
# documents are built from parts,
+
global $xwDebug;
−
# the parts are a tree in its body
+
if (!preg_match("/^xpath:(.+)$/", $query, $match)) $match = array('', "/properties/$query");
−
# includes 'edit' link for each (like section, and also like table)
+
if (count($results = xwXPathQuery($properties, $match[1])) == 0) return false;
 +
if (php(4)) $value = $results[count($results)-1]->get_content();
 +
else $value = $results[count($results)-1]->nodeValue;
 +
if ($xwDebug) xwMessage("xwGetProperty( $query ) returned \"$value\"", 'purple');
 +
return true;
 
}
 
}
  
−
# A document object is finalised by transforming it to its body's text
+
# - Syntax:  xpath:XPathQuery:[[@]node][+] = value
−
function xwTransform_document_render() {
+
# - if "node" exists, then a new element (or att if "@node") is created for the value
−
global $xwArticle;
+
# - if "+" exists, content is appended, else replaced
−
$root = $xwArticle->document_element();  
+
function xwSetProperty(&$properties, $query, $value) {
−
$body = $root->get_elements_by_tagname('body');  
+
global $xwDebug;
−
if (count($body)) $xwArticle = $body[0]->dump_mem(true);
+
if ($xwDebug) xwMessage("xwSetProperty( $query , $value )", 'purple');
 +
if (!is_object($properties)) return false;
 +
if (!preg_match("/^xpath:(.+):(@?)(\\w*?)(\\+?)$/", $query, $match)) {
 +
# If not xpath, remove property before creating
 +
$tNodes = xwXPathQuery($properties, "/properties/$query");
 +
foreach ($tNodes as $tNode)
 +
if (php(4)) $tNode->unlink_node(); else $tNode->parentNode->removeChild($tNode);
 +
$match = array('', '/properties', '', $query, '');
 +
}
 +
list(, $xpath, $att, $node, $append) = $match;
 +
foreach (xwXPathQuery($properties, $xpath) as $result) {
 +
if ($node) {
 +
# create new element/attribute in result-node
 +
if ($att) {
 +
if (php(4)) $result->append_child($properties->create_attribute($node, $value));
 +
else $result->setAttribute($node, $value);
 +
}
 +
else {
 +
if (php(4)) {
 +
$node = $properties->create_element($node);
 +
$node->set_content($value);
 +
$result->append_child($node);
 +
}
 +
else $result->appendChild($properties->createElement($node, $value));
 +
}
 +
}
 +
else {
 +
# node not set, replace or append current-result-value
 +
if ($append) {
 +
if (php(4)) $result->set_content( ($result->get_content()).$value );
 +
else $result->nodeValue .= $value;
 +
}
 +
else {
 +
if (php(4)) {
 +
$newnode = $properties->create_element($result->tagname);
 +
$newnode->set_content($value);
 +
$result->replace_node($newnode);
 +
}
 +
else $result->parentNode->replaceChild($properties->createElement($result->nodeName, $value), $result);
 +
}
 +
}
 +
}
 +
return true;
 
}
 
}
  
−
function xwTransform_layout_xxx() {
+
# Return array of comma-separated-items in element content
−
# for layout container style article
+
# - if more than one element all are split and appended into the list
 +
function xwGetListByTagname(&$xml, $tag) {
 +
$list = array();
 +
if (is_object($xml)) {
 +
if (php(4)) {
 +
$root = $xml->document_element();
 +
foreach ($root->get_elements_by_tagname($tag) as $element)
 +
if ($csv = $element->get_content()) $list = array_merge($list, split(',', $csv));
 +
}
 +
else {
 +
foreach ($xml->documentElement->getElementsByTagname($tag) as $element)
 +
if ($csv = $element->nodeValue) $list = array_merge($list, split(',', $csv));
 +
}
 +
}
 +
return $list;
 
}
 
}
  
−
function xwTransform_image_xxx() {
+
# Merge the two passed DOM objects
−
# object contains properties for loading and transforming an image
+
# - appends, does not overwrite
−
# image needs no body
+
function xwMergeDOM(&$dom1, &$dom2, $id1 = 'dom1', $id2 = 'dom2') {
−
+
global $xwDebug;
−
# Get the global image on which imageTransforms work
+
# Return if first DOM not a valid properties article
−
global $xwArticleImage;
+
if (!is_object($dom1)) return false;
 +
if (php(4)) $docType = $dom1->doctype(); else $docType = $dom1->doctype;
 +
if (!ereg('^xmlwiki:properties', $docType->name)) {
 +
if ($xwDebug) xwMessage('xwMergeDOM: First parameter is not an xmlwiki:properties object!','red');
 +
return false;
 +
}
 +
# Return DOM1 if DOM2 not valid properties
 +
if (!is_object($dom2)) return $dom1;
 +
if (php(4)) $docType = $dom2->doctype(); else $docType = $dom2->doctype;
 +
if (!ereg('^xmlwiki:properties', $docType->name)) return $dom1;
 +
# Both are ok, perform the merge
 +
if ($xwDebug) xwMessage("xwMergeDOM( &$id1 , $id2 )",'blue');
 +
if (php(4)) {
 +
$root1 = $dom1->document_element();
 +
$root2 = $dom2->document_element();
 +
foreach ($root2->child_nodes() as $node) $root1->append_child($node->clone_node(true));
 +
}
 +
else $dom1->documentElement->appendChild($dom1->importNode($dom2->documentElement, true));
 +
return true;
 
}
 
}
  
−
# Converts the in-memory-working image into article content
+
# Remove all occourences of a certain element
−
function xwTransform_image_render() {
+
function xwRemoveElement( &$properties, $element ) {
−
global $xwArticle;
+
$root = $properties->document_element();
−
global $xwArticleTitle;
+
if (php(4)) {
−
global $xwArticleImage;
+
while ( count($tNodes = $root->get_elements_by_tagname($element)) ) $tNodes[0]->unlink_node();
−
global $xwRaw;
 
−
if ($xwRaw) {
 
−
# replace article object with image
 
−
ob_start()
 
−
imagePng($xwArticleImage);
 
−
$xwArticle = ob_get_clean();
 
−
# set header to image
 
−
header("Content-type: image/png");
 
 
}
 
}
 
else {
 
else {
−
# the raw image is not being requested, render image in-page with info instead
+
while ( ($tNodes = $root->getElementsByTagname($element)) && $tNodes->length ) {
−
$xwArticle = "<img src=\"$xwArticleTitle?action=raw\" alt=\"$xwArticleTitle\"/>";
+
$tNode = $tNodes->item(0);
 +
$tNode->parentNode->removeChild( $tNode );
 +
}
 
}
 
}
−
}
 
−
 
−
# A table object is an interface to a database table
 
−
# - this can't be implimented fully until the 'edit' hook is done
 
−
function xwTransform_table_xxx() {
 
−
# - view lists the table/result with links to edit each (like a normal composition-doc)
 
−
# - also form for create/edit/edlete
 
 
}
 
}
  
 
# ---------------------------------------------------------------------------------------------------------------------- #
 
# ---------------------------------------------------------------------------------------------------------------------- #
−
# FUNCTIONS
+
# UTILITY FUNCTIONS
  
−
# Retreive wiki-article
+
# Extract error-messages from captured output and put in proper message-queue
−
# - A DOM object is returned if possible,
+
function xwExtractMessages($where = false) {
−
# - or otherwise string content is returned (which can be parsed for highlighting)
+
if ($where) $where = " of \"$where\"";
−
function xwGetArticle($articleTitle) {
+
$err = preg_replace("/<.+?>/", "", ob_get_contents());
−
# Return with results if already cached
+
foreach (split("\n", $err) as $msg) if (trim($msg)) {
−
global $xwArticleCache;
+
if (ereg("eval\\(\\)'d code on line ([0-9]+)", $msg, $m)) $line = " (Line $m[1]$where)";
−
if (isset($xwArticleCache[$articleTitle])) return $xwArticleCache[$articleTitle];
+
$msg = preg_replace('/ in .+? on line.+?([0-9]+)/', " (Line $1$where)", $msg);
−
# Get wiki article content (XML)
+
if (isset($line)) $msg .= $line;
−
$article = new Article(Title::newFromText($articleTitle));
+
xwMessage($msg, 'red');
−
$article = $article->getContent(false);
+
}
−
# Convert to DOM object if possible
 
−
if ($articleDOM = @domxml_open_mem($article)) $article = $articleDOM;
 
−
# Return content
 
−
return $xwArticleCache[$articleTitle] = $article;
 
 
}
 
}
−
 
+
−
# Return a list of the hrefs found in the passed content
 
−
function xwExtractHrefs($content) {
 
−
preg_match_all('/(<a.+?<\/a>)/', $content, $match);
 
−
return $match[1];
 
−
}
 
−
 
 
 
# Add message to queue
 
# Add message to queue
−
function xwMessage($msg, $col) {
+
function xwMessage($msg, $col = '#000080') {
 
global $xwMessages;
 
global $xwMessages;
−
$xwMessages[] = "<div class=\"xwMessage\"><font color=\"$col\">$msg</font></div>\n";
+
$msg = htmlentities($msg);
 +
return $xwMessages[] = "<font color=\"$col\">$msg</font>";
 
}
 
}
  
−
# ---------------------------------------------------------------------------------------------------------------------- #
+
function xwReplaceTokens(&$article, $embed = false) {
−
# ADMIN
+
global $xwStyleSheets, $xwMessages, $xwCssToken, $xwMsgToken, $xwScript;
−
function xwAdminPage() {
 
  
−
?><html><head><title>xmlWiki Admin Page</title></head><body bgcolor=#cccccc>
+
# Stylesheets
−
<table border=0 width=100% cellpadding=0 cellspacing=0>
+
$stylesheets = '';
−
<tr><td align=center><table border=0 width=30%>
+
foreach ($xwStyleSheets as $title)
−
<tr><td align=center>
+
if ($embed) $stylesheets .= '<style type="text/css" media="screen">'.xwArticleContent($title).'</style>';
−
<a href="./index.php/xmlWiki"><img src="./xmlwiki.jpg" border=0 alt="xmlWiki"></a>
+
else $stylesheets = "<link rel=\"stylesheet\" type=\"text/css\" href=\"$xwScript?title=$title&action=raw&ctype=text/css\" />\n$stylesheets";
−
<tr><td align=center bgcolor=#003366>
+
$article = str_replace($xwCssToken, $stylesheets, $article);
−
<b><font size=5 color=white face=helvetica>xmlWiki Admin Page</font></b>
 
−
</table></table><br><br><br><br><?
 
  
−
# back up index.php if doesn't already exist
+
# Messages
−
if (!file_exists('./index.bak')) {
+
if (count($xwMessages)) {
−
if (!copy('./index.bak', './index.php')) {
+
$msg = '<div class="portlet" id="p-xwmessages"><h5>There are Messages</h5></div>';
−
print xwMessage('Could not back up index.php!', '#d00000');
+
$msg .= '<div class="xwmessage"><ul><li>'.join("</li><li>", $xwMessages).'</li></ul></div>';
−
exit;
+
$article = str_replace($xwMsgToken, $msg, $article);
−
}
 
 
}
 
}
−
if (array_key_exists('enable', $_GET)) {
+
}
−
# Replace from backup before enabling
+
 
−
if (!copy('./index.bak', './index.php'))
+
# Print list of passed object's methods and properties
−
print xwMessage('Could not copy index.bak over index.php', '#d00000');
+
function xwCheckoutObject($obj) {
−
require_once('./Version.php');
+
if (is_object($obj)) {
−
$ver = $wgSoftwareRevision;
+
print strtoupper("<br>$obj properties:<br>");
−
# Matches for patch-points/MediaWiki versions
+
foreach (get_object_vars($obj) as $k=>$v) print htmlentities("$k => $v")."<br>";
−
$requireMatch['1002'] = "/^wfProfileOut\\( *'main-misc-setup' *\\);$/m";
+
print strtoupper("<br>$obj methods:<br>");
−
$inputMatch['1002'] = "/^wfProfileIn\\( *'main-action' *\\);$/m";
+
foreach (get_class_methods($obj) as $k=>$v) print "$v<br>";
−
$outputMatch['1002'] = "/\\\$wgOut->output\\(\\);/m";
 
−
# Apply patches
 
−
if (preg_match($requireMatch[$ver], $file = join('', file('./index.php')))
 
−
&&  preg_match($inputMatch[$ver], $file)
 
−
&&  preg_match($outputMatch[$ver], $file)) {
 
−
$file = preg_replace($requireMatch[$ver], "wfProfileOut( 'main-misc-setup' );\nrequire_once( './xmlwiki.php' );", $file);
 
−
$file = preg_replace($inputMatch[$ver], "xwProcessInput();\nwfProfileIn( 'main-action' );", $file);
 
−
$file = preg_replace($outputMatch[$ver], "xwProcessOutput();", $file);
 
−
if ($handle = fopen('./index.php', 'w')) {
 
−
fwrite($handle, $file);
 
−
fclose($handle);
 
−
} else print xwMessage('Could not open index.php for writing!', '#d00000');
 
−
} else print xwMessage('Could not match content of index.php script!', '#d00000');
 
 
}
 
}
−
elseif (array_key_exists('disable', $_GET)) {
+
if (is_array($obj)) {
−
# Replace from backup
+
print strtoupper("<br>Array content:<br>");
−
if (!copy('./index.bak', './index.php'))
+
foreach ($obj as $k=>$v) print "$k => $v<br>";
−
print xwMessage('Could not copy index.bak over index.php', '#d00000');
 
 
}
 
}
−
# Print current state
+
die;
−
if (filesize('./index.php') == filesize('./index.bak'))
+
}
−
print xwMessage('xmlWiki is currently disabled. [ <a href="./xmlwiki.php?enable">enable</a> ]', '#003366');
+
 
−
else print xwMessage('xmlWiki is currently enabled. [ <a href="./xmlwiki.php?disable">disable</a> ]', '#003366');
+
# Return true if PHP major version equals passed int
−
+
# - needed due to different DOM implementation on 4 and 5 (and none on 3)
 +
function php($ver) { return substr(phpversion(),0,1) == "$ver"; }
 +
 
 +
# Add a log entry to a log article ([[[[XmlWiki Log]]]] is default)
 +
function xwLog($comment, $title = 'XmlWiki Log') {
 +
global $wgLang;
 +
$ts = $wgLang->timeanddate(wfTimestampNow(),true);
 +
$log = xwArticleContent($title)."\n*$ts : $comment";
 +
$a = new Article(Title::newFromText($title));
 +
$a->quickEdit($log);
 +
}
 +
 
 +
# Parse wikitext string and return HTML string
 +
function xwWikiParse(&$text) {
 +
global $wgHooks,$wgTitle,$wgUser;
 +
$tmp = $wgHooks['PreParser'];
 +
$wgHooks['PreParser'] = array();
 +
$parser = new Parser;
 +
$output = $parser->parse($text,$wgTitle,ParserOptions::newFromUser($wgUser),true,false);
 +
$wgHooks['PreParser'] = $tmp;
 +
return $output->getText();
 +
}
  
−
?><br><br><br><table border=0 width=100% cellpadding=0 cellspacing=0>
+
# Parse an XmlWiki article and return resulting HTML
−
<tr><td align=center colspan=3><table border=0 width=50%>
+
function xwXmlWikiParse($title) {
−
<td align=right valign=top><a href="http://w3c.org/"><img src="./xhtml.jpg" alt="XHTML1.0" border=0 /></a>
+
global $wgTitle,$wgHooks,$wgUser,$xwUserName,$xwAnonymous;
−
<td align=right valign=top><a href="http://www.php.net/"><img src="./php.jpg" alt="PHP" border=0 /></a>
+
$bookmarks = $xwAnonymous ? "Bookmarks:Default" : "Bookmarks:$xwUserName";
−
<td align=right valign=top><a href="http://www.mediawiki.org/"><img src="./mediawiki.jpg" alt="MediaWiki" border=0 /></a>
+
$text = str_replace('{{BOOKMARKS}}',$bookmarks,xwArticleContent($title)); # Hack so that {{BOOKMARKS}} can be used in an XmlWiki link
−
</table></table><br><br></body></html><?
+
$text = preg_replace('/<!--([^@]+?)-->/s','@@'.'@@$1@@'.'@@',$text); # Hack so that HTML comments in the wikitext are preserved
 +
$properties = xwArticleProperties($title);
 +
xwSetProperty($properties,'xpath:/properties:data','document.php');
 +
# If no language specified in properties, guess from name and content
 +
        xwGetProperty($properties,'language',$lang);
 +
        if (!$lang) xwSetProperty($properties,'language',xwArticleType($title,$text));
 +
xwReduceTransformStack($text,$properties,$title,'data','xwXmlWikiParse/preParse/data');
 +
$tmp = $wgHooks['PreParser'];
 +
$wgHooks['PreParser'] = array();
 +
$parser = new Parser;
 +
$output = $parser->parse($text,$wgTitle,ParserOptions::newFromUser($wgUser),true,false);
 +
$wgHooks['PreParser'] = $tmp;
 +
$text = $output->getText();
 +
$text = preg_replace('/@{4}([^@]+?)@{4}/s','<!--$1-->',$text); # HTML comments hack
 +
xwSetProperty($properties,'xpath:/properties:view','tree-view.php');
 +
xwReduceTransformStack($text,$properties,$title,'view','xwXmlWikiParse/preParse/view');
 +
return $text;
 
}
 
}
−
?>
+
</source>
−
</php>
 

Latest revision as of 22:18, 20 November 2019

Legacy.svg Legacy: This article describes a concept that has been superseded in the course of ongoing development on the Organic Design wiki. Please do not develop this any further or base work on this concept, now this page is for historic record only. 
# xmlWiki - MediaWiki XML Hack
# Nad - Started: 2005-05-18

# Exit if not included from index.php
defined('MEDIAWIKI') or die('xmlwiki.php must be included from MediaWiki\'s index.php!');
if (php(3)) die('xmlWiki cannot run on less than PHP4!');

# Add the rest of the hooks
$wgHooks['PreParser'][] = 'xwPreParserHook';
$wgHooks['ParserBeforeStrip'][] = 'xwPreParserHook';
$wgHooks['ArticleSaveComplete'][] = 'xwPostParserHook';
$wgHooks['ParserAfterTidy'][] = 'xwPostParserHook';
$wgHooks['Input'][] = 'xwInputHook';
$wgHooks['Output'][] = 'xwOutputHook';
$wgHooks['ParserFunctions'][] = 'xwTransclusionSecurity';
function xwTransclusionSecurity(&$title,&$text,$args,$argc) {
	$title = ereg_replace('^:','',$title);
	if ($title && !xwArticleAccess($title)) { $text = 'Sorry, article not readable!'; $title = false; }
	return true;
	}

# System globals
$xwDebug				= false;
$xwMessages				= array();
$xwArticleCache			= array();
$xwStyleSheets			= array();
$xwTemplate				= null;
$xwParserHookCalled		= false;
$xwSkinHookCalled		= false;
$xwMsgToken				= '<!--xwMsg-->';
$xwCssToken				= '<!--xwCss-->';
$xwScript				= $wgScript;
$xwTransformID			= 1;

# User globals
$xwUserName				= ucwords( $wgUser->mName );
$xwAnonymous			= ereg( "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+", $xwUserName );
$xwUserSYS				= null;
$xwUserGroups			= array($xwUserName, 'anyone');
$xwEdit					= isset($_REQUEST['action']) && ($_REQUEST['action'] == 'edit');
$xwView					= (!isset($_REQUEST['action']) || (isset($_REQUEST['action']) && ($_REQUEST['action'] == 'view')));
$xwRaw					= isset($_REQUEST['action']) && ($_REQUEST['action'] == 'raw');
$xwPreview				= isset($_REQUEST['wpPreview']); 
$xwSave					= isset($_REQUEST['wpSave']);

# Article globals
$xwArticleTitle			= $wgTitle->getPrefixedText();
$xwArticle				= $xwPreview ? $wgRequest->gettext('wpTextbox1') : $wgArticle->getContent(false);
$xwArticleProperties	= null;
$xwIsProperties			= preg_match('/^xml:.+$/i', $xwArticleTitle);
$xwIsSystem				= preg_match('/^sys:.+$/i', $xwArticleTitle);
$xwIsUser				= preg_match('/^user:.+$/i', $xwArticleTitle);
$xwIsSpecial				= preg_match('/^special:.+$/i', $xwArticleTitle);
$xwIsAdmin				= false;
$xwArticleReadableBy	= null;
$xwArticleWritableBy	= null;

# Get default properties article
$xwDefaultProperties = $xwDefaultPropertiesXML = xwArticleContent( 'default-properties.xml', false );
xwDomificateArticle( $xwDefaultProperties, 'defaults' );

# Get user-system-article and extract users' groups from it if any
$xwUserSYS = xwArticleContent( "sys:$xwUserName" );
xwDomificateArticle( $xwUserSYS, "sys:$xwUserName" );
$xwUserGroups = array_merge( $xwUserGroups, xwGetListByTagname( $xwUserSYS, 'groups' ) );

# Read user-prefs
xwGetProperty( $xwUserSYS, 'xpath:/user/debug', $xwDebug );

# Get article-meta-file and extract article-perms
if ( $xwIsSystem ) $xwArticleReadableBy = $xwArticleWritableBy = array('admin');
else {

	# Get xml:article (self if already xml:*)
	if ( $p = $xwIsProperties ? xwDomificateArticle( $xwArticle ) : xwArticleProperties( $xwArticleTitle ) )

	# Start with default-properties and merge article props (so new transforms on top)
	$xwArticleProperties =
		'<?xml version="1.0" standalone="yes"?>
		<!DOCTYPE xmlwiki:properties SYSTEM "xmlwiki-properties.dtd">
		<properties/>';
	xwDomificateArticle( $xwArticleProperties, 'CreateProperties' );
	xwMergeDOM( $xwArticleProperties, $xwDefaultProperties );
	xwMergeDOM( $xwArticleProperties, $p );

	$xwArticleReadableBy = xwGetListByTagname( $xwArticleProperties, 'read' );
	$xwArticleWritableBy = xwGetListByTagname( $xwArticleProperties, 'write' );
	if ( $xwIsProperties ) $xwArticleProperties = false;
	}
if ( !is_object( $xwArticleProperties ) ) $xwArticleProperties = $xwDefaultProperties;
if ( $xwIsSpecial || !count( $xwArticleReadableBy ) ) $xwArticleReadableBy = array('anyone');
if ( !count($xwArticleWritableBy) ) $xwArticleWritableBy = array('anyone');

# If no language specified in properties, guess from name and content
if ( !xwGetProperty( $xwArticleProperties, 'language', $xwLanguage ) )
	xwSetProperty( $xwArticleProperties, 'language', xwArticleType( $xwArticleTitle, $xwArticle ) );

# Set perms for this request
if ($xwDebug) xwMessage('PERMISSIONS:','green');
if (in_array('admin', $xwUserGroups)) $xwIsAdmin = $xwReadable = $xwWritable = true;
else {
	$xwReadable = 0 < count(array_intersect($xwArticleReadableBy, $xwUserGroups));
	$xwWritable = 0 < count(array_intersect($xwArticleWritableBy, $xwUserGroups));
	}
if ($xwDebug) {
	xwMessage('Groups: '.join(', ', $xwUserGroups));
	xwMessage('Readable ('.($xwReadable?'yes':'no').'): '.join(', ', $xwArticleReadableBy));
	xwMessage('Writable ('.($xwWritable?'yes':'no').'): '.join(', ', $xwArticleWritableBy));
	}

# Divert to access-denied article if not readable
if (!$xwReadable) {
	$action = 'view';
	$xwSave = $xwEdit = false;
	}

# Handle security for Move
if (!$xwIsAdmin and ($target = $_REQUEST['target']) ) {
	if ($xwArticleProperties = new Article(Title::newFromText("xml:$target")))
		$xwArticleProperties = $xwArticleProperties->getContentWithoutUsingSoManyDamnGlobals();
	$writableBy = xwGetListByTagname(xwDomificateArticle($xwArticleProperties), 'write');
	if (!count($writableBy)) $writableBy = array('anyone');
	if (!count(array_intersect($writableBy, $xwUserGroups))) {
		$xwArticleTitle = $target;
		xwMessage("Sorry article \"$xwArticleTitle\" not movable!",'red');
		$wgArticle = new Article($wgTitle = Title::newFromText($target));
		$xwArticle = $wgArticle->getContent(false);
		}
	}

# Apply init transforms
xwReduceTransformStack( $xwArticle, $xwArticleProperties, $xwArticleTitle, 'init', 'INIT-HOOK' );


# ---------------------------------------------------------------------------------------------------------------------- #
# INPUT HOOK

# Parse and process input from forms
function xwInputHook() {

	global $xwArticle, $xwArticleProperties, $xwArticleTitle, $xwWritable, $_REQUEST;
	global $xwDebug, $xwSave, $xwEdit, $action, $xwUserName, $wgArticle, $wgTitle;
	global $xwUserGroups, $xwIsProperties, $xwIsSystem, $xwIsAdmin;
	if ($xwDebug) xwMessage('INPUT-HOOK:','green');

	# If not writable, change action to view
	if ( !$xwWritable && !in_array($action, array('view','history','raw')) ) {
		xwMessage('Sorry, article not writable, action changed to "view".', 'red');
		$action = 'view';
		$xwSave = $xwEdit = false;
		}

	# Scan POST and apply any XPath inputs
	foreach ($_REQUEST as $query => $value) {
		if (ereg('^xpath.3A.+.3A', $query)) $query = urldecode( $query );
		if (ereg('^xpath:.+:', $query)) xwSetProperty($xwArticleProperties, $query, str_replace('&', '%26', $value));
		}

	# if saving a pseudo-namespace...
	if ($xwSave) {
		if ( $xwIsProperties || $xwIsSystem ) {
			# wpTextbox1 should be valid XML to be saved
			$tb = $_REQUEST['wpTextbox1'];
			xwDomificateArticle( $tb, 'POST-DATA' );
			if ( !is_object($tb) ) {
				xwMessage('A meta-article must be valid XML! article not saved.', 'red');
				$action = 'view';
				$xwSave = $xwEdit = false;
				}
			elseif ( $xwIsProperties && !$xwIsAdmin ) {
				foreach ( xwGetListByTagname($tb, 'write') as $perm ) {
					if ( !in_array( $perm, $xwUserGroups ) ) {
						xwMessage("Only members of \"$perm\" can set permissions for \"$perm\"! article not saved.", 'red');
						$action = 'view';
						$xwSave = $xwEdit = false;
						}
					}
				}
			}
		}

	}


# ---------------------------------------------------------------------------------------------------------------------- #
# OUTPUT HOOK

# Post-process and output article
function xwOutputHook() {

	global $wgUser, $xwUserName, $wgOut, $xwDebug, $xwIsProperties, $xwIsSystem, $xwIsAdmin;
	global $xwArticle, $xwArticleProperties, $xwArticleTitle, $xwEdit, $action;
	if ($action == 'raw') return;
	if ($xwDebug) xwMessage('OUTPUT-HOOK:','green');

	# Activate the skin-hook and generate wiki's output
	$wgUser->setOption('skin', 'xwskin');
	$wgOut->output();

	# Editing article
	if ($xwEdit && preg_match("/^(.*<textarea .+?>)\\s*(<\\/textarea>.*)$/s", $xwArticle, $m)) {
		# If editing an empty sys:article or xml:article, add default content
		if ($xwIsSystem) {
			$xwArticle = $m[1]."<?xml version=\"1.0\" standalone=\"yes\"?>\n";
			$xwArticle .= "<!DOCTYPE xmlwiki:user SYSTEM \"xmlwiki-user.dtd\">\n";
			$xwArticle .= "<user>\n\t<groups></groups>\n</user>\n".$m[2];
			xwMessage('Note: There is currently no content for this system article, default content has been generated','red');
			}
		elseif ($xwIsProperties) {
			$a = xwArticleContent( str_replace( 'Xml:', '', $xwArticleTitle ) );
			if ( preg_match("/\\[\\[Category:(.+?)]]/", $a, $n) && $xwArticle = xwArticleProperties('Category:'.$n[1]) ) {
				xwUndomificateArticle( $xwArticle );
				xwMessage('Note: This article has no properties, default content has been inherited from Xml:'.$n[1], 'red');
				}
			else {
				xwMessage('Note: This article has no properties, a general default has been generated', 'red');
				$xwArticle = "<?xml version=\"1.0\" standalone=\"yes\"?>\n";
				$xwArticle .= "<!DOCTYPE xmlwiki:properties SYSTEM \"xmlwiki-properties.dtd\">\n";
				$xwArticle .= "<properties>\n\t<read>anyone</read>\n\t<write>$xwUserName</write>\n";
				$xwArticle .= "\t<language></language>\n\t<category></category>\n\t<data></data>\n\t<view></view>\n\t<edit></edit>\n\t<save></save>\n</properties>\n";
				}
			$xwArticle = $m[1].$xwArticle.$m[2];
			}
		}
	elseif ( $xwEdit ) {
		# Editing normally, apply transforms in edit-list
		xwReduceTransformStack( $xwArticle, $xwArticleProperties, $xwArticleTitle, 'edit', 'OUTPUT-HOOK' );
		}

	if ( $xwDebug ) {
		global $xwParserHookCalled, $xwSkinHookCalled;
		if ( !$xwParserHookCalled ) xwMessage( 'PARSER-HOOK was not called', 'green' );
		if ( !$xwSkinHookCalled ) xwMessage( 'SKIN-HOOK was not called', 'green' );
		}

	# Insert stylesheets and messages into output
	xwReplaceTokens( $xwArticle );

	# Permhack: remove private info if search result
	if ( isset($_REQUEST['search']) && !$xwIsAdmin ) $xwArticle = preg_replace(
		'/<li><a href.+?>(.+?)<\\/a>.+?<\\/li>/ise',
		'xwArticleAccess($1,"read")?$0:""',
		$xwArticle
		);

	# Output final result
	print $xwArticle;
	}


# ---------------------------------------------------------------------------------------------------------------------- #
# PRE-PARSER HOOK

function xwPreParserHook( &$text ) {
	global $xwArticleTitle, $xwArticle, $xwArticleProperties, $xwSave;
	global $xwParserHookCalled, $xwDebug, $xwReadable, $xwScript;
	if ( $xwDebug ) xwMessage( 'PREPARSER-HOOK:', 'green' );
	$xwParserHookCalled = true;

	# Save clears all output, but we need to parse it for save-transforms
	if ( $xwSave ) $text = $_REQUEST['wpTextbox1'];

	# If this text-fragment is our article, apply transforms
	if ( $xwSave or is_object($xwArticle) or strncmp( $text, $xwArticle, 100 ) == 0 or strncmp( $text, xwArticleContent( $xwArticleTitle, false ), 100 ) == 0 ) {
		if ( $xwDebug ) xwMessage( "Matching text-fragment intercepted." );
		if ( !$xwReadable ) {
			xwMessage( 'Sorry, article not readable!', 'red' );
			$text = $xwArticle = "<a href=\"$xwScript?title=Special:Userlogin\">Please Login</a>";
			return false;
			}
		# Apply data-transforms
		# - domificate first if xml
		# - undomificate after if still an object
		if ( !is_object($xwArticle) and preg_match("/^<\\?xml/i", $text) ) xwDomificateArticle( $text, 'PreParserHook/text' );
		xwReduceTransformStack( $text, $xwArticleProperties, $xwArticleTitle, 'data', 'PREPARSER-HOOK' );
		xwUndomificateArticle( $text, $xwArticleTitle ); 
		}
	elseif ( $xwDebug ) xwMessage( 'Parsing other content' );
	# Get language and return true back to parser if lang wasn't ours
	xwGetProperty( $xwArticleProperties, 'language', $language );
	if ($xwDebug) xwMessage( 'Content language determined as '.($language ? strtoupper($language) : 'WIKI') );
	return $language == '';
	}


# ---------------------------------------------------------------------------------------------------------------------- #
# POST-PARSER HOOK
# - this hook was not implemented or had been removed,
#   I've put in on the official ArticleSaveComplete hook for now
#   - was function xwPostParserHook( &$text ) 
function xwPostParserHook( &$article, &$user, &$text, &$summary, &$minoredit, &$watchthis, &$sectionanchor ) {

	global $xwArticleTitle, $xwArticleProperties, $xwSave, $xwDebug;
	#if ( !$xwSave ) return;
	if ( $xwDebug ) xwMessage( 'POSTPARSER-HOOK:','green' );

	# Apply view transforms first
	#xwReduceTransformStack( $text, $xwArticleProperties, $xwArticleTitle, 'view', 'POSTPARSER-HOOK' );

	# Now apply the save-stack
	$dummy = "";
	xwReduceTransformStack( $dummy, $xwArticleProperties, $xwArticleTitle, 'save', 'POSTPARSER-HOOK' );

	# Output should be empty for save
	#$text = '';
	}


# ---------------------------------------------------------------------------------------------------------------------- #
# SKIN HOOK

# If attempted xml encountered, try to domificate and transform
# - Raw requests don't get here
function xwSkinHook( &$tmpl ) {

	global $xwArticle, $xwArticleTitle, $xwArticleProperties, $xwRaw;
	global $xwTemplate, $xwDebug, $xwSkinHookCalled, $xwReadable, $xwRaw;

	# Extract article from existing template structure
	if ( $xwDebug ) xwMessage( 'SKIN-HOOK:', 'green' );
	$xwSkinHookCalled = true;
	$xwTemplate = $tmpl;
	if ( $xwReadable ) $xwArticle = $xwTemplate->data['bodytext'];

	# Apply view-transforms
	# - "default-skin.php" builds XML output structure
	# - "default-skin.xslt" transforms XML to HTML with table-layout
	# - "default-skin.css" transforms HTML with design
	xwReduceTransformStack( $xwArticle, $xwArticleProperties, $xwArticleTitle, 'view', 'SKIN-HOOK' );
	}

	
# ---------------------------------------------------------------------------------------------------------------------- #
# ARTICLE FUNCTIONS
# - these all use super-globals since they can be called from within evals

# Return true if passed title readable/writable by current user
function xwArticleAccess( $title, $perm = 'read' ) {
	global $xwIsAdmin, $xwUserGroups, $xwDefaultProperties;
	if ( !$access = $xwIsAdmin ) {
		$properties = xwArticleProperties( $title );
		xwMergeDOM( $properties, $xwDefaultProperties );
		$access = xwGetListByTagname( $properties, $perm ) + array( 'anyone' );
		$access = count( array_intersect( $access, $xwUserGroups ) );
		}
	return $access > 0;
	}

# Retreive wiki-article as raw text
function xwArticleContent( $articleTitle, $secure = true ) {
	global $xwArticleCache, $xwDebug, $xwIsAdmin, $xwUserGroups;
	if ($xwDebug) xwMessage("xwArticleContent(\"$articleTitle\")",'blue');

	# Temp: quick fix for slack security model :-(
	# - should combine article and properties into getContent()
	if ($secure and !$xwIsAdmin) {
		if ($properties = new Article(Title::newFromText('xml:'.ucwords($articleTitle))))
			$properties = $properties->getContentWithoutUsingSoManyDamnGlobals();
		$readableBy = xwGetListByTagname(xwDomificateArticle($properties), 'read') + array('anyone');
		if (!count(array_intersect($readableBy, $xwUserGroups))) {
			xwMessage("Sorry article \"$articleTitle\" not readable!",'red');
			return "[[Special:Userlogin|Please Login]]";
			}
		}

	# Return with results if already cached
	if (isset($xwArticleCache[$articleTitle])) return $xwArticleCache[$articleTitle];
	# Get wiki article content (or use global if no article passed)
	# - using getContentWithoutUsingSoManyDamnGlobals() because getContent() fucks up nested-article-reads
	if ($article = new Article(Title::newFromText($articleTitle)))
		$article = $article->getContentWithoutUsingSoManyDamnGlobals();
	if ($article == '') {
		if ($xwDebug) xwMessage("Article \"$articleTitle\" not found.");
		return false;
		}
	elseif ($article == '(There is currently no text in this page)') {
		if ($xwDebug) xwMessage("Article \"$articleTitle\" not found.");
		return false;
		}
	if ($articleTitle) $xwArticleCache[$articleTitle] = $article;
	return $article;
	}

# Return properties object from title
# - returns self if already a properties article
function xwArticleProperties( $articleTitle, $xmlself = true ) {
	global $xwDebug;
	if ($xwDebug) xwMessage("xwArticleProperties(\"$articleTitle\")",'blue');
	$id = ( $xmlself && eregi( '^xml:', $articleTitle ) ) ? $articleTitle : 'xml:'.ucfirst($articleTitle);
	if ( !$properties = xwArticleContent( $id, false ) ) $properties =
		'<?xml version="1.0" standalone="yes"?>
		<!DOCTYPE xmlwiki:properties SYSTEM "xmlwiki-properties.dtd">
		<properties/>';
	return xwDomificateArticle( $properties, $id );
	}

# Decide kind of article from content and title
function xwArticleType( $title, $article ) {
	if ( is_object($article) ) return 'xml';
	if ( eregi('\\.php$', $title) ) return 'php';
	if ( eregi('\\.css$', $title) ) return 'css';
	if ( eregi('^talk:', $title) ) return '';
	if ( preg_match("/^<\\?xml.+?\\?>.*<xsl:stylesheet/is", $article) ) return 'xslt';
	if ( eregi('^(sys|xml):.+$', $title) || ereg('^<\\?xml', $article) ) return 'xml';
	if ( eregi('^<\\?html', $article ) || eregi('\\.html$', $title)) return 'html4strict';
	if ( eregi('\\.p[lm]$', $title) ) return 'perl';
	if ( ereg('^#![/a-zA-Z0-9]+\\/perl', $article) ) return 'perl';
	if ( eregi('\\.as$', $title) ) return 'actionscript';
	if ( eregi('\\.dtd$', $title) ) return 'xml';
	if ( eregi('\\.tex$', $title) ) return 'tex';
        if ( eregi('\\.nt$', $title) ) return 'dna';
	if ( eregi('\\.r$', $title) ) return 'r';
	if ( eregi('\\.py$', $title) ) return 'python';
	if ( eregi('\\.java$', $title) ) return 'java';
	if ( eregi('\\.(c\\+\\+|cpp)$', $title)) return 'cpp';
	if ( eregi('\\.[ch]$', $title) ) return 'c';
	if ( eregi('\\.js$', $title) ) return 'javascript';
	if ( ereg('^#![/a-zA-Z0-9]+sh', $article) ) return 'bash';
	return '';
	}

# Convert passed article to a DOM object
# - Article is unchanged if not valid XML
function xwDomificateArticle(&$article, $id = '') {
	global $xwDebug;
	if ($xwDebug) xwMessage("xwDomificateArticle(\"$id\")",'blue');
	ob_start();
	if ($article) {
		if (php(4)) $dom = domxml_open_mem($article);
		else $dom = DOMDocument::loadXML($article);
		}
	if (isset($dom) && is_object($dom)) $article = $dom;
	else {
		# Could not convert, extract error messages from output
		if ($xwDebug) xwMessage("Failed :-(", 'red');
		xwExtractMessages();
		}
	ob_end_clean();
	return $article;
	}

# Reduce article to a string if it's a DOM object
# - ie if all xslt's had xml-output-method
function xwUndomificateArticle(&$article, $id = '') {
	if (!is_object($article)) return false;
	global $xwDebug;
	if ($xwDebug) xwMessage("xwUndomificate(\"$id\")",'blue');
	# TODO:
	# Validate, report errors
	# xwApplyXSLT($article, $xslt) if xml referrs one
	# Convert DOM back to XML if still an object
	if (php(4)) {
		# Attempt to fix PHP4's crap dump
		$xml = "<?xml version=\"1.0\" standalone=\"yes\"?>\n";
		$children = $article->child_nodes();
		$xml .= trim($article->dump_node($children[0]))."\n";
		for ($i = 1; $i < count($children); $i++) {
			$top = $children[$i];
			$name = $top->node_name();
			$xml .= "<$name>\n";
			foreach ($top->child_nodes() as $child) {
				$line = trim($article->dump_node($child));
				if ($line) $xml .= "\t$line\n";
				}
			$xml .= "</$name>\n";
			}
		$article = $xml;
		}
	else $article = $article->saveXML();
	return true;
	}


# ---------------------------------------------------------------------------------------------------------------------- #
# TRANSFORM FUNCTIONS

# Apply all transforms in passed stack
function xwReduceTransformStack( &$article, &$properties, $title, $event, $id = '' ) {
	global $xwDebug;
	$GLOBALS['xwTransformID']++;
	if ( $xwDebug ) xwMessage( "Applying \"$event\" transforms to \"$title\" from \"$id\".");
	if ( is_object( $properties ) ) {
		if (php(4)) {
			$docType = $properties->doctype();
			$root = $properties->document_element();
			}
		else {
			$docType = $properties->doctype;
			$root = $properties->documentElement;
			}
		if ( ereg( '^xmlwiki:properties', $docType->name ) ) {
			if (php(4)) {
				while (count($tNodes = $root->get_elements_by_tagname($event))) {
					$tName = $tNodes[0]->get_content();
					xwApplyTransform($tName, $article, $properties, $title, $event);
					$tNodes[0]->unlink_node();
					}
				}
			else {
				while (($tNodes = $root->getElementsByTagname($event)) && $tNodes->length) {
					$tNode = $tNodes->item(0);
					xwApplyTransform($tNode->nodeValue, $article, $properties, $title, $event);
					$tNode->parentNode->removeChild($tNode);
					}
				}
			}
		else xwMessage('Could not transform: article-properties must be xmlwiki:properties doctype!','red');
		}
	}

# Apply a transform
function xwApplyTransform($transform, &$article, &$properties, &$title, $event) {
	global $xwDebug;
	if ( $transform ) {
		if ( $tText = xwArticleContent($transform) ) {
			# Get transform language (take a guess if none specified)
			$tProperties = xwArticleProperties($transform);
			xwGetProperty( $tProperties, 'language', $tLang );
			if ( !$tLang ) $tLang = xwArticleType( $transform, $tText );
			if ( $tLang == 'xslt' )	 xwApplyXSLT( $article, $title, $properties, $tText, $transform );
			elseif ( $tLang == 'php' ) xwApplyPHP( $article, $tText, $transform, $title, $properties, $tProperties, $event );
			elseif ( $tLang == 'css' ) xwApplyCSS( $title, $transform );
			elseif ( $tLang == 'xml' ) xwMergeDOM( $properties, xwDomificateArticle( $tText, $transform ), $title, $transform );
			}
		else xwMessage( "Unknown transform \"$transform\" attached to \"$event\" event!", 'red' );
		}
	}

# Apply PHP-transform if article perms are only writable by admin or dev
function xwApplyPHP( &$article, &$tCode, $tTitle, &$title, &$properties, &$tProperties, $event ) {
	global $xwDebug;
	if ( $xwDebug ) xwMessage( "xwApplyPHP( $title , $tTitle )", 'blue' );
	# Get transform perms
	if ( !count( preg_grep( '/^(admin)|(dev)$/i', xwGetListByTagname( $tProperties, 'write' ) ) ) ) {
		xwMessage( "Failed to execute \"$tTitle\", must be writable only by dev or admin!", 'red' );
		return;
		}
	# Permissions ok, execute the transform code and trap output
	$path = '/properties/'.preg_replace( "/\\.\\w+$/", '', $tTitle );
	$script = $GLOBALS['xwScript'];
	ob_start();
	eval( "?>$tCode<?" );
	xwExtractMessages( $tTitle );
	ob_end_clean();
	}

# Append CSS stylesheet link to output
function xwApplyCSS($title, $tName) {
	global $xwDebug, $xwStyleSheets;
	if ($xwDebug) xwMessage("xwApplyCSS( $title , $tName )",'blue');
	$xwStyleSheets[] = $tName;
	}

# Apply XSLT to article-dom
# - if article is not and object, the XSLT will be appended to the stylesheet-ref list like a CSS
# - if output-method is html, article will get stringified and language updated
function xwApplyXSLT(&$article, $title, $properties, &$xslt, $tName) {
	global $xwDebug, $xwStyleSheets;
	if ($xwDebug) xwMessage("xwApplyXSLT( $title , $tName )",'blue');
	if (is_object($article)) {
		ob_start();
		if ($tObject = domxml_xslt_stylesheet($xslt)) {
			$tResult = $tObject->process($article);
			# If output-method is html, use XSLT's dump_mem to create an html-string
			if (preg_match('/<xsl:output +?method *= *"html"/i', $xslt)) {
				$tResult = $tObject->result_dump_mem($tResult);
				xwSetProperty($properties, 'language', '');
				}
			}
		xwExtractMessages();
		ob_end_clean();
		if (isset($tResult)) $article = $tResult;
		}
	else $xwStyleSheets[] = $tName;
	}


# ---------------------------------------------------------------------------------------------------------------------- #
# DOM FUNCTIONS

# Return result set of an XPath query on passed DOM-object
function xwXPathQuery(&$dom, $query) {
	$result = array();
	if (is_object($dom)) {
		global $xwDebug;
		if ($xwDebug) xwMessage("xwXPathQuery( $query )",'blue');
		ob_start();
		if (php(4)) {
			$context = $dom->xpath_new_context(); 
			if ($xpath = $context->xpath_eval($query)) $result = @$xpath->nodeset;
			elseif ($xwDebug) xwMessage("Query \"$query\" failed :-(", 'red');
			}
		else if ($xpath = new DOMXPath($dom)) $result = $xpath->query($query);
		xwExtractMessages();
		ob_end_clean();
		}
	if (php(4)) return is_array($result) ? $result : array();
	else {	
		$tmp = array();
		foreach ($result as $node) $tmp[] = $node;
		return $tmp;
		}
	}	

function xwGetProperty(&$properties, $query, &$value) {
	global $xwDebug;
	if (!preg_match("/^xpath:(.+)$/", $query, $match)) $match = array('', "/properties/$query");
	if (count($results = xwXPathQuery($properties, $match[1])) == 0) return false;
	if (php(4)) $value = $results[count($results)-1]->get_content();
		else $value = $results[count($results)-1]->nodeValue;
	if ($xwDebug) xwMessage("xwGetProperty( $query ) returned \"$value\"", 'purple');
	return true;
	}

# - Syntax:  xpath:XPathQuery:[[@]node][+] = value
# - if "node" exists, then a new element (or att if "@node") is created for the value
# - if "+" exists, content is appended, else replaced
function xwSetProperty(&$properties, $query, $value) {
	global $xwDebug;
	if ($xwDebug) xwMessage("xwSetProperty( $query , $value )", 'purple');
	if (!is_object($properties)) return false;
	if (!preg_match("/^xpath:(.+):(@?)(\\w*?)(\\+?)$/", $query, $match)) {
		# If not xpath, remove property before creating
		$tNodes = xwXPathQuery($properties, "/properties/$query");
		foreach ($tNodes as $tNode)
			if (php(4)) $tNode->unlink_node(); else $tNode->parentNode->removeChild($tNode);
		$match = array('', '/properties', '', $query, '');
		}
	list(, $xpath, $att, $node, $append) = $match;
	foreach (xwXPathQuery($properties, $xpath) as $result) {
		if ($node) {
			# create new element/attribute in result-node
			if ($att) {
				if (php(4)) $result->append_child($properties->create_attribute($node, $value));
				else $result->setAttribute($node, $value);
				}
			else {
				if (php(4)) {
					$node = $properties->create_element($node);
					$node->set_content($value);
					$result->append_child($node);
					}
				else $result->appendChild($properties->createElement($node, $value));
				}
			}
		else {
			# node not set, replace or append current-result-value
			if ($append) {
				if (php(4)) $result->set_content( ($result->get_content()).$value );
				else $result->nodeValue .= $value;
				}
			else {
				if (php(4)) {
					$newnode = $properties->create_element($result->tagname);
					$newnode->set_content($value);
					$result->replace_node($newnode);
					}
				else $result->parentNode->replaceChild($properties->createElement($result->nodeName, $value), $result);
				}
			}
		}
	return true;
	}

# Return array of comma-separated-items in element content
# - if more than one element all are split and appended into the list
function xwGetListByTagname(&$xml, $tag) {
	$list = array();
	if (is_object($xml)) {
		if (php(4)) {
			$root = $xml->document_element(); 
			foreach ($root->get_elements_by_tagname($tag) as $element)
				if ($csv = $element->get_content()) $list = array_merge($list, split(',', $csv));
			}
		else {
			foreach ($xml->documentElement->getElementsByTagname($tag) as $element)
				if ($csv = $element->nodeValue) $list = array_merge($list, split(',', $csv));
			}
		}
	return $list;
	}

# Merge the two passed DOM objects
# - appends, does not overwrite
function xwMergeDOM(&$dom1, &$dom2, $id1 = 'dom1', $id2 = 'dom2') {
	global $xwDebug;
	# Return if first DOM not a valid properties article
	if (!is_object($dom1)) return false;
	if (php(4)) $docType = $dom1->doctype(); else $docType = $dom1->doctype;
	if (!ereg('^xmlwiki:properties', $docType->name)) {
		if ($xwDebug) xwMessage('xwMergeDOM: First parameter is not an xmlwiki:properties object!','red');
		return false;
		}
	# Return DOM1 if DOM2 not valid properties
	if (!is_object($dom2)) return $dom1;
	if (php(4)) $docType = $dom2->doctype(); else $docType = $dom2->doctype;
	if (!ereg('^xmlwiki:properties', $docType->name)) return $dom1;
	# Both are ok, perform the merge
	if ($xwDebug) xwMessage("xwMergeDOM( &$id1 , $id2 )",'blue');
	if (php(4)) {
		$root1 = $dom1->document_element();
		$root2 = $dom2->document_element();
		foreach ($root2->child_nodes() as $node) $root1->append_child($node->clone_node(true));
		}
	else $dom1->documentElement->appendChild($dom1->importNode($dom2->documentElement, true));
	return true;
	}

# Remove all occourences of a certain element
function xwRemoveElement( &$properties, $element ) {
	$root = $properties->document_element();
	if (php(4)) {
		while ( count($tNodes = $root->get_elements_by_tagname($element)) ) $tNodes[0]->unlink_node();
		}
	else {
		while ( ($tNodes = $root->getElementsByTagname($element)) && $tNodes->length ) {
			$tNode = $tNodes->item(0);
			$tNode->parentNode->removeChild( $tNode );
			}
		}
	}

# ---------------------------------------------------------------------------------------------------------------------- #
# UTILITY FUNCTIONS

# Extract error-messages from captured output and put in proper message-queue
function xwExtractMessages($where = false) {
	if ($where) $where = " of \"$where\"";
	$err = preg_replace("/<.+?>/", "", ob_get_contents());
	foreach (split("\n", $err) as $msg) if (trim($msg)) {
		if (ereg("eval\\(\\)'d code on line ([0-9]+)", $msg, $m)) $line = " (Line $m[1]$where)";
		$msg = preg_replace('/ in .+? on line.+?([0-9]+)/', " (Line $1$where)", $msg);
		if (isset($line)) $msg .= $line;
		xwMessage($msg, 'red');
		}
	}
	
# Add message to queue
function xwMessage($msg, $col = '#000080') {
	global $xwMessages;
	$msg = htmlentities($msg);
	return $xwMessages[] = "<font color=\"$col\">$msg</font>";
	}

function xwReplaceTokens(&$article, $embed = false) {
	global $xwStyleSheets, $xwMessages, $xwCssToken, $xwMsgToken, $xwScript;

	# Stylesheets
	$stylesheets = '';
	foreach ($xwStyleSheets as $title)
		if ($embed) $stylesheets .= '<style type="text/css" media="screen">'.xwArticleContent($title).'</style>';
		else $stylesheets = "<link rel=\"stylesheet\" type=\"text/css\" href=\"$xwScript?title=$title&action=raw&ctype=text/css\" />\n$stylesheets";
	$article = str_replace($xwCssToken, $stylesheets, $article);

	# Messages
	if (count($xwMessages)) {
		$msg = '<div class="portlet" id="p-xwmessages"><h5>There are Messages</h5></div>';
		$msg .= '<div class="xwmessage"><ul><li>'.join("</li><li>", $xwMessages).'</li></ul></div>';
		$article = str_replace($xwMsgToken, $msg, $article);
		}
	}

# Print list of passed object's methods and properties
function xwCheckoutObject($obj) {
	if (is_object($obj)) {
		print strtoupper("<br>$obj properties:<br>");
		foreach (get_object_vars($obj) as $k=>$v) print htmlentities("$k => $v")."<br>";
		print strtoupper("<br>$obj methods:<br>");
		foreach (get_class_methods($obj) as $k=>$v) print "$v<br>";
		}
	if (is_array($obj)) {
		print strtoupper("<br>Array content:<br>");
		foreach ($obj as $k=>$v) print "$k => $v<br>";
		}
	die;
	}

# Return true if PHP major version equals passed int
# - needed due to different DOM implementation on 4 and 5 (and none on 3)
function php($ver) { return substr(phpversion(),0,1) == "$ver"; }

# Add a log entry to a log article ([[[[XmlWiki Log]]]] is default)
function xwLog($comment, $title = 'XmlWiki Log') {
	global $wgLang;
	$ts = $wgLang->timeanddate(wfTimestampNow(),true);
	$log = xwArticleContent($title)."\n*$ts : $comment";
	$a = new Article(Title::newFromText($title));
	$a->quickEdit($log);
	}

# Parse wikitext string and return HTML string
function xwWikiParse(&$text) {
	global $wgHooks,$wgTitle,$wgUser;
	$tmp = $wgHooks['PreParser'];
	$wgHooks['PreParser'] = array();
	$parser = new Parser;
	$output = $parser->parse($text,$wgTitle,ParserOptions::newFromUser($wgUser),true,false);
	$wgHooks['PreParser'] = $tmp;
	return $output->getText();
	}

# Parse an XmlWiki article and return resulting HTML
function xwXmlWikiParse($title) {
	global $wgTitle,$wgHooks,$wgUser,$xwUserName,$xwAnonymous;
	$bookmarks = $xwAnonymous ? "Bookmarks:Default" : "Bookmarks:$xwUserName";
	$text = str_replace('{{BOOKMARKS}}',$bookmarks,xwArticleContent($title)); # Hack so that {{BOOKMARKS}} can be used in an XmlWiki link
	$text = preg_replace('/<!--([^@]+?)-->/s','@@'.'@@$1@@'.'@@',$text); # Hack so that HTML comments in the wikitext are preserved
	$properties = xwArticleProperties($title);
	xwSetProperty($properties,'xpath:/properties:data','document.php');
	# If no language specified in properties, guess from name and content
        xwGetProperty($properties,'language',$lang);
        if (!$lang) xwSetProperty($properties,'language',xwArticleType($title,$text));
	xwReduceTransformStack($text,$properties,$title,'data','xwXmlWikiParse/preParse/data');
	$tmp = $wgHooks['PreParser'];
	$wgHooks['PreParser'] = array();
	$parser = new Parser;
	$output = $parser->parse($text,$wgTitle,ParserOptions::newFromUser($wgUser),true,false);
	$wgHooks['PreParser'] = $tmp;
	$text = $output->getText();
	$text = preg_replace('/@{4}([^@]+?)@{4}/s','<!--$1-->',$text); # HTML comments hack
	xwSetProperty($properties,'xpath:/properties:view','tree-view.php');
	xwReduceTransformStack($text,$properties,$title,'view','xwXmlWikiParse/preParse/view');
	return $text;
	}
Retrieved from "https://organicdesign.nz/wiki/index.php?title=Xmlwiki.php&oldid=126816"