--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sbsv2/raptor/python/generic_path.py Tue Oct 27 16:36:35 2009 +0000
@@ -0,0 +1,315 @@
+#
+# Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+# All rights reserved.
+# This component and the accompanying materials are made available
+# under the terms of the License "Eclipse Public License v1.0"
+# which accompanies this distribution, and is available
+# at the URL "http://www.eclipse.org/legal/epl-v10.html".
+#
+# Initial Contributors:
+# Nokia Corporation - initial contribution.
+#
+# Contributors:
+#
+# Description:
+# generic_path module
+#
+
+import os
+import sys
+import re
+import types
+
+# are we on windows, and if so what is the current drive letter
+isWin = sys.platform.lower().startswith("win")
+if isWin:
+ drive = re.match('^([A-Za-z]:)',os.getcwd()).group(0)
+
+# regex for "bare" drive letters
+driveRE = re.compile('^[A-Za-z]:$')
+
+# Base class
+
+class Path:
+ """This class represents a file path.
+
+ A generic path object supports operations without needing to know
+ about Windows and Linux differences. The standard str() function can
+ obtain a string version of the path in Local format for use by
+ platform-specific functions (file opening for example).
+
+ We use forward slashes as path separators (even on Windows).
+
+ For example,
+
+ path1 = generic_path.Path("/foo")
+ path2 = generic_path.Path("bar", "bing.bang")
+
+ print str(path1.Append(path2))
+
+ Prints /foo/bar/bing.bang on Linux
+ Prints c:/foo/bar/bing.bang on Windows (if c is the current drive)
+ """
+
+ def __init__(self, *arguments):
+ """construct a path from a list of path elements"""
+
+ if len(arguments) == 0:
+ self.path = ""
+ return
+
+ list = []
+ for i,arg in enumerate(arguments):
+ if isWin:
+ if i == 0:
+ # If the first element starts with \ or / then we will
+ # add the current drive letter to make a fully absolute path
+ if arg.startswith("\\\\"):
+ list.append(arg) # A UNC path - don't mess with it
+ elif arg.startswith("\\") or arg.startswith("/"):
+ list.append(drive + arg)
+ # If the first element is a bare drive then dress it with a \
+ # temporarily otherwise "join" will not work properly.
+ elif driveRE.match(arg):
+ list.append(arg + "\\")
+ # nothing special about the first element
+ else:
+ list.append(arg)
+ else:
+ if arg.startswith("\\\\"):
+ raise ValueError("non-initial path components must not start with \\\\ : %s" % arg)
+ else:
+ list.append(arg)
+ if ";" in arg:
+ raise ValueError("An individual windows Path may not contain ';' : %s" % arg)
+ else:
+ list.append(arg)
+
+ self.path = os.path.join(*list)
+
+ # normalise to avoid nastiness with dots and multiple separators
+ # but do not normalise "" as it will become "."
+ if self.path != "":
+ self.path = os.path.normpath(self.path)
+
+ # always use forward slashes as separators
+ self.path = self.path.replace("\\", "/")
+
+ # remove trailing slashes unless we are just /
+ if self.path != "/":
+ self.path = self.path.rstrip("/")
+
+ def __str__(self):
+ return self.path
+
+ def GetNeutralStr(self):
+ """return the path as a string that could be included in other paths."""
+ return self.path.replace(":","").replace("/","")
+
+ def GetLocalString(self):
+ """return a string in the local file-system format.
+
+ e.g. C:/tmp on Windows or /C/tmp on Linux"""
+ return self.path
+
+ def isAbsolute(self):
+ "test whether this path is absolute or relative"
+ # C: is an absolute directory
+ return (os.path.isabs(self.path) or driveRE.match(self.path))
+
+ def Absolute(self):
+ """return an object for the absolute version of this path.
+
+ Prepends the current working directory to relative paths and
+ the current drive (on Windows) to /something type paths."""
+ # leave C: alone as abspath will stick the cwd on
+ if driveRE.match(self.path):
+ return Path(self.path)
+ else:
+ return Path(os.path.abspath(self.path))
+
+ def Append(self, *arguments):
+ "return an object with path elements added at the end of this path"
+ return Join(*((self,) + arguments))
+
+ def Prepend(self, *arguments):
+ "return an object with path elements added at the start of this path"
+ return Join(*(arguments + (self,)))
+
+ def isDir(self):
+ "test whether this path points to an existing directory"
+ # C: is a directory
+ return (os.path.isdir(self.path) or driveRE.match(self.path))
+
+ def isFile(self):
+ "test whether this path points to an existing file"
+ return os.path.isfile(self.path)
+
+ def Exists(self):
+ "test whether this path exists in the filesystem"
+ if driveRE.match(self.path):
+ return os.path.exists(self.path + "/")
+ else:
+ return os.path.exists(self.path)
+
+ def Dir(self):
+ "return an object for the directory part of this path"
+ if driveRE.match(self.path):
+ return Path(self.path)
+ else:
+ return Path(os.path.dirname(self.path))
+
+ def File(self):
+ "return a string for the file part of this path"
+ return os.path.basename(self.path)
+
+ def Components(self):
+ """return a list of the components of this path."""
+ return self.path.split('/')
+
+ def FindCaseless(self):
+ """Given a path which may not be not correct in terms of case,
+ search the filesystem to find the corresponding, correct path.
+ paths are assumed to be absolute and normalised (which they
+ should be in this class).
+
+ Assumes that the path is more right than wrong, i.e. starts
+ with the full path and tests for existence - then takes the
+ last component off and check for that.
+
+ This will be inefficient if used in cases where the file
+ has a high probability of not existing.
+ """
+
+ if os.path.exists(self.path):
+ return Path(self.path)
+
+ unknown_elements = []
+ tail = self.path
+ head = None
+ while tail != '':
+ if os.path.exists(tail):
+ break
+ else:
+ (tail,head) = os.path.split(tail)
+ #print "(head,tail) = (%s,%s)\n" % (head,tail)
+ unknown_elements.append(head)
+
+ if tail == None:
+ result = ""
+ else:
+ result = tail
+
+ # Now we know the bits that may be wrong so we can search for them
+ unknown_elements.reverse()
+ for item in unknown_elements:
+ possible = os.path.join(result, item)
+ if os.path.exists(possible):
+ result = possible
+ continue # not finished yet - only this element is ok
+
+ # Nope, we really do have to search for this component of the path
+ possible = None
+ if result:
+ for file in os.listdir(result):
+ if file.lower() == item.lower():
+ possible = os.path.join(result,file)
+ break # find first matching name (might not be right)
+ if possible is None:
+ result = ""
+ break # really couldn't find the file
+ result = possible
+
+ if result == "":
+ return None
+
+ return Path(result)
+
+ def From(self,source):
+ """Returns the relative path from 'source' to here."""
+ list1 = source.Absolute().Components()
+ list2 = self.Absolute().Components()
+
+ # on windows if the drives are different
+ # then the relative path is the absolute one.
+ if isWin and list1[0] != list2[0]:
+ return self.Absolute()
+
+ final_list = []
+ for item in list1:
+ if list2 != []:
+ for widget in list2:
+ if item == widget:
+ list2.pop(0)
+ break
+ else:
+ final_list.insert(0, "..")
+ final_list.append(widget)
+ list2.pop(0)
+ break
+ else:
+ final_list.insert(0, "..")
+
+ final_list.extend(list2)
+
+ return Join(*final_list)
+
+ def GetShellPath(self):
+ """Returns correct slashes according to os type as a string
+ """
+ if isWin:
+ if "OSTYPE" in os.environ and os.environ['OSTYPE'] == "cygwin" :
+ return self.path
+
+ return self.path.replace("/", "\\")
+
+ return self.path
+
+
+# Module functions
+
+def Join(*arguments):
+ """Concatenate the given list to make a generic path object.
+
+ This can accept both strings and Path objects, and join
+ them "intelligently" to make a complete path."""
+ list = []
+ for arg in arguments:
+ if isinstance(arg, Path):
+ list.append(arg.path)
+ else:
+ list.append(arg)
+
+ return Path(*list)
+
+def CurrentDir():
+ "return a Path object for the current working directory"
+ return Path(os.getcwd())
+
+def NormalisePathList(aList):
+ """Convert a list of strings into a list of Path objects"""
+ return map(lambda x: Path(x), aList)
+
+def Where(afile):
+ """Return the location of a file 'afile' in the system path.
+
+ On windows, adds .exe onto the filename if it's not there. Returns the first location it found or None if it wasn't found.
+
+ >>> Where("python")
+ "/usr/bin/python"
+ >>> Where("nonexistentfile")
+ None
+ """
+ location = None
+ if sys.platform.startswith("win"):
+ if not afile.lower().endswith(".exe"):
+ afile += ".exe"
+
+ for current_file in [os.path.join(loop_number,afile) for loop_number in
+ os.environ["PATH"].split(os.path.pathsep)]:
+ if os.path.isfile(current_file):
+ location = current_file
+ break
+ return location
+
+# end of generic_path module