Subversion Repositories – MLAB

(root)/WebSVN/include/svnlook.php

Rev 4988

<?php
// WebSVN - Subversion repository viewing via the web using PHP
// Copyright (C) 2004-2006 Tim Armes
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA     02111-1307      USA
//
// --
//
// svn-look.php
//
// Svn bindings
//
// These binding currently use the svn command line to achieve their goal.      Once a proper
// SWIG binding has been produced for PHP, there'll be an option to use that instead.

require_once 'include/utils.php';

// {{{ Classes for retaining log information ---

$debugxml = false;

class SVNInfoEntry {
        var $rev = 1;
        var $path = '';
        var $isdir = null;
}

class SVNMod {
        var $action = '';
        var $copyfrom = '';
        var $copyrev = '';
        var $path = '';
        var $isdir = null;
}

class SVNListEntry {
        var $rev = 1;
        var $author = '';
        var $date = '';
        var $committime;
        var $age = '';
        var $file = '';
        var $isdir = null;
}

class SVNList {
        var $entries; // Array of entries
        var $curEntry; // Current entry

        var $path = ''; // The path of the list
}

class SVNLogEntry {
        var $rev = 1;
        var $author = '';
        var $date = '';
        var $committime;
        var $age = '';
        var $msg = '';
        var $path = '';
        var $precisePath = '';

        var $mods;
        var $curMod;
}

function SVNLogEntry_compare($a, $b) {
        return strnatcasecmp($a->path, $b->path);
}

class SVNLog {
        var $entries; // Array of entries
        var $curEntry; // Current entry

        var $path = ''; // Temporary variable used to trace path history

        // findEntry
        //
        // Return the entry for a given revision

        function findEntry($rev) {
                foreach ($this->entries as $index => $entry) {
                        if ($entry->rev == $rev) {
                                return $index;
                        }
                }
        }
}

// }}}

// {{{ XML parsing functions---

$curTag = '';

$curInfo = 0;

// {{{ infoStartElement

function infoStartElement($parser, $name, $attrs) {
        global $curInfo, $curTag, $debugxml;

        switch ($name) {
                case 'INFO':
                        if ($debugxml) print 'Starting info'."\n";
                        break;

                case 'ENTRY':
                        if ($debugxml) print 'Creating info entry'."\n";

                        if (count($attrs)) {
                                foreach ($attrs as $k => $v) {
                                        switch ($k) {
                                                case 'KIND':
                                                        if ($debugxml) print 'Kind '.$v."\n";
                                                        $curInfo->isdir = ($v == 'dir');
                                                        break;
                                                case 'REVISION':
                                                        if ($debugxml) print 'Revision '.$v."\n";
                                                        $curInfo->rev = $v;
                                                        break;
                                        }
                                }
                        }
                        break;

                default:
                        $curTag = $name;
                        break;
        }
}

// }}}

// {{{ infoEndElement

function infoEndElement($parser, $name) {
        global $curInfo, $debugxml, $curTag;

        switch ($name) {
                case 'ENTRY':
                        if ($debugxml) print 'Ending info entry'."\n";
                        if ($curInfo->isdir) {
                                $curInfo->path .= '/';
                        }
                        break;
        }

        $curTag = '';
}

// }}}

// {{{ infoCharacterData

function infoCharacterData($parser, $data) {
        global $curInfo, $curTag, $debugxml;

        switch ($curTag) {
                case 'URL':
                        if ($debugxml) print 'URL: '.$data."\n";
                        $curInfo->path = $data;
                        break;

                case 'ROOT':
                        if ($debugxml) print 'Root: '.$data."\n";
                        $curInfo->path = urldecode(substr($curInfo->path, strlen($data)));
                        break;
        }
}

// }}}

$curList = 0;

// {{{ listStartElement

function listStartElement($parser, $name, $attrs) {
        global $curList, $curTag, $debugxml;

        switch ($name) {
                case 'LIST':
                        if ($debugxml) print 'Starting list'."\n";

                        if (count($attrs)) {
                                foreach ($attrs as $k => $v) {
                                        switch ($k) {
                                                case 'PATH':
                                                        if ($debugxml) print 'Path '.$v."\n";
                                                        $curList->path = $v;
                                                        break;
                                        }
                                }
                        }
                        break;

                case 'ENTRY':
                        if ($debugxml) print 'Creating new entry'."\n";
                        $curList->curEntry = new SVNListEntry;

                        if (count($attrs)) {
                                foreach ($attrs as $k => $v) {
                                        switch ($k) {
                                                case 'KIND':
                                                        if ($debugxml) print 'Kind '.$v."\n";
                                                        $curList->curEntry->isdir = ($v == 'dir');
                                                        break;
                                        }
                                }
                        }
                        break;

                case 'COMMIT':
                        if ($debugxml) print 'Commit'."\n";

                        if (count($attrs)) {
                                foreach ($attrs as $k => $v) {
                                        switch ($k) {
                                                case 'REVISION':
                                                        if ($debugxml) print 'Revision '.$v."\n";
                                                        $curList->curEntry->rev = $v;
                                                        break;
                                        }
                                }
                        }
                        break;

                default:
                        $curTag = $name;
                        break;
        }
}

