--- a/sbsv2/raptor/python/generic_path.py Wed Oct 28 14:39:48 2009 +0000
+++ b/sbsv2/raptor/python/generic_path.py Mon Nov 16 09:46:46 2009 +0000
@@ -1,315 +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
+#
+# 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