Warning fixes.

[wxWidgets.git] / wxPython / samples / ide / activegrid / util / fileutils.py

diff --git a/wxPython/samples/ide/activegrid/util/fileutils.py b/wxPython/samples/ide/activegrid/util/fileutils.py
index 7d334c7dde9f043c05f2b7934622b705fdc8641e..2a75997aeab4b4e184018483b5439379209cfdf3 100644 (file)
--- a/wxPython/samples/ide/activegrid/util/fileutils.py
+++ b/wxPython/samples/ide/activegrid/util/fileutils.py
@@ -10,18 +10,45 @@
 # License:      wxWindows License
 #----------------------------------------------------------------------------
 
 # License:      wxWindows License
 #----------------------------------------------------------------------------
 

+import logging
+import copy

 import os
 import os

+import shutil
+import sys
+import zipfile
+
+import activegrid.util.aglogging as aglogging
+import activegrid.util.sysutils as sysutils
+from activegrid.util.lang import *
+
+global fileutilsLogger
+fileutilsLogger = logging.getLogger("activegrid.util.fileutils")
+# FATAL : No logging
+# ERROR : No logging
+# WARN  : No logging
+# INFO  : No logging
+# DEBUG : debugging
+aglogging.setLevelFatal(fileutilsLogger)
+#logging.getLogger().addHandler(logging.StreamHandler(sys.stderr))
+
+
+def makeDirsForFile(filename):
+    d = os.path.dirname(filename)
+    if (not os.path.exists(d)):
+        os.makedirs(d)

 
 def createFile(filename, mode='w'):
     f = None
 
 def createFile(filename, mode='w'):
     f = None

-    try:
-        f = file(filename, mode)
-    except:
-        os.makedirs(filename[:filename.rindex(os.sep)])
-        f = file(filename, mode)
+    if (not os.path.exists(filename)):
+        makeDirsForFile(filename)
+    f = file(filename, mode)

     return f
 
 def compareFiles(file1, file2):
     return f
 
 def compareFiles(file1, file2):

+##    result = filecmp.cmp(file1, file2)
+##    if result:
+##        return 0
+##    return -1

     file1.seek(0)
     file2.seek(0)
     while True:
     file1.seek(0)
     file2.seek(0)
     while True:


@@ -35,5 +62,287 @@ def compareFiles(file1, file2):
         elif (len(line2) == 0):
             return -1
         elif (line1 != line2):
         elif (len(line2) == 0):
             return -1
         elif (line1 != line2):

