Fix sync to always respect walkpath order.

Specifically, we could run into issues where a parent doesn't exist yet when copying files.

```
julia> index = Dict(Tuple(setdiff(p.segments, src.segments)) => p for p in walkpath(src))
Dict{Tuple{String,Vararg{String,N} where N},PosixPath} with 5 entries:
  ("folder1", "folder2")          => /var/folders/h_/vkjv56410m7f75g9ffp46mf80000gp/T/tmpcJbzPa/folder1/folder2
  ("folder1",)                    => /var/folders/h_/vkjv56410m7f75g9ffp46mf80000gp/T/tmpcJbzPa/folder1
  ("folder1", "file2")            => /var/folders/h_/vkjv56410m7f75g9ffp46mf80000gp/T/tmpcJbzPa/folder1/file2
  ("folder1", "folder2", "file3") => /var/folders/h_/vkjv56410m7f75g9ffp46mf80000gp/T/tmpcJbzPa/folder1/folder2/file3
  ("file1",)                      => /var/folders/h_/vkjv56410m7f75g9ffp46mf80000gp/T/tmpcJbzPa/file1
```

This would try and copy folder1/folder2 before creating folder1 because of how the segments were hashed.
An OrderedDict would also resolve this, but we don't want to depend on external dependencies in FilePathsBase.

Author: rofinn

src/path.jl

@@ -522,15 +522,19 @@ exist at the source will be removed.
 """
 function sync(src::AbstractPath, dst::AbstractPath; delete=false)
     # Create an index of all of the source files
-    index = Dict(Tuple(setdiff(p.segments, src.segments)) => p for p in walkpath(src))
+    src_paths = collect(walkpath(src))
+    index = Dict(
+        Tuple(setdiff(p.segments, src.segments)) => i for (i, p) in enumerate(src_paths)
+    )
 
     if exists(dst)
         for p in walkpath(dst)
             k = Tuple(setdiff(p.segments, dst.segments))
 
             if haskey(index, k)
-                if modified(index[k]) > modified(p)
-                    cp(index[k], p; force=true)
+                src_path = src_paths[index[k]]
+                if modified(src_path) > modified(p)
+                    cp(src_path, p; force=true)
                 end
 
                 delete!(index, k)
@@ -540,8 +544,12 @@ function sync(src::AbstractPath, dst::AbstractPath; delete=false)
         end
 
         # Finally, copy over files that don't exist at the destination
-        for (seg, p) in index
-            cp(p, Path(dst, tuple(dst.segments..., seg...)); force=true)
+        # But we need to iterate through it in a way that respects the original
+        # walkpath order otherwise we may end up trying to copy a file before its parents.
+        index_pairs = collect(pairs(index))
+        index_pairs = index_pairs[sortperm(last.(index_pairs))]
+        for (seg, i) in index_pairs
+            cp(src_paths[i], Path(dst, tuple(dst.segments..., seg...)); force=true)
         end
     else
         cp(src, dst)

src/test.jl

@@ -640,6 +640,29 @@ module TestPaths
             sync(ps.foo, ps.qux / "foo"; delete=true)
             @test !exists(ps.qux / "foo" / "test.txt")
             rm(ps.qux / "foo"; recursive=true)
+
+            # Test a condtion where the index could reorder the walkpath order.
+            tmp_src = ps.root / "tmp-src"
+            mkdir(tmp_src)
+            src_file = tmp_src / "file1"
+            write(src_file, "Hello World!")
+
+            src_folder = tmp_src / "folder1"
+            mkdir(src_folder)
+            src_folder_file = src_folder / "file2"
+            write(src_folder_file, "") # empty file
+
+            src_folder2 = src_folder / "folder2"  # nested folders
+            mkdir(src_folder2)
+            src_folder2_file = src_folder2 / "file3"
+            write(src_folder2_file, "Test")
+
+            tmp_dst = ps.root / "tmp_dst"
+            mkdir(tmp_dst)
+            sync(tmp_src, tmp_dst)
+            @test exists(tmp_dst / "folder1" / "folder2" / "file3")
+            rm(tmp_src; recursive=true)
+            rm(tmp_dst; recursive=true)
         end
     end