// }}}

// {{{ listEndElement

function listEndElement($parser, $name) {
        global $curList, $debugxml, $curTag;

        switch ($name) {
                case 'ENTRY':
                        if ($debugxml) print 'Ending new list entry'."\n";
                        if ($curList->curEntry->isdir) {
                                $curList->curEntry->file .= '/';
                        }
                        $curList->entries[] = $curList->curEntry;
                        $curList->curEntry = null;
                        break;
        }

        $curTag = '';
}

// }}}

// {{{ listCharacterData

function listCharacterData($parser, $data) {
        global $curList, $curTag, $debugxml;

        switch ($curTag) {
                case 'NAME':
                        if ($debugxml) print 'Name: '.$data."\n";
                        if ($data === false || $data === '') return;
                        $curList->curEntry->file .= $data;
                        break;

                case 'AUTHOR':
                        if ($debugxml) print 'Author: '.$data."\n";
                        if ($data === false || $data === '') return;
                        if (function_exists('mb_detect_encoding') && function_exists('mb_convert_encoding'))
                                $data = mb_convert_encoding($data, 'UTF-8', mb_detect_encoding($data));
                        $curList->curEntry->author .= $data;
                        break;

                case 'DATE':
                        if ($debugxml) print 'Date: '.$data."\n";
                        if ($data === false || $data === '') return;
                        $committime = parseSvnTimestamp($data);
                        $curList->curEntry->committime = $committime;
                        $curList->curEntry->date = date('Y-m-d H:i:s', $committime);
                        $curList->curEntry->age = datetimeFormatDuration(max(time() - $committime, 0), true, true);
                        break;
        }
}

// }}}

$curLog = 0;

// {{{ logStartElement

function logStartElement($parser, $name, $attrs) {
        global $curLog, $curTag, $debugxml;

        switch ($name) {
                case 'LOGENTRY':
                        if ($debugxml) print 'Creating new log entry'."\n";
                        $curLog->curEntry = new SVNLogEntry;
                        $curLog->curEntry->mods = array();

                        $curLog->curEntry->path = $curLog->path;

                        if (count($attrs)) {
                                foreach ($attrs as $k => $v) {
                                        switch ($k) {
                                                case 'REVISION':
                                                        if ($debugxml) print 'Revision '.$v."\n";
                                                        $curLog->curEntry->rev = $v;
                                                        break;
                                        }
                                }
                        }
                        break;

                case 'PATH':
                        if ($debugxml) print 'Creating new path'."\n";
                        $curLog->curEntry->curMod = new SVNMod;

                        if (count($attrs)) {
                                foreach ($attrs as $k => $v) {
                                        switch ($k) {
                                                case 'ACTION':
                                                        if ($debugxml) print 'Action '.$v."\n";
                                                        $curLog->curEntry->curMod->action = $v;
                                                        break;

                                                case 'COPYFROM-PATH':
                                                        if ($debugxml) print 'Copy from: '.$v."\n";
                                                        $curLog->curEntry->curMod->copyfrom = $v;
                                                        break;

                                                case 'COPYFROM-REV':
                                                        $curLog->curEntry->curMod->copyrev = $v;
                                                        break;

                                                case 'KIND':
                                                        if ($debugxml) print 'Kind '.$v."\n";
                                                        $curLog->curEntry->curMod->isdir = ($v == 'dir');
                                                        break;
                                        }
                                }
                        }

                        $curTag = $name;
                        break;

                default:
                        $curTag = $name;
                        break;
        }
}

// }}}

// {{{ logEndElement

function logEndElement($parser, $name) {
        global $curLog, $debugxml, $curTag;

        switch ($name) {
                case 'LOGENTRY':
                        if ($debugxml) print 'Ending new log entry'."\n";
                        $curLog->entries[] = $curLog->curEntry;
                        break;

                case 'PATH':
                        // The XML returned when a file is renamed/branched in inconsistent.
                        // In the case of a branch, the path doesn't include the leafname.
                        // In the case of a rename, it does.    Ludicrous.

                        if (!empty($curLog->path)) {
                                $pos = strrpos($curLog->path, '/');
                                $curpath = substr($curLog->path, 0, $pos);
                                $leafname = substr($curLog->path, $pos + 1);
                        } else {
                                $curpath = '';
                                $leafname = '';
                        }

                        $curMod = $curLog->curEntry->curMod;
                        if ($curMod->action == 'A') {
                                if ($debugxml) print 'Examining added path "'.$curMod->copyfrom.'" - Current path = "'.$curpath.'", leafname = "'.$leafname.'"'."\n";
                                if ($curMod->path == $curLog->path) {
                                        // For directories and renames
                                        $curLog->path = $curMod->copyfrom;
                                } else if ($curMod->path == $curpath || $curMod->path == $curpath.'/') {
                                        // Logs of files that have moved due to branching
                                        $curLog->path = $curMod->copyfrom.'/'.$leafname;
                                } else {
                                        $curLog->path = str_replace($curMod->path, $curMod->copyfrom, $curLog->path);
                                }
                                if ($debugxml) print 'New path for comparison: "'.$curLog->path.'"'."\n";
                        }

                        if ($debugxml) print 'Ending path'."\n";
                        $curLog->curEntry->mods[] = $curLog->curEntry->curMod;
                        break;

                case 'MSG':
                        $curLog->curEntry->msg = trim($curLog->curEntry->msg);
                        if ($debugxml) print 'Completed msg = "'.$curLog->curEntry->msg.'"'."\n";
                        break;
        }

        $curTag = '';
}