-            return -1
+            line1 = line1.replace(" ", "")
+            line2 = line2.replace(" ", "")
+            if (line1 != line2):
+                len1 = len(line1)
+                len2 = len(line2)
+                if ((abs(len1 - len2) == 1) and (len1 > 0) and (len2 > 0) 
+                    and (line1[-1] == "\n") and (line2[-1] == "\n")):
+                    if (len1 > len2):
+                        longer = line1
+                        shorter = line2
+                    else:
+                        shorter = line1
+                        longer = line2
+                    if ((longer[-2] == "\r") and (longer[:-2] == shorter[:-1])):
+                        continue
+                    if ((longer[-2:] == shorter[-2:]) and (longer[-3] == "\r") and (longer[:-3] == shorter[:-2])):
+                        continue
+                return -1
+
+def expandVars(value):
+    """Syntax: ${myvar,default="default value"}"""
+    import activegrid.runtime as runtime
+    sx = value.find("${")
+    if (sx >= 0):
+        result = asString(value[:sx])
+        endx = value.find("}")
+        if (endx > 1):
+            defaultValue = None
+            defsx = value.find(",default=\"")
+            if ((defsx > sx) and (defsx < endx)):
+                varname = value[sx+2:defsx]
+                if (value[endx-1] == '"'):
+                    defaultValue = value[defsx+10:endx-1]
+            if (defaultValue == None):
+                varname = value[sx+2:endx]
+            if (varname == "AG_SYSTEM"):
+                varval = runtime.appInfo.getSystemDir()
+            elif (varname == "AG_SYSTEM_STATIC"):
+                varval = runtime.appInfo.getSystemStaticDir()
+            elif (varname == "AG_APP"):
+                varval = runtime.appInfo.getAppDir()
+            elif (varname == "AG_APP_STATIC"):
+                varval = runtime.appInfo.getAppStaticDir()
+            else:
+                varval = os.getenv(varname)
+            if ((varval == None) and (defaultValue != None)):
+                varval = defaultValue
+            if (varval == None):
+                result += value[sx:endx+1]
+            else:
+                result += varval
+            return result + expandVars(value[endx+1:])
+    return value
+
+def toPHPpath(path, otherdir=None):
+    return convertSourcePath(path, "php", otherdir=otherdir)
+                    
+def toPythonpath(path, otherdir=None):
+    return convertSourcePath(path, "python", otherdir=otherdir)
+                    
+def toUnixPath(path):
+    if (path != None and os.sep != '/'):
+        path = path.replace(os.sep, '/')
+    return path
+
+def convertSourcePath(path, to, otherdir=None):
+    fromname = "python"
+    if (to == "python"):
+        fromname = "php"
+    pythonNode = os.sep + fromname + os.sep
+    ix = path.find(pythonNode)
+    if (ix < 0):
+        ix = path.find(fromname) - 1
+        if ((ix < 0) or (len(path) <= ix+7)
+            or (path[ix] not in ("\\", "/")) or (path[ix+7]  not in ("\\", "/"))):
+            raise Exception("Not in a %s source tree.  Cannot create file name for %s." % (fromname, path))
+        if (otherdir == None):
+            return path[:ix+1] + to + path[ix+7:]
+        else:
+            return otherdir + path[ix+7:]
+    if (otherdir == None):
+        return path.replace(pythonNode, os.sep + to + os.sep)
+    else:
+        return otherdir + path[ix+7:]
+
+
+def visit(directory, files, extension):
+    testdirs = os.listdir(directory)
+    for thing in testdirs:
+        fullpath = os.path.join(directory, thing)
+        if (os.path.isdir(fullpath)):
+            visit(fullpath, files, extension)
+        elif thing.endswith(extension):
+            fullname = os.path.normpath(os.path.join(directory, thing))
+            if not fullname in files:
+                files.append(fullname)
+ 
+def listFilesByExtensionInPath(path=[], extension='.lyt'):
+    #Collect input and output arguments into one bunch
+    retval = []
+    for directory in path:
+        visit(directory, retval, extension)
+    return retval
+
+def getFileLastModificationTime(fileName):
+    return os.path.getmtime(fileName)
+
+def findFileLocation(location, fileName):
+    i = fileName.rfind(os.sep)
+    if i > 0:
+        fileName = fileName[:i]
+    while location[0:2] == '..' and location[2:3] == os.sep:
+        location = location[3:]
+        i = fileName.rfind(os.sep)
+        fileName = fileName[:i]
+    absPath = fileName + os.sep + location
+    return absPath
+
+def getAllExistingFiles(files, basepath=None, forceForwardSlashes=False):
+    """For each file in files, if it exists, adds its absolute path to the rtn list. If file is a dir, calls this function recursively on all child files in the dir.
+    If basepath is set, and if the file being processed is relative to basedir, adds that relative path to rtn list instead of the abs path.
+    Is this is Windows, and forceForwardSlashes is True, make sure returned paths only have forward slashes."""
+    if isinstance(files, basestring):
+        files = [files]
+    rtn = []
+    for file in files:
+        if os.path.exists(file): 
+            if os.path.isfile(file):
+                if basepath and hasAncestorDir(file, basepath):
+                    rtn.append(getRelativePath(file, basepath))
+                else:
+                    rtn.append(os.path.abspath(str(file)))
+            elif os.path.isdir(file):
+                dircontent = [os.path.join(file, f) for f in os.listdir(file)]
+                rtn.extend(getAllExistingFiles(dircontent, basepath))
+                
+    if forceForwardSlashes and sysutils.isWindows():
+        newRtn = []
+        for f in rtn:
+            newRtn.append(f.replace("\\", "/"))
+        rtn = newRtn
+        
+    return rtn
+
+def hasAncestorDir(file, parent):
+    """Returns true if file has the dir 'parent' as some parent in its path."""
+    return getRelativePath(file, parent) != None
+
+def getRelativePath(file, basedir):
+    """Returns relative path from 'basedir' to 'file', assuming 'file' lives beneath 'basedir'. If it doesn't, returns None."""
+    file = os.path.abspath(file)
+    parent = os.path.abspath(basedir)

 
 

