Merge lp:~mandel/ubuntuone-client/legal_linux_chars into lp:ubuntuone-client

[Manuel de la Peña]

Allow to send the events to the state machine that do not have the utf8 special chars.

Allow to send the events to the state machine that do not have the utf8 special chars. To test do:

python C:\Python27\Scripts\u1trial tests\platform\windows\test_os_helper.py

[Natalia Bidart (nataliabidart)]

review: Approve

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'tests/platform/windows/test_os_helper.py'
--- tests/platform/windows/test_os_helper.py	2011-06-20 16:50:13 +0000
+++ tests/platform/windows/test_os_helper.py	2011-06-21 10:21:47 +0000
@@ -20,8 +20,9 @@
 import errno
 
 from ubuntuone.platform.windows.os_helper import (
-    _remove_windows_illegal_chars,
+    remove_windows_illegal_chars,
     access,
+    is_illegal_path,
     listdir,
     make_dir,
     open_file,
@@ -29,6 +30,7 @@
     remove_dir,
     remove_file,
     rename,
+    remove_utf8_chars,
     set_no_rights,
     set_file_readwrite,
     stat_path,
@@ -46,7 +48,7 @@
         self.basedir = self.mktemp('test_root')
         self.testfile = os.path.join(self.basedir, "test_file")
         self.testfile += ''.join(WINDOWS_ILLEGAL_CHARS_MAP)
-        self.fd = open(_remove_windows_illegal_chars(self.testfile), 'w')
+        self.fd = open(remove_windows_illegal_chars(self.testfile), 'w')
 
     def test_path_file_exist_yes(self):
         """Test that the file exists."""
@@ -55,7 +57,7 @@
     def test_path_file_exist_no(self):
         """Test that the file doesn't exist."""
         self.fd.close()
-        os.remove(_remove_windows_illegal_chars(self.testfile))
+        os.remove(remove_windows_illegal_chars(self.testfile))
         self.assertFalse(path_exists(self.testfile))
 
     def test_path_dir_exist_yes(self):
@@ -65,7 +67,7 @@
     def test_path_dir_exist_no(self):
         """Test that the dir doesn't exist."""
         self.fd.close()
-        os.remove(_remove_windows_illegal_chars(self.testfile))
+        os.remove(remove_windows_illegal_chars(self.testfile))
         self.assertFalse(path_exists(os.path.join(self.basedir, 'nodir')))
 
     def test_remove_file(self):
@@ -73,7 +75,7 @@
         self.fd.close()
         remove_file(self.testfile)
         self.assertFalse(os.path.exists(
-                         _remove_windows_illegal_chars(self.testfile)))
+                         remove_windows_illegal_chars(self.testfile)))
 
     def test_remove_dir(self):
         """Test the remove dir."""
@@ -143,23 +145,23 @@
         """Rename a file."""
         testfile1 = os.path.join(self.basedir, 'testfile1>')
         testfile2 = os.path.join(self.basedir, 'testfile2<')
-        open(_remove_windows_illegal_chars(testfile1), 'w').close()
+        open(remove_windows_illegal_chars(testfile1), 'w').close()
         rename(testfile1, testfile2)
         self.assertFalse(os.path.exists(
-                         _remove_windows_illegal_chars(testfile1)))
+                         remove_windows_illegal_chars(testfile1)))
         self.assertTrue(os.path.exists(
-                         _remove_windows_illegal_chars(testfile2)))
+                         remove_windows_illegal_chars(testfile2)))
 
     def test_rename_dir(self):
         """Rename a dir."""
         testdir1 = os.path.join(self.basedir, 'testdir1>')
         testdir2 = os.path.join(self.basedir, 'testdir2<')
-        os.mkdir(_remove_windows_illegal_chars(testdir1))
+        os.mkdir(remove_windows_illegal_chars(testdir1))
         rename(testdir1, testdir2)
         self.assertFalse(os.path.exists(
-                         _remove_windows_illegal_chars(testdir1)))
+                         remove_windows_illegal_chars(testdir1)))
         self.assertTrue(os.path.exists(
-                         _remove_windows_illegal_chars(testdir2)))
+                         remove_windows_illegal_chars(testdir2)))
 
     def test_listdir(self):
         """Return a list of the files in a dir."""