// }}}

// {{{ logCharacterData

function logCharacterData($parser, $data) {
        global $curLog, $curTag, $debugxml;

        switch ($curTag) {
                case 'AUTHOR':
                        if ($debugxml) print 'Author: '.$data."\n";
                        if ($data === false || $data === '') return;
                        if (function_exists('mb_detect_encoding') && function_exists('mb_convert_encoding'))
                                $data = mb_convert_encoding($data, 'UTF-8', mb_detect_encoding($data));
                        $curLog->curEntry->author .= $data;
                        break;

                case 'DATE':
                        if ($debugxml) print 'Date: '.$data."\n";
                        if ($data === false || $data === '') return;
                        $committime = parseSvnTimestamp($data);
                        $curLog->curEntry->committime = $committime;
                        $curLog->curEntry->date = date('Y-m-d H:i:s', $committime);
                        $curLog->curEntry->age = datetimeFormatDuration(max(time() - $committime, 0), true, true);
                        break;

                case 'MSG':
                        if ($debugxml) print 'Msg: '.$data."\n";
                        if (function_exists('mb_detect_encoding') && function_exists('mb_convert_encoding'))
                                $data = mb_convert_encoding($data, 'UTF-8', mb_detect_encoding($data));
                        $curLog->curEntry->msg .= $data;
                        break;

                case 'PATH':
                        if ($debugxml) print 'Path name: '.$data."\n";
                        if ($data === false || $data === '') return;
                        $curLog->curEntry->curMod->path .= $data;
                        break;
        }
}

// }}}

// }}}

// {{{ internal functions (_topLevel and _listSort)

// Function returns true if the give entry in a directory tree is at the top level

function _topLevel($entry) {
        // To be at top level, there must be one space before the entry
        return (strlen($entry) > 1 && $entry[0] == ' ' && $entry[ 1 ] != ' ');
}

// Function to sort two given directory entries.
// Directories go at the top if config option alphabetic is not set

function _listSort($e1, $e2) {
        global $config;

        $file1 = $e1->file;
        $file2 = $e2->file;
        $isDir1 = ($file1[strlen($file1) - 1] == '/');
        $isDir2 = ($file2[strlen($file2) - 1] == '/');

        if (!$config->isAlphabeticOrder()) {
                if ($isDir1 && !$isDir2) return -1;
                if ($isDir2 && !$isDir1) return 1;
        }

        if ($isDir1) $file1 = substr($file1, 0, -1);
        if ($isDir2) $file2 = substr($file2, 0, -1);

        return strnatcasecmp($file1, $file2);
}

// }}}

// {{{ encodePath

// Function to encode a URL without encoding the /'s

function encodePath($uri) {
        global $config;

        $uri = str_replace(DIRECTORY_SEPARATOR, '/', $uri);
        if (function_exists('mb_detect_encoding') && function_exists('mb_convert_encoding')) {
                $uri = mb_convert_encoding($uri, 'UTF-8', mb_detect_encoding($uri));
        }

        $parts = explode('/', $uri);
        $partscount = count($parts);
        for ($i = 0; $i < $partscount; $i++) {
                // do not rawurlencode the 'svn+ssh://' part!
                if ($i != 0 || $parts[$i] != 'svn+ssh:') {
                        $parts[$i] = rawurlencode($parts[$i]);
                }
        }

        $uri = implode('/', $parts);

        // Quick hack. Subversion seems to have a bug surrounding the use of %3A instead of :

        $uri = str_replace('%3A', ':', $uri);

        // Correct for Window share names
        if ($config->serverIsWindows) {
                if (substr($uri, 0, 2) == '//') {
                        $uri = '\\'.substr($uri, 2, strlen($uri));
                }

                if (substr($uri, 0, 10) == 'file://///' ) {
                        $uri = 'file:///\\'.substr($uri, 10, strlen($uri));
                }
        }

        return $uri;
}

// }}}

