move and copy plus docs

Author: willmcgugan

docs/source/guide.rst

@@ -69,7 +69,7 @@ Calling :meth:`fs.base.FS.tree` on a FS object will give you a nice ASCII repres
 Closing Filesystems
 ~~~~~~~~~~~~~~~~~~~
 
-Closing a filesystem may be an alien concept if you are accustomed to using the Python standard library, but FS objects have a ``close`` method (:meth:`fs.base.FS.close`) which will perform any required clean-up actions. For many filesystems (notably :class:`fs.osfs.OSFS`), the close method does very little, but other filesystems may only finalize files or release resources once ``close()`` is called.
+FS objects have a ``close`` method (:meth:`fs.base.FS.close`) which will perform any required clean-up actions. For many filesystems (notably :class:`fs.osfs.OSFS`), the ``close`` method does very little, but other filesystems may only finalize files or release resources once ``close()`` is called.
 
 You can call ``close`` explicitly once you are finished using a filesystem. For example::
 
@@ -166,10 +166,17 @@ Moving and Copying
 
 You can move and copy file contents with :meth:`fs.base.FS.move` and :meth:`fs.base.FS.copy` methods, and the equivalent :meth:`fs.base.FS.movedir` and :meth:`fs.base.FS.copydir` methods which operate on directories rather than files.
 
-These move and copy methods are optimized where possible, and depending on the implementation, they may be more performant than reading and writing open files.
+These move and copy methods are optimized where possible, and depending on the implementation, they may be more performant than reading and writing files.
 
-To move and/or copy files *between* filesystems (as apposed to within the same filesystem), use the :mod:`fs.move` and :mod:`fs.copy` modules. The methods in these modules accept both FS objects and FS URLS, which can make for quite elegant code. For instance, the following will compress the contents of your projects folder::
+To move and/or copy files *between* filesystems (as apposed to within the same filesystem), use the :mod:`fs.move` and :mod:`fs.copy` modules. The methods in these modules accept both FS objects and FS URLS. For instance, the following will compress the contents of your projects folder::
 
     >>> from fs.copy import copy_fs
     >>> copy_fs('~/projects', 'zip://projects.zip')
 
+Which is the equivalent to this, more verbose, code:::
+
+    >>> from fs.copy import copy_fs
+    >>> from fs.osfs import OSFS
+    >>> from fs.zipfs import ZipFS
+    >>> copy_fs(OSFS('~/projects'), ZipFS('projects.zip'))
+

docs/source/path.rst

@@ -3,5 +3,7 @@ fs.path
 
 Work with PyFilesystem paths.
 
+See :ref:`paths` for an explanation of PyFilesystem paths.
+
 .. automodule:: fs.path
     :members:

fs/base.py

@@ -234,18 +234,17 @@ def copydir(self, src_path, dst_path, create=False):
         """
         Copy the contents of ``src_path`` to ``dst_path``.
 
-        :param str src_path: A path to a directory on the filesystem.
-        :param str dst_path: A path to a directory in the filesystem.
-        :param create: If ``True`` then ``src_path`` will be created if
+        :param str src_path: Source directory.
+        :param str dst_path: Destination directory.
+        :param bool reate: If ``True`` then ``src_path`` will be created if
             it doesn't already exist.
-        :type create: bool
-        :raises `fs.errors.DirectoryExists`: If the directory exists,
-            and ``create`` is not True.
+        :raises `fs.errors.ResourceNotFound`: If the destination
+            directory does not exist, and ``create`` is not True.
 
         """
         with self._lock:
-            if create:
-                self.makedirs(dst_path, recreate=True)
+            if not create and not self.exists(dst_path):
+                raise errors.ResourceNotFound(dst_path)
             copy.copy_dir(
                 self,
                 src_path,
@@ -258,7 +257,8 @@ def create(self, path, wipe=False):
         Create an empty file.
 
         :param str path: Path to new file in filesystem.
-        :param bool wipe: If ``True``, truncate file to 0 bytes if it exists.
+        :param bool wipe: If ``True``, truncate file to 0 bytes if it
+            exists.
         :returns: True if file was created, False if it already existed.
         :rtype bool:
 
@@ -682,8 +682,8 @@ def movedir(self, src_path, dst_path, create=False):
 
         """
         with self._lock:
-            if create:
-                self.makedirs(dst_path, recreate=True)
+            if not create and not self.exists(dst_path):
+                raise errors.ResourceNotFound(dst_path)
             move.move_dir(
                 self,
                 src_path,

fs/copy.py

@@ -9,10 +9,6 @@
 from .path import normpath
 
 
-class CopyError(Exception):
-    """An error occurred during copying."""
-
-
 def copy_fs(src_fs, dst_fs):
     """
     Copy the contents of one filesystem to another.
@@ -93,12 +89,16 @@ def copy_dir(src_fs, src_path, dst_fs, dst_path):
         with manage_fs(dst_fs, create=True) as dst_fs:
             with src_fs.lock(), dst_fs.lock():
                 dst_fs.makedir(_dst_path, recreate=True)
-                for dir_path, _dirs, files in walk.walk(src_fs, _src_path):
+                for dir_path, dirs, files in walk.walk(src_fs, _src_path):
                     copy_path = combine(
                         _dst_path,
                         frombase(_src_path, dir_path)
                     )
-                    dst_fs.makedir(copy_path, recreate=True)
+                    for info in dirs:
+                        dst_fs.makedir(
+                            info.make_path(copy_path),
+                            recreate=True
+                        )
                     for info in files:
                         copy_file(
                             src_fs,

fs/move.py

@@ -6,10 +6,6 @@
 from .opener import manage_fs
 
 
-class MoveError(Exception):
-    """An error occurred during move."""
-
-
 def move_fs(src_fs, dst_fs):
     """
     Move the contents of a filesystem to another filesystem.

fs/path.py

@@ -247,7 +247,8 @@ def split(path):
     the last pathname component and 'head' is all preceding components.
 
     :param str path: Path to split
-    :rtype: str
+    :rtype: tuple
+    :returns: tuple of ``(head, tail)``
 
     >>> split("foo/bar")
     ('foo', 'bar')
@@ -269,7 +270,7 @@ def splitext(path):
     last '.' and the extension).
 
     :param path: A path to split
-    :returns: tuple of (path, extension)
+    :returns: tuple of ``(path, extension)``
     :rtype: tuple
 
     >>> splitext('baz.txt')

fs/permissions.py

@@ -130,7 +130,7 @@ def __eq__(self, other):
         if isinstance(other, Permissions):
             names = other.dump()
         else:
-            names = list(other)
+            names = other
         return self.dump() == names
 
     def __ne__(self, other):

tests/test_copy.py

@@ -0,0 +1,37 @@
+from __future__ import unicode_literals
+
+import unittest
+
+import fs.copy
+from fs import open_fs
+
+
+class TestCopy(unittest.TestCase):
+
+    def test_copy_fs(self):
+        src_fs = open_fs('mem://')
+        src_fs.makedirs('foo/bar')
+        src_fs.makedirs('foo/empty')
+        src_fs.touch('test.txt')
+        src_fs.touch('foo/bar/baz.txt')
+
+        dst_fs = open_fs('mem://')
+        fs.copy.copy_fs(src_fs, dst_fs)
+
+        self.assertTrue(dst_fs.isdir('foo/empty'))
+        self.assertTrue(dst_fs.isdir('foo/bar'))
+        self.assertTrue(dst_fs.isfile('test.txt'))
+
+    def test_copy_dir(self):
+        src_fs = open_fs('mem://')
+        src_fs.makedirs('foo/bar')
+        src_fs.makedirs('foo/empty')
+        src_fs.touch('test.txt')
+        src_fs.touch('foo/bar/baz.txt')
+
+        dst_fs = open_fs('mem://')
+        fs.copy.copy_dir(src_fs, '/foo', dst_fs, '/')
+
+        self.assertTrue(dst_fs.isdir('bar'))
+        self.assertTrue(dst_fs.isdir('empty'))
+        self.assertTrue(dst_fs.isfile('bar/baz.txt'))

tests/test_fs.py

@@ -1423,6 +1423,9 @@ def test_copydir(self):
         self.assert_text('foo/bar/foofoo.txt', 'Hello')
         self.assert_isdir('foo/bar/baz/egg')
 
+        with self.assertRaises(errors.ResourceNotFound):
+            self.fs.copydir('foo', 'foofoo')
+
     def test_movedir(self):
         self.fs.makedirs('foo/bar/baz/egg')
         self.fs.settext('foo/bar/foofoo.txt', 'Hello')
@@ -1433,6 +1436,9 @@ def test_movedir(self):
         self.assert_not_exists('foo/bar/foofoo.txt')
         self.assert_not_exists('foo/bar/baz/egg')
 
+        with self.assertRaises(errors.ResourceNotFound):
+            self.fs.movedir('foo', 'foofoo')
+
     def test_tree(self):
         self.fs.makedirs('foo/bar')
         self.fs.create('test.txt')

tests/test_move.py

@@ -0,0 +1,36 @@
+
+from __future__ import unicode_literals
+
+import unittest
+
+import fs.move
+from fs import open_fs
+
+
+class TestMove(unittest.TestCase):
+
+    def test_move_fs(self):
+        src_fs = open_fs('mem://')
+        src_fs.makedirs('foo/bar')
+        src_fs.touch('test.txt')
+        src_fs.touch('foo/bar/baz.txt')
+
+        dst_fs = open_fs('mem://')
+        fs.move.move_fs(src_fs, dst_fs)
+
+        self.assertTrue(dst_fs.isdir('foo/bar'))
+        self.assertTrue(dst_fs.isfile('test.txt'))
+        self.assertTrue(src_fs.isempty('/'))
+
+    def test_copy_dir(self):
+        src_fs = open_fs('mem://')
+        src_fs.makedirs('foo/bar')
+        src_fs.touch('test.txt')
+        src_fs.touch('foo/bar/baz.txt')
+
+        dst_fs = open_fs('mem://')
+        fs.move.move_dir(src_fs, '/foo', dst_fs, '/')
+
+        self.assertTrue(dst_fs.isdir('bar'))
+        self.assertTrue(dst_fs.isfile('bar/baz.txt'))
+        self.assertFalse(src_fs.exists('foo'))