@@ -177,7 +179,7 @@
 
     def test_access_ro(self):
         """Test access on a file with read only permission."""
-        fixed_path = _remove_windows_illegal_chars(self.testfile)
+        fixed_path = remove_windows_illegal_chars(self.testfile)
         os.chmod(fixed_path, 0o444)
         self.assertTrue(access(self.testfile))
         os.chmod(fixed_path, 0o664)
@@ -190,7 +192,7 @@
 
     def test_stat_normal(self):
         """Test on a normal file."""
-        self.assertEqual(os.stat(_remove_windows_illegal_chars(self.testfile)),
+        self.assertEqual(os.stat(remove_windows_illegal_chars(self.testfile)),
                          stat_path(self.testfile))
 
     def test_stat_no_path(self):
@@ -207,7 +209,7 @@
     def test_path_exists_file_no(self):
         """The file is not there."""
         self.fd.close()
-        os.remove(_remove_windows_illegal_chars(self.testfile))
+        os.remove(remove_windows_illegal_chars(self.testfile))
         self.assertFalse(path_exists(self.testfile))
 
     def test_path_exists_dir_yes(self):
@@ -217,4 +219,9 @@
     def test_path_exists_dir_no(self):
         """The dir is not there."""
         self.fd.close()
-        self.assertFalse(path_exists(os.path.join(self.basedir, 'subdir')))
 \ No newline at end of file
+        self.assertFalse(path_exists(os.path.join(self.basedir, 'subdir')))
+
+    def test_remove_utf8_chars(self):
+        """Test that the path does not have utf chars."""
+        path = remove_utf8_chars(remove_windows_illegal_chars(self.testfile))
+        self.assertFalse(is_illegal_path(path))
 \ No newline at end of file
 
=== modified file 'ubuntuone/platform/windows/filesystem_notifications.py'
--- ubuntuone/platform/windows/filesystem_notifications.py	2011-06-17 09:25:12 +0000
+++ ubuntuone/platform/windows/filesystem_notifications.py	2011-06-21 10:21:47 +0000
@@ -67,7 +67,8 @@
     GeneralINotifyProcessor)
 from ubuntuone.platform.windows.os_helper import (
     LONG_PATH_PREFIX,
-    listdir)
+    listdir,
+    remove_utf8_chars)
 from ubuntuone import logger
 from ubuntuone.platform.windows.os_helper import longpath
 # our logging level
@@ -275,7 +276,8 @@
             # add the diff events to the q so that the can be processed no
             # matter the speed.
             for action, file in results:
-                full_filename = os.path.join(self._path, file)
+                full_filename = remove_utf8_chars(os.path.join(self._path,
+                                                  file))
                 self._raw_events_queue.put((full_filename, action))
                 self.log.debug('Added %s to raw events queue.',
                     (full_filename, action))
 
=== modified file 'ubuntuone/platform/windows/os_helper.py'
--- ubuntuone/platform/windows/os_helper.py	2011-06-20 23:59:33 +0000
+++ ubuntuone/platform/windows/os_helper.py	2011-06-21 10:21:47 +0000
@@ -126,23 +126,22 @@
 def _check_winerror_123(exception, cb, path, *args, **kwargs):
     """Checks if an exception is a 123 error and executes the cb."""
     if getattr(exception, "winerror", None) == 123 :
-        path = _remove_windows_illegal_chars(path)
+        path = remove_windows_illegal_chars(path)
         return cb(path, *args, **kwargs)
     else:
         raise exception
 
 
-def _is_illegal_path(path):
-    """Return if the path is illegal in the system."""
+def _contains_chars(path, chars):
+    """Returns if one of the chars is in the path."""
     if LONG_PATH_PREFIX in path:
         path = path.replace(LONG_PATH_PREFIX, '')