function _equalPart($str1, $str2) {
        $len1 = strlen($str1);
        $len2 = strlen($str2);
        $i = 0;
        while ($i < $len1 && $i < $len2) {
                if (strcmp($str1[$i], $str2[$i]) != 0) {
                        break;
                }
                $i++;
        }
        if ($i == 0) {
                return '';
        }
        return substr($str1, 0, $i);
}

function _logError($string) {
        $string = preg_replace("/--password '.*'/", "--password '[...]'", $string);
        error_log($string);
}

// The SVNRepository class

class SVNRepository {
        var $repConfig;
        var $geshi = null;

        function __construct($repConfig) {
                $this->repConfig = $repConfig;
        }

        // {{{ highlightLine
        //
        // Distill line-spanning syntax highlighting so that each line can stand alone
        // (when invoking on the first line, $attributes should be an empty array)
        // Invoked to make sure all open syntax highlighting tags (<font>, <i>, <b>, etc.)
        // are closed at the end of each line and re-opened on the next line

        function highlightLine($line, &$attributes) {
                $hline = '';

                // Apply any highlighting in effect from the previous line
                foreach ($attributes as $attr) {
                        $hline .= $attr['text'];
                }

                // append the new line
                $hline .= $line;

                // update attributes
                for ($line = strstr($line, '<'); $line; $line = strstr(substr($line, 1), '<')) {
                        if (substr($line, 1, 1) == '/') {
                                // if this closes a tag, remove most recent corresponding opener
                                $tagNamLen = strcspn($line, '> '."\t", 2);
                                $tagNam = substr($line, 2, $tagNamLen);
                                foreach (array_reverse(array_keys($attributes)) as $k) {
                                        if ($attributes[$k]['tag'] == $tagNam) {
                                                unset($attributes[$k]);
                                                break;
                                        }
                                }
                        } else {
                                // if this opens a tag, add it to the list
                                $tagNamLen = strcspn($line, '> '."\t", 1);
                                $tagNam = substr($line, 1, $tagNamLen);
                                $tagLen = strcspn($line, '>') + 1;
                                $attributes[] = array('tag' => $tagNam, 'text' => substr($line, 0, $tagLen));
                        }
                }

                // close any still-open tags
                foreach (array_reverse($attributes) as $attr) {
                        $hline .= '</'.$attr['tag'].'>';
                }

                // XXX: this just simply replaces [ and ] with their entities to prevent
                //              it from being parsed by the template parser; maybe something more
                //              elegant is in order?
                $hline = str_replace('[', '&#91;', str_replace(']', '&#93;', $hline) );
                return $hline;
        }

        // }}}

        // Private function to simplify creation of common SVN command string text.
        function svnCommandString($command, $path, $rev, $peg) {
                global $config;
                return $config->getSvnCommand().$this->repConfig->svnCredentials().' '.$command.' '.($rev ? '-r '.$rev.' ' : '').quote(encodePath($this->getSvnPath($path)).'@'.($peg ? $peg : ''));
        }

        // Private function to simplify creation of enscript command string text.
        function enscriptCommandString($path) {
                global $config, $extEnscript;

                $filename = basename($path);
                $ext = strrchr($path, '.');

                $lang = false;
                if (array_key_exists($filename, $extEnscript)) {
                        $lang = $extEnscript[$filename];
                } else if ($ext && array_key_exists(strtolower($ext), $extEnscript)) {
                        $lang = $extEnscript[strtolower($ext)];
                }

                $cmd = $config->enscript.' --language=html';
                if ($lang !== false) {
                        $cmd .= ' --color --'.(!$config->getUseEnscriptBefore_1_6_3() ? 'highlight' : 'pretty-print').'='.$lang;
                }
                $cmd .= ' -o -';
                return $cmd;
        }

        // {{{ getFileContents
        //
        // Dump the content of a file to the given filename

