3b53ceedcd
* Monotone.php (IDF_Scm_Monotone_Stdio): add support for multiple, equally named options * Source.php, commit.html: split-off the global commit template (which had some separate code already for SVN) and adapt the left blocks for mtn to shorten branch and tag names just like we do everywhere else
613 lines
28 KiB
PHP
613 lines
28 KiB
PHP
<?php
|
|
/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
# ***** BEGIN LICENSE BLOCK *****
|
|
# This file is part of InDefero, an open source project management application.
|
|
# Copyright (C) 2008 Céondo Ltd and contributors.
|
|
#
|
|
# InDefero 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.
|
|
#
|
|
# InDefero 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
#
|
|
# ***** END LICENSE BLOCK ***** */
|
|
|
|
Pluf::loadFunction('Pluf_HTTP_URL_urlForView');
|
|
Pluf::loadFunction('Pluf_Shortcuts_RenderToResponse');
|
|
Pluf::loadFunction('Pluf_Shortcuts_GetObjectOr404');
|
|
Pluf::loadFunction('Pluf_Shortcuts_GetFormForModel');
|
|
|
|
/**
|
|
* View SCM repository.
|
|
*/
|
|
class IDF_Views_Source
|
|
{
|
|
/**
|
|
* Extension supported by the syntax highlighter.
|
|
*/
|
|
public static $supportedExtenstions = array(
|
|
'ascx', 'ashx', 'asmx', 'aspx', 'browser', 'bsh', 'c', 'cc',
|
|
'config', 'cpp', 'cs', 'csh', 'csproj', 'css', 'cv', 'cyc',
|
|
'html', 'html', 'java', 'js', 'master', 'perl', 'php', 'pl',
|
|
'pm', 'py', 'rb', 'sh', 'sitemap', 'skin', 'sln', 'svc', 'vala',
|
|
'vb', 'vbproj', 'wsdl', 'xhtml', 'xml', 'xsd', 'xsl', 'xslt');
|
|
|
|
/**
|
|
* Display help on how to checkout etc.
|
|
*/
|
|
public $help_precond = array('IDF_Precondition::accessSource');
|
|
public function help($request, $match)
|
|
{
|
|
$title = sprintf(__('%s Source Help'), (string) $request->project);
|
|
$scm = IDF_Scm::get($request->project);
|
|
$scmConf = $request->conf->getVal('scm', 'git');
|
|
$params = array(
|
|
'page_title' => $title,
|
|
'title' => $title,
|
|
'scm' => $scmConf,
|
|
);
|
|
return Pluf_Shortcuts_RenderToResponse('idf/source/'.$scmConf.'/help.html',
|
|
$params, $request);
|
|
}
|
|
|
|
public $changeLog_precond = array('IDF_Precondition::accessSource');
|
|
public function changeLog($request, $match)
|
|
{
|
|
$scm = IDF_Scm::get($request->project);
|
|
if (!$scm->isAvailable()) {
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::help',
|
|
array($request->project->shortname));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$branches = $scm->getBranches();
|
|
$commit = $match[2];
|
|
if (!$scm->isValidRevision($commit)) {
|
|
if (count($branches) == 0) {
|
|
// Redirect to the project source help
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::help',
|
|
array($request->project->shortname));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
// Redirect to the first branch
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::changeLog',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$title = sprintf(__('%1$s %2$s Change Log'), (string) $request->project,
|
|
$this->getScmType($request));
|
|
$changes = $scm->getChangeLog($commit, 25);
|
|
$rchanges = array();
|
|
// Sync with the database
|
|
foreach ($changes as $change) {
|
|
$rchanges[] = IDF_Commit::getOrAdd($change, $request->project);
|
|
}
|
|
$rchanges = new Pluf_Template_ContextVars($rchanges);
|
|
$scmConf = $request->conf->getVal('scm', 'git');
|
|
$in_branches = $scm->inBranches($commit, '');
|
|
$tags = $scm->getTags();
|
|
$in_tags = $scm->inTags($commit, '');
|
|
return Pluf_Shortcuts_RenderToResponse('idf/source/'.$scmConf.'/changelog.html',
|
|
array(
|
|
'page_title' => $title,
|
|
'title' => $title,
|
|
'changes' => $rchanges,
|
|
'commit' => $commit,
|
|
'branches' => $branches,
|
|
'tree_in' => $in_branches,
|
|
'tags' => $tags,
|
|
'tags_in' => $in_tags,
|
|
'scm' => $scmConf,
|
|
),
|
|
$request);
|
|
}
|
|
|
|
public $treeBase_precond = array('IDF_Precondition::accessSource');
|
|
public function treeBase($request, $match)
|
|
{
|
|
$scm = IDF_Scm::get($request->project);
|
|
if (!$scm->isAvailable()) {
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::help',
|
|
array($request->project->shortname));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$commit = $match[2];
|
|
$cobject = $scm->getCommit($commit);
|
|
if (!$cobject) {
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::treeBase',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$title = sprintf(__('%1$s %2$s Source Tree'),
|
|
$request->project, $this->getScmType($request));
|
|
$branches = $scm->getBranches();
|
|
$in_branches = $scm->inBranches($commit, '');
|
|
$tags = $scm->getTags();
|
|
$in_tags = $scm->inTags($commit, '');
|
|
$cache = Pluf_Cache::factory();
|
|
$key = sprintf('Project:%s::IDF_Views_Source::treeBase:%s::',
|
|
$request->project->id, $commit);
|
|
if (null === ($res=$cache->get($key))) {
|
|
$res = new Pluf_Template_ContextVars($scm->getTree($commit));
|
|
$cache->set($key, $res);
|
|
}
|
|
$scmConf = $request->conf->getVal('scm', 'git');
|
|
$props = $scm->getProperties($commit);
|
|
return Pluf_Shortcuts_RenderToResponse('idf/source/'.$scmConf.'/tree.html',
|
|
array(
|
|
'page_title' => $title,
|
|
'title' => $title,
|
|
'files' => $res,
|
|
'cobject' => $cobject,
|
|
'commit' => $commit,
|
|
'tree_in' => $in_branches,
|
|
'branches' => $branches,
|
|
'tags' => $tags,
|
|
'tags_in' => $in_tags,
|
|
'props' => $props,
|
|
),
|
|
$request);
|
|
}
|
|
|
|
public $tree_precond = array('IDF_Precondition::accessSource');
|
|
public function tree($request, $match)
|
|
{
|
|
$scm = IDF_Scm::get($request->project);
|
|
$commit = $match[2];
|
|
|
|
if (!$scm->isAvailable()) {
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::help',
|
|
array($request->project->shortname));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$fburl = Pluf_HTTP_URL_urlForView('IDF_Views_Source::treeBase',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
$request_file = $match[3];
|
|
if (substr($request_file, -1) == '/') {
|
|
$request_file = substr($request_file, 0, -1);
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::tree',
|
|
array($match[1], $match[2],
|
|
$request_file));
|
|
return new Pluf_HTTP_Response_Redirect($url, 301);
|
|
}
|
|
if (!$scm->isValidRevision($commit, $request_file)) {
|
|
// Redirect to the first branch
|
|
return new Pluf_HTTP_Response_Redirect($fburl);
|
|
}
|
|
$request_file_info = $scm->getPathInfo($request_file, $commit);
|
|
if (!$request_file_info) {
|
|
// Redirect to the first branch
|
|
return new Pluf_HTTP_Response_Redirect($fburl);
|
|
}
|
|
$branches = $scm->getBranches();
|
|
$tags = $scm->getTags();
|
|
if ($request_file_info->type != 'tree') {
|
|
$info = self::getRequestedFileMimeType($request_file_info,
|
|
$commit, $scm);
|
|
if (!self::isText($info)) {
|
|
$rep = new Pluf_HTTP_Response($scm->getFile($request_file_info),
|
|
$info[0]);
|
|
$rep->headers['Content-Disposition'] = 'attachment; filename="'.$info[1].'"';
|
|
return $rep;
|
|
} else {
|
|
// We want to display the content of the file as text
|
|
$extra = array('branches' => $branches,
|
|
'tags' => $tags,
|
|
'commit' => $commit,
|
|
'request_file' => $request_file,
|
|
'request_file_info' => $request_file_info,
|
|
'mime' => $info,
|
|
);
|
|
return $this->viewFile($request, $match, $extra);
|
|
}
|
|
}
|
|
|
|
$bc = self::makeBreadCrumb($request->project, $commit, $request_file_info->fullpath);
|
|
$title = sprintf(__('%1$s %2$s Source Tree'),
|
|
$request->project, $this->getScmType($request));
|
|
|
|
$page_title = $bc.' - '.$title;
|
|
$cobject = $scm->getCommit($commit);
|
|
if (!$cobject) {
|
|
// Redirect to the first branch
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::treeBase',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$in_branches = $scm->inBranches($commit, $request_file);
|
|
$in_tags = $scm->inTags($commit, $request_file);
|
|
$cache = Pluf_Cache::factory();
|
|
$key = sprintf('Project:%s::IDF_Views_Source::tree:%s::%s',
|
|
$request->project->id, $commit, $request_file);
|
|
if (null === ($res=$cache->get($key))) {
|
|
$res = new Pluf_Template_ContextVars($scm->getTree($commit, $request_file));
|
|
$cache->set($key, $res);
|
|
}
|
|
// try to find the previous level if it exists.
|
|
$prev = explode('/', $request_file);
|
|
$l = array_pop($prev);
|
|
$previous = substr($request_file, 0, -strlen($l.' '));
|
|
$scmConf = $request->conf->getVal('scm', 'git');
|
|
$props = $scm->getProperties($commit, $request_file);
|
|
return Pluf_Shortcuts_RenderToResponse('idf/source/'.$scmConf.'/tree.html',
|
|
array(
|
|
'page_title' => $page_title,
|
|
'title' => $title,
|
|
'breadcrumb' => $bc,
|
|
'files' => $res,
|
|
'commit' => $commit,
|
|
'cobject' => $cobject,
|
|
'base' => $request_file_info->file,
|
|
'prev' => $previous,
|
|
'tree_in' => $in_branches,
|
|
'branches' => $branches,
|
|
'tags' => $tags,
|
|
'tags_in' => $in_tags,
|
|
'props' => $props,
|
|
),
|
|
$request);
|
|
}
|
|
|
|
public static function makeBreadCrumb($project, $commit, $file, $sep='/')
|
|
{
|
|
$elts = explode('/', $file);
|
|
$out = array();
|
|
$stack = '';
|
|
$i = 0;
|
|
foreach ($elts as $elt) {
|
|
$stack .= ($i==0) ? rawurlencode($elt) : '/'.rawurlencode($elt);
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::tree',
|
|
array($project->shortname,
|
|
$commit, $stack));
|
|
$out[] = '<a href="'.$url.'">'.Pluf_esc($elt).'</a>';
|
|
$i++;
|
|
}
|
|
return '<span class="breadcrumb">'.implode('<span class="sep">'.$sep.'</span>', $out).'</span>';
|
|
}
|
|
|
|
public $commit_precond = array('IDF_Precondition::accessSource');
|
|
public function commit($request, $match)
|
|
{
|
|
$scm = IDF_Scm::get($request->project);
|
|
$commit = $match[2];
|
|
if (!$scm->isValidRevision($commit)) {
|
|
// Redirect to the first branch
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::treeBase',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$large = $scm->isCommitLarge($commit);
|
|
$cobject = $scm->getCommit($commit, !$large);
|
|
if (!$cobject) {
|
|
// Redirect to the first branch
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::treeBase',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$title = sprintf(__('%s Commit Details'), (string) $request->project);
|
|
$page_title = sprintf(__('%s Commit Details - %s'), (string) $request->project, $commit);
|
|
$rcommit = IDF_Commit::getOrAdd($cobject, $request->project);
|
|
$diff = new IDF_Diff($cobject->changes);
|
|
$diff->parse();
|
|
$scmConf = $request->conf->getVal('scm', 'git');
|
|
$branches = $scm->getBranches();
|
|
$in_branches = $scm->inBranches($cobject->commit, '');
|
|
$tags = $scm->getTags();
|
|
$in_tags = $scm->inTags($cobject->commit, '');
|
|
return Pluf_Shortcuts_RenderToResponse('idf/source/'.$scmConf.'/commit.html',
|
|
array(
|
|
'page_title' => $page_title,
|
|
'title' => $title,
|
|
'diff' => $diff,
|
|
'cobject' => $cobject,
|
|
'commit' => $commit,
|
|
'branches' => $branches,
|
|
'tree_in' => $in_branches,
|
|
'tags' => $tags,
|
|
'tags_in' => $in_tags,
|
|
'scm' => $scmConf,
|
|
'rcommit' => $rcommit,
|
|
'large_commit' => $large,
|
|
),
|
|
$request);
|
|
}
|
|
|
|
public $downloadDiff_precond = array('IDF_Precondition::accessSource');
|
|
public function downloadDiff($request, $match)
|
|
{
|
|
$scm = IDF_Scm::get($request->project);
|
|
$commit = $match[2];
|
|
if (!$scm->isValidRevision($commit)) {
|
|
// Redirect to the first branch
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::treeBase',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$cobject = $scm->getCommit($commit, true);
|
|
$rep = new Pluf_HTTP_Response($cobject->changes, 'text/plain');
|
|
$rep->headers['Content-Disposition'] = 'attachment; filename="'.$commit.'.diff"';
|
|
return $rep;
|
|
}
|
|
|
|
/**
|
|
* Should only be called through self::tree
|
|
*/
|
|
public function viewFile($request, $match, $extra)
|
|
{
|
|
$title = sprintf(__('%1$s %2$s Source Tree'), (string) $request->project,
|
|
$this->getScmType($request));
|
|
$scm = IDF_Scm::get($request->project);
|
|
$branches = $extra['branches'];
|
|
$tags = $extra['tags'];
|
|
$commit = $extra['commit'];
|
|
$request_file = $extra['request_file'];
|
|
$request_file_info = $extra['request_file_info'];
|
|
$bc = self::makeBreadCrumb($request->project, $commit, $request_file_info->fullpath);
|
|
$page_title = $bc.' - '.$title;
|
|
$cobject = $scm->getCommit($commit);
|
|
$in_branches = $scm->inBranches($commit, $request_file);
|
|
$in_tags = $scm->inTags($commit, '');
|
|
// try to find the previous level if it exists.
|
|
$prev = explode('/', $request_file);
|
|
$l = array_pop($prev);
|
|
$previous = substr($request_file, 0, -strlen($l.' '));
|
|
$scmConf = $request->conf->getVal('scm', 'git');
|
|
$props = $scm->getProperties($commit, $request_file);
|
|
$content = self::highLight($extra['mime'], $scm->getFile($request_file_info));
|
|
return Pluf_Shortcuts_RenderToResponse('idf/source/'.$scmConf.'/file.html',
|
|
array(
|
|
'page_title' => $page_title,
|
|
'title' => $title,
|
|
'breadcrumb' => $bc,
|
|
'file' => $content,
|
|
'commit' => $commit,
|
|
'cobject' => $cobject,
|
|
'fullpath' => $request_file,
|
|
'efullpath' => IDF_Scm::smartEncode($request_file),
|
|
'base' => $request_file_info->file,
|
|
'prev' => $previous,
|
|
'tree_in' => $in_branches,
|
|
'branches' => $branches,
|
|
'tags' => $tags,
|
|
'tags_in' => $in_tags,
|
|
'props' => $props,
|
|
),
|
|
$request);
|
|
}
|
|
|
|
/**
|
|
* Get a given file at a given commit.
|
|
*
|
|
*/
|
|
public $getFile_precond = array('IDF_Precondition::accessSource');
|
|
public function getFile($request, $match)
|
|
{
|
|
$scm = IDF_Scm::get($request->project);
|
|
$commit = $match[2];
|
|
$request_file = $match[3];
|
|
if (!$scm->isValidRevision($commit)) {
|
|
// Redirect to the first branch
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::treeBase',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$request_file_info = $scm->getPathInfo($request_file, $commit);
|
|
if (!$request_file_info or $request_file_info->type == 'tree') {
|
|
// Redirect to the first branch
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::treeBase',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$info = self::getRequestedFileMimeType($request_file_info,
|
|
$commit, $scm);
|
|
$rep = new Pluf_HTTP_Response($scm->getFile($request_file_info),
|
|
$info[0]);
|
|
$rep->headers['Content-Disposition'] = 'attachment; filename="'.$info[1].'"';
|
|
return $rep;
|
|
}
|
|
|
|
/**
|
|
* Get a zip archive of the current commit.
|
|
*
|
|
*/
|
|
public $download_precond = array('IDF_Precondition::accessSource');
|
|
public function download($request, $match)
|
|
{
|
|
$commit = trim($match[2]);
|
|
$scm = IDF_Scm::get($request->project);
|
|
if (!$scm->isValidRevision($commit)) {
|
|
// Redirect to the first branch
|
|
$url = Pluf_HTTP_URL_urlForView('IDF_Views_Source::treeBase',
|
|
array($request->project->shortname,
|
|
$scm->getMainBranch()));
|
|
return new Pluf_HTTP_Response_Redirect($url);
|
|
}
|
|
$base = $request->project->shortname.'-'.$commit;
|
|
$cmd = $scm->getArchiveCommand($commit, $base.'/');
|
|
$rep = new Pluf_HTTP_Response_CommandPassThru($cmd, 'application/x-zip');
|
|
$rep->headers['Content-Transfer-Encoding'] = 'binary';
|
|
$rep->headers['Content-Disposition'] = 'attachment; filename="'.$base.'.zip"';
|
|
return $rep;
|
|
}
|
|
|
|
|
|
/**
|
|
* Find the mime type of a requested file.
|
|
*
|
|
* @param stdClass Request file info
|
|
* @param string Commit at which we want the file
|
|
* @param IDF_Scm SCM object
|
|
* @param array Mime type found or 'application/octet-stream', basename, extension
|
|
*/
|
|
public static function getRequestedFileMimeType($file_info, $commit, $scm)
|
|
{
|
|
$mime = self::getMimeType($file_info->file);
|
|
if ('application/octet-stream' != $mime[0]) {
|
|
return $mime;
|
|
}
|
|
return self::getMimeTypeFromContent($file_info->file,
|
|
$scm->getFile($file_info));
|
|
}
|
|
|
|
/**
|
|
* Find the mime type of a file using the fileinfo class.
|
|
*
|
|
* @param string Filename/Filepath
|
|
* @param string File content
|
|
* @return array Mime type found or 'application/octet-stream', basename, extension
|
|
*/
|
|
public static function getMimeTypeFromContent($file, $filedata)
|
|
{
|
|
$info = pathinfo($file);
|
|
$res = array('application/octet-stream',
|
|
$info['basename'],
|
|
isset($info['extension']) ? $info['extension'] : 'bin');
|
|
if (function_exists('finfo_open')) {
|
|
$finfo = finfo_open(FILEINFO_MIME);
|
|
$mime = finfo_buffer($finfo, $filedata);
|
|
finfo_close($finfo);
|
|
if ($mime) {
|
|
$res[0] = $mime;
|
|
}
|
|
if (!isset($info['extension']) && $mime) {
|
|
$res[2] = (0 === strpos($mime, 'text/')) ? 'txt' : 'bin';
|
|
} elseif (!isset($info['extension'])) {
|
|
$res[2] = 'bin';
|
|
}
|
|
}
|
|
return $res;
|
|
}
|
|
|
|
|
|
/**
|
|
* Find the mime type of a file.
|
|
*
|
|
* Use /etc/mime.types to find the type.
|
|
*
|
|
* @param string Filename/Filepath
|
|
* @param array Mime type found or 'application/octet-stream', basename, extension
|
|
*/
|
|
public static function getMimeType($file)
|
|
{
|
|
$src= Pluf::f('idf_mimetypes_db', '/etc/mime.types');
|
|
$mimes = preg_split("/\015\012|\015|\012/", file_get_contents($src));
|
|
$info = pathinfo($file);
|
|
if (isset($info['extension'])) {
|
|
foreach ($mimes as $mime) {
|
|
if ('#' != substr($mime, 0, 1)) {
|
|
$elts = preg_split('/ |\t/', $mime, -1, PREG_SPLIT_NO_EMPTY);
|
|
if (in_array($info['extension'], $elts)) {
|
|
return array($elts[0], $info['basename'], $info['extension']);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// we consider that if no extension and base name is all
|
|
// uppercase, then we have a text file.
|
|
if ($info['basename'] == strtoupper($info['basename'])) {
|
|
return array('text/plain', $info['basename'], 'txt');
|
|
}
|
|
$info['extension'] = 'bin';
|
|
}
|
|
return array('application/octet-stream', $info['basename'], $info['extension']);
|
|
}
|
|
|
|
/**
|
|
* Find if a given mime type is a text file.
|
|
* This uses the output of the self::getMimeType function.
|
|
*
|
|
* @param array (Mime type, file name, extension)
|
|
* @return bool Is text
|
|
*/
|
|
public static function isText($fileinfo)
|
|
{
|
|
if (0 === strpos($fileinfo[0], 'text/')) {
|
|
return true;
|
|
}
|
|
$ext = 'mdtext php-dist h gitignore diff patch'
|
|
.Pluf::f('idf_extra_text_ext', '');
|
|
$ext = array_merge(self::$supportedExtenstions, explode(' ' , $ext));
|
|
return (in_array($fileinfo[2], $ext));
|
|
}
|
|
|
|
public static function highLight($fileinfo, $content)
|
|
{
|
|
$pretty = '';
|
|
if (self::isSupportedExtension($fileinfo[2])) {
|
|
$pretty = ' prettyprint';
|
|
}
|
|
$table = array();
|
|
$i = 1;
|
|
foreach (preg_split("/\015\012|\015|\012/", $content) as $line) {
|
|
$table[] = '<tr class="c-line"><td class="code-lc" id="L'.$i.'"><a href="#L'.$i.'">'.$i.'</a></td>'
|
|
.'<td class="code mono'.$pretty.'">'.IDF_Diff::padLine(Pluf_esc($line)).'</td></tr>';
|
|
$i++;
|
|
}
|
|
return Pluf_Template::markSafe(implode("\n", $table));
|
|
}
|
|
|
|
/**
|
|
* Test if an extension is supported by the syntax highlighter.
|
|
*
|
|
* @param string The extension to test
|
|
* @return bool
|
|
*/
|
|
public static function isSupportedExtension($extension)
|
|
{
|
|
return in_array($extension, self::$supportedExtenstions);
|
|
}
|
|
|
|
/**
|
|
* Get the scm type for page title
|
|
*
|
|
* @return String
|
|
*/
|
|
private function getScmType($request)
|
|
{
|
|
return mb_convert_case($request->conf->getVal('scm', 'git'),
|
|
MB_CASE_TITLE, 'UTF-8');
|
|
}
|
|
}
|
|
|
|
function IDF_Views_Source_PrettySize($size)
|
|
{
|
|
return Pluf_Template::markSafe(str_replace(' ', ' ',
|
|
Pluf_Utils::prettySize($size)));
|
|
}
|
|
|
|
function IDF_Views_Source_PrettySizeSimple($size)
|
|
{
|
|
return Pluf_Utils::prettySize($size);
|
|
}
|
|
|
|
function IDF_Views_Source_ShortenString($string, $length)
|
|
{
|
|
$ellipse = "...";
|
|
$length = max(strlen($ellipse) + 2, $length);
|
|
$preflen = ceil($length / 10);
|
|
|
|
if (mb_strlen($string) < $length)
|
|
return $string;
|
|
|
|
return substr($string, 0, $preflen).$ellipse.
|
|
substr($string, -($length - $preflen - mb_strlen($ellipse)));
|
|
}
|
|
|