+    if file == parent:
+        return None
+
+    if file.startswith(parent):
+        return file[len(parent)+1:]
+    
+    return None
+
+def isEmptyDir(dir):
+    if not os.path.isdir(dir):
+        return False
+    return len(os.listdir(dir)) == 0
+
+ifDefPy()
+def zip(zipfilepath, basedir=None, files=None):
+    """Zip all files in files and save zip as zipfilepath. If files is None, zip all files in basedir. For all files to be zipped, if they are relative to basedir, include the relative path in the archive."""
+    
+    if not files and not basedir:
+        raise AssertionError("Either 'basedir' or 'files' must be set")
+            
+    if not files:
+        aglogging.debug(fileutilsLogger,\
+                        "Looking for files to zip in %s" % basedir)
+        files = getAllExistingFiles(basedir)
+    else:
+        # removes files that don't exist and gets abs for each
+        files = getAllExistingFiles(files) 
+
+    if len(files) == 0:
+        aglogging.debug(fileutilsLogger, "No files to zip, nothing to do")
+        return
+    
+    z = zipfile.ZipFile(zipfilepath, mode="w", compression=zipfile.ZIP_DEFLATED)
+
+    try:
+        for file in files:
+            arcname = None
+            if basedir:
+                arcname = getRelativePath(file, basedir)
+            if not arcname:
+                arcname = file
+                aglogging.debug(fileutilsLogger,\
+                                "%s: adding %s with arcname %s" %\
+                                (zipfilepath, file, arcname))
+            z.write(file, arcname)
+    finally:
+        z.close()
+endIfDef()        
+
+
+ifDefPy()
+def unzip(zipfilepath, extractdir):
+    """Unzip zipfilepath into extractdir."""
+    z = zipfile.ZipFile(zipfilepath, mode="r")
+    for info in z.infolist():
+        filename = os.path.join(extractdir, info.filename)
+        try:
+            dir = os.path.dirname(filename)
+            aglogging.debug(fileutilsLogger, "Creating dir %s" % dir)
+            os.makedirs(dir) # do we have to worry about permissions?
+        except:
+            pass
+        if os.path.isdir(filename):
+            continue
+        aglogging.debug(fileutilsLogger,\
+                       ("Writing arcfile %s to %s" % (info.filename, filename)))
+        f = open(filename, "w")
+        f.write(z.read(info.filename))
+        f.close()
+endIfDef()
+
+ifDefPy()
+def copyFile(src, dest):
+    """Copies file src to dest. Creates directories in 'dest' path if necessary."""
+    destdir = os.path.dirname(dest)
+    if not os.path.exists(destdir):
+        os.makedirs(destdir)
+    shutil.copy(src, dest)
+endIfDef()
+
+ifDefPy()
+def copyDir(src, dest):
+    """Copies dir 'src' into dir 'dest'. Creates 'dest' if it does not exist."""
+    shutil.copytree(src, dest)
+endIfDef()
+
+ifDefPy()
+def remove(file):
+    if not os.path.exists(file):
+        return
+    if os.path.isfile(file):
+        os.remove(file)
+    elif os.path.isdir(file):
+        shutil.rmtree(file)
+endIfDef()
+
+ifDefPy()
+import warnings
+warnings.filterwarnings("ignore", message="tmpnam is a potential security risk to your program")
+def getTmpFile():
+    return os.tmpnam()
+endIfDef()
+
+ifDefPy()
+#@accepts str, dict, str, str, boolean
+def replaceToken(infilepath, tokens={}, outfilepath=None, delim="@@",\
+                 useEnv=False):
+    """Replaces tokens of form 'delim'<tokenname>'delim' in file at 'infilepath', using values in dict 'tokens'. If 'outfilepath' is set, writes output to 'outfilepath', if not set, overwrites original file. If 'useEnv' is True, adds os.environ to 'tokens'. This makes it possible to define an env var FOO=BLAH, and have @@FOO@@ be replaced with BLAH, without explicitly passing FOO=BLAH in 'tokens'. Note that entries in 'tokens' take precedence over entries in os.environ."""
+
+    if useEnv:
+        for key, val in os.environ.items():
+            # passed in tokens take precedence
+            if not tokens.has_key(key):
+                tokens[key] = val        
+    
+    f = open(infilepath, "r")
+    try:
+        content = f.read()
+    finally:
+        if f: f.close()
+
+    for token, value in tokens.items():
+        content = content.replace("%s%s%s" % (delim, token , delim), str(value))
+
+    if not outfilepath: outfilepath = infilepath
+    f = open(outfilepath, "w")
+    try:
+        f.write(content)
+    finally:
+        if f: f.close()
+endIfDef()