        function getFileContents($path, $filename, $rev = 0, $peg = '', $pipe = '', $highlight = 'file') {
                global $config;
                assert ($highlight == 'file' || $highlight == 'no' || $highlight == 'line');

                $highlighted = false;

                // If there's no filename, just deliver the contents as-is to the user
                if ($filename == '') {
                        $cmd = $this->svnCommandString('cat', $path, $rev, $peg);
                        passthruCommand($cmd.' '.$pipe);
                        return $highlighted;
                }

                // Get the file contents info

                $tempname = $filename;
                if ($highlight == 'line') {
                        $tempname = tempnamWithCheck($config->getTempDir(), '');
                }
                $highlighted = true;
                $shouldTrimOutput = false;
                $explodeStr = "\n";
                if ($highlight != 'no' && $config->useGeshi && $geshiLang = $this->highlightLanguageUsingGeshi($path)) {
                        $this->applyGeshi($path, $tempname, $geshiLang, $rev, $peg, false, $highlight);
                        // Geshi outputs in HTML format, enscript does not
                        $shouldTrimOutput = true;
                        $explodeStr = "<br />";
                } else if ($highlight != 'no' && $config->useEnscript) {
                        // Get the files, feed it through enscript, then remove the enscript headers using sed
                        // Note that the sed command returns only the part of the file between <PRE> and </PRE>.
                        // It's complicated because it's designed not to return those lines themselves.
                        $cmd = $this->svnCommandString('cat', $path, $rev, $peg);
                        $cmd = $cmd.' | '.$this->enscriptCommandString($path).' | '.
                                $config->sed.' -n '.$config->quote.'1,/^<PRE.$/!{/^<\\/PRE.$/,/^<PRE.$/!p;}'.$config->quote.' > '.$tempname;
                } else {
                        $highlighted = false;
                        $cmd = $this->svnCommandString('cat', $path, $rev, $peg);
                        $cmd = $cmd.' > '.quote($filename);
                }

                if (isset($cmd)) {
                        $error  = '';
                        $output = runCommand($cmd, true, $error);

                        if (!empty($error)) {
                                global $lang;
                                _logError($lang['BADCMD'].': '.$cmd);
                                _logError($error);

                                global $vars;
                                $vars['warning'] = nl2br(escape(toOutputEncoding($error)));
                        }
                }

                if ($highlighted && $highlight == 'line') {
                        // If we need each line independently highlighted (e.g. for diff or blame)
                        // then we'll need to filter the output of the highlighter
                        // to make sure tags like <font>, <i> or <b> don't span lines

                        $dst = fopen($filename, 'w');
                        if ($dst) {
                                $content = file_get_contents($tempname);
                                $content = explode($explodeStr, $content);

                                // $attributes is used to remember what highlighting attributes
                                // are in effect from one line to the next
                                $attributes = array(); // start with no attributes in effect

                                foreach ($content as $line) {
                                        if ($shouldTrimOutput) {
                                                $line = trim($line);
                                        }
                                        fputs($dst, $this->highlightLine($line, $attributes)."\n");
                                }
                                fclose($dst);
                        }
                }
                if ($tempname != $filename) {
                        @unlink($tempname);
                }
                return $highlighted;
        }

        // }}}

        // {{{ highlightLanguageUsingGeshi
        //
        // check if geshi can highlight the given extension and return the language

        function highlightLanguageUsingGeshi($path) {
                global $config;
                global $extGeshi;

                $filename = basename($path);
                $ext = strrchr($path, '.');
                if (substr($ext, 0, 1) == '.') $ext = substr($ext, 1);

                foreach ($extGeshi as $language => $extensions) {
                        if (in_array($filename, $extensions) || in_array(strtolower($ext), $extensions)) {
                                if ($this->geshi === null) {
                                        if (!defined('USE_AUTOLOADER')) {
                                                require_once $config->getGeshiScript();
                                        }
                                        $this->geshi = new GeSHi();
                                }
                                $this->geshi->set_language($language);
                                if ($this->geshi->error() === false) {
                                        return $language;
                                }
                        }
                }
                return '';
        }

        // }}}

        // {{{ applyGeshi
        //
        // perform syntax highlighting using geshi

        function applyGeshi($path, $filename, $language, $rev, $peg = '', $return = false, $highlight = 'file') {
                global $config;

                // Output the file to the filename
                $error  = '';
                $cmd    = $this->svnCommandString('cat', $path, $rev, $peg).' > '.quote($filename);
                $output = runCommand($cmd, true, $error);

                if (!empty($error)) {
                        global $lang;
                        _logError($lang['BADCMD'].': '.$cmd);
                        _logError($error);

                        global $vars;
                        $vars['warning'] = 'Unable to cat file: '.nl2br(escape(toOutputEncoding($error)));
                        return;
                }

                $source = file_get_contents($filename);

                if ($this->geshi === null) {
                        if (!defined('USE_AUTOLOADER')) {
                                require_once $config->getGeshiScript();
                        }
                        $this->geshi = new GeSHi();
                }

                $this->geshi->set_source($source);
                $this->geshi->set_language($language);
                $this->geshi->set_header_type(GESHI_HEADER_NONE);
                $this->geshi->set_overall_class('geshi');
                $this->geshi->set_tab_width($this->repConfig->getExpandTabsBy());

                if ($highlight == 'file') {
                        $this->geshi->enable_line_numbers(GESHI_FANCY_LINE_NUMBERS);
                        $this->geshi->set_overall_id('geshi');
                        $this->geshi->enable_ids(true);
                }

                if ($return) {
                        return $this->geshi->parse_code();
                } else {
                        $f = @fopen($filename, 'w');
                        fwrite($f, $this->geshi->parse_code());
                        fclose($f);
                }
        }

        // }}}

        // {{{ listFileContents
        //
        // Print the contents of a file without filling up Apache's memory

