def DeletePycFiles(self): """ Tries to delete all pyc files from _projectPath, _rootFolders and thirdPartyFolders. However, __init__.pyc files are not removed. """ # determine list of folders to search for pyc files folderList = [] if self.context: folderList.extend(self.context.GetThirdPartyFolders()) folderList.extend(self.context.GetRootFolders()) # remove pyc files while len(folderList) > 0: newFolders = [] for folder in folderList: pycFiles = [ csnUtility.NormalizePath(x) for x in glob.glob("%s/*.pyc" % folder) ] for pycFile in pycFiles: if not os.path.basename(pycFile) == "__init__.pyc": os.remove(pycFile) newFolders.extend([ csnUtility.NormalizePath(os.path.dirname(x)) for x in glob.glob("%s/*/__init__.py" % folder) ]) folderList = list(newFolders)
def ResolvePathsOfFilesToInstall(self, _skipCVS=1): """ This function replaces relative paths and wildcards in self.filesToInstall with absolute paths without wildcards. Any folder is replaced by a complete list of the files in that folder. _skipCVS - If true, folders called CVS and .svn are automatically skipped. """ excludedFolderList = ("CVS", ".svn") for project in self.project.GetProjects(_recursive=1, _includeSelf=True): project.installManager.filesToInstallResolved = dict() for mode in ("Debug", "Release"): filesToInstall = dict() for location in project.installManager.filesToInstall[ mode].keys(): for dllPattern in project.installManager.filesToInstall[ mode][location]: for tpfolder in self.project.context.GetThirdPartyBuildFolders( ): tpfolder += "/" + self.project.context.GetCompiler( ).GetThirdPartySubFolder() path = csnUtility.NormalizePath(dllPattern) if not os.path.isabs(path): path = "%s/%s" % (tpfolder, path) for file in glob.glob(path): if (os.path.basename(file) in excludedFolderList ) and _skipCVS and os.path.isdir(file): continue if os.path.isdir(file): for folderFile in GlobDirectoryWalker.Walker( file, ["*"], excludedFolderList): if not os.path.isdir(folderFile): normalizedLocation = location + "/" + csnUtility.RemovePrefixFromPath( os.path.dirname(folderFile), file) normalizedLocation = csnUtility.NormalizePath( normalizedLocation) if not filesToInstall.has_key( normalizedLocation): filesToInstall[ normalizedLocation] = [] filesToInstall[ normalizedLocation].append( csnUtility.NormalizePath( folderFile)) else: normalizedLocation = csnUtility.NormalizePath( location) if not filesToInstall.has_key( normalizedLocation): filesToInstall[normalizedLocation] = [] filesToInstall[normalizedLocation].append( csnUtility.NormalizePath(file)) project.installManager.filesToInstallResolved[ mode] = filesToInstall
def testNormalizePath(self): """ csnUtilityTests: test NormalizePath function. """ refString = "c:/hallo" self.assertEqual(csnUtility.NormalizePath(""), ".") self.assertEqual(csnUtility.NormalizePath("."), ".") testString1 = "c:/hallo" self.assertEqual(csnUtility.NormalizePath(testString1), refString) testString2 = "c:\\hallo" self.assertEqual(csnUtility.NormalizePath(testString2), refString)
def FindAdditionalRootFolders(self): ''' Look for folders with the rootFolder.csnake file. ''' result = [] folder = csnUtility.NormalizePath( os.path.dirname(self.context.GetCsnakeFile())) previousFolder = "" while folder != previousFolder: if os.path.exists( "%s/rootFolder.csnake" % folder) and not folder in self.context.GetRootFolders(): result.append(folder) previousFolder = folder folder = csnUtility.NormalizePath(os.path.split(folder)[0]) return result
def Do(self, _project): # create folder if it does not exist if not os.path.exists(_project.context.GetKdevelopProjectFolder()): os.makedirs(_project.context.GetKdevelopProjectFolder()) kdevelopProjectFolder = csnUtility.NormalizePath( _project.context.GetKdevelopProjectFolder()) if not os.path.exists(self.__GetKDevelopProjectFilename(_project)): return # Postprocess "*.kdevelop.filelist" file (KDevelop filelist) f = open(self.__GetFilelistFilename(_project), 'w') for project in _project.dependenciesManager.ProjectsToUse(): for source in project.GetSources(): fileListItem = csnUtility.RemovePrefixFromPath( source, kdevelopProjectFolder) fileListItem = csnUtility.NormalizePath(fileListItem) f.write(fileListItem + "/n") f.close() csnUtility.ReplaceDestinationFileIfDifferent( self.__GetFilelistFilename(_project), self.__GetFilelistFilename(_project, kdevelopProjectFolder)) # Postprocess "*.kdevelop" file (KDevelop project) f = open(self.__GetKDevelopProjectFilename(_project), 'r') kdevelopProjectText = f.read() f.close() searchText = "<projectdirectory>%s" % _project.GetBuildFolder() replaceText = "<projectdirectory>%s" % kdevelopProjectFolder kdevelopProjectText = kdevelopProjectText.replace( searchText, replaceText) searchText = "<filelistdirectory>%s" % _project.GetBuildFolder() replaceText = "<filelistdirectory>%s" % kdevelopProjectFolder kdevelopProjectText = kdevelopProjectText.replace( searchText, replaceText) if csnUtility.FileToString( self.__GetKDevelopProjectFilename( _project, kdevelopProjectFolder)) != kdevelopProjectText: f = open( self.__GetKDevelopProjectFilename(_project, kdevelopProjectFolder), 'w') f.write(kdevelopProjectText) f.close()
def __init__(self, name, type, sourceRootFolder=None, categories=None, context=None): # name self.name = name # type: dll, exe, tp self.type = type # source root folder if sourceRootFolder is None: sourceRootFolder = csnUtility.NormalizePath( os.path.dirname(FindFilename(1))) # categories: ~name self.categories = categories if self.categories is None: self.categories = [] # context self.context = context # managers self.pathsManager = csnProjectPaths.Manager(self, sourceRootFolder) self.dependenciesManager = csnDependencies.Manager(self) self.installManager = csnInstall.Manager(self)
def CilabModuleProject(_name, _type, _sourceRootFolder=None): if _sourceRootFolder is None: filename = csnProject.FindFilename(1) dirname = os.path.dirname(filename) _sourceRootFolder = csnUtility.NormalizePath(dirname, _correctCase=False) return StandardModuleProject(_name=_name, _type=_type, _sourceRootFolder=_sourceRootFolder)
def __init__(self, _name, _type, _sourceRootFolder=None, _categories=None, _context=None): """ _type -- Type of the project, should be \"executable\", \"library\", \"dll\" or \"third party\". _name -- Name of the project, e.g. \"SampleApp\". _sourceRootFolder -- Folder used for locating source files for this project. If None, then the folder name is derived from the call stack. For example, if this class' constructor is called in a file d:/users/me/csnMyProject.py, then d:/users/me will be set as the source root folder. """ if _sourceRootFolder is None: _sourceRootFolder = csnUtility.NormalizePath( os.path.dirname(FindFilename(1))) VeryGenericProject.__init__(self, _name, _type, _sourceRootFolder, _categories, _context) # TODO: Remove this code as soon as possible. This process should be done exclusively in the subclass for third parties. self.thirdPartyIndex = -1 count = 0 for folder in self.context.GetThirdPartyFolders(): if csnUtility.IsSameFileOrDirectory( folder, os.path.dirname(_sourceRootFolder)): self.thirdPartyIndex = count break count += 1 if self.thirdPartyIndex < 0 and self.type == "third party": raise Exception( "Could not find any thirdparty folder for this project.") self.rules = dict() self.customCommands = [] self.__compileManager = csnCompile.Manager(self) self.__compileManagerUpdates = list() self.installSubFolder = "" self.testsManager = csnTests.Manager(self) self.properties = [] self.__postCMakeTasks = [] self.listCmakeInsertBeforeTarget = list() self.listCmakeInsertAfterTarget = list() self.listCmakeInsertBeginning = list() for flag in globalCurrentContext.GetCompiler().GetCompileFlags(): self.__compileManager.private.definitions.append(flag) # Function called before "ADD_LIBARRY" self.CMakeInsertBeforeTarget = new.instancemethod( SetCMakeInsertBeforeTarget, self) # Function called after "ADD_LIBARRY" self.CMakeInsertAfterTarget = new.instancemethod( SetCMakeInsertAfterTarget, self) # Function called at the beginning of the CMakeList self.CMakeInsertBeginning = new.instancemethod(SetCMakeInsertBeginning, self)
def GimiasPluginProject(_name, _sourceRootFolder=None): """ This class is used to build a plugin coming from the CilabApps/Plugins folder. Use AddWidgetModules to add widget modules to the plugin. """ if _sourceRootFolder is None: _sourceRootFolder = csnUtility.NormalizePath( os.path.dirname(csnProject.FindFilename(1))) pluginName = "GIMIAS%s" % _name project = csnProject.Project(_name, _type="dll", _sourceRootFolder=_sourceRootFolder, _categories=[pluginName]) project.applicationsProject = None project.installSubFolder = "plugins/%s/lib" % _name project.AddIncludeFolders(["."]) project.AddWidgetModules = new.instancemethod( _AddWidgetModulesMemberFunction, project) project.context.SetSuperSubCategory("Plugins", pluginName) # Windows debug installFolder = "%s/debug" % project.installSubFolder project.installManager.AddFilesToInstall(project.Glob("plugin.xml"), installFolder, _debugOnly=1, _WIN32=1) installFolder = installFolder + "/Filters/" project.installManager.AddFilesToInstall(project.Glob("Filters/*.xml"), installFolder, _debugOnly=1, _WIN32=1) # Windows release installFolder = "%s/release" % project.installSubFolder project.installManager.AddFilesToInstall(project.Glob("plugin.xml"), installFolder, _releaseOnly=1, _WIN32=1) installFolder = installFolder + "/Filters/" project.installManager.AddFilesToInstall(project.Glob("Filters/*.xml"), installFolder, _releaseOnly=1, _WIN32=1) # Linux project.installManager.AddFilesToInstall(project.Glob("plugin.xml"), project.installSubFolder, _NOT_WIN32=1) installFolder = project.installSubFolder + "/Filters" project.installManager.AddFilesToInstall(project.Glob("Filters/*.xml"), installFolder, _NOT_WIN32=1) return project
def StandardModuleProject(_name, _type, _sourceRootFolder=None): if _sourceRootFolder is None: _sourceRootFolder = csnUtility.NormalizePath( os.path.dirname(csnProject.FindFilename(1))) project = csnProject.Project(_name, _type, _sourceRootFolder) project.applicationsProject = None project.AddLibraryModules = new.instancemethod( _AddLibraryModulesMemberFunction, project) project.AddApplications = new.instancemethod( _AddApplicationsMemberFunction, project) return project
def AddTests(self, listOfTests, _cxxTestProject, _enableWxWidgets=0, _dependencies=None, _pch=""): """ _cxxTestProject -- May be the cxxTest project instance, or a function returning a cxxTest project instance. listOfTests -- List of source files containing cxx test classes. """ cxxTestProject = csnProject.ToProject(_cxxTestProject) if self.testProject is None: self.__CreateTestProject(cxxTestProject, _enableWxWidgets) for test in listOfTests: absPathToTest = self.testProject.pathsManager.PrependRootFolderToRelativePath( test) self.testProject.AddSources([absPathToTest], _checkExists=0) wxRunnerArg = None if _enableWxWidgets: wxRunnerArg = "--template \"%s\"" % (csnUtility.GetRootOfCSnake() + "/resources/wxRunner.tpl") else: wxRunnerArg = "--template \"%s\"" % ( csnUtility.GetRootOfCSnake() + "/resources/%s" % self.testProject.context.GetTestRunnerTemplate()) pythonScript = "%s/CxxTest/cxxtestgen.py" % cxxTestProject.GetSourceRootFolder( ) command = "\"%s\" \"%s\" %s --have-eh --error-printer -o \"%s\" " % ( csnUtility.NormalizePath(self.testProject.context.GetPythonPath()), pythonScript, wxRunnerArg, self.testRunnerSourceFile) depends = [] for source in self.testProject.GetSources(): if os.path.splitext(source)[1] in (".h", ".hpp"): depends.append('"%s"' % source) command += ' "%s"' % source self.testProject.AddRule("Create test runner", self.testRunnerSourceFile, command, depends) self.testProject.AddCMakeInsertAfterTarget(CustomCMakeLinesTest, self.testProject) self.holdingProject.AddCMakeInsertBeginning( CustomCMakeLinesTestHoldingProject, self.holdingProject) self.testProject.AddLibraries(["DelayImp"], _WIN32=1) if not _dependencies is None: self.testProject.AddProjects(_dependencies) if (_pch != ""): self.testProject.SetPrecompiledHeader(_pch)
def CreateThirdPartyProject(self, name, sourceRootFolder = None): """ Creates a new third party project (project that has its source in one of the third party source folders and that is compiled using a custom "CMakeLists.txt" file rather than CSnake files. The CSnake project returned by this function can then be used to point dependent projects to the config- and use-file of this third party project, so other projects are able to use the libraries. """ if sourceRootFolder is None: filename = csnProject.FindFilename(1) dirname = os.path.dirname(filename) sourceRootFolder = csnUtility.NormalizePath(dirname, _correctCase = False) project = ThirdPartyProject(name, csnProject.globalCurrentContext, sourceRootFolder) return self.__thirdPartyProjectConstructor(project, self.__version)
def __init__(self, _name, _type, _sourceRootFolder=None, _categories=None): if _sourceRootFolder is None: filename = csnProject.FindFilename(1) dirname = os.path.dirname(filename) _sourceRootFolder = csnUtility.NormalizePath(dirname, _correctCase=False) GenericProject.__init__(self, _name=_name, _type=_type, _sourceRootFolder=_sourceRootFolder, _categories=_categories, _context=csnProject.globalCurrentContext) self.applicationsProject = None
def CreateStandardModuleProject(self, name, projectType, sourceRootFolder = None, categories = None, showInProjectTree = False): """ Creates a compiled project (see "CreateCompiledProject") with the additional modules "AddApplications" and "AddLibraryModules". """ if sourceRootFolder is None: filename = csnProject.FindFilename(1) dirname = os.path.dirname(filename) sourceRootFolder = csnUtility.NormalizePath(dirname, _correctCase = False) if categories: showInProjectTree = True project = StandardModuleProject(name, projectType, sourceRootFolder, [name] if showInProjectTree else None) if categories: superCategory = " / ".join(categories) project.context.SetSuperSubCategory(superCategory, name) return self.__standardModuleProjectConstructor(project, self.__version)
def __FindPath(self, _path): """ Tries to locate _path as an absolute path or as a path relative to self.sourceRootFolder. Returns an absolute path, containing only forward slashes. Throws IOError if path was not found. """ path = os.path.normpath(_path) if not os.path.isabs(path): path = os.path.abspath("%s/%s" % (self.project.GetSourceRootFolder(), path)) if not os.path.exists(path): raise IOError, "Path file not found %s (tried %s)" % (_path, path) path = csnUtility.NormalizePath(path) return path
def __init__(self, name, context, sourceRootFolder=None): if sourceRootFolder is None: sourceRootFolder = csnUtility.NormalizePath( os.path.dirname(FindFilename(1))) VeryGenericProject.__init__(self, name, "third party", sourceRootFolder, None, context) # Get the thirdPartyBuildFolder index self.thirdPartyIndex = -1 count = 0 for folder in self.context.GetThirdPartyFolders(): if csnUtility.IsSameFileOrDirectory( folder, os.path.dirname(sourceRootFolder)): self.thirdPartyIndex = count break count += 1 if self.thirdPartyIndex < 0: raise Exception( "Could not find any thirdparty folder for this project.")
def CommandLinePlugin(_name, _holderProject=None): """ Create a command line plugin project. """ _sourceRootFolder = csnUtility.NormalizePath( os.path.dirname(csnProject.FindFilename(1))) # command line lib projectLibName = "%sLib" % _name projectLib = csnProject.Project(projectLibName, "dll", _sourceRootFolder) #project = CilabModuleProject(projectName, "dll", _sourceRootFolder) projectLib.AddDefinitions(["-Dmain=ModuleEntryPoint"], _private=1) projectLib.installSubFolder = "commandLinePlugins" projectLib.CMakeInsertBeforeTarget = new.instancemethod( CreateCMakeCLPPre, projectLib) projectLib.CMakeInsertAfterTarget = new.instancemethod( CreateCMakeCLPPost, projectLib) # command line executable projectAppName = _name projectApp = csnBuild.Project(projectAppName, "executable", _sourceRootFolder) projectApp.AddProjects([projectLib]) projectApp.installSubFolder = "commandLinePlugins" # wrapper for shared libraries wrapperSourceFile = None for thirdParty in csnProject.globalCurrentContext.GetThirdPartyFolders(): currentWrapperSourceFile = u'%s/SLICER/Slicer3/Applications/CLI/Templates/CommandLineSharedLibraryWrapper.cxx' % thirdParty if os.path.isfile(currentWrapperSourceFile): wrapperSourceFile = currentWrapperSourceFile if wrapperSourceFile is None: raise Exception( "Could not find Slicer template in your thirdParty folders.") projectApp.AddSources([wrapperSourceFile]) # force the creation of the application project projectLib.AddProjects([projectApp], _dependency=0) if not (_holderProject is None): _holderProject.AddProjects([projectLib]) return projectLib
def CreateCompiledProject(self, name, projectType, sourceRootFolder = None, categories = None, showInProjectTree = False): """ Creates a compiled project. name - Project name projectType - Type of the project: Can be "executable", "library" or "dll". sourceRootFolder - The main folder of the library (many subsequent operations take subdirectory parameters relative to this directory); if None, the location of the CSnake file calling this function is used. categories - Hierarchy of categories for the project tree of the "Select Projects" tab showInProjectTree - If True, the project will be shown in the project tree of the "Select Projects" tab (if there is a connection between the selected instance and this project) and can be deselected (if the selected instance doesn't depend on this project). If False, the project is always compiled, if there is a connection between the selected instance and this project. """ if sourceRootFolder is None: filename = csnProject.FindFilename(1) dirname = os.path.dirname(filename) sourceRootFolder = csnUtility.NormalizePath(dirname, _correctCase = False) if categories: showInProjectTree = True project = GenericProject(name, projectType, sourceRootFolder, [name] if showInProjectTree else None, _context=csnProject.globalCurrentContext) if categories: superCategory = " / ".join(categories) project.context.SetSuperSubCategory(superCategory, name) return self.__genericProjectConstructor(project, self.__version)
def Executable(_name, _sourceRootFolder=None, _categories=None): if _sourceRootFolder is None: _sourceRootFolder = csnUtility.NormalizePath( os.path.dirname(FindFilename(1))) return Project(_name, "executable", _sourceRootFolder, _categories)
def Project(_name, _type, _sourceRootFolder=None, _categories=None): if _sourceRootFolder is None: _sourceRootFolder = csnUtility.NormalizePath( os.path.dirname(FindFilename(1))) return globalCurrentContext.CreateProject(_name, _type, _sourceRootFolder, _categories)
import csnProject import csnUtility import os.path import inspect import csnVisualStudio2003 import csnVisualStudio2005 import csnVisualStudio2008 if csnBuild.version < 2.22: import csnVisualStudio2008x64 # Used to configure gimias def CreateGIMIAS(): gimias = csnCilab.CilabModuleProject("Gimias", "executable") gimias.AddSources(gimias.Glob("GUI/MainApp/src/*.h"), _checkExists=1) gimias.AddSources(gimias.Glob("GUI/MainApp/src/*.cxx"), _checkExists=1) gimias.SetPrecompiledHeader("GUI/MainApp/gmMainAppPCH.h") gimias.AddIncludeFolders([gimias.GetBuildFolder()]) return gimias commandLinePlugins = csnProject.Project( "CommandLinePlugins", "container", csnUtility.NormalizePath(os.path.dirname(inspect.stack()[1][1])), _categories=["GIMIASCommandLinePlugins"])
def FindSourceRootFolder(self, level = 0): """ Find the folder containing the CSnake file that is (directly or indirectly) calling this function. level - see function FindScriptFilename """ return csnUtility.NormalizePath(os.path.dirname(csnProject.FindFilename(1+level)))
def GetControlValue(self): controlValue = self.control.GetValue() if controlValue != "" and FilenameLabel() in self.labels: controlValue = csnUtility.NormalizePath(controlValue) return controlValue