ofToDataPath simplification

libs/openFrameworks/utils/ofFileUtils.cpp

@@ -22,28 +22,31 @@ using std::istream;
 using std::ostream;
 using std::ios;
 
+// FIXME: remove this temporary using
+using std::cout;
+using std::endl;
+
 namespace{
 	bool enableDataPath = true;
 
 	//--------------------------------------------------
-//	MARK: - near future
-//	of::filesystem::path defaultDataPath(){
-	std::string defaultDataPath(){
-	#if defined TARGET_OSX
-		try{
-			return of::filesystem::canonical(ofFilePath::getCurrentExeDir() / of::filesystem::path("../../../data/")).string();
-		}catch(...){
-			return (ofFilePath::getCurrentExeDir() / of::filesystem::path("../../../data/")).string();
-		}
-	#elif defined TARGET_ANDROID
-		return string("sdcard/");
-	#else
-		try{
-            return of::filesystem::canonical(ofFilePath::join(ofFilePath::getCurrentExeDir(),  "data/")).make_preferred().string();
-        }catch(...){
-			return (ofFilePath::getCurrentExeDir() / of::filesystem::path("data/")).string();
-		}
-	#endif
+	of::filesystem::path defaultDataPath(){
+#if defined TARGET_OSX
+
+	// three levels up because is a directory with path App.app/Contents/MacOS/App
+	of::filesystem::path data = ofFilePath::getCurrentExeDir().parent_path().parent_path().parent_path() / "data";
+	if (!of::filesystem::is_directory(data)) {
+		// bundle data folder inside app
+		// one level up : MacOS/../Resources/data
+		data = ofFilePath::getCurrentExeDir().parent_path() / "Resources/data";
+	}
+	return data;
+
+#elif defined TARGET_ANDROID
+	return { "sdcard/" };
+#else
+	return (ofFilePath::getCurrentExeDir() / "data");
+#endif
 	}
 
 	//--------------------------------------------------
@@ -55,14 +58,16 @@ namespace{
 	//--------------------------------------------------
 	of::filesystem::path & dataPathRoot(){
 		static auto * dataPathRoot = new of::filesystem::path(defaultDataPath());
+		// This is the most important change in the way OF handles paths.
+		of::filesystem::current_path(*dataPathRoot);
 		return *dataPathRoot;
 	}
 }
 
 namespace of{
 	namespace priv{
 		void initfileutils(){
-			defaultWorkingDirectory() = of::filesystem::absolute(of::filesystem::current_path());
+			defaultWorkingDirectory() = dataPathRoot();
 		}
 	}
 }
@@ -559,7 +564,7 @@ bool ofFile::openStream(Mode _mode, bool _binary){
 //------------------------------------------------------------------------------------------------------------
 bool ofFile::open(const of::filesystem::path & _path, Mode _mode, bool binary){
 	close();
-	myFile = ofToDataPath(_path);
+	myFile = ofToDataPath(_path, true);
 	return openStream(_mode, binary);
 }
 
@@ -1166,14 +1171,13 @@ ofDirectory::ofDirectory(const of::filesystem::path & path){
 
 //------------------------------------------------------------------------------------------------------------
 void ofDirectory::open(const of::filesystem::path & path){
-	originalDirectory = ofFilePath::getPathForDirectory(path.string());
 	files.clear();
-	myDir = of::filesystem::path(ofToDataPath(originalDirectory));
+	myDir = of::filesystem::path(ofToDataPath(path)).lexically_normal();
 }
 
 //------------------------------------------------------------------------------------------------------------
 void ofDirectory::openFromCWD(const of::filesystem::path & path){
-	originalDirectory = ofFilePath::getPathForDirectory(path.string());
+	originalDirectory = ofFilePath::getPathForDirectory(path);
 	files.clear();
 	myDir = of::filesystem::path(originalDirectory);
 }
@@ -1186,7 +1190,7 @@ void ofDirectory::close(){
 //------------------------------------------------------------------------------------------------------------
 bool ofDirectory::create(bool recursive){
 
-	if(!myDir.string().empty()){
+	if(!myDir.empty()){
 		try{
 			if(recursive){
 				of::filesystem::create_directories(myDir);
@@ -1341,11 +1345,24 @@ bool ofDirectory::copyTo(const of::filesystem::path& _path, bool bRelativeToData
 
 //------------------------------------------------------------------------------------------------------------
 bool ofDirectory::moveTo(const of::filesystem::path& path, bool bRelativeToData, bool overwrite){
-	if(copyTo(path,bRelativeToData,overwrite)){
-		return remove(true);
+	if (of::filesystem::exists(path)) {
+		cout << "exists " << path << endl;
+		if (overwrite) {
+			of::filesystem::remove_all(path);
+			cout << "remove all " << path << endl;
+		}
+		else {
+			return false;
+		}
 	}
-
-	return false;
+	const of::filesystem::path & old = myDir;
+	try {
+		of::filesystem::rename(old, path);
+	} catch (of::filesystem::filesystem_error const& ex) {
+		return false;
+	}
+	myDir = path;
+	return true;
 }
 
 //------------------------------------------------------------------------------------------------------------
@@ -1679,8 +1696,7 @@ string ofFilePath::addLeadingSlash(const of::filesystem::path& _path){
 }
 
 //------------------------------------------------------------------------------------------------------------
-//	MARK: - near future
-//of::filesystem::path ofFilePath::addTrailingSlash(const of::filesystem::path & _path){
+//	MARK: - Remove this function after FS transition
 std::string ofFilePath::addTrailingSlash(const of::filesystem::path & _path){
 #if OF_USING_STD_FS && !OF_USE_EXPERIMENTAL_FS
 	if(_path.string().empty()) return "";
@@ -1776,7 +1792,9 @@ std::string ofFilePath::getEnclosingDirectory(const of::filesystem::path & _file
 	if(bRelativeToData){
 		fp = ofToDataPath(fp);
 	}
-	return addTrailingSlash(fp.parent_path());
+
+//	return addTrailingSlash(fp.parent_path());
+	return fp.parent_path().string();
 }
 
 //------------------------------------------------------------------------------------------------------------
@@ -1854,10 +1872,9 @@ string ofFilePath::getCurrentExePath(){
 }
 
 //------------------------------------------------------------------------------------------------------------
-// MARK: - near future
-//of::filesystem::path ofFilePath::getCurrentExeDir(){
-std::string ofFilePath::getCurrentExeDir(){
-	return ofFilePath::getEnclosingDirectory(ofFilePath::getCurrentExePath(), false);
+of::filesystem::path ofFilePath::getCurrentExeDir(){
+	auto exePath = of::filesystem::path(getCurrentExePath());
+	return exePath.parent_path();
 }
 
 //------------------------------------------------------------------------------------------------------------
@@ -1927,97 +1944,23 @@ void ofSetDataPathRoot(const of::filesystem::path& newRoot){
 }
 
 //--------------------------------------------------
-// MARK: - near future
 //of::filesystem::path ofToDataPath(const of::filesystem::path & path, bool makeAbsolute){
 std::string ofToDataPath(const of::filesystem::path & path, bool makeAbsolute){
-	if (makeAbsolute && path.is_absolute()) {
-//		return path;
-		return path.string();
-	}
-
-	if (!enableDataPath) {
-//		return path;
+	if (path.is_absolute()) {
 		return path.string();
-	}
-
-	bool hasTrailingSlash = !path.empty() && path.generic_string().back()=='/';
-
-	// if our Current Working Directory has changed (e.g. file open dialog)
-#ifdef TARGET_WIN32
-	if (defaultWorkingDirectory() != of::filesystem::current_path()) {
-		// change our cwd back to where it was on app load
-		bool ret = ofRestoreWorkingDirectoryToDefault();
-		if(!ret){
-			ofLogWarning("ofUtils") << "ofToDataPath: error while trying to change back to default working directory " << defaultWorkingDirectory();
-		}
-	}
-#endif
-
-	// this could be performed here, or wherever we might think we accidentally change the cwd, e.g. after file dialogs on windows
-	const auto & dataPath = dataPathRoot();
-	of::filesystem::path inputPath(path);
-	of::filesystem::path outputPath;
-
-	// if path is already absolute, just return it
-	if (inputPath.is_absolute()) {
-		try {
-			auto outpath = of::filesystem::canonical(inputPath).make_preferred();
-			if(of::filesystem::is_directory(outpath) && hasTrailingSlash){
-				return ofFilePath::addTrailingSlash(outpath);
-			}else{
-				return outpath.string();
-				// return outpath;
-			}
-		}
-		catch (...) {
-			return inputPath.string();
-			// return inputPath;
-		}
-	}
-
-	// here we check whether path already refers to the data folder by looking for common elements
-	// if the path begins with the full contents of dataPathRoot then the data path has already been added
-	// we compare inputPath.toString() rather that the input var path to ensure common formatting against dataPath.toString()
-	auto dirDataPath = dataPath;
-	// also, we strip the trailing slash from dataPath since `path` may be input as a file formatted path even if it is a folder (i.e. missing trailing slash)
-	dirDataPath = ofFilePath::addTrailingSlash(dataPath);
-
-	auto relativeDirDataPath = ofFilePath::makeRelative(of::filesystem::current_path(), dataPath);
-	relativeDirDataPath = ofFilePath::addTrailingSlash(relativeDirDataPath);
-
-	// FIXME: this can be simplified without using string conversion
-	// if (inputPath.string().find(dirDataPath.string()) != 0 && inputPath.string().find(relativeDirDataPath.string())!=0) {
-	if (inputPath.string().find(dirDataPath.string()) != 0 && inputPath.string().find(relativeDirDataPath)!=0) {
-		// inputPath doesn't contain data path already, so we build the output path as the inputPath relative to the dataPath
-		if(makeAbsolute){
-			outputPath = dirDataPath / inputPath;
-		}else{
-			outputPath = relativeDirDataPath / inputPath;
-		}
 	} else {
-		// inputPath already contains data path, so no need to change
-		outputPath = inputPath;
+		return (dataPathRoot() / path).string();
 	}
 
-	// finally, if we do want an absolute path and we don't already have one
-	if(makeAbsolute){
-		// then we return the absolute form of the path
-		try {
-			auto outpath = of::filesystem::canonical(of::filesystem::absolute(outputPath)).make_preferred();
-			if(of::filesystem::is_directory(outpath) && hasTrailingSlash){
-				return ofFilePath::addTrailingSlash(outpath);
-			}else{
-//				return outpath;
-				return outpath.string();
-			}
-		}
-		catch (std::exception &) {
-		   return of::filesystem::absolute(outputPath).string();
-			// return of::filesystem::absolute(outputPath);
-		}
-	}else{
-		// or output the relative path
-//		return outputPath;
-		return outputPath.string();
-	}
+//// if our Current Working Directory has changed (e.g. file open dialog)
+//#ifdef TARGET_WIN32
+//	if (defaultWorkingDirectory() != of::filesystem::current_path()) {
+//		// change our cwd back to where it was on app load
+//		bool ret = ofRestoreWorkingDirectoryToDefault();
+//		if(!ret){
+//			ofLogWarning("ofUtils") << "ofToDataPath: error while trying to change back to default working directory " << defaultWorkingDirectory();
+//		}
+//	}
+//#endif
+
 }

libs/openFrameworks/utils/ofFileUtils.h

@@ -315,8 +315,6 @@ class ofFilePath{
 	///
 	/// \param path directory path
 	/// \returns path + slash
-//	MARK: - near future
-//	static of::filesystem::path addTrailingSlash(const of::filesystem::path& path);
 	static std::string addTrailingSlash(const of::filesystem::path& path);
 
 	/// Remove a path's trailing slash (if found),
@@ -438,9 +436,7 @@ class ofFilePath{
 	/// Mac: the Contents/MacOS folder within the application's .app bundle
 	///
 	/// \returns current executable directory
-//	MARK: - near future
-//	static of::filesystem::path getCurrentExeDir();
-	static std::string getCurrentExeDir();
+	static of::filesystem::path getCurrentExeDir();
 
 	/// Get the absolute path to the user's home directory.
 	///

tests/utils/fileUtils/bin/data/.gitkeep

@@ -0,0 +1 @@
+

tests/utils/fileUtils/src/main.cpp

@@ -120,6 +120,8 @@ class ofApp: public ofxUnitTestsApp{
 			ofxTest(ofDirectory("d1").canExecute(),"ofDirectory::canExecute");
 		}
 
+//		std::exit(0);
+
 		ofDirectory("noreaddir").create();
 		ofDirectory("noreaddir").setWriteable(false);
 		ofxTest(ofDirectory("noreaddir").canRead(),"ofDirectory::canRead readonly");
@@ -139,6 +141,9 @@ class ofApp: public ofxUnitTestsApp{
 		ofxTest(ofFile("d5/f1").isFile(),"ofDirectory::moveTo f1 exists");
 		ofxTest(ofFile("d5/d3/f2").isFile(),"ofDirectory::moveTo f2 exists");
 
+
+		std::exit(0);
+
 		ofxTest(ofDirectory("d5").renameTo("d4"),"ofDirectory::renameTo");
 		ofxTest(ofDirectory("d4").isDirectory(),"ofDirectory::renameTo dir exists");
 		ofxTest(ofDirectory("d4/d3").isDirectory(),"ofDirectory::renameTo recursive dir exists");
@@ -208,13 +213,16 @@ class ofApp: public ofxUnitTestsApp{
         ofLogNotice() << "tests #4299";
         ofxTestEq(of::filesystem::path(ofFilePath::getCurrentWorkingDirectory()), initial_cwd, "ofFilePath::getCurrentWorkingDirectory()");
 		if(ofGetTargetPlatform()==OF_TARGET_OSX){
-			ofxTestEq(ofToDataPath("",false),"../../../data/","ofToDataPath relative");
+			ofxTestEq(ofToDataPath("",false),"../../../data","ofToDataPath relative");
 		}else if(ofGetTargetPlatform()==OF_TARGET_WINVS || ofGetTargetPlatform()==OF_TARGET_MINGW){
-			ofxTestEq(ofToDataPath("",false),"data\\","ofToDataPath relative");
+			ofxTestEq(ofToDataPath("",false),"data","ofToDataPath relative");
 		}else{
-			ofxTestEq(ofToDataPath("",false),"data/","ofToDataPath relative");
+			ofxTestEq(ofToDataPath("",false),"data","ofToDataPath relative");
 		}
 
+		std::exit(0);
+
+
 
         //========================================================================
         ofLogNotice() << "";

tests/utils/xml/bin/data/.gitkeep

@@ -0,0 +1 @@
+