-    return any(c in WINDOWS_ILLEGAL_CHARS_MAP
-               for c in os.path.splitdrive(path)[1])
-
-
-def _remove_windows_illegal_chars(path):
+    return any(c in chars for c in os.path.splitdrive(path)[1])
+
+
+def _modify_chars(path, should_apply, chars):
     """Remove illegal chars and return a valid windows path."""
-    if not _is_illegal_path(path):
+    if not should_apply(path):
         return path
     prefix = False
     # do not split the path if you have a long path prefix since the
@@ -156,7 +155,7 @@
     result = []
     for partial in partial_paths:
         # ensure that the illegal chars are not there
-        for illegal_char, replacement in WINDOWS_ILLEGAL_CHARS_MAP.iteritems():
+        for illegal_char, replacement in chars.iteritems():
             partial = partial.replace(illegal_char, replacement)
         result.append(partial)
     result = os.path.join(*result)
@@ -166,6 +165,27 @@
         result = LONG_PATH_PREFIX + result
     return unicode(result)
 
+
+def is_illegal_path(path):
+    """Return if the path is illegal in the system."""
+    return _contains_chars(path, WINDOWS_ILLEGAL_CHARS_MAP)
+
+
+def remove_windows_illegal_chars(path):
+    """Remove illegal chars and return a valid windows path."""
+    return _modify_chars(path, is_illegal_path, WINDOWS_ILLEGAL_CHARS_MAP)
+
+
+def is_modified_path(path):
+    """Return if the path contains the special utf8 chars."""
+    return _contains_chars(path, LINUX_ILLEGAL_CHARS_MAP)
+
+
+def remove_utf8_chars(path):
+    """Remove the special chars from the path and use the basic ones."""
+    return _modify_chars(path, is_modified_path, LINUX_ILLEGAL_CHARS_MAP)
+
+
 def _set_file_attributes(path, groups):
     """Set file attributes using the wind32api."""
     security_descriptor = None
@@ -176,7 +196,7 @@
                          'for path %s', path, groups)
         #check if the issue was due to an illegal path
         if getattr(e, "winerror", None) == 123:
-            path = _remove_windows_illegal_chars(path)
+            path = remove_windows_illegal_chars(path)
             return _set_file_attributes(path, groups)
         else:
             raise
@@ -358,8 +378,8 @@
 @longpath(paths_indexes=[0])
 def path_exists(path):
     """Return if the path exists."""
-    if _is_illegal_path(path):
-        path = _remove_windows_illegal_chars(path)
+    if is_illegal_path(path):
+        path = remove_windows_illegal_chars(path)
     return os.path.exists(path)
 
 
@@ -409,8 +429,8 @@
                          '%s to %s', path_from, path_to)
         #check if the issue was due to an illegal path
         if getattr(e, "winerror", None) == 123:
-            path_from = _remove_windows_illegal_chars(path_from)
-            path_to = _remove_windows_illegal_chars(path_to)
+            path_from = remove_windows_illegal_chars(path_from)
+            path_to = remove_windows_illegal_chars(path_to)
             try:
                 MoveFileExW(
                     path_from, path_to,
@@ -489,8 +509,8 @@
     # since that will only occur in the case where the user created the path
     # for a file to be readable it has to be readable either by the user or
     # by the everyone group
-    if _is_illegal_path(path):
-        path = _remove_windows_illegal_chars(path)
+    if is_illegal_path(path):
+        path = remove_windows_illegal_chars(path)
     if not os.path.exists(path):
         return False
     security_descriptor = GetFileSecurity(path, DACL_SECURITY_INFORMATION)
@@ -588,7 +608,7 @@
     """Return an abspath."""
     # TODO: do we really need to do this, are the tests broken?
     path = path.replace('/', '\\')
-    abs = os.path.abspath(_remove_windows_illegal_chars(path))
+    abs = os.path.abspath(remove_windows_illegal_chars(path))
     if not LONG_PATH_PREFIX in abs:
         abs = LONG_PATH_PREFIX + abs
     return abs
 \ No newline at end of file