env_paths.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2017 Wayne Stambaugh <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * Copyright (C) 2017 CERN
 * @author Maciej Suminski <[email protected]>
 *
 * 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 3 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, see <https://www.gnu.org/licenses/>.
 */
 
#include <env_paths.h>
#include <project.h>
#include <wx/filename.h>
 
static bool normalizeAbsolutePaths( const wxFileName& aPathA, const wxFileName& aPathB,
                                    wxString* aResultPath )
{
    wxCHECK_MSG( aPathA.IsAbsolute(), false,
                 aPathA.GetPath() + wxS( " is not an absolute path." ) );
    wxCHECK_MSG( aPathB.IsAbsolute(), false,
                 aPathB.GetPath() + wxS( " is not an absolute path." ) );
 
    if( aPathA.GetPath() == aPathB.GetPath() )
        return true;
 
    // Not sure all of volume checks are necessary since wxFileName::GetVolume() returns
    // an empty string if the path has no volume.
    if( ( aPathA.GetDirCount() > aPathB.GetDirCount() )
      || ( aPathA.HasVolume() && !aPathB.HasVolume() )
      || ( !aPathA.HasVolume() && aPathB.HasVolume() )
      || ( ( aPathA.HasVolume() && aPathB.HasVolume() )
         && ( aPathA.GetVolume().CmpNoCase( aPathB.GetVolume() ) != 0 ) ) )
        return false;
 
    wxArrayString aDirs = aPathA.GetDirs();
    wxArrayString bDirs = aPathB.GetDirs();
 
    size_t i = 0;
 
    while( i < aDirs.GetCount() )
    {
        if( aDirs[i] != bDirs[i] )
            return false;
 
        i++;
    }
 
    if( aResultPath )
    {
        while( i < bDirs.GetCount() )
        {
            *aResultPath += bDirs[i] + wxT( "/" );
            i++;
        }
    }
 
    return true;
}
 
 
wxString NormalizePath( const wxFileName& aFilePath, const ENV_VAR_MAP* aEnvVars,
                        const wxString& aProjectPath )
{
    wxFileName envPath;
    wxString   varName;
    wxString   remainingPath;
    wxString   normalizedFullPath;
    int        pathDepth = 0;
 
    if( aEnvVars )
    {
        for( const std::pair<const wxString, ENV_VAR_ITEM>& entry : *aEnvVars )
        {
            // Don't bother normalizing paths that don't exist or the user cannot read.
            if( !wxFileName::DirExists( entry.second.GetValue() )
                    || !wxFileName::IsDirReadable( entry.second.GetValue() ) )
            {
                continue;
            }
 
            envPath.SetPath( entry.second.GetValue() );
 
            wxString tmp;
 
            if( normalizeAbsolutePaths( envPath, aFilePath, &tmp ) )
            {
                int newDepth = envPath.GetDirs().GetCount();
 
                // Only use the variable if it removes more directories than the previous ones
                if( newDepth > pathDepth )
                {
                    pathDepth     = newDepth;
                    varName       = entry.first;
                    remainingPath = tmp;
                }
 
                // @fixme Shouldn't we break here if an environment variable path is found or try
                //        at least try to pick the best match?
            }
        }
    }
 
    if( varName.IsEmpty() && !aProjectPath.IsEmpty()
        && wxFileName( aProjectPath ).IsAbsolute() && wxFileName( aFilePath ).IsAbsolute() )
    {
        envPath.SetPath( aProjectPath );
 
        if( normalizeAbsolutePaths( envPath, aFilePath, &remainingPath ) )
            varName = PROJECT_VAR_NAME;
    }
 
    if( varName.IsEmpty() )
    {
        normalizedFullPath = aFilePath.GetFullPath();
    }
    else
    {
        normalizedFullPath = wxString::Format( "${%s}/", varName );
 
        if( !remainingPath.IsEmpty() )
            normalizedFullPath += remainingPath;
 
        normalizedFullPath += aFilePath.GetFullName();
    }
 
    return normalizedFullPath;
}
 
 
wxString NormalizePath( const wxFileName& aFilePath, const ENV_VAR_MAP* aEnvVars,
                        const PROJECT* aProject )
{
    if( aProject )
        return NormalizePath( aFilePath, aEnvVars, aProject->GetProjectPath() );
    else
        return NormalizePath( aFilePath, aEnvVars, "" );
}
 
 
wxString MakeRelativePath( const wxString& aPath, const wxString& aBaseDir )
{
    wxFileName fn( aPath );
    wxFileName base = wxFileName::DirName( aBaseDir );
 
    if( aBaseDir.IsEmpty() || !fn.IsAbsolute() || !base.IsAbsolute() )
        return aPath;
 
    if( wxFileName::DirName( aPath ).SameAs( base ) )
        return wxS( "." );
 
    if( !fn.MakeRelativeTo( base.GetPath() ) )
        return aPath;
 
    return fn.GetFullPath( wxPATH_UNIX );
}
 
 
wxString NormalizePathForProject( const wxString& aPath, const ENV_VAR_MAP* aEnvVars,
                                  const wxString& aProjectPath, bool aAllowParentDirs )
{
    wxFileName fn( aPath );
 
    if( !fn.IsAbsolute() )
        return aPath;
 
    wxString relPath = MakeRelativePath( aPath, aProjectPath );
 
    if( relPath != aPath && relPath != wxS( ".." ) && !relPath.StartsWith( wxS( "../" ) ) )
        return relPath;
 
    // A "../" path only survives moving the project together with its surroundings
    wxString envPath = NormalizePath( fn, aEnvVars, wxEmptyString );
 
    if( envPath != fn.GetFullPath() || !aAllowParentDirs )
        return envPath;
 
    return relPath;
}
 
 
// Create file path by appending path and file name. This approach allows the filename
// to contain a relative path, whereas wxFileName::SetPath() would replace the
// relative path
static wxString createFilePath( const wxString& aPath, const wxString& aFileName )
{
    wxString path( aPath );
 
    if( !path.EndsWith( wxFileName::GetPathSeparator() ) )
        path.Append( wxFileName::GetPathSeparator() );
 
    return path + aFileName;
}
 
 
wxString ResolveFile( const wxString& aFileName, const ENV_VAR_MAP* aEnvVars,
                      const PROJECT* aProject )
{
    wxFileName full( aFileName );
 
    if( full.IsAbsolute() )
        return full.GetFullPath();
 
    if( aProject )
    {
        wxFileName fn( createFilePath( aProject->GetProjectPath(), aFileName ) );
 
        if( fn.Exists() )
            return fn.GetFullPath();
    }
 
    if( aEnvVars )
    {
        for( const std::pair<const wxString, ENV_VAR_ITEM>& entry : *aEnvVars )
        {
            wxFileName fn( createFilePath( entry.second.GetValue(), aFileName ) );
 
            if( fn.Exists() )
                return fn.GetFullPath();
        }
    }
 
    return wxEmptyString;
}
 
 
bool PathIsInsideProject( const wxString& aFileName, const PROJECT* aProject, wxFileName* aSubPath )
{
    wxFileName fn( aFileName );
    wxFileName prj( aProject->GetProjectPath() );
 
    wxArrayString pdirs = prj.GetDirs();
    wxArrayString fdirs = fn.GetDirs();
 
    if( fdirs.size() < pdirs.size() )
        return false;
 
    for( size_t i = 0; i < pdirs.size(); i++ )
    {
        if( fdirs[i] != pdirs[i] )
            return false;
    }
 
    // Now we know that fn is inside prj
    if( aSubPath )
    {
        aSubPath->Clear();
 
        for( size_t i = pdirs.size(); i < fdirs.size(); i++ )
            aSubPath->AppendDir( fdirs[i] );
    }
 
    return true;
}