You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdevelop/lib/util/urlutil.cpp

320 lines
9.6 KiB

/* This file is part of the KDE project
Copyright (C) 2003 Julian Rockey <linux@jrockey.com>
Copyright (C) 2003 Alexander Dymo <cloudtemple@mksat.net>
Copyright (C) 2003 Mario Scalas <mario.scalas@libero.it>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include <tqstringlist.h>
#include <tqdir.h>
#include <tqfileinfo.h>
#include <kdebug.h>
#include <unistd.h>
#include <limits.h>
#include <stdlib.h>
#include "urlutil.h"
#include <tdeversion.h>
///////////////////////////////////////////////////////////////////////////////
// Namespace URLUtil
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::filename(const TQString & name) {
int slashPos = name.findRev("/");
return slashPos<0 ? name : name.mid(slashPos+1);
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::directory(const TQString & name) {
int slashPos = name.findRev("/");
return slashPos<0 ? TQString("") : name.left(slashPos);
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::getRelativePath(const TQString& basepath, const TQString& destpath)
{
TQString relpath = ".";
if (!TQFile::exists(basepath) ||
!TQFile::exists(destpath))
return "";
TQStringList basedirs = TQStringList::split(TQString( TQChar( TQDir::separator() ) ),basepath);
TQStringList destdirs = TQStringList::split(TQString( TQChar( TQDir::separator() ) ),destpath);
int maxCompare=0;
if (basedirs.count()>=destdirs.count())
maxCompare=destdirs.count();
else
maxCompare=basedirs.count();
int lastCommonDir=-1;
for (int i=0; i<maxCompare; i++)
{
if (basedirs[i] != destdirs[i])
break;
lastCommonDir=i;
}
for (uint i=0;i<basedirs.count()-(lastCommonDir+1); i++)
relpath += TQString( TQChar( TQDir::separator() ) )+TQString("..");
for (int i=0; i<lastCommonDir+1; i++)
destdirs.pop_front();
if (destdirs.count())
relpath += TQString( TQChar( TQDir::separator() ) )+destdirs.join( TQChar( TQDir::separator() ) );
return TQDir::cleanDirPath(relpath);
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::relativePath(const KURL & parent, const KURL & child, uint slashPolicy) {
bool slashPrefix = slashPolicy & SLASH_PREFIX;
bool slashSuffix = slashPolicy & SLASH_SUFFIX;
if (parent.equals(child,true))
return slashPrefix ? TQString("/") : TQString("");
if (!parent.isParentOf(child)) return TQString();
int a=slashPrefix ? -1 : 1;
int b=slashSuffix ? 1 : -1;
return child.path(b).mid(parent.path(a).length());
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::relativePath(const TQString & parent, const TQString & child, uint slashPolicy) {
return relativePath(KURL(parent), KURL(child), slashPolicy);
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::upDir(const TQString & path, bool slashSuffix) {
int slashPos = path.findRev("/");
if (slashPos<1) return TQString();
return path.mid(0,slashPos+ (slashSuffix ? 1 : 0) );
}
///////////////////////////////////////////////////////////////////////////////
KURL URLUtil::mergeURL(const KURL & source, const KURL & dest, const KURL & child) {
// if already a child of source, then fine
if (source.isParentOf(child) || source.equals(child,true)) return child;
// if not a child of dest, return blank URL (error)
if (!dest.isParentOf(child) && !dest.equals(child,true)) return KURL();
// if child is same as dest, return source
if (dest.equals(child,true)) return source;
// calculate
TQString childUrlStr = child.url(-1);
TQString destStemStr = dest.url(1);
TQString sourceStemStr = source.url(1);
return KURL(sourceStemStr.append( childUrlStr.mid( destStemStr.length() ) ) );
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::getExtension(const TQString & path) {
int dotPos = path.findRev('.');
if (dotPos<0) return TQString("");
return path.mid(dotPos+1);
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::extractPathNameRelative(const KURL &baseDirUrl, const KURL &url )
{
TQString absBase = extractPathNameAbsolute( baseDirUrl ),
absRef = extractPathNameAbsolute( url );
int i = absRef.find( absBase, 0, true );
if (i == -1)
return TQString();
if (absRef == absBase)
return TQString( "." );
else
return absRef.replace( 0, absBase.length(), TQString() );
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::extractPathNameRelative(const TQString &basePath, const KURL &url )
{
KURL baseDirUrl = KURL::fromPathOrURL( basePath );
return extractPathNameRelative( baseDirUrl, url );
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::extractPathNameRelative(const TQString &basePath, const TQString &absFilePath )
{
KURL baseDirUrl = KURL::fromPathOrURL( basePath ),
fileUrl = KURL::fromPathOrURL( absFilePath );
return extractPathNameRelative( baseDirUrl, fileUrl );
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::extractPathNameAbsolute( const KURL &url )
{
if (isDirectory( url ))
return url.path( +1 ); // with trailing "/" if none is present
else
{
// Ok, this is an over-tight pre-condition on "url" since I hope nobody will never
// stress this function with absurd cases ... but who knows?
/*
TQString path = url.path();
TQFileInfo fi( path ); // Argh: TQFileInfo is back ;))
return ( fi.exists()? path : TQString() );
*/
return url.path();
}
}
///////////////////////////////////////////////////////////////////////////////
bool URLUtil::isDirectory( const KURL &url )
{
return isDirectory( url.path() );
}
///////////////////////////////////////////////////////////////////////////////
bool URLUtil::isDirectory( const TQString &absFilePath )
{
return TQDir( absFilePath ).exists();
}
///////////////////////////////////////////////////////////////////////////////
void URLUtil::dump( const KURL::List &urls, const TQString &aMessage )
{
if (!aMessage.isNull())
{
kdDebug(9000) << aMessage << endl;
}
kdDebug(9000) << " List has " << urls.count() << " elements." << endl;
for (size_t i = 0; i<urls.count(); ++i)
{
KURL url = urls[ i ];
// kdDebug(9000) << " * Element = " << url.path() << endl;
}
}
///////////////////////////////////////////////////////////////////////////////
TQStringList URLUtil::toRelativePaths( const TQString &baseDir, const KURL::List &urls)
{
TQStringList paths;
for (size_t i=0; i<urls.count(); ++i)
{
paths << extractPathNameRelative( baseDir, urls[i] );
}
return paths;
}
///////////////////////////////////////////////////////////////////////////////
TQString URLUtil::relativePathToFile( const TQString & dirUrl, const TQString & fileUrl )
{
if (dirUrl.isEmpty() || (dirUrl == "/"))
return fileUrl;
TQStringList dir = TQStringList::split("/", dirUrl, false);
TQStringList file = TQStringList::split("/", fileUrl, false);
TQString resFileName = file.last();
file.remove(file.last());
uint i = 0;
while ( (i < dir.count()) && (i < (file.count())) && (dir[i] == file[i]) )
i++;
TQString result_up;
TQString result_down;
TQString currDir;
TQString currFile;
do
{
i >= dir.count() ? currDir = "" : currDir = dir[i];
i >= file.count() ? currFile = "" : currFile = file[i];
//tqWarning("i = %d, currDir = %s, currFile = %s", i, currDir.latin1(), currFile.latin1());
if (currDir.isEmpty() && currFile.isEmpty())
break;
else if (currDir.isEmpty())
result_down += file[i] + "/";
else if (currFile.isEmpty())
result_up += "../";
else
{
result_down += file[i] + "/";
result_up += "../";
}
i++;
}
while ( (!currDir.isEmpty()) || (!currFile.isEmpty()) );
return result_up + result_down + resFileName;
}
///////////////////////////////////////////////////////////////////////////////
//TODO: remove for KDE4
TQString URLUtil::canonicalPath( const TQString & path )
{
TQDir dir(path);
return dir.canonicalPath();
}
///////////////////////////////////////////////////////////////////////////////
//written by "Dawit A." <adawit@kde.org>
//borrowed from his patch to KShell
TQString URLUtil::envExpand ( const TQString& str )
{
uint len = str.length();
if (len > 1 && str[0] == '$')
{
int pos = str.find ('/');
if (pos < 0)
pos = len;
char* ret = getenv( TQConstString(str.unicode()+1, pos-1).string().local8Bit().data() );
if (ret)
{
TQString expandedStr ( TQFile::decodeName( ret ) );
if (pos < (int)len)
expandedStr += str.mid(pos);
return expandedStr;
}
}
return str;
}