        function listFileContents($path, $rev = 0, $peg = '') {
                global $config;

                if ($config->useGeshi && $geshiLang = $this->highlightLanguageUsingGeshi($path)) {
                        $tempname = tempnamWithCheck($config->getTempDir(), 'websvn');
                        if ($tempname !== false) {
                                print toOutputEncoding($this->applyGeshi($path, $tempname, $geshiLang, $rev, $peg, true));
                                @unlink($tempname);
                        }
                } else {
                        $pre = false;
                        $cmd = $this->svnCommandString('cat', $path, $rev, $peg);
                        if ($config->useEnscript) {
                                $cmd .= ' | '.$this->enscriptCommandString($path).' | '.
                                        $config->sed.' -n '.$config->quote.'/^<PRE.$/,/^<\\/PRE.$/p'.$config->quote;
                        } else {
                                $pre = true;
                        }

                        if ($result = popenCommand($cmd, 'r')) {
                                if ($pre)
                                        echo '<pre>';
                                while (!feof($result)) {
                                        $line = fgets($result, 1024);
                                        $line = toOutputEncoding($line);
                                        if ($pre) {
                                                $line = escape($line);
                                        }
                                        print hardspace($line);
                                }
                                if ($pre)
                                        echo '</pre>';
                                pclose($result);
                        }
                }
        }

        // }}}

        // {{{ listReadmeContents
        //
        // Parse the README.md file
        function listReadmeContents($path, $rev = 0, $peg = '') {
                global $config;

                $file = "README.md";

                if ($this->isFile($path.$file) != True)
                {
                        return;
                }

                if (!$config->getUseParsedown())
                {
                        return;
                }

                // Autoloader handles most of the time
                if (!defined('USE_AUTOLOADER')) {
                        require_once $config->getParsedownScript();
                }

                $mdParser = new Parsedown();
                $cmd = $this->svnCommandString('cat', $path.$file, $rev, $peg);

                if (!($result = popenCommand($cmd, 'r')))
                {
                        return;
                }

                echo('<div id="wrap">');
                while (!feof($result))
                {
                        $line = fgets($result, 1024);
                        echo $mdParser->text($line);
                }
                echo('</div>');
                pclose($result);

        }

        // }}}

        // {{{ getBlameDetails
        //
        // Dump the blame content of a file to the given filename

        function getBlameDetails($path, $filename, $rev = 0, $peg = '') {
                $error  = '';
                $cmd    = $this->svnCommandString('blame', $path, $rev, $peg).' > '.quote($filename);
                $output = runCommand($cmd, true, $error);

                if (!empty($error)) {
                        global $lang;
                        _logError($lang['BADCMD'].': '.$cmd);
                        _logError($error);

                        global $vars;
                        $vars['warning'] = 'No blame info: '.nl2br(escape(toOutputEncoding($error)));
                }
        }

        // }}}

        function getProperties($path, $rev = 0, $peg = '') {
                $cmd = $this->svnCommandString('proplist', $path, $rev, $peg);
                $ret = runCommand($cmd, true);
                $properties = array();
                if (is_array($ret)) {
                        foreach ($ret as $line) {
                                if (substr($line, 0, 1) == ' ') {
                                        $properties[] = ltrim($line);
                                }
                        }
                }
                return $properties;
        }

        // {{{ getProperty

        function getProperty($path, $property, $rev = 0, $peg = '') {
                $cmd = $this->svnCommandString('propget '.$property, $path, $rev, $peg);
                $ret = runCommand($cmd, true);
                // Remove the surplus newline
                if (count($ret)) {
                        unset($ret[count($ret) - 1]);
                }
                return implode("\n", $ret);
        }

        // }}}

        // {{{ exportDirectory
        //
        // Exports the directory to the given location

        function exportRepositoryPath($path, $filename, $rev = 0, $peg = '') {
                $cmd = $this->svnCommandString('export', $path, $rev, $peg).' '.quote($filename.'@');
                $retcode = 0;
                execCommand($cmd, $retcode);
                if ($retcode != 0) {
                        global $lang;
                        _logError($lang['BADCMD'].': '.$cmd);
                }
                return $retcode;
        }

        // }}}

        // {{{ _xmlParseCmdOutput

        function _xmlParseCmdOutput($cmd, $startElem, $endElem, $charData) {
                $error          = '';
                $lines          = runCommand($cmd, false, $error);
                $linesCnt       = count($lines);
                $xml_parser     = xml_parser_create('UTF-8');

                xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true);
                xml_set_element_handler($xml_parser, $startElem, $endElem);
                xml_set_character_data_handler($xml_parser, $charData);

                for ($i = 0; $i < $linesCnt; ++$i) {
                        $line   = $lines[$i] . "\n";
                        $isLast = $i == ($linesCnt - 1);

                        if (xml_parse($xml_parser, $line, $isLast)) {
                                continue;
                        }

                        $errorMsg = sprintf('XML error: %s (%d) at line %d column %d byte %d'."\n".'cmd: %s',
                                                                xml_error_string(xml_get_error_code($xml_parser)),
                                                                xml_get_error_code($xml_parser),
                                                                xml_get_current_line_number($xml_parser),
                                                                xml_get_current_column_number($xml_parser),
                                                                xml_get_current_byte_index($xml_parser),
                                                                $cmd);

                        if (xml_get_error_code($xml_parser) == 5) {
                                break;
                        }

                        // errors can contain sensitive info! don't echo this ~J
                        _logError($errorMsg);
                        exit;
                }

                xml_parser_free($xml_parser);
                if (empty($error)) {
                        return;
                }

                $error = toOutputEncoding(nl2br(str_replace('svn: ', '', $error)));
                global $lang;
                _logError($lang['BADCMD'].': '.$cmd);
                _logError($error);

                global $vars;
                if (strstr($error, 'found format')) {
                        $vars['error'] = 'Repository uses a newer format than Subversion '.$config->getSubversionVersion().' can read. ("'.nl2br(escape(toOutputEncoding(substr($error, strrpos($error, 'Expected'))))).'.")';
                } else if (strstr($error, 'No such revision')) {
                        $vars['warning'] = 'Revision '.$rev.' of this resource does not exist.';
                } else {
                        $vars['error'] = $lang['BADCMD'].': <code>'.escape(stripCredentialsFromCommand($cmd)).'</code><br />'.nl2br(escape(toOutputEncoding($error)));
                }
        }

        // }}}

        // {{{ getInfo

        function getInfo($path, $rev = 0, $peg = '') {
                global $config, $curInfo;

                // Since directories returned by svn log don't have trailing slashes (:-(), we need to remove
                // the trailing slash from the path for comparison purposes

                if ($path[strlen($path) - 1] == '/' && $path != '/') {
                        $path = substr($path, 0, -1);
                }

                $curInfo = new SVNInfoEntry;

                // Get the svn info

                if ($rev == 0) {
                        $headlog = $this->getLog('/', '', '', true, 1);
                        if ($headlog && isset($headlog->entries[0]))
                                $rev = $headlog->entries[0]->rev;
                }

                $cmd = $this->svnCommandString('info --xml', $path, $rev, $peg);
                $this->_xmlParseCmdOutput($cmd, 'infoStartElement', 'infoEndElement', 'infoCharacterData');

                if ($this->repConfig->subpath !== null) {
                        if (substr($curInfo->path, 0, strlen($this->repConfig->subpath) + 1) === '/'. $this->repConfig->subpath) {
                                $curInfo->path = substr($curInfo->path, strlen($this->repConfig->subpath) + 1);
                        } else {
                                // hide entry when file is outside of subpath
                                return null;
                        }
                }

                return $curInfo;
        }

        // }}}

        // {{{ getList

        function getList($path, $rev = 0, $peg = '') {
                global $config, $curList;

                // Since directories returned by svn log don't have trailing slashes (:-(), we need to remove
                // the trailing slash from the path for comparison purposes

                if ($path[strlen($path) - 1] == '/' && $path != '/') {
                        $path = substr($path, 0, -1);
                }

                $curList = new SVNList;
                $curList->entries = array();
                $curList->path = $path;

                // Get the list info

                if ($rev == 0) {
                        $headlog = $this->getLog('/', '', '', true, 1);
                        if ($headlog && isset($headlog->entries[0]))
                                $rev = $headlog->entries[0]->rev;
                }

                if ($config->showLoadAllRepos()) {
                        $cmd = $this->svnCommandString('list -R --xml', $path, $rev, $peg);
                        $this->_xmlParseCmdOutput($cmd, 'listStartElement', 'listEndElement', 'listCharacterData');
                }
                else {
                        $cmd = $this->svnCommandString('list --xml', $path, $rev, $peg);
                        $this->_xmlParseCmdOutput($cmd, 'listStartElement', 'listEndElement', 'listCharacterData');
                        usort($curList->entries, '_listSort');
                }

                return $curList;
        }

        // }}}

        // {{{ getListSearch

        function getListSearch($path, $term = '', $rev = 0, $peg = '') {
                global $config, $curList;

                // Since directories returned by "svn log" don't have trailing slashes (:-(), we need to
                // remove the trailing slash from the path for comparison purposes.
                if (($path[strlen($path) - 1] == '/') && ($path != '/')) {
                        $path = substr($path, 0, -1);
                }

                $curList                        = new SVNList;
                $curList->entries       = array();
                $curList->path          = $path;

                // Get the list info

                if ($rev == 0) {
                        $headlog = $this->getLog('/', '', '', true, 1);
                        if ($headlog && isset($headlog->entries[0]))
                                $rev = $headlog->entries[0]->rev;
                }

                $term   = escapeshellarg($term);
                $cmd    = 'list -R --search ' . $term . ' --xml';
                $cmd    = $this->svnCommandString($cmd, $path, $rev, $peg);
                $this->_xmlParseCmdOutput($cmd, 'listStartElement', 'listEndElement', 'listCharacterData');

                return $curList;
        }

        // }}}


        // {{{ getLog

        function getLog($path, $brev = '', $erev = 1, $quiet = false, $limit = 2, $peg = '', $verbose = false) {
                global $config, $curLog;

                // Since directories returned by svn log don't have trailing slashes (:-(),
                // we must remove the trailing slash from the path for comparison purposes.
                if (!empty($path) && $path != '/' && $path[strlen($path) - 1] == '/') {
                        $path = substr($path, 0, -1);
                }

                $curLog = new SVNLog;
                $curLog->entries = array();
                $curLog->path = $path;

                // Get the log info
                $effectiveRev   = ($brev && $erev ? $brev.':'.$erev : ($brev ? $brev.':1' : ''));
                $effectivePeg   = ($peg ? $peg : ($brev ? $brev : ''));
                $cmd                    = $this->svnCommandString('log --xml '.($verbose ? '--verbose' : ($quiet ? '--quiet' : '')).($limit != 0 ? ' --limit '.$limit : ''), $path, $effectiveRev, $effectivePeg);

                $this->_xmlParseCmdOutput($cmd, 'logStartElement', 'logEndElement', 'logCharacterData');

                foreach ($curLog->entries as $entryKey => $entry) {
                        $fullModAccess = true;
                        $anyModAccess = (count($entry->mods) == 0);
                        $precisePath = null;
                        foreach ($entry->mods as $modKey => $mod) {
                                $access = $this->repConfig->hasLogReadAccess($mod->path);
                                if ($access) {
                                        $anyModAccess = true;

                                        // find path which is parent of all modification but more precise than $curLogEntry->path
                                        $modpath = $mod->path;
                                        if (!$mod->isdir || $mod->action == 'D') {
                                                $pos = strrpos($modpath, '/');
                                                $modpath = substr($modpath, 0, $pos + 1);
                                        }
                                        if (strlen($modpath) == 0 || substr($modpath, -1) !== '/') {
                                                $modpath .= '/';
                                        }
                                        //compare with current precise path
                                        if ($precisePath === null) {
                                                $precisePath = $modpath;
                                        } else {
                                                $equalPart = _equalPart($precisePath, $modpath);
                                                if (substr($equalPart, -1) !== '/') {
                                                        $pos = strrpos($equalPart, '/');
                                                        $equalPart = substr($equalPart, 0, $pos + 1);
                                                }
                                                $precisePath = $equalPart;
                                        }

                                        // fix paths if command was for a subpath repository
                                        if ($this->repConfig->subpath !== null) {
                                                if (substr($mod->path, 0, strlen($this->repConfig->subpath) + 1) === '/'. $this->repConfig->subpath) {
                                                        $curLog->entries[$entryKey]->mods[$modKey]->path = substr($mod->path, strlen($this->repConfig->subpath) + 1);
                                                } else {
                                                        // hide modified entry when file is outside of subpath
                                                        unset($curLog->entries[$entryKey]->mods[$modKey]);
                                                }
                                        }
                                } else {
                                        // hide modified entry when access is prohibited
                                        unset($curLog->entries[$entryKey]->mods[$modKey]);
                                        $fullModAccess = false;
                                }
                        }
                        if (!$fullModAccess) {
                                // hide commit message when access to any of the entries is prohibited
                                $curLog->entries[$entryKey]->msg = '';
                        }
                        if (!$anyModAccess) {
                                // hide author and date when access to all of the entries is prohibited
                                $curLog->entries[$entryKey]->author = '';
                                $curLog->entries[$entryKey]->date = '';
                                $curLog->entries[$entryKey]->committime = '';
                                $curLog->entries[$entryKey]->age = '';
                        }

                        if ($precisePath !== null) {
                                $curLog->entries[$entryKey]->precisePath = $precisePath;
                        } else {
                                $curLog->entries[$entryKey]->precisePath = $curLog->entries[$entryKey]->path;
                        }
                }
                return $curLog;
        }

        // }}}

        function isFile($path, $rev = 0, $peg = '') {
                $cmd = $this->svnCommandString('info --xml', $path, $rev, $peg);
                return strpos(implode(' ', runCommand($cmd, true)), 'kind="file"') !== false;
        }

        // {{{ getSvnPath

        function getSvnPath($path) {
                if ($this->repConfig->subpath === null) {
                        return $this->repConfig->path.$path;
                } else {
                        return $this->repConfig->path.'/'.$this->repConfig->subpath.$path;
                }
        }

        // }}}

}

// Initialize SVN version information by parsing from command-line output.
$cmd = $config->getSvnCommand();
$cmd = str_replace(array('--non-interactive', '--trust-server-cert'), array('', ''), $cmd);
$cmd .= ' --version -q';
$ret = runCommand($cmd, false);
if (preg_match('~([0-9]+)\.([0-9]+)\.([0-9]+)~', $ret[0], $matches)) {
        $config->setSubversionVersion($matches[0]);
        $config->setSubversionMajorVersion($matches[1]);
        $config->setSubversionMinorVersion($matches